33

आपका लक्ष्य यह जांचना है कि एक पूर्ण माइनस्वीपर बोर्ड वैध है या नहीं। इसका मतलब यह है कि प्रत्येक संख्या खदानों की सही संख्या है, जो इसके समीप की कोशिकाओं में है, जिसमें विकर्ण शामिल हैं। बोर्ड चारों ओर नहीं लपेटता है।

हमेशा की तरह , आपको फ़ंक्शन या प्रोग्राम और बाइट्स जीत में सबसे छोटा कोड देना चाहिए।

Minesweeper को उत्पन्न करने , हल करने और पूरी तरह से लागू करने के लिए पिछली चुनौतियों को भी देखें ।

इनपुट:

इस तरह एक एकल स्ट्रिंग 02X2 13X2 X211:।

माइन्सवीपर बोर्ड की पंक्तियों को रिक्त स्थान द्वारा अलग किया गया है। तो, ऊपर 3x4 बोर्ड का प्रतिनिधित्व करता है:

02X2
13X2
X211
प्रत्येक कोशिका एक चरित्र है: Xएक खदान के लिए, या एक संख्या के 0माध्यम से 8।
सभी पंक्तियों की लंबाई समान है।
कम से कम 3 पंक्तियाँ और 3 कॉलम हैं।
इनपुट एक स्थान के साथ शुरू या समाप्त नहीं होता है, लेकिन यदि आप चाहें तो आप अंत में एक नई पंक्ति शामिल कर सकते हैं।

आउटपुट:

सही बोर्डों पर एक सुसंगत सत्य , और गलत बोर्डों पर एक सुसंगत झूठी मूल्य। सुसंगत का अर्थ है कि सभी ट्रू आउटपुट एक समान हैं और सभी फाल्सी आउटपुट समान हैं।

परीक्षण के मामलों

प्रत्येक पंक्ति एक अलग परीक्षण मामला है।

True:

02X2 13X2 X211
XXXX XXXX XXXX XXXX
XX4X2 5X6X4 XX6XX 4XX54 2X4XX

False:

02X2 13X2 X212
XXXX XXXX X7XX XXXX
XX5X2 5X6X4 XX6XX 4XX54 2X5XX

— XNOR
स्रोत

आपको संभवत: निर्दिष्ट करना चाहिए कि सुसंगत मिथ्या आउटपुट सुसंगत सत्य आउटपुट से अलग होना चाहिए ;-)

— जॉन ड्वोरक

@JanDvorak कि उनके द्वारा क्रमशः सत्य और मिथ्या होने का आरोप लगाया जाना चाहिए।

— xnor

ज़रुरी नहीं। "सत्य" और "झूठा" केवल दो लेबल हैं जो आप हमें परिभाषित करने दे रहे हैं। मैं कोई प्रतिबंध नहीं देख सकता कि वे वास्तव में हमारे द्वारा उपयोग की जाने वाली भाषा में क्रमशः सत्य या मिथ्या हैं। एकमात्र शब्द जिसके लिए उन्हें अलग होना पड़ सकता है वह है "संकेत" क्रिया। मुझे यकीन नहीं है कि यह एक युक्ति के रूप में गिना जाता है (यह अभी भी एक मानक खामियों के रूप में निषिद्ध है, हालांकि)।

— जॉन ड्वोरक

4

@JDDvorak 'सच्चाई' और 'झूठा' वास्तव में कुछ सामान्य शब्द हैं अगर मुझे गलती से मूल रूप से उन चीजों का वर्णन करने के लिए उपयोग नहीं किया जाता है (जरूरी नहीं कि बूल) जो बूल के लिए टाइप किए जाने पर सही या गलत का मूल्यांकन करते हैं। उदाहरण के लिए 0 आम तौर पर मिथ्या है और 1 आम तौर पर सत्य है।

— केसाब

1

@JDDvorak नहींं, सत्य / असत्य को सही / गलत का मिलान करना होगा।

— xnor

11

पायथन 2, 132 129 128

def f(s):w=s.find(' ');E=dict(enumerate(s));return all(E[i]in' X'+`sum(E.get(i+d/3*~w+d%3+w,5)>'O'for d in range(9))`for i in E)

मैं enumerateएक गोल्फ में इस्तेमाल किया ... और यहां तक rangeकि एक ही कार्यक्रम में कहीं और इस्तेमाल किया । स्पष्ट रूप से यहां कुछ गलत है।

संपादित करें: dict(enumerate(s))इसके बजाय से अधिक enumerate(s), इसलिए enumerateदो बार बुलाया जाने की आवश्यकता नहीं है।

— feersum
स्रोत

क्या एक चतुर का उपयोग करें ~! और शब्दकोशों को सही ढंग से अनुक्रमित करने के लिए बाहर का काम करना।

— xnor

@xnor ~ऑपरेटर के बारे में आपकी टिप्पणी ने मुझे विडंबना दी कि मैं इसे बिना किसी कारण के दो बार उपयोग कर रहा था, जहाँ केवल एक बार उपयोग करने से यह स्पष्ट रूप से एक ही बात को पूरा करेगा। मुझे लगा कि डिक्शनरी का हिस्सा मज़ेदार था, धन्यवाद।

— feersum

9

पायथ, ४३

Jhxzd!f-@zT+" X"`sm/:+*JNztd+d2\Xm+T*kJU3Uz

कोशिश करो यहाँ ।

स्पष्टीकरण:

Jhxzd: यह इनपुट + 1 में पहले स्थान का स्थान है (z इनपुट में, dस्थान है।) यह बोर्ड पर लंबवत आसन्न कोशिकाओं के बीच इनपुट में पृथक्करण है।
!f: यह !एक फिल्टर का तार्किक नहीं है ( )f , जो कि Trueतभी होगा और यदि अभिव्यक्ति अनुक्रम के हर तत्व के लिए गलत है।
-@zT: स्थान पर चरित्र ले लो T इनपुट से (लैम्ब्डा चर) पर ले जाएं, और किसी भी प्रकार के दिखावे को हटा दें: (यह सत्य होगा यदि चरित्र को हटाया नहीं गया है, और गलत है अगर यह है।
+" X": अंतरिक्ष, एक्स, और निकालें
`: से पुनर्प्राप्त
sm: करने के लिए मानचित्र का योग
/ \X: में "X" की गिनती
:+*JNz: इनपुट का टुकड़ा द्वारा उपसर्ग J डमी पात्रों
td+d2: D-1 से d + 2 तक।
m+T*kJU3: [टी, टी + जे, टी + 2 * जे] में डी के लिए।
UzT में के लिए range(len(input))।

— isaacg
स्रोत

7

डाउनवोटर्स: डाउनवोट्स क्यों?

— इसहाक

7

APL (NARS2000) (74)

{~0∊(G>9)∨G=(⍴G)↑{+/∊9<⍵∘⌷¨G∘.⊖(G←2-⍳3)∘.⌽⊂Z}¨⍳⍴Z←G↑⍨2+⍴G←¯1+⎕D⍳⊃⍵⊂⍨⍵≠' '}

इसके अलावा ⎕MLसेट करने पर Dyalog APL में काम करता है 3।

स्पष्टीकरण:

⊃⍵⊂⍨⍵≠' ': ⍵रिक्त स्थान पर विभाजित करें और मैट्रिक्स बनाने के लिए सूचियों का उपयोग करें।
G←¯1+⎕D⍳: ⎕Dप्रत्येक मान के लिए इंडेक्स ढूंढें , 1 घटाएं, और इसमें स्टोर करें G। ( ⎕Dअंक शामिल हैं, कोई भी गैर-अंक में बदल जाएगा 10)।
Z←G↑⍨2+⍴G: रैपराउंड से निपटने के लिए, मैट्रिक्स के किनारे पर दो लाइनें और शून्य के कॉलम जोड़ें
{... }¨⍳⍴Z: प्रत्येक स्थिति के लिएZ , उस स्थिति के मूर पड़ोस में बमों की मात्रा ज्ञात करें:
- G∘.⊖(G←2-⍳3)∘.⌽⊂Z: Zबाएँ, दाएँ, ऊपर, नीचे, बाएँ-दाएँ, दाएँ-बाएँ, बाएँ-दाएँ, और दाएँ-बाएँ घुमाएँ ।
- ⍵∘⌷¨: इनमें से प्रत्येक के लिए, ⍵इन घुमाए गए मैट्रिक्स में से प्रत्येक में तत्व को ढूंढें
- +/∊9<: गिनें कि कितने तत्व 9 से अधिक हैं (यह बम की मात्रा है)।
(⍴G)↑: फिर से शून्य की अतिरिक्त लाइनों को हटा दें,
G=: जांचें कि क्या प्रत्येक तत्व Gउस स्थिति के आसपास बमों की मात्रा के बराबर है (यह सभी गैर-बम वर्गों के लिए सच होना चाहिए)
(G>9)∨: और जांच में तत्वों है कि क्या Gतुलना में अधिक है 9(ये बम हैं)।
~0∊: 1यदि परिणामस्वरूप मैट्रिक्स में कोई शून्य (= सभी वर्ग या तो बम या सही संख्या नहीं है), और 0यदि ऐसा होता है , तो वापस लौटें ।

— मारीनस
स्रोत

क्या आपने बाइट्स या वर्णों की गणना की है? आपको बाइट्स गिनना चाहिए।

— टिम एस।

5

@ समय: 1-बाइट एपीएल एनकोडिंग का भार है, यहाँ एक है ।

— मारिनस

5

सी#, 321 320 305

bool s(string B){var L=B.Split(' ').Select(s=>' '+s+' ').ToList();var b=new string(' ',L[0].Length);L.Insert(0,b);L.Add(b);Func<int,int,IEnumerable<int>>E=Enumerable.Range;return E(1,b.Length-2).All(x=>E(1,L.Count-2).All(y=>L[y][x]=='X'||L[y][x]-'0'==E(x-1,3).Sum(X=>E(y-1,3).Sum(Y=>L[Y][X]=='X'?1:0))));}

पहले कुछ भी गोल्फ का प्रयास करें, और मुझे पता है कि C # आदर्श भाषा नहीं है।

मुझे आशा है कि एक इंस्टेंस विधि लिखने की अनुमति है, अन्यथा इसके लिए एक और 7 वर्ण जोड़ें static।

बाहर स्थान:

bool s(string B) {
    var L = B.Split(' ').Select(s => ' ' + s + ' ').ToList();
    var b = new string(' ', L[0].Length);
    L.Insert(0, b);
    L.Add(b);
    Func<int, int, IEnumerable<int>> E = Enumerable.Range;
    return E(1, b.Length - 2).All(x =>
        E(1, L.Count - 2).All(y =>
            L[y][x] == 'X' ||
            L[y][x] - '0' == E(x - 1, 3).Sum(X =>
                E(y - 1, 3).Sum(Y =>
                  L[Y][X] == 'X' ? 1 : 0))));
}

Linq का उपयोग छोरों की तुलना में कुछ जगह बचाता है, लेकिन यह डीबग करना कठिन है।

मैंने कुछ चीजें सीखी जैसे char => intकि घटाना द्वारा परिवर्तित करना'0' ।

ऐसा लगता है कि बोर्ड को रिक्त स्थान के साथ पैड करना आसान था, इसलिए इस पर चलना आसान होगा।

— कार्ल वाल्श
स्रोत

1

आप की जगह सिर्फ नहीं कर सकते -'0'के साथ -48। मेरे लिए काम करता है और विभिन्न 'एक्स' और '' के लिए कुछ बाइट्स बचाता है

— रोमन ग्रैफ़

5

अजगर 2, 121

def f(B):n=B.find(' ')+1;R=range(len(B));print all(B[I]in' X'+`sum(2>I%n-i%n>-2<I/n-i/n<2<B[i]>'W'for i in R)`for I in R)

यह झगड़े के जवाब से काफी हद तक प्रेरित है । दिन का क्रम ओवरकिल है: सेल के 9 पड़ोसियों में खानों की जांच करने के बजाय, यह देखने के लिए हर एक सेल की जांच करें कि क्या यह पड़ोसी की खान है।

हम जाँच लें कि दो कोशिकाओं के साथ पड़ोसी हैं 2>r>-2<c<2, जहां rऔर cकोशिकाओं की पंक्ति और स्तंभ मतभेद, के बराबर हैं {r,c}<{-1,0,1}। ये निर्देशांक सेल सूचकांकों Iऔर iजैसे c=I%n-i%nऔर से गणना किए जाते हैं r=I/n-i/n। सूचियों की सूची की तरह इसे 2 डी ऑब्जेक्ट में बदलने के लिए सीधे स्ट्रिंग और एक्स्ट्रेक्ट्स इंडेक्स और कॉलम को इंडेक्स करना अधिक कुशल है। मेरा चेक B[i]>'W'यहाँ के बराबर है B[i]=='X'।

उपयोग enumerateकरने से बदसूरत पर दो पात्रों को बचाया जा सकता है range(len(B))सिवाय इसके कि वह एक पुनरावृत्त वस्तु लौटाता है जो इसके माध्यम से दो नेस्टेड छोरों का समर्थन नहीं करता है।

— XNOR
स्रोत

मुझे लगता है कि एक नकारात्मक मापांक n के लिए काम करना चाहिए; तब आप उपयोग कर सकते हैं ~B.find।

— feersum

@ फ़ेर्सुम दुर्भाग्य से, यह गड़बड़ करता है /क्योंकि यह नकारात्मक को भी नीचे की ओर गोल करता है।

— xnor

4

अजगर 2, 140

s=input();w=s.index(' ')+1
print all(c in'X 'or(int(c)==sum(s[max(0,a-1):max(0,a+2)].count('X')for a in[i-w,i,i+w]))for i,c in enumerate(s))

— KSab
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 135 133 125 122

f=s=>s.split(" ")[e="every"]((l,i,a)=>[...l][e]((c,j)=>!(-[-1,0,k=1][e]((y,m,q)=>q[e](x=>k+=(a[i+y]||0)[j+x]=="X"))-c+k)))

स्ट्रिंग के रूप में फ़ंक्शन को इनपुट प्रदान करें:

f("XX4X2 5X6X4 XX6XX 4XX54 2X4XX");

स्पष्टीकरण के लिए, नीचे पुराना संस्करण देखें। नया संस्करण forलूप को everyकॉल के साथ बदलता है , और इसके बजाय e="every"करने के लिए चर का उपयोग करता someArray[e](...)हैsomeArray.every(...) ।

इसके अलावा, काउंटर kको अब अनुक्रमित किया गया है 1ताकि लूप को चालू k+=...रखने के लिए अभिव्यक्ति हमेशा सत्य हो every। हम परिणाम 1को घटाकर उस अतिरिक्त को समाप्त करते हैं true(जो कि संख्यात्मक रूप से coerces 1) everyऑपरेशन द्वारा लौटाया जाता है [-1,0,k=1][e](...)।

पुराना संस्करण:

f=s=>s.split(" ").every((l,i,a)=>[...l].every((c,j)=>{q=[-1,k=0,1];for(y of q)for(x of q)k+=(a[i+y]||0)[j+x]=="X";return c=="X"||k==c}))

रिक्त स्थान और टिप्पणियों के साथ कोड:

f=s=>s.split(" ")                 // split on spaces
      .every((l,i,a)=>             // for every line
                                   //     l: line string, i: line number, a: whole array
          [...l].every((c,j)=>{    // for every character
                                   //     c: character, j: index in string
              q=[-1,k=0,1];        // define counter k=0 and q=[-1,0,1]
              for(y of q)          // use q to loop adjacent spaces
                  for(x of q)

                      k+=              // add the following boolean to k:

                          (a[i+y]      //   from line number i+y...
                                 ||0)  //   (or a dummy zero, to prevent lookups on undefined)
                          [j+x]        //   ...get index j+x from the above value...
                                =="X"; //   ...and compare it to "X"

              return !(k-c)     // after the loop, this character passed if
                                // the char equals the number of counted X's (so k-c is 0)
                                // or it is an X itself (so `k-c` is NaN)
          })
      )

जावास्क्रिप्ट everyसरणी विधि कॉलबैक लेती है और कॉलबैक को सरणी के हर तत्व पर लागू करती है। यदि कोई कॉलबैक एक गलत मान देता है, तो everyकॉल लौटाता है false।

जेएस में बूलियन को जोड़ के 1 या 0 के लिए मजबूर किया जाता है। प्रत्येक आसपास के स्थान के लिए, हम इसके मूल्य की तुलना करने के बूलियन परिणाम को "जोड़ते हैं" Xऔर फिर उस मूल्य को kअभिव्यक्ति में काउंटर पर जोड़ते हैं k += (... == "X")। इसलिए, kआसपास के Xएस की संख्या की एक संख्या शामिल है , क्योंकि के trueरूप में गिना जाता है 1और के falseरूप में मायने रखता है 0।

— apsillers
स्रोत

c=="X"कोशिश के बजाय !c/1, जो आपको बाइट्स की एक जोड़ी की बड़ी मात्रा में बचाता है! यदि यह विफल रहता है, तो प्रयास करें !!c/1। तर्क यह है कि 'X'/1 => NaN, और NaNझूठा है। आप जाँच करें कि c=='X', क्यों नहीं की जाँच करने की कोशिश अगर यह नहीं है false?

— इस्माइल मिगुएल

@IsmaelMiguel वही मूल्यांकन (!c)/1करता है, जो मदद नहीं करता है, दुर्भाग्य से; मुझे इसके लिए कोष्ठक की आवश्यकता होगी !(c/1), जिसकी लागत 2. इसके अलावा, 0/1गलत है, इसलिए अमान्य इनपुट " 0X" का गलत परिणाम होगा true। सबसे अच्छा मैं अभी भी कर सकता हूं जबकि शून्य का सम्मान करना दो स्थितियों को एक नकारात्मक वाक्यांश में संयोजित करना है, जैसे !(+c+1&&k-c), लेकिन यह वही लंबाई है जो मेरे पास पहले से है।

— अप्सिलर्स

@IsmaelMiguel मुझे इसके बारे में सोचने के लिए धन्यवाद, हालांकि - मैंने महसूस किया है कि !(k-1-c)दोनों स्थितियों का परीक्षण करता है, क्योंकि यदि kमैच c(शून्य से 1 ऑफसेट) है, तो नकार 0सही बनाता है, और यदि cकोई संख्या नहीं है, तो हम प्राप्त करते हैं NaNऔर नकार देते हैं। भी है true।

— अप्सिलर्स

तुम सच में भूखे थे! आप प्रारंभिक कोड के बाद से 10 बाइट्स खा गए! मैं वास्तव में आपके साथ आए समाधान को पसंद करता हूं। आपके समाधान के लिए +1!

— इस्माइल मिगुएल

3

सीजेएम, 70 65 63 बाइट्स

1l_S#):L)S*+:Q{Ii33/2%[0~1LL)L(L~)L~_))]W):Wf+Qf='X/,(scI==&}fI

यह बहुत गोल्फ हो सकता है।

देता है 1एक वैध बोर्ड के लिए और 0गलत बोर्ड के लिए।

परीक्षण के मामलों

{-1:W;
1l_S#):L)S*+:Q{Ii33/2%[0~1LL)L(L~)L~_))]W):Wf+Qf='X/,(scI==&}fI
}6*]N*

इनपुट

02X2 13X2 X211
XXXX XXXX XXXX XXXX
XX4X2 5X6X4 XX6XX 4XX54 2X4XX
02X2 13X2 X212
XXXX XXXX X7XX XXXX
XX5X2 5X6X4 XX6XX 4XX54 2X5XX

उत्पादन

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

3

जावास्क्रिप्ट (ईएस 6) 98

स्ट्रिंग के प्रत्येक चरित्र के लिए एक फ़ंक्शन लागू करने के लिए कुछ का उपयोग करना ।
फलन लौटता है

अगर खाली है तो गलत है
NaN यदि 'X' (बार-बार गैर संख्यात्मक अंक से मान घटाता है जैसे 'X' NaN देता है)
0 का सांख्यिक मान यदि सही संख्या में 'X' है, तो दूसरा 0.
आंतरिक चेक केवल मानचित्र का उपयोग करके बनाया गया है क्योंकि यह forach से छोटा है

पहले सत्य मूल्य (इस मामले में, नॉनज़रो) में कुछ रिटर्न सही हैं, जिसका अर्थ है एक विफल चेक। परिणाम एक अधिक पहचानने योग्य सच / गलत देने के लिए नकारा जाता है।

F=v=>![...v].some(
  (x,p)=>x!=' '&&[1,-1,l=v.search(' '),-l,++l,-l,++l,-l].map(q=>x-=v[p+q]=='X')|x
)

फायरफॉक्स / फायरबग कंसोल में टेस्ट

;["02X2 13X2 X212","XXXX XXXX X7XX XXXX","XX5X2 5X6X4 XX6XX 4XX54 2X5XX"
,"02X2 13X2 X211","XXXX XXXX XXXX XXXX","XX4X2 5X6X4 XX6XX 4XX54 2X4XX","111 1X1 111"]
.forEach(t => console.log(t, F(t)))

उत्पादन

02X2 13X2 X212 false
XXXX XXXX X7XX XXXX false
XX5X2 5X6X4 XX6XX 4XX54 2X5XX false
02X2 13X2 X211 true
XXXX XXXX XXXX XXXX true
XX4X2 5X6X4 XX6XX 4XX54 2X4XX true
111 1X1 111 true

— edc65
स्रोत

1

आर, 156 चार

a=b=do.call(rbind,strsplit(scan(,""),""));for(i in 1:nrow(a))for(j in 1:ncol(a))b[i,j]=sum(a[abs(i-row(a))<2&abs(j-col(a))<2]=="X");v=a!="X";all(b[v]==a[v])

क्षतिपूर्ति के लिए इंडेंट, स्पेस और लाइन ब्रेक के साथ:

a = b = do.call(rbind,strsplit(scan(,""),"")) #Reads stdin and turn into a matrix
for(i in 1:nrow(a)) #Ugly, ugly loop
    for(j in 1:ncol(a))
        b[i,j] = sum(a[abs(i-row(a))<2 & abs(j-col(a))<2]=="X")
v = a!="X"
all(b[v]==a[v])

उदाहरण:

> a=b=do.call(rbind,strsplit(scan(,""),""));for(i in 1:nrow(a))for(j in 1:ncol(a))b[i,j]=sum(a[abs(i-row(a))<2&abs(j-col(a))<2]=="X");v=a!="X";all(b[v]==a[v])
1: XX4X2 5X6X4 XX6XX 4XX54 2X4XX
6: 
Read 5 items
[1] TRUE
> a=b=do.call(rbind,strsplit(scan(,""),""));for(i in 1:nrow(a))for(j in 1:ncol(a))b[i,j]=sum(a[abs(i-row(a))<2&abs(j-col(a))<2]=="X");v=a!="X";all(b[v]==a[v])
1: XXXX XXXX XXXX XXXX
5: 
Read 4 items
[1] TRUE
> a=b=do.call(rbind,strsplit(scan(,""),""));for(i in 1:nrow(a))for(j in 1:ncol(a))b[i,j]=sum(a[abs(i-row(a))<2&abs(j-col(a))<2]=="X");v=a!="X";all(b[v]==a[v])
1: XX5X2 5X6X4 XX6XX 4XX54 2X5XX
6: 
Read 5 items
[1] FALSE

— plannapus
स्रोत

एक माइनस्वीपर बोर्ड को सत्यापित करें

पायथन 2, 132 129 128

पायथ, ४३

APL (NARS2000) (74)

सी#, 321 320 305

अजगर 2, 121

अजगर 2, 140

जावास्क्रिप्ट (ईएस 6), 135 133 125 122

सीजेएम, 70 65 63 बाइट्स

जावास्क्रिप्ट (ईएस 6) 98

आर, 156 चार