एक क्षैतिज ASCII पालतू सांप का सत्यापन

Question

हाल ही में वहाँ ASCII पालतू साँप चुनौतियों का एक जोड़ा गया है (जैसे यहाँ )

            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   

यह चुनौती बेतरतीब ढंग से उत्पन्न क्षैतिज पालतू साँप (पाँच लाइनों की ऊँचाई, 30 की लंबाई) लेना है, और यह सत्यापित करना है:

• प्रत्येक स्तंभ में केवल एक है 0
• प्रत्येक पहले और उसके बाद 0"जुड़ा हुआ है" 0(केवल 0 या 1 पंक्ति द्वारा लंबवत रूप से स्थान दिया गया है)

अंतिम आउटपुट हो सकता है trueया 1यदि साँप वैध है, falseया 0यदि साँप अमान्य है

संपादित-स्पष्टीकरण

इनपुट मानें:

• एक तार है
• केवल '', '0' और '\ n' शामिल हैं
• प्रत्येक पंक्ति में ठीक 30 वर्ण हैं
• बिल्कुल 5 लाइनें हैं

यानी सत्यापित करें कि क्या सांप जुड़ा हुआ है, और कोई आवारा चरखा नहीं है। उस "कैनवास" को मान्य करने की आवश्यकता नहीं है जिस पर सांप मुद्रित है।

Comments

नमस्ते और पीपीसीजी में आपका स्वागत है :) यह पहली पोस्ट के लिए एक अच्छी चुनौती है, लेकिन आप शायद कुछ और परीक्षण मामलों को जोड़ना चाहते हैं जो कि सरल झीलों को पकड़ते हैं। आप शायद यह भी तय करना चाहेंगे कि क्या साँप को शून्य द्वारा दर्शाया जाना है या कोई भी चरित्र हो सकता है। भविष्य में, सैंडबॉक्स का उपयोग करने पर विचार करें । शुभकामनाएँ :)

— FryAmTheEggman

क्या इसे स्टिंग के रूप में लिया जाता है? या यह एक 2d सरणी के रूप में इनपुट हो सकता है?

— 1

क्या हम गारंटी देते हैं कि इनपुट में 0 और स्थान शामिल हैं? कि हर लाइन की लंबाई 30 है? कि 5 लाइनें हैं?

— xnor

चूंकि यह एक निर्णय-समस्या है कि truthy/falseyबजाय इसके बारे में कैसे true/false?

— जोनाथन एलन

@ जेश्चिफ़ मुझे यकीन है कि एक सांप बाइट्स है?

— मारियो

Answer 1

जावास्क्रिप्ट (ES2018), 62 54 बाइट्स

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

इनपुट एक स्ट्रिंग है:

• नई लाइन के बिना
• केवल स्थान, '0' और '\ n' होते हैं
• 30 वर्ण प्रत्येक पंक्ति, 5 रेखाएँ, कुल 154 वर्ण

फ्लैग का sमतलब होता है एक डॉट मैच कुछ भी ('\ n' सहित)। यह सुविधा वर्तमान में कॉम्पिटिटर -टेबल के आधार पर क्रोम 63+, ओपेरा 50+, सफारी 11.1+ द्वारा समर्थित है । आप इन समर्थित ब्राउज़र के साथ इस फ़ंक्शन का परीक्षण कर सकते हैं। यदि आपका ब्राउज़र इस सुविधा का समर्थन नहीं करता है तो आपको पेज लोड करते समय एक अपवाद मिलेगा।

यह काम किस प्रकार करता है:

• कोई कॉलम नहीं के साथ 0:
  • मेल नहीं खाता /( .{30}){4} /
• 0एक कॉलम में कोई दो नहीं :
  • मेल नहीं खाता /0.{30}(.{31})*0/
• कोई 0अपने पड़ोसियों से कनेक्ट नहीं:
  • मेल नहीं खाते /0.{60}(.{31})*0/,/0.{62}(.{31})*0/

इन सभी regex को मिलाएं, और आपको अंत में यह मिल जाएगा।

f =

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

<textarea id=i style="width:100%;height:100px">            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   </textarea>
<button onclick="o.value=f(i.value.slice(0,154))">Validate</button>
Result: <output id=o></output>

मार्टिन एंडर के लिए धन्यवाद कि एक भी !ऑपरेटर 8 बाइट बचा सकता है।

Answer 2

स्नेकएक्स , 51 बाइट्स

यह स्पष्ट रूप से कार्य के लिए सही भाषा है। : ^ डी

s:({c<L>}{c<R>}0[(<R> <L>)(<L> <R>)_?])%{30}
c:0 *$

यदि यह एक वैध साँप है तो पूरे इनपुट से मेल खाता है; यदि यह नहीं है तो मैच में विफल रहता है। यहाँ कोशिश करो!

व्याख्या

SnakeEx एक 2-D पैटर्न से मेल खाने वाली भाषा है । एक कार्यक्रम में "सांप" के लिए परिभाषाओं की एक सूची होती है, जो कि इनपुट मिलान वाले पात्रों के चारों ओर क्रॉल करते हैं, दिशा बदलते हैं, और अन्य सांपों को पैदा करते हैं। हमारे कार्यक्रम में, हम दो सांपों को परिभाषित करते हैं, sऔर c।

हम शुरू करेंगे cक्योंकि यह सरल है। इसकी परिभाषा है 0 *$, जो काफी पठनीय होनी चाहिए यदि आप रेगेक्स जानते हैं: मैच 0, इसके बाद शून्य या अधिक रिक्त स्थान, इसके बाद ग्रिड के किनारे। यहां मुख्य पकड़: यह मिलान किसी भी दिशा में आगे बढ़ सकता है। हम cसाँप से ऊपर और नीचे दोनों का उपयोग करने जा रहे हैं , यह सत्यापित करने के लिए कि 0प्रत्येक कॉलम में कोई अतिरिक्त s नहीं हैं ।

अभी मुख्य साँप के लिए, s। यह रूप लेता है (...)%{30}, जिसका अर्थ है "30 बार कोष्ठक की सामग्री से मेल खाता है" - 0सांप में प्रत्येक के लिए एक बार । अब तक सब ठीक है। कोष्ठक के अंदर क्या जाता है?

{c<L>}

इसने एक नए cसाँप को जन्म दिया, 90 डिग्री पर छोड़ दिया। दिशा sसाँप की दिशा के सापेक्ष है , इसलिए नया साँप ग्रिड के शीर्ष की ओर बढ़ता है (मुख्य साँप दाईं ओर बढ़ रहा है)। cसाँप की जाँच करता है कि मौजूदा ग्रिड सेल एक है 0और है कि यह ऊपर हर कोशिका एक जगह नहीं है। यदि यह विफल रहता है, तो पूरा मैच विफल हो जाता है। यदि यह सफल होता है, तो हम जारी रखते हैं

{c<R>}

जो एक ही काम करता है, केवल दाएं मुड़ता है (ग्रिड के नीचे की ओर)।

ध्यान दें कि ये स्पॉन मुख्य साँप में मैच पॉइंटर की स्थिति को प्रभावित नहीं करते हैं। वे रेगेक्स में लुकहैड्स की तरह हैं। (शायद यहाँ हम उन्हें "लुक्सबस" कह सकते हैं?) इसलिए यह सत्यापित करने के बाद कि हम एक ओर इशारा कर रहे हैं 0और बाकी कॉलम में केवल रिक्त स्थान हैं, हमें वास्तव में मेल खाना चाहिए 0:

0

अब मैच पॉइंटर दायीं ओर के चरित्र पर है 0। हमें तीन अलग-अलग विकल्पों की जाँच करने की आवश्यकता है: साँप कोण नीचे, साँप कोण ऊपर, या साँप सीधा जाता है। इसके लिए, हम एक या अभिव्यक्ति का उपयोग कर सकते हैं:

[...]

हमारे OR के अंदर, हमारे पास तीन संभावनाएँ हैं:

(<R> <L>)

दाएं मुड़ें, एक स्थान से मेल खाएं, और बाईं ओर फिर से मुड़ें (साँप कोण नीचे)।

(<L> <R>)

बाएं मुड़ें, एक स्थान से मेल खाएं, और दाहिनी ओर फिर से मुड़ें (साँप कोण ऊपर)।

_?

मैच शून्य या एक अंडरस्कोर। चूंकि इनपुट में कोई अंडरस्कोर नहीं हैं, यह हमेशा एक खाली मैच होगा (सांप सीधे चला जाता है)।

उपरोक्त तीन विकल्पों में से एक के मिलान के बाद, मैच पॉइंटर को 0अगले कॉलम में इंगित किया जाना चाहिए , कोष्ठक अभिव्यक्ति को फिर से मैच करने के लिए तैयार।

Answer 3

सीजेएम , 35 34 बाइट्स

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}

इसे ऑनलाइन आज़माएं! इनपुट वर्णों के सरणियों का एक आयताकार सरणी है। केवल इनपुट शामिल हैं और 0।

स्पष्टीकरण:

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}   Function taking a character matrix:
 z                                      Transpose.
   {      }%                            Consider whether each row
      e=                                  contains
        1=                                exactly one
    '0                                    of the character '0'.
            :*                            This must be true for every row.
                  #                     Next, find the position
               '0                         of the character '0'
                 f                        at every row
  _           \                           in the original input.
                       :-               Find the differences between
                      :                   each
                   2                      pair
                    ew                    of adjacent elements (in other words, compute
                                            the increments).
                                        For the snake to be valid, this array of increments
                                            must only contain {0, 1, -1}, so
                              -         Remove from this list
                         [   ]            the elements
                          W                 -1,
                           0                0,
                            X               and 1,
                               !          and then check whether the array is empty.
                                *       The previous code tested two different properties
                                          of the matrix; they both must be true for a
                                          valid snake.

Answer 4

05AB1E , 18 बाइट्स

ζDε0k}¥Ä2‹sεþg}ìPΘ

इसे ऑनलाइन आज़माएं!

व्याख्या

ζ                    # transpose
 D                   # duplicate
  ε  }               # for each row in the first copy (column of input)
   0k                # get the index of the first 0
      ¥Ä             # calculate absolute delta's
        2‹           # check that each is less than 2
          sε  }      # for each row in the second copy (column of input)
            þg       # calculate the length of the string with non-digits removed
               ì     # concatenate the lists
                P    # calculate product
                 Θ   # truthify (turn false values to 0)

Answer 5

भूसी , 12 बाइट्स

नियम स्पष्टीकरण के आधार पर, 11 बाइट्स या 13 बाइट्स हो सकते हैं ।

±Λ=;1Ẋ×≈mηfT

इसे ऑनलाइन आज़माएं!

इनपुट केवल रिक्त स्थान और 0s वाली लाइनों की एक सूची है; यदि एक एकल स्ट्रिंग की आवश्यकता होती है, ¶तो प्रोग्राम को लाइनों में विभाजित करने के लिए तैयार करें। TIO लिंक स्पष्टता के लिए पहले से ही ऐसा करता है। आउटपुट 0 या 1 है; यदि कोई झूठा और सत्य मान ठीक है, तो ±उसे हटाया जा सकता है।

व्याख्या

±Λ=;1Ẋ×≈mηfT  Implicit input: a list of lines.
           T  Transpose into list of columns.
        m     For each column,
         ηf   get list of indices of truthy elements.
              In Husk, whitespace characters are falsy and other are truthy,
              so this gets us the indices of 0s on each column.
     Ẋ        For each adjacent pair of these index lists,
      ×       for all pairs drawn from the two lists,
       ≈      give 1 if they differ by at most 1, otherwise 0.
              For each adjacent pair, this produces a list of 1s and 0s.
 Λ            Do all of these lists
  =;1         equal [1]? Return either 0 or 30 (length of the outer list + 1).
±             Signum; convert to 0 or 1.

यह विचार करने के लिए उपयोग किया ×≈जाता है कि (क) सभी कॉलमों में ठीक एक 0 है, और (बी) उनकी स्थिति सबसे अलग है। एक उदाहरण के रूप में, 8-स्तंभ इनपुट पर विचार करें

0  0  0 
 000 0  
  00   0

सबसे पहले, mηfTइसे सूचकांक सूची की सूची में बदल देता है

[[1],[2],[2,3],[1,2,3],[],[2],[1],[3]]

फिर Ẋ×≈देता है

[[1],[1,1],[1,1,0,1,1,1],[],[],[1],[0]]

प्रत्येक 1सूचकांकों की एक जोड़ी से मेल खाता है जो कि अधिकतम 1 से भिन्न होता है, और प्रत्येक 0जोड़े से मेल नहीं खाता है। [1]जब दोनों सूचियों में एक इंडेक्स होता है, तो प्रत्येक परिणाम ठीक-ठीक मिलता है और सूचकांकों में सबसे अधिक 1 होता है।

Answer 6

पायथन 2 , 71 बाइट्स

f=lambda s:s[1]<' 'or'0'in s[::31]in' %s '%s[1::31]in'%6s'%0*2*f(s[1:])

इसे ऑनलाइन आज़माएं!

मल्टीलाइन स्ट्रिंग के रूप में इनपुट लेता है। बब्बल से टेस्ट का मामला ।

पहले कॉलम के रूप में s[::31]और दूसरे के रूप में निकाला जाता है s[1::31], और उन्हें वैधता के लिए जांचा जाता है। हम sपहले चरित्र को हटाने पर पुनर्विचार करते हैं , जिससे स्तंभों के क्रमिक जोड़े की जाँच की जा सकती है।

दो स्तंभों के लिए inचेक कई चेक के संयोजन के लिए पायथन की तुलना श्रृंखलन का उपयोग करता है:

• '0'in s[::31] जाँचता है कि पहले कॉलम में कम से कम एक है 0
• s[::31]in' %s '%s[1::31]जाँच करता है कि पहला कॉलम दो स्थानों के बीच दूसरे कॉलम सैंडविच का एक विकल्प है, जो 0अधिकांश स्थान पर स्थानांतरित की गई स्थिति को सुनिश्चित करता है
• ' %s '%s[1::31]in'%6s'%0*2जाँचता है कि दूसरे कॉलम में सबसे अधिक एक है 0।

अंत *f(s[1:])भी पुनरावर्ती मामले को सच होने के लिए मजबूर करता है।

Comments

अब जब मैं इसके बारे में सोचता हूं, तो पायथन इन "साँप" चुनौतियों के लिए एक भयानक भाषा है। : पी

— मूंछें

Answer 7

सी (जीसीसी) ,246 245 232 215 212 बाइट्स

#define F)exit(1);
#define L for(i=l=0;i<30;i++)
#define X b[7][i]
char b[8][31];k,j,l;main(i){for(;j++<5;){gets(b);L{if(i[*b]>47){if(X++F memset(b[j+1]+i-1,l=1,3);}else if(!X&b[j][i]F}k+=!!l;}if(k<5 F L if(!X F}

इसे ऑनलाइन आज़माएं!

समझ गया कि मैं अपनी पसंदीदा भाषा इस पर ले जाऊंगा (भले ही मैं कई अन्य से देख सकता हूं, छोटी प्रविष्टियां जो शायद इस तरह की चुनौती के लिए आदर्श से बहुत दूर हैं) और सी क्या मैं प्रबंधित कर सकता था। समस्या के लिए कार्यक्रम का दृष्टिकोण अपेक्षाकृत सरल है, बस बहुत सारे बाइट पेनी-पिंचिंग के साथ; यह साँप को स्टैडिन पर ले जाता है और मुख्य के वापसी मूल्य में अपना परिणाम देता है (इस प्रकार निकास कोड;जैसा कि समस्या में अनुरोध किया गया है 0 एक अमान्य सांप और 1 वैध को इंगित करता है, भले ही बाहर निकलने वाले कोड के लिए अजीब होएक्ज़िट कोड के लिए विशिष्ट के रूप में 0 एक वैध साँप है और 1 एक अमान्य साँप है)। मैक्रोज़ के विस्तार और कुछ अच्छे व्हाट्सएप के साथ यह निम्नलिखित की तरह दिखता है:

char b[8][31];l,j,k;                           //Declares a buffer to work in, initialized all to 0; l j and k default to int and as globals are init to 0
main(i) {                                      //This is run no-args, so argc is 1 and the undeclared type defaults to int.
  for (; j++ < 5;) {                           //Iterating over each row, 1-indexed for convenience accessing the buffer
    gets(b);                                   //Reads into b[0] because of stack array decl layout
    for (i = l = 0; i < 30; i++) {             //j and l both init each time we begin this overall loop
      if (i[*b] > 47) {                        //Did we read a zero?
        if(b[7][i]++) exit(1);                 //If the snake already had a zero in this column, fail out
        memset(b[j+1] + i-1, l = 1, 3);        //Expect them on the next row in the columns left and right of this one (also set l)
      } else if (!b[7][i] & b[j][i]) exit(1);  //If we didn't read a zero, and we had reason to expect one this row, and there wasn't already a zero in this column, fail out
    }
    k+=!!l;                                    //Adds 1 to k iff l is nonzero 
  } if (k < 5) exit(1);                        //If less than 5 rows had zeroes in them, fail out
  for(i = l = 0 ; i < 30; i++) {               //l isn't relevant in this loop but saves some bytes when sharing a macro with the other horizontal loop
    if(!b[7][i]) exit(1);                      //If any columns didn't have zeroes, fail out
  }                                            //Else, snake is valid. main default returns 0.
}

इनपुट की पंक्तियों को बफर की पहली पंक्ति में पढ़ा जाता है, अगले पांच ट्रैकिंग के लिए हैं कि किन स्थानों से उम्मीद की जाती है (पढ़ें: अवश्य) प्रत्येक वर्तमान के बाद की पंक्ति में शून्य होना चाहिए, और अंतिम ट्रैकिंग के लिए है कि क्या शून्य पहले से ही है किसी दिए गए कॉलम में, किसी भी पंक्ति में पढ़ा जा सकता है। कार्यक्रम बदले में प्रत्येक पंक्ति को संसाधित करता है।

यह बिल्कुल मजबूत नहीं है ( gets()केवल शुरुआत है) और इनपुट में सभी प्रासंगिक रिक्त स्थान (उदाहरण के लिए कोई बाएं-पीछे की व्हाट्सएप) नहीं होना चाहिए, और जीडीएस की चेतावनी और stdlib कार्यक्षमता के बारे में नोटों को स्पष्ट रूप से घोषित किया गया है और इसलिए, लेकिन, सी जीवन।

यह भी मानता है कि साँप के सिर को केंद्र की पंक्ति में नहीं होना चाहिए, और यह कि एक वैध साँप को हर पंक्ति में कम से कम एक शून्य होना चाहिए (यानी 5 इनपुट पंक्तियों में सभी स्थानों की कोई पंक्तियाँ नहीं)। यदि उत्तरार्द्ध की आवश्यकता नहीं है, तो इसे थोड़ा कम किया जा सकता है - कार्यक्रम में kऔर उसके साथ करने के लिए सब कुछ किया lजा सकता है या उस मामले में कोड के कम बाइट्स के साथ प्रतिस्थापित किया जा सकता है।

लगभग उपयोगकर्ता 202029 के लिए धन्यवाद। 26 बाइट बच गईं।

Comments

PPCG में आपका स्वागत है! और, अन्य भाषाओं में छोटे कार्यक्रमों के बारे में चिंता न करें ।

— user202729

आप -1 बाइट के बीच #define Fऔर बाहर की जगह छोड़ सकते हैं )।

— user202729

इसके अलावा, क्योंकि इनपुट में केवल \n(10), <space>(32) और 0(48) आप (-1 बाइट) के ==48साथ देख सकते हैं >47। / यदि वैरिएबल ग्लोबल है तो आप ={0}इनिशियलाइज़ कर सकते हैं b। इसी तरह से kवैश्विक और i(अप्राप्त -> int) पैरामीटर main( argcजिसके स्थान पर है 1) बनाते हैं ।

— user202729

धन्यवाद! इससे पहले कि मैंने बाद के सुझावों को देखा संपादित किया; मैं उनके माध्यम से अपने तरीके से टिक करूँगा ( iजैसा argcकि प्रतिभाशाली है)। इसके पहले ड्राफ्ट 400 से अधिक बाइट्स थे; मुझे अभी काफी समय हो गया है कि मैं इसे अपने 300 और फिर 256 के व्यक्तिगत लक्ष्यों तक ले जाऊं ताकि अच्छी तरह से और अधिक तरीके हो सकें कि मैं इसे याद कर सकूं।

— सेवनस्टारस्टोनेशन

अलग-अलग घोषणाएं होने से बचाने के लिए बनाने के लिए k, jऔर lसभी ग्लोबल्स का फैसला किया int, फिर एहसास हुआ कि चूक मुझे पूरी तरह से बंद छोड़ने के साथ दूर होने देगी। एक बार फिर धन्यवाद!

— सेवनस्टारोनेस्टेशन

Answer 8

MATL , 18 17 बाइट्स

32>&fun30=wd|2<vA

इनपुट एक 2 डी चार सरणी है। सांप के लिए किसी भी गैर-अंतरिक्ष पात्र का उपयोग किया जा सकता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

32>      % Implicit input. Transform non-space into 1, space into 0
&f       % Push vector of row indices and vector of column indices of nonzeros
u        % Unique: vector of deduplicated entries
n        % Length
30=      % Does it equal 30? (*)
w        % Swap. Moves vector of row indices to top
d|       % Absolute consecutive differences
2<       % Is each value less than 2? (**)
v        % Concatenate results (*) and (**) vertically
A        % All: true if all entries are nonzero. Implicit display

Comments

इसका तात्पर्य है कि लाइन की लंबाई 30 होने की गारंटी है, इसलिए मुझे लगता है कि आप कुछ बचा सकते हैं।

— जोनाथन एलन

@JonathanAllan धन्यवाद! मैं un30=यह जांचने के लिए उपयोग कर रहा हूं कि सभी कॉलम इंडेक्स अलग हैं, और 30 कॉलमों में से कोई भी खाली नहीं है। शायद मैं और अधिक सीधे परीक्षण कर सकता हूं, लेकिन मैं यह नहीं देखता कि कैसे

— लुइस मेंडो

Answer 9

पर्ची , 28 बाइट्स

((\|/)?0(<(?| *$^)<){2}){30}

इसका परीक्षण यहां करें।

Answer 10

जेली , 19 बाइट्स

Zn⁶T€L€=1$$;FIỊ$$$Ạ

इसे ऑनलाइन आज़माएं!

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

व्याख्या

Zn⁶T€L€=1$$;FIỊ$$$Ạ  Main Link
Z                    Transpose the matrix of characters
                         (string -> list of chars in Jelly)
 n⁶                  != " " (vectorizing)
   T€                For each column, get (row) indices of snake parts
     L€=1$$          For each index list, is its length 1? (that is, exactly one snake part per column)
           ;     $   Append (helper part)
            FIỊ$$    helper part:
            F        flatten index list
             I       get increments/forward differences
              Ị      are the values insignificant? (|z| <= 1)
                  Ạ  Are these all true?

इनपुट स्ट्रिंग्स की एक सूची के रूप में है

Comments

@ Mr.Xcoder Huh विफल, जेली स्ट्रिंग प्रतिनिधित्व मुद्दों योग्य। 1 बाइट ungolfing द्वारा तय

— HyperNeutrino

Answer 11

जेली , (14? *) 13 बाइट्स

Zn⁶T€z-IỊ0-¦Ȧ

पांच तारों की एक सूची लेने वाला एक विचित्र लिंक *, प्रत्येक की लंबाई 30 रिक्त स्थान और किसी भी अन्य वर्ण (जैसे 0s), और एक पूर्णांक लौटाते हैं (1 यदि एक सांप परिभाषित के रूप में, 0 अन्यथा)

* यदि इनपुट में एक स्ट्रिंग (वर्णों की सूची) होनी चाहिए, तो Ỵलाइन फीड में स्ट्रिंग को विभाजित करने के लिए प्रीपेंड करें ।

इसे ऑनलाइन आज़माएं!

कैसे?

Zn⁶T€z-IỊ0-¦Ȧ - Link: list of lists of characters, Lines
Z             - transpose the lines -> columns
  ⁶           - literal space character
 n            - not equal? -> 0 where there were spaces and 1 where there were "0"s
   T€         - truthy indices for each -> e.g. [0,0,1,0,0] -> [3] or [0,1,1,0,0] -> [2,3]
              -                           note: [0,0,0,0,0] -> []
      -       - literal minus one
     z        - transpose with filler (-1) -> {valid: a single list of heights {top:1,...,bottom:5}
              -                              invalid: list of >1 lists, some of which contain -1
              -                                       ...OR an empty list (no 0s in the input at all)}
       I      - differences -> {up:-1; down:1; flat:0; invalid:-6,-5,...,-2,2,...4}
        Ị     - insignificant (abs(z)<=1) -? {up/down/flat:1; invalid:0}
           ¦  - sparse application///
         0    - ...action: literal zero
          -   - ...to indices: [-1] -> make penultimate list into a zero (when one exists)
            Ȧ - any & all -> when flattened:{empty or contains a 0:0; otherwise:1}

Comments

आह सोचा कि मैं सभी किनारे मामलों की कोशिश की, सिर के लिए धन्यवाद; बाद में संबोधित करना होगा।

— जोनाथन एलन

@LuisMendo हे और फिक्सिंग में मैंने तीन को बचा लिया, इसलिए फिर से धन्यवाद!

— जोनाथन एलन

... उह, लेकिन मैंने एक और परिचय दिया। एक और 3 के लिए निर्धारित :(

— जोनाथन एलन

हालांकि एक बुरा बाइट-काउंट नहीं है :-)

— लुइस मेंडो

Answer 12

स्टेक्स , 20 बाइट्स ^CP437

Å┴m▐◘5)ît╢V¼≥+╝╜►º½ê

24 बाइट्स अनपैक किए जाने पर,

LM{'0|Ic%vChm:-{Jh!f%29=

भागो और डिबग ऑनलाइन!

सबसे अच्छा गोल्फ नहीं हो सकता है लेकिन मुझे लगता है कि यह तरीका उपन्यास और दिलचस्प है।

व्याख्या

LM                          Load the input string as a 2d array of characters, and transpose it

  {         m               Map array with block
   '0|I                     Get all indices of substring "0"
       c%vC                 Map to nothing if the indices are not unique
           h                Otherwise map to the unique index

             :-             Take pairwise difference

               {   f        Filter array with block
                Jh!         Only keep 0, 1 and -1

                    %29=    Check whether the final array has exactly 29 elements

Answer 13

जे , 38, 37 30 बाइट्स

-8 बाइट्स FrownyFrog के लिए धन्यवाद

[:($e.~[:(-:*)2-/\])@:I.'0'=|:

इसे ऑनलाइन आज़माएं!

Comments

कैसे के बारे में [:(-:*)2-/\, सभी अंतर ,1, 0 या 1. हैं, तो जांच लें

— FrownyFrog

@FrownyFrog हाँ, यह बहुत अधिक दांव लगाने वाला है! धन्यवाद!

— गालेन इवानोव

@ FrownyFrog हम्म, मुझे यह एहसास नहीं था। मैं इसे ठीक करने की कोशिश करूंगा। उसे इंगित करने के लिए धन्यवाद।

— गैलेन इवानोव

[:(#@{.=[:(-:*)2-/\])@:I.'0'=|:

— FrownyFrog

ओह, यह भी काम करता है[:($e.~[:(-:*)2-/\])@:I.'0'=|:

— FrownyFrog

Answer 14

जेली , 16 बाइट्स

Zµi€”0IỊ;ċ€⁶=4ƊẠ

इसे ऑनलाइन आज़माएं!

मान लेता है कि इनपुट स्ट्रिंग में हमेशा केवल रिक्त स्थान और शून्य होंगे। स्ट्रिंग्स की सूची के रूप में इनपुट लेता है (प्रत्येक एक पंक्ति का प्रतिनिधित्व करता है), और 1 आउटपुट अगर सत्य, 0 अन्यथा।

व्याख्या

Zµi€”0IỊ;ċ€⁶=4ƊẠ | Monadic full program.
Z                | Transpose.
 µ               | Start a new monadic chain.
  i€”0           | Retrieve the first index of 0 in each column.
      IỊ         | Check whether their increments are insignificant (element-wise).
        ;     Ɗ  | Append the result of the following:
         ċ€⁶     | In each list of characters, count the occurrences of a space.
            =4   | Check whether they equal 4 (returns a boolean array).
               Ạ | All. Check whether all the elements are truthy.

Answer 15

पायथन 2 , 141 बाइट्स

lambda g:(lambda a:all(map(len,a)+[-2<x-y<2 for b in[sum(a,[])]for x,y in zip(b,b[1:])]))([[i for i in range(5)if"0"==r[i]]for r in zip(*g)])

इसे ऑनलाइन आज़माएं!

इनपुट पात्रों का एक ग्रिड है।

Answer 16

पायथन 2 और पायथन 3 , 122 120 119 बाइट्स

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and' '<s[62]

इसे ऑनलाइन आज़माएं!

इनपुट प्रारूप 154 की लंबाई की एक स्ट्रिंग है (5 x 30 वर्ण, 4 नए अंक):

'''
            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   '''[1:] # to exclude starting newline

---

यदि सिर को केंद्र पंक्ति नहीं होना है

मूल चुनौती में केंद्र-पंक्ति-सिर की आवश्यकता थी, लेकिन मैंने पाया कि यह यहाँ मामला नहीं है (कम से कम इसका स्पष्ट उल्लेख नहीं है)।

पायथन 2 और पायथन 3 , 124 123 बाइट्स

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and'0'in s[::31]

इसे ऑनलाइन आज़माएं!

---

संपादित करें:

• ==प्रत्येक कोड के लिए असमानताओं ( ) में असमानताओं को बदलकर 2 बाइट्स कम करें ।
• कम सीमित संस्करण में गलतियाँ मिलीं, और इसे संशोधित किया। (सौभाग्य से यह बहुत भयानक नहीं है, इसलिए मैं सभी संस्करणों को लंबाई में समान रख सकता हूं।) आप बाद के दो TIO लिंक में अतिरिक्त परीक्षण मामलों को देख सकते हैं।
• Py2 के समाधानों में एक झूलने वाली बाइट मिली, जिससे all()चाल को Py3 में अर्थहीन बना दिया गया, इसलिए दोनों संस्करणों को मिला दिया गया।

Answer 17

एक्सेल (VBA), 68 बाइट्स

Cell[A6]आउटपुट के रूप में तत्काल विंडो का उपयोग करना ।

[A1:AD5]="=CHOOSE(ROUND(RAND()+1,),0,"""")":[A6]="=COUNT(A1:AD5)=30"

Answer 18

घोंघे , 18 बाइट्स

\0!(ud.,\0)raa7)30

इसे ऑनलाइन आज़माएं!

Answer 19

ग्रिम , 30 26 23 बाइट्स

7 बाइट बचाने और एक बग को इंगित करने के लिए ज़गारब को धन्यवाद।

e`" 0/0 "oO|#29ddv&d#1+

इसे ऑनलाइन आज़माएं!

Answer 20

रूबी , 93 बाइट्स

->x{x.transpose.map{|x|x.count(?0)<2&&x.index(?0)}.each_cons(2).all?{|x,y|x&&y&&(x-y).abs<2}}

इसे ऑनलाइन आज़माएं!

Answer 21

जावास्क्रिप्ट (Node.js) , 128 126 बाइट्स

इनपुट स्पष्टीकरण के बाद संपादित किया गया कि इनपुट "एक स्ट्रिंग" है।

F=(a,l=29,r=0,t=/^( *)0 *$/.exec(a.split`
`.map(p=>p[l]).join``),q=t&&~t[1].length)=>q&&(s=q-(r=r||q))>-2&s<2?l?F(a,l-1,q):1:0

इसे ऑनलाइन आज़माएं!

Answer 22

पायथन 3 , 197 185 बाइट्स

कमांड प्रॉम्प्ट में verify.py<snake.txtया बैश डू में cat snake.txt | python verify.py। जहां snake.txtएक फाइल है जिसमें एक सांप है जिसे सत्यापित करना है।

अगर सांप सही है तो कुछ भी आउटपुट नहीं होगा। यदि यह सही नहीं है तो पायथन एक इंडेक्स एरर बढ़ाएगा।

import sys
s=sys.stdin.read().split("\n")
x=0
exec('t,y="",0\nwhile y<5:t+=s[y][x];y+=1\ns+=[t];x+=1;'*30)
s=list(map(lambda l:len(l.rstrip()),s))
while y<35:"ee"[abs(s[y]-s[y+1])];y+=2

Comments

ओह, ध्यान नहीं दिया कि मेरा आउटपुट सही या गलत होना था। क्या त्रुटि कोड की गणना की गई है?

— मूंछें

गोल्फ 12 बाइट्स।

— मूंछें