Esta questão é inspirada no torneio em andamento do "jogo do hooligan jogado por cavalheiros", a Copa do Mundo de Rugby , que acaba de completar a etapa da piscina. Existem 20 equipes no torneio, e elas são divididas em 4 grupos de 5 equipes cada. Durante a fase da piscina, cada equipe joga contra todas as outras equipes da piscina (um total de 10 partidas por piscina), e as 2 principais equipes de cada piscina avançam para a fase eliminatória.

No final do estágio da piscina, há uma tabela para cada piscina mostrando o número de vitórias, derrotas e empates de cada equipe. O desafio para essa pergunta é escrever um programa que insira a contagem de vitórias, derrotas e empates de cada equipe em um pool e, a partir dessa informação, produz os resultados individuais de cada uma das 10 partidas (quem venceu, perdeu ou empatou contra quem ) se possível ou emite uma mensagem de erro, se não.

Por exemplo, aqui está a tabela para o Pool D do torneio deste ano:

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

Com base nessas informações, podemos deduzir que a Irlanda venceu o Canadá, França, Itália e Romênia, porque venceu todos os seus jogos. A França deve ter vencido contra o Canadá, Itália e Romênia, mas perdeu para a Irlanda, porque perdeu apenas um e deve ter sido para a Irlanda invicta. Acabamos de descobrir que a Itália perdeu para a Irlanda e a França, então eles devem ter vencido contra o Canadá e a Romênia. O Canadá perdeu todos os jogos e, portanto, a vitória da Romênia deve ter sido contra o Canadá.

         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       -

Aqui está um exemplo mais complicado (fictício):

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

Nesse caso, podemos deduzir que a Romênia venceu o Canadá, França, Itália e Irlanda, porque venceu todos os jogos. O Canadá deve ter vencido contra a Irlanda, Itália e França, mas perdeu para a Romênia. Acabamos de descobrir que a Itália perdeu para a Romênia e o Canadá, então eles devem ter empatado contra a França e a Irlanda. Isso significa que a Irlanda empatou com a Itália e perdeu para todos os outros e, portanto, a França deve ter derrotado a Irlanda, empatada com a Itália e perdida para o Canadá e a Romênia.

         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       -

Algumas tabelas são insolúveis, por exemplo, o Pool B deste ano, em que três equipes obtiveram os mesmos totais de P / 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

No entanto, algumas tabelas com linhas duplicadas são solucionáveis, como esta (fictícia):

            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

Entrada

Seu programa ou função deve aceitar 15 números, especificando os totais de vitórias, derrotas e empates para cada uma das 5 equipes. Você pode usar qualquer delimitador que desejar, inserir os números na ordem principal de linhas ou colunas e aceitar os números via stdin ou passados ​​através de uma matriz para uma função.

Como vitórias + perdas + empates = 4, você pode omitir um dos valores e calculá-lo dos outros, se desejar, o que significa que você só precisa inserir 10 números.

Você não precisa inserir nenhum nome de equipe.

Entrada de amostra:

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

Resultado

A saída do seu programa ou função deve estar na forma de uma grade 5 x 5 impressa em stdout ou em uma matriz retornada de uma função. Cada elemento deve especificar se a equipe dada na posição da linha venceu, perdeu ou empatou contra a equipe na posição da coluna. A ordem das linhas para a saída deve corresponder à entrada. Você pode definir o que denota uma vitória, perda ou empate, para que as letras W, L, D ou dígitos 0 1 2 ou o que você quiser possa ser usado desde que elas sejam claramente definidas e se diferenciem. Os elementos diagonais são indefinidos, você pode produzir qualquer coisa, mas deve ser o mesmo em cada caso. Os valores podem ser separados por vírgulas, espaços ou qualquer caractere que você goste ou não. Tanto a entrada quanto a saída podem ser formatadas com todos os valores em uma única linha, se desejado.

Se uma tabela não tiver uma solução exclusiva, você deverá enviar uma mensagem de erro simples de sua escolha.

Saída de amostra:

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

Saída de amostra para tabela não solucionável:

dunno mate

Este é um código de golfe, e o programa mais curto em bytes vence.

Relacionado à foto (Japão versus África do Sul):

CJam, 57 49 47 45 bytes

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

Essa é uma função anônima que exibe uma matriz bidimensional da pilha e deixa uma em troca. Contém 2vitórias, 1empates e 0derrotas. Ele também contém 1elementos diagonais, para os quais você pode produzir qualquer coisa . Se o problema não for solucionável, a função retornará -1.

O código funcionará online, mas levará um tempo. Experimente no intérprete CJam .

Execução de teste

$ 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

Como funciona

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 bytes

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]

Uma vitória é mostrada como 1, uma perda como -1e um empate como 0. Elementos diagonais também são 0. Tabelas insolúveis são listas vazias, ie [].

Exemplo de uso: 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]]].

Como funciona: força bruta! Crie uma lista de vitórias / perdas / empates de acordo com a entrada, por exemplo [3,1,0]-> [1,1,1,-1]permute, construa todas as combinações, insira diagonais e mantenha todas as tabelas iguais à sua transposição com todos os elementos negados. Pegue o primeiro.