Этот вопрос вдохновлен продолжающимся турниром "хулиганской игры, в которую играют джентльмены", чемпионатом мира по регби , который только что завершил этап в бассейне. В турнире 20 команд, и они разделены на 4 группы по 5 команд в каждой. На этапе пула каждая команда играет против всех других команд в своем пуле (всего 10 матчей за пул), и две лучшие команды каждого пула переходят в стадию нокаута.

В конце этапа пула есть таблица для каждого пула, показывающая количество побед, поражений и ничьих для каждой команды. Задача для этого вопроса состоит в том, чтобы написать программу, которая вводит количество побед, поражений и ничьих для каждой команды в пуле, и из этой информации выводит индивидуальные результаты каждого из 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       -

Некоторые таблицы неразрешимы, например, пул 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 команд. Вы можете использовать любой желаемый разделитель, вводить числа в главном порядке строк или столбцов и принимать числа либо через стандартный ввод, либо через массив в функцию.

Поскольку выигрыши + проигрыши + ничьи = 4, вы можете опустить одно из значений и поработать с другими, если хотите, то есть вам нужно всего лишь ввести 10 чисел.

Вам не нужно вводить названия команд.

Пример ввода:

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

Выход

Выходные данные вашей программы или функции должны быть в виде сетки 5 x 5, напечатанной на стандартный вывод, или массива, возвращаемого функцией. Каждый элемент должен указывать, выиграла ли команда, указанная в позиции строки, проиграла или сыграла ничью с командой в позиции столбца. Порядок строк для выходных данных должен соответствовать входным. Вы можете определить, что означает выигрыш, проигрыш или ничью, поэтому можно использовать буквы 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 байт

{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], перестановка, построение всех комбинаций, вставка диагоналей и сохранение всех таблиц, которые равны их транспонированию, с отрицанием всех элементов. Возьми первый.