कोड गोल्फ बिंगो!

Question

आपको बिंगो बोर्ड और कॉल की सूची दी गई है । आपको BINGO प्रिंट करना होगा! जैसे ही आपका बोर्ड गेम जीतता है।

बिंगो बोर्ड इस तरह दिखते हैं:

उन्हें इस तरह निर्दिष्ट किया जाएगा:

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

इसके तुरंत बाद बोर्ड को कॉल किया जाएगा, जैसे:

B7
I29
G60
G51
O71
I23
I16
N38

आपको कॉल करने के कुछ समय बाद तक मानक आउटपुट के लिए कॉल को गूंजना चाहिए, जो आपको जीतता है (एक पंक्ति, स्तंभ, या 5-लंबी विकर्ण सभी भरे हुए), फिर प्रिंट करें BINGO!।

उपरोक्त उदाहरण के लिए, प्रिंट करें:

B7
I29
G60
G51
O71
I23
I16
BINGO!

नियम

मानक कोड-गोल्फ नियम, सबसे छोटा कोड जीतता है।

विवरण

आपको बिंगो की गारंटी देने के लिए हमेशा पर्याप्त कॉल होंगे। बोर्ड पर कोई डुप्लिकेट नंबर नहीं होगा, और कोई डुप्लिकेट कॉल नहीं होगा। बोर्डों में हमेशा सही ढंग से मिलान किए गए नंबर और अक्षर होंगे ( Bकॉलम में केवल 1-15 होता है, Iकॉलम में केवल 16-30 होते हैं, और इसी तरह), जैसा कि कॉल करेगा। एक और केवल मुक्त स्थान हमेशा मध्य में होगा, *एक संख्या के बजाय चिह्नित । विजेता कॉल की अनुमति के बाद मानक इनपुट से कॉल करना और छोड़ना, लेकिन आवश्यक नहीं है।

अपने खुद के परीक्षण के मामले बनाओ!

Answer 1

पर्ल, 122 120 चार

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

$bदो अतिरिक्त कबाड़ स्तंभों के साथ कार्ड का निर्माण करें । उन नंबरों को बदलें जो कार्ड पर कॉल किए गए हैं *और कॉल किए गए नंबर को प्रिंट करें। तब अंतिम नियमित अभिव्यक्ति सच का मूल्यांकन करेगी जब *बोर्ड पर 5 नियमित रूप से स्थान हैं।

Answer 2

सी # - 536

(ठीक है, यह शायद उस के लिए सबसे उपयुक्त भाषा नहीं है, लेकिन फिर भी ...)

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

प्रारूपित और टिप्पणी की गई:

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

Answer 3

रूबी 1.9 (194, 130)

यह संभवत: खाली स्तंभों की जांच करने का सबसे समझदार तरीका नहीं है, लेकिन यह पहली चीज थी जिसे मैंने करने की कोशिश की थी! विशेष रूप से, यह #transposeबहुत खर्च होता है।

बोर्ड की घोषणा करते समय या तो बोर्ड और संख्याओं या निश्चित चौड़ाई वाले क्षेत्रों के बीच एक रिक्त रेखा बहुत सारे पात्रों को बचाएगी। मैं वास्तव में 5 लाइनों को पढ़ने के लिए एक बहुत अच्छा तरीका नहीं सोच सकता।

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

संपादित करें: भीड़ के पर्ल जवाब से नियमित अभिव्यक्ति तकनीक का उपयोग करते हुए 130 चरित्र समाधान:

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

Answer 4

ओपन सोर्स सॉफ्टवेयर के रूप में रॉल के आसन्न रिलीज की लंबी, लंबी, लंबी अतिदेय घोषणा को देखते हुए , मैं इस बिंगो समस्या को हल करने के लिए अपनी पालतू बोली पर लौट आया । मैं जल्द ही Rebmu को अपने स्वयं के, किशोर GPL पैकेज के रूप में वितरित करने में सक्षम हो सकता हूं। :)

---

रेम्बु 88 अक्षर

कॉम्पैक्ट संकेतन में:

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

बोली एक चाल मैं कॉल का उपयोग करता mushing जिस पर समझाया गया है Rebmu पेज । यह इस अर्थ में "वैध" है कि यह पार्सर को धोखा नहीं देता है; यह Rebol वैध है ... और वास्तव में इसे स्वतंत्र रूप से साधारण कोड के साथ-साथ (अहम) "लॉन्ग-फॉर्म" Rebmu ... से जोड़ा जा सकता है ... जिसमें BTW 141 अक्षर होगा:

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

(यह देखते हुए कि मैं दावा करता हूं कि संपीड़न एक चाल है जिसे कोई स्वचालन या संकलन की सहायता के बिना कर सकता है, मैं वास्तव में कोड को शापित रूप में विकसित करता हूं। यह मुश्किल नहीं है।)

यह वास्तव में काफी सरल है, कुछ खास नहीं - मुझे यकीन है कि अन्य रेबोल प्रोग्रामर चीजों को बंद कर सकते हैं। कुछ टिप्पणी स्रोत GitHub पर है , लेकिन मैं जो मुख्य चाल का उपयोग करता हूं वह एक लंबी श्रृंखला ("सूची", "सरणी", व्हाट्स-यू-यू) में सभी संभव समाधानों का निर्माण करना है। मैं इनपुट लूप के दौरान विकर्ण समाधानों का निर्माण करता हूं, क्योंकि यह सिर पर पांच सम्मिलन लेता है और उन्हें बनाने के लिए पूंछ में पांच जोड़ देता है ... और प्रगति में पहले से ही पांच-पुनरावृत्ति लूप है।

पूरी बात आसानी से रेबोले कोड के लिए मैप करती है, और मैंने अभी तक किसी भी "मैट्रिक्स लाइब्रेरी" को रेम्बु में ट्रांसपोज़िशन या अन्य नौटंकी के साथ नहीं फेंका है जो अक्सर ऊपर आते हैं। किसी दिन मैं ऐसा करूंगा लेकिन अभी मैं केवल रेबोल के माध्यम के अपेक्षाकृत करीब काम करने की कोशिश कर रहा हूं। क्रिप्टिक-दिखने वाली चीजें जैसे:

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

... बल्कि सरल हैं:

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

नोट: कोष्ठक स्पष्टता के लिए ऊपर जोड़ा गया। लेकिन रेबोल प्रोग्रामर (अंग्रेजी बोलने वालों की तरह) आम तौर पर संचार में व्याकरण का संकेत देने के लिए अतिरिक्त संरचनात्मक कॉलआउट के आवेदन से बचते हैं ... बल्कि अन्य अनुप्रयोगों के लिए उन्हें बचाते हैं ...

बस एक अतिरिक्त बोनस के रूप में यह दिखाने के लिए कि यह वास्तव में कितना दिलचस्प है, मैं बोर्ड को योग करने के लिए सामान्य कोड के कुछ मिश्रण में फेंक दूंगा। प्रोग्रामिंग शैलियों वास्तव में हैं ... संगत:

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

यह रेम्बु के रूप में अच्छी तरह से मान्य है, और यह आपके साथ बिंगो खेलने से पहले आपको एक अच्छा बोर्ड योग देगा। दिए गए उदाहरण में, यह कहता है Hey grandma, the board sum is 912। जो शायद सही है। लेकिन आपको बात समझ आ गयी। :)

Answer 5

गणितज्ञ २५०

प्रकटीकरण: मैंने माना कि इनपुट को सूचियों में दिया गया था जो कि गणितज्ञ के लिए उपयोग करने के लिए अधिक स्वाभाविक हैं। इसलिए, bबोर्ड का cप्रतिनिधित्व करने और कॉल का प्रतिनिधित्व करने के साथ ,

b//Grid
c//Column

यदि इनपुट स्ट्रिंग्स में होना था, तो कोड लगभग 30 वर्णों तक बढ़ जाएगा। (मैं बाद में उस भिन्नता को शामिल करूँगा।)

कोड

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++]

बी 7

I29

G60

G51

O71

I23

I16

बिंगो!

Answer 6

अजगर 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!'

उपयोग:

$ ./bingo.py < bingo.txt
B7
I29
G60
G51
O71
I23
I16
BINGO!

Comments

आप rowएक-चार नाम से बदल सकते हैं । अनटाइटेड: कोशिश करें i in'*'*5]और [x=='*']साथ बदलें [x==i]।

— मोनिका

Answer 7

एपीएल (82)

{(D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵:'BINGO!'⋄∇⍵∨B=⍎1↓⎕←⍞}0=B←↑{⍎(K,K)[⍞⍳⍨K←11↑⎕D]}¨⍳5

• {... }¨⍳5: 5 बार करें:
• ⍎(K,K)[⍞⍳⍨K←11↑⎕D]: एक पंक्ति पढ़ें ( ⍞) और सभी वर्णों को मैप करें जो कि अंक या स्थान नहीं हैं 0, फिर रेखा का मूल्यांकन करें।
• B←↑: इसे मैट्रिक्स में बदलें (5x5 यदि इनपुट सही था), और बी में स्टोर करें।
• {... }0=B: शुरुआती बोर्ड में रिक्त स्थान में 1 (0) और अन्य स्थानों में 0 है।
• (D≡(⍵∨⌽⍵)∧D←=/¨⍳⍴⍵)∨∨/(∧⌿⍵)∨∧/⍵: यदि एक रेखा, एक स्तंभ, या एक विकर्ण भरा है:
• 'BINGO!': फिर आउटपुट BINGO
• ∇⍵∨B=⍎1↓⎕←⍞: अन्यथा, एक पंक्ति पढ़ें ( ⍞), इसे प्रतिध्वनि करें ( ⎕←), पहले वर्ण को गिराएं ( 1↓), संख्या प्राप्त करने के लिए इसका मूल्यांकन करें ( ⍎), देखें कि यह बोर्ड पर कहां होता है ( B=), इसे चिह्नित करें ( ⍵∨), और फिर से प्रयास करें ( ∇) ।

Answer 8

के, 114

बोर्ड bऔर कॉल को देखते हुएc

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