ตัวเลขธรรมชาติรวมถึง 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 ไบต์

Ḷ߀

นี่คือลิงค์ monadic ลองออนไลน์!

มันทำงานอย่างไร

แต่ละจำนวนธรรมชาติคือชุดของจำนวนธรรมชาติก่อนหน้านี้ทั้งหมดคือ, 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 ไบต์

ฉันใหม่กับการเล่นกอล์ฟทับทิม แต่นี่ไม่มีอะไรเลย ขอบคุณจอร์แดนที่ช่วยประหยัด 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

ในการวนซ้ำแต่ละครั้งบล็อกจะสร้างการแสดงตัวเลขจากจำนวนที่อยู่ก่อนหน้า เพื่อแสดงให้พิจารณาซ้ำสองที่เป็นตัวแทนของหมายเลขที่2ถูกสร้างขึ้นจากที่ซึ่งเป็นสตริง1"[[]]"

1. สแตกประกอบด้วย "[[]]"
2. หลังจากคำสั่ง_(ซ้ำ) มันมี"[[]]","[[]]"
3. หลังจากคำสั่ง)(uncons) มันมี"[[]]", "[[]","]"
4. หลังจากคำสั่ง@(หมุน) มันมี"[[]", "]","[[]]"
5. หลังจากคำสั่ง\(สลับ) มันมี"[[]", "[[]]","]"
6. หลังจากคำสั่ง](แพ็คเป็น array) มันมีซึ่งจะแสดงเป็นสตริง["[[]" "[[]]" "]"]"[[][[]]]"

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

ลองออนไลน์!

บันทึก 1 ไบต์ขอบคุณ Adnan

Pyth, 4 ไบต์

LyMb

ชุดทดสอบ

L: กำหนดฟังก์ชั่นyด้วยอินพุตb

yMb: yแมปในช่วง0, 1, ..., b-1

กับการป้อนข้อมูล 0, []แผนที่นี้ผลตอบแทน มิฉะนั้นก็จะส่งกลับแมปมากกว่าตัวเลขทั้งหมดขึ้นอยู่กับyb

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 24ไบต์

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

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

คำอธิบาย

.+
$*1<>

สิ่งนี้จะแปลงอินพุตเป็นเอกภาพและต่อท้าย<>เป็นการแทน0ค่า

+`1<
<<$'

นี่เป็นการ+บ่งชี้ว่าการทดแทนนี้ควรรันในลูปจนกว่าสตริงจะหยุดการเปลี่ยนแปลง มันง่ายกว่าที่จะอธิบายสิ่งนี้โดยทำตามขั้นตอนแต่ละอย่างที่ฉันลงมือทำ มาพร้อมกับการทดแทนในรุ่นนี้:

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

สิ่งนี้ตรงกับการ1แทนค่า unary สุดท้ายของอินพุตที่เหลือ (เพื่อลบและลดอินพุต) เช่นเดียวกับเนื้อหาของชุดปัจจุบันที่สิ้นสุด จากนั้นจะถูกแทนที่ด้วยชุดใหม่ที่มีชุดก่อนหน้ารวมถึงเนื้อหา อย่างไรก็ตามเราสามารถสังเกตเห็นว่า$1มีการตามด้วย>ทั้งสองกรณีและด้วยเหตุนี้เราจึงสามารถรวมไว้ในการจับภาพตัวเองและตัดออกจากรูปแบบการทดแทน ที่นำไปสู่รูปแบบ

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

แต่ตอนนี้เราสามารถสังเกตว่า(.*)เพียงแค่จับต่อท้ายของสตริงหลังและเรายังใส่ต่อท้ายนี้ในตอนท้ายด้วย1< $1เนื่องจากไวยากรณ์การแทนที่ทำให้เราสามารถอ้างถึงส่วนของสตริงหลังจากการจับคู่กับ$'เราก็สามารถละเว้นทั้งสองส่วนเหล่านั้นและจบลงด้วยรุ่นที่ใช้ในคำตอบ:

1<
<<$'

อันเดอร์ 14 ไบต์

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

ลองออนไลน์!

โปรแกรม Underload เต็มไม่สามารถรับข้อมูลผ่านวิธีการใด ๆ ที่เรากำหนดไว้ดังนั้นนี่คือฟังก์ชั่นที่รับอินพุตจากสแต็กเป็นตัวเลขของคริสตจักร .

(…)เครื่องหมายการจัดกลุ่มจะต้องทำเรื่องนี้ให้ฟังก์ชั่น (นำมาใช้ใหม่) มากกว่าตัวอย่าง (เฉพาะที่ใช้งานได้ครั้งเดียว) wrapper ในลิงค์ TIO จะเรียกใช้ฟังก์ชันที่มีข้อสงสัยอย่างทำลายล้าง^แต่สามารถนำกลับมาใช้ซ้ำได้ด้วยการทำสำเนาและใช้สำเนาหนึ่งชุดเมื่อเรียกใช้ นอกจากนี้ยังมีการป้อนข้อมูลในการเขียนโปรแกรม (นี่(:*:*)คือ 4) Sและพิมพ์การส่งออกโดยใช้

คำอธิบาย

อันเดอร์โหลดเหมาะอย่างยิ่งสำหรับงานนี้เมื่อทัวริงทาร์พิทไปมีสิ่งที่มีประโยชน์เช่น "สำเนา" และ "ล้อมรอบด้วยวงเล็บ" (อย่างใดอันเดอร์ Underload เป็นภาษา verbose มากคือตี Mathematica โดยปกติภาษาที่ชนะเนื่องจากมีชุดใหญ่ของ builtins ผ่านการมี builtins ที่เหมาะสมมากขึ้น!) นี่คือวิธีการทำงานของโปรแกรม:

((: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 one ต้องกำหนดหนึ่งฟังก์ชันฉันเรียกมันว่า 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))

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

การทดสอบ (ใน Racket {} เหมือนกับ () และเอาต์พุตเริ่มต้นคือ ()):

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

{ใช้ความจริงที่ว่าคำตอบของแต่ละคนจะมีค่าเท่ากับคำตอบก่อนหน้านี้ใส่เข้าไปในตัวเองหลังจากชั้นนำ เอาต์พุตสองสามตัวแรกมีดังนี้:

{}

{{}}

{{{}}{}}

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

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

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