Make my number a set
Natural to set
(set meaning an unordered collection with no duplicates, though answers may use and output lists instead)
Recently I was brainstorming what a language with only (arbitrarily nested) sets would be like. A number is represented with a set of that many elements. The elements need to be different, which leads to this definition:
Definition
- The set representation of $0$ is the empty set.
- The set representation of any other integer $n$ is the set of the set representations of all positive integers less than $n$, including zero.
- Negative, complex, or rational numbers do not need to be handled.
- Your full program or function is to convert from a positive integer to a set or list.
Examples
0 {}
1 {{}}
2 {{}, {{}}}
3 {{}, {{}}, {{}, {{}}}}
[JavaScript (V8)], 32 bytes …
3y ago
BQN, 7 6 bytesSBCS ``` ≢↑∘ …
3y ago
[APL (ngn/apl)], 6 bytes …
3y ago
[Python 3], 34 bytes …
3y ago
Japt, 3 bytes ``` ÆßX ``` …
3y ago
[Jelly], 3 bytes Ḷ߀ …
3y ago
[Haskell], 51 31 bytes Save …
3y ago
[Ruby], 27 bytes ```ruby - …
3y ago
Jq, 19 bytes ```python def …
3y ago
Ruby, 23 bytes ```ruby ->n …
3y ago
10 answers
You are accessing this answer with a direct link, so it's being shown above all other answers regardless of its score. You can return to the normal view.
Haskell, 51 31 bytes
Saved 20 bytes thanks to Hakerh400!
data S=S[S]
f i=S$map f[0..i-1]
S is a recursive data structure, because sets of varying element types can't be represented with simple lists in Haskell.
BQN, 7 6 bytesSBCS
≢↑∘⊢´↕
The less-golfed version {↑⍟𝕩⟨⟩} is more readable: it applies Prefixes (↑) the given number of times to the empty list ⟨⟩ and… that's it. (Suffixes also works, placing elements in the opposite order). The reason this works is that a prefix of a set-number is also a set-number, so that the values of the prefixes for n range from the empty prefix 0 to the complete prefix n. This list is defined to be n+1.
The golfed version uses Fold (´) and some other tricks to turn the computation into a 3-train: something that doesn't work well with Repeat (⍟) because the number needs to be an operand.
≢↑∘⊢´↕
↕ # Range: a list with length given by the argument
≢ # Shape: an empty list as the argument has no axes
´ # Fold over the range, starting with the shape
↑ # Prefixes
∘⊢ # Of the right argument
0 comment threads
JavaScript (V8), 32 bytes
f=n=>[...Array(n).keys()].map(f)
Somehow it doesn't recurse forever at n=0. Pretty nice.
APL (ngn/apl), 6 bytes
{∇¨⍳⍵}
Dyalog APL and dzaima/APL appear to not give empty vectors for ⍳0, so I used ngn/APL. I don't know how to turn on boxing there, though, so there's extra processing code in the footer.
{∇¨⍳⍵}
⍵ ⍝ The input
⍳ ⍝ Make a range [1,⍵]
∇¨ ⍝ For each number in that range, run this function on it
0 comment threads
Python 3, 34 bytes
f=lambda x:[f(y)for y in range(x)]
-9 bytes thanks to Moshi
Unfortunately, I cannot use Python sets, because sets are unhashable and thus cannot be put into sets.
Japt, 3 bytes
ÆßX
Try it online! (don't mind the -Q
This is Shaggy's solution.
ÆßX
Æ Make a range [0, input) and map each number X:
ß Run this program again on
X
Japt, 11 8 bytes
Saved 3 bytes thanks to Shaggy! (Shaggy also has a 3-byter ready)
gA=_o mA
This is practically a port of Razetime's answer, which you should upvote!
gA=_o mA
g Apply the following function to the input
A= It's a recursive function, so assign it to the variable A
_o Make a range [0, Z), where Z is the input
mA And map every number in that range to A again
Ruby, 27 bytes
->n{x=[];n.times{x<<x*1};x}
->n{ } # lambda taking n
x=[]; # set x to empty array
n.times{ }; # repeat n times
x<<x*1 # append x with a copy of itself
x # return x
Ruby, 23 bytes
->n,*x{eval'x<<x*1;'*n}
There is also 22 bytes version, but it uses special $* global variables (so it can be run only once in single process):
->n{eval'$*<<$**1;'*n}
0 comment threads
0 comment threads