List *all* the tuples!
$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.
code-golf sequence
$endgroup$
|
show 2 more comments
$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.
code-golf sequence
$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
|
show 2 more comments
$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.
code-golf sequence
$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
code-golf sequence
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
|
show 2 more comments
$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
|
show 2 more comments
16 Answers
16
active
oldest
votes
$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.
$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 ofn-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 after4,1,2
and5,1,1
.
$endgroup$
– Jonah
14 hours ago
1
$begingroup$
@Jonah The recursion works like this. You start with 1-tuples overN
. For 2-tuples you take Cartesian product withN
ordered by sum of indices. In both lists, each numbern
is at indexn
so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product ofN
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
add a comment |
$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).
$endgroup$
add a comment |
$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.
$endgroup$
add a comment |
$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.
$endgroup$
1
$begingroup$
f}bT
->}#b
Also, your byte count seems to be incorrect at the moment?
$endgroup$
– FryAmTheEggman
23 hours ago
add a comment |
$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).
$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
add a comment |
$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...
$endgroup$
5
$begingroup$
This doesn't list every tuple exactly once (for instance,(0, 1, 0, 0)
is not listed).
$endgroup$
– bb94
yesterday
add a comment |
$begingroup$
Wolfram Language (Mathematica), 62 bytes
Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&
Try it online!
-3 bytes with inconsistent separation (delete @#&
)
Try it online!
$endgroup$
add a comment |
$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)
$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
add a comment |
$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
$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
add a comment |
$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!
$endgroup$
add a comment |
$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
0
s and m
1
s.
$endgroup$
$begingroup$
if i==p:i=0;p*=2
can becomei%=p;p<<=i<1
to save 5 bytes.
$endgroup$
– mypetlion
yesterday
$begingroup$
I'm pretty sure the space afterprint b
is not needed :D
$endgroup$
– ArBo
18 hours ago
$begingroup$
It looks like thei+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
add a comment |
$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
$endgroup$
add a comment |
$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!
$endgroup$
add a comment |
$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)
$endgroup$
add a comment |
$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.
$endgroup$
add a comment |
$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
$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 usedproduct
and notpermutations
. 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
add a comment |
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
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
$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.
$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 ofn-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 after4,1,2
and5,1,1
.
$endgroup$
– Jonah
14 hours ago
1
$begingroup$
@Jonah The recursion works like this. You start with 1-tuples overN
. For 2-tuples you take Cartesian product withN
ordered by sum of indices. In both lists, each numbern
is at indexn
so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product ofN
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
add a comment |
$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.
$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 ofn-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 after4,1,2
and5,1,1
.
$endgroup$
– Jonah
14 hours ago
1
$begingroup$
@Jonah The recursion works like this. You start with 1-tuples overN
. For 2-tuples you take Cartesian product withN
ordered by sum of indices. In both lists, each numbern
is at indexn
so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product ofN
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
add a comment |
$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.
$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.
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 ofn-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 after4,1,2
and5,1,1
.
$endgroup$
– Jonah
14 hours ago
1
$begingroup$
@Jonah The recursion works like this. You start with 1-tuples overN
. For 2-tuples you take Cartesian product withN
ordered by sum of indices. In both lists, each numbern
is at indexn
so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product ofN
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
add a comment |
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 ofn-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 after4,1,2
and5,1,1
.
$endgroup$
– Jonah
14 hours ago
1
$begingroup$
@Jonah The recursion works like this. You start with 1-tuples overN
. For 2-tuples you take Cartesian product withN
ordered by sum of indices. In both lists, each numbern
is at indexn
so for length 2 the result happens to be ordered by sum. To get 3-tuples you take Cartesian product ofN
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
add a comment |
$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).
$endgroup$
add a comment |
$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).
$endgroup$
add a comment |
$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).
$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).
answered yesterday
LynnLynn
51k899234
51k899234
add a comment |
add a comment |
$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.
$endgroup$
add a comment |
$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.
$endgroup$
add a comment |
$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.
$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.
answered yesterday
xnorxnor
94.1k18192452
94.1k18192452
add a comment |
add a comment |
$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.
$endgroup$
1
$begingroup$
f}bT
->}#b
Also, your byte count seems to be incorrect at the moment?
$endgroup$
– FryAmTheEggman
23 hours ago
add a comment |
$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.
$endgroup$
1
$begingroup$
f}bT
->}#b
Also, your byte count seems to be incorrect at the moment?
$endgroup$
– FryAmTheEggman
23 hours ago
add a comment |
$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.
$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.
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
add a comment |
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
add a comment |
$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).
$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
add a comment |
$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).
$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
add a comment |
$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).
$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).
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
add a comment |
$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
add a comment |
$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...
$endgroup$
5
$begingroup$
This doesn't list every tuple exactly once (for instance,(0, 1, 0, 0)
is not listed).
$endgroup$
– bb94
yesterday
add a comment |
$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...
$endgroup$
5
$begingroup$
This doesn't list every tuple exactly once (for instance,(0, 1, 0, 0)
is not listed).
$endgroup$
– bb94
yesterday
add a comment |
$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...
$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...
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
add a comment |
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
add a comment |
$begingroup$
Wolfram Language (Mathematica), 62 bytes
Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&
Try it online!
-3 bytes with inconsistent separation (delete @#&
)
Try it online!
$endgroup$
add a comment |
$begingroup$
Wolfram Language (Mathematica), 62 bytes
Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&
Try it online!
-3 bytes with inconsistent separation (delete @#&
)
Try it online!
$endgroup$
add a comment |
$begingroup$
Wolfram Language (Mathematica), 62 bytes
Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&
Try it online!
-3 bytes with inconsistent separation (delete @#&
)
Try it online!
$endgroup$
Wolfram Language (Mathematica), 62 bytes
Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&
Try it online!
-3 bytes with inconsistent separation (delete @#&
)
Try it online!
answered yesterday
attinatattinat
5897
5897
add a comment |
add a comment |
$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)
$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
add a comment |
$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)
$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
add a comment |
$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)
$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)
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
add a comment |
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
add a comment |
$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
$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
add a comment |
$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
$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
add a comment |
$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
$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
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
add a comment |
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
add a comment |
$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!
$endgroup$
add a comment |
$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!
$endgroup$
add a comment |
$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!
$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!
edited yesterday
answered yesterday
Luis MendoLuis Mendo
75.3k889292
75.3k889292
add a comment |
add a comment |
$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
0
s and m
1
s.
$endgroup$
$begingroup$
if i==p:i=0;p*=2
can becomei%=p;p<<=i<1
to save 5 bytes.
$endgroup$
– mypetlion
yesterday
$begingroup$
I'm pretty sure the space afterprint b
is not needed :D
$endgroup$
– ArBo
18 hours ago
$begingroup$
It looks like thei+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
add a comment |
$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
0
s and m
1
s.
$endgroup$
$begingroup$
if i==p:i=0;p*=2
can becomei%=p;p<<=i<1
to save 5 bytes.
$endgroup$
– mypetlion
yesterday
$begingroup$
I'm pretty sure the space afterprint b
is not needed :D
$endgroup$
– ArBo
18 hours ago
$begingroup$
It looks like thei+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
add a comment |
$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
0
s and m
1
s.
$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
0
s and m
1
s.
edited 8 hours ago
answered yesterday
Chas BrownChas Brown
5,2391523
5,2391523
$begingroup$
if i==p:i=0;p*=2
can becomei%=p;p<<=i<1
to save 5 bytes.
$endgroup$
– mypetlion
yesterday
$begingroup$
I'm pretty sure the space afterprint b
is not needed :D
$endgroup$
– ArBo
18 hours ago
$begingroup$
It looks like thei+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
add a comment |
$begingroup$
if i==p:i=0;p*=2
can becomei%=p;p<<=i<1
to save 5 bytes.
$endgroup$
– mypetlion
yesterday
$begingroup$
I'm pretty sure the space afterprint b
is not needed :D
$endgroup$
– ArBo
18 hours ago
$begingroup$
It looks like thei+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
add a comment |
$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
$endgroup$
add a comment |
$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
$endgroup$
add a comment |
$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
$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
answered yesterday
Expired DataExpired Data
958217
958217
add a comment |
add a comment |
$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!
$endgroup$
add a comment |
$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!
$endgroup$
add a comment |
$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!
$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!
edited yesterday
answered yesterday
J42161217J42161217
14.1k21353
14.1k21353
add a comment |
add a comment |
$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)
$endgroup$
add a comment |
$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)
$endgroup$
add a comment |
$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)
$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)
edited yesterday
answered yesterday
AbigailAbigail
48617
48617
add a comment |
add a comment |
$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.
$endgroup$
add a comment |
$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.
$endgroup$
add a comment |
$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.
$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.
answered 18 hours ago
ArBoArBo
48018
48018
add a comment |
add a comment |
$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
$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 usedproduct
and notpermutations
. 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
add a comment |
$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
$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 usedproduct
and notpermutations
. 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
add a comment |
$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
$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
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 usedproduct
and notpermutations
. 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
add a comment |
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 usedproduct
and notpermutations
. 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
add a comment |
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).
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
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
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
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
$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