คำถามนี้ได้รับแรงบันดาลใจจากการแข่งขันอย่างต่อเนื่องของ "เกมของนักเลงที่เล่นโดยสุภาพบุรุษ", Rugby World Cupซึ่งเพิ่งผ่านด่านพูลไปแล้ว มี 20 ทีมในการแข่งขันและแบ่งออกเป็น 4 กลุ่มละ 5 ทีม ในช่วงสระว่ายน้ำแต่ละทีมเล่นกับทีมอื่น ๆ ในกลุ่ม (รวม 10 แมตช์ต่อพูล) และทีม 2 อันดับแรกของแต่ละพูลจะเข้าสู่รอบน็อคเอาท์

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

ตัวอย่างเช่นนี่คือตารางสำหรับพูล D ของทัวร์นาเมนต์ในปีนี้:

            Win    Loss    Draw
Canada        0       4       0
France        3       1       0
Ireland       4       0       0
Italy         2       2       0
Romania       1       3       0

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

         Canada  France Ireland   Italy Romania
Canada        -       L       L       L       L
France        W       -       L       W       W
Ireland       W       W       -       W       W
Italy         W       L       L       -       W
Romania       W       L       L       L       -

นี่คือตัวอย่างที่ซับซ้อนมากขึ้น (ตัวละคร):

            Win    Loss    Draw
Canada        3       1       0
France        1       2       1
Ireland       0       3       1
Italy         0       2       2
Romania       4       0       0

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

         Canada  France Ireland   Italy Romania
Canada        -       W       W       W       L
France        L       -       W       D       L
Ireland       L       L       -       D       L
Italy         L       D       D       -       L
Romania       W       W       W       W       -

บางตารางไม่สามารถแก้ไขได้เช่น Pool B ในปีนี้ซึ่งทั้ง 3 ทีมมีผลรวม W / L / D เดียวกัน:

            Win    Loss    Draw
Japan         3       1       0
Samoa         1       3       0
Scotland      3       1       0
South Africa  3       1       0
United States 0       4       0

อย่างไรก็ตามบางตารางที่มีแถวที่ซ้ำกันสามารถแก้ไขได้เช่นนี้ (สมมติ) หนึ่ง:

            Win    Loss    Draw
Japan         4       0       0
Samoa         0       3       1
Scotland      2       2       0
South Africa  0       3       1
United States 3       1       0

อินพุต

โปรแกรมหรือฟังก์ชั่นของคุณควรรับ 15 หมายเลขโดยระบุการชนะแพ้และเสมอกันสำหรับ 5 ทีมแต่ละทีม คุณสามารถใช้ตัวคั่นใด ๆ ที่คุณต้องการป้อนหมายเลขในลำดับหลัก ๆ ของแถวหรือคอลัมน์และยอมรับตัวเลขทั้งทาง stdin หรือส่งผ่านผ่านอาร์เรย์ไปยังฟังก์ชัน

เนื่องจากชนะ + loss + draws = 4 คุณสามารถละเว้นค่าใดค่าหนึ่งและทำงานจากค่าอื่น ๆ หากคุณต้องการหมายความว่าคุณต้องป้อนตัวเลขเพียง 10 ตัวเท่านั้น

คุณไม่จำเป็นต้องใส่ชื่อทีมใด ๆ

ตัวอย่างอินพุต:

3 1 0
1 2 1
0 3 1
0 2 2
4 0 0

เอาท์พุต

เอาต์พุตของโปรแกรมหรือฟังก์ชันของคุณควรอยู่ในรูปแบบของตารางขนาด 5 x 5 ที่พิมพ์ไปยัง stdout หรืออาร์เรย์ที่ส่งคืนจากฟังก์ชัน แต่ละองค์ประกอบควรระบุว่าทีมที่ได้รับในตำแหน่งแถวชนะแพ้หรือดึงออกจากทีมในตำแหน่งคอลัมน์หรือไม่ การเรียงลำดับแถวสำหรับเอาต์พุตควรตรงกับอินพุต คุณสามารถกำหนดสิ่งที่หมายถึงการชนะแพ้หรือเสมอดังนั้นตัวอักษร W, L, D หรือตัวเลข 0 1 2 หรือสิ่งที่คุณต้องการสามารถใช้ตราบใดที่มันถูกกำหนดไว้อย่างชัดเจนและสามารถแยกจากกัน องค์ประกอบเส้นทแยงมุมไม่ได้กำหนดคุณสามารถส่งออกอะไรก็ได้ แต่ควรจะเหมือนกันในแต่ละกรณี ค่าสามารถคั่นด้วยเครื่องหมายจุลภาคเว้นวรรคหรืออักขระใดก็ได้ที่คุณต้องการหรือไม่ใช่อักขระ ทั้งอินพุตและเอาต์พุตสามารถจัดรูปแบบด้วยค่าทั้งหมดในบรรทัดเดียวหากต้องการ

หากตารางไม่มีโซลูชันเฉพาะคุณต้องแสดงข้อความแสดงข้อผิดพลาดอย่างง่ายที่คุณเลือก

ตัวอย่างผลลัพธ์:

- W W W L
L - W D L
L L - D L
L D D - L
W W W W -

เอาต์พุตตัวอย่างสำหรับตารางที่ไม่สามารถแก้ไขได้:

dunno mate

นี่คือโค้ดกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ

รูปที่เกี่ยวข้อง (ญี่ปุ่นกับแอฟริกาใต้):

CJam, 57 49 47 45 bytes

{JZb:af{.*e_1+e!}:m*:e_5f/{_z2\ff-=},_,(0@?~}

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่ปรากฏอาร์เรย์สองมิติจากสแต็ก มันมี2ไว้สำหรับผู้ชนะ1การเสมอและ0การสูญเสีย นอกจากนี้ยังมี1สำหรับองค์ประกอบในแนวทแยงซึ่งคุณสามารถอะไรเอาท์พุท -1หากปัญหาไม่ได้แก้ปัญหาได้ผลตอบแทนที่ฟังก์ชั่น

รหัสจะทำงานออนไลน์ แต่จะใช้เวลาสักครู่ ลองมันในล่าม CJam

ทดสอบการทำงาน

$ cat input
3 1 0
1 2 1
0 3 1
0 2 2
4 0 0
$ time cjam results.cjam < input
[1 2 2 2 0]
[0 1 2 1 0]
[0 0 1 1 0]
[0 1 1 1 0]
[2 2 2 2 1]

real    0m1.584s
user    0m4.020s
sys     0m0.146s

มันทำงานอย่างไร

JZb:a e# Push 19 in base 3; wrap each digit in an array. Pushes [[2] [0] [1]].
f{    e# For each row of the input, push it and [[2] [0] [1]]; then:
  .*  e# Repeat 2, 0 and 1 (win, loss, draw) the specified number of times.
  e_  e# Flatten the resulting array.
  1+  e# Append a 1 for the diagonal.
  e!  e# Push all possible permutations.
}     e#
:m*   e# Cartesian product; push all possible combinations of permutations.
:e_   e# Flatten the results.
5f/   e# Split into rows of length 5.
{     e# Filter:
  _z  e#   Push a transposed copy of the array.
  2\  e#   Swap the result with 2.
  ff- e#   Subtract all elements from 2.
  =   e#   Check for equality.
},    e# Keep the element if `=' pushed 1.
_,(   e# Get the length of the array of solutions and subtract 1.
0@?   e# Keep the array for length 1, push 0 otherwise.
~     e# Either dump the singleton array or turn 0 into -1.

Haskell, 180 177 ไบต์

import Data.List
z=zipWith
m=map
a#b|(c,d)<-splitAt a b=c++[0]++d
f t=take 1[x|x<-m(z(#)[0..])$sequence$m(permutations.concat.z(flip replicate)[1,-1,0])t,transpose x==m(m(0-))x]

ชนะจะแสดงเป็น1การสูญเสียเป็นและวาดเป็น-1 องค์ประกอบในแนวทแยงนอกจากนี้ยังมี0 ตารางที่แก้ไม่ได้เป็นรายการที่ว่างเปล่าเช่น0[]

ตัวอย่างการใช้งาน: ->f [[3,1,0],[1,2,1],[0,3,1],[0,2,2],[4,0,0]][[[0,1,1,1,-1],[-1,0,1,0,-1],[-1,-1,0,0,-1],[-1,0,0,0,-1],[1,1,1,1,0]]]

มันทำงานอย่างไร: กำลังดุร้าย! สร้างรายการที่ชนะ / ขาดทุน / เสมอตามข้อมูลที่ป้อนเช่น[3,1,0]-> [1,1,1,-1], เปลี่ยนแปลง, สร้างชุดค่าผสมทั้งหมด, แทรก diagonals และเก็บตารางทั้งหมดที่เท่ากับการเปลี่ยนตำแหน่งด้วยองค์ประกอบทั้งหมดที่ถูกทำให้เป็นโมฆะ เอาอันแรก