0を含む自然数は、次のように正式にセットとして定義されます。

• 番号0は空のセット{}として定義されます
• 以下のために、N 0、数≥ nは +1として定義されるN ∪{ N }。

結果として、n = {0、1、...、n -1}。

この手順で定義される最初の番号は次のとおりです。

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

チャレンジ

与えられたn、その表現をセットとして出力します。

ルール

出力は一貫して任意の使用できるブラケットなどの文字を{}、[]、()または<>。任意の文字（など01）は使用できません。

上記のようにコンマの代わりに、区切り記号には任意の句読記号を使用できます。または存在しない可能性があります。

スペース（改行ではなく）は、arbitrarily意的かつ一貫性なく含めることができます。

たとえば、角括弧とセミコロンを区切り文字とする数字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

}

ルビー、27 21バイト

ルビーゴルフは初めてですが、ここでは何もしません。6バイトを節約してくれたJordanに感謝します！

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

各反復で、ブロックは前の数値の表現から数値の表現を構築します。説明のために、2番目の反復を考えてみましょう。ここで、numberの表現は、string であるの表現2から構築され1ます"[[]]"。

1. スタックには "[[]]"
2. ステートメントの後_（複製）には"[[]]"、"[[]]"
3. 文の後に)それが含まれている（uncons） 、、"[[]]""[[]""]"
4. 文の後に@それが含まれている（回転）"[[]"、"]"、"[[]]"
5. 文の後に\それが含まれています（スワップ）"[[]"、"[[]]"、"]"
6. ステートメント]（配列にパック）の後に["[[]" "[[]]" "]"]、文字列として表示されるが含まれます"[[][[]]]"。

チェダー、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$_}{

古いperlでは、前にスペースを削除してfor26バイトを取得できるため

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)

オンラインでお試しください！

アンダーロードフルプログラムは、定義されたメソッドのいずれかを介して入力を取得できないため、これはスタックからの入力をチャーチ数字として取得し（アンダーロードで整数を定義する通常の方法）、スタックへの出力を文字列として生成する関数です。

(…)これをスニペット（1回のみ使用可能）ではなく関数（再利用可能）にするには、グループ化マーカーが必要です。TIOリンクのラッパーは、を使用して問題の関数を破壊的に呼び出しますが、^そのコピーを作成し、呼び出し時にコピーの1つだけを使用することで再利用できます。また、プログラムへの入力（ここでは(:*:*)、つまり4）を提供し、を使用して出力を出力しSます。

説明

アンダーロードは、「コピー」や「括弧で囲む」などの有用なプリミティブを持ち、チューリングのターピットが進むにつれて、このタスクに驚くほど適しています。（どういうわけか、通常非常に冗長な言語である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で指定された回数だけ繰り返されるループを記述する慣用的な方法です。（~^上記の2つの異なる方法で説明されていることに注意してください.Underloadの整数は、その整数に特化した関数べき乗として定義されているため、関数のべき乗を行うには、単に整数を関数であるかのように実行しようとします）

パリ/ 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はここでvoidセット{}を表します。Zilde要素またはZildeで満たされた1つの要素を印刷したい場合、Zildeは何も印刷しません。 Zildeを参照するには、1つの関数を定義する必要があります。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%

各回答が、先頭の後に自分自身に挿入された前の回答と等しいという事実を使用し{ます。最初のいくつかの出力は次のとおりです。

{}

{{}}

{{{}}{}}

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

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

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