पृष्ठभूमि

ऑक्टेव द्वारा प्रेरित (और, विस्तार से, MATL की) सत्य / मिथ्या मैट्रिस की बहुत सुविधाजनक व्याख्या, जेली को, (ऑक्टेव-शैली सभी ) परमाणु मिला।

And इनपुट के रूप में एक सरणी लेता है और 1 रिटर्न देता है यदि सरणी गैर-रिक्त है और पेड़ की संरचना में कहीं भी संख्या 0 (पूर्णांक, फ्लोट या जटिल) शामिल नहीं है ; अन्यथा, यह 0 देता है ।

उदाहरण के लिए, सरणी [[]] सत्य है क्योंकि यह गैर-रिक्त है और इसमें कोई शून्य नहीं है, लेकिन [[0]] मिथ्या है क्योंकि इसमें अंतरतम स्तर पर एक 0 होता है।

कार्य

एक में प्रोग्रामिंग भाषा अपनी पसंद का एक पूर्ण कार्यक्रम या एक समारोह है कि एक संभवतः रिक्त होता है, की संभवतः दांतेदार सरणी लेता लिखने पूर्णांकों और इनपुट के रूप में प्रिंट या रिटर्न एक truthy या falsy मान दर्शाता है कि यदि Ȧ वापसी होगी 1 या 0 क्रमश।

आपका सबमिशन निम्नलिखित नियमों का पालन करना चाहिए।

सत्य और मिथ्या मूल्य सभी आदानों के लिए संगत होना चाहिए , अर्थात, सभी सरणियाँ जिसके लिए 1 रिटर्न 1 को समान सत्य मान पर मैप करना होगा, और सभी सरणियों के लिए 0 रिटर्न 0 एक ही गलत मूल्य पर मैप करना होगा।
चूंकि पूर्ण कार्यक्रम केवल इनपुट के रूप में सरणियों के स्ट्रिंग प्रतिनिधित्व ले सकते हैं, यह अनुमति है। हालाँकि, आपको अपनी भाषा के निरूपण निरूपण का उपयोग करना चाहिए, जैसा कि इसके द्वारा दिया गया है repr।

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

बाइट्स जीतने में सबसे छोटा कोड हो सकता है!

सत्य परीक्षण के मामले

[1]
[10]
[[]]
[[[[1]]]]
[[], [1], [1, 2]]
[[1], [1, [2]], [1, [2, [3]]]]
[[8], [8, [9]], [8, [9, [10]]]]

झूठे परीक्षण के मामले

[]
[0]
[0, -1]
[-1, 0]
[[[[0]]]]
[[0], [1, 2], [3, 4, 5]]
[[8], [8, [9]], [8, [9, [1, 0]]]]
[-1, 0, 0, 0]

— डेनिस
स्रोत

परीक्षण के मामलों के आधार पर, क्या आपका मतलब "संरचना में कहीं भी होने के लिए संख्या 0" है? इसका मतलब यह नहीं है कि मैंने इसका मतलब निकाला है।

— xnor

हाँ, कहीं भी। मैं स्पष्ट करने की कोशिश करूंगा।

— डेनिस

आपका वास्तव में क्या मतलब है "आप यह नहीं मान सकते कि स्ट्रिंग प्रतिनिधित्व का एक विशेष प्रारूप होगा"?

— दादा

2

ये दांतेदार सरणियाँ नहीं हैं - दांतेदार सरणियों में एक ही गहराई पर सभी संख्याएं होंगी, क्योंकि केवल आकार भिन्न होते हैं, तत्व प्रकार नहीं।

— अर्जन जोहानसन

2

@Qwertiy राइट, "अधिकांश" भाषाएं जहां "सब कुछ" एक Object... मेरा पसंदीदा हास्केल है, जहां यह नहीं है। न ही सी में, कम से कम एक तरह से नहीं जो आपको एरेज़ और इनट्स को सुरक्षित रूप से मिलाने की अनुमति देता है। वे दोनों भाषाएँ दांतेदार सरणियों के लिए पूरी तरह से सक्षम हैं, लेकिन फिर भी इस समस्या के लिए उनका उपयोग नहीं कर सकते हैं।

— अर्जन जोहान्सन

38

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

ṭFẠ

F इनपुट सूची को समतल करता है।

ṭ एक तत्व के रूप में मूल इनपुट सूची पर tacks, जो गलत है अगर और केवल अगर यह खाली है।

Ạ फिर जाँचता है कि क्या कोई भी सूची चपटी सूची में है, या मूल सूची ही गलत है।

(मूल उत्तर)

FẠ^Ṇ

डेनिस को धन्यवाद देने के लिए उसका समाधान खोजने के लिए प्रोत्साहित किया।

FẠ0 देता है यदि इनपुट में किसी भी गहराई पर गलत मूल्य है, तो बाकी 1. Ȧखाली सूचियों को छोड़कर यही होता है।

Ṇ 1 देता है यदि इनपुट एक झूठा मान है, तो और 0. केवल झूठी सूची खाली सूची है।

XOR- आईएनजी दो जवाब देता है।

F;WẠ

यह डेनिस के रूप में एक ही भावना में बहुत कुछ है F;LẠ, लेकिन Lसूची खाली होने पर सूची में शून्य डालने के लिए उपयोग करने के बजाय , यह Wखाली सूची को स्वयं (उत्पादन [[]]) में डालने के लिए उपयोग करता है , जिससे यह एक मिथ्या तत्व होता है।

— HVD
स्रोत

30

मेरी अपनी चुनौती और मेरी अपनी भाषा में ... बहुत अच्छा किया!

— डेनिस

15

रेटिना , 10 बाइट्स

A`\b0
^...

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

पहले हम इनपुट निकालते हैं यदि इसमें शून्य होता है। हम स्ट्रिंग की शुरुआत से कम से कम तीन वर्णों का मिलान करने का प्रयास करते हैं (यह सुनिश्चित करने के लिए कि इनपुट पिछले चरण में समाप्त नहीं हुआ है, या केवल इसके []साथ शुरू होना था )।

— मार्टिन एंडर
स्रोत

12

रूबी, 25 24 23 18 16 बाइट्स

p$_!~/\D0|^..$/

-nकमांड लाइन पर ध्वज की आवश्यकता होती है (+1 बाइट, -e-> -ne)।

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

यह एक पूर्ण कार्यक्रम है जो रूबी के कैनोनिकल सरणी प्रारूप में STDIN और आउटपुट trueया falseSTDOUT पर इनपुट लेता है ।

 $_              # line of input that was read automatically (-n)
   !~/        /  # does not match the regex...
      \D0        #   a non-digit followed by a 0
         |       #   or...
          ^..$   #   a 2-length string (which must be [], the empty array)
p                # output the result

23 बाइट फ़ंक्शन संस्करण:

->a{"#{a}"!~/\D0|^..$/}

यह एक खरीद है जो एक तर्क, परीक्षण की जाने वाली सरणी लेता है।

के लिए धन्यवाद मार्टिन Ender एक बाइट के लिए और करने के लिए Ventero दो बाइट के लिए!

— Doorknob
स्रोत

आप ध्वज के साथ एक साथ p$_!~/\D0|^..$/(या p ! ~/\D0|^..$/, महत्वपूर्ण व्हाट्सएप) का उपयोग करके दो और बाइट्स बचा सकते हैं -n।

— वेंटरो

8

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

FẠ_Ṇ

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

Ȧ0यदि इनपुट खाली है तो पैदावार होती है या इसमें ए0 , अन्यथा है 1।

FẠ पैदावार 0यदि इनपुट में आय होती है 0, तो खाली सरणी के केवल किनारे के मामले को छोड़कर (चूंकि इनपुट एक सरणी होने की गारंटी है)।

Ṇएक गैर-वेक्टरिंग लॉजिकल मोनड नहीं है, और इसलिए 0किसी भी गैर-खाली सूची के लिए और खाली सूची के लिए लौटता है 1। इस तरह के रूप में यह बस का FẠउपयोग करने के परिणाम से नियंत्रित किया जा सकता है _।

— जोनाथन एलन
स्रोत

एक नीचे, कम से कम एक और जाने के लिए।

— डेनिस

@ डेनिस यह FẠạṆसही नहीं है ?

— 1901

@EriktheOutgolfer नहीं, यह नहीं है। मेरे पास जो जवाब है, वह एक खाली सरणी के किनारे के मामले से अलग है और गैर-सरणियों के लिए एक अलग परिणाम देगा।

— डेनिस

@ डेनिस ट्रू के लिए ए, झूठे के लिए बी, खाली के लिए सी और गैर-सरणी के लिए डी की तरह? यह गैर-प्रतिस्पर्धात्मक होगा। मैंने जो किया वह अंतर के बजाय पूर्ण अंतर का उपयोग करना है क्योंकि कोई नकारात्मक बूलियन नहीं हैं।

— को आउटगोल्फर

@EriktheOutgolfer B को चुनौती युक्ति का पालन करने के लिए C के बराबर होना चाहिए, लेकिन D कुछ भी हो सकता है क्योंकि इनपुट एक सरणी होने की गारंटी है।

— डेनिस

8

05AB1E , 9 8 बाइट्स

-1 बाइट्स एमिग्ना के लिए धन्यवाद

)Q¹˜0å~_

स्पष्टीकरण:

)Q        Is the length of the input 0?
  ~    _  ... NOR ... (just for you, Dennis) 
   ¹˜     Input deep flattened
     0å   Contains 0

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

— Okx
स्रोत

के लिए असफल लगता है [[]]।

— डेनिस

है 0 वास्तव में 05AB1E में truthy?

— डेनिस

सभी सरणियाँ, जिनके लिए 1 रिटर्न 1 को समान सत्य मान पर मैप करना चाहिए , और सभी सरणियों के लिए Ȧ रिटर्न 0 को उसी मिथ्या मूल्य (जोर मेरा) पर मैप करना होगा

— डेनिस

1

@ डेनिस ठीक है, वहाँ एक तार्किक निषेध बाइट में चकित।

— ओकेक्स

1

अजी, बस मेरे लिए। : पी

— डेनिस

7

गणितज्ञ, १ Mat बाइट्स

#!={}&&#~FreeQ~0&

FreeQ0हमारे खिलाफ चेक करता है, लेकिन निश्चित रूप से यह Trueइनपुट के लिए वापस आ जाएगा {}, इसलिए हमें उस मामले को अलग से जांचना होगा।

— मार्टिन एंडर
स्रोत

7

एपीएल (डायलॉग), २१ १२ 7 बाइट्स

फोर्क के उपयोग से एडेअम के लिए 5 बाइट्स का धन्यवाद

⍬∘≡⍱0∊∊

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

यह दलयोग में मेरा पहला प्रयास है। गोल्फ युक्तियाँ स्वागत है!

व्याख्या

⍬∘≡                   Fork; Is the argument a null set
   ⍱                  Nor
    0∊∊               0 belongs to the enlisted form of the argument
                      For example, (1 (2 (3 (0)))) would become
                      1 2 3 0 using the ∊ monad
                      Then we check if zero belongs to this vector

— क्रिकटी लिथोस
स्रोत

+1 ध्यान दें कि आप दो परीक्षणों के परिणामों का संयोजन कर रहे हैं। यह एक कांटा के लिए एकदम सही है। ⍬∘≡बाएं परीक्षण (खाली-सेट बाउंड-टू-टू-टू), और 0∊∊राइट टेस्ट (स्वयं एक कांटा; शून्य सदस्य-सूचीबद्ध फॉर्म का) है। इसे एक साथ रखें ⍬∘≡⍱0∊∊:। इसे ऑनलाइन आज़माएं!

— आदम

इसके अलावा, आप "APL (Dyalog)" नाम का उपयोग करना चाह सकते हैं ताकि लोग यह जान सकें कि आप इसका क्या उपयोग कर रहे हैं।

— अदम

@ Adám सुझावों के लिए धन्यवाद!

— कृतिका लिथोस

6

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 199 188 बाइट्स

A={f={private["_i","_r"];_r=1;_i=0;while{_i<count _this}do{o=_this select _i;if(o in [o])then{if(o==0)then{_r=0}}else{_r=o call f};_i=_i+1};_r};if(count _this==0)then{0}else{_this call f}}

के साथ बुलाना:

[3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A

या साथ:

hint format["%1", [3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A]

स्पष्टीकरण:

खेल की स्क्रिप्टिंग भाषा में, किसी भी स्ट्रिंग वाले कोड को कहा जा सकता है। घुंघराले ब्रेसिज़ {}एक स्ट्रिंग की शुरुआत और अंत को दर्शाते हैं। (उद्धरण चिह्न भी काम करते हैं, लेकिन जब वे घोंसले में जाते हैं तो गड़बड़ हो जाते हैं।) तो,A={...} चर को एक स्ट्रिंग प्रदान करता है A, और फिर चर को एक फ़ंक्शन के साथ कहा जा सकता है:<argument> call A :। मूल रूप से किसी भी स्ट्रिंग को कोड के ब्लॉक के रूप में माना जा सकता है।

फिर, "फ़ंक्शन" के अंदर A, हम एक और फ़ंक्शन को परिभाषित करते हैं f। privateदो चर घोषित करता है _iऔर_rकार्य करने के स्थानीय करता हैf । एक स्थानीय चर का नाम एक अंडरस्कोर के साथ शुरू होता है।

while {} do {} एक लूप है, जहां पहले स्ट्रिंग (द्वारा चिह्नित) {} ) में लूप की स्थिति के लिए कोड और दूसरे में लूप बॉडी के लिए कोड होता है।

_this तर्क है कि के साथ पारित किया गया था call फ़ंक्शन के ।_thisकिसी भी प्रकार का हो सकता है, लेकिन यहाँ हम मानते हैं कि यह एक सरणी है।

लूप में, o=_this select _i_i: th तत्व को एक्सेस करता है और इसे वेरिएबल में असाइन करता है o। if (o in [o])यह निर्धारित करने के लिए एक चाल है कि क्या oएक और सरणी है या नहीं। यदि oकोई संख्या (या किसी सरणी के अलावा कुछ भी) है, o in [o]तो मूल्यांकन करेगा true, क्योंकि inफ़ंक्शन oसरणी से एक मूल्य मिलान पाता है [o]। यदि oएक सरणी है, तो अभिव्यक्ति की पैदावार होती है false, क्योंकिin सरणियों की तुलना करने से इनकार करता है।

यदि oयह एक सरणी नहीं है, तो हम जाँचते हैं कि क्या यह शून्य के बराबर है, और यदि ऐसा होता है, तो हम चर को सेट करेंगे _r, जिसका उपयोग हम वापसी मान के रूप में करेंगे, शून्य पर। अन्यथा, यदि oकोई सरणी है, तो हम _rपुनरावर्ती कॉल के वापसी मूल्य को निर्दिष्ट करते हैंf नए सरणी के साथo तर्क के रूप में करते हैं।

लूप के बाद, फ़ंक्शन के अंत में f, हम अभिव्यक्ति का मूल्यांकन करते हैं _r, जो कि मूल्य का पैदावार करता है _r, और जैसा कि मूल्यांकन किया जाने वाला अंतिम अभिव्यक्ति है, यह वही है जो फ़ंक्शन को कॉल करता fहै।

अब जब हमने परिभाषित किया है f( fअंदर की आवश्यकता नहीं है A, लेकिन इस तरह से हम इसे एक स्थानीय चर / फ़ंक्शन (वास्तव में कोई अंतर नहीं) घोषित कर सकते थे Aयदि हम कुछ बाइट्स को सहेजना नहीं चाहते थे), तो वापस लौटते हैं A। if (count _this == 0)जाँचता है कि Aइनपुट सरणी खाली है, और यदि यह है, तो A0. लौटाता है। अन्यथा फ़ंक्शन fको कॉल किया जाता है और इसका रिटर्न मान होगाA ।

कोई यह नोटिस कर सकता है कि ऐसा लगता है कि अर्धविराम कुछ स्थानों से गायब होगा, लेकिन यह मामला नहीं है, क्योंकि एक बयान के बाद ही अर्धविराम की आवश्यकता होती है यदि कोई अन्य कथन कोड के उसी ब्लॉक (यानी स्ट्रिंग) के अंदर आता है।

— Steadybox
स्रोत

रुको क्या?! ऑपरेशन फ्लैशपॉइंट?

— ब्रेन गाइडर

वाट कैसे? क्या??? कन्फ्यूज्ड

— क्रिस्टोफर

@DownChristopher ने एक स्पष्टीकरण जोड़ा।

— फरवरी

1

@AnderBiguri हां, क्यों नहीं? गेम की स्क्रिप्टिंग भाषा, प्रश्न में लिंक मेटा पोस्ट में दी गई प्रोग्रामिंग भाषा की परिभाषा को फिट करती है।

— स्टेडीबॉक्स

1

@Steadybox मैं चीज़ के अस्तित्व के बारे में उलझन में हूँ, इसकी वैधता नहीं !!

— ब्रेन गाइडर

5

पर्ल 5 , 15 बाइट्स

Doorknob के रूबी जवाब के रूप में एक ही तकनीक का उपयोग करके 2 बाइट्स बचाए ।

कोड + -pध्वज के 14 बाइट्स

$_=!/\b0|^..$/

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

/.../ यह सुनिश्चित करता है कि सरणी खाली नहीं है (यह किसी भी सरणी पर मेल खाएगा लेकिन [] ।
/\b0/अगर वहाँ एक है केवल से मेल खाएगी 0सरणी में। ( \bसुनिश्चित करें कि 0कोई दूसरा नंबर है, लेकिन एक पूरी संख्या) का एक हिस्सा नहीं है।

— बापू
स्रोत

5

हास्केल , 48 बाइट्स

f x=or[elem c"[,"|c:'0':_<-scanr(:)[]x]<(x<"[]")

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

परीक्षण के मामलों और के लिए लिन का धन्यवाद x<"[]" चाल ।

बाहरी असमानता के लिए (x<"[]")सही (गैर-रिक्त सूची) और होना आवश्यक हैor[elem c"[,"|c:'0':_<-scanr(:)[]x] गलत (शून्य नहीं) होना आवश्यक है।

वर्णों का 0पता एक ,या निम्नलिखित के रूप में लगाया जाता है [, जैसे संख्या के विपरीत 20। अभिव्यक्ति scanr(:)[]xसभी प्रकार के लक्षणों को उत्पन्न करती है l, और c:'0':_<-उन लोगों को पकड़ती है जिनका दूसरा चरित्र है '0'। फिर, elem c"[,"जांचता है कि पहला चरित्र है ,या नहीं[ ।

मैं यहाँ मानता हूँ कि हास्केल-शैली की सूचियों में स्थान नहीं हैं, लेकिन यदि ऐसा है तो ','बस इसे बदला जा सकता है' ' ।

यहाँ, एक और अधिक प्रत्यक्ष 48-बाइट विधि है, हालांकि यह पैदा करता 0है और 1के जो हास्केल में Truthy / Falsey नहीं हैं।

f"[]"=0
f(c:'0':_)|elem c"[,"=0
f(_:t)=f t
f _=1

— XNOR
स्रोत

5

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

F;LẠ

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

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

F;LẠ  Main link. Argument: A (array)

F     Flatten A.
  L   Yield A's length.
 ;    Concatenate.
   Ạ  All; Tell if all elements of the resulting 1D array are truthy.

ध्यान दें कि that परमाणु पायथन की तरह व्यवहार करता है allऔर इस प्रकार प्रतिबंधित Ạ से अलग होता है।

— डेनिस
स्रोत

8

हेड-अप: यह केवल 4-बाइट समाधान जेली नहीं है, स्पष्ट के अलावा L;FẠ। दूसरा कौन मिल सकता है?

— डेनिस

4

जावास्क्रिप्ट (ईएस 6), 34 बाइट्स

a=>a.length&&+!~`,${a}`.search`,0`

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

कोड स्निपेट दिखाएं

let f =

a=>a.length&&+!~`,${a}`.search`,0`

console.log('Truthy:')
console.log(f([1]))
console.log(f([10]))
console.log(f([[]]))
console.log(f([[[[1]]]]))
console.log(f([[], [1], [1, 2]]))
console.log(f([[1], [1, [2]], [1, [2, [3]]]]))
console.log(f([[8], [8, [9]], [8, [9, [10]]]]))

console.log('Falsy:')
console.log(f([]))
console.log(f([0]))
console.log(f([0, -1]))
console.log(f([-1, 0]))
console.log(f([[[[0]]]]))
console.log(f([[0], [1, 2], [3, 4, 5]]))
console.log(f([[8], [8, [9]], [8, [9, [1, 0]]]]))

Expand snippet

— Arnauld
स्रोत

आप शायद के !!a[0]बजाय उपयोग कर सकते हैं a.length। (आपको a[0]शून्य होने के बारे में चिंता करने की ज़रूरत नहीं है क्योंकि परिणाम इस मामले में वैसे भी गलत होना चाहिए।)

— नील

कोई बात नहीं, मैंने देखा कि क्वर्टी पहले से ही वहां मौजूद था।

— नील

4

जूलिया, 45 बाइट्स

a(x)=all(a,x);a(x::Int)=x!=0;g(x)=x!=[]&&a(x)

यह एक फ़ंक्शन बनाता है gजो इंगित करता है कि पुनरावर्ती फ़ंक्शन को कॉल करके indicates 1 या 0 होगा a। एक उपयुक्त बनाने के लिए a, हम कई प्रेषण का उपयोग करते हैं:

# A method for scalar values
a(x::Int) = x != 0

# A recursive fallback for arrays
a(x) = all(a, x)

फ़ंक्शन allएक फ़ंक्शन तर्क लेता है, इसलिए हम aइनपुट के प्रत्येक तत्व पर कॉल कर रहे हैं । फिर हम केवल प्रस्तुत करने के लिए फ़ंक्शन को परिभाषित करते हैं

g(x) = x != [] && a(x)

मूल रूप से हमें बस जरूरत है aलेकिन सही ढंग से संभाल करने के लिए एक चेक के साथ[] ।

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

— एलेक्स ए।
स्रोत

आप समारोह को परिभाषित कर सकते a(x)या g(x)के रूप में !xके बजाय?

— साइओस

4

ग्रिम , १६ १४ 11 बाइट्स

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

e`s\0v#|!..

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

eजमी हुई कीट बताता कोशिश करते हैं और पूरे इनपुट से मेल और मुद्रित करने के लिए0 या1 कि क्या संभव है कि पर निर्भर करता है।

|!प्रभावी ढंग से, एक "न" ऑपरेटर है, क्योंकि x|!yके लिए आशुलिपि है (x|y)!। इसलिए हम यह सुनिश्चित करते हैं कि इनपुट में न तो प्रतीक से पहले का शून्य है और न ही केवल दो वर्णों का तार है ([] ) ।

दूसरी छमाही के बारे में एक नोट: P#एक आयत से मेल खाता है जिसमें कम से कम एक मैच होता है P। हालांकि, हमारे मामले Pमें दोनों शामिल हैं sऔर \0इसलिए सामान्य रूप से कोष्ठक की आवश्यकता होगी: (s\0)#(क्योंकि पूर्वता #बहुत अधिक है)। लेकिन Grime में एक बहुत ही साफ-सुथरी सुविधा है, जहां आप ऑपरेटरों की पूर्वता को संशोधित कर सकते हैं^ और v। इसलिए v#हम निम्न #वरीयता का उपयोग करते हैं ताकि यह किसी भी अन्य ऑपरेटर (संघनन सहित) की तुलना में कम हो, जो हमें कोष्ठकों पर एक बाइट को बचाने की अनुमति देता है।

— मार्टिन एंडर
स्रोत

3

रंज , 12 बाइट्स

#Va&`\b0`NIa

सरणी को पिप के रिप के रूप में कमांड-लाइन तर्क के रूप में लेता है, जैसे [1;[2;3]]। रिटर्न 1truthy के लिए, 0falsey के लिए।इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

              a is 1st cmdline arg (implicit)
 Va            Eval a (converting from a string to a list)
#              Take the length (0 if empty, nonzero if nonempty)
   &          Logical AND
    `\b0`      Regex pattern: word boundary followed by 0 (avoids things like 10)
         NIa   Not in a (0 if `\b0` matches in a, 1 if it doesn't)
              Autoprint

बोनस उत्तर, 12 बाइट्स

यहाँ एक फ़ंक्शन है जो इसके बजाय एक सूची लेता है:

#_>0=0N_Js^s

#_            Len(arg)
  >0          is greater than 0
    =         which also equals the following (comparison operators chain like Python's):
     0N       Count of 0's in
       _Js^s  arg, joined on space and then split on space (a hacky way to flatten)

TIO

— DLosc
स्रोत

3

रोड़ा , 59 44 बाइट्स

f a{[1]if{g(a)[[]!=a]}}g a{[a!=0];try a|g _}

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

fएक सूची के रूप में इनपुट को एक सूची के रूप में लेता है जिसमें अन्य सूचियाँ और पूर्णांक हो सकते हैं। यह 1अगर aसच है और अन्यथा कुछ भी नहीं है। हेल्पर फंक्शन gचेक करता है अगरa शून्य हो ।

स्पष्टीकरण:

f a{[1]if{g(a)[[]!=a]}}
f a{                  } /* Function declaration */
          g(a)          /* Call g -> pushes some booleans to the stream */
              [[]!=a]   /* Push value []!=a to the stream */
       if{           }  /* If all booleans in the stream are true: */
    [1]                 /*   Push 1 to the stream */
                        /* Otherwise return nothing */

g a{[a!=0];try a|g _}   /* Helper function */
g a{                }   /* Function declaration */
    [a!=0];             /* Push value a!=0 to the output stream */
           try          /* Ignore errors in the following if a is not a list */
               a        /* Push values in a to the stream */
                |g _    /* Pull values from the stream and */
                        /*   call g for each of them */
                        /*   (pushes boolean values to the output stream) */

एक समाधान जो रेगेक्स का उपयोग करता है वह बहुत कम हो सकता है।

यदि यह कई मूल्यों को वापस करने की अनुमति दी जाती तो यह उत्तर कम हो सकता था । इससे पहले मेरे एक जवाब में इस पर चर्चा की गई है , और यह निष्कर्ष निकाला गया कि डिफ़ॉल्ट नियमों में अलग-अलग इनपुट्स के लिए अलग-अलग सत्य और झूठे मूल्यों को वापस करने की अनुमति है, लेकिन किसी कारण से ओपी ने इसे यहां और वहां मना किया है। :(

— fergusq
स्रोत

3

आश्चर्य है , 15 बाइट्स

@&#0! iO0flat#0

उपयोग:

(@&#0! iO0flat#0)[1;2;3;[8;9;0]]

समतल इनपुट, 0 की सभी घटनाओं को प्राप्त करें, तार्किक नहीं, तार्किक और इनपुट के साथ।

— मामा फन रोल
स्रोत

3

हास्केल , 62 बाइट्स

import Data.List
(%)=isInfixOf
f x=not(",0"%x||"[0"%x)&&x<"[]"

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

यह एक फंक्शन है String -> Bool। हास्केल की सूची विषम हैं, इसलिए जैसी सूचियों का प्रतिनिधित्व करने के लिए कोई अंतर्निहित तरीका नहीं है [0, [0]]।

— लिन
स्रोत

री-वर्ड किए गए नियमों के आधार पर, इनपुट में रिक्त स्थान नहीं होना चाहिए क्योंकि हास्केल सरणियां डिफ़ॉल्ट रूप से नहीं होती हैं। कम से कम, मुझे लगता है कि यह व्याख्या तब भी है जब हास्केल दांतेदार सरणियों की अनुमति नहीं देता है। लेकिन ऐसा लगता है कि आपका कोड ,`` के लिए समान होगा ।

— xnor

2

मैं सवाल टिप्पणियों quibbling कर रहा हूँ के रूप में, हास्केल करता दांतेदार सरणियों (और सूचियों) है - यह सिर्फ है कि यह वास्तव में काफी क्या इस प्रश्न की आवश्यकता है के लिए नहीं है।

— अर्जन जोहान्सन

3

पायथन 2 , 45 39 38 बाइट्स

lambda a:(a>[])^(' 0'in`a`or'[0'in`a`)

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

-6 धन्यवाद @BenFrankel के लिए

पिछले संस्करण, स्ट्रिंग रिप करने के लिए सूची में परिवर्तित किए बिना, 68 बाइट्स:

lambda a:(len(a)and g(a))*1
g=lambda b:all(map(g,b))if b>[]else b!=0

— OVS
स्रोत

यह एक झूठी सकारात्मक देता है []। निम्नलिखित 6 बाइट्स बचाता है और इस पर सफल होता है []:lambda a:bool(a)^(' 0'in`a`or'[0'in`a`)

— बेन फ्रैंकल

2

MATLAB, 49 बाइट्स

MATLAB (साथ ही ऑक्टेव) इस तरह के नेस्टेड सरणियों की अनुमति नहीं देता है, हम इसे एक स्ट्रिंग के रूप में व्याख्या करते हैं।

पहले हम सभी गैर-अंकीय वर्णों को एक स्थान से प्रतिस्थापित करते हैं। तब हम str2numइसे एक (1D) सरणी में बदलने के लिए उपयोग करते हैं , जिस पर हम आवेदन कर सकते हैं all(जिसकी अनुमति है, क्योंकि यह इस कार्य को पूरी तरह से स्वयं से हल नहीं करता है।)

s=input('');s(s<45|s>57)=32;disp(all(str2num(s)))

— flawr
स्रोत

2

जैसे, 7 + 3 = 10 बाइट्स

\<0|^.]

-vपरिणाम को पलटने के लिए आवश्यक ध्वज के लिए +3 बाइट्स ।

Grep में सरणियों की कोई अवधारणा नहीं है, इसलिए यह प्रश्न में दिए गए अनुसार स्ट्रिंग प्रतिनिधित्व का उपयोग करता है। स्टड से एक लाइन पर इनपुट लेता है, निकास कोड (स्टडआउट को अनदेखा) के माध्यम से रिटर्न करता है।

(अब एक ऐसे संस्करण का उपयोग करना, जो 01शब्द और ईश्वर के समान नहीं है, क्योंकि यह ठीक है)

मूल बैश / grep प्रविष्टि:

grep -Ev '\<0+\>|^.]'

0कहीं भी ढूँढता है (शब्द सीमा जाँच का उपयोग करके या जैसी चीजों को छूट \<देने के \>लिए ), या एक पूरी स्ट्रिंग मिलान , फिर मैच का विरोध करता है।10a1[]

टूट - फूट:

grep
     -E \    # extended regular expression syntax
     -v \    # invert match
     \<0+\>  # a number of 0s with alphanumeric boundaries on both sides
     |^.\]   # or ']' as the second character (implies '[]')

— डेव
स्रोत

धोखा नहीं, सिर्फ अच्छी गोल्फिंग। :) Btw, grep मौलिकता परीक्षण के लिए सक्षम है, इसलिए यह एक प्रोग्रामिंग भाषा है जहाँ तक PPCG का संबंध है। \<0\|^.]प्लस -v11 बाइट समाधान के रूप में गिना जाएगा।

— डेनिस

1

@ डेनिस कूल, धन्यवाद! (मैं एक अतिरिक्त बाइट को बचाने के egrepबजाय स्विच किया grep; भाषा का नाम बाइट-गिनती की ओर नहीं है!)

— डेव

2

जावास्क्रिप्ट ईएस 6, 24 वर्ण

सरणी, रिटर्न 1या 0: के साथ काम करता है

a=>!!a[0]&!/\b0/.test(a)

परीक्षा:

f=a=>!!a[0]&!/\b0/.test(a)

console.log([
  [1],
  [10],
  [[]],
  [[[[1]]]],
  [[], [1], [1, 2]],
  [[1], [1, [2]], [1, [2, [3]]]],
  [[8], [8, [9]], [8, [9, [10]]]],
].every(x => f(x)===1))

console.log([
  [],
  [0],
  [0, -1],
  [-1, 0],
  [[[[0]]]],
  [[0], [1, 2], [3, 4, 5]],
  [[8], [8, [9]], [8, [9, [1, 0]]]],
].every(x => f(x)===0))

स्निपेट का विस्तार करें

— Qwertiy
स्रोत

चूँकि वापसी का मूल्य सत्य / मिथ्या हो सकता है, आप इसे छोड़ सकते हैं !!(हालांकि तब आपको बदलना &होगा &&)। एक-एक बाइट बचाता है।

— ब्रायन मैककिनटन

@BrianMcCutchon, बाइनरी नहीं है &। के मामले में &&बिना !!लगातार उत्पादन ध्वस्त किया जा सकता: undefinedके लिए [], 0के लिए [0]और [0,1,2]और falseदूसरों के लिए।

— Qwertiy

मैं यह नहीं देखता कि इस चुनौती में लगातार आउटपुट को तोड़ना कितना बुरा है। स्विच करने के साथ मेरी बात &&यह है कि यदि आपको मेरा पहला सुझाव लेना है, तो आपको इसकी आवश्यकता होगी 2 & 1 == 0।

— बजे ब्रायन मेकचून

@BrianMcCutchon, प्रश्न का पहला बिंदु: "सत्य और मिथ्या मूल्य सभी इनपुट के लिए संगत होना चाहिए, अर्थात, सभी सरणियाँ जिसके लिए 1 रिटर्न 1 को समान सत्य मान पर मैप करना होगा, और सभी सरणियों के लिए जिसमें Ȧ रिटर्न 0 होना चाहिए, मैप करना चाहिए एक ही मिथ्या मूल्य के लिए। "

— क्वर्टी २१'१

आह, मैंने बहुत जल्दी स्किम किया। कोई बात नहीं।

— बजे ब्रायन मैककिनटन

2

Tes å ı ¥® Ï ı 12 , 12 4 बाइट्स

i0Bu

व्याख्या

i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   u         › convert top value to its boolean

अगर परिणाम की जरूरत है ...

i0Buo        › same as above; o outputs the top value on the stack

पिछला समाधान

मैंने यह महसूस करने से पहले पोस्ट किया था कि स्टैक आधारित भाषाएं आउटपुट के रूप में स्टैक पर मूल्य छोड़ सकती हैं

i0B¿0oP?!¿o?

व्याख्या

i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   ¿         › If the top value is true ...
    0        › Push 0
     o       › Output the top value on the stack
      P      › Pop the top value from the stack
       ?     › End if statement
        !    › Boolean opposite of top value
         ¿   › If the top value is true ...
          o  › Output the top value
           ? › End if statement

— केर्ड सिक्काहिरिंग
स्रोत

2

हास्केल, 45

जैसा कि लिन और xnor ने टिप्पणी की है, हस्केल एक विषम-नेस्टेड सूची प्रकार के साथ नहीं आता है। लेकिन उन्हें कस्टम डेटा प्रकार के रूप में जोड़ना आसान है और फ़ंक्शन को उस प्रकार पर काम करने देते हैं, और यह (urgh!) स्ट्रिंग्स पर काम करने के लिए बहुत बेहतर है ।

data L=L Int|T[L]
f(L n)=n/=0
f(T l)=all f l

वास्तव में [1, [2]]वाक्य रचना के साथ शाब्दिक के रूप में इस तरह की सूचियों को लिखने में सक्षम होने के लिए , आपको कुछ टाइपकास्ट फू की भी आवश्यकता है। पूर्ण परीक्षण मामला:

{-# LANGUAGE OverloadedLists, TypeFamilies #-}
import GHC.Exts (IsList(..))

instance Num L where
  fromInteger = L . fromInteger
  negate (L n) = L $ negate n
instance IsList L where
  type Item L = L
  fromList = T
main = mapM_ (print . f) (
                    [ [1]
                    , [[[[0]]]]
                    , [[8], [8, [9]], [8, [9, [1, 0]]]]
                    ] :: [L])

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

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत

2

विम, 23 बाइट्स

:g/0\|^..$/d
:s/.\+/1/<CR>

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

असत्य के 1लिए या सच के लिए एक रिक्त स्ट्रिंग आउटपुट करता है। यह छोटा हो सकता है अगर मैं एक खाली स्ट्रिंग या [] असत्य के लिए आउटपुट कर सकता हूं (दोनों जिनमें से गलत मान हैं)।

— क्रिकटी लिथोस
स्रोत

1

स्टैक्ड , 20 बाइट्स

:size\flat,0 eq none

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

वैकल्पिक रूप से, एक स्ट्रिंग का उपयोग करके:

:tostr'\d+'match'0'has¬\size¬>

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

— कोनोर ओ ब्रायन
स्रोत

1

लिथप , 74 बाइट्स

(def f #L::((foldl(flatten L)(?(>(length L)0)1 0)#N,A::((?(== N 0)0 A)))))

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

खैर, मुझे उम्मीद थी कि इससे अधिक समय हो गया। []मामले मुझे फिसल गया और कुछ बाइट्स गयी। यह बस सूची को समतल करता है और इसके ऊपर एक गुना छोड़ देता है, और यदि यह 0 पाता है तो यह संचायक को 0 पर सेट करता है।

— Andrakis
स्रोत

1

रूबी , 24 22 बाइट्स

->a{a[0]&&a*?!!~/\b0/}

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

हां मुझे पता है कि रूबी में एक बेहतर समाधान है, लेकिन मैं एक स्ट्रिंग के बजाय इनपुट में सरणी लेना चाहता था।

— जीबी
स्रोत

1

टिनिइलिश , 70 64 बाइट्स

(load library
(d _(q((X)(i(c()X)(all(map _ X))X
(q((L)(i L(_ L)0

अंतिम पंक्ति एक अनाम लैम्बडा फ़ंक्शन है जो एक सूची लेता है और 1"ट्रू-अंडर-Ȧ" और 0फाल्सी के लिए लौटता है। इसे ऑनलाइन आज़माएं!

Ungolfed

(load library)

(def _Ȧ
 (lambda (val)
  (if (equal? (type val) List)
   (all (map _Ȧ val))
   val)))

(def Ȧ
 (lambda (ls)
  (if ls
   (_Ȧ ls)
   0)))

पुनरावर्ती सहायक कार्य _Ȧअधिकांश कार्य करता है। यदि इसका तर्क एक सूची है, तो हम map _Ȧइसके तत्वों की ओर लौटते हैं और 1यदि वे सत्य हैं all, 0यदि कोई गलत है। (आसानी से, खाली सूची दिए जाने पर allरिटर्न 1।) अन्यथा, तर्क पूर्णांक होना चाहिए; हम इसे इस रूप में लौटाते हैं (0 यह गलत है और अन्य सभी पूर्णांक टिनिइस्प में सत्य हैं)।

मुख्य फ़ंक्शन यह Ȧजाँचता है कि सूची गैर-रिक्त है या नहीं। यदि हां, तो यह कॉल करता है _Ȧ; यदि नहीं, तो यह वापस आ जाता है0 ।

गोल्फ संस्करण कुछ अपरिभाषित व्यवहार का लाभ उठाता है: (e(type X)List)परीक्षण करने के बजाय कि क्या Xपूर्णांक या सूची है, यह करता है (c()X), जो consखाली सूची को चालू करने का प्रयास करता है X। यदि Xएक सूची है, तो यह एक गैर-रिक्त सूची में परिणाम है, जो सत्य है। यदि Xएक पूर्णांक है, तो टिनिस्प एक त्रुटि संदेश का उत्पादन करता है और एक खाली सूची देता है, जो कि गलत है। चूंकि stderr को अनदेखा किया जाता है, यह दृष्टिकोण मान्य है।

— DLosc
स्रोत

0

PHP, 63 54 बाइट्स

9 बाइट्स @ user63956 द्वारा सहेजे गए

function a($a){return$a&&!strpos(print_r($a,1)," 0");}

इनपुट के रूप में एक सरणी लेता है; रिटर्न trueया false: यदि $aरिक्त नहीं है,
तो जांचें कि print_rआउटपुट में 0मान है।

सरणी समाधान, 83 बाइट्स

function b($a,$r=0){$r|=$a;foreach($a as$v)$r|=is_array($v)?b($v,1):!!$v;return$r;}

पुनरावर्ती फ़ंक्शन रिटर्न 1या 0।

टूट - फूट

function b($a,$r=0)
{
    $r|=$a;         # if $a is not empty, set $r (no effect in recursion)
    foreach($a as$v)    # loop through elements:    
        $r&=is_array($v)    # 2. if test failed, clear $r
            ?b($v,1)        # 1. if array, recurse
            :!!$v;          #    else test element <>0
    return$r;           # return $r
}

— टाइटस
स्रोत

1

आप के strpos(print_r($a,1)," 0")बजाय के साथ कुछ बाइट्स बचा सकता है preg_match(...)।

— user63956

@ user63956 ... और यह 0-इंडेक्स समस्या को भी हल करता है। मैं दूसरे print_rपैरामीटर से वाकिफ नहीं था । महान!

— टाइटस

क्या यह सच है? जेली से पूछो!

पृष्ठभूमि

कार्य

सत्य परीक्षण के मामले

झूठे परीक्षण के मामले

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

रेटिना , 10 बाइट्स

रूबी, 25 24 23 18 16 बाइट्स

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

05AB1E , 9 8 बाइट्स

गणितज्ञ, १ Mat बाइट्स

एपीएल (डायलॉग), २१ १२ 7 बाइट्स

व्याख्या

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 199 188 बाइट्स

पर्ल 5 , 15 बाइट्स

हास्केल , 48 बाइट्स

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

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

जावास्क्रिप्ट (ईएस 6), 34 बाइट्स

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

जूलिया, 45 बाइट्स

ग्रिम , १६ १४ 11 बाइट्स

रंज , 12 बाइट्स

व्याख्या

बोनस उत्तर, 12 बाइट्स

रोड़ा , 59 44 बाइट्स

आश्चर्य है , 15 बाइट्स

हास्केल , 62 बाइट्स

पायथन 2 , 45 39 38 बाइट्स

पिछले संस्करण, स्ट्रिंग रिप करने के लिए सूची में परिवर्तित किए बिना, 68 बाइट्स:

MATLAB, 49 बाइट्स

जैसे, 7 + 3 = 10 बाइट्स

मूल बैश / grep प्रविष्टि:

टूट - फूट:

जावास्क्रिप्ट ईएस 6, 24 वर्ण

Tes å ı ¥® Ï ı 12 , 12 4 बाइट्स

व्याख्या

पिछला समाधान

व्याख्या

हास्केल, 45

विम, 23 बाइट्स

स्टैक्ड , 20 बाइट्स

लिथप , 74 बाइट्स

रूबी , 24 22 बाइट्स

टिनिइलिश , 70 64 बाइट्स

Ungolfed

PHP, 63 54 बाइट्स