Natural construction

The natural numbers including 0 are formally defined as sets, in the following way:

• Number 0 is defined as the empty set, {}
• For n ≥ 0, number n+1 is defined as n ∪ {n}.

As a consequence, n = {0, 1, ..., n-1}.

The first numbers, defined by this procedure, are:

• 0 = {}
• 1 = {{}}
• 2 = {{}, {{}}}
• 3 = {{}, {{}}, {{}, {{}}}}

Challenge

Given n, output its representation as a set.

Rules

The output can consistently use any bracket character such as {}, [], () or <>. Arbitrary characters (such as 01) are not allowed.

Instead of a comma as above, the separator can be any punctuation sign; or it may be inexistent.

Spaces (not newlines) may be included arbitrarily and inconsistently.

For example, number 2 with square brackets and semicolon as separator is [[]; [[]]], or equivalently [ [ ]; [ [ ] ] ], or even [ [ ] ;[ []]]

The order in which elements of a set are specified doesn't matter. So you can use any order in the representation. For example, these are some valid outputs for 3:

{{},{{}},{{},{{}}}}
{{{}},{{},{{}}},{}}
{{{}},{{{}},{}},{}}


You can write a program or function. Output may be a string or, if using a function, you may return a nested list or array whose string representation conforms to the above.

Test cases

0  ->  {}
1  ->  {{}}
2  ->  {{},{{}}}
3  ->  {{},{{}},{{},{{}}}}
4  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}
5  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}
6  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}
7  ->  {{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}},{{},{{}},{{},{{}}},{{},{{}},{{},{{}}}}}}}}

• Related Sep 30, 2016 at 21:45

Python 2, 26 bytes

f=lambda n:map(f,range(n))


Test it on Ideone.

Jelly, 3 bytes

Ḷß€


How it works

Each natural number is the set of all previous natural numbers, i.e., n = {0, …, n-1}. Since there are no natural numbers preceding 0, we have that 0 = {}.

Ḷß€  Monadic link. Argument: n (natural number)

Ḷ    Unlength; yield [0, ..., n-1].
ß€  Recursively map this link over the range.

• "Unlength" I like Jelly's inverse functions. Sep 30, 2016 at 22:07
• If I am understanding correctly, unlength is basically range [0,n)? Sep 30, 2016 at 22:31
• @Downgoat That's correct. I try to keep letters and letters with dot below as lateral inverses. Since ḶL is a no-op, the mnemonic is unlength. There's also unbinary, undecimal, unhalve, unsine, unarccosine, etc. Sep 30, 2016 at 23:08
• Wait, unarccosine? Wouldn't that just be cosine? Oct 4, 2016 at 0:42
• @ETHproductions Yup. There's no C with dot below though. Oct 4, 2016 at 1:20

JavaScript (ES6), 32 bytes

f=n=>[...Array(n).keys()].map(f)


Simple enough.

• @Downgoat I think this may be the first time I've used .map() without an arrow function inside :-) Sep 30, 2016 at 22:29
• well technically f is an arrow function :P Sep 30, 2016 at 23:57
• @ETHproductions Really? .map(Number) is quite a common case. Oct 1, 2016 at 0:36
• @Xufox Though .map(e=>+e) is shorter, by a byte. Oct 1, 2016 at 3:50
• @ConorO'Brien Usually .map(eval)
– l4m2
Mar 26 at 2:16

Perl 6, 16 bytes

{({@_}…*)[$_]}  Returns nested data structure. Example: say {({@_}…*)[$_]}( 4 );
# [[] [[]] [[] [[]]] [[] [[]] [[] [[]]]]]


Explanation:

{   # lambda with implicit parameter ｢$_｣ ( # produce a lazy infinite sequence of all results { # lambda with implicit parameter ｢@_｣ @_ # array containing all previously seen values in the sequence } … # keep repeating that block until: * # Whatever ( never stop ) )[$_ ]   # use the outer block's argument to index into the sequence

}

• This is... impressive. Oct 1, 2016 at 3:51

p n='{':(p=<<[0..n-1])++"}"


Try it on Ideone.

Ruby, 27 21 bytes

I'm new to ruby golfing, but here goes nothing. Thanks to Jordan for saving 6 bytes!

f=->s{(0...s).map &f}


This is a recursive function f (a proc, to be specific) and takes an argument s. It maps the proc f over 0...s, which is the range [0, s).

• You can replace map{|e|f[e]} with map &f. Sep 30, 2016 at 23:34
• @Jordan Wow, nice! Sep 30, 2016 at 23:35

05AB1E, 8 7 bytes

)IF)©®


Explanation

)         # wrap stack in a list, as stack is empty this becomes the empty list []
IF       # input number of times do:
)      # wrap stack in list
©     # store a copy of the list in the register
# flatten the list
®   # push the copy from the register
# implicitly print top value of stack after the last loop iteration


Try it online!

Saved 1 byte thanks to Adnan.

• Less than 2 minutes LOL Sep 30, 2016 at 21:46
• @LuisMendo I literally just logged on when the challenge was posted :) Sep 30, 2016 at 21:47
• I believe you can remove the last bracket :p Oct 2, 2016 at 16:36
• @Adnan: Oops. I don't know how I missed that :) Oct 2, 2016 at 18:05

CJam, 14 bytes

"[]"{_)@\]}ri*


Try it online!

Explanation

"[]"            e# Push this string. It is the representation of 0, and also serves
e# to initialize
{     }ri*  e# Repeat this block as many times as the input number
_          e# Duplicate
)         e# Uncons: split into array without the last element, and last element
@\       e# Rotate, swap
]      e# Pack stack contents into an array
e# Implicitly display


In each iteration, the block builds the representation of a number from that of the preceding one. To illustrate, let's consider the second iteration, where the representation of number 2 is built from that of 1, which is the string "[[]]".

1. The stack contains "[[]]"
2. After statement _ (duplicate) it contains "[[]]", "[[]]"
3. After statement ) (uncons) it contains "[[]]", "[[]", "]"
4. After statement @ (rotate) it contains "[[]", "]", "[[]]"
5. After statement \ (swap) it contains "[[]", "[[]]", "]"
6. After statement ] (pack into array) it contains ["[[]" "[[]]" "]"], which would be displayed as the string "[[][[]]]".

Cheddar, 17 bytes

n f->(|>n).map(f)


Short recursion + Short range + Short iteration = A challenge where cheddar does very well

Non-competing, 11 bytes

n f->|>n=>f


The => operator was added after this challenge was released making this answer non-competing.

This may look confusing but let me simplify it:

n f -> |> n => f


basically n is the input and f is the function itself. |>n generates [0, n) and => maps that over f.

• The non-competing one looks very nice :D Oct 2, 2016 at 17:51

Mathematica, 14 bytes

Array[#0,#,0]&


Pyth, 4 bytes

LyMb


Test suite

L: Define the function y with input b

yMb: y mapped over the range 0, 1, ..., b-1

On the input 0, this map returns []. Otherwise, it returns y mapped over all numbers up to b.

MATL, 13 bytes

Xhi:"tY:Xh]&D


Try it online!

Explanation

Xh              % Concatenate the stack contents into cell array. Since the stack
% is empty, this produces the empty cell array, {}
i:"     ]     % Take input number. Repeat that many times
t          % Duplicate the cell array that is at the top of the stack
Y:        % Unbox it, i.e., push its contents onto the stack
Xh      % Concatenate the stack contents into a cell array
&D   % String representation. Implicitly display

• Very clever answer Sep 30, 2016 at 22:33
• @Suever Thanks! Way too long though... Sep 30, 2016 at 22:35

Perl, 27 bytes

Includes +1 for -p

Many different methods all seem to end up as either 27 or 28 bytes. e.g.

#!/usr/bin/perl -p
$\=$_="{@F}"for@F[0..$_]}{  The best I could find is #!/usr/bin/perl -p s/./{$_/ for($\="{}")x$_}{


since on older perls you can drop the space before the for and get 26 bytes

((:a*)~^()~^a)


Try it online!

Underload full programs can't take input via any of our defined methods, so this is a function that takes input from the stack as a Church numeral (the normal way to define integers in Underload), and produces output to the stack as a string.

The (…) grouping markers are required to make this a function (reusable) rather than a snippet (only usable once). The wrapper in the TIO link calls the function in question destructively using ^, but it could be reused via making a copy of it and only consuming one of the copies when calling it. It also provides input to the program (here, (:*:*), i.e. 4), and prints the output using S.

Explanation

Underload's surprisingly suited for this task as Turing tarpits go, having such useful primitives as "copy" and "surround with parentheses". (Somehow, Underload, normally a very verbose language, is beating Mathematica, normally a language which wins due to having a huge set of builtins, via having more appropriate builtins!) Here's how the program works:

((:a*)~^()~^a)
(            )   Make a snippet into a function
(   )~^         Exponentiate the following function by the top of stack:
:                Copy the top stack element
a               Surround the copy in parentheses
*              Append the copy to the original, popping the copy
~^     Run the resulting function, with the following argument on its stack:
()         Empty string
a    Surround the result in parentheses


Function exponentiation effectively causes the steps of the function to repeat that many times, so, e.g., (:a*)³ would be (:a*:a*:a*). That's the idiomatic way to write a loop that repeats a given number of times in Underload. (You can note that the ~^ is described two different ways above; that's because integers in Underload are defined as function exponentiation specialised to that integer, so in order to do a function exponentiation, you simply try to execute an integer as though it were a function.)

Husk, 10 bytes

:'}:'{ṁ₀ŀ


Try it online!

:'}:'{ṁ₀ŀ
ŀ  Range [0, n)
ṁ₀   For all numbers in that range, run this function on them
ṁ    Then concatenate those representations together
:'{     Prepend '{'
:'}        Append '}'

• i thought of s; and then removing the quotes and backslashes, but it doesn't get below 10 :( Apr 28, 2021 at 8:47

Mathematica, 31 bytes

Straightforwardly implements the definition as a nested list. Uses an unnamed function that recursively calls itself using #0.

If[#<1,{},Join[t=#0[#-1],{t}]]&

• You can save a lot by using a named operator as well as Union instead of Join: ±0={};±n_:={t=±(n-1)}⋃t ... However, in this case it's even shorter to go for an iterative solution: Nest[{#}⋃#&,{},#]& Oct 2, 2016 at 16:53

Retina, 24 18 bytes

.+
$*1<> +1< <<$'


Try it online! (The first line enables a linefeed-separated test suite.)

Explanation

.+
$*1<>  This converts the input to unary and appends <>, the representation of 0. +1< <<$'


Here, the + indicates that this substitution should be run in a loop until the string stops changing. It's easier to explain this by going through the individual steps I took golfing it down. Let's with this version of the substitution:

1<(.*)>
<<$1>$1>


This matches the last 1 of the unary representation of the remaining input (to remove it and decrement the input), as well as the contents of the current set at the end. This is then replaced with a new set containing the previous one as well as its contents. However, we can notice that $1 is followed by > in both cases and hence we can include it in the capture itself and omit it from the substitution pattern. That leads to the form 1<(.*) <<$1$1  However, now we can observe that (.*) just captures the suffix of the string after 1< and we even reinsert this suffix at the end with $1. Since the substitution syntax gives us a way to refer to the part of a string after a match with $' we can simply omit both of those parts and end up with the version used in the answer: 1< <<$'

• You sure this is Retina and not the ><> language? :-P Oct 2, 2016 at 17:18
• @LuisMendo I guess I could have used {}, but <> is the only pair that never needs escaping, so I thought I'd go with that. ;) Oct 2, 2016 at 17:22

Batch, 74 bytes

@set s={}
@for /l %%i in (1,1,%1)do @call set s={%%s%%%%s:~1%%
@echo %s%


Uses the fact that each answer is equal to the previous answer inserted into itself after the leading {. The first few outputs are as follows:

{}

{{}}

{{{}}{}}

{{{{}}{}}{{}}{}}

{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}

{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}

• Can you post an example showing input and output formats? Mar 7, 2017 at 10:40

Pari/GP, 23 bytes

f(n)=[f(i)|i<-[0..n-1]]


Try it online!

APL(NARS), 15 chars, 30 bytes

{⍵=0:⍬⋄∇¨¯1+⍳⍵}


test:

  f←{⍵=0:⍬⋄∇¨¯1+⍳⍵}
o←⎕fmt
o f 0
┌0─┐
│ 0│
└~─┘
o f 1
┌1───┐
│┌0─┐│
││ 0││
│└~─┘2
└∊───┘
o f 2
┌2──────────┐
│┌0─┐ ┌1───┐│
││ 0│ │┌0─┐││
│└~─┘ ││ 0│││
│     │└~─┘2│
│     └∊───┘3
└∊──────────┘
o f 3
┌3────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐│││
│     │└~─┘2 │└~─┘ ││ 0││││
│     └∊───┘ │     │└~─┘2││
│            │     └∊───┘3│
│            └∊──────────┘4
└∊────────────────────────┘
o f 4
┌4────────────────────────────────────────────────────┐
│┌0─┐ ┌1───┐ ┌2──────────┐ ┌3────────────────────────┐│
││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│ │┌0─┐ ┌1───┐ ┌2──────────┐││
│└~─┘ ││ 0││ ││ 0│ │┌0─┐││ ││ 0│ │┌0─┐│ │┌0─┐ ┌1───┐│││
│     │└~─┘2 │└~─┘ ││ 0│││ │└~─┘ ││ 0││ ││ 0│ │┌0─┐││││
│     └∊───┘ │     │└~─┘2│ │     │└~─┘2 │└~─┘ ││ 0│││││
│            │     └∊───┘3 │     └∊───┘ │     │└~─┘2│││
│            └∊──────────┘ │            │     └∊───┘3││
│                          │            └∊──────────┘4│
│                          └∊────────────────────────┘5
└∊────────────────────────────────────────────────────┘


I don't know if this would be accepted... Zilde is ⍬ here it represent the void set {} if I want print the Zilde element or one element full of Zilde, and Zilde enclosed all what happen is print nothing... so for see Zilde one has to define one function I call it o (o←⎕fmt) I do not insert in the count because the element and its structure exist even if the sys not print it...It is possible if io is 0

{⍵=0:⍬⋄∇¨⍳⍵}


could be 12 characters solution too...

Pip-p, 4 bytes

fM,a


Try it online!

The basic recursive approach works well in Pip:

f     The main function, i.e. the whole program treated as a function
M    mapped to
,a  range(argument)


The result is a nested list, which is printed using square brackets thanks to the -p flag.

Raku, 17 15 bytes

(),{|$_,$_}...*


Try it online!

An anonymous lazy list. You can assign it to a variable like:

my @list = (),{|$_,$_}...* ;

and access it with @list[n].

x86-64 machine code, 22 bytes

31 C0 99 B0 7B AA FF C2 0F BC CA 39 F1 B0 7D F3 AA 75 F0 66 AB C3


Try it online!

Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI an address at which to place the result, as a null-terminated byte string, and takes the number n in RSI.

In assembly:

f:  xor eax, eax    #
cdq             # Set EAX and EDX to 0.
r:  mov al, 0x7B    # Put the ASCII code of '{' into AL.
inc edx         # Add 1 to EDX.
bsf ecx, edx    # Set ECX to the lowest position of a 1 bit in EDX.
cmp ecx, esi    # Compare that number with n.
mov al, 0x7D    # Put the ASCII code of '}' in AL.
rep stosb       # Add that to the string ECX times, advancing the pointer.
jne r           # Repeat if the number is not equal to n.
stosw           # Add two bytes from AX to the string: one more '}' and a null byte.
ret             # Return.


Brachylog, 14 bytes

yk:{,[]:?:gi}a


Try it online!

Explanation

yk                The range [0, ..., Input - 1]
:{        }a    Apply on each element of the range
,[]:?:gi      Group the empty list [] in a list Input times


GAP, 22 bytes

f:=n->Set([0..n-1],f);


For example:

gap> f(3);
[ [  ], [ [  ] ], [ [  ], [ [  ] ] ] ]


Racket 119 bytes

(λ(n)(define ll(list'()))(for((i(range 1 n)))(set! ll(cons ll(for/list((j(length ll)))(list-ref ll j)))))(reverse ll))


Ungolfed:

(define f
(λ (n)
(define ll (list '()))
(for ((i (range 1 n)))
(set! ll
(cons ll
(for/list ((j (length ll)))
(list-ref ll j)
))))
(reverse ll)))


Testing (In Racket {} is same as () and default output is ()):

(f 4)

'(() (()) ((()) ()) (((()) ()) (()) ()))


To clearly see each number (0 to 3):

(for((i (f 4)))  (println (reverse i)))

'()
'(())
'(() (()))
'(() (()) ((()) ()))


Uiua, 33 characters

m←|1⟨""|$"_{_}".m-1⟩↧1. f←$"{_}"m


Try it here!

JavaScript (Node.js), 26 bytes

f=n=>n?[...f(--n),f(n)]:[]


Try it online!

Why not

BrainPipe, 185 161 bytes

-[>,----------]>>-<<<+[->++++++[->------<]>--<<[->>+<<]<+]>>>>+[-<[->++++++++++<]>>+]<.|.->,+[-[-[->+>+<<]>>[-<<+>>].<]+.-<+]-|+[++++[->++++++++<],[->+<]>.[-]<+]


Try it online!

Brainpipe is my Brainfuck derivative I just made where you get to glue multiple bf interpreters together at their inputs and outputs. This Program uses three such subunits:

• One to convert a number given into a byte
• One to implement the following algorithm:

Output 0 and place a marker to make a stack. Take Input onto the stack. Until the stack is empty, if the top value on the stack is not 0, output 0, decrement the value and duplicate it. If the value is 0, pop it and output 1.

• One to add 40 to each of the bits the previous has provided, which turns them into ( and ).

The funny part is that the actual logic is rather short, and that most bytes are dedicated to dealing with ASCII.

ASCII DEC to byte -[>,----------]>>-<<<+[->++++++[->------<]>--<<[->>+<<]<+]>>>>+[-<[->++++++++++<]>>+]<.
The Algorithm    |.->,+[-[-[->+>+<<]>>[-<<+>>].<]+.-<+]
`