การก่อสร้างนี้เป็นวิธีการแสดงตัวเลขธรรมชาติ

ในการแทนค่านี้ 0 หมายถึงชุดว่างและสำหรับตัวเลขอื่น ๆ ทั้งหมด n คือค่ารวมของ {0} และ {n-1}

เช่นสร้าง 3 เราสามารถทำตามอัลกอริทึม:

3 =
{ø, 2} =
{ø, {ø, 1}} =
{ø, {ø, {ø}}}

งาน

ในขณะที่คุณอาจเดาได้ว่างานของคุณคือการใช้จำนวนธรรมชาติ (รวมถึงศูนย์) และเอาท์พุทก่อสร้าง

คุณอาจส่งออกเป็นสตริงหรือเป็นวัตถุชุดหากภาษาที่คุณเลือกรองรับวัตถุดังกล่าว

หากคุณเลือกที่จะแสดงผลเป็นสตริงคุณควรแสดงชุดด้วยเครื่องหมายปีกกา ( {}) คุณอาจเลือกที่จะแสดงชุดเปล่าเป็นø(มิฉะนั้นมันควรจะเป็นชุดที่ไม่มีรายการ{}) คุณอาจเลือกที่จะเพิ่มจุลภาคและช่องว่างระหว่างและหลังรายการในชุด

คำสั่งไม่สำคัญ แต่คุณอาจไม่มีองค์ประกอบซ้ำในชุดที่คุณส่งออก (เช่น{ø,ø})

นี่คือโค้ดกอล์ฟดังนั้นเป้าหมายคือมีไบต์น้อยที่สุด

กรณีทดสอบ

ต่อไปนี้เป็นกรณีทดสอบบางตัวอย่างที่มีเอาต์พุตตัวอย่าง

0 -> {}
1 -> {{}}
2 -> {{}{{}}}
3 -> {{}{{}{{}}}}
4 -> {{}{{}{{}{{}}}}}

Pythonขนาด 28 ไบต์

lambda x:"{{}"*x+x*"}"or"{}"

ลองออนไลน์!

นี่เป็นวิธีแก้ปัญหาที่ค่อนข้างอ่อนหวาน "{{}"*x+"}"*xสำหรับตัวเลขที่มากกว่าศูนย์คุณจะได้รับการแสดงที่มีสูตรสตริง อย่างไรก็ตามวิธีนี้ใช้ไม่ได้กับศูนย์ซึ่งเป็นสตริงว่าง เราสามารถใช้ข้อเท็จจริงนี้เพื่อลัดวงจรและorส่งคืนเซตว่าง

ฉันต้องการใช้ pinton ชุดวัตถุเพื่อแก้ปัญหานี้ แต่น่าเสียดายที่:

TypeError: unhashable type: 'set'

คุณไม่สามารถใส่ชุดในชุดในหลาม

Haskell , 37 ไบต์

f 0="{}"
f n=([1..n]>>)=<<["{{}","}"]

ลองออนไลน์!

จนกระทั่งเมื่อ 10 นาทีก่อนคำตอบเช่นนี้คงไม่สมเหตุสมผลสำหรับฉัน เครดิตทั้งหมดไปที่คำตอบเคล็ดลับนี้

โดยพื้นฐานแล้วเราใช้>>เป็นconcat $ replicate(แต่ผ่านรายการขององค์ประกอบ n แทนเพียง n) และ=<<เป็นconcatMapซ้ำจากนั้น n คูณแต่ละสตริงในรายการและต่อผลลัพธ์เป็นสตริงเดียว

0กรณีที่ได้รับการปฏิบัติแยกเป็นมันจะกลับมาเป็นสตริงว่าง

JavaScript ขนาด 28 ไบต์

f=n=>n?--n?[[],f(n)]:[[]]:[]

หมายถึงการตั้งค่าโดยใช้อาร์เรย์ วิธีแก้ปัญหาแบบไม่ทำงาน 38 ไบต์:

n=>'{{}'.repeat(n)+'}'.repeat(n)||'{}'

ส่งคืนสตริงเอาต์พุตตัวอย่าง

Mathematica ขนาด 27 ไบต์

ฉันมีสองวิธีในการนับไบต์นี้:

Nest[{{}}~Union~{#}&,{},#]&
Union//@Nest[{{},#}&,{},#]&

Perl 6 , 37 ไบต์

{('{}','{{}}',{q:s'{{}$_}'}...*)[$_]}

ลองมัน

ขยาย:

{   # bare block lambda with implicit parameter ｢$_｣

  (
    # generate a sequence

    '{}',   # seed it with the first two values
    '{{}}',

    {   # bare block lambda with implicit parameter ｢$_｣

      q         # quote
      :scalar   # allow scalar values

      '{{}$_}'  # embed the previous value ｢$_｣ in a new string

    }

    ...         # keep using that code block to generate values

    *           # never stop

  )[ $_ ] # get the value at the given position in the sequence
}

05AB1E , 6 5 ไบต์

รหัส

ƒ)¯sÙ

ใช้การเข้ารหัสCP-1252 ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด! .

คำอธิบาย

ƒ       # For N in range(0, input + 1)..
 )      #   Wrap the entire stack into an array
  ¯     #   Push []
   s    #   Swap the two top elements
    Ù   #   Uniquify the array

เรติน่า 22 ไบต์

.+
$*
\`.
{{}
{

^$
{}

ลองออนไลน์!

คำอธิบาย

.+
$*

แปลงอินพุตเป็น unary

\`.
{{}

แทนที่ตัวเลขหลักแต่ละตัวด้วย{{}และพิมพ์ผลลัพธ์โดยไม่ต้องป้อนบรรทัดต่อท้าย ( \)

{

ลบช่องเปิด{เพื่อให้ส่วนที่เหลือ}เป็นเหมือนกับที่เรายังต้องพิมพ์เพื่อปิดชุดทั้งหมด อย่างไรก็ตามขั้นตอนข้างต้นล้มเหลวในการป้อนข้อมูล0โดยที่เราจะไม่พิมพ์อะไรเลย ดังนั้น...

^$
{}

หากสตริงว่างให้แทนที่ด้วยชุดว่าง

Brain-Flak , 135 ไบต์

รวม +1 สำหรับ -A

(({}())<{({}[()]<((((((()()()()()){}){}){}())()){}{})>)}{}({}[()()])>)(({})<{({}[()]<(((({}()())[()()])))>)}{}>[()]){(<{}{}{}>)}{}{}{}

ลองออนไลน์!

(({}())<                 # Replace Input with input + 1 and save for later
  {({}[()]<              # For input .. 0
    (...)                # Push '}'
  >)}{}                  # End for and pop counter
  ({}[()()])             # change the top '}' to '{'. This helps the next stage
                         # and removes the extra '}' that we got from incrementing input
>)                       # Put the input back on

(({})<                   # Save input
  {({}[()]<              # For input .. 0
    (((({}()())[()()]))) # Replace the top '{' with "{{{}"
  >)}{}                  # end for and pop the counter
>[()])                   # Put down input - 1
{(<{}{}{}>)}             # If not 0, remove the extra "{{}"
{}{}{}                   # remove some more extras

Röda , 37 ไบต์

f n{[[[],f(n-1)]]if[n>1]else[[[]]*n]}

CJam , 11 ไบต์

Lri{]La|}*p

พิมพ์วัตถุ set-like ซึ่งประกอบด้วยรายการของรายการ CJam พิมพ์รายการว่างเปล่าเป็นสตริงว่างเนื่องจากรายการและสตริงเกือบจะใช้แทนกันได้

ลองออนไลน์!

คำอธิบาย

L            Push an empty array 
 ri          Read an integer from input
   {    }*   Run this block that many times:
    ]          Wrap the entire stack in an array
     La        Wrap an empty list in an array, i.e. [[]]
       |       Set union of the two arrays
          p  Print the result

คำตอบเก่า21 18 ไบต์

นี่คือก่อนที่จะได้รับการยืนยันว่ามันเป็นตกลงที่จะพิมพ์โครงสร้างรายการที่ซ้อนกัน ใช้อัลกอริทึมการทำซ้ำสตริง

บันทึก 3 ไบต์ด้วย Martin Ender!

ri{{}}`3/f*~_{{}}|

คำอธิบาย

ri                  Read an integer from input
  {{}}`             Push the string "{{}}"
       3/           Split it into length-3 subtrings, gives ["{{}" "}"]
         f*         Repeat each element of that array a number of times equal to the input
           ~_       Dump the array on the stack, duplicate the second element
             {{}}|  Pop the top element, if it's false, push an empty block, which gets 
                      printed as "{}". An input of 0 gives two empty strings on the 
                      repetition step. Since empty strings are falsy, we can correct the 
                      special case of 0 with this step.

เยลลี่ 6 ไบต์

⁸,⁸Q$¡

นี่คือลิงก์ niladic ที่อ่านจำนวนเต็มจาก STDIN และส่งคืนอาร์เรย์ ragged

ลองออนไลน์!

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

⁸,⁸Q$¡  Niladic link.

⁸       Set the return value to [].
    $   Combine the three links to the left into a monadic chain.
 ,⁸     Pair the previous return value with the empty array.
   Q    Unique; deduplicate the result.
     ¡  Read an integer n from STDIN and call the chain to the left n times.

Python 3 , 32 ไบต์

f=lambda n:[[],n and f(n-1)][:n]

ไม่ใช่วิธีที่สั้นที่สุด แต่ฉันต้องทำทำด้วยการเรียกซ้ำ

ลองออนไลน์!

พระคาร์ดินัล , 51 50 ไบต์

%:#>"{"#? v
x  ^?-"}{"<
v <8/ ?<
>  8\
v"}"<
>?-?^

ลองออนไลน์!

คำอธิบาย

%:#
x

รับข้อมูลแล้วส่งลงและปล่อยจาก #

   >"{" ? v
   ^?-"}{"<

พิมพ์ "{" หนึ่งครั้งจากนั้นพิมพ์ "{} {" n-1 ครั้งหาก n> 1 แล้วพิมพ์ "{}" ถ้า n> 0

       #

v <8/ ?<
>  8\

กดค้างไว้ที่ค่าอินพุตจนกว่าลูปแรกจะเสร็จสมบูรณ์

v"}"<
>?-?^

พิมพ์ "}" หนึ่งครั้งจากนั้นทำซ้ำ n-1 ครั้งหาก n> 1

AHK, 55 ไบต์

IfEqual,1,0
s={{}{}}
Loop,%1%
s={{ 2}{}}%s%{}}
Send,%s%

มันไม่ได้เป็นคำตอบที่สั้นที่สุด แต่ผมมีความสุขนี้เพราะนิสัยของ AutoHotkey ทำให้วิธีการเรียกซ้ำนี้มองซุปเปอร์ผิด IfและLoopข้อความสั่งจะถือว่าบรรทัดถัดไปเป็นสิ่งเดียวที่รวมไว้หากไม่ใช้เครื่องหมายวงเล็บ วงเล็บปีกกาเป็นตัวหนีดังนั้นคุณต้องหลบหนีด้วยวงเล็บปีกกาอื่น ๆ เพื่อใช้เป็นข้อความ นอกจากนี้ตัวแปร1คืออาร์กิวเมนต์ที่ส่งผ่านครั้งแรก เมื่อฉันอ่านโค้ดโดยที่ไม่ทราบเกร็ดความรู้เหล่านั้นตรรกะจะเป็นดังนี้:

• ถ้า 1 = 0 ให้ตั้งค่าsเท่ากับคำตอบที่ผิด
• วนรอบและเพิ่มกลุ่มของวงเล็บไปที่จุดเริ่มต้นและไม่กี่ไปยังจุดสิ้นสุดทุกครั้ง
• ส่งคืนโดยส่งสตริงผลลัพธ์ไปยังหน้าต่างปัจจุบัน

หากไม่มีอักขระวงเล็บเหลี่ยมทั้งหมดจะมีลักษณะดังนี้:

IfEqual,1,0
   s={}
Loop,%1%
   s={{}%s%}
Send,%s%

JavaScript 50 ไบต์

g=n=>n==0?"":"{{}"+g(n-1)+"}"
z=m=>m==0?"{}":g(m)

tinylisp , 52 ไบต์

(d f(q((n)(i n(i(e n 1)(c()())(c()(c(f(s n 1))())))(

ลองออนไลน์! สายรัดทดสอบ.

คำอธิบาย

โปรดทราบว่า(cons x (cons y nil))เป็นวิธีที่คุณสร้างรายการที่มีxและyในเสียงกระเพื่อม

(d f           Define f to be
 (q(           a quoted list of two items (which acts as a function):
  (n)           Arglist is a single argument n
  (i n          Function body: if n is truthy (i.e. nonzero)
   (i(e n 1)     then if n equals 1
    (c()())       then cons nil to nil, resulting in (())
    (c            else (if n > 1) cons
     ()            nil to
     (c            cons
      (f(s n 1))    (recursive call with n-1) to
      ())))         nil
   ()))))        else (if n is 0) nil

C (gcc) , 52 ไบต์

n(i){putchar(123);i>1&&n(0);i&&n(i-1);putchar(125);}

ใช้ประโยชน์จากการประเมินการลัดวงจรและการเรียกซ้ำ

ลองออนไลน์!

Pure Bash , 49 48 41 ไบต์

for((;k++<$1;)){ s={{}$s};};echo ${s-{\}}

ลองออนไลน์!

dc , 46 ไบต์

[[{}]]sx256?^dd3^8d^1-/8092541**r255/BF*+d0=xP

ลองออนไลน์!

อินพุตบน stdin, เอาต์พุตบน stdout

สิ่งนี้ทำงานได้โดยการคำนวณสูตรสำหรับผลลัพธ์ที่ต้องการเป็นตัวเลขฐาน 256 คำสั่ง P ใน dc จะถูกใช้เพื่อพิมพ์หมายเลขฐาน 256 เป็นสตริง

คำอธิบายเพิ่มเติม:

ให้ n เป็นอินพุต n โปรแกรม dc คำนวณผลรวมของ

A = floor (256 ^ n / 255) * 125 (BF ถูกตีความโดย dc เป็น 11 * 10 + 15 = 125)

และ

B = พื้น ((256 ^ n) ^ 3 / (8 ^ 8-1)) * 8092541 * (256 ^ n)

สำหรับ:

สังเกตว่า 1 + 256 + 256 ^ 2 + ... + 256 ^ (n-1) เท่ากับ (256 ^ n-1) / 255 โดยสูตรสำหรับความก้าวหน้าทางเรขาคณิตและเท่ากับชั้น (256 ^ n / 255 ) นี่คือจำนวนที่ประกอบด้วย n 1 ในฐาน 256

เมื่อคุณคูณด้วย 125 เพื่อรับ A ผลลัพธ์คือตัวเลขที่ประกอบด้วย n 125's ในฐาน 256 (125 เป็นตัวเลขหลักเดียวในฐาน 256 ของหลักสูตร) มันอาจจะดีกว่าถ้าเขียนตัวเลขในฐาน 256 เป็นเลขฐานสิบหก 125 คือ hex 7D ดังนั้น A คือตัวเลขฐาน 256 ซึ่งประกอบด้วย n 7D ในหนึ่งแถว

B คล้ายกัน:

เวลานี้สังเกตว่า 1 + 16777216 + 16777216 ^ 2 + ... + 16777216 ^ (n-1) เท่ากับ (16777216 ^ n - 1) / 16777215 และชั้นนี้เท่ากับ (16777216 ^ n / 16777215)

ทีนี้, 256 ^ 3 = 16777216, และ 8 ^ 8-1 = 16777215, นี่คือสิ่งที่เรากำลังคำนวณว่าเป็นพื้น ((256 ^ n) ^ 3 / (8 ^ 8-1))

จากการแสดงชุดรูปทรงเรขาคณิตตัวเลขนี้ในฐาน 256 คือ 100100100 ... 1001 โดยมี n ของตัวเลขเป็น 1 และส่วนที่เหลือเป็น 0

สิ่งนี้จะถูกคูณด้วย 8092541 ซึ่งเป็น 7B7B7D เป็นเลขฐานสิบหก ในฐาน 256 นี่คือตัวเลขสามหลักซึ่งประกอบด้วยตัวเลข 7B, 7B และ 7D (เขียนตัวเลขเหล่านั้นเป็นเลขฐานสิบหกเพื่อความสะดวก)

ตามด้วยผลิตภัณฑ์ที่เขียนในฐาน 256 เป็นหมายเลข 3n ซึ่งประกอบด้วย 3 หลัก 7B 7B 7D ซ้ำ n ครั้ง

สิ่งนี้จะถูกคูณด้วย 256 ^ n ทำให้ตัวเลข 4n- หลัก -254 ประกอบด้วย 3 หลัก 7B 7B 7D ซ้ำ n ครั้งตามด้วย n's 0 นั่นคือ B.

ตอนนี้การเพิ่ม A + B จะทำให้จำนวนฐาน 256 หลัก 4n ประกอบด้วย 3 หลัก 7B 7B 7D ทำซ้ำ n ครั้งตามด้วย n 7D's เนื่องจาก 7B และ 7D เป็นรหัส ASCII สำหรับ{และ}ตามลำดับนี่คือสตริงที่ประกอบด้วย n สำเนาของ{{}ตามด้วย n สำเนาของ}ซึ่งเป็นสิ่งที่เราต้องการสำหรับ n> 0 คำสั่ง P ใน dc พิมพ์จำนวนฐาน 256 เป็นสตริงเช่นเดียวกับที่เราต้องการ

น่าเสียดายที่ n = 0 จะต้องได้รับการปฏิบัติเป็นกรณีพิเศษ การคำนวณข้างต้นเกิดขึ้นเพื่อให้ผลลัพธ์เป็น 0 สำหรับ n = 0; ในกรณีนั้นฉันพิมพ์รหัสสตริง{}ได้ยาก

Java 7, 61 ไบต์

String p(int p){return p<1?"{}":p<2?"{{}}":"{{}"+p(p-1)+"}";}

ลองออนไลน์!

แบตช์, 88 ไบต์

@set s={}
@if %1 gtr 0 set s=&for /l %%i in (1,1,%1)do @call set s={{}%%s%%}
@echo %s%

Brainf *** , 99 ไบต์

>+>+>+>+<[>[-<+++++>]<-<]>--[->+>+<<]
>[-<+>]>++<,[[->>+>+<<<]>>[-<<<..>>.>]>[-<<.>>]+[]]<.>>.

(ขึ้นบรรทัดใหม่เพื่อความสวยงาม) เนื่องจากมันเป็นสมอง *** จะใช้เวลาป้อนเป็นรหัส ASCII ถ่าน (ใส่ "a" สอดคล้องกับ 96)

Braineasy, 60 ไบต์

นอกจากนี้ในภาษาที่กำหนดเองของฉัน (ตาม brainf **, ล่ามที่นี่ ):

#123#[->+>+<<]>++<,[[-<+<+>>]<[->>>..<.<<]<[->>>.<<<]!]>>.<.

คุณต้องใส่รหัสโปรแกรมลงในล่ามเพราะฉันขี้เกียจ

05AB1E , 5 3 ไบต์

F¯)

ลองออนไลน์!

รุ่นนี้เป็นหลังจากที่เขาชี้แจงว่าชุดไม่เป็นไร

F   # From 1 to input...
 ¯  # Push global array (default value is []).
  ) # Wrap stack to array.

รุ่นเก่า (ที่ใช้ประโยชน์จากø):

05AB1E , 5 4 ไบต์

FX¸)

ลองออนไลน์!

ไหนจะเทียบเท่ากับ1ø

F    # From 1 to input...
 X   # Push value in register X (default is 1).
  ¸  # Wrap pushed value into an array.
   ) # Wrap whole stack into an array.
     # Implicit loop end (-1 byte).
     # Implicit return.