Ti viene data una tavola da bingo e un elenco di chiamate. Devi stampare BINGO! non appena il tuo tavolo vince la partita.

Le bingo sono così:

Verranno specificati in questo modo:

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

Immediatamente dopo la scheda saranno chiamate, in questo modo:

B7
I29
G60
G51
O71
I23
I16
N38

Devi fare eco alle chiamate allo standard output fino a subito dopo la chiamata che ti fa vincere (ottenere una riga, una colonna o una diagonale di 5 lunghe tutte riempite), quindi stampare BINGO!.

Per l'esempio sopra, stampa:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Regole

Regole standard di golf di codice, vince il codice più corto.

Dettagli

Ci saranno sempre abbastanza chiamate per garantirti un Bingo. Non ci saranno numeri duplicati sul tabellone e chiamate duplicate. Le bacheche avranno sempre numeri e lettere correttamente abbinati (la Bcolonna contiene solo 1-15, la Icolonna contiene solo 16-30 e così via), così come le chiamate. L'unico e unico spazio libero sarà sempre nel mezzo, contrassegnato da* anziché un numero. Consumare e scartare le chiamate dall'input standard dopo la chiamata vincente è consentito, ma non necessario.

Crea i tuoi casi di test!

Perl, 122 120 char

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

Costruisci la carta $bcon due ulteriori colonne junky. Sostituisci i numeri chiamati sulla carta con *e stampa il numero chiamato. Quindi l'ultima espressione regolare verrà valutata vera quando ci sono 5 *s regolarmente spaziate sul tabellone.

C # - 536

(OK, questa probabilmente non è la lingua più adatta per questo, ma comunque ...)

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;}}}}}

Formattato e commentato:

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)

Questo probabilmente non è il modo più sensato per verificare la presenza di colonne vuote, ma è stata la prima cosa che ho pensato di provare! In particolare, questo #transposecosta molto.

Una linea vuota tra la tavola e i numeri o campi a larghezza fissa quando si dichiara la tavola salverebbe molti caratteri. Non riuscivo a pensare a un modo davvero carino di leggere esattamente 5 righe.

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}}}

EDIT: soluzione a 130 caratteri usando la tecnica dell'espressione regolare dalla risposta perl di mob:

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}}

Dato il lungo, molto, tanto atteso annuncio dell'imminente rilascio di Rebol come software open source , sono tornato al mio dialetto per risolvere questo problema del Bingo . Potrei presto essere in grado di distribuire Rebmu come suo pacchetto GPL per adolescenti. :)

Rebmu 88 caratteri

Nella notazione compatta:

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

Il dialetto usa un trucco che io chiamo mushing che è spiegato nella pagina Rebmu . È "legittimo", nel senso che non imbroglia il parser; questo è Rebol valido ... e può effettivamente essere mescolato liberamente con il codice ordinario così come (ahem) Rebmu "long-form" ... che BTW sarebbe di 141 caratteri:

[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!"]

(Dato che sostengo che la compressione è un trucco che si può fare senza l'aiuto dell'automazione o della compilazione, in realtà sviluppo il codice in forma confusa. Non è difficile.)

In realtà è abbastanza semplice, niente di speciale: sono sicuro che altri programmatori Rebol potrebbero radere le cose. Alcuni fonti commentate sono su GitHub , ma il trucco principale che uso è costruire tutte le possibili soluzioni in una lunga serie ("list", "array", what-have-you). Costruisco le soluzioni diagonali durante il ciclo di input, poiché sono necessarie cinque inserzioni in testa e cinque in coda per realizzarle ... e c'è già un ciclo di cinque iterazioni in corso.

Il tutto si associa facilmente al codice di Rebol, e non ho ancora gettato nessuna "libreria di matrici" in Rebmu con trasposizione o altri espedienti che sembrano emergere spesso. Un giorno lo farò, ma per ora sto solo cercando di lavorare relativamente vicino al mezzo di Rebol stesso. Cose dall'aspetto criptico come:

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

... sono piuttosto semplici:

 [
     ; 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 '*
 ]

Nota: le parentesi aggiunte sopra per chiarezza. Ma i programmatori Rebol (come chi parla inglese) generalmente evitano l'applicazione di callout strutturali extra per indicare la grammatica nella comunicazione ... piuttosto salvarli per altre applicazioni ...

Proprio come un ulteriore bonus per mostrare quanto questo sia davvero interessante, aggiungerò un po 'di codice normale per sommare il tabellone. Gli stili di programmazione sono in realtà ... compatibili:

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!"

È valido anche Rebmu e ti darà una bella somma di bordo prima di giocare a Bingo con te. Nell'esempio fornito, dice Hey grandma, the board sum is 912. Che probabilmente è giusto. Ma ottieni il punto. :)

Mathematica 250

Divulgazione: ho ipotizzato che l'input fosse fornito in elenchi che sono molto più naturali da usare per Mathematica. Così, conb rappresentare la scheda e crappresentare le chiamate,

b//Grid
c//Column

Se l'input dovesse essere in stringhe, il codice aumenterebbe di circa 30 caratteri. (In seguito includerò quella variante.)

Codice

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!'

Uso:

$ ./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: fare 5 volte:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: leggi una linea ( ⍞) e mappa tutti i caratteri che non sono cifre o spazio 0, quindi valuta la linea.
• B←↑: trasformalo in una matrice (5x5 se l'input era corretto) e memorizza in B.
• {... }0=B: la tavola di partenza ha 1 nello spazio libero (0) e 0 negli altri spazi.
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: se viene riempita una linea, una colonna o una diagonale:
• 'BINGO!': quindi uscita BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: altrimenti, leggi una riga ( ⍞), echo it ( ⎕←), rilascia il primo carattere ( 1↓), valutalo per ottenere un numero ( ⍎), vedi dove si trova sul tabellone ( B=), segnalo ( ⍵∨) e riprova ( ∇) .

K, 114

Dato il consiglio be le chiamatec

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