เมื่อให้ลูกเต๋าสองรายการสำหรับการต่อสู้ใน Risk โปรแกรมหรือฟังก์ชันของคุณจะต้องแสดงจำนวนกองทหารที่ผู้เล่นแต่ละคนแพ้

พื้นหลัง

^{คุณไม่จำเป็นต้องอ่านสิ่งนี้เพราะมันเป็นเพียงพื้นหลัง ข้ามไปยังหัวข้อย่อย "งาน" เพื่อดำเนินการต่อไปคงที่}

ในเกมแห่งความเสี่ยงผู้เล่นคนหนึ่งสามารถโจมตีผู้เล่นอื่นได้ (ในความเป็นจริงมันเป็นสิ่งจำเป็นที่จะชนะ) ผลลัพธ์ของการต่อสู้จะพิจารณาจากการทอยลูกเต๋า การต่อสู้ทุกครั้งเกิดขึ้นเนื่องจากการต่อเนื่องของการรบย่อยซึ่งผู้เล่นแต่ละคนสามารถแพ้ได้2ชิ้นส่วนของกองทัพ

ในการต่อสู้ย่อยผู้พิทักษ์และผู้โจมตีแต่ละคนทอยลูกเต๋าหลายลูกซึ่งจำนวนอาจแตกต่างกันไปตามสถานการณ์ที่ไม่เกี่ยวข้องกับความท้าทายนี้ ค่าสูงสุดของผู้โจมตีนั้นเทียบกับค่าสูงสุดของผู้พิทักษ์ หากผู้โจมตีเสียชีวิตสูงกว่าผู้พิทักษ์ตายฝ่ายป้องกันเสียหนึ่งชิ้น มิฉะนั้นผู้โจมตีสูญเสียหนึ่งชิ้น

จากนั้นหากผู้เล่นทั้งสองมีอย่างน้อยสองลูกเต๋าลูกเต๋าที่มีมูลค่าสูงสุดอันดับสองของผู้เล่นทั้งสองจะถูกเปรียบเทียบ อีกครั้งถ้าผู้โจมตีตายมากกว่าผู้พิทักษ์ฝ่ายตายผู้พิทักษ์เสียชิ้นเดียว มิฉะนั้นผู้โจมตีสูญเสียหนึ่งชิ้น

(Defender ชนะการผูกหากทั้งผู้พิทักษ์และผู้โจมตีกลิ้ง a 4ผู้โจมตีจะแพ้ชิ้น)

_{ในการต่อสู้ย่อยจากบทความ Wikipedia ลูกเต๋าของผู้โจมตีเป็นสีแดงและลูกเต๋าของผู้พิทักษ์เป็นสีขาว สูงสุดของลูกเต๋าโจมตีเป็นและสูงสุดของการมีกองหลังของ4 3เนื่องจากผู้โจมตีสูงขึ้นผู้พิทักษ์จึงเสียส่วนหนึ่ง อันดับสอง3สำหรับผู้โจมตีและ2ผู้พิทักษ์ เนื่องจากผู้โจมตีสูงขึ้นอีกครั้งผู้พิทักษ์จึงเสียอีกชิ้นหนึ่ง ดังนั้นในการรบย่อยนี้ผู้โจมตีไม่ต้องเสียชิ้นใดเลยและผู้พิทักษ์ก็สูญเสีย2ชิ้นส่วนไป}

โปรดทราบว่าชิ้นส่วนที่สามที่สูงที่สุดจะไม่ถูกเปรียบเทียบ นี่เป็นเพราะผู้พิทักษ์ไม่มีลูกเต๋ามากกว่าสองครั้งในการรบย่อยครั้งเดียวดังนั้นจึงไม่มีการเปรียบเทียบชิ้นที่สามที่สูงที่สุดเท่าที่เคยมีมา

งาน

ให้ลูกเต๋าที่ไม่ได้เรียง (จำนวนเต็มในช่วง 1 ถึง 6 รวม) ของทั้งผู้โจมตีและผู้ปกป้องการรบย่อยของความเสี่ยงในรูปแบบที่สะดวกสบายใด ๆ ส่งออกจำนวนชิ้นส่วนกองทัพที่ผู้เล่นแต่ละคนแพ้ เอาต์พุตอาจอยู่ในรูปแบบที่สะดวกใด ๆ ตราบใดที่มีเอาต์พุตต่างกันเพื่อระบุความเป็นไปได้ทั้งห้า คุณต้องระบุว่าอะไรคือผลลัพธ์ที่แตกต่างกันในคำถามของคุณ

เอาท์พุทจะถูกกำหนดดังนี้เริ่มต้นด้วยและdef=0 ถ้าค่าที่ยิ่งใหญ่ที่สุดของรายการของลูกเต๋าม้วนโจมตีที่มีค่ามากกว่าค่ามากที่สุดของรายการของลูกเต๋าม้วนของกองหลังที่เพิ่มขึ้นแล้วatk=0 มิฉะนั้นการเพิ่มขึ้นdefatk

หากทั้งสองรายการของลูกเต๋าม้วนมีความยาวอย่างน้อย2แล้ว: ถ้าค่าที่สองที่ยิ่งใหญ่ที่สุดของรายการของลูกเต๋าม้วนโจมตีมากกว่าที่สองที่ยิ่งใหญ่ที่สุดมูลค่าของรายการแล้วเพิ่มขึ้นdefและอื่น ๆ atkเพิ่มขึ้น

ท้ายที่สุดโปรแกรมหรือฟังก์ชั่นจะต้องส่งออกตัวระบุที่ไม่ซ้ำกันสำหรับความเป็นไปได้ของผลลัพธ์ 5 รายการต่อไปนี้

  ╔═══╦═══╗
  ║atk║def║
  ╠═══╬═══╣
  ║ 1 ║ 0 ║
  ║ 0 ║ 1 ║
  ║ 2 ║ 0 ║
  ║ 1 ║ 1 ║
  ║ 0 ║ 2 ║
  ╚═══╩═══╝

ตัวอย่าง

กองหลัง: [3, 2] โจมตี: [2, 4, 1] แม็กซ์ของผู้พิทักษ์เป็นและสูงสุดของการโจมตีคือ3 ดังนั้น สองกองหลังที่เป็นและที่สองของการโจมตีคือ ดังนั้น ผลลัพธ์ก็คือ44>3def=122Not(2>2)atk=1[1,1]

กรณีทดสอบ

Defender
Attacker
Output (as [def,atk])
-----
[1]
[1]
[0,1]
-----
[6,6]
[1,1,1]
[0,2]
-----
[1,2]
[5,2,3]
[2,0]
-----
[5]
[3,4]
[0,1]
-----
[4]
[4,5]
[1,0]
-----
[1,3]
[1,2,3]
[1,1]
-----
[4]
[4,5,6]
[1,0]
-----
[4,5]
[6,2]
[1,1]
-----
[5]
[6,1,3]
[1,0]
-----
[5,5]
[4,4,1]
[0,2]
-----
[2,5]
[2,2]
[0,2]
-----
[6,6]
[4,4,3]
[0,2]
-----
[2,1]
[4,3]
[2,0]
-----
[4]
[1,5]
[1,0]
-----
[1]
[5,2]
[1,0]
-----
[6,2]
[4]
[0,1]
-----
[4,2]
[2,5,5]
[2,0]
-----
[2]
[6,6,2]
[1,0]
-----
[6]
[2,6]
[0,1]
-----
[3,1]
[1]
[0,1]
-----
[6,2]
[3,5,2]
[1,1]
-----
[4,2]
[1,1]
[0,2]
-----
[4,3]
[5,4,1]
[2,0]
-----
[5,6]
[1,2]
[0,2]
-----
[3,2]
[4,4]
[2,0]
-----
[2]
[6,3,4]
[1,0]
-----
[1,4]
[6,2,4]
[2,0]
-----
[4,2]
[2,5,4]
[2,0]
-----
[5]
[6,2,1]
[1,0]
-----
[3]
[2,5,4]
[1,0]
-----
[5,4]
[2]
[0,1]
-----
[6,3]
[2,6,5]
[1,1]
-----
[3,1]
[4]
[1,0]
-----
[4]
[6,6,5]
[1,0]
-----
[6,3]
[4,2]
[0,2]
-----
[1,6]
[5,4]
[1,1]
-----
[3,6]
[4,4]
[1,1]
-----
[5,4]
[5,1,1]
[0,2]
-----
[6,3]
[5,4]
[1,1]
-----
[2,6]
[1,2]
[0,2]
-----
[4,2]
[3,5,5]
[2,0]
-----
[1]
[1,2,1]
[1,0]
-----
[4,5]
[1,6]
[1,1]
-----
[1]
[3,5,1]
[1,0]
-----
[6,2]
[6,2]
[0,2]

การใช้งานตัวอย่าง

Python 2 หรือ 3

def risk(atk_rolls,def_rolls):
    # set the rolls in descending order, e.g. [5,3,2]
    atk_rolls = sorted(atk_rolls,reverse = True)
    def_rolls = sorted(def_rolls,reverse = True)
    # minimum length.
    minlen = min(len(atk_rolls),len(def_rolls))
    atk_lost = 0
    def_lost = 0
    # compare the highest-valued rolls
    if atk_rolls[0]>def_rolls[0]:
        def_lost += 1
    else:
        atk_lost += 1
    if minlen == 2:
        # compare the second-highest-valued rolls
        if atk_rolls[1] > def_rolls[1]:
            def_lost += 1
        else:
            atk_lost += 1
    return [def_lost, atk_lost]    

ข้อมูลจำเพาะ

• อินพุตอาจถูกนำมาเป็นรูปแบบใด ๆ ที่เข้ารหัสเฉพาะม้วนของผู้พิทักษ์และม้วนของผู้โจมตี
• เอาต์พุตอาจอยู่ในรูปแบบใด ๆ ที่ให้เอาต์พุตที่ไม่ซ้ำกันสำหรับแต่ละความเป็นไปได้ห้าประการที่กล่าวไว้ข้างต้น
• ม้วนพิทักษ์มีรายการ1หรือจำนวนเต็มในชุด2 [1,2,3,4,5,6]ม้วนโจมตีเป็นรายการ1ที่จะจำนวนเต็มในชุด3[1,2,3,4,5,6]
• เนื่องจากนี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษาจึงชนะ! ไม่ได้ให้คำตอบในภาษากอล์ฟกีดกันคุณจากคำตอบโพสต์ในภาษาอื่น ๆ

ประตู NAND, 237

สร้างด้วยLogisim

อินพุตเป็นไบนารีที่ไม่ได้ลงชื่อ 3 บิตป้อนทางด้านซ้าย เอาต์พุต (2 บิต) อยู่ทางขวา

มันใหญ่เกินไปที่จะพอดีกับหน้าจอและ Logisim ไม่สามารถซูมได้ดังนั้นภาพจึงเป็นสีดำและขาว ขออภัย :(

ใช้งานได้กับทุกกรณีทดสอบ

น่าจะเป็นวิธีที่ดีกว่าในการทำเช่นนี้โดยใช้วงจรหน่วยความจำบางส่วนเพื่อให้สามารถนำชิ้นส่วนขนาดใหญ่กลับมาใช้ซ้ำได้

เจลลี่ ,  12  11 ไบต์

NṢ€>/Ṡḟ-o-S

ลิงก์ monadic ที่ใช้รายการDefender, Attackerม้วน (แต่ละรายการ) คืนค่าจำนวนเต็มระหว่าง-2และ2รวม (การสูญเสียตัวป้องกัน - การสูญเสียของผู้โจมตี):

result : [def, atk]
    -2 : [  0,   2]
    -1 : [  0,   1]
     0 : [  1,   1]
     1 : [  1,   0]
     2 : [  2,   0]

ลองออนไลน์! หรือดูชุดทดสอบ (ซึ่งจับคู่ผลลัพธ์กับรูปแบบ OP)

อย่างไร?

NṢ€>/Ṡḟ-o-S - Link: list [list Def, list Atk]
N           - negate all the rolls
 Ṣ€         - sort €ach of the lists of -1*rolls (max rolls are to the left now)
    /       - reduce by:
   >        -   is greater than?  (when len(Atk) > len(Def) leaves trailing negatives)
     Ṡ      - sign (maps all negatives to -1; zeros and ones of comparison unchanged)
       -    - literal -1
      ḟ     - filter discard (remove the -1s)
         -  - literal -1
        o   - logical or, vectorises (replaces the zeros with minus ones)
          S - sum

เรติน่า , 82 ไบต์

%O^`.
((.)+).*(¶(?<-2>.)+)(?(2)(?!)).*
$1$3
O$`.
$.%`
\d
$*1D
(1+)D1*\1

1+D
A
O`.

ลองออนไลน์! บรรทัดแรกของการป้อนข้อมูลคือลูกเต๋าของผู้โจมตีที่สองคือลูกเต๋าของผู้พิทักษ์ ผลตอบแทน (บนเส้นที่แยกต่างหาก) AA, AD, DD, AหรือDตามความเหมาะสม

Python 2 , 83 75 ไบต์

x=0
k=map(sorted,input())
while all(k):x+=cmp(*map(list.pop,k))or 1
print-x

ลองออนไลน์!

เอาท์พุทคือการสูญเสียกองหลัง - การสูญเสียของผู้โจมตี

MATL , 23 ไบต์

oH2$S1&Y)Y&t1M>t~b,Y&sD

ลองออนไลน์!

ไม่แน่ใจว่าทำไมกองหลังถึงได้รับอนุญาตมากกว่าผู้โจมตี แต่บางทีฉันอาจไม่คุ้นเคยกับความเสี่ยง โปรแกรมหลักเป็นเพียงแค่>t~,sDไบต์อื่น ๆ ทั้งหมดที่มีเพื่อให้ความยาวของอินพุตที่แตกต่างกันกับบิตของการจัดเรียงโยนเข้าอินพุตเป็นผู้โจมตีตามด้วยกองหลังเอาท์พุทคือการสูญเสียของผู้โจมตีตามด้วยการสูญเสียกองหลัง

o    % Convert input to numeric array, padding with zeroes 
H2$S % Sort row-wise (specified to prevent 1v1 sorting)
1&Y) % Split attacker/defender
Y&t  % Logical and to filter out excess dice. Duplicate for 'do twice' later.
1M>  % Get throws again, decide who won
t~   % And the inverse to decide who lost
b,   % Bubble filter to the top. Do twice:
  Y& % Apply filter
  sD % Sum of losses. Display.

JavaScript (SpiderMonkey) , 97 83 78 ไบต์

d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++
return[u,v]}

ลองออนไลน์!

-4 ไบต์และคงที่ด้วย @ovs และ @Craig Ayre
-1 ไบต์ขอบคุณ @Shaggy

แกลบขนาด 10 ไบต์

M#eI¬¤z>Ö>

ลองออนไลน์!

ป้อนข้อมูลเป็นสองรายการแยกกันของม้วนเอาท์พุทเช่นเดียวกับใน op

คำอธิบาย

¤z>Ö> เรียงลำดับแต่ละรายการตามลำดับจากมากไปหาน้อยแล้วบีบอัดรายการนั้นเพื่อเปรียบเทียบองค์ประกอบที่เกี่ยวข้อง (และตัดทอนรายการที่ยาวกว่า)

M#eI¬สร้างรายการ 2 องค์ประกอบ ( e) ที่มีจำนวน ( #) ของค่าความจริง (ผ่านตัวตนI) และค่าเท็จ (ผ่านการปฏิเสธตรรกะ¬)

Perl 5 , 66 + 1 (-a) = 67 ไบต์

@A=sort split/ /,<>;$b+=@A?pop@A>$_?-1:1:0for reverse sort@F;say$b

ลองออนไลน์!

การป้อนข้อมูล:

สองเส้น บรรทัดแรกคือผู้พิทักษ์ (ผู้เล่น 1) รองผู้โจมตี (ผู้เล่น 2) แต่ละม้วนคั่นด้วยช่องว่าง

เอาท์พุท:

แสดงให้เห็นถึงการเปลี่ยนแปลงที่มีประสิทธิภาพในความแข็งแกร่งของกองหลังกับผู้โจมตี

Output Attacker Defender
   2      0        2        Defender wins both
   1      0        1        Defender wins the only roll
   0      1        1        Attacker wins first, defender wins second
  -1      1        0        Attacker wins the only roll
  -2      2        0        Attacker wins both rolls

เยลลี่ 30 ไบต์

0,0‘⁸Ṁ€</¤¦‘⁸ḟ"Ṁ€⁺</¤¦⁸L€Ṃ>1¤¡

ลองออนไลน์!

Veeeeeeeery ungolfed! > _ <

ส่งออกค่าตรงตามในกรณีทดสอบ

R , 46 ไบต์

function(x,y)s(s(y,T)[1:2]>s(x,T)[1:2])
s=sort

ลองออนไลน์!

ทั้งหมดนี้มีสามประเภทและหนึ่งการเปรียบเทียบ ... บวกกับการแยกสององค์ประกอบแรกที่อยู่ตรงกลาง

อินพุตเป็นสองเวกเตอร์ของการทอยลูกเต๋า

เอาต์พุตที่เข้ารหัสดังนี้:

╔═══╦═══╗
║atk║def║
╠═══╬═══╣
║ 1 ║ 0 ║ TRUE
║ 0 ║ 1 ║ FALSE
║ 2 ║ 0 ║ TRUE  TRUE
║ 1 ║ 1 ║ FALSE TRUE
║ 0 ║ 2 ║ FALSE FALSE
╚═══╩═══╝

ใช้งานได้เนื่องจากการแยกใน R ไม่ได้รีไซเคิลอาร์กิวเมนต์ แต่ใส่แผ่นผลลัพธ์ด้วยNAเพื่อไปที่ความยาวที่ร้องขอ