Otrzymasz tablicę Bingo i listę połączeń. Musisz wydrukować BINGO! jak tylko twoja plansza wygra grę.

Tablice bingo wyglądają tak:

Zostaną one określone w ten sposób:

14 29 38 52 74
4 18 33 46 62
7 16 * 60 71
9 27 44 51 67
12 23 35 47 73

Zaraz za tablicą pojawią się połączenia, takie jak to:

B7
I29
G60
G51
O71
I23
I16
N38

Musisz powtórzyć wywołania na standardowe wyjście, aż do momentu tuż po wywołaniu, które wygrywa (wypełnij wiersz, kolumnę lub przekątną 5-długości), a następnie wydrukuj BINGO!.

W powyższym przykładzie wydrukuj:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Zasady

Standardowe zasady gry w golfa, wygrywa najkrótszy kod.

Detale

Zawsze będzie wystarczająco dużo połączeń, aby zagwarantować Ci Bingo. Na tablicy nie będzie duplikatów numerów ani duplikatów połączeń. Tablice zawsze będą miały poprawnie dopasowane cyfry i litery ( Bkolumna zawiera tylko 1-15, Ikolumna zawiera tylko 16-30 itd.), Tak jak wezwania. Jedyne wolne miejsce będzie zawsze na środku, oznaczone *zamiast liczby. Wykorzystywanie i odrzucanie połączeń ze standardowego wejścia po zwycięskim połączeniu jest dozwolone, ale nie wymagane.

Twórz własne przypadki testowe!

Perl, 122 120 znaków

$b=join'. .
',map~~<>,0..4;while(<>){/(\d+)/;$b=~s/\b$1\b/*/;print;
$b=~/(\*\s(\S+\s){$_}){4}\*/&&die"BINGO!
"for 0..7}

Zbuduj kartę za $bpomocą dwóch dodatkowych śmieciowych kolumn. Zamień numery, które są wywoływane na karcie, *i wydrukuj wybrany numer. Następnie ostatnie wyrażenie regularne zostanie ocenione jako prawdziwe, gdy *na planszy znajduje się 5 regularnych odstępów .

C # - 536

(OK, to chyba nie jest najbardziej odpowiedni język do tego, ale w każdym razie…)

using System;using System.Collections.Generic;using System.Linq;class C{static void Main(){var s=Enumerable.Range(1,12).Select(_=>new HashSet<string>()).ToList();var b=Enumerable.Range(1,5).Select(_=>Console.ReadLine().Split(' ')).ToList();int i;for(i=0;i<5;++i){for(int j=0;j<5;++j){s[i].Add(b[i][j]);s[i+5].Add(b[j][i]);}s[10].Add(b[i][i]);s[11].Add(b[4-i][i]);}while(i>0){var l=Console.ReadLine();Console.WriteLine(l);l=l.Substring(1);foreach(var x in s){x.Remove("*");x.Remove(l);if(x.Count==0){Console.WriteLine("BINGO!");i=0;}}}}}

Sformatowane i skomentowane:

using System;
using System.Collections.Generic;
using System.Linq;

class C
{
    static void Main()
    {
        // all possible winnable five-item sets – any one of them need to be emptied to win
        var s = Enumerable.Range(1, 12).Select(_ => new HashSet<string>()).ToList();
        // read the board from input to a list of arrays of numbers
        var b = Enumerable.Range(1, 5).Select(_ => Console.ReadLine().Split(' ')).ToList();
        int i;
        // split the board into the winnable sets
        for (i = 0; i < 5; ++i)
        {
            for (int j = 0; j < 5; ++j)
            {
                // sets 0–4 represent rows
                s[i].Add(b[i][j]);
                // sets 5–9 represent columns
                s[i + 5].Add(b[j][i]);
            }
            // set 10 represent one diagonal
            s[10].Add(b[i][i]);
            // set 11 represent the other diagonal
            s[11].Add(b[4 - i][i]);
        }
        while (i > 0)
        {
            // read and echo another input
            var l = Console.ReadLine();
            Console.WriteLine(l);
            // ignore the initial letter – we are guaranteed it is correct, anyway
            l = l.Substring(1);
            // remove the number from all sets
            foreach (var x in s)
            {
                x.Remove(l);
                // also remove the center * (inside the loop just to shave off a few characters)
                x.Remove("*");
                // if any set became empty, we won!
                if (x.Count == 0)
                {
                    Console.WriteLine("BINGO!");
                    // ensure the loop will stop (might not be necessary per the rules, but anyway)
                    i = 0;
                }
            }
        }
    }
}

Ruby 1.9 (194, 130)

To prawdopodobnie nie jest najrozsądniejszy sposób sprawdzania pustych kolumn, ale to była pierwsza rzecz, którą chciałem wypróbować! W szczególności to #transposekosztuje.

Albo pusta linia między tablicą a cyframi lub pola o stałej szerokości podczas deklarowania tablicy uratowałyby wiele znaków. Nie mogłem wymyślić naprawdę fajnego sposobu na odczytanie dokładnie 5 linii.

b=(R=0..4).map{gets}.join.scan /\d+|\*/
loop{gets
puts$_
~/\d+/
(e=b.index$&)&&b[e]=?*
R.map{|y|$><<:BINGO!&&exit if R.map{|x|[b[5*x+y],b[5*y+x],b[y<1?x*6:4*x+4]]}.transpose.any?{|a|a==[?*]*5}}}

EDYCJA: 130 znaków rozwiązanie przy użyciu techniki wyrażeń regularnych z perla moba odpowiedź:

b=(0..4).map{gets}*'~ ~ '
loop{gets
puts$_
~/\d+/
b[/\b#$&\b/]=?*
7.times{|i|$><<:BINGO!&&exit if b=~/(\*\s(\S+\s){#{i}}){4}\*/m}}

Biorąc pod uwagę długą, długą i długo spóźnioną informację o zbliżającej się premierze Rebola jako oprogramowania typu open source , wróciłem do mojego zwierzaka, aby rozwiązać ten problem Bingo . Być może wkrótce będę mógł dystrybuować Rebmu jako swój własny pakiet dla nastolatków GPL. :)

Rebmu 88 znaków

W zwartej notacji:

rtZ5[GisGpcRaZisGaAPgPCaSB6zAPv'*]l5[AgL5[apGfAsk+A5]]hd+Gu[raGin-NTrM'*fisGv5]p"BINGO!"

Dialekt używa sztuczki, którą nazywam mushingiem, która jest wyjaśniona na stronie Rebmu . Jest „legalny” w tym sensie, że nie oszukuje parsera; jest to poprawne Rebol ... i może faktycznie być dowolnie mieszane ze zwykłym kodem, a także (ahem) „długim” Rebmu ... który BTW będzie 141 znaków:

[rt z 5 [g: is g pc r a z is g a ap g pc a sb 6 z ap v '*] l 5 [a: g l 5 [ap g f a sk+ a 5]] hd+ g u [ra g in- nt r m '* fis g v 5] p "BINGO!"]

(Biorąc pod uwagę, że twierdzę, że kompresja jest sztuczką, którą można zrobić bez pomocy automatyzacji lub kompilacji, faktycznie opracowuję kod w zamyślonej formie. Nie jest to trudne).

To w rzeczywistości dość proste, nic specjalnego - jestem pewien, że inni programiści Rebol mogliby się zgolić. Niektóre skomentowane źródło znajduje się na GitHub , ale główną sztuczką, której używam, jest zbudowanie wszystkich możliwych rozwiązań w długiej serii („lista”, „tablica”, co masz). Rozwiązania diagonalne buduję podczas pętli wejściowej, ponieważ potrzeba pięciu wstawek na głowie i pięciu dołączeń na ogonie, aby je wykonać ... i już trwa pętla pięciokrotna.

Całość z łatwością mapuje się na kod Rebol, a ja jeszcze nie wrzuciłem żadnych „bibliotek macierzy” do Rebmu z transpozycją lub innymi sztuczkami, które wydają się często pojawiać. Pewnego dnia to zrobię, ale na razie staram się pracować stosunkowo blisko samego Rebola. Zagadkowe rzeczy, takie jak:

 [g: is g pc r a z is g a ap g pc a sb 6 z ap v '*]

... są raczej proste:

 [
     ; assign the series pointer "g" to the result of inserting 
     ; the z'th element picked out of reading in some series
     ; from input that was stored in "a"...this pokes an element
     ; for the forward diagonal near the front of g
     g: insert g (pick (readin-mu a) z)

     ; insert the read-in series "a" from above into "g" as well,
     ; but *after* the forward diagonal elements we've added...
     insert g a

     ; for the reverse diagonal, subtract z from 6 and pick that
     ; (one-based) element out of the input that was stored in "a"
     ; so an element for the reverse diagonal is at the tail
     append g (pick a (subtract 6 z))

     ; so long as we are counting to 5 anyway, go ahead and add an
     ; asterisk to a series we will use called "v" to search for
     ; a fulfilled solution later
     append v '*
 ]

Uwaga: Nawiasy dodane powyżej dla przejrzystości. Ale programiści Rebol (podobnie jak anglojęzyczni) generalnie unikają stosowania dodatkowych objaśnień strukturalnych w celu wskazania gramatyki w komunikacji ... raczej zachowują je dla innych aplikacji ...

Jako dodatkowy bonus pokazujący, jak interesujące jest to, dodam mieszankę normalnego kodu, aby podsumować planszę. Style programowania są w rzeczywistości ... kompatybilne:

rtZ5[GisGpcRaZisGaAPgPCaSB6zAPv'*]
temp-series: g
sum: 0
loop 5 * 5 [
    square: first temp-series
    if integer! == type? square [
        sum: sum + square
    ]
    temp-series: next temp-series
]
print ["Hey grandma, the board sum is" sum]
l5[AgL5[apGfAsk+A5]]hd+Gu[raGin-NTrM'*fisGv5]p"BINGO!"

To również jest ważne Rebmu i da ci niezłą sumę planszy przed graniem w Bingo z tobą. W podanym przykładzie jest napisane Hey grandma, the board sum is 912. Co prawdopodobnie jest słuszne. Ale rozumiesz. :)

Mathematica 250

Ujawnienie: Zakładałem, że dane wejściowe zostały podane w listach, które są znacznie bardziej naturalne w przypadku Mathematica. Tak więc, z breprezentującą planszę i creprezentowanie połączeń,

b//Grid
c//Column

Jeśli dane wejściowe miałyby być ciągami, kod zwiększyłby się o około 30 znaków. (Później dołączę tę odmianę).

Kod

y = ReplacePart[ConstantArray[0, {5, 5}], {3, 3} -> 1]; d = Diagonal;
t := Tr[BitAnd @@@ Join[y, Transpose@y, {d@y}, {d[Reverse /@ y]}]] > 0;
r@i_ :=(y = ReplacePart[y, Position[x, ToExpression@StringDrop[i, 1]][[1]] -> 1]; 
Print@If[t, Column[{i, "BINGO!"}], i])
n = 1; While[! t, r@c[[n]]; n++]

B7

I29

G60

G51

O71

I23

I16

BINGO!

Python 249

R=raw_input;F=B=[[[x,0][x=='*']for x in row]for row in[R().split()for i in'11111']];A=any
while all([all(map(A,B)),all(map(A,zip(*B))),A(F[::6]),A(F[4:24:4])]):c=R();print c;C=c[1:];B=[[[x,0][x==C]for x in row]for row in B];F=sum(B,[])
print'BINGO!'

Stosowanie:

$ ./bingo.py < bingo.txt
B7
I29
G60
G51
O71
I23
I16
BINGO!

APL (82)

{(D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵:'BINGO!'⋄∇⍵∨B=⍎1↓⎕←⍞}0=B←↑{⍎(K,K)[⍞⍳⍨K←11↑⎕D]}¨⍳5

• {... }¨⍳5: wykonaj 5 razy:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: przeczytaj wiersz ( ⍞) i zamapuj wszystkie znaki, które nie są cyframi ani spacjami 0, a następnie oceń linię.
• B←↑: zamień go w macierz (5x5, jeśli dane wejściowe były prawidłowe) i zapisz w B.
• {... }0=B: tablica startowa ma 1 w wolnym polu (0) i 0 w pozostałych polach.
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: jeśli linia, kolumna lub przekątna są wypełnione:
• 'BINGO!': następnie wyjście BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: w przeciwnym razie przeczytaj wiersz ( ⍞), wypowiedz go ( ⎕←), upuść pierwszy znak ( 1↓), oceń go, aby uzyskać liczbę ( ⍎), zobacz, gdzie występuje na tablicy ( B=), zaznacz go ( ⍵∨) i spróbuj ponownie ( ∇) .

K, 114

Biorąc pod uwagę zarząd bi połączeniac

b{-1@y;a:(5*!5)_@[,/x;&(,/x)~\:1_y;:;"*"];$[max{max@min'"*"=,/'x}@/:(a;a ./:/:+:'(r;)'(r;|:r:!5));'"BINGO!";];a}/c

.

k)b
"14" "29" "38" "52" "74"
,"4" "18" "33" "46" "62"
,"7" "16" ,"*" "60" "71"
,"9" "27" "44" "51" "67"
"12" "23" "35" "47" "73"
k)c
"B7"
"I29"
"G60"
"G51"
"O71"
"I23"
"I16"
"N38"
k)b{-1@y;a:(5*!5)_@[,/x;&(,/x)~\:1_y;:;"*"];$[max{max@min'"*"=,/'x}@/:(a;a ./:/:+:'(r;)'(r;|:r:!5));'"BINGO!";];a}/c
B7
I29
G60
G51
O71
I23
I16
'BINGO