सेट के साथ प्राकृतिक संख्याओं का निर्माण

Question

यह निर्माण प्राकृतिक संख्याओं का प्रतिनिधित्व करने का एक तरीका है।

इस प्रतिनिधित्व में, 0 को खाली सेट के रूप में और अन्य सभी संख्याओं के लिए परिभाषित किया गया है, n {0} और {n-1} का मिलन है।

3 के निर्माण के लिए उदाहरण के लिए हम एल्गोरिथ्म का पालन कर सकते हैं:

3 =
{ø, 2} =
{ø, {ø, 1}} =
{ø, {ø, {ø}}}

कार्य

जैसा कि आपने अनुमान लगाया होगा कि आपका कार्य एक प्राकृतिक संख्या (शून्य सहित) में लेना है और इसके निर्माण का उत्पादन करना है।

यदि आपकी पसंद की भाषा ऐसी वस्तुओं का समर्थन करती है, तो आप एक स्ट्रिंग के रूप में या एक सेट ऑब्जेक्ट के रूप में आउटपुट कर सकते हैं।

यदि आप एक स्ट्रिंग के रूप में आउटपुट का चयन करते हैं तो आपको घुंघराले ब्रेस ( {}) के साथ एक सेट का प्रतिनिधित्व करना चाहिए । आप वैकल्पिक रूप से खाली सेट का प्रतिनिधित्व कर सकते हैं ø(अन्यथा यह बिना किसी प्रविष्टि के एक सेट होना चाहिए {})। आप सेट में प्रविष्टियों के बीच और बाद में अल्पविराम और व्हाट्सएप जोड़ना चुन सकते हैं।

आदेश महत्वपूर्ण नहीं है, हालाँकि आपके द्वारा सेट किए गए सेट में कोई दोहराए गए तत्व नहीं हो सकते हैं (उदाहरण के लिए {ø,ø})

यह कोड-गोल्फ है इसलिए लक्ष्य सबसे कम बाइट्स है

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

यहां कुछ उदाहरण आउटपुट के साथ कुछ परीक्षण मामले हैं।

0 -> {}
1 -> {{}}
2 -> {{}{{}}}
3 -> {{}{{}{{}}}}
4 -> {{}{{}{{}{{}}}}}

Comments

@ mbomb007 इससे कोई फर्क नहीं पड़ता कि परिभाषा "गलत" है या नहीं। यह अभी भी एक ठीक चुनौती है (और एक अलग)।

— मार्टिन एंडर

बारीकी से संबंधित।

— मार्टिन एंडर

@ mbomb007 परीक्षण के मामले और इस चुनौती में दी गई परिभाषा मेल खाती है, और अन्य चुनौती से अलग हैं। यदि कुछ भी हो, तो लिंक में सुधार किया जा सकता है, लेकिन मुझे नहीं लगता कि लिंक स्वयं चुनौती के लिए प्रासंगिक है।

— मार्टिन एंडर

उन्होंने इसे वॉन न्यूमैन निर्माण कहा, हालांकि, और यह चुनौती नहीं है। यही दुआ है। यह निम्नानुसार है कि प्रत्येक प्राकृतिक संख्या सभी प्राकृतिक संख्याओं से कम के बराबर है

— mbomb007

क्या हम एक सेट-जैसे ऑब्जेक्ट को किसी फ़ंक्शन से सूचियों की सूची में वापस ला सकते हैं या अपनी भाषा का प्रतिनिधित्व STDOUT में प्रिंट कर सकते हैं?

— डेनिस

Answer 1

पायथन , 28 बाइट्स

lambda x:"{{}"*x+x*"}"or"{}"

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

यह समस्या का एक बहुत अच्छा समाधान है। शून्य से अधिक संख्या के लिए आप स्ट्रिंग सूत्र के साथ प्रतिनिधित्व प्राप्त कर सकते हैं "{{}"*x+"}"*x। हालांकि यह शून्य के लिए काम नहीं करता है जहां यह खाली स्ट्रिंग है। हम orखाली सेट को वापस करने के लिए शॉर्ट सर्किट के लिए इस तथ्य का उपयोग कर सकते हैं ।

मैं इस समस्या को हल करने के लिए अजगर की निर्मित वस्तुओं का उपयोग करना चाहता था लेकिन दुर्भाग्य से:

TypeError: unhashable type: 'set'

आप सेट के अंदर सेट को अजगर में नहीं डाल सकते।

Comments

आप x"{{}"*x+x*"}"or

— रॉड

f=हटाया जा सकता है।

— यति

सीएफ codegolf.stackexchange.com/a/111696/62084

— बॉलपॉइंटबैन

वहाँ है frozenset लेकिन किसी को भी उस के लिए बाइट्स नहीं मिला है ...

— फल

Answer 2

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

f 0="{}"
f n=([1..n]>>)=<<["{{}","}"]

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

10 मिनट पहले तक इस तरह के जवाब से मुझे कोई मतलब नहीं था। सभी क्रेडिट इस सुझाव के जवाब में जाते हैं ।

असल में, हम (लेकिन इसे केवल n के बजाय n तत्वों की सूची को पास करते हुए) के >>रूप में उपयोग करते हैं concat $ replicate, और फिर, प्रत्येक स्ट्रिंग को सूची में n के =<<रूप concatMapमें दोहराते हैं और परिणाम को एक स्ट्रिंग में परिवर्तित करते हैं।

0मामले को अलग से इलाज किया जाता है के रूप में यह एक खाली स्ट्रिंग लौट आते हैं।

Comments

@ लैकोनी मैंने भी कुछ ऐसा ही करने की कोशिश की, लेकिन आपको f 1इसे सही ढंग से काम करने के लिए विशेष मामले की भी आवश्यकता होगी

— लियो

वास्तव में। फिर मुझे आपका संस्करण और भी पसंद है।

— लिकोनी

Answer 3

जावास्क्रिप्ट, 28 बाइट्स

f=n=>n?--n?[[],f(n)]:[[]]:[]

रिप्रेसेन्ट एरे का उपयोग करके सेट करता है। 38-बाइट अप्रतिस्पर्धी समाधान:

n=>'{{}'.repeat(n)+'}'.repeat(n)||'{}'

उदाहरण आउटपुट स्ट्रिंग्स लौटाता है।

Answer 4

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

मैं इस बाइट गिनती में दो समाधान मिल गया है:

Nest[{{}}~Union~{#}&,{},#]&
Union//@Nest[{{},#}&,{},#]&

Comments

32 बाइट्स के पास मिस #//.{1->{{}},x_/;x>1->{{},x-1}}&:। हालांकि मुझे लगता है कि यह इनपुट 0

— ग्रेग मार्टिन

Answer 5

पर्ल 6 , 37 बाइट्स

{('{}','{{}}',{q:s'{{}$_}'}...*)[$_]}

कोशिश करो

विस्तारित:

{   # bare block lambda with implicit parameter ｢$_｣

  (
    # generate a sequence

    '{}',   # seed it with the first two values
    '{{}}',

    {   # bare block lambda with implicit parameter ｢$_｣

      q         # quote
      :scalar   # allow scalar values

      '{{}$_}'  # embed the previous value ｢$_｣ in a new string

    }

    ...         # keep using that code block to generate values

    *           # never stop

  )[ $_ ] # get the value at the given position in the sequence
}

Comments

क्या आप एक उद्धरण टर्मिनेटर याद कर रहे हैं :या यह पर्ल 6 के लिए कुछ नया है?

— क्रेगआर 8806

@ CraigR8806 आप कॉलोन का उपयोग पर्ल 6 में निर्माणों को उद्धृत करने के लिए नहीं कर सकते क्योंकि क्रियाविशेषणों के लिए उपयोग किया जाता है। (विस्तृत संस्करण को देखें)

— ब्रैड गिल्बर्ट b2gills

Answer 6

05AB1E , 6 5 बाइट्स

कोड

ƒ)¯sÙ

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!या सभी परीक्षण मामलों को सत्यापित करें! ।

व्याख्या

ƒ       # For N in range(0, input + 1)..
 )      #   Wrap the entire stack into an array
  ¯     #   Push []
   s    #   Swap the two top elements
    Ù   #   Uniquify the array

Comments

F¯), वह काम नहीं करता है?

— मैजिक ऑक्टोपस Urn

@carusocomputing मुझे नहीं लगता कि यह काम करता है n=0, क्योंकि आउटपुट खाली है (खाली सेट नहीं)।

— अदनान

Answer 7

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

.+
$*
\`.
{{}
{

^$
{}

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

व्याख्या

.+
$*

इनपुट को unary में बदलें।

\`.
{{}

प्रत्येक अयोग्य अंक {{}को एक अनुरेखित लाइनफीड ( \) के बिना परिणाम के साथ प्रिंट करें ।

{

शुरुआती {एस को हटा दें , ताकि शेष }बिल्कुल वही हो जो हमें अभी भी सभी सेटों को बंद करने के लिए प्रिंट करने की आवश्यकता है। हालाँकि, उपरोक्त प्रक्रिया इनपुट के लिए विफल होती है 0, जहां हम कुछ भी प्रिंट नहीं करेंगे। इसलिए...

^$
{}

यदि स्ट्रिंग खाली है, तो इसे खाली सेट के साथ बदलें।

Comments

मैं सोच रहा था कि nरेटिना में एक स्ट्रिंग बार कैसे दोहराया जाए ...

— नील

Answer 8

ब्रेन-आलोचना , 135 बाइट्स

के लिए +1 शामिल है -A

(({}())<{({}[()]<((((((()()()()()){}){}){}())()){}{})>)}{}({}[()()])>)(({})<{({}[()]<(((({}()())[()()])))>)}{}>[()]){(<{}{}{}>)}{}{}{}

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

(({}())<                 # Replace Input with input + 1 and save for later
  {({}[()]<              # For input .. 0
    (...)                # Push '}'
  >)}{}                  # End for and pop counter
  ({}[()()])             # change the top '}' to '{'. This helps the next stage
                         # and removes the extra '}' that we got from incrementing input
>)                       # Put the input back on

(({})<                   # Save input
  {({}[()]<              # For input .. 0
    (((({}()())[()()]))) # Replace the top '{' with "{{{}"
  >)}{}                  # end for and pop the counter
>[()])                   # Put down input - 1
{(<{}{}{}>)}             # If not 0, remove the extra "{{}"
{}{}{}                   # remove some more extras

Answer 9

रोड़ा , 37 बाइट्स

f n{[[[],f(n-1)]]if[n>1]else[[[]]*n]}

Answer 10

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

Lri{]La|}*p

सूचियों की सूची से मिलकर एक सेट जैसी वस्तु प्रिंट करता है। CJam रिक्त सूचियों को रिक्त स्ट्रिंग्स के रूप में प्रिंट करता है, क्योंकि सूचियाँ और स्ट्रिंग्स लगभग विनिमेय हैं।

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

व्याख्या

L            Push an empty array 
 ri          Read an integer from input
   {    }*   Run this block that many times:
    ]          Wrap the entire stack in an array
     La        Wrap an empty list in an array, i.e. [[]]
       |       Set union of the two arrays
          p  Print the result

पुराना उत्तर, 21 18 बाइट्स

इससे पहले कि यह पुष्टि की गई थी कि एक नेस्टेड सूची संरचना को प्रिंट करना ठीक था। स्ट्रिंग पुनरावृत्ति एल्गोरिथ्म का उपयोग करता है।

मार्टिन एंडर के लिए 3 बाइट्स बचाए गए!

ri{{}}`3/f*~_{{}}|

व्याख्या

ri                  Read an integer from input
  {{}}`             Push the string "{{}}"
       3/           Split it into length-3 subtrings, gives ["{{}" "}"]
         f*         Repeat each element of that array a number of times equal to the input
           ~_       Dump the array on the stack, duplicate the second element
             {{}}|  Pop the top element, if it's false, push an empty block, which gets 
                      printed as "{}". An input of 0 gives two empty strings on the 
                      repetition step. Since empty strings are falsy, we can correct the 
                      special case of 0 with this step.

Answer 11

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

⁸,⁸Q$¡

यह एक निलादिक लिंक है जो STDIN से पूर्णांक को पढ़ता है और एक रग्ड सरणी देता है।

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

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

⁸,⁸Q$¡  Niladic link.

⁸       Set the return value to [].
    $   Combine the three links to the left into a monadic chain.
 ,⁸     Pair the previous return value with the empty array.
   Q    Unique; deduplicate the result.
     ¡  Read an integer n from STDIN and call the chain to the left n times.

Answer 12

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

f=lambda n:[[],n and f(n-1)][:n]

सबसे छोटा रास्ता नहीं है, लेकिन मुझे बस पुनरावृत्ति के साथ ऐसा करना था ।

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

Answer 13

कार्डिनल , 51 50 बाइट्स

%:#>"{"#? v
x  ^?-"}{"<
v <8/ ?<
>  8\
v"}"<
>?-?^

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

व्याख्या

%:#
x

इनपुट प्राप्त करें और # से नीचे और बाएं भेजें

   >"{" ? v
   ^?-"}{"<

"{" एक बार प्रिंट करें फिर "{} {" n-1 बार अगर n> 1 प्रिंट करें तो "{}" प्रिंट करें अगर n> 0

       #

v <8/ ?<
>  8\

पहला लूप पूरा होने तक इनपुट वैल्यू पर होल्ड करें

v"}"<
>?-?^

प्रिंट "}" एक बार फिर n-1 बार दोहराएँ अगर n> 1

Answer 14

एएचके, 55 बाइट्स

IfEqual,1,0
s={{}{}}
Loop,%1%
s={{ 2}{}}%s%{}}
Send,%s%

यह कम से कम जवाब नहीं है, लेकिन मुझे यह बहुत अच्छा लगा, क्योंकि ऑटोहॉट्की के आइडिओसिप्रेसरीज इस रिकर्सन विधि को सुपर गलत बनाते हैं। Ifऔर Loopकथन मान लें कि अगली पंक्ति में केवल वही चीज़ शामिल है यदि ब्रैकेट का उपयोग नहीं किया गया है। घुंघराले ब्रैकेट पात्रों से बच जाते हैं इसलिए आपको उन्हें पाठ के रूप में उपयोग करने के लिए अन्य घुंघराले कोष्ठक के साथ बचना होगा। इसके अलावा, चर 1पहला पारित तर्क है। जब मैं उन tidbits को जाने बिना कोड पढ़ता हूं, तो तर्क इस तरह दिखता है:

• यदि 1 = 0 है, तो सेट करें s गलत उत्तर के बराबर
• लूप करें और हर बार शुरुआत में ब्रैकेट और कुछ को अंत तक जोड़ें
• वर्तमान विंडो में परिणामी स्ट्रिंग भेजकर वापस लौटें

सभी ब्रैकेट एस्केप पात्रों के बिना, यह इस तरह दिखेगा:

IfEqual,1,0
   s={}
Loop,%1%
   s={{}%s%}
Send,%s%

Answer 15

जावास्क्रिप्ट 50 बाइट्स

g=n=>n==0?"":"{{}"+g(n-1)+"}"
z=m=>m==0?"{}":g(m)

Comments

जब कोई संख्या 0 के बराबर हो तो यह जावास्क्रिप्ट के लिए एक मिथ्या मूल्य है। तो आप == 0 को हटा सकते हैं यदि आप अपनी

— त्रिक

Answer 16

टिनिइलिस , 52 बाइट्स

(d f(q((n)(i n(i(e n 1)(c()())(c()(c(f(s n 1))())))(

इसे ऑनलाइन आज़माएं!(दोहन परीक्षण)।

व्याख्या

ध्यान दें कि (cons x (cons y nil))कैसे आप लिस्ट में xऔर yलिस्प में एक सूची बनाते हैं ।

(d f           Define f to be
 (q(           a quoted list of two items (which acts as a function):
  (n)           Arglist is a single argument n
  (i n          Function body: if n is truthy (i.e. nonzero)
   (i(e n 1)     then if n equals 1
    (c()())       then cons nil to nil, resulting in (())
    (c            else (if n > 1) cons
     ()            nil to
     (c            cons
      (f(s n 1))    (recursive call with n-1) to
      ())))         nil
   ()))))        else (if n is 0) nil

Answer 17

सी (जीसीसी) , 52 बाइट्स

n(i){putchar(123);i>1&&n(0);i&&n(i-1);putchar(125);}

कुछ शॉर्ट सर्किट मूल्यांकन और पुनरावृत्ति का लाभ उठाते हुए।

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

Comments

48 बाइट्स

— सीलिंगकैट

Answer 18

प्योर बैश , 49 48 41 बाइट्स

for((;k++<$1;)){ s={{}$s};};echo ${s-{\}}

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

Answer 19

डीसी , 46 बाइट्स

[[{}]]sx256?^dd3^8d^1-/8092541**r255/BF*+d0=xP

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

स्टड पर इनपुट, स्टडआउट पर आउटपुट।

यह बेस-256 नंबर के रूप में वांछित आउटपुट के लिए एक सूत्र की गणना करके काम करता है। Dc में P कमांड को तब स्ट्रिंग के रूप में बेस-256 नंबर को प्रिंट करने के लिए उपयोग किया जाता है।

---

आगे की व्याख्या:

N को इनपुट n होने दें। डीसी कार्यक्रम के योग की गणना करता है

A = मंजिल (256 ^ n / 255) * 125 (BF को 11 * 10 + 15 = 125 के रूप में डीसी द्वारा व्याख्या किया गया है)

तथा

बी = मंजिल ((256 ^ n) ^ 3 / (8 ^ 8-1)) * 8092541 * (256 ^ n)।

 

के लिए:

ध्यान दें कि 1 + 256 + 256 ^ 2 + ... + 256 ^ (n-1) बराबर (256 ^ n-1) / 255, एक ज्यामितीय प्रगति के लिए सूत्र द्वारा, और यह बराबर मंजिल (256 ^ n / 255) )। तो यह संख्या 1 है जिसमें n 256 का आधार 256 है।

जब आप ए प्राप्त करने के लिए इसे 125 से गुणा करते हैं, तो परिणाम n 125 के आधार 256 में संख्या होती है (125 बेस 256 में एकल अंक है, निश्चित रूप से)। आधार संख्या में अंकों को हेक्स संख्या के रूप में लिखना शायद बेहतर है; 125 हेक्स 7 डी है, इसलिए ए एक पंक्ति में n 7 डी के आधार पर 256 नंबर है।

 

बी समान है:

इस बार देखें कि 1 + 16777216 + 16777216 ^ 2 + ... + 16777216 ^ (n-1) बराबर (16777216 ^ n - 1) / 16777215, और यह बराबर मंजिल (16777216 ^ n / 16777215)।

अब, 256 ^ 3 = 16777216, और 8 ^ 8-1 = 16777215, तो यह वही है जो हम फर्श के रूप में गणना कर रहे हैं ((256 ^ n) ^ 3 / (8 ^ 8-1)।

ज्यामितीय श्रृंखला प्रतिनिधित्व से, आधार 256 में यह संख्या 100100100 है ... 1001 अंकों के n के साथ 1 और बाकी के अंक 0 हैं।

यह 8092541 से गुणा किया जाता है, जो कि हेक्साडेसिमल में 7B7B7D है। बेस 256 में, यह एक तीन अंकों की संख्या है जिसमें 7B, 7B, और 7D अंक (सुविधा के लिए हेक्स में उन अंकों को लिखना) शामिल हैं।

यह निम्नानुसार है कि बेस 256 में लिखा गया उत्पाद 3-अंकों की संख्या है जिसमें 3 अंक 7 बी 7 बी 7 डी दोहराया गया है।

यह 256 ^ n से गुणा किया जाता है, जिसके परिणामस्वरूप 4n-अंक आधार-256 संख्या होती है, जिसमें 3 अंक 7B 7B 7D 7 बार दोहराया जाता है, जिसके बाद n 0 होता है। वह बी।

 

A + B को जोड़ने पर अब 4n-digit base-256 नंबर प्राप्त होता है जिसमें 3 अंक 7B 7B 7D 7 बार दोहराया जाता है, इसके बाद n 7D होता है। चूंकि क्रमशः 7B और 7D ASCII कोड हैं {और }क्रमशः, यह स्ट्रिंग है जिसमें n प्रतियों की {{}n प्रतियां शामिल हैं।} है, जो वास्तव में क्या हम n के लिए चाहते हैं> 0. डीसी में पी आदेश प्रिंट एक आधार-256 नंबर एक स्ट्रिंग के रूप में, जैसे हमें ज़रूरत है।

दुर्भाग्य से, n = 0 को एक विशेष मामले के रूप में माना जाना चाहिए। ऊपर की गणना 0 = n = 0 के लिए परिणाम देने के लिए होती है; उस स्थिति में, मैंने स्ट्रिंग की छपाई को हार्ड-कोड किया है {}।

Comments

उस मुद्रण आदेश के कम ज्ञात व्यवहार का उपयोग करते हुए यह एक बहुत ही दिलचस्प दृष्टिकोण है। अच्छी तरह से किया! यह कैसे काम करता है इसका एक स्पष्टीकरण उत्तर में सुधार करेगा।

— शेषमारा

@seshoumara धन्यवाद - मैंने एक विस्तृत विवरण जोड़ा है।

— मिशेल स्पेक्टर

Answer 20

जावा 7, 61 बाइट्स

String p(int p){return p<1?"{}":p<2?"{{}}":"{{}"+p(p-1)+"}";}

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

Answer 21

बैच, 88 बाइट्स

@set s={}
@if %1 gtr 0 set s=&for /l %%i in (1,1,%1)do @call set s={{}%%s%%}
@echo %s%

Answer 22

ब्रेनफ *** , 99 बाइट्स

>+>+>+>+<[>[-<+++++>]<-<]>--[->+>+<<]
>[-<+>]>++<,[[->>+>+<<<]>>[-<<<..>>.>]>[-<<.>>]+[]]<.>>.

(सौंदर्यशास्त्र के लिए न्यूलाइन) चूंकि यह ब्रेनफ *** है, इसलिए इसे एससीआई चार कोड के रूप में इनपुट लिया जाता है (इनपुट "ए" बीटीसी से मेल खाती है)

दिमागी, 60 बाइट्स

इसके अलावा, मेरी कस्टम भाषा में (ब्रेनफ़ ** आधारित, दुभाषिया यहाँ ):

#123#[->+>+<<]>++<,[[-<+<+>>]<[->>>..<.<<]<[->>>.<<<]!]>>.<.

आपको दुभाषिया में प्रोग्राम इनपुट को हार्डकोड करना होगा क्योंकि मैं आलसी हूं।

Comments

साइट पर आपका स्वागत है! क्यों है एक []? ऐसा लगता है कि इसे हटाया जा सकता है

— पोस्ट रॉक गार्फ हंटर

यदि आपके पास ऐसा नहीं है, तो यह अंत में एक अतिरिक्त {} आउटपुट करेगा (यह असीम रूप से छोरों)।

— internet_user

Answer 23

05AB1E , 5 3 बाइट्स

F¯)

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

इस संस्करण के बाद उन्होंने स्पष्ट किया कि सेट ठीक हैं।

F   # From 1 to input...
 ¯  # Push global array (default value is []).
  ) # Wrap stack to array.

---

पुराना संस्करण (जो ø का उपयोग करता है):

05AB1E , 5 4 बाइट्स

FX¸)

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

कहाँ 1के बराबर है ø।

F    # From 1 to input...
 X   # Push value in register X (default is 1).
  ¸  # Wrap pushed value into an array.
   ) # Wrap whole stack into an array.
     # Implicit loop end (-1 byte).
     # Implicit return.