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

3mo ago

BQN, 7 6 bytesSBCS ``` ≢↑∘ …

3mo ago

[APL (ngn/apl)], 6 bytes …

3mo ago

[Python 3], 34 bytes …

8d ago

Japt, 3 bytes ``` ÆßX ``` …

29d ago

[Jelly], 3 bytes Ḷß€ …

~2mo ago

[Haskell], 51 31 bytes Save …

~1mo ago

Jq, 19 bytes ```python def …

3mo ago

[Ruby], 27 bytes ```ruby - …

13d ago

## 9 answers

#
BQN, ~~7~~ 6 bytes^{SBCS}

```
≢↑∘⊢´↕
```

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.

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

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

## 0 comment threads