Questa domanda si ispira al torneo in corso del "gioco del teppista giocato da gentiluomini", la Coppa del mondo di rugby , che ha appena completato la fase di biliardo. Ci sono 20 squadre nel torneo e sono divise in 4 gruppi da 5 squadre ciascuno. Durante la fase di pool ogni squadra gioca contro tutte le altre squadre del proprio pool (per un totale di 10 partite per pool) e le prime 2 squadre di ogni pool passano alla fase a eliminazione diretta.

Alla fine della fase del pool c'è un tavolo per ogni pool che mostra il numero di vittorie, perdite e pareggi per ogni squadra. La sfida per questa domanda è quella di scrivere un programma che inserisca il conteggio delle vittorie, delle perdite e dei pareggi per ogni squadra in un pool, e da quella informazione genera i risultati individuali di ciascuna delle 10 partite (chi ha vinto, perso o pareggiato contro chi ) se possibile o genera un messaggio di errore in caso contrario.

Ad esempio, ecco il tavolo per il Pool D del torneo di quest'anno:

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

Da queste informazioni, possiamo dedurre che l'Irlanda ha vinto contro Canada, Francia, Italia e Romania, perché hanno vinto tutte le loro partite. La Francia deve aver vinto contro il Canada, l'Italia e la Romania, ma ha perso contro l'Irlanda, perché ne ha perso solo uno e deve essere stato contro l'Irlanda imbattuta. Abbiamo appena scoperto che l'Italia ha perso contro Irlanda e Francia, quindi devono aver vinto contro il Canada e la Romania. Il Canada ha perso tutte le partite e quindi la vittoria della Romania deve essere stata contro il Canada.

         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       -

Ecco un esempio (complicato) più complicato:

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

In questo caso, possiamo dedurre che la Romania ha vinto contro Canada, Francia, Italia e Irlanda, perché hanno vinto tutte le loro partite. Il Canada deve aver vinto contro Irlanda, Italia e Francia, ma ha perso contro la Romania. Abbiamo appena scoperto che l'Italia ha perso contro la Romania e il Canada, quindi devono aver pareggiato contro la Francia e l'Irlanda. Ciò significa che l'Irlanda ha pareggiato con l'Italia e ha perso contro tutti gli altri, e quindi la Francia deve aver battuto l'Irlanda, pareggiato con l'Italia e perso contro il Canada e la Romania.

         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       -

Alcuni tavoli sono irrisolvibili, ad esempio il Pool B di quest'anno, in cui 3 team hanno ottenuto gli stessi totali 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

Tuttavia alcune tabelle con righe duplicate sono risolvibili, come questa (fittizia):

            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

Ingresso

Il tuo programma o funzione dovrebbe accettare 15 numeri che specificano il totale di vincite, sconfitte e pareggi per ognuna delle 5 squadre. È possibile utilizzare qualsiasi delimitatore desiderato, immettere i numeri nell'ordine principale di riga o colonna e accettare i numeri tramite stdin o passati tramite un array a una funzione.

Poiché vince + perdite + pareggi = 4, puoi omettere uno dei valori e risolverlo dagli altri, se lo desideri, il che significa che devi solo inserire 10 numeri.

Non è necessario inserire i nomi delle squadre.

Input di esempio:

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

Produzione

L'output del programma o della funzione deve essere nella forma di una griglia 5 x 5 stampata su stdout o di un array restituito da una funzione. Ogni elemento deve specificare se la squadra indicata nella posizione della riga ha vinto, perso o pareggiato contro la squadra nella posizione della colonna. L'ordinamento di riga per l'output deve corrispondere all'input. Puoi definire ciò che indica una vittoria, una perdita o un pareggio, quindi le lettere W, L, D o le cifre 0 1 2 o qualsiasi cosa tu voglia possono essere usate purché siano chiaramente definite e possano essere distinte l'una dall'altra. Gli elementi diagonali non sono definiti, puoi produrre qualsiasi cosa, ma dovrebbe essere lo stesso in ogni caso. I valori possono essere separati da virgole, spazi o qualunque carattere ti piaccia o meno. Se lo si desidera, sia l'input che l'output possono essere formattati con tutti i valori su una sola riga.

Se una tabella non ha una soluzione univoca, è necessario generare un semplice messaggio di errore a scelta.

Uscita campione:

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

Output di esempio per tabella irrisolvibile:

dunno mate

Questo è il golf del codice, quindi vince il programma più breve in byte.

Immagini correlate (Giappone contro Sudafrica):

CJam, 57 49 47 45 byte

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

Questa è una funzione anonima che estrae un array bidimensionale dallo stack e ne lascia uno in cambio. Contiene 2per vittorie, 1pareggi e 0perdite. Contiene anche 1elementi diagonali, per i quali è possibile produrre qualsiasi cosa . Se il problema non è risolvibile, la funzione ritorna -1.

Il codice funzionerà online, ma ci vorrà del tempo. Provalo nell'interprete CJam .

Prova

$ 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

Come funziona

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 byte

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]

Viene mostrata una vittoria come 1, una perdita come -1e un pareggio come 0. Sono anche elementi diagonali 0. Le tabelle irrisolvibili sono liste vuote, ad es [].

Esempio di utilizzo: 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]]].

Come funziona: forza bruta! Crea un elenco di vincite / perdite / pareggi in base all'input, ad es. [3,1,0]-> [1,1,1,-1], permuta, costruisci tutte le combinazioni, inserisci diagonali e mantieni tutte le tabelle uguali alla loro trasposizione con tutti gli elementi negati. Prendi il primo.