Te dan un tablero de Bingo y una lista de llamadas. Debes imprimir BINGO! tan pronto como tu tablero gane el juego.

Los tableros de bingo se ven así:

Se especificarán así:

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

Inmediatamente después del tablero habrá llamadas, como esta:

B7
I29
G60
G51
O71
I23
I16
N38

Debe repetir las llamadas a la salida estándar hasta justo después de la llamada que lo hace ganar (obtenga una fila, columna o diagonal de 5 de longitud completa), luego imprima BINGO!.

Para el ejemplo anterior, imprima:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Reglas

Código estándar de reglas de golf, el código más corto gana.

Detalles

Siempre habrá suficientes llamadas para garantizarle un Bingo. No habrá números duplicados en el tablero ni llamadas duplicadas. Los tableros siempre tendrán números y letras que coincidan correctamente (la Bcolumna contiene solo 1-15, la Icolumna contiene solo 16-30, etc.), al igual que las llamadas. El único espacio libre siempre estará en el medio, marcado con en *lugar de un número. Consumir y descartar llamadas de la entrada estándar después de que la llamada ganadora esté permitida, pero no es obligatoria.

¡Haz tus propios casos de prueba!

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}

Construye la tarjeta $bcon dos columnas adicionales de basura. Reemplace los números que se llaman en la tarjeta con *e imprima el número llamado. Luego, la última expresión regular se evaluará como verdadera cuando haya 5 *s espaciados regularmente en el tablero.

C # - 536

(OK, este probablemente no sea el lenguaje más adecuado para eso, pero de todos modos ...)

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

Formateado y comentado:

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)

Probablemente esta no sea la forma más sensata de verificar si hay columnas vacías, ¡pero fue lo primero que pensé probar! En particular, eso #transposecuesta mucho.

O bien una línea en blanco entre el tablero y los números o los campos de ancho fijo al declarar el tablero ahorrarían muchos caracteres. No se me ocurrió una forma realmente agradable de leer exactamente 5 líneas.

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

EDITAR: solución de 130 caracteres usando la técnica de expresión regular de la respuesta perl de 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}}

Dado el anuncio muy, muy, muy retrasado del lanzamiento inminente de Rebol como software de código abierto , volví a mi dialecto favorito para resolver este problema de Bingo . Es posible que pronto pueda distribuir Rebmu como su propio paquete GPL para adolescentes. :)

Rebmu 88 caracteres

En la notación compacta:

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

El dialecto usa un truco que llamo mushing, que se explica en la página Rebmu . Es "legítimo" en el sentido de que no engaña al analizador; este es Rebol válido ... y en realidad se puede mezclar libremente con código ordinario así como (ejem) Rebmu "de forma larga" ... que por cierto sería 141 caracteres:

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

(Dado que afirmo que la compresión es un truco que uno puede hacer sin la ayuda de la automatización o la compilación, en realidad desarrollo el código en forma desordenada. No es difícil).

En realidad es bastante simple, nada especial: estoy seguro de que otros programadores de Rebol podrían afeitarse. Alguna fuente comentada está en GitHub , pero el truco principal que uso es construir todas las soluciones posibles en una serie larga ("lista", "matriz", lo que tienes). Construyo las soluciones diagonales durante el ciclo de entrada, ya que se necesitan cinco inserciones en la cabeza y cinco se agregan en la cola para hacerlas ... y ya hay un ciclo de cinco iteraciones en progreso.

Todo esto se asigna fácilmente al código Rebol, y todavía no he lanzado ninguna "biblioteca de matriz" a Rebmu con transposición u otros trucos que parecen surgir a menudo. Algún día lo haré, pero por ahora solo estoy tratando de trabajar relativamente cerca del medio de Rebol. Cosas de aspecto críptico como:

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

... son bastante simples:

 [
     ; 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: Paréntesis agregados arriba para mayor claridad. Pero los programadores de Rebol (como los angloparlantes) generalmente evitan la aplicación de llamadas estructurales adicionales para indicar la gramática en la comunicación ... en lugar de guardarlas para otras aplicaciones ...

Solo como una ventaja adicional para mostrar lo interesante que es en realidad, agregaré una combinación de código normal para sumar el tablero. Los estilos de programación son en realidad ... compatibles:

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

Eso también es válido para Rebmu, y te dará una buena suma de tablero antes de jugar Bingo contigo. En el ejemplo dado, dice Hey grandma, the board sum is 912. Lo cual probablemente sea correcto. Pero usted consigue el punto. :)

Mathematica 250

Divulgación: asumí que la entrada se dio en listas que son mucho más naturales de usar para Mathematica. Entonces, al brepresentar el tablero y crepresentar las llamadas,

b//Grid
c//Column

Si la entrada estuviera en cadenas, el código crecería en unos 30 caracteres. (Más adelante incluiré esa variación).

Código

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: hacer 5 veces:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: lee una línea ( ⍞) y asigna todos los caracteres que no son dígitos o espacio 0, luego evalúa la línea.
• B←↑: conviértalo en una matriz (5x5 si la entrada fue correcta) y almacene en B.
• {... }0=B: el tablero inicial tiene un 1 en el espacio libre (0) y 0 en los otros espacios.
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: si se llena una línea, una columna o una diagonal:
• 'BINGO!': luego salida BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: de lo contrario, lea una línea ( ⍞), repítala ( ⎕←), suelte el primer carácter ( 1↓), evalúelo para obtener un número ( ⍎), vea dónde aparece en el tablero ( B=), márquelo ( ⍵∨) e intente nuevamente ( ∇) .

K, 114

Dado el tablero by las llamadasc

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