包含0的自然数通过以下方式正式定义为集合：

• 数字0定义为空集{}
• 对于Ñ ≥0，数Ñ 1被定义为ñ ∪{ Ñ }。

结果，n = {0，1，...，n -1}。

此过程定义的第一个数字是：

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

挑战

给定n，将其表示形式输出为一组。

规则

输出可以始终如一地使用任何托架字符如{}，[]，()或<>。01不允许使用任意字符（例如）。

代替上面的逗号，分隔符可以是任何标点符号。或可能不存在。

可以任意和不一致地包含空格（不是换行符）。

例如，带有方括号和分号作为分隔符的数字2是[[]; [[]]]，或等价地[ [ ]; [ [ ] ] ]，甚至[ [ ] ;[ []]]

指定集合中的元素的顺序无关紧要。因此，您可以在表示形式中使用任何顺序。例如，以下是一些有效的输出3：

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

您可以编写程序或函数。输出可以是字符串，或者，如果使用函数，则可以返回其字符串表示形式符合上述条件的嵌套列表或数组。

测试用例

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

果冻，3 个字节

Ḷ߀

这是一个单子链接。在线尝试！

怎么运行的

每个自然数都是所有先前自然数的集合，即n = {0，…，n-1}。由于没有自然数在0之前，因此我们有0 = {}。

Ḷ߀  Monadic link. Argument: n (natural number)

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

Python 2，26字节

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

在Ideone上进行测试。

JavaScript（ES6），32个字节

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

很简单。

Perl 6、16个字节

{({@_}…*)[$_]}

返回嵌套的数据结构。

例：

say {({@_}…*)[$_]}( 4 );
# [[] [[]] [[] [[]]] [[] [[]] [[] [[]]]]]

说明：

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

}

Ruby，27 21字节

我是红宝石打高尔夫球的新手，但是什么也没做。感谢Jordan节省6个字节！

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

这是一个递归函数f（具体来说是proc），带有一个参数s。它的PROC映射f过0...s，这是范围[0, s)。

Haskell，32 27字节

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

在Ideone上尝试。

CJam，14个字节

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

在线尝试！

说明

"[]"            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

在每次迭代中，该块均根据前一个数字构建数字表示。为了说明这一点，让我们考虑第二次迭代，其中number的表示2是基于of的1（即string ）构建的"[[]]"。

1. 堆栈包含 "[[]]"
2. 语句_（重复）后包含"[[]]"，"[[]]"
3. 后声明)（uncons）它包含"[[]]"，"[[]"，"]"
4. 后声明@（旋转）它包含"[[]"，"]"，"[[]]"
5. 后声明\（SWAP）它包含"[[]"，"[[]]"，"]"
6. 语句之后]（打包成数组）包含["[[]" "[[]]" "]"]，它将显示为字符串"[[][[]]]"。

Cheddar，17个字节

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

短递归+短距离+短迭代=切达干酪表现出色的挑战

非竞争性，11个字节

n f->|>n=>f

在=>这一挑战发布使这个答案非竞争后加入经营者。

这可能看起来令人困惑，但让我简化一下：

n f -> |> n => f

基本上n是输入，f是函数本身。|>n生成[0，n）并将其=>映射到f。

05AB1E，8 7字节

)IF)©`®

说明

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

在线尝试！

感谢Adnan，节省了1个字节。

Pyth，4个字节

LyMb

测试套件

L：y用输入定义功能b

yMb：y映射到范围内0, 1, ..., b-1

在输入0上，此映射返回[]。否则，它将返回y映射到所有数字的映射，直到为止b。

MATL，13字节

Xhi:"tY:Xh]&D

在线尝试！

说明

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

Perl，27个字节

包括+1的 -p

许多不同的方法似乎都以27或28个字节结尾。例如

#!/usr/bin/perl -p
$\=$_="{@F}"for@F[0..$_]}{

我能找到的最好的是

#!/usr/bin/perl -p
s/./{$_/ for($\="{}")x$_}{

因为在较旧的perls上，您可以在之前删除空格for并获得26个字节

Mathematica，14个字节

Array[#0,#,0]&

Mathematica，31个字节

直接将定义实现为嵌套列表。使用未命名的函数，该函数使用递归调用自身#0。

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

视网膜，24 18字节

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

在线尝试！（第一行启用换行分隔的测试套件。）

说明

.+
$*1<>

这会将输入转换为一元并附加<>的表示形式0。

+`1<
<<$'

在此，+指示该替换应循环运行，直到字符串停止更改为止。通过逐个打高尔夫球，可以更轻松地解释这一点。让我们用这个版本的替换：

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

这与1剩余输入的一元表示形式的最后一个（以删除该输入并减少该输入）以及末尾当前设置的内容相匹配。然后，将其替换为包含先前集合及其内容的新集合。但是，我们注意到在两种情况下$1都紧随其后>，因此我们可以将其包括在捕获本身中，并从替换模式中将其省略。导致形式

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

但是，现在我们可以观察到，它(.*)只是捕获了之后的字符串后缀，1<我们甚至在末尾重新插入了该后缀$1。由于替换语法为我们提供了一种在与之匹配后引用字符串部分的方式，因此$'我们可以简单地忽略这两个部分，最后得到答案中使用的版本：

1<
<<$'

欠载，14字节

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

在线尝试！

欠载完整程序无法通过我们定义的任何方法获取输入，因此该函数将来自堆栈的输入作为教堂数字（在Underload中定义整数的正常方式），并以字符串的形式产生输出至堆栈。

(…)要使此功能（可重复使用）而不是摘要（仅可使用一次），需要使用分组标记。TIO链接中的包装器使用破坏性地调用了有问题的函数^，但是可以通过制作它的副本并在调用它时仅使用其中一个副本来重用它。它还向程序提供输入（此处为(:*:*)4），并使用来打印输出S。

说明

图灵（taring）图平运行时，Underload出人意料地适合此任务，具有诸如“复制”和“带括号的包围”等有用的原语。（以某种方式，Underload通常是一种非常冗长的语言，它击败了Mathematica，这通常是一种语言，因为它具有大量内置函数，因此会通过使用更合适的内置函数而获胜！）以下是程序的工作方式：

((: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

函数幂运算有效地导致函数的步骤重复多次，因此，例如(:a*)将会是(:a*:a*:a*)。这是编写循环的惯用方式，该循环在Underload中重复指定的次数。（您可以注意到，~^上面用两种不同的方式描述了；这是因为Underload中的整数定义为专用于该整数的函数幂运算，因此，要进行函数幂运算，您只需尝试像执行函数一样执行整数即可）

Pari / GP，23字节

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

在线尝试！

APL（NARS），15个字符，30个字节

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

测试：

  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
└∊────────────────────────────────────────────────────┘

我不知道这是否会被接受... Zilde是⍬，如果我想打印Zilde元素或一个充满Zilde的元素，它表示空集{}，而Zilde封闭的所有内容都是什么都不打印...因此请参见Zilde，一个人必须定义一个函数，我称它为o（o←⎕fmt）我不插入计数，因为即使sys不打印它，元素和其结构也存在...如果io为0，则可能

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

可能也是12个字符的解决方案...

Brachylog，14个字节

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

在线尝试！

说明

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字节

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

例如：

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

球拍119字节

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

取消高尔夫：

(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)))

测试（在球拍{}中与（）相同，默认输出为（））：

(f 4)

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

要清楚地看到每个数字（0到3）：

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

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

批处理，74字节

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

使用以下事实：每个答案等于前导之后插入到自身中的前一个答案{。前几个输出如下：

{}

{{}}

{{{}}{}}

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

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

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