Code Golf Bingo!

14

On vous donne un tableau de Bingo et une liste d'appels. Vous devez imprimer BINGO! dès que votre plateau gagne la partie.

Les planches de bingo ressemblent à ceci:

entrez la description de l'image ici

Ils seront spécifiés comme ceci:

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

Immédiatement après le tableau, il y aura des appels, comme ceci:

B7
I29
G60
G51
O71
I23
I16
N38

Vous devez répéter les appels vers la sortie standard jusqu'à ce que juste après l'appel qui vous fait gagner (obtenir une ligne, une colonne ou une diagonale de 5 longs tous remplis), puis imprimer BINGO!.

Pour l'exemple ci-dessus, imprimez:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Règles

Règles de code-golf standard, les gains de code les plus courts.

Détails

Il y aura toujours suffisamment d'appels pour vous garantir un Bingo. Il n'y aura pas de numéros en double sur le tableau et pas d'appels en double. Les tableaux auront toujours des chiffres et des lettres correctement appariés (la Bcolonne ne contient que 1-15, la Icolonne ne contient que 16-30, etc.), tout comme les appels. Le seul et unique espace libre sera toujours au milieu, marqué par* lieu d'un nombre. Consommer et rejeter les appels de l'entrée standard après que l'appel gagnant soit autorisé, mais pas obligatoire.

Faites vos propres cas de test!

Keith Randall
la source

Réponses:

3

Perl, 122120 char

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

Construisez la carte $bavec deux colonnes junky supplémentaires. Remplacez les numéros appelés sur la carte par *et imprimez le numéro appelé. Ensuite, la dernière expression régulière sera évaluée comme vraie lorsqu'il y a 5 *s régulièrement espacés sur la carte.

foule
la source
4

C # - 536

(OK, ce n'est probablement pas la langue la plus appropriée pour ça, mais de toute façon…)

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

Formaté et commenté:

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;
                }
            }
        }
    }
}
Mormegil
la source
4

Rubis 1.9 (194, 130)

Ce n'est probablement pas le moyen le plus judicieux de vérifier les colonnes vides, mais c'est la première chose que j'ai pensé essayer! En particulier, cela #transposecoûte cher.

Soit une ligne vierge entre le tableau et les nombres, soit des champs à largeur fixe lors de la déclaration du tableau enregistrerait beaucoup de caractères. Je ne pouvais pas penser à une très belle façon de lire exactement 5 lignes.

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: solution de 130 caractères utilisant la technique d'expression régulière de la réponse 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}}
Paul Prestidge
la source
4

Compte tenu de l'annonce attendue depuis longtemps, très longtemps de la sortie imminente de Rebol en tant que logiciel open source , je suis retourné dans mon dialecte pour résoudre ce problème de bingo . Je pourrai bientôt distribuer Rebmu comme son propre package GPL pour adolescents. :)


Rebmu 88 caractères

Dans la notation compacte:

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

Le dialecte utilise une astuce que j'appelle mushing qui est expliquée sur la page Rebmu . C'est "légitime" dans le sens où il ne trompe pas l'analyseur; c'est Rebol valide ... et peut en fait être librement mélangé avec du code ordinaire ainsi que (ahem) Rebmu "longue forme" ... qui BTW serait de 141 caractères:

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

(Étant donné que je prétends que la compression est une astuce que l'on peut faire sans l'aide de l'automatisation ou de la compilation, je développe en fait le code sous la forme bouillonnée. Ce n'est pas difficile.)

C'est en fait assez simple, rien de spécial - je suis sûr que d'autres programmeurs Rebol pourraient raser les choses. Une source commentée est sur GitHub , mais l'astuce principale que j'utilise est de construire toutes les solutions possibles dans une longue série ("list", "array", what-have-you). Je construis les solutions diagonales pendant la boucle d'entrée, car il faut cinq insertions en tête et cinq annexes en queue pour les faire ... et il y a déjà une boucle de cinq itérations en cours.

Le tout est facilement mappé au code Rebol, et je n'ai pas encore lancé de "bibliothèques matricielles" dans Rebmu avec une transposition ou d'autres gadgets qui semblent souvent arriver. Un jour, je le ferai, mais pour l'instant j'essaie juste de travailler relativement près du milieu de Rebol lui-même. Des choses d'apparence cryptique comme:

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

... sont assez 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 '*
 ]

Remarque: parenthèses ajoutées ci-dessus pour plus de clarté. Mais les programmeurs Rebol (comme les anglophones) évitent généralement l'application de légendes structurelles supplémentaires pour indiquer la grammaire de la communication ... plutôt les enregistrer pour d'autres applications ...

Juste comme un bonus supplémentaire pour montrer à quel point c'est intéressant, je vais ajouter un mélange de code normal pour résumer le tableau. Les styles de programmation sont en fait ... 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!"

C'est aussi valable Rebmu, et cela vous donnera une belle somme de plateau avant de jouer au Bingo avec vous. Dans l'exemple donné, il est dit Hey grandma, the board sum is 912. C'est probablement vrai. Mais vous comprenez. :)

HostileFork dit de ne pas faire confiance à SE
la source
2

Mathematica 250

Divulgation: J'ai supposé que l'entrée était donnée dans des listes qui sont beaucoup plus naturelles à utiliser pour Mathematica. Donc, en breprésentant le conseil d'administration et en creprésentant les appels,

b//Grid
c//Column

contribution

Si l'entrée devait être en chaînes, le code augmenterait d'environ 30 caractères. (J'inclurai plus tard cette variation.)

Code

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!

DavidC
la source
2

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

Usage:

$ ./bingo.py < bingo.txt
B7
I29
G60
G51
O71
I23
I16
BINGO!
Mat
la source
Vous pouvez remplacer rowpar un nom à un caractère. Non testé: essayez de le i in'*'*5]remplacer [x=='*']par [x==i].
Rétablir Monica
2

APL (82)

{(D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵:'BINGO!'⋄∇⍵∨B=⍎1↓⎕←⍞}0=B←↑{⍎(K,K)[⍞⍳⍨K←11↑⎕D]}¨⍳5
  • {... }¨⍳5: faire 5 fois:
  • ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: lire une ligne ( ) et mapper tous les caractères qui ne sont pas des chiffres ou des espaces 0, puis évaluer la ligne.
  • B←↑: le transformer en matrice (5x5 si l'entrée était correcte), et le stocker dans B.
  • {... }0=B: la planche de départ a un 1 dans l'espace libre (0) et 0 dans les autres espaces.
  • (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: si une ligne, une colonne ou une diagonale est remplie:
  • 'BINGO!': puis sortie BINGO
  • ∇⍵∨B=⍎1↓⎕←⍞: sinon, lisez une ligne ( ), faites-la écho ( ⎕←), supprimez le premier caractère ( 1↓), évaluez-le pour obtenir un nombre ( ), voyez où cela se produit sur le tableau ( B=), marquez-le ( ⍵∨) et essayez à nouveau ( ) .
marinus
la source
0

K, 114

Compte tenu du conseil d'administration bet des appelsc

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
tmartin
la source