Các số tự nhiên bao gồm 0 được định nghĩa chính thức dưới dạng tập hợp, theo cách sau :

• Số 0 được định nghĩa là tập hợp trống, {}
• Với n ≥ 0, số n +1 được định nghĩa là n ∪ { n }.

Kết quả là, n = {0, 1, ..., n -1}.

Các số đầu tiên, được xác định bởi thủ tục này, là:

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

Thử thách

Cho n, xuất đại diện của nó như là một bộ.

Quy tắc

Đầu ra luôn có thể sử dụng bất kỳ ký tự dấu ngoặc nào {}, như [], ()hoặc <>. Các ký tự tùy ý (như 01) không được phép.

Thay vì dấu phẩy như trên, dấu phân cách có thể là bất kỳ dấu chấm câu nào; hoặc nó có thể không tồn tại.

Không gian (không phải dòng mới) có thể được bao gồm tùy ý và không nhất quán.

Ví dụ: số 2 với dấu ngoặc vuông và dấu chấm phẩy làm dấu phân cách là [[]; [[]]]hoặc tương đương [ [ ]; [ [ ] ] ]hoặc thậm chí[ [ ] ;[ []]]

Thứ tự mà các phần tử của một tập hợp được chỉ định không quan trọng. Vì vậy, bạn có thể sử dụng bất kỳ thứ tự trong đại diện. Ví dụ: đây là một số đầu ra hợp lệ cho 3:

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

Bạn có thể viết một chương trình hoặc chức năng . Đầu ra có thể là một chuỗi hoặc, nếu sử dụng hàm, bạn có thể trả về một danh sách hoặc mảng lồng nhau có biểu diễn chuỗi phù hợp với ở trên.

Các trường hợp thử nghiệm

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

Thạch , 3 byte

Ḷ߀

Đây là một liên kết đơn nguyên. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Mỗi số tự nhiên là tập hợp của tất cả các số tự nhiên trước đó, nghĩa là n = {0, Cách, n-1} . Vì không có số tự nhiên nào trước 0 , nên ta có 0 = {} .

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

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

Python 2, 26 byte

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

Kiểm tra nó trên Ideone .

JavaScript (ES6), 32 byte

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

Đủ đơn giản.

Perl 6 , 16 byte

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

Trả về cấu trúc dữ liệu lồng nhau.

Thí dụ:

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

Giải trình:

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

Tôi mới chơi golf ruby, nhưng ở đây không có gì. Cảm ơn Jordan vì đã tiết kiệm 6 byte!

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

Đây là một hàm đệ quy f(một Proc, cụ thể) và đưa ra một đối số s. Nó ánh xạ các Proc ftrên 0...s, đó là phạm vi [0, s).

Haskell, 32 27 byte

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

Hãy thử nó trên Ideone.

CJam , 14 byte

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

Hãy thử trực tuyến!

Giải trình

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

Trong mỗi lần lặp, khối xây dựng biểu diễn của một số từ số trước đó. Để minh họa, chúng ta hãy xem xét lần lặp thứ hai, trong đó biểu diễn số 2được xây dựng từ đó 1, đó là chuỗi "[[]]".

1. Ngăn xếp chứa "[[]]"
2. Sau câu lệnh _(trùng lặp) nó chứa "[[]]","[[]]"
3. Sau khi tuyên bố )(uncons) nó chứa "[[]]", "[[]","]"
4. Sau khi tuyên bố @(rotate) nó chứa "[[]", "]","[[]]"
5. Sau khi tuyên bố \(swap) nó chứa "[[]", "[[]]","]"
6. Sau câu lệnh ](gói thành mảng) ["[[]" "[[]]" "]"], nó sẽ được hiển thị dưới dạng chuỗi "[[][[]]]".

Cheddar, 17 byte

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

Đệ quy ngắn + Phạm vi ngắn + Lặp lại ngắn = Thử thách trong đó cheddar làm rất tốt

Không cạnh tranh, 11 byte

n f->|>n=>f

Các => điều hành đã được thêm vào sau khi thử thách này được đưa ra khiến câu trả lời này không cạnh tranh.

Điều này có thể trông khó hiểu nhưng hãy để tôi đơn giản hóa nó:

n f -> |> n => f

về cơ bản nlà đầu vào và flà chính chức năng. |>ntạo [0, n) và =>ánh xạ qua f.

05AB1E , 8 7 byte

)IF)©`®

Giải trình

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

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ Adnan.

Bình thường, 4 byte

LyMb

Bộ kiểm tra

L: Xác định hàm y với đầu vàob

yMb: y ánh xạ trên phạm vi0, 1, ..., b-1

Trên đầu vào 0, bản đồ này trả về []. Mặt khác, nó trả về yánh xạ trên tất cả các số lên đến b.

MATL , 13 byte

Xhi:"tY:Xh]&D

Hãy thử trực tuyến!

Giải trình

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 byte

Bao gồm +1 cho -p

Nhiều phương thức khác nhau dường như kết thúc ở mức 27 hoặc 28 byte. ví dụ

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

Điều tốt nhất tôi có thể tìm thấy là

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

vì trên các perls cũ hơn, bạn có thể thả khoảng trắng trước forvà nhận 26 byte

Toán học, 14 byte

Array[#0,#,0]&

Toán học, 31 byte

Nói thẳng ra là định nghĩa như một danh sách lồng nhau. Sử dụng một hàm không tên mà gọi đệ quy chính nó bằng cách sử dụng #0.

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

Võng mạc , 24 18 byte

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

Hãy thử trực tuyến!(Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

.+
$*1<>

Điều này chuyển đổi đầu vào thành unary và nối thêm <>, đại diện của 0.

+`1<
<<$'

Ở đây, +chỉ ra rằng sự thay thế này sẽ được chạy trong một vòng lặp cho đến khi chuỗi ngừng thay đổi. Thật dễ dàng để giải thích điều này bằng cách trải qua các bước riêng lẻ mà tôi đã chơi golf. Hãy cùng với phiên bản thay thế này:

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

Điều này khớp với phần cuối cùng 1của đại diện đơn nguyên của đầu vào còn lại (để loại bỏ nó và giảm đầu vào), cũng như nội dung của bộ hiện tại ở cuối. Điều này sau đó được thay thế bằng một bộ mới chứa bộ trước đó cũng như nội dung của nó. Tuy nhiên, chúng ta có thể nhận thấy rằng $1được theo sau >trong cả hai trường hợp và do đó chúng ta có thể đưa nó vào trong bản chụp và bỏ qua nó khỏi mẫu thay thế. Điều đó dẫn đến hình thức

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

Tuy nhiên, bây giờ chúng ta có thể quan sát rằng (.*)chỉ cần bắt được hậu tố của chuỗi sau 1<và chúng ta thậm chí còn đặt lại hậu tố này vào cuối $1. Vì cú pháp thay thế cho chúng ta một cách để tham chiếu đến một phần của chuỗi sau khi khớp với $'chúng ta, chúng ta có thể bỏ qua cả hai phần đó và kết thúc với phiên bản được sử dụng trong câu trả lời:

1<
<<$'

Dưới tải , 14 byte

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

Hãy thử trực tuyến!

Tải xuống đầy đủ các chương trình không thể lấy đầu vào thông qua bất kỳ phương thức nào được xác định của chúng tôi, vì vậy đây là hàm lấy đầu vào từ ngăn xếp dưới dạng số Church (cách thông thường để xác định số nguyên trong Underload) và tạo đầu ra cho ngăn xếp dưới dạng chuỗi .

Các (…)điểm đánh dấu nhóm được yêu cầu để làm cho chức năng này (có thể sử dụng lại) thay vì một đoạn trích (chỉ có thể sử dụng một lần). Trình bao bọc trong liên kết TIO gọi hàm trong câu hỏi sử dụng triệt để ^, nhưng nó có thể được sử dụng lại thông qua việc tạo một bản sao của nó và chỉ tiêu thụ một trong các bản sao khi gọi nó. Nó cũng cung cấp đầu vào cho chương trình (ở đây (:*:*), tức là 4) và in đầu ra bằng cách sử dụngS .

Giải trình

Underload phù hợp một cách đáng ngạc nhiên cho nhiệm vụ này khi Turing tarpits đi, có các nguyên thủy hữu ích như "sao chép" và "bao quanh với dấu ngoặc đơn". .

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

Hàm lũy thừa có hiệu quả làm cho các bước của hàm lặp lại nhiều lần, vì vậy, ví dụ, (:a*)sẽ là (:a*:a*:a*). Đó là cách thành ngữ để viết một vòng lặp lặp lại một số lần nhất định trong Tải trọng. (Bạn có thể lưu ý rằng cách ~^được mô tả theo hai cách khác nhau ở trên; đó là vì số nguyên trong Underload được định nghĩa là hàm lũy thừa hàm chuyên cho số nguyên đó, vì vậy để thực hiện phép lũy thừa hàm, bạn chỉ cần thử thực hiện một số nguyên như thể đó là hàm .)

Pari / GP , 23 byte

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

Hãy thử trực tuyến!

APL (NARS), 15 ký tự, 30 byte

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

kiểm tra:

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

Tôi không biết điều này có được chấp nhận hay không ... Zilde ở đây nó đại diện cho tập hợp void {} nếu tôi muốn in phần tử Zilde hoặc một phần tử đầy Zilde và Zilde kèm theo tất cả những gì xảy ra là không in gì ... Vì vậy, để xem Zilde người ta phải xác định một hàm tôi gọi nó là o ( o←⎕fmt) Tôi không chèn số đếm vì phần tử và cấu trúc của nó tồn tại ngay cả khi các sys không in nó ... Có thể nếu io bằng 0

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

có thể là giải pháp 12 ký tự quá ...

Brachylog , 14 byte

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

Hãy thử trực tuyến!

Giải trình

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 byte

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

Ví dụ:

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

Vợt 119 byte

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

Ung dung:

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

Kiểm tra (Trong vợt {} giống như () và đầu ra mặc định là ()):

(f 4)

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

Để thấy rõ từng số (0 đến 3):

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

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

Mẻ, 74 byte

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

Sử dụng thực tế là mỗi câu trả lời bằng với câu trả lời trước được chèn vào chính nó sau câu dẫn {. Một vài kết quả đầu ra như sau:

{}

{{}}

{{{}}{}}

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

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

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