List *all* the tuples!












27












$begingroup$


Write a program, given an input n, will generate all possible n-tuples using natural numbers.



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)...



  • The output may be in any order that does not break any other rules.

  • The program must be written to run forever and list all applicable tuples exactly once, in theory.


    • In reality, your program will reach your integer type's limit and crash. This is acceptable as long the program would run infinitely long if only your integer type was unlimited.

    • Each valid tuple must be listed within finite time, if only the program were allowed to run that long.



  • The output may, at your option, include zeroes in addition to the natural numbers.

  • You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)

  • The input (n) is an integer from one to six. Required behavior is undefined for inputs outside of this range.

  • Code-golf rules apply, shortest program wins.


Thanks to "Artemis Fowl" for feedback during the sandbox phase.










share|improve this question











$endgroup$












  • $begingroup$
    I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
    $endgroup$
    – Luis Mendo
    yesterday






  • 1




    $begingroup$
    Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
    $endgroup$
    – Jonathan Allan
    yesterday






  • 5




    $begingroup$
    "You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
    $endgroup$
    – Jonathan Allan
    yesterday










  • $begingroup$
    @JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
    $endgroup$
    – billpg
    yesterday






  • 1




    $begingroup$
    Related (integers instead of natural numbers)
    $endgroup$
    – Esolanging Fruit
    22 hours ago
















27












$begingroup$


Write a program, given an input n, will generate all possible n-tuples using natural numbers.



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)...



  • The output may be in any order that does not break any other rules.

  • The program must be written to run forever and list all applicable tuples exactly once, in theory.


    • In reality, your program will reach your integer type's limit and crash. This is acceptable as long the program would run infinitely long if only your integer type was unlimited.

    • Each valid tuple must be listed within finite time, if only the program were allowed to run that long.



  • The output may, at your option, include zeroes in addition to the natural numbers.

  • You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)

  • The input (n) is an integer from one to six. Required behavior is undefined for inputs outside of this range.

  • Code-golf rules apply, shortest program wins.


Thanks to "Artemis Fowl" for feedback during the sandbox phase.










share|improve this question











$endgroup$












  • $begingroup$
    I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
    $endgroup$
    – Luis Mendo
    yesterday






  • 1




    $begingroup$
    Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
    $endgroup$
    – Jonathan Allan
    yesterday






  • 5




    $begingroup$
    "You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
    $endgroup$
    – Jonathan Allan
    yesterday










  • $begingroup$
    @JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
    $endgroup$
    – billpg
    yesterday






  • 1




    $begingroup$
    Related (integers instead of natural numbers)
    $endgroup$
    – Esolanging Fruit
    22 hours ago














27












27








27


4



$begingroup$


Write a program, given an input n, will generate all possible n-tuples using natural numbers.



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)...



  • The output may be in any order that does not break any other rules.

  • The program must be written to run forever and list all applicable tuples exactly once, in theory.


    • In reality, your program will reach your integer type's limit and crash. This is acceptable as long the program would run infinitely long if only your integer type was unlimited.

    • Each valid tuple must be listed within finite time, if only the program were allowed to run that long.



  • The output may, at your option, include zeroes in addition to the natural numbers.

  • You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)

  • The input (n) is an integer from one to six. Required behavior is undefined for inputs outside of this range.

  • Code-golf rules apply, shortest program wins.


Thanks to "Artemis Fowl" for feedback during the sandbox phase.










share|improve this question











$endgroup$




Write a program, given an input n, will generate all possible n-tuples using natural numbers.



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)...



  • The output may be in any order that does not break any other rules.

  • The program must be written to run forever and list all applicable tuples exactly once, in theory.


    • In reality, your program will reach your integer type's limit and crash. This is acceptable as long the program would run infinitely long if only your integer type was unlimited.

    • Each valid tuple must be listed within finite time, if only the program were allowed to run that long.



  • The output may, at your option, include zeroes in addition to the natural numbers.

  • You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)

  • The input (n) is an integer from one to six. Required behavior is undefined for inputs outside of this range.

  • Code-golf rules apply, shortest program wins.


Thanks to "Artemis Fowl" for feedback during the sandbox phase.







code-golf sequence






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited 19 hours ago







billpg

















asked yesterday









billpgbillpg

1,00511030




1,00511030












  • $begingroup$
    I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
    $endgroup$
    – Luis Mendo
    yesterday






  • 1




    $begingroup$
    Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
    $endgroup$
    – Jonathan Allan
    yesterday






  • 5




    $begingroup$
    "You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
    $endgroup$
    – Jonathan Allan
    yesterday










  • $begingroup$
    @JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
    $endgroup$
    – billpg
    yesterday






  • 1




    $begingroup$
    Related (integers instead of natural numbers)
    $endgroup$
    – Esolanging Fruit
    22 hours ago


















  • $begingroup$
    I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
    $endgroup$
    – Luis Mendo
    yesterday






  • 1




    $begingroup$
    Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
    $endgroup$
    – Jonathan Allan
    yesterday






  • 5




    $begingroup$
    "You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
    $endgroup$
    – Jonathan Allan
    yesterday










  • $begingroup$
    @JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
    $endgroup$
    – billpg
    yesterday






  • 1




    $begingroup$
    Related (integers instead of natural numbers)
    $endgroup$
    – Esolanging Fruit
    22 hours ago
















$begingroup$
I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
$endgroup$
– Luis Mendo
yesterday




$begingroup$
I assume it is valid if when the program crashes it produces some extraneous output in addition to the tuples printed so far, right?
$endgroup$
– Luis Mendo
yesterday




1




1




$begingroup$
Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
$endgroup$
– Jonathan Allan
yesterday




$begingroup$
Must we output as we go or would a function which yields an infinite list at the end of time sufficient?
$endgroup$
– Jonathan Allan
yesterday




5




5




$begingroup$
"You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
$endgroup$
– Jonathan Allan
yesterday




$begingroup$
"You may choose your program's output format for your convenience, as long as the separation between tuples and numbers inside each tuple is clear and consistent" - may we output differing (albeit consistently differing) separation (e.g. like this)?
$endgroup$
– Jonathan Allan
yesterday












$begingroup$
@JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
$endgroup$
– billpg
yesterday




$begingroup$
@JonathanAllan I would have to include the output of that object's infinite contents as part of the program.
$endgroup$
– billpg
yesterday




1




1




$begingroup$
Related (integers instead of natural numbers)
$endgroup$
– Esolanging Fruit
22 hours ago




$begingroup$
Related (integers instead of natural numbers)
$endgroup$
– Esolanging Fruit
22 hours ago










16 Answers
16






active

oldest

votes


















20












$begingroup$


Husk, 2 bytes



πN


Try it online!



Explanation



N is the infinite list of natural numbers [1,2,3,4,...
π is Cartesian power.
Result is an infinite list of lists.
Each list of the desired length occurs exactly once because π is cool like that.
Input and output are implicit.






share|improve this answer









$endgroup$









  • 1




    $begingroup$
    Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
    $endgroup$
    – billpg
    yesterday










  • $begingroup$
    @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
    $endgroup$
    – Zgarb
    23 hours ago










  • $begingroup$
    "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
    $endgroup$
    – Jonah
    14 hours ago






  • 1




    $begingroup$
    @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
    $endgroup$
    – Zgarb
    13 hours ago



















10












$begingroup$


Haskell, 62 bytes





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


Try it online!



n!s generates all the n-tuples that sum to s.



Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].



This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).






share|improve this answer









$endgroup$





















    5












    $begingroup$


    Haskell, 50 bytes





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


    Try it online!



    Lists n-tuples sorted by sum. mapM does the heavy lifting to generate all n-tuples of numbers from 0 to k. The <$f trick is explained here.




    Haskell, 51 bytes





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


    Try it online!



    Recursively stretches all n-1-tuples into all n-tuples by splitting the first number a of each n-1-tuple into two numbers a-k,k that sum to it, in every possible way.






    share|improve this answer









    $endgroup$





















      4












      $begingroup$

      Pyth - 10 bytes



      Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb



      .V1f}bT^Sb


      Try it online.






      share|improve this answer











      $endgroup$









      • 1




        $begingroup$
        f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
        $endgroup$
        – FryAmTheEggman
        23 hours ago



















      3












      $begingroup$


      Brachylog (v2), 9 bytes



      ~l.ℕᵐ+≜∧≜


      Try it online!



      This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).



      It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.



      Explanation



      ~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]


      Incidentally, it strikes me as interesting just how different my explanations of the two are, despite them doing the exact same thing from Brachylog's point of view. The first is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).






      share|improve this answer











      $endgroup$













      • $begingroup$
        ↰₁ẉ⊥ is also a good header, for printing infinitely.
        $endgroup$
        – Unrelated String
        yesterday










      • $begingroup$
        Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
        $endgroup$
        – Unrelated String
        yesterday






      • 1




        $begingroup$
        @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
        $endgroup$
        – ais523
        yesterday










      • $begingroup$
        Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
        $endgroup$
        – Unrelated String
        yesterday





















      2












      $begingroup$


      Perl 6, 37 bytes





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


      Try it online!



      Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...






      share|improve this answer









      $endgroup$









      • 5




        $begingroup$
        This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
        $endgroup$
        – bb94
        yesterday



















      2












      $begingroup$


      Wolfram Language (Mathematica), 62 bytes



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


      Try it online!





      -3 bytes with inconsistent separation (delete @#&)



      Try it online!






      share|improve this answer









      $endgroup$





















        1












        $begingroup$


        Jelly, 10 (9?) bytes



        9 if we may output using non-consistent separation (which I have enquired about) -- removal of the .



        ‘ɼṗ³ċƇ®Ṅ€ß


        Try it online!



        How?



        ‘ɼṗ³ċƇ®Ṅ€ß - 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)





        share|improve this answer











        $endgroup$









        • 1




          $begingroup$
          Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
          $endgroup$
          – Kevin Cruijssen
          yesterday



















        1












        $begingroup$


        05AB1E, 15 11 bytes



        [¼¾LIãvy¾å—


        -4 bytes by creating a port of @Maltysen's Pyth answer.



        Try it online.



        Explanation:





        [             # 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





        share|improve this answer











        $endgroup$









        • 2




          $begingroup$
          When will the program get to [1,2,1]? Remember it has to be within finite time.
          $endgroup$
          – billpg
          yesterday










        • $begingroup$
          @billpg Should be fixed now.
          $endgroup$
          – Kevin Cruijssen
          yesterday



















        1












        $begingroup$


        MATL, 16 bytes



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


        Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.



        Try it online!






        share|improve this answer











        $endgroup$





















          1












          $begingroup$


          Python 2, 126 112 106 101 100 83 bytes





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


          Try it online!



          5 bytes thx to mypetlion; 1 byte from the eagle eye of ArBo; 17 bytes from xnor!



          Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.






          share|improve this answer











          $endgroup$













          • $begingroup$
            if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
            $endgroup$
            – mypetlion
            yesterday










          • $begingroup$
            I'm pretty sure the space after print b is not needed :D
            $endgroup$
            – ArBo
            18 hours ago










          • $begingroup$
            It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
            $endgroup$
            – xnor
            11 hours ago










          • $begingroup$
            @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
            $endgroup$
            – Chas Brown
            8 hours ago



















          0












          $begingroup$


          VDM-SL, 51 bytes



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


          Recursive set comprehension with sequence concatenation..



          Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):



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


          Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1






          share|improve this answer









          $endgroup$





















            0












            $begingroup$


            Wolfram Language (Mathematica), 131 bytes



            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={}


            Try it online!






            share|improve this answer











            $endgroup$





















              0












              $begingroup$

              perl -M5.010 122 bytes



              $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}"


              Added some newlines for readabilities sake (not counted in the byte count)






              share|improve this answer











              $endgroup$





















                0












                $begingroup$


                Python 2, 120 bytes





                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


                Try it online!



                A bit longer than most other answers, but I liked the idea behind it.






                share|improve this answer









                $endgroup$





















                  -4












                  $begingroup$

                  Python3 (58 characters)



                  This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.



                  from itertools import*
                  lambda n:product(count(1),repeat=n)


                  Proof that this works for limited integer range:



                  from itertools import*
                  l = lambda n: product(range(1, 10), repeat=n)
                  print(list(l(3))) # returns all permutations of (1, 2, 3, ..., 10) of length 3





                  share|improve this answer











                  $endgroup$









                  • 2




                    $begingroup$
                    This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                    $endgroup$
                    – alexis
                    yesterday










                  • $begingroup$
                    My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                    $endgroup$
                    – agtoever
                    22 hours ago






                  • 1




                    $begingroup$
                    I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                    $endgroup$
                    – Chas Brown
                    20 hours ago






                  • 5




                    $begingroup$
                    @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                    $endgroup$
                    – alexis
                    19 hours ago












                  Your Answer






                  StackExchange.ifUsing("editor", function () {
                  StackExchange.using("externalEditor", function () {
                  StackExchange.using("snippets", function () {
                  StackExchange.snippets.init();
                  });
                  });
                  }, "code-snippets");

                  StackExchange.ready(function() {
                  var channelOptions = {
                  tags: "".split(" "),
                  id: "200"
                  };
                  initTagRenderer("".split(" "), "".split(" "), channelOptions);

                  StackExchange.using("externalEditor", function() {
                  // Have to fire editor after snippets, if snippets enabled
                  if (StackExchange.settings.snippets.snippetsEnabled) {
                  StackExchange.using("snippets", function() {
                  createEditor();
                  });
                  }
                  else {
                  createEditor();
                  }
                  });

                  function createEditor() {
                  StackExchange.prepareEditor({
                  heartbeatType: 'answer',
                  autoActivateHeartbeat: false,
                  convertImagesToLinks: false,
                  noModals: true,
                  showLowRepImageUploadWarning: true,
                  reputationToPostImages: null,
                  bindNavPrevention: true,
                  postfix: "",
                  imageUploader: {
                  brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                  contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                  allowUrls: true
                  },
                  onDemand: true,
                  discardSelector: ".discard-answer"
                  ,immediatelyShowMarkdownHelp:true
                  });


                  }
                  });














                  draft saved

                  draft discarded


















                  StackExchange.ready(
                  function () {
                  StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f183225%2flist-all-the-tuples%23new-answer', 'question_page');
                  }
                  );

                  Post as a guest















                  Required, but never shown

























                  16 Answers
                  16






                  active

                  oldest

                  votes








                  16 Answers
                  16






                  active

                  oldest

                  votes









                  active

                  oldest

                  votes






                  active

                  oldest

                  votes









                  20












                  $begingroup$


                  Husk, 2 bytes



                  πN


                  Try it online!



                  Explanation



                  N is the infinite list of natural numbers [1,2,3,4,...
                  π is Cartesian power.
                  Result is an infinite list of lists.
                  Each list of the desired length occurs exactly once because π is cool like that.
                  Input and output are implicit.






                  share|improve this answer









                  $endgroup$









                  • 1




                    $begingroup$
                    Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                    $endgroup$
                    – billpg
                    yesterday










                  • $begingroup$
                    @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                    $endgroup$
                    – Zgarb
                    23 hours ago










                  • $begingroup$
                    "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                    $endgroup$
                    – Jonah
                    14 hours ago






                  • 1




                    $begingroup$
                    @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                    $endgroup$
                    – Zgarb
                    13 hours ago
















                  20












                  $begingroup$


                  Husk, 2 bytes



                  πN


                  Try it online!



                  Explanation



                  N is the infinite list of natural numbers [1,2,3,4,...
                  π is Cartesian power.
                  Result is an infinite list of lists.
                  Each list of the desired length occurs exactly once because π is cool like that.
                  Input and output are implicit.






                  share|improve this answer









                  $endgroup$









                  • 1




                    $begingroup$
                    Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                    $endgroup$
                    – billpg
                    yesterday










                  • $begingroup$
                    @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                    $endgroup$
                    – Zgarb
                    23 hours ago










                  • $begingroup$
                    "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                    $endgroup$
                    – Jonah
                    14 hours ago






                  • 1




                    $begingroup$
                    @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                    $endgroup$
                    – Zgarb
                    13 hours ago














                  20












                  20








                  20





                  $begingroup$


                  Husk, 2 bytes



                  πN


                  Try it online!



                  Explanation



                  N is the infinite list of natural numbers [1,2,3,4,...
                  π is Cartesian power.
                  Result is an infinite list of lists.
                  Each list of the desired length occurs exactly once because π is cool like that.
                  Input and output are implicit.






                  share|improve this answer









                  $endgroup$




                  Husk, 2 bytes



                  πN


                  Try it online!



                  Explanation



                  N is the infinite list of natural numbers [1,2,3,4,...
                  π is Cartesian power.
                  Result is an infinite list of lists.
                  Each list of the desired length occurs exactly once because π is cool like that.
                  Input and output are implicit.







                  share|improve this answer












                  share|improve this answer



                  share|improve this answer










                  answered yesterday









                  ZgarbZgarb

                  26.8k462231




                  26.8k462231








                  • 1




                    $begingroup$
                    Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                    $endgroup$
                    – billpg
                    yesterday










                  • $begingroup$
                    @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                    $endgroup$
                    – Zgarb
                    23 hours ago










                  • $begingroup$
                    "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                    $endgroup$
                    – Jonah
                    14 hours ago






                  • 1




                    $begingroup$
                    @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                    $endgroup$
                    – Zgarb
                    13 hours ago














                  • 1




                    $begingroup$
                    Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                    $endgroup$
                    – billpg
                    yesterday










                  • $begingroup$
                    @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                    $endgroup$
                    – Zgarb
                    23 hours ago










                  • $begingroup$
                    "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                    $endgroup$
                    – Jonah
                    14 hours ago






                  • 1




                    $begingroup$
                    @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                    $endgroup$
                    – Zgarb
                    13 hours ago








                  1




                  1




                  $begingroup$
                  Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                  $endgroup$
                  – billpg
                  yesterday




                  $begingroup$
                  Wow, and this doesn't do [1,1,n] either. Is there a pattern to the order it outputs?
                  $endgroup$
                  – billpg
                  yesterday












                  $begingroup$
                  @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                  $endgroup$
                  – Zgarb
                  23 hours ago




                  $begingroup$
                  @billpg It builds the tuples recursively: n- tuples are obtained by taking the Cartesian product of the original list and the list of n-1-tuples, in ascending order of sum of indices.
                  $endgroup$
                  – Zgarb
                  23 hours ago












                  $begingroup$
                  "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                  $endgroup$
                  – Jonah
                  14 hours ago




                  $begingroup$
                  "ascending order of sum of indices" -- Can you clarify this? I'm having trouble seeing why, eg, 2,2,2 comes after 4,1,2 and 5,1,1.
                  $endgroup$
                  – Jonah
                  14 hours ago




                  1




                  1




                  $begingroup$
                  @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                  $endgroup$
                  – Zgarb
                  13 hours ago




                  $begingroup$
                  @Jonah The recursion works like this. You start with 1-tuples over N. For 2-tuples you take Cartesian product with N ordered by sum of indices. In both lists, each number n is at index n so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product of N and the list of 2-tuples, ordered by sum of the elements' indices in these lists. It doesn't look at the tuple's sum, it looks at its position in the list of tuples.
                  $endgroup$
                  – Zgarb
                  13 hours ago











                  10












                  $begingroup$


                  Haskell, 62 bytes





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


                  Try it online!



                  n!s generates all the n-tuples that sum to s.



                  Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].



                  This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).






                  share|improve this answer









                  $endgroup$


















                    10












                    $begingroup$


                    Haskell, 62 bytes





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


                    Try it online!



                    n!s generates all the n-tuples that sum to s.



                    Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].



                    This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).






                    share|improve this answer









                    $endgroup$
















                      10












                      10








                      10





                      $begingroup$


                      Haskell, 62 bytes





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


                      Try it online!



                      n!s generates all the n-tuples that sum to s.



                      Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].



                      This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).






                      share|improve this answer









                      $endgroup$




                      Haskell, 62 bytes





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


                      Try it online!



                      n!s generates all the n-tuples that sum to s.



                      Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].



                      This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).







                      share|improve this answer












                      share|improve this answer



                      share|improve this answer










                      answered yesterday









                      LynnLynn

                      51k899234




                      51k899234























                          5












                          $begingroup$


                          Haskell, 50 bytes





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


                          Try it online!



                          Lists n-tuples sorted by sum. mapM does the heavy lifting to generate all n-tuples of numbers from 0 to k. The <$f trick is explained here.




                          Haskell, 51 bytes





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


                          Try it online!



                          Recursively stretches all n-1-tuples into all n-tuples by splitting the first number a of each n-1-tuple into two numbers a-k,k that sum to it, in every possible way.






                          share|improve this answer









                          $endgroup$


















                            5












                            $begingroup$


                            Haskell, 50 bytes





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


                            Try it online!



                            Lists n-tuples sorted by sum. mapM does the heavy lifting to generate all n-tuples of numbers from 0 to k. The <$f trick is explained here.




                            Haskell, 51 bytes





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


                            Try it online!



                            Recursively stretches all n-1-tuples into all n-tuples by splitting the first number a of each n-1-tuple into two numbers a-k,k that sum to it, in every possible way.






                            share|improve this answer









                            $endgroup$
















                              5












                              5








                              5





                              $begingroup$


                              Haskell, 50 bytes





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


                              Try it online!



                              Lists n-tuples sorted by sum. mapM does the heavy lifting to generate all n-tuples of numbers from 0 to k. The <$f trick is explained here.




                              Haskell, 51 bytes





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


                              Try it online!



                              Recursively stretches all n-1-tuples into all n-tuples by splitting the first number a of each n-1-tuple into two numbers a-k,k that sum to it, in every possible way.






                              share|improve this answer









                              $endgroup$




                              Haskell, 50 bytes





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


                              Try it online!



                              Lists n-tuples sorted by sum. mapM does the heavy lifting to generate all n-tuples of numbers from 0 to k. The <$f trick is explained here.




                              Haskell, 51 bytes





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


                              Try it online!



                              Recursively stretches all n-1-tuples into all n-tuples by splitting the first number a of each n-1-tuple into two numbers a-k,k that sum to it, in every possible way.







                              share|improve this answer












                              share|improve this answer



                              share|improve this answer










                              answered yesterday









                              xnorxnor

                              94.1k18192452




                              94.1k18192452























                                  4












                                  $begingroup$

                                  Pyth - 10 bytes



                                  Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb



                                  .V1f}bT^Sb


                                  Try it online.






                                  share|improve this answer











                                  $endgroup$









                                  • 1




                                    $begingroup$
                                    f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                    $endgroup$
                                    – FryAmTheEggman
                                    23 hours ago
















                                  4












                                  $begingroup$

                                  Pyth - 10 bytes



                                  Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb



                                  .V1f}bT^Sb


                                  Try it online.






                                  share|improve this answer











                                  $endgroup$









                                  • 1




                                    $begingroup$
                                    f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                    $endgroup$
                                    – FryAmTheEggman
                                    23 hours ago














                                  4












                                  4








                                  4





                                  $begingroup$

                                  Pyth - 10 bytes



                                  Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb



                                  .V1f}bT^Sb


                                  Try it online.






                                  share|improve this answer











                                  $endgroup$



                                  Pyth - 10 bytes



                                  Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb



                                  .V1f}bT^Sb


                                  Try it online.







                                  share|improve this answer














                                  share|improve this answer



                                  share|improve this answer








                                  edited yesterday

























                                  answered yesterday









                                  MaltysenMaltysen

                                  21.4k445116




                                  21.4k445116








                                  • 1




                                    $begingroup$
                                    f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                    $endgroup$
                                    – FryAmTheEggman
                                    23 hours ago














                                  • 1




                                    $begingroup$
                                    f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                    $endgroup$
                                    – FryAmTheEggman
                                    23 hours ago








                                  1




                                  1




                                  $begingroup$
                                  f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                  $endgroup$
                                  – FryAmTheEggman
                                  23 hours ago




                                  $begingroup$
                                  f}bT -> }#b Also, your byte count seems to be incorrect at the moment?
                                  $endgroup$
                                  – FryAmTheEggman
                                  23 hours ago











                                  3












                                  $begingroup$


                                  Brachylog (v2), 9 bytes



                                  ~l.ℕᵐ+≜∧≜


                                  Try it online!



                                  This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).



                                  It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.



                                  Explanation



                                  ~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]


                                  Incidentally, it strikes me as interesting just how different my explanations of the two are, despite them doing the exact same thing from Brachylog's point of view. The first is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).






                                  share|improve this answer











                                  $endgroup$













                                  • $begingroup$
                                    ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday










                                  • $begingroup$
                                    Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday






                                  • 1




                                    $begingroup$
                                    @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                    $endgroup$
                                    – ais523
                                    yesterday










                                  • $begingroup$
                                    Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday


















                                  3












                                  $begingroup$


                                  Brachylog (v2), 9 bytes



                                  ~l.ℕᵐ+≜∧≜


                                  Try it online!



                                  This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).



                                  It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.



                                  Explanation



                                  ~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]


                                  Incidentally, it strikes me as interesting just how different my explanations of the two are, despite them doing the exact same thing from Brachylog's point of view. The first is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).






                                  share|improve this answer











                                  $endgroup$













                                  • $begingroup$
                                    ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday










                                  • $begingroup$
                                    Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday






                                  • 1




                                    $begingroup$
                                    @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                    $endgroup$
                                    – ais523
                                    yesterday










                                  • $begingroup$
                                    Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday
















                                  3












                                  3








                                  3





                                  $begingroup$


                                  Brachylog (v2), 9 bytes



                                  ~l.ℕᵐ+≜∧≜


                                  Try it online!



                                  This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).



                                  It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.



                                  Explanation



                                  ~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]


                                  Incidentally, it strikes me as interesting just how different my explanations of the two are, despite them doing the exact same thing from Brachylog's point of view. The first is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).






                                  share|improve this answer











                                  $endgroup$




                                  Brachylog (v2), 9 bytes



                                  ~l.ℕᵐ+≜∧≜


                                  Try it online!



                                  This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).



                                  It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.



                                  Explanation



                                  ~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]


                                  Incidentally, it strikes me as interesting just how different my explanations of the two are, despite them doing the exact same thing from Brachylog's point of view. The first is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).







                                  share|improve this answer














                                  share|improve this answer



                                  share|improve this answer








                                  answered yesterday


























                                  community wiki





                                  ais523













                                  • $begingroup$
                                    ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday










                                  • $begingroup$
                                    Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday






                                  • 1




                                    $begingroup$
                                    @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                    $endgroup$
                                    – ais523
                                    yesterday










                                  • $begingroup$
                                    Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday




















                                  • $begingroup$
                                    ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday










                                  • $begingroup$
                                    Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday






                                  • 1




                                    $begingroup$
                                    @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                    $endgroup$
                                    – ais523
                                    yesterday










                                  • $begingroup$
                                    Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                    $endgroup$
                                    – Unrelated String
                                    yesterday


















                                  $begingroup$
                                  ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday




                                  $begingroup$
                                  ↰₁ẉ⊥ is also a good header, for printing infinitely.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday












                                  $begingroup$
                                  Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday




                                  $begingroup$
                                  Although I do feel like this may not actually be a full answer, since any single independent invocation of this predicate will just generate zeroes, with the "generate all" part being done by the or the in the header.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday




                                  1




                                  1




                                  $begingroup$
                                  @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                  $endgroup$
                                  – ais523
                                  yesterday




                                  $begingroup$
                                  @UnrelatedString Your code doesn't use the predicate as a generator, though. We have explicit rules allowing list output using a generator. What you're doing in your TIO link is calling the predicate in a loop to get 1000 different generators, then taking the first output from each of them; that's a really unnatural operation to do on generators, and it won't let you see the other elements that they can generate.
                                  $endgroup$
                                  – ais523
                                  yesterday












                                  $begingroup$
                                  Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday






                                  $begingroup$
                                  Ah, so I've just been misinterpreting the semantics of what a Brachylog predicate is this whole time--my idea of "generator" is stuck on Python. Now that that's straight in my head I guess I'll go shave three bytes off of some of my old answers.
                                  $endgroup$
                                  – Unrelated String
                                  yesterday













                                  2












                                  $begingroup$


                                  Perl 6, 37 bytes





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


                                  Try it online!



                                  Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...






                                  share|improve this answer









                                  $endgroup$









                                  • 5




                                    $begingroup$
                                    This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                    $endgroup$
                                    – bb94
                                    yesterday
















                                  2












                                  $begingroup$


                                  Perl 6, 37 bytes





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


                                  Try it online!



                                  Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...






                                  share|improve this answer









                                  $endgroup$









                                  • 5




                                    $begingroup$
                                    This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                    $endgroup$
                                    – bb94
                                    yesterday














                                  2












                                  2








                                  2





                                  $begingroup$


                                  Perl 6, 37 bytes





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


                                  Try it online!



                                  Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...






                                  share|improve this answer









                                  $endgroup$




                                  Perl 6, 37 bytes





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


                                  Try it online!



                                  Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...







                                  share|improve this answer












                                  share|improve this answer



                                  share|improve this answer










                                  answered yesterday









                                  Phil HPhil H

                                  1,166817




                                  1,166817








                                  • 5




                                    $begingroup$
                                    This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                    $endgroup$
                                    – bb94
                                    yesterday














                                  • 5




                                    $begingroup$
                                    This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                    $endgroup$
                                    – bb94
                                    yesterday








                                  5




                                  5




                                  $begingroup$
                                  This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                  $endgroup$
                                  – bb94
                                  yesterday




                                  $begingroup$
                                  This doesn't list every tuple exactly once (for instance, (0, 1, 0, 0) is not listed).
                                  $endgroup$
                                  – bb94
                                  yesterday











                                  2












                                  $begingroup$


                                  Wolfram Language (Mathematica), 62 bytes



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


                                  Try it online!





                                  -3 bytes with inconsistent separation (delete @#&)



                                  Try it online!






                                  share|improve this answer









                                  $endgroup$


















                                    2












                                    $begingroup$


                                    Wolfram Language (Mathematica), 62 bytes



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


                                    Try it online!





                                    -3 bytes with inconsistent separation (delete @#&)



                                    Try it online!






                                    share|improve this answer









                                    $endgroup$
















                                      2












                                      2








                                      2





                                      $begingroup$


                                      Wolfram Language (Mathematica), 62 bytes



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


                                      Try it online!





                                      -3 bytes with inconsistent separation (delete @#&)



                                      Try it online!






                                      share|improve this answer









                                      $endgroup$




                                      Wolfram Language (Mathematica), 62 bytes



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


                                      Try it online!





                                      -3 bytes with inconsistent separation (delete @#&)



                                      Try it online!







                                      share|improve this answer












                                      share|improve this answer



                                      share|improve this answer










                                      answered yesterday









                                      attinatattinat

                                      5897




                                      5897























                                          1












                                          $begingroup$


                                          Jelly, 10 (9?) bytes



                                          9 if we may output using non-consistent separation (which I have enquired about) -- removal of the .



                                          ‘ɼṗ³ċƇ®Ṅ€ß


                                          Try it online!



                                          How?



                                          ‘ɼṗ³ċƇ®Ṅ€ß - 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)





                                          share|improve this answer











                                          $endgroup$









                                          • 1




                                            $begingroup$
                                            Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday
















                                          1












                                          $begingroup$


                                          Jelly, 10 (9?) bytes



                                          9 if we may output using non-consistent separation (which I have enquired about) -- removal of the .



                                          ‘ɼṗ³ċƇ®Ṅ€ß


                                          Try it online!



                                          How?



                                          ‘ɼṗ³ċƇ®Ṅ€ß - 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)





                                          share|improve this answer











                                          $endgroup$









                                          • 1




                                            $begingroup$
                                            Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday














                                          1












                                          1








                                          1





                                          $begingroup$


                                          Jelly, 10 (9?) bytes



                                          9 if we may output using non-consistent separation (which I have enquired about) -- removal of the .



                                          ‘ɼṗ³ċƇ®Ṅ€ß


                                          Try it online!



                                          How?



                                          ‘ɼṗ³ċƇ®Ṅ€ß - 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)





                                          share|improve this answer











                                          $endgroup$




                                          Jelly, 10 (9?) bytes



                                          9 if we may output using non-consistent separation (which I have enquired about) -- removal of the .



                                          ‘ɼṗ³ċƇ®Ṅ€ß


                                          Try it online!



                                          How?



                                          ‘ɼṗ³ċƇ®Ṅ€ß - 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)






                                          share|improve this answer














                                          share|improve this answer



                                          share|improve this answer








                                          edited yesterday

























                                          answered yesterday









                                          Jonathan AllanJonathan Allan

                                          54.4k537174




                                          54.4k537174








                                          • 1




                                            $begingroup$
                                            Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday














                                          • 1




                                            $begingroup$
                                            Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday








                                          1




                                          1




                                          $begingroup$
                                          Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                          $endgroup$
                                          – Kevin Cruijssen
                                          yesterday




                                          $begingroup$
                                          Based on "as long as the separation between tuples and numbers inside each tuple is clear and consistent. (For example, one tuple per line.)" I assumed it wasn't allowed and the is required, but let's wait what OP has to say.
                                          $endgroup$
                                          – Kevin Cruijssen
                                          yesterday











                                          1












                                          $begingroup$


                                          05AB1E, 15 11 bytes



                                          [¼¾LIãvy¾å—


                                          -4 bytes by creating a port of @Maltysen's Pyth answer.



                                          Try it online.



                                          Explanation:





                                          [             # 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





                                          share|improve this answer











                                          $endgroup$









                                          • 2




                                            $begingroup$
                                            When will the program get to [1,2,1]? Remember it has to be within finite time.
                                            $endgroup$
                                            – billpg
                                            yesterday










                                          • $begingroup$
                                            @billpg Should be fixed now.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday
















                                          1












                                          $begingroup$


                                          05AB1E, 15 11 bytes



                                          [¼¾LIãvy¾å—


                                          -4 bytes by creating a port of @Maltysen's Pyth answer.



                                          Try it online.



                                          Explanation:





                                          [             # 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





                                          share|improve this answer











                                          $endgroup$









                                          • 2




                                            $begingroup$
                                            When will the program get to [1,2,1]? Remember it has to be within finite time.
                                            $endgroup$
                                            – billpg
                                            yesterday










                                          • $begingroup$
                                            @billpg Should be fixed now.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday














                                          1












                                          1








                                          1





                                          $begingroup$


                                          05AB1E, 15 11 bytes



                                          [¼¾LIãvy¾å—


                                          -4 bytes by creating a port of @Maltysen's Pyth answer.



                                          Try it online.



                                          Explanation:





                                          [             # 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





                                          share|improve this answer











                                          $endgroup$




                                          05AB1E, 15 11 bytes



                                          [¼¾LIãvy¾å—


                                          -4 bytes by creating a port of @Maltysen's Pyth answer.



                                          Try it online.



                                          Explanation:





                                          [             # 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






                                          share|improve this answer














                                          share|improve this answer



                                          share|improve this answer








                                          edited yesterday

























                                          answered yesterday









                                          Kevin CruijssenKevin Cruijssen

                                          42.9k571217




                                          42.9k571217








                                          • 2




                                            $begingroup$
                                            When will the program get to [1,2,1]? Remember it has to be within finite time.
                                            $endgroup$
                                            – billpg
                                            yesterday










                                          • $begingroup$
                                            @billpg Should be fixed now.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday














                                          • 2




                                            $begingroup$
                                            When will the program get to [1,2,1]? Remember it has to be within finite time.
                                            $endgroup$
                                            – billpg
                                            yesterday










                                          • $begingroup$
                                            @billpg Should be fixed now.
                                            $endgroup$
                                            – Kevin Cruijssen
                                            yesterday








                                          2




                                          2




                                          $begingroup$
                                          When will the program get to [1,2,1]? Remember it has to be within finite time.
                                          $endgroup$
                                          – billpg
                                          yesterday




                                          $begingroup$
                                          When will the program get to [1,2,1]? Remember it has to be within finite time.
                                          $endgroup$
                                          – billpg
                                          yesterday












                                          $begingroup$
                                          @billpg Should be fixed now.
                                          $endgroup$
                                          – Kevin Cruijssen
                                          yesterday




                                          $begingroup$
                                          @billpg Should be fixed now.
                                          $endgroup$
                                          – Kevin Cruijssen
                                          yesterday











                                          1












                                          $begingroup$


                                          MATL, 16 bytes



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


                                          Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.



                                          Try it online!






                                          share|improve this answer











                                          $endgroup$


















                                            1












                                            $begingroup$


                                            MATL, 16 bytes



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


                                            Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.



                                            Try it online!






                                            share|improve this answer











                                            $endgroup$
















                                              1












                                              1








                                              1





                                              $begingroup$


                                              MATL, 16 bytes



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


                                              Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.



                                              Try it online!






                                              share|improve this answer











                                              $endgroup$




                                              MATL, 16 bytes



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


                                              Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.



                                              Try it online!







                                              share|improve this answer














                                              share|improve this answer



                                              share|improve this answer








                                              edited yesterday

























                                              answered yesterday









                                              Luis MendoLuis Mendo

                                              75.3k889292




                                              75.3k889292























                                                  1












                                                  $begingroup$


                                                  Python 2, 126 112 106 101 100 83 bytes





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


                                                  Try it online!



                                                  5 bytes thx to mypetlion; 1 byte from the eagle eye of ArBo; 17 bytes from xnor!



                                                  Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.






                                                  share|improve this answer











                                                  $endgroup$













                                                  • $begingroup$
                                                    if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                    $endgroup$
                                                    – mypetlion
                                                    yesterday










                                                  • $begingroup$
                                                    I'm pretty sure the space after print b is not needed :D
                                                    $endgroup$
                                                    – ArBo
                                                    18 hours ago










                                                  • $begingroup$
                                                    It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                    $endgroup$
                                                    – xnor
                                                    11 hours ago










                                                  • $begingroup$
                                                    @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                    $endgroup$
                                                    – Chas Brown
                                                    8 hours ago
















                                                  1












                                                  $begingroup$


                                                  Python 2, 126 112 106 101 100 83 bytes





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


                                                  Try it online!



                                                  5 bytes thx to mypetlion; 1 byte from the eagle eye of ArBo; 17 bytes from xnor!



                                                  Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.






                                                  share|improve this answer











                                                  $endgroup$













                                                  • $begingroup$
                                                    if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                    $endgroup$
                                                    – mypetlion
                                                    yesterday










                                                  • $begingroup$
                                                    I'm pretty sure the space after print b is not needed :D
                                                    $endgroup$
                                                    – ArBo
                                                    18 hours ago










                                                  • $begingroup$
                                                    It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                    $endgroup$
                                                    – xnor
                                                    11 hours ago










                                                  • $begingroup$
                                                    @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                    $endgroup$
                                                    – Chas Brown
                                                    8 hours ago














                                                  1












                                                  1








                                                  1





                                                  $begingroup$


                                                  Python 2, 126 112 106 101 100 83 bytes





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


                                                  Try it online!



                                                  5 bytes thx to mypetlion; 1 byte from the eagle eye of ArBo; 17 bytes from xnor!



                                                  Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.






                                                  share|improve this answer











                                                  $endgroup$




                                                  Python 2, 126 112 106 101 100 83 bytes





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


                                                  Try it online!



                                                  5 bytes thx to mypetlion; 1 byte from the eagle eye of ArBo; 17 bytes from xnor!



                                                  Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.







                                                  share|improve this answer














                                                  share|improve this answer



                                                  share|improve this answer








                                                  edited 8 hours ago

























                                                  answered yesterday









                                                  Chas BrownChas Brown

                                                  5,2391523




                                                  5,2391523












                                                  • $begingroup$
                                                    if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                    $endgroup$
                                                    – mypetlion
                                                    yesterday










                                                  • $begingroup$
                                                    I'm pretty sure the space after print b is not needed :D
                                                    $endgroup$
                                                    – ArBo
                                                    18 hours ago










                                                  • $begingroup$
                                                    It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                    $endgroup$
                                                    – xnor
                                                    11 hours ago










                                                  • $begingroup$
                                                    @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                    $endgroup$
                                                    – Chas Brown
                                                    8 hours ago


















                                                  • $begingroup$
                                                    if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                    $endgroup$
                                                    – mypetlion
                                                    yesterday










                                                  • $begingroup$
                                                    I'm pretty sure the space after print b is not needed :D
                                                    $endgroup$
                                                    – ArBo
                                                    18 hours ago










                                                  • $begingroup$
                                                    It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                    $endgroup$
                                                    – xnor
                                                    11 hours ago










                                                  • $begingroup$
                                                    @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                    $endgroup$
                                                    – Chas Brown
                                                    8 hours ago
















                                                  $begingroup$
                                                  if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                  $endgroup$
                                                  – mypetlion
                                                  yesterday




                                                  $begingroup$
                                                  if i==p:i=0;p*=2 can become i%=p;p<<=i<1 to save 5 bytes.
                                                  $endgroup$
                                                  – mypetlion
                                                  yesterday












                                                  $begingroup$
                                                  I'm pretty sure the space after print b is not needed :D
                                                  $endgroup$
                                                  – ArBo
                                                  18 hours ago




                                                  $begingroup$
                                                  I'm pretty sure the space after print b is not needed :D
                                                  $endgroup$
                                                  – ArBo
                                                  18 hours ago












                                                  $begingroup$
                                                  It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                  $endgroup$
                                                  – xnor
                                                  11 hours ago




                                                  $begingroup$
                                                  It looks like the i+p is just counting up 1, 2, 3... in a convoluted way and so can just be a single variable.
                                                  $endgroup$
                                                  – xnor
                                                  11 hours ago












                                                  $begingroup$
                                                  @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                  $endgroup$
                                                  – Chas Brown
                                                  8 hours ago




                                                  $begingroup$
                                                  @xnor: D'oh! Got so wrapped up in the concept, couldn't see the forest for the trees.
                                                  $endgroup$
                                                  – Chas Brown
                                                  8 hours ago











                                                  0












                                                  $begingroup$


                                                  VDM-SL, 51 bytes



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


                                                  Recursive set comprehension with sequence concatenation..



                                                  Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):



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


                                                  Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1






                                                  share|improve this answer









                                                  $endgroup$


















                                                    0












                                                    $begingroup$


                                                    VDM-SL, 51 bytes



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


                                                    Recursive set comprehension with sequence concatenation..



                                                    Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):



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


                                                    Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1






                                                    share|improve this answer









                                                    $endgroup$
















                                                      0












                                                      0








                                                      0





                                                      $begingroup$


                                                      VDM-SL, 51 bytes



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


                                                      Recursive set comprehension with sequence concatenation..



                                                      Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):



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


                                                      Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1






                                                      share|improve this answer









                                                      $endgroup$




                                                      VDM-SL, 51 bytes



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


                                                      Recursive set comprehension with sequence concatenation..



                                                      Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):



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


                                                      Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1







                                                      share|improve this answer












                                                      share|improve this answer



                                                      share|improve this answer










                                                      answered yesterday









                                                      Expired DataExpired Data

                                                      958217




                                                      958217























                                                          0












                                                          $begingroup$


                                                          Wolfram Language (Mathematica), 131 bytes



                                                          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={}


                                                          Try it online!






                                                          share|improve this answer











                                                          $endgroup$


















                                                            0












                                                            $begingroup$


                                                            Wolfram Language (Mathematica), 131 bytes



                                                            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={}


                                                            Try it online!






                                                            share|improve this answer











                                                            $endgroup$
















                                                              0












                                                              0








                                                              0





                                                              $begingroup$


                                                              Wolfram Language (Mathematica), 131 bytes



                                                              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={}


                                                              Try it online!






                                                              share|improve this answer











                                                              $endgroup$




                                                              Wolfram Language (Mathematica), 131 bytes



                                                              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={}


                                                              Try it online!







                                                              share|improve this answer














                                                              share|improve this answer



                                                              share|improve this answer








                                                              edited yesterday

























                                                              answered yesterday









                                                              J42161217J42161217

                                                              14.1k21353




                                                              14.1k21353























                                                                  0












                                                                  $begingroup$

                                                                  perl -M5.010 122 bytes



                                                                  $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}"


                                                                  Added some newlines for readabilities sake (not counted in the byte count)






                                                                  share|improve this answer











                                                                  $endgroup$


















                                                                    0












                                                                    $begingroup$

                                                                    perl -M5.010 122 bytes



                                                                    $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}"


                                                                    Added some newlines for readabilities sake (not counted in the byte count)






                                                                    share|improve this answer











                                                                    $endgroup$
















                                                                      0












                                                                      0








                                                                      0





                                                                      $begingroup$

                                                                      perl -M5.010 122 bytes



                                                                      $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}"


                                                                      Added some newlines for readabilities sake (not counted in the byte count)






                                                                      share|improve this answer











                                                                      $endgroup$



                                                                      perl -M5.010 122 bytes



                                                                      $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}"


                                                                      Added some newlines for readabilities sake (not counted in the byte count)







                                                                      share|improve this answer














                                                                      share|improve this answer



                                                                      share|improve this answer








                                                                      edited yesterday

























                                                                      answered yesterday









                                                                      AbigailAbigail

                                                                      48617




                                                                      48617























                                                                          0












                                                                          $begingroup$


                                                                          Python 2, 120 bytes





                                                                          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


                                                                          Try it online!



                                                                          A bit longer than most other answers, but I liked the idea behind it.






                                                                          share|improve this answer









                                                                          $endgroup$


















                                                                            0












                                                                            $begingroup$


                                                                            Python 2, 120 bytes





                                                                            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


                                                                            Try it online!



                                                                            A bit longer than most other answers, but I liked the idea behind it.






                                                                            share|improve this answer









                                                                            $endgroup$
















                                                                              0












                                                                              0








                                                                              0





                                                                              $begingroup$


                                                                              Python 2, 120 bytes





                                                                              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


                                                                              Try it online!



                                                                              A bit longer than most other answers, but I liked the idea behind it.






                                                                              share|improve this answer









                                                                              $endgroup$




                                                                              Python 2, 120 bytes





                                                                              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


                                                                              Try it online!



                                                                              A bit longer than most other answers, but I liked the idea behind it.







                                                                              share|improve this answer












                                                                              share|improve this answer



                                                                              share|improve this answer










                                                                              answered 18 hours ago









                                                                              ArBoArBo

                                                                              48018




                                                                              48018























                                                                                  -4












                                                                                  $begingroup$

                                                                                  Python3 (58 characters)



                                                                                  This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.



                                                                                  from itertools import*
                                                                                  lambda n:product(count(1),repeat=n)


                                                                                  Proof that this works for limited integer range:



                                                                                  from itertools import*
                                                                                  l = lambda n: product(range(1, 10), repeat=n)
                                                                                  print(list(l(3))) # returns all permutations of (1, 2, 3, ..., 10) of length 3





                                                                                  share|improve this answer











                                                                                  $endgroup$









                                                                                  • 2




                                                                                    $begingroup$
                                                                                    This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    yesterday










                                                                                  • $begingroup$
                                                                                    My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                    $endgroup$
                                                                                    – agtoever
                                                                                    22 hours ago






                                                                                  • 1




                                                                                    $begingroup$
                                                                                    I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                    $endgroup$
                                                                                    – Chas Brown
                                                                                    20 hours ago






                                                                                  • 5




                                                                                    $begingroup$
                                                                                    @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    19 hours ago
















                                                                                  -4












                                                                                  $begingroup$

                                                                                  Python3 (58 characters)



                                                                                  This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.



                                                                                  from itertools import*
                                                                                  lambda n:product(count(1),repeat=n)


                                                                                  Proof that this works for limited integer range:



                                                                                  from itertools import*
                                                                                  l = lambda n: product(range(1, 10), repeat=n)
                                                                                  print(list(l(3))) # returns all permutations of (1, 2, 3, ..., 10) of length 3





                                                                                  share|improve this answer











                                                                                  $endgroup$









                                                                                  • 2




                                                                                    $begingroup$
                                                                                    This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    yesterday










                                                                                  • $begingroup$
                                                                                    My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                    $endgroup$
                                                                                    – agtoever
                                                                                    22 hours ago






                                                                                  • 1




                                                                                    $begingroup$
                                                                                    I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                    $endgroup$
                                                                                    – Chas Brown
                                                                                    20 hours ago






                                                                                  • 5




                                                                                    $begingroup$
                                                                                    @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    19 hours ago














                                                                                  -4












                                                                                  -4








                                                                                  -4





                                                                                  $begingroup$

                                                                                  Python3 (58 characters)



                                                                                  This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.



                                                                                  from itertools import*
                                                                                  lambda n:product(count(1),repeat=n)


                                                                                  Proof that this works for limited integer range:



                                                                                  from itertools import*
                                                                                  l = lambda n: product(range(1, 10), repeat=n)
                                                                                  print(list(l(3))) # returns all permutations of (1, 2, 3, ..., 10) of length 3





                                                                                  share|improve this answer











                                                                                  $endgroup$



                                                                                  Python3 (58 characters)



                                                                                  This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.



                                                                                  from itertools import*
                                                                                  lambda n:product(count(1),repeat=n)


                                                                                  Proof that this works for limited integer range:



                                                                                  from itertools import*
                                                                                  l = lambda n: product(range(1, 10), repeat=n)
                                                                                  print(list(l(3))) # returns all permutations of (1, 2, 3, ..., 10) of length 3






                                                                                  share|improve this answer














                                                                                  share|improve this answer



                                                                                  share|improve this answer








                                                                                  edited 22 hours ago

























                                                                                  answered yesterday









                                                                                  agtoeveragtoever

                                                                                  1,406425




                                                                                  1,406425








                                                                                  • 2




                                                                                    $begingroup$
                                                                                    This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    yesterday










                                                                                  • $begingroup$
                                                                                    My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                    $endgroup$
                                                                                    – agtoever
                                                                                    22 hours ago






                                                                                  • 1




                                                                                    $begingroup$
                                                                                    I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                    $endgroup$
                                                                                    – Chas Brown
                                                                                    20 hours ago






                                                                                  • 5




                                                                                    $begingroup$
                                                                                    @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    19 hours ago














                                                                                  • 2




                                                                                    $begingroup$
                                                                                    This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    yesterday










                                                                                  • $begingroup$
                                                                                    My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                    $endgroup$
                                                                                    – agtoever
                                                                                    22 hours ago






                                                                                  • 1




                                                                                    $begingroup$
                                                                                    I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                    $endgroup$
                                                                                    – Chas Brown
                                                                                    20 hours ago






                                                                                  • 5




                                                                                    $begingroup$
                                                                                    @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                    $endgroup$
                                                                                    – alexis
                                                                                    19 hours ago








                                                                                  2




                                                                                  2




                                                                                  $begingroup$
                                                                                  This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                  $endgroup$
                                                                                  – alexis
                                                                                  yesterday




                                                                                  $begingroup$
                                                                                  This is not a solution :-( The last element of the tuple will increase forever, so the other elements will never be reached. ("After infinity" does not count.) Also you never visit (1,1,1), etc., even in the demo case.
                                                                                  $endgroup$
                                                                                  – alexis
                                                                                  yesterday












                                                                                  $begingroup$
                                                                                  My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                  $endgroup$
                                                                                  – agtoever
                                                                                  22 hours ago




                                                                                  $begingroup$
                                                                                  My mistake. I should have used product and not permutations. This will return all tuples in the order that it will iterate the last element until infinity first and after that the element after that, etc. As I see it, all rules are obliged. I just chose another order...
                                                                                  $endgroup$
                                                                                  – agtoever
                                                                                  22 hours ago




                                                                                  1




                                                                                  1




                                                                                  $begingroup$
                                                                                  I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                  $endgroup$
                                                                                  – Chas Brown
                                                                                  20 hours ago




                                                                                  $begingroup$
                                                                                  I do not think "Proof that this works for..." means what you think it means - Inigo Montoya
                                                                                  $endgroup$
                                                                                  – Chas Brown
                                                                                  20 hours ago




                                                                                  5




                                                                                  5




                                                                                  $begingroup$
                                                                                  @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                  $endgroup$
                                                                                  – alexis
                                                                                  19 hours ago




                                                                                  $begingroup$
                                                                                  @agtoever, you do not satisfy the rules. "Each valid tuple must be reached in finite time" translates into you cannot "run to infinity" on the last element and then come back for the rest. This is the whole point of this challenge.
                                                                                  $endgroup$
                                                                                  – alexis
                                                                                  19 hours ago


















                                                                                  draft saved

                                                                                  draft discarded




















































                                                                                  If this is an answer to a challenge…




                                                                                  • …Be sure to follow the challenge specification. However, please refrain from exploiting obvious loopholes. Answers abusing any of the standard loopholes are considered invalid. If you think a specification is unclear or underspecified, comment on the question instead.


                                                                                  • …Try to optimize your score. For instance, answers to code-golf challenges should attempt to be as short as possible. You can always include a readable version of the code in addition to the competitive one.
                                                                                    Explanations of your answer make it more interesting to read and are very much encouraged.


                                                                                  • …Include a short header which indicates the language(s) of your code and its score, as defined by the challenge.



                                                                                  More generally…




                                                                                  • …Please make sure to answer the question and provide sufficient detail.


                                                                                  • …Avoid asking for help, clarification or responding to other answers (use comments instead).





                                                                                  draft saved


                                                                                  draft discarded














                                                                                  StackExchange.ready(
                                                                                  function () {
                                                                                  StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodegolf.stackexchange.com%2fquestions%2f183225%2flist-all-the-tuples%23new-answer', 'question_page');
                                                                                  }
                                                                                  );

                                                                                  Post as a guest















                                                                                  Required, but never shown





















































                                                                                  Required, but never shown














                                                                                  Required, but never shown












                                                                                  Required, but never shown







                                                                                  Required, but never shown

































                                                                                  Required, but never shown














                                                                                  Required, but never shown












                                                                                  Required, but never shown







                                                                                  Required, but never shown







                                                                                  Popular posts from this blog

                                                                                  數位音樂下載

                                                                                  格利澤436b

                                                                                  When can things happen in Etherscan, such as the picture below?