प्राकृतिक निर्माण

27

निम्न सहित प्राकृतिक संख्याओं को औपचारिक रूप से सेट के रूप में परिभाषित किया गया है :

  • नंबर 0 को खाली सेट के रूप में परिभाषित किया गया है, {}
  • के लिए n ≥ 0, संख्या n +1 के रूप में परिभाषित n ∪ { n }।

परिणामस्वरूप, n = {0, 1, ..., n -1}।

इस प्रक्रिया द्वारा परिभाषित पहले नंबर हैं:

  • 0 = {}
  • 1 = {{}}
  • 2 = {{}, {{}}}
  • 3 = {{}, {{}}, {{}, {{}}}}

चुनौती

दिया n, एक सेट के रूप में अपने प्रतिनिधित्व का उत्पादन।

नियम

उत्पादन लगातार किसी भी उपयोग कर सकते हैं ब्रैकेट जैसे चरित्र {}, [], ()या <>। मनमाना चरित्र (जैसे 01) की अनुमति नहीं है।

ऊपर के रूप में अल्पविराम के बजाय, विभाजक कोई विराम चिह्न हो सकता है; या यह अक्षम्य हो सकता है।

रिक्त स्थान (newlines नहीं) को मनमाने और असंगत रूप से शामिल किया जा सकता है।

उदाहरण के लिए, वर्ग कोष्ठक और अर्धविराम के साथ संख्या 2 विभाजक के रूप में है [[]; [[]]], या समकक्ष है [ [ ]; [ [ ] ] ], या यहां तक ​​कि[ [ ] ;[ []]]

जिस क्रम में किसी सेट के तत्व निर्दिष्ट होते हैं, वह कोई मायने नहीं रखता। इसलिए आप प्रतिनिधित्व में किसी भी आदेश का उपयोग कर सकते हैं। उदाहरण के लिए, ये कुछ मान्य आउटपुट हैं 3:

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

आप एक प्रोग्राम या फंक्शन लिख सकते हैं । आउटपुट एक स्ट्रिंग हो सकता है या, यदि किसी फ़ंक्शन का उपयोग कर रहे हैं, तो आप एक नेस्टेड सूची या सरणी वापस कर सकते हैं जिसका स्ट्रिंग प्रतिनिधित्व उपरोक्त के अनुरूप है।

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

0  ->  {}
1  ->  {{}}
2  ->  {{},{{}}}
3  ->  {{},{{}},{{},{{}}}}
4  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
5  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}
6  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}
7  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}}
code-golf  math  number  set-theory 
— लुइस मेंडो
स्रोत
— लुइस मेंडो सेप

जवाबों:

8

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

Ḷ߀

यह एक अद्वैत कड़ी है। इसे ऑनलाइन आज़माएं!

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

प्रत्येक प्राकृतिक संख्या पिछले सभी प्राकृतिक संख्याओं का समुच्चय है, अर्थात, n = {0,…, n-1} । चूंकि 0 से पहले कोई प्राकृतिक संख्या नहीं है , इसलिए हमारे पास 0 = {} है ।

Ḷ߀  Monadic link. Argument: n (natural number)

Ḷ    Unlength; yield [0, ..., n-1].
 ߀  Recursively map this link over the range.
— डेनिस
स्रोत
3
"अनलोडिंग" मुझे जैली का उलटा कार्य पसंद है।
— 22
1
अगर मैं सही तरीके से समझ रहा हूं, तो अनलॉग्रोज़ मूल रूप से श्रेणी [0, n) है?
— डाउनगेट
5
@Downgoat यह सही है। मैं लेटर और अक्षरों को डॉट के साथ नीचे रखने की कोशिश करता हूं जैसा कि पार्श्व में होता है। चूँकि ḶLएक नो-ऑप है, इसलिए ममनोनिक अनलॉक्सी है। वहाँ भी unbinary, undecimal, unhalve, unsine, unarccosine, आदि है
— Dennis
1
रुको, अपरंपरागत? क्या यह केवल कोसाइन नहीं होगा?
— ETHproductions
@ETHproductions यप। हालांकि नीचे के साथ कोई C नहीं है।
— डेनिस
10

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

f=n=>[...Array(n).keys()].map(f)

काफी सरल।

— ETHproductions
स्रोत
1
@Downgoat मुझे लगता है कि यह पहली बार हो सकता है जब मैंने .map()बिना किसी एरो फंक्शन के इस्तेमाल किया हो :-)
— ETHproductions
अच्छी तरह से तकनीकी रूप से एफ एक तीर का कार्य है: पी
— डाउनगोट
@ETHproductions वास्तव में? .map(Number)काफी सामान्य मामला है।
— सेबस्टियन साइमन
@Xufox अच्छी बात है, मुझे लगता है कि मैंने कम से कम एक बार किया है।
— ETHproductions
4
@Xufox हालांकि .map(e=>+e)एक बाइट से छोटा है।
— कॉनर ओ'ब्रायन
7

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

{({@_}…*)[$_]}

नेस्टेड डेटा संरचना लौटाता है।

उदाहरण:

say {({@_}…*)[$_]}( 4 );
# [[] [[]] [[] [[]]] [[] [[]] [[] [[]]]]]

स्पष्टीकरण:

{   # lambda with implicit parameter ｢$_｣

  (


    # produce a lazy infinite sequence of all results

    {       # lambda with implicit parameter ｢@_｣
      @_    # array containing all previously seen values in the sequence
    }

    …       # keep repeating that block until:

    *       # Whatever ( never stop )


  )[ $_ ]   # use the outer block's argument to index into the sequence

}
— ब्रैड गिल्बर्ट b2gills
स्रोत
यह ... प्रभावशाली है।
— कोनोर ओ'ब्रायन
6

रूबी, 27 21 बाइट्स

मैं रूबी गोल्फ के लिए नया हूं, लेकिन यहां कुछ भी नहीं है। 6 बाइट बचाने के लिए जॉर्डन को धन्यवाद!

f=->s{(0...s).map &f}

यह एक पुनरावर्ती कार्य f(एक विशेष, विशिष्ट होने के लिए) है और एक तर्क लेता है s। यह खरीद के नक्शे fपर है 0...s, जो कि सीमा है [0, s)।

— कोनोर ओ ब्रायन
स्रोत
आप बदल सकते हैं map{|e|f[e]}के साथ map &f।
— जॉर्डन
@ जोर्डन वाह, अच्छा!
— कॉनर ओ'ब्रायन
4

CJam , 14 बाइट्स

"[]"{_)@\]}ri*

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

व्याख्या

"[]"            e# Push this string. It is the representation of 0, and also serves
                e# to initialize
    {     }ri*  e# Repeat this block as many times as the input number
     _          e# Duplicate
      )         e# Uncons: split into array without the last element, and last element
       @\       e# Rotate, swap
         ]      e# Pack stack contents into an array
                e# Implicitly display

प्रत्येक पुनरावृत्ति में, ब्लॉक पूर्ववर्ती संख्या से एक संख्या का प्रतिनिधित्व बनाता है। वर्णन करने के लिए, आइए दूसरी पुनरावृत्ति पर विचार करें, जहाँ से संख्या 2का निरूपण 1किया जाता है, जो कि स्ट्रिंग है "[[]]"।

  1. स्टैक शामिल हैं "[[]]"
  2. कथन _(डुप्लिकेट) के बाद इसमें शामिल है "[[]]","[[]]"
  3. बयान के बाद )(uncons) इसमें "[[]]", "[[]","]"
  4. बयान के बाद @(घुमाने) इसमें "[[]", "]","[[]]"
  5. बयान के बाद \(स्वैप) इसमें "[[]", "[[]]","]"
  6. स्टेटमेंट ](एरे में पैक) के बाद इसमें शामिल होता है ["[[]" "[[]]" "]"], जिसे स्ट्रिंग के रूप में प्रदर्शित किया जाएगा "[[][[]]]"।
— लुइस मेंडो
स्रोत
4

चेडर, 17 बाइट्स

n f->(|>n).map(f)

लघु पुनरावृत्ति + लघु श्रेणी + लघु पुनरावृत्ति = एक चुनौती जहां चेडर बहुत अच्छी तरह से करता है

गैर-प्रतिस्पर्धात्मक, 11 बाइट्स

n f->|>n=>f

=>के बाद इस चुनौती इस उत्तर गैर प्रतिस्पर्धा कर रही है जारी किया गया था ऑपरेटर जोड़ दिया गया।

यह भ्रामक लग सकता है लेकिन मुझे इसे सरल बनाने दें:

n f -> |> n => f

मूल रूप nसे इनपुट है और fफ़ंक्शन ही है। |>nउत्पन्न करता है [0, n) और =>नक्शे जो खत्म हो गए हैं f।

— Downgoat
स्रोत
1
गैर-प्रतिस्पर्धी बहुत अच्छा दिखता है: डी
— कॉनर ओ'ब्रायन
4

05AB1E , 8 7 बाइट्स

)IF)©`®

व्याख्या

)         # wrap stack in a list, as stack is empty this becomes the empty list []
 IF       # input number of times do:
   )      # wrap stack in list
    ©     # store a copy of the list in the register
     `    # flatten the list
      ®   # push the copy from the register
          # implicitly print top value of stack after the last loop iteration

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

अदनान को 1 बाइट दिया।

— Emigna
स्रोत
2 मिनट से भी कम समय
— लुइस मेन्डो सेप
@LuisMendo मैं सचमुच जब चुनौती पोस्ट किया गया था पर लॉग ऑन किया गया :)
— एमिग्ना
मेरा मानना ​​है कि आप
— अदनान
@ अदनान: उफ़। मुझे नहीं पता कि मैं कैसे चूक गया :)
— Emigna
3

अजगर, 4 बाइट्स

LyMb

परीक्षण सूट

L: yइनपुट के साथ फ़ंक्शन को परिभाषित करेंb

yMb: yरेंज पर मैप किया गया0, 1, ..., b-1

इनपुट 0 पर, यह नक्शा लौटाता है []। अन्यथा, यह yसभी नंबरों पर मैप किया गया रिटर्न अप करता है b।

— isaacg
स्रोत
3

MATL , 13 बाइट्स

Xhi:"tY:Xh]&D

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

व्याख्या

Xh              % Concatenate the stack contents into cell array. Since the stack
                % is empty, this produces the empty cell array, {}
  i:"     ]     % Take input number. Repeat that many times
     t          % Duplicate the cell array that is at the top of the stack
      Y:        % Unbox it, i.e., push its contents onto the stack
        Xh      % Concatenate the stack contents into a cell array
           &D   % String representation. Implicitly display
— लुइस मेंडो
स्रोत
2
बहुत ही चतुर उत्तर
— स्वेपर
@ शुक्रिया! हालांकि बहुत लंबा रास्ता ...
— लुइस मेंडो सेप
3

पर्ल, 27 बाइट्स

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

कई अलग-अलग तरीके सभी 27 या 28 बाइट्स के रूप में समाप्त होने लगते हैं। जैसे

#!/usr/bin/perl -p
$\=$_="{@F}"for@F[0..$_]}{

सबसे अच्छा मुझे मिल सकता है

#!/usr/bin/perl -p
s/./{$_/ for($\="{}")x$_}{

चूंकि पुराने पर्ल्स पर आप स्पेस को छोड़ सकते हैं forऔर 26 बाइट्स प्राप्त कर सकते हैं

— टन हास्पेल
स्रोत
2

मैथेमेटिका, 31 बाइट्स

सीधे नेस्टेड सूची के रूप में परिभाषा को लागू करता है। एक अनाम फ़ंक्शन का उपयोग करता है जो पुन: उपयोग करके स्वयं को कॉल करता है #0।

If[#<1,{},Join[t=#0[#-1],{t}]]&
— ग्रेग मार्टिन
स्रोत
4
आप Unionइसके बजाय एक नामित ऑपरेटर का उपयोग करके बहुत कुछ बचा सकते हैं Join: ±0={};±n_:={t=±(n-1)}⋃t... हालांकि, इस मामले में यह एक पुनरावृत्त समाधान के लिए जाने के लिए भी कम है:Nest[{#}⋃#&,{},#]&
— मार्टिन एंडर
2

रेटिना , 24 18 बाइट्स

.+
$*1<>
+`1<
<<$'

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

.+
$*1<>

यह इनपुट को यूनरी में परिवर्तित करता है और एपेंड करता है <>, का प्रतिनिधित्व करता है 0।

+`1<
<<$'

यहां, यह +इंगित करता है कि इस प्रतिस्थापन को लूप में चलाया जाना चाहिए जब तक कि स्ट्रिंग बदलना बंद न हो जाए। इसे अलग-अलग चरणों के माध्यम से समझाना आसान है, जो मैंने इसे नीचे गिराया था। प्रतिस्थापन के इस संस्करण के साथ आइए:

1<(.*)>
<<$1>$1>

यह 1शेष इनपुट (इसे हटाने और इनपुट को कम करने) के संयुक्त प्रतिनिधित्व के अंतिम से मेल खाता है , साथ ही साथ अंत में वर्तमान सेट की सामग्री भी है। इसके बाद पिछले सेट के साथ ही इसकी सामग्री के साथ एक नया सेट लगाया जाता है। हालाँकि, हम देख सकते हैं कि दोनों मामलों में $1इसके बाद है >और इसलिए हम इसे कैप्चर में शामिल कर सकते हैं और इसे प्रतिस्थापन पैटर्न से हटा सकते हैं। जो रूप की ओर ले जाता है

1<(.*)
<<$1$1

हालाँकि, अब हम यह देख सकते हैं कि (.*)बस स्ट्रिंग के प्रत्यय को पकड़ लेता है 1<और हम अंत में इस प्रत्यय को फिर से जोड़ देते हैं $1। चूँकि प्रतिस्थापन सिंटैक्स हमें मैच के बाद स्ट्रिंग के भाग को संदर्भित करने का एक तरीका देता है, जिसके साथ $'हम उन दोनों भागों को छोड़ सकते हैं और उत्तर में प्रयुक्त संस्करण के साथ समाप्त कर सकते हैं:

1<
<<$'
— मार्टिन एंडर
स्रोत
आपको यकीन है कि यह रेटिना है और> <> भाषा नहीं है? :-P
— लुइस मेंडो
@LuisMendo मुझे लगता है कि मैं इस्तेमाल कर सकता था {}, लेकिन <>एकमात्र जोड़ी है जिसे कभी भागने की ज़रूरत नहीं है, इसलिए मैंने सोचा कि मैं उसके साथ जाऊंगा। ;)
— मार्टिन एंडर
2

अंडरलोड , 14 बाइट्स

((:a*)~^()~^a)

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

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

(…)समूहीकरण मार्करों बल्कि एक टुकड़ा (केवल प्रयोग करने योग्य एक बार) की तुलना में इस एक समारोह (पुन: प्रयोज्य) बनाने के लिए आवश्यक हैं। TIO लिंक में रैपर फ़ंक्शन को विध्वंसक रूप से उपयोग करते हुए कॉल करता है ^, लेकिन इसकी प्रतिलिपि बनाकर और कॉल करते समय केवल एक कॉपी की खपत के माध्यम से इसका पुन: उपयोग किया जा सकता है। यह प्रोग्राम को इनपुट प्रदान करता है (यहां (:*:*), अर्थात 4), और आउटपुट का उपयोग करके प्रिंट करता है S।

व्याख्या

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

((:a*)~^()~^a)
(            )   Make a snippet into a function
 (   )~^         Exponentiate the following function by the top of stack:
  :                Copy the top stack element
   a               Surround the copy in parentheses
    *              Append the copy to the original, popping the copy
          ~^     Run the resulting function, with the following argument on its stack:
        ()         Empty string
            a    Surround the result in parentheses

फ़ंक्शन घातांक प्रभावी रूप से फ़ंक्शन के चरणों को कई बार दोहराने का कारण बनता है, इसलिए, उदाहरण के लिए, (:a*)iation होगा (:a*:a*:a*)। यह एक लूप लिखने का मुहावरेदार तरीका है जो अंडरलोड में दिए गए समय की संख्या को दोहराता है। (आप यह नोट कर सकते हैं कि ~^ऊपर दो अलग-अलग तरीके बताए गए हैं; ऐसा इसलिए है क्योंकि अंडरलोड में पूर्णांकों को उस पूर्णांक के लिए विशेष रूप से कार्य घातांक के रूप में परिभाषित किया गया है, इसलिए फ़ंक्शन घातांक करने के लिए, आप बस एक पूर्णांक को निष्पादित करने का प्रयास करते हैं जैसे कि यह एक फ़ंक्शन था। ।)

— ais523
स्रोत
2

एपीएल (एनएआरएस), 15 चार्ट, 30 बाइट्स

{⍵=0:⍬⋄∇¨¯1+⍳⍵}

परीक्षा:

  f←{⍵=0:⍬⋄∇¨¯1+⍳⍵}
  o←⎕fmt
  o f 0
┌0─┐
│ 0│
└~─┘
  o f 1
┌1───┐
│┌0─┐│
││ 0││
│└~─┘2
└∊───┘
  o f 2
┌2──────────┐
│┌0─┐ ┌1───┐│
││ 0│ │┌0─┐││
│└~─┘ ││ 0│││
│     │└~─┘2│
│     └∊───┘3
└∊──────────┘
  o f 3
┌3────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐│││
│     │└~─┘2 │└~─┘ ││ 0││││
│     └∊───┘ │     │└~─┘2││
│            │     └∊───┘3│
│            └∊──────────┘4
└∊────────────────────────┘
  o f 4
┌4────────────────────────────────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐ ┌3────────────────────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│ │┌0─┐ ┌1───┐ ┌2──────────┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐││ ││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│││
│     │└~─┘2 │└~─┘ ││ 0│││ │└~─┘ ││ 0││ ││ 0│ │┌0─┐││││
│     └∊───┘ │     │└~─┘2│ │     │└~─┘2 │└~─┘ ││ 0│││││
│            │     └∊───┘3 │     └∊───┘ │     │└~─┘2│││
│            └∊──────────┘ │            │     └∊───┘3││
│                          │            └∊──────────┘4│
│                          └∊────────────────────────┘5
└∊────────────────────────────────────────────────────┘

मुझे नहीं पता कि यह स्वीकार किया जाएगा ... ज़िल्ड would यहाँ है यह शून्य सेट {} का प्रतिनिधित्व करता है अगर मैं ज़िल्डे तत्व या ज़िल्ड से भरा एक तत्व प्रिंट करना चाहता हूं, और ज़िल्डे ने सभी को संलग्न किया कि क्या होता है प्रिंट कुछ भी नहीं ... इसलिए देखने के लिए कि ज़िल्ड को एक फ़ंक्शन को मैं ओ कहकर परिभाषित o←⎕fmtकरना है ( ) मैं गिनती में सम्मिलित नहीं करता हूं क्योंकि तत्व और इसकी संरचना मौजूद है भले ही sys इसे प्रिंट न करें ... यह संभव है अगर io 0 है

{⍵=0:⍬⋄∇¨⍳⍵}

12 अक्षरों का समाधान भी हो सकता है ...

— RosLuP
स्रोत
1

रैकेट 119 बाइट्स

(λ(n)(define ll(list'()))(for((i(range 1 n)))(set! ll(cons ll(for/list((j(length ll)))(list-ref ll j)))))(reverse ll))

Ungolfed:

(define f
  (λ (n)
    (define ll (list '()))
    (for ((i (range 1 n)))
      (set! ll
            (cons ll
                  (for/list ((j (length ll)))
                    (list-ref ll j)
                    ))))
    (reverse ll)))

परीक्षण (रैकेट में {} समान है () और डिफ़ॉल्ट आउटपुट () है:

(f 4)

'(() (()) ((()) ()) (((()) ()) (()) ()))

प्रत्येक संख्या (0 से 3) को स्पष्ट रूप से देखने के लिए: 

(for((i (f 4)))  (println (reverse i)))

'()
'(())
'(() (()))
'(() (()) ((()) ()))
— rnso
स्रोत
1

बैच, 74 बाइट्स

@set s={}
@for /l %%i in (1,1,%1)do @call set s={%%s%%%%s:~1%%
@echo %s%

इस तथ्य का उपयोग करता है कि प्रत्येक उत्तर अग्रणी के बाद खुद में डाले गए पिछले उत्तर के बराबर है {। पहले कुछ आउटपुट इस प्रकार हैं:

{}

{{}}

{{{}}{}}

{{{{}}{}}{{}}{}}

{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}

{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
— नील
स्रोत
क्या आप इनपुट और आउटपुट फॉर्मेट दिखाते हुए एक उदाहरण पोस्ट कर सकते हैं?
— लुइस मेंडो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.