Bạn được cấp một bảng Bingo và một danh sách các cuộc gọi. Bạn phải in BINGO! ngay khi bảng của bạn thắng trò chơi.

Bảng Bingo trông như thế này:

Chúng sẽ được chỉ định như thế này:

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

Ngay sau hội đồng quản trị sẽ có các cuộc gọi, như thế này:

B7
I29
G60
G51
O71
I23
I16
N38

Bạn phải lặp lại các cuộc gọi ra đầu ra tiêu chuẩn cho đến khi ngay sau cuộc gọi khiến bạn thắng (nhận được một hàng, cột hoặc đường chéo dài 5 được điền đầy đủ), sau đó in BINGO!.

Ví dụ trên, in:

B7
I29
G60
G51
O71
I23
I16
BINGO!

Quy tắc

Quy tắc golf tiêu chuẩn, mã ngắn nhất sẽ thắng.

Chi tiết

Sẽ luôn có đủ các cuộc gọi để đảm bảo cho bạn một Bingo. Sẽ không có số trùng lặp trên bảng và không có cuộc gọi trùng lặp. Các bảng sẽ luôn có các số và chữ cái khớp chính xác ( Bcột chỉ chứa 1-15, Icột chỉ chứa 16-30, v.v.), như sẽ gọi. Không gian trống một và duy nhất sẽ luôn ở giữa, được đánh dấu *thay vì số. Tiêu thụ và loại bỏ các cuộc gọi từ đầu vào tiêu chuẩn sau khi cuộc gọi chiến thắng được cho phép, nhưng không bắt buộc.

Làm trường hợp thử nghiệm của riêng bạn!

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}

Xây dựng thẻ trong $bvới hai cột Junky bổ sung. Thay thế các số được gọi trên thẻ bằng *và in số được gọi. Sau đó, biểu thức chính quy cuối cùng sẽ đánh giá là đúng khi có 5 *s cách đều nhau trên bảng.

C # - 536

(OK, đây có lẽ không phải là ngôn ngữ phù hợp nhất cho điều đó, nhưng dù sao thì thì)

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

Định dạng và nhận xét:

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)

Đây có lẽ không phải là cách hợp lý nhất để kiểm tra các cột trống, nhưng đó là điều đầu tiên tôi nghĩ nên thử! Đặc biệt, #transposechi phí rất nhiều.

Hoặc là một dòng trống giữa bảng và số hoặc các trường có chiều rộng cố định khi khai báo bảng sẽ tiết kiệm rất nhiều ký tự. Tôi không thể nghĩ ra một cách thực sự hay để đọc chính xác 5 dòng.

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: Giải pháp 130 ký tự bằng cách sử dụng kỹ thuật biểu thức chính quy từ câu trả lời perl của 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}}

Đưa ra thông báo dài, quá hạn, dài hạn về việc phát hành sắp tới của Rebol dưới dạng phần mềm nguồn mở , tôi quay lại phương ngữ thú cưng của mình để giải quyết vấn đề Bingo này . Tôi có thể sớm có thể phân phối Rebmu dưới dạng gói GPL thiếu niên của riêng mình. :)

Rebmu 88 ký tự

Trong ký hiệu nhỏ gọn:

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

Các phương ngữ sử dụng một thủ thuật tôi gọi mushing đó được giải thích trên trang Rebmu . Đó là "hợp pháp" theo nghĩa là nó không lừa đảo trình phân tích cú pháp; đây là Rebol hợp lệ ... và thực sự có thể được xen kẽ tự do với mã thông thường cũng như (ahem) "dạng dài" Rebmu ... mà BTW sẽ có 141 ký tự:

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

(Cho rằng tôi khẳng định việc nén là một mẹo mà người ta có thể làm mà không cần sự trợ giúp của tự động hóa hoặc biên dịch, tôi thực sự phát triển mã ở dạng được nhúng. Nó không khó.)

Nó thực sự khá đơn giản, không có gì đặc biệt - Tôi chắc rằng các lập trình viên Rebol khác có thể loại bỏ mọi thứ. Một số nguồn nhận xét là trên GitHub , nhưng mẹo chính tôi sử dụng là xây dựng tất cả các giải pháp có thể trong một chuỗi dài ("danh sách", "mảng", những gì bạn có). Tôi xây dựng các giải pháp đường chéo trong vòng lặp đầu vào, vì phải mất năm lần chèn vào đầu và năm lần nối ở đuôi để tạo ra chúng ... và đã có một vòng lặp năm bước đang diễn ra.

Toàn bộ điều này dễ dàng ánh xạ tới mã Rebol và tôi chưa ném bất kỳ "thư viện ma trận" nào vào Rebmu với sự hoán vị hoặc các mánh lới quảng cáo khác dường như xuất hiện thường xuyên. Một ngày nào đó tôi sẽ làm điều đó nhưng bây giờ tôi chỉ đang cố gắng làm việc tương đối gần với phương tiện của chính Rebol. Những thứ có vẻ khó hiểu như:

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

... khá đơn giản:

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

Lưu ý: Dấu ngoặc đơn được thêm ở trên cho rõ ràng. Nhưng các lập trình viên Rebol (như người nói tiếng Anh) thường tránh áp dụng các chú thích cấu trúc bổ sung để chỉ ra ngữ pháp trong giao tiếp ... thay vì lưu chúng cho các ứng dụng khác ...

Giống như một phần thưởng bổ sung để cho thấy điều này thực sự thú vị như thế nào, tôi sẽ đưa vào một số hỗn hợp mã thông thường để tổng hợp bảng. Các phong cách lập trình thực sự ... tương thích:

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

Đó là Rebmu hợp lệ là tốt, và nó sẽ cung cấp cho bạn một khoản tiền tốt đẹp trước khi chơi Bingo với bạn. Trong ví dụ đưa ra, nó nói Hey grandma, the board sum is 912. Điều này có lẽ đúng. Nhưng bạn sẽ có được điểm. :)

Toán học 250

Tiết lộ: Tôi giả định rằng đầu vào được đưa ra trong các danh sách sử dụng tự nhiên hơn nhiều cho Mathicala. Vì vậy, với việc bđại diện cho hội đồng quản trị và cđại diện cho các cuộc gọi,

b//Grid
c//Column

Nếu đầu vào là chuỗi, mã sẽ tăng thêm khoảng 30 ký tự. (Sau này tôi sẽ bao gồm biến thể đó.)

Mã

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

CHƠI LÔ TÔ!

Con trăn 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!'

Sử dụng:

$ ./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: làm 5 lần:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: đọc một dòng ( ⍞) và ánh xạ tất cả các ký tự không phải là chữ số hoặc dấu cách 0, sau đó đánh giá dòng đó.
• B←↑: biến nó thành ma trận (5x5 nếu đầu vào đúng) và lưu trữ trong B.
• {... }0=B: bảng bắt đầu có 1 trong không gian trống (0) và 0 trong các không gian khác.
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: nếu một dòng, một cột hoặc một đường chéo được điền:
• 'BINGO!': sau đó đầu ra BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: nếu không, hãy đọc một dòng ( ⍞), lặp lại nó ( ⎕←), bỏ ký tự đầu tiên ( 1↓), đánh giá nó để lấy một số ( ⍎), xem nó xuất hiện ở đâu trên bảng ( B=), đánh dấu nó ( ⍵∨) và thử lại ( ∇) .

K, 114

Đưa ra bảng bvà các cuộc gọic

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