सूची * सभी * tuples!

Question

एक प्रोग्राम लिखें, जो एक इनपुट n है , प्राकृतिक संख्याओं का उपयोग करके सभी संभव n-tuples उत्पन्न करेगा।

n=1
(1),(2),(3),(4),(5),(6)...

n=2
(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3)...

n=6
(1,1,1,1,1,1) (1,1,1,1,2,1) (1,1,1,2,1,1)... 

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

सैंडबॉक्स चरण के दौरान प्रतिक्रिया के लिए "आर्टेमिस फॉवेल" के लिए धन्यवाद।

Comments

मुझे लगता है कि यह मान्य है अगर प्रोग्राम क्रैश हो जाता है तो यह अब तक छपी टुपल्स के अलावा कुछ विलुप्त आउटपुट पैदा करता है, है ना?

— लुइस मेंडो

क्या हमें आउटपुट करना चाहिए क्योंकि हम जाते हैं या एक ऐसा फंक्शन होता है जो समय के अंत में एक अनंत सूची तैयार करता है?

— जोनाथन एलन

"आप अपनी सुविधा के लिए अपने प्रोग्राम के आउटपुट फॉर्मेट का चयन कर सकते हैं, जब तक कि प्रत्येक ट्यूपल के अंदर ट्यूपल्स और संख्याओं के बीच अलगाव स्पष्ट और सुसंगत नहीं होता है" - क्या हम अलग-अलग ( इस तरह अलग-अलग) अलग-अलग आउटपुट कर सकते हैं ?

— जोनाथन एलन

@JonathanAllan मुझे प्रोग्राम के भाग के रूप में उस ऑब्जेक्ट की अनंत सामग्री का आउटपुट शामिल करना होगा।

— बिल्वपत्र

संबंधित (प्राकृतिक संख्या के बजाय पूर्णांक)

— फल

Answer 1

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

πN

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

व्याख्या

Nप्राकृतिक संख्या की अनंत सूची है [1,2,3,4,..। πकार्टेसियन शक्ति है। परिणाम सूचियों की एक अनंत सूची है। वांछित लंबाई की प्रत्येक सूची ठीक एक बार होती है क्योंकि πइस तरह से शांत होती है। इनपुट और आउटपुट निहित हैं।

Comments

वाह, और यह [1,1, n] भी नहीं करता है। वहाँ आदेश के लिए एक पैटर्न यह आउटपुट है?

— बिल्वपत्र

@billpg यह पुनरावर्ती रूप से ट्यूपल्स का निर्माण करता है: n- ट्यूपल्स को मूल सूची के कार्टेसियन उत्पाद और n-1सूचकांक की राशि के आरोही क्रम में -tuples की सूची में ले जाकर प्राप्त किया जाता है ।

— ज़र्गब

"सूचकांकों के योग का आरोही क्रम" - क्या आप इसे स्पष्ट कर सकते हैं? मुझे यह देखने में परेशानी हो रही है कि क्यों, जैसे, 2,2,2के बाद 4,1,2और आता है 5,1,1।

— योना

@ जोनाह पुनरावृत्ति इस तरह काम करता है। आप 1-ट्यूपल्स के साथ शुरू करते हैं N। 2-ट्यूपल्स के लिए आप Nसूचकांकों के योग के साथ कार्टेशियन उत्पाद लेते हैं । दोनों सूचियों में, प्रत्येक संख्या nसूचकांक पर है nइसलिए लंबाई 2 के लिए परिणाम योग द्वारा आदेश दिया जाना है। 3-ट्यूपल्स प्राप्त करने के लिए आप Nइन सूचियों में तत्वों के सूचकांकों के योग द्वारा ऑर्डर किए गए कार्टेशियन उत्पाद और 2-ट्यूपल्स की सूची लेते हैं । यह टपल के योग को नहीं देखता है, यह टुपल्स की सूची में अपनी स्थिति को देखता है।

— ज़र्गब

"इस कार्य में अनंत के विभिन्न आयामों को चित्रित करें और एक ऐसा पैटर्न खोजें जो इसे गिनने योग्य अनंत तक कम कर देता है, फिर एक कार्यक्रम लिखें जो इस पैटर्न पर पुनरावृत्त करता है।" - "अरे, मेरे पास इसके लिए एक बिलिन है!"

— फेबियन रोलिंग

Answer 2

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

([1..]>>=).(!)
0!s=[[]|s<1]
n!s=[a:p|a<-[1..s],p<-(n-1)!(s-a)]

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

n!s सभी उत्पन्न करता है n -tuples है s।

तो जवाब है ([1..]>>=).(!) , यानी \n -> [t | s<-[1..], t<-n!s]।

यह एक फ़ंक्शन है जो एक पूर्णांक nको ट्यूपल्स (पूर्णांक की सूची) की एक अनन्त आलसी सूची में मैप करता है।

Answer 3

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

f n=[l|k<-[0..],l<-mapM([0..k]<$f)[0..n],sum l==k]

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

सूचियाँ n-टुप द्वारा छांटे गए। 0 से k तक की mapMसभी nसंख्याओं को उत्पन्न करने के लिए भारी उठाने का काम करता है । <$fचाल है कि यहां बताया गया ।

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

f 1=pure<$>[0..]
f n=[a-k:k:t|a:t<-f$n-1,k<-[0..a]]

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

प्रत्येक -tuple की पहली संख्या को दो संख्याओं में विभाजित करके सभी n-1-tuples में पुनरावर्ती रूप से सभी -tuples को nखींचता है , इसे हर संभव तरीके से।an-1a-k,k

Answer 4

पायथ - 9 बाइट्स

गोल्फ के लिए @FryAmTheEggman को धन्यवाद

सभी एक्स के माध्यम से लूप्स, और [1..x] ^ एन। यह डुप्लिकेट बनाता है, इसलिए केवल उन लोगों को रखता है जो उस एक्स के लिए नए हैं, उर्फ ​​उनमें एक्स होते हैं। स्वरूपण थोड़ा अजीब है, लेकिन इसे एक और बाइट के साथ मानक बनाया जा सकता है,.V1j}#b^Sb

.V1}#b^Sb

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

Comments

f}bT-> }#bइसके अलावा, इस समय आपकी बाइट गिनती गलत लगती है?

— FryAmTheEggman

@FryAmTheEggman रुको, यह गलत क्यों है? यदि आप TIO लिंक के बारे में बात कर रहे हैं, जिसमें प्रारूपण शामिल है j(b)। इसके अलावा, गोल्फ के लिए धन्यवाद।

— माल्टीसेन

आह, यह मुझे उलझन में है, क्षमा करें!

— FryAmTheEggman

Answer 5

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

~l.ℕᵐ+≜∧≜

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

यह एक अनंत जनरेटर है जो सभी संभव ट्यूपल्स उत्पन्न करता है। TIO लिंक में एक हेडर होता है जो 1000 तत्वों को उत्पन्न करने के लिए जनरेटर का उपयोग करता है और उन्हें प्रिंट करता है (लेकिन जनरेटर अनिश्चित काल तक जारी रह सकता है यदि मैंने इसके बजाय कहा; ब्रेजलॉग के पूर्णांक अनबाउंड हैं)।

ऐसा लगता है कि एक कठिन रास्ता होना चाहिए, लेकिन बहुत सारी बाधाएं हैं और यह सबसे कठिन है मैं उन्हें एक कार्यक्रम में फिट कर सकता हूं।

व्याख्या

~l.ℕᵐ+≜∧≜
  .        Generate
        ≜  all explicit
~l         lists whose length is {the input}
    ᵐ      for which every element
   ℕ       is non-negative
     +     and whose sum
      ≜    is used to order the lists (closest to zero first)
       ∧   [remove unwanted implicit constraint]

संयोग से, यह मुझे दिलचस्प लगता है कि दोनों की मेरी व्याख्याएं कितनी अलग ≜हैं, इसके बावजूद वे ब्रिग्लॉग के दृष्टिकोण से सटीक काम करते हैं। पहला ≜कार्यक्रम में पहला nondeterministic विधेय है, इसलिए यह परिणामों का क्रम निर्धारित करता है; इस स्थिति में, यह 0, 1, 2, 3… क्रम में सूची के योग के लिए सभी संभावित स्पष्ट मानों की गणना करता है, और यह सुनिश्चित करने के लिए उपयोग किया जा रहा है कि सूचियां उनकी राशि के क्रम में आउटपुट हैं (यह सुनिश्चित करता है कि प्रत्येक संभव है सूची उत्पादन की एक परिमित राशि के बाद दिखाई देती है)। दूसरे ≜का उपयोग सूची के लिए सभी स्पष्ट संभावनाओं की गणना करने के लिए किया जाता है (बजाय एक फार्मूला तैयार करने के कि कैसे सूची के तत्व एक दूसरे से संबंधित हैं)।

Comments

↰₁ẉ⊥एक अच्छा हेडर भी है, असीम रूप से छपाई के लिए।

— असंबंधित स्ट्रिंग

हालांकि मुझे ऐसा लगता है कि यह वास्तव में एक पूर्ण उत्तर नहीं हो सकता है, क्योंकि इस विधेय के किसी भी स्वतंत्र आह्वान से केवल शून्य उत्पन्न होगा , हेडर में ᶠया उसके द्वारा किए जा रहे "उत्पन्न सभी" भाग के साथ ⊥।

— असंबंधित स्ट्रिंग

@UnrelatedString आपका कोड, हालांकि जनरेटर के रूप में विधेय का उपयोग नहीं करता है। हमारे पास जनरेटर का उपयोग करके सूची उत्पादन की अनुमति देने वाले स्पष्ट नियम हैं । आप अपने TIO लिंक में क्या कर रहे हैं, 1000 अलग-अलग जनरेटर प्राप्त करने के लिए एक लूप में विधेय को बुला रहा है, फिर उनमें से प्रत्येक से पहला आउटपुट ले रहा है; जनरेटर पर करने के लिए यह वास्तव में अप्राकृतिक ऑपरेशन है, और यह आपको अन्य तत्वों को देखने नहीं देगा जो वे उत्पन्न कर सकते हैं।

— अनीस 523

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

— असंबंधित स्ट्रिंग

Answer 6

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

{$++.polymod(1+$++ xx $_-1).say xx *}

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

आवश्यक polymodरूप से आवश्यक रूप से कई प्रविष्टियों के साथ चलता है , जहां मोडुलो हमेशा इनपुट से अधिक होता है, अर्थात 0.पोलिमॉड (1,1,1), 1.पोलिमोड (2,2,2) आदि। इस तरह से अंक हमेशा भीतर होता है। क्षेत्र। Perl6 मुझे modulo अनंत नहीं होने देगा ...

Comments

यह प्रत्येक टपल को बिल्कुल एक बार (0, 1, 0, 0)सूचीबद्ध नहीं करता है (उदाहरण के लिए, सूचीबद्ध नहीं है)।

— bb94

Answer 7

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&

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

---

असंगत अलगाव के साथ -3 बाइट्स (हटाएं @#&)

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

Answer 8

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 148 बाइट्स

n=>{var a=new int[n];int j=0;void g(int k){if(k<n)for(int i=0;i++<j;g(k+1))a[k]=i;else if(a.Sum()==j)WriteLine(string.Join(' ',a));}for(;;j++)g(0);}

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

-3 बाइट्स @ASCIIOnly को धन्यवाद!

// n: size of tuples to generate
n=>{
  // a: current tuple workspace
  var a=new int[n];
  // j: target sum value
  int j=0;
  // recursive function that works on slot k
  void g(int k){

    // tuple is not fully generated,
    if(k<n)

      // try all values from (0,j]
      for(int i=0;i++<j;
        // recursive call - generates all
        // values from (0,j] in the next slot
        g(k+1)
      )
        // update the kth slot
        a[k]=i;

    // tuple is fully generated, however
    // we should only display if the sum
    // is equal to the target sum. tuples
    // are generated many times, this
    // let's us enforce that they are only
    // displayed once.
    else if(a.Sum()==j)
      WriteLine(string.Join(' ',a));
  }
  // increment the high value forever
  // while continually starting the
  // recursive function at slot 0
  for(;;j++)
    g(0);
}

Comments

आपने यह कैसे किया

— स्टैकस्टक

इसे .NET कोर में स्ट्रेट-अप करने से शायद अब भी मुझे बहुत सारे बाइट्स मिलेंगे ।

— स्टैकस्टक

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

— दाना

Writeउदाहरण के लिए '<literal tab>'या |एक ही लंबाई है, और बहुत कम लाइनें लेता है: पी

— एएससीआईआई-केवल

aw , 151

— एएससीआईआई-केवल

Answer 9

जेली , 10 (9?) बाइट्स

^{9 यदि हम गैर-सुसंगत पृथक्करण का उपयोग कर आउटपुट कर सकते हैं (जिसके बारे में मैंने पूछताछ की है) - का निष्कासन €।}

‘ɼṗ³ċƇ®Ṅ€ß

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

कैसे?

‘ɼṗ³ċƇ®Ṅ€ß - Main Link: some argument, x (initially equal to n, but unused)
 ɼ         - recall v from the register (initially 0), then set register to, and yield, f(v)
‘          -   f = increment
           - (i.e. v=v+1)
   ³       - program's third command line argument (1st program argument) = n
  ṗ        - (implicit range of [1..v]) Cartesian power (n)
           - (i.e. all tuples of length n with items in [1..v])
     Ƈ     - filter keep those for which:
    ċ      -   count
      ®    -   recall from register
           - (i.e. keep only those containing v)
       Ṅ€  - print €ach
         ß - call this Link with the same arity
           - (i.e. call Main(theFilteredList), again the argument is not actually used)

Comments

" जब तक प्रत्येक tuple के अंदर tuples और संख्याओं के बीच अलगाव स्पष्ट और सुसंगत है (उदाहरण के लिए, प्रति पंक्ति एक tuple)। " "मैंने माना कि यह अनुमति नहीं थी और €आवश्यक है, लेकिन चलो इंतज़ार करते हैं कि OP के पास क्या है। कहते हैं।

— केविन क्रूज़सेन

Answer 10

05AB1E , 15 11 बाइट्स

[¼¾LIãvy¾å—

-4 बाइट्स @Maltysen के पाइथ उत्तर का एक पोर्ट बनाकर ।

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

स्पष्टीकरण:

[             # Start an infinite loop:
 ¼            #  Increase the counter_variable by 1 (0 by default)
  ¾L          #  Create a list in the range [1, counter_variable]
    Iã        #  Take the cartesian power of this list with the input
      v       #  Loop over each list `y` in this list of lists:
       y¾å    #   If list `y` contains the counter_variable:
          —   #    Print list `y` with trailing newline

Comments

कार्यक्रम कब मिलेगा [1,2,1]? याद रखें कि यह परिमित समय के भीतर होना चाहिए।

— बिल्वपत्र

@billpg को अब ठीक किया जाना चाहिए।

— केविन क्रूज़सेन

Answer 11

MATL , 16 बाइट्स

`@:GZ^t!Xs@=Y)DT

ट्यूप्स को राशि बढ़ाने का आदेश दिया जाता है, और दी गई राशि के भीतर उन्हें शाब्दिक रूप से ऑर्डर किया जाता है।

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

Answer 12

पायथन 2 , 126 112 106 101 100 83 बाइट्स

n=input()
i=1
while 1:
 b=map(len,bin(i)[3:].split('0'));i+=1
 if len(b)==n:print b

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

5 बाइट्स thx to mypetlion ; अरबो की ईगल आंख से 1 बाइट ; Xnor से 17 बाइट्स !

एस और एस के साथ द्विआधारी संख्या के लिए चयन करके , डिब्बे mमें दिए गए विभाजन का निर्माण करें ।nm = 0,1,2,3,...n-1 0m 1

Comments

if i==p:i=0;p*=2i%=p;p<<=i<15 बाइट बचाने के लिए बन सकता है ।

— म्य्प्टेलियन

मुझे पूरा यकीन है कि अंतरिक्ष की print bजरूरत नहीं है: D

— ArBo

ऐसा लग रहा है कि i+pसिर्फ 1, 2, 3 ... को एक जटिल तरीके से गिना जा रहा है और इसलिए यह केवल एक चर हो सकता है।

— xnor

@ एक्सनोर: डी'ओह! इस अवधारणा में लिपटे हुए, पेड़ों के लिए जंगल नहीं देख सकता था।

— चास ब्राउन

Answer 13

सी # (.NET कोर) , 608 570 567 बाइट्स

using C=System.Console;using L=System.Collections.Generic.List<int[]>;class A{static void Main(){L x=new L(),y=new L(),z=new L();int i=int.Parse(C.ReadLine()),j=0,k,l,m;x.Add(new int[i]);while(i>0){j++;for(m=0;m++<i;){foreach(var a in y)x.Add(a);y=new L();foreach(var a in x){for(k=0;k<i;){int[] t=new int[i];System.Array.Copy(a,t,i);t[k++]=j;var b=true;z.AddRange(x);z.AddRange(y);foreach(var c in z){for(l=0;l<i;l++)if(c[l]!=t[l])break;if(l==i)b=false;}if(b)y.Add(t);}}}}for(k=0;k<x.Count;k++){C.Write("[ ");for(l=0;l<i;l++)C.Write(x[k][l]+" ");C.WriteLine("]");}}}

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

मेरे भगवान ने मैंने क्या किया है (इतने सारे छोरों, यही मैंने किया है)

यह काम करना चाहिए, हालांकि!

यदि आप प्रिंट लूप को एक ब्रैकेट में स्थानांतरित करते हैं, तो यह आपको सूची दिखाएगा जैसा कि यह बनाया गया है, हर बार यह लूप करता है। (यदि आप करते हैं तो प्रत्येक लूप को अलग करने के लिए एक नई पंक्ति या कुछ जोड़ने की सलाह देते हैं।)

ईमानदारी से कहूं तो मेरा बहुत सारा समय भाषा के साथ लड़ने में बीता ... कोई सुंदर-छपाई वाली सरणियाँ नहीं, == का व्यवहार ...

उम्मीद है कि इस संस्करण को पढ़ना आसान है।

using C=System.Console;
using L=System.Collections.Generic.List<int[]>;
class A{
    static void Main(){
        L x=new L(),y=new L(),z=new L();
        int i=int.Parse(C.ReadLine()),j=0,k,l,m;
        x.Add(new int[i]);
        while(i>0){
            j++;
            for(m=0;m++<i;){
                foreach(var a in y) x.Add(a);
                y=new L();
                foreach(var a in x){
                    for(k=0;k<i;){
                        int[] t=new int[i];
                        System.Array.Copy(a,t,i);
                        t[k++]=j;
                        var b=true;
                        z.AddRange(x);
                        z.AddRange(y);
                        foreach(var c in z){
                            for(l=0;l<i;l++) if(c[l]!=t[l])break;
                            if(l==i)b=false;
                        }
                        if(b)y.Add(t);
                    }
                }
            }
        }
        for(k=0;k<x.Count;k++){
            C.Write("[ ");
            for(l=0;l<i;l++)C.Write(x[k][l]+" ");
            C.WriteLine("]");
        }
    }
}

Comments

मुझे बस एहसास हुआ कि मैं प्रिंट लूप को स्टेटमेंट में स्टिक कर सकता हूं ताकि यह प्रिंट हो जाए। एक पल का सामना ।

— स्टैकस्टक

इंतजार नहीं कर सकते कि

— स्टैकस्टक

... ओह प्रिय, मुझे यकीन नहीं है कि यह कोड अब काम करता है।

— स्टैकस्टक

यह नहीं है।

— स्टैकस्टक

इस के साथ शुभकामनाएँ :) मैंने C # में एक समाधान कोड करना शुरू किया और यह महसूस किया कि मैं जितना उम्मीद कर रहा था उससे कहीं अधिक मुश्किल था। "विज़ुअल सी # इंटरएक्टिव" दुभाषिया का उपयोग क्यों नहीं करें? बस वर्ग परिभाषा को शामिल नहीं करने से एक गुच्छा बच जाएगा। वैसे भी, मुझ से +1 :)

— दाना

Answer 14

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

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}

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

अनाम कोड ब्लॉक जो एक आलसी अनंत सूची देता है। यह चास ब्राउन के जवाब के समान रणनीति का उपयोग करता है ।

स्पष्टीकरण:

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}
{                                                } # Anonymous code block
                                              xx*  # Repeat indefinitely
                                 ($++        )     # From the current index
                                     .base(2)      # Get the binary form
         {S/.//                 }   # Remove the first digit
               .split(0)            # And split by zeroes
                        >>.chars    # And get the length of each section
 grep   ,   # From this infinite list, filter:
      $_      # The groups with length the same as the input

Answer 15

VDM-SL , 51 बाइट्स

g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

अनुक्रम संगति से पुनरावर्ती समुच्चय बोध।

TIO पर नहीं, आप एक कार्यक्रम में दौड़ सकते हैं (यदि आप नेट प्रकार के लिए सीमाएँ चालू करते हैं या इसे समाप्त नहीं करेंगे):

functions 
g:nat->set of ?
g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

उत्तर में वैकल्पिक 0s शामिल है अन्यथा यह nat1 पर 52 बाइट्स बाध्यकारी होगा

Answer 16

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

While[0<1,If[a~FreeQ~#,Print@#]&/@(b=Table[Select[Range@t~Tuples~{s},Tr@#==k&],{k,t,t(s=#)}]~Flatten~1);a={a}~Join~b;t++]&
t=1
a={}

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

Answer 17

perl -M5.010 122 बाइट्स

$n=shift;
$s.="for\$x$_(1..\$m){"for 1..$n;
$t.="\$x$_ "for 1..$n;
$u.='}'x$n;
eval"{\$m++;$s\$_=qq' $t';/ \$m /&&say$u;redo}"

पठनीयता के लिए कुछ नई कड़ियाँ जोड़ी गईं (बाइट की गिनती में नहीं)

Answer 18

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

from random import*
m=n=input()
a=()
while 1:
 m+=len(a)==m**n;t=[randint(1,m)for _ in[1]*n]
 if(t in a)<1:a+=t,;print t

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

अधिकांश अन्य उत्तरों की तुलना में थोड़ा लंबा, लेकिन मुझे इसके पीछे का विचार पसंद आया।

Answer 19

स्टैक्स , 6 बाइट्स

£ƒ$↔┬ï

इसे चलाएं और डीबग करें

इनपुट के nलिए प्रक्रिया लगभग है

for i in [0..infinity]:
    get all the distinct n length arrays of positive integers that sum to i
    for each
        join with spaces
        implicitly output

Answer 20

जावास्क्रिप्ट (V8) , 98 बाइट्स

n=>{for(a=[],b=[j=1];;b.push(++j))(g=k=>k<n?b.map(i=>(a[k]=i)|g(k+1)):a.includes(j)&&print(a))(0)}

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

हुर्रे! अंत में इसे 100 के तहत मिला :) मूल रूप से मेरे सी # उत्तर का एक बंदरगाह है ।

// n: length of tuples to generate
n=>{
  // a: workspace for current tuple
  // b: range of numbers that grows
  //     - iteration 1: [1]
  //     - iteration 2: [1,2]
  //     - iteration 3: [1,2,3]
  // j: largest number in b
  for(a=[],b=[j=1];;b.push(++j))
    // g: recursive function to build tuples
    // k: index of slot for current recursive call
    (g=k=>
       // current slot less than the tuple size? 
       k<n?
         // tuple generation not complete
         // try all values in current slot and
         // recurse to the next slot
         b.map(i=>(a[k]=i)|g(k+1)):
         // tuple generation complete
         // print tuple if it contains the
         // current high value
         a.includes(j)&&print(a)
    // start recursive function at slot 0
    )(0)
}