Você recebe um quadro de bingo e uma lista de chamadas. Você deve imprimir o BINGO! assim que seu tabuleiro vencer o jogo.

As placas de bingo ficam assim:

Eles serão especificados assim:

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

Imediatamente após o quadro haverá chamadas, assim:

B7
I29
G60
G51
O71
I23
I16
N38

Você deve fazer eco das chamadas para a saída padrão até logo após a chamada que faz você ganhar (obter uma linha, coluna ou diagonal de 5 compridas todas preenchidas) e depois imprimir BINGO!.

Para o exemplo acima, imprima:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Regras

Regras padrão de código-golfe, código mais curto vence.

Detalhes

Sempre haverá chamadas suficientes para garantir um Bingo. Não haverá números duplicados no quadro nem chamadas duplicadas. Os painéis sempre terão números e letras correspondentes corretamente (a Bcoluna contém apenas 1 a 15, a Icoluna contém apenas 16 a 30 e assim por diante), assim como as chamadas. O único espaço livre estará sempre no meio, marcado com em *vez de um número. Consumir e descartar chamadas da entrada padrão depois que a chamada vencedora é permitida, mas não necessária.

Faça seus próprios casos de teste!

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}

Construa o cartão $bcom duas colunas adicionais indesejadas. Substitua os números chamados no cartão *e imprima o número chamado. A última expressão regular será avaliada como verdadeira quando houver 5 *s regularmente espaçados no quadro.

C # - 536

(OK, esse provavelmente não é o idioma mais adequado para isso, mas mesmo assim…)

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

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

Rubi 1.9 (194, 130)

Essa provavelmente não é a maneira mais sensata de procurar colunas vazias, mas foi a primeira coisa que pensei em tentar! Em particular, isso #transposecusta muito.

Uma linha em branco entre o quadro e os números ou campos de largura fixa ao declarar o quadro economizariam muitos caracteres. Eu não conseguia pensar em uma maneira muito legal de ler exatamente 5 linhas.

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: solução de 130 caracteres usando a técnica de expressão regular da resposta perl do 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 o anúncio, muito, muito atrasado, do lançamento iminente da Rebol como software de código aberto , voltei ao meu dialeto de estimação para resolver esse problema do Bingo . Em breve, poderei distribuir o Rebmu como seu próprio pacote GPL pequenino. :)

Rebmu 88 caracteres

Na notação compacta:

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

O dialeto usa um truque que chamo de mushing, explicado na página Rebmu . É "legítimo" no sentido de que não engana o analisador; isso é Rebol válido ... e pode realmente ser livremente misturado com código comum, bem como (ahem) "forma longa" Rebmu ... que BTW teria 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 a compactação é um truque que se pode fazer sem a ajuda da automação ou compilação, na verdade desenvolvo o código na forma simplificada. Não é difícil.)

Na verdade, é bastante simples, nada de especial - tenho certeza de que outros programadores da Rebol poderiam raspar as coisas. Alguma fonte comentada está no GitHub , mas o principal truque que utilizo é criar todas as soluções possíveis em uma longa série ("lista", "matriz", o que você tem). Eu construo as soluções diagonais durante o loop de entrada, pois são necessárias cinco inserções na cabeça e cinco anexos na cauda para fazê-las ... e já existe um loop de cinco iterações em andamento.

A coisa toda é facilmente mapeada para o código Rebol, e ainda não joguei nenhuma "biblioteca de matriz" no Rebmu com transposição ou outros truques que parecem surgir com frequência. Um dia farei isso, mas por enquanto estou apenas tentando trabalhar relativamente próximo ao meio da própria Rebol. Aparências enigmáticas como:

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

... são 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ênteses adicionados acima para maior clareza. Mas os programadores da Rebol (como falantes de inglês) geralmente evitam a aplicação de textos explicativos extras para indicar a gramática na comunicação ... em vez disso, os salva para outras aplicações ...

Apenas como um bônus a mais para mostrar o quão interessante isso realmente é, eu jogarei uma mistura de código normal para somar o quadro. Os estilos de programação são realmente ... compatíveis:

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

Também é válido o Rebmu, e ele lhe dará uma boa soma no tabuleiro antes de jogar o Bingo com você. No exemplo dado, ele diz Hey grandma, the board sum is 912. O que provavelmente está certo. Mas você entendeu. :)

Mathematica 250

Divulgação: Eu assumi que a entrada foi dada em listas que são muito mais naturais para usar no Mathematica. Portanto, com a brepresentação do quadro e cas chamadas,

b//Grid
c//Column

Se a entrada estivesse em strings, o código aumentaria em cerca de 30 caracteres. (Mais tarde, incluirei essa variação.)

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: faça 5 vezes:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: leia uma linha ( ⍞) e mapeie todos os caracteres que não têm dígitos ou espaço 0, e avalie a linha.
• B←↑: transformá-lo em uma matriz (5x5 se a entrada estiver correta) e armazene em B.
• {... }0=B: o quadro inicial possui 1 no espaço livre (0) e 0 nos outros espaços.
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: se uma linha, coluna ou diagonal estiver preenchida:
• 'BINGO!': então saída BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: caso contrário, leia uma linha ( ⍞), faça eco ( ⎕←), solte o primeiro caractere ( 1↓), avalie-o para obter um número ( ⍎), veja onde isso ocorre no quadro (B= ), marque-o ( ⍵∨) e tente novamente ( ∇) .

K, 114

Dada a diretoria be as ligaçõesc

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