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