To pytanie jest inspirowane trwającym turniejem „gry chuliganów granej przez dżentelmenów”, Puchar Świata w Rugby , który właśnie zakończył etap bilardowy. W turnieju bierze udział 20 drużyn, które są podzielone na 4 grupy po 5 drużyn. Podczas fazy puli każda drużyna gra ze wszystkimi innymi drużynami w swojej puli (łącznie 10 meczów na pulę), a 2 najlepsze drużyny z każdej puli przechodzą do fazy pucharowej.

Na końcu fazy puli znajduje się tabela dla każdej puli pokazująca liczbę wygranych, przegranych i remisów dla każdej drużyny. Wyzwaniem dla tego pytania jest napisanie programu, który wprowadza liczbę wygranych, przegranych i remisów dla każdej drużyny w puli, a z tych informacji wynikają indywidualne wyniki każdego z 10 meczów (kto wygrał, przegrał lub zremisował z kim ), jeśli to możliwe, lub wyświetla komunikat o błędzie, jeśli nie.

Na przykład, oto tabela dla puli D tegorocznego turnieju:

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

Na podstawie tych informacji możemy wywnioskować, że Irlandia wygrała z Kanadą, Francją, Włochami i Rumunią, ponieważ wygrała wszystkie swoje mecze. Francja musiała wygrać z Kanadą, Włochami i Rumunią, ale przegrała z Irlandią, ponieważ przegrała tylko jedną i musiała to być Irlandia niepokonana. Właśnie odkryliśmy, że Włochy przegrały z Irlandią i Francją, więc musiały wygrać z Kanadą i Rumunią. Kanada przegrała wszystkie mecze, więc zwycięstwo Rumunii musiało być przeciwko Kanadzie.

         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       -

Oto bardziej skomplikowany (fikcyjny) przykład:

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

W tym przypadku możemy wywnioskować, że Rumunia wygrała z Kanadą, Francją, Włochami i Irlandią, ponieważ wygrała wszystkie swoje mecze. Kanada musiała wygrać z Irlandią, Włochami i Francją, ale przegrała z Rumunią. Właśnie odkryliśmy, że Włochy przegrały z Rumunią i Kanadą, więc musiały zremisować przeciwko Francji i Irlandii. Oznacza to, że Irlandia zremisowała z Włochami i przegrała z innymi, dlatego Francja musiała pokonać Irlandię, zremisować z Włochami i przegrać z Kanadą i Rumunią.

         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       -

Niektóre tabele są nierozwiązywalne, na przykład tegoroczna pula B, w której 3 drużyny otrzymały takie same sumy 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

Jednak niektóre tabele ze zduplikowanymi wierszami są rozwiązywalne, takie jak ta (fikcyjna):

            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

Wejście

Twój program lub funkcja powinna przyjąć 15 liczb określających sumę wygranych, przegranych i losowań dla każdej z 5 drużyn. Możesz użyć dowolnego ogranicznika, wprowadzić liczby w kolejności rzędów lub kolumn oraz zaakceptować liczby albo przez standardowe wejście, albo przez tablicę do funkcji.

Ponieważ wygrane + przegrane + remisy = 4, możesz pominąć jedną z wartości i opracować ją dla innych, jeśli chcesz, co oznacza, że ​​musisz wprowadzić tylko 10 liczb.

Nie musisz wprowadzać żadnych nazw drużyn.

Przykładowe dane wejściowe:

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

Wynik

Dane wyjściowe programu lub funkcji powinny mieć postać siatki 5 x 5 wydrukowanej na standardowym wyjściu lub tablicy zwróconej z funkcji. Każdy element powinien określać, czy drużyna podana w pozycji w rzędzie wygrała, przegrała lub zremisowała w stosunku do drużyny w pozycji kolumny. Kolejność wierszy dla danych wyjściowych powinna być zgodna z danymi wejściowymi. Możesz zdefiniować, co oznacza wygraną, przegraną lub remis, więc litery W, L, D lub cyfry 0 1 2 lub cokolwiek chcesz, mogą być używane, o ile są one wyraźnie zdefiniowane i można je od siebie odróżnić. Elementy ukośne są niezdefiniowane, możesz wyprowadzać wszystko, ale w każdym przypadku powinno być tak samo. Wartości można oddzielić przecinkami, spacjami lub dowolnym innym znakiem, który chcesz, lub nie znakiem. W razie potrzeby zarówno format wejściowy, jak i wyjściowy można sformatować przy użyciu wszystkich wartości w jednym wierszu.

Jeśli tabela nie ma unikalnego rozwiązania, musisz wygenerować prosty komunikat o błędzie według własnego wyboru.

Przykładowe dane wyjściowe:

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

Przykładowe dane wyjściowe dla nierozwiązywalnej tabeli:

dunno mate

To jest kod golfowy, więc wygrywa najkrótszy program w bajtach.

Powiązane zdjęcia (Japonia kontra Republika Południowej Afryki):

CJam, 57 49 47 45 bajtów

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

Jest to anonimowa funkcja, która wyrywa dwuwymiarową tablicę ze stosu i pozostawia jedną w zamian. Zawiera 2wygrane, 1remisy i 0przegrane. Zawiera także 1elementy ukośne, dla których można wyprowadzać wszystko . Jeśli problemu nie da się rozwiązać, funkcja powraca -1.

Kod będzie działał online, ale zajmie to trochę czasu. Wypróbuj w interprecie CJam .

Testowe uruchomienie

$ 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

Jak to działa

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 bajtów

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]

Wygrana jest pokazana jako 1, przegrana jako -1i remis jako 0. Elementy ukośne są również 0. Tabele nierozwiązywalne to puste listy, tj [].

Przykład użycia: 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]]].

Jak to działa: brutalna siła! Utwórz listę wygranych / przegranych / losowań zgodnie z danymi wejściowymi, np. [3,1,0]-> [1,1,1,-1], permutuj, buduj wszystkie kombinacje, wstaw przekątne i utrzymuj wszystkie tabele, które są równe ich transpozycji, z zaprzeczeniem wszystkich elementów. Weź pierwszy.