क्या यह सेट एक प्राकृतिक संख्या का प्रतिनिधित्व करता है?

Question

सेट सिद्धांत में, प्राकृतिक संख्याएं को आमतौर पर शुद्ध सेट के रूप में एन्कोड किया जाता है , वह सेट होता है जिसमें केवल खाली सेट या अन्य सेट होते हैं जो शुद्ध होते हैं । हालांकि, सभी शुद्ध सेट प्राकृतिक संख्याओं का प्रतिनिधित्व नहीं करते हैं। यह चुनौती यह तय करने के बारे में है कि क्या दिया गया शुद्ध सेट प्राकृतिक संख्या के एन्कोडिंग का प्रतिनिधित्व करता है या नहीं।$\mathbb{N} = \{0, 1, 2, 3, ...\}$

प्राकृतिक संख्या की एन्कोडिंग निम्नलिखित तरीके से काम करता है ¹ :

• शून्य खाली सेट है:$Set(0) = \{\}$
• संख्या :$n > 0$$Set(n) = Set(n-1) \cup \{Set(n-1)\}$

इस प्रकार, पहले कुछ प्राकृतिक संख्याओं के एनकोडिंग हैं

• $0 \leadsto \{\}$
• $1 \leadsto \{0\} \leadsto \{\{\}\}$
• $2 \leadsto \{0,1\} \leadsto \{\{\},\{\{\}\}\}$
• $3 \leadsto \{0,1,2\} \leadsto \{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}$
• $4 \leadsto \{0,1,2,3\} \leadsto \{\{\},\{\{\}\},\{\{\},\{\{\}\}\},\{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}\}$

काम

• एक शुद्ध सेट का प्रतिनिधित्व करने वाले स्ट्रिंग को देखते हुए, यह निर्धारित करें कि क्या यह सेट उपरोक्त निर्माण के अनुसार एक प्राकृतिक संख्या को एन्कोड करता है।
• ध्यान दें, हालांकि, एक सेट के तत्वों का आदेश नहीं दिया गया है, इसलिए $\{\{\},\{\{\}\},\{\{\},\{\{\}\}\}\}$$3$ का एकमात्र वैध प्रतिनिधित्व नहीं है, जैसे कि $\{\{\{\}\},\{\},\{\{\{\}\},\{\}\}\}$ एक ही सेट का प्रतिनिधित्व करता है।
• आप उपयोग कर सकते हैं [], ()या <>इसके बजाय {}।
• आप मान सकते हैं कि सेट ,विभाजक के बिना दिए गए हैं ।
• आप मान सकते हैं कि इनपुट में कोई डुप्लिकेट तत्व नहीं होंगे, उदाहरण के {{},{}}लिए एक वैध इनपुट नहीं है, और यह कि इनपुट अच्छी तरह से बना है, उदाहरण के लिए नहीं {{},, {,{}}या इसी तरह का।

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

सच:

{}
{{}}
{{},{{}}}
{{{}},{}}
{{},{{}},{{},{{}}}}
{{{},{{}}},{},{{}}}
{{{{}},{}},{{}},{}}
{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
{{{{{}},{}},{{}},{}},{{}},{},{{},{{}}}}
{{},{{}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{{}},{}},{{},{{}},{{},{{}}}}}
{{{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}}

असत्य:

{{{}}}
{{{{}}}}
{{{{}},{}}}
{{},{{}},{{{}}}}
{{{},{{}}},{{}}}
{{{{{}}},{}},{{}},{}}
{{},{{}},{{},{{}}},{{},{{}},{{{}}}}}
{{{{{}},{}},{{{}}},{}},{{}},{},{{},{{}}}}
{{{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}},{{{{{}},{}},{{}},{}},{{{}},{}},{{}}},{{{{}},{}},{{}},{}},{{{}},{}},{{}},{}}

---

^{संबंधित: प्राकृतिक निर्माण (किसी दिए गए प्राकृतिक संख्या के सेट एन्कोडिंग का उत्पादन।)
1 https://en.wikipedia.org/wiki/Set-theoretic_definition_of_natural_numbers देखें}

Comments

परीक्षण के मामले एक (अभी तक) अनइम्प्लॉइज्ड एसोलंग में एक कार्यक्रम की तरह दिखते हैं :)

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

क्या इनपुट स्ट्रिंग के बजाय डेटा संरचना (नेस्टेड लिस्ट) हो सकता है?

— ngn

मैंने सोचा कि यह एक पल के लिए ब्रेन-फ्लैक था ।

— बेलेंहिक्स

@ नहीं, इनपुट के लिए स्ट्रिंग होना आवश्यक है।

— लकोनी

@KirillL। तकनीकी रूप से ये जवाब शुरू करने के लिए वैध नहीं थे क्योंकि चुनौती हमेशा "शुद्ध सेट का प्रतिनिधित्व करने वाले एक स्ट्रिंग को देखते हुए" बताई गई थी, हालांकि मैं इस बिंदु को देखता हूं कि नेस्टेड डेटा संरचनाओं को दिलचस्प गोल्फिंग अवसरों की अनुमति देता है। हालाँकि, मुझे यह तय करना कठिन है कि एक स्वीकृत डेटा संरचना क्या है, इस पर रेखा खींचना है और बहुत अधिक इनपुट इनपुट प्रारूप के दुरुपयोग से बचने के लिए क्या नहीं है, इसलिए मैंने सरलता और स्पष्टता के लिए इनपुट को सीमित करने का निर्णय लिया। ।

— लैकोनी

Answer 1

जावास्क्रिप्ट (Node.js) , 53 48 44 बाइट्स

f=a=>(a=eval(a)).every(e=>a[e.length]&&f(e))

इसे ऑनलाइन आज़माएं! टेस्ट केस ज्यादातर बेशर्मी से @ अरनॉल्ड के जवाब से चुराए जाते हैं। स्पष्टीकरण: यदि कोई सेट किसी प्राकृतिक संख्या का प्रतिनिधित्व करता है, तो उसका प्रतिनिधित्व करने वाला प्राकृतिक नंबर सेट के आकार के बराबर होना चाहिए, और (यह देखते हुए कि तत्व अलग-अलग हैं इसकी गारंटी दी गई है) तत्व प्राकृतिक संख्याओं से कम होना चाहिए, और इसलिए इनकी लंबाई कम होनी चाहिए। यह पाठ्यक्रम के खाली सेट का तुच्छ सच है। संपादित करें: @Arnauld के लिए 5 बाइट्स सहेजे गए। @Cowsquack की बदौलत 4 बाइट्स बचाए।

Comments

!e[a.length-1]3 बाइट्स बचाना चाहिए

— Arnauld

@ बर्न या बेहतर अभी भी, a[e.length]&&5 बाइट्स के लिए!

— नील

@JoKing ऊग, मैंने अभी-अभी Arnauld की नकल की है ... स्ट्रिंग इनपुट की लागत 14 बाइट्स है :-(

— नील

निश्चित रूप से, g=(A,a=eval(A))=>a.every(e=>a[e.length]&&g(e))काम करेगा?

— कृति लिथोस

@Cowsquack आह, अच्छा, जो वास्तव में 4 बाइट्स बचाता है, धन्यवाद!

— नील

Answer 2

पायथन 3 , 69 58 44 बाइट्स

11 बाइट्स एग्री द आउटगॉल्फ के लिए धन्यवाद।

मिस्टर एक्सकोडर का 14 बाइट्स धन्यवाद।

f=lambda s:all(len(e)<len(s)*f(e)for e in s)

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

Comments

@ Mr.Xcoder ने किया

— लीक नन

अरे वाह, अच्छा सुधार!

— श्री एक्सकोडर

@ Mr.Xcoder और फिर अब मुझे एहसास हुआ कि यह नील के जवाब के समान है ... इसलिए टेचीनकली नील ने मुझे हराया

— लीकी नून

Answer 3

वोल्फ्राम भाषा (गणितज्ञ) , 60 59 बाइट्स

E!=(If[Sort@#===Range[t=Tr[1^#]]-1,t,E]&//@ToExpression@#)&

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

इस समाधान का मूल कार्य है

If[Sort@#===Range[t=Tr[1^#]]-1,t,E]&

जो {0,1,2,...,n-1}किसी भी क्रम में प्रपत्र की एक सूची को आउटपुट में n(विशेष रूप से, यह कनवर्ट करता {}है 0) में परिवर्तित करता है , और किसी अन्य चीज़ को वास्तविक संख्या में परिवर्तित करता है E।

इस फ़ंक्शन को कॉल करें f। एक इनपुट को देखते हुए "{{{}},{}}", जैसे हम निम्नलिखित करते हैं:

1. एक गणितीय अभिव्यक्ति में स्ट्रिंग में कनवर्ट करें।
2. fहर स्तर पर लागू हो रही है f[{f[{f[{}]}], f[{}]}]।
3. सभी के मूल्यांकन का fप्रतिनिधित्व करने वाले इनपुट के लिए एक प्राकृतिक संख्या का उत्पादन होगा। उदाहरण के लिए, f[{f[{f[{}]}], f[{}]}]= f[{f[{0}], 0}]= f[{1, 0}]= 2। और कुछ भी उत्पादन होगा E।
4. हम परीक्षण करते हैं कि यदि परिणाम प्राकृतिक संख्या है या नहीं तो जाँच कर E।

Answer 4

ब्रेकीलॉग (v2), 9 बाइट्स

↰ᵐo.t~k|Ė

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

निर्णय-समस्या के लिए हमेशा की तरह , यह एक पूर्ण कार्यक्रम है। स्क्वायर ब्रैकेट का उपयोग करते हुए, मानक इनपुट से इनपुट। मानक आउटपुट के रूप में आउटपुट true.बनाम false.।

व्याख्या

हालांकि मैंने ऊपर कहा कि यह एक पूर्ण कार्यक्रम है, यह वास्तव में उससे अधिक दिलचस्प है; यह एक पूर्ण कार्यक्रम और एक समारोह दोनों है। जब एक पूर्ण कार्यक्रम के रूप में उपयोग किया जाता है, तो यह प्रिंट करता है true.यदि सेट एक प्राकृतिक संख्या है, या false.यदि यह नहीं है। जब एक फ़ंक्शन के रूप में उपयोग किया जाता है, तो यह एक प्राकृतिक संख्या को "सामान्य करता है" (अर्थात इसके सभी तत्वों को सामान्य करता है और उन्हें मूल्य द्वारा क्रम में क्रमबद्ध करता है; यह प्रोग्राम आंतरिक रूप से सूचियों का उपयोग करता है, सेट नहीं करता है), या "एक अपवाद फेंकता है" (वास्तव में एक विफलता, जैसा कि यह) Prolog है) यदि इनपुट प्राकृतिक संख्या नहीं है।

पूरा कार्यक्रम व्यवहार समझाने के लिए काफी आसान है: यह पूरी तरह से पूर्ण कार्यक्रमों के Brachylog के उपचार में निहित है जिसमें I / O निर्देश शामिल नहीं हैं। प्रश्न में व्यवहार "मानक इनपुट से इसके इनपुट को लेते हुए फ़ंक्शन को चलाता है, और यह कहते हुए कि इसका आउटपुट पहले कमांड-लाइन तर्क द्वारा दिए गए विवरण से मेल खाता है; यदि अभिकथन विफल हो जाता है या प्रोग्राम एक अपवाद, प्रिंट false., अन्यथा प्रिंट करता है true." । इस स्थिति में, कमांड-लाइन तर्क गायब है (यानी "कुछ भी जाता है"), इसलिए फ़ंक्शन का अपवाद / नो-अपवाद व्यवहार आउटपुट देता है।

कार्य व्यवहार के लिए:

↰ᵐo.t~k|Ė
↰ᵐ          Map a recursive call to this function over the list
  o         Sort the list
   .   |    Assert that the following operation need not change the list:
    t         Take the last (i.e. greatest) element of the list
     ~k       Append an arbitrary element to the resulting list
   .   |    Output the unchanged list
       |    Exception handler: if the above threw an exception,
        Ė     Assert that the input is empty, and output an empty list

एक प्राकृतिक संख्या को दो भागों से युक्त के रूप में परिभाषित किया गया है: नीचे दिए गए प्राकृतिक संख्या के तत्वों को संख्या के साथ संघबद्ध किया गया है। इस प्रकार, इसके सभी तत्व भी प्राकृतिक संख्याएँ हैं। हम किसी प्राकृतिक संख्या को a) यह सत्यापित करके पहचान सकते हैं कि उसके सभी तत्व प्राकृतिक संख्याएँ हैं, b) यह सत्यापित करते हुए कि सेट का सबसे बड़ा तत्व इसके सबसे बड़े तत्व के बिना सेट के समान है।

जब हम सेट (इस प्रकार वर्ग कोष्ठक) के बजाय सूचियों का उपयोग कर रहे हैं, तो हमें उन्हें काम करने के लिए समानता तुलना (इस मामले में, "मूल्य" द्वारा क्रमबद्ध) के लिए एक सुसंगत आदेश में डालने की आवश्यकता है। Brachylog का डिफ़ॉल्ट सॉर्ट क्रम सूची से पहले सूची का एक उपसर्ग छाँटेगा, जो आसानी से इसका अर्थ है कि यह संख्यात्मक मान द्वारा प्राकृतिक संख्याओं को क्रमबद्ध करेगा। इसलिए हम उन्हें लगातार क्रम में लाने के लिए अपनी सभी संख्याओं की पुनरावृत्ति कर सकते हैं। वास्तव में, जिस फ़ंक्शन के माध्यम से हम पुनरावर्ती रूप से परिभाषित कर रहे हैं, हम एक ही समय में दोनों परिणाम प्राप्त कर सकते हैं: पुनरावर्ती रूप से संख्या के तत्वों को छांट रहे हैं, और सत्यापित कर रहे हैं कि यह एक प्राकृतिक संख्या है।

इस प्रकार फ़ंक्शन के चार मुख्य भाग होते हैं। ↰ᵐपुनरावर्ती कॉल है, यह सुनिश्चित करते हुए कि प्रत्येक तत्व एक प्राकृतिक संख्या है, और इसे प्रत्येक तत्व को एक सामान्यीकृत रूप में परिवर्तित करना है। oसंख्या को सामान्य करता है (इसके तत्वों को पहले से ही सामान्यीकृत किया जाता है, इसलिए हम सभी को इसे क्रमबद्ध करना होगा)। फिर .t~k|सुनिश्चित करता है कि हमारे पास यह संरचना है कि हम यह जांच कर सकें कि सबसे बड़ा तत्व और अन्य तत्व समान हैं। एक खाली सूची (यानी 0) में एक अंतिम तत्व नहीं है, इसलिए इसके साथ एक असफलता मिलेगी t; |Ėइस मामले को संभालता है, उस मामले में एक स्पष्ट वापसी के माध्यम से जहां इनपुट सूची खाली है।

Answer 5

के (ngn / k) , २६ २४ २ n बाइट्स

~^{$[#(!#x)^o'x;0N;#x]}@`j@

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

इनपुट एक json स्ट्रिंग है जिसे पार्स किया गया है `j@(वाक्यविन्यास ngn / k के लिए विशिष्ट)

{ }तर्क के साथ एक पुनरावर्ती कार्य है x। यदि यह एक का प्रतिनिधित्व नहीं करता है, तो यह सेट xया शून्य ( 0N) द्वारा प्रस्तुत प्राकृतिक संख्या देता है ।

$[ ; ; ]अगर-तब-तब। 0 गलत है, अन्य पूर्णांक सत्य हैं

!#xx(अनन्य) की लंबाई (अनन्य) से पूर्णांक

^ के बिना

o'xoप्रत्येक ( ') के तत्व पर पुनरावर्तन ( )x

# लंबाई

^ शून्य है?

~ नहीं

@कि इतने एक डमी पिछले क्रिया के रूप में कार्य करता है ~और ^साथ बना हो { }यह करने के लिए लागू किया जा रहा करने के बजाय

Answer 6

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

ẈṢ‘⁼Jȧ@ßƇƑ

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

Answer 7

जाप , 9 बाइट्स

पोर्ट ऑफ नील जेएस समाधान । कृपया upvote करें कि यदि आप इसे बढ़ा रहे हैं।

e@Ê>XÊ©ßX

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

              :Implicit input of array U
e             :Does every element in U return true
 @            :When passed through the following function as X
  Ê           :Length of U
   >          :Greater than
    XÊ        :Length of X
      ©       :Logical AND with
       ßX     :A recursive call of the programme with X passed as the new value of U

Answer 8

लाल , 81 बाइट्स

func[a][p: 1 foreach e to-block a[p: p *(pick[1 0](length? e)< length? a)* f e]p]

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

लीक नून के पायथन 3 के जवाब के समान

Answer 9

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

߀Ṣ
ÇṖƤƑ

चूंकि इनपुट को एक स्ट्रिंग होना है, इसलिए यह सबमिशन केवल एक पूर्ण प्रोग्राम के रूप में मान्य है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

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

߀Ṣ   Helper link. Argument: A (array)

߀    Recursively map the helper link over A.
  Ṣ   Sort the result.

यह इनपुट के एक विहित प्रतिनिधित्व को जन्म देता है, जिसमें केवल क्रमबद्ध सरणियों का समावेश होता है।

ÇṖƤƑ  Main link. Argument: A (array)

Ç     Call the helper link to canonicalize the array.
   Ƒ  Fixed; call the link to the left and test if it returns its argument unchanged.
 ṖƤ       Pop prefix; for each non-empty prefix of the result, remove its last element.

Answer 10

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

Ẉ<La߀Ạ

यह लीक नून के पायथन जवाब का एक बंदरगाह है ।

चूंकि इनपुट को एक स्ट्रिंग होना है, इसलिए यह सबमिशन केवल एक पूर्ण प्रोग्राम के रूप में मान्य है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

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

Ẉ<La߀Ạ  Main link. Argument: A (array)

Ẉ        Width; compute the length of A's elements.
  L      Yield the length of A.
 <       Compare them, yielding an array of Booleans.
    ߀   Recursively map the main link over A.
   a     Take the logical AND of the Booleans and the results of the map.
      Ạ  All; yield 1 if and only if all ANDs yielded 1.

Answer 11

वोल्फ्राम भाषा (गणितज्ञ) , 52 बाइट्स

If[Max[#0/@#]<(l=2Length@#),l]&@*ToExpression/*EvenQ

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