0을 포함한 자연수는 공식적으로 다음과 같은 방식 으로 집합으로 정의됩니다 .

• 숫자 0은 빈 세트 {}로 정의됩니다.
• 들면 N 0 번호 ≥ N +1로 정의 N ∪ { N }.

결과적으로 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.

파이썬 2, 26 바이트

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

Ideone에서 테스트하십시오 .

자바 스크립트 (ES6), 32 바이트

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

충분히 간단합니다.

펄 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 fover ( 0...s범위)를 매핑합니다 [0, s).

하스켈, 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

각 반복에서 블록은 이전 숫자의 숫자 표현을 작성합니다. 예를 들어, 숫자의 표현 이 string 인 표현에서 2빌드되는 두 번째 반복을 고려해 봅시다 .1"[[]]"

1. 스택에 "[[]]"
2. 진술서 _(중복)에는 "[[]]","[[]]"
3. 문 다음에 )포함 된 (uncons) "[[]]", "[[]","]"
4. 문 이후 @에 포함 (회전) "[[]", "]","[[]]"
5. 명령문 \(스왑) 뒤에 "[[]","[[]]" ,"]"
6. after 문 ](배열로 묶음)에는 ["[[]" "[[]]" "]"]문자열로 표시되는이 포함 됩니다 "[[][[]]]".

체다, 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

펄, 27 바이트

에 +1 포함 -p

여러 가지 방법이 모두 27 또는 28 바이트로 끝나는 것 같습니다. 예 :

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

내가 찾을 수있는 최선은

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

이전 perls에서 공간을 삭제하고 for26 바이트를 얻을 수 있습니다.

수학, 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)

온라인으로 사용해보십시오!

언더로드 풀 프로그램은 정의 된 메소드를 통해 입력을받을 수 없으므로 스택에서 입력을 교회 숫자 (언더로드에서 정수를 정의하는 일반적인 방법)로 가져 와서 스택에 출력을 문자열로 생성하는 함수입니다 .

(…)그룹화 마커는 오히려 조각 (만 사용할 수 번)보다이 함수 (재사용)을 만들기 위해 필요합니다. TIO 링크의 래퍼는을 사용하여 문제의 함수를 파괴적으로 호출 ^하지만, 사본을 작성하고 호출 할 때 사본 중 하나만 사용하여 재사용 할 수 있습니다. 또한 프로그램에 입력을 제공하고 (여기서 (:*:*), 즉 4),를 사용하여 출력을 인쇄합니다 S.

설명

언더로드는 놀랍게도 튜링 타르 핏이 가면서 "복사"와 "괄호로 둘러 싸인"과 같은 유용한 기본 요소를 가지면서이 작업에 적합합니다. (어쨌든, Underload, 일반적으로 매우 장황한 언어는 Mathematica를 꺾고 있습니다. 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 is ⍬ 여기서 Zilde 요소 또는 Zilde로 가득 찬 하나의 요소를 인쇄하려는 경우 void set {}을 나타내며 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

간격 , 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%

각 답변이 선행 다음에 삽입 된 이전 답변과 동일하다는 사실을 사용합니다 {. 처음 몇 개의 출력은 다음과 같습니다.

{}

{{}}

{{{}}{}}

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

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

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