Konstruksi ini adalah cara untuk mewakili Bilangan Alam.

Dalam representasi ini, 0 didefinisikan sebagai himpunan kosong dan untuk semua angka lainnya, n adalah gabungan dari {0} dan {n-1}.

Sebagai contoh untuk membangun 3 kita dapat mengikuti algoritma:

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

Tugas

Seperti yang Anda duga, tugas Anda adalah mengambil bilangan asli (termasuk nol) dan menampilkan konstruksinya.

Anda dapat menampilkan sebagai string atau sebagai objek set jika bahasa pilihan Anda mendukung objek tersebut.

Jika Anda memilih untuk menampilkan sebagai string, Anda harus mewakili satu set dengan kurung kurawal ( {}). Anda secara opsional dapat mewakili set kosong sebagai ø(jika tidak set harus tanpa entri {}). Anda juga dapat memilih untuk menambahkan koma dan spasi putih di antara dan setelah entri di set.

Urutan tidak penting, namun Anda mungkin tidak memiliki elemen berulang dalam set yang Anda hasilkan (mis. {ø,ø})

Ini adalah kode-golf sehingga tujuannya adalah untuk memiliki byte paling sedikit

Uji kasus

Berikut adalah beberapa test case dengan beberapa contoh output.

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

Python , 28 byte

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

Cobalah online!

Ini adalah solusi yang cukup hambar untuk masalah ini. Untuk angka yang lebih besar dari nol Anda bisa mendapatkan representasi dengan rumus string "{{}"*x+"}"*x. Namun ini tidak berfungsi untuk nol di mana ini adalah string kosong. Kita dapat menggunakan fakta ini untuk membuat hubungan pendek dan ormengembalikan set kosong.

Saya ingin menggunakan objek set bawaan python untuk mengatasi masalah ini, tetapi sayangnya:

TypeError: unhashable type: 'set'

Anda tidak bisa meletakkan set di dalam set dengan python.

Haskell , 37 byte

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

Cobalah online!

Sampai 10 menit yang lalu jawaban seperti ini tidak masuk akal bagiku. Semua kredit masuk ke jawaban kiat ini .

Pada dasarnya, kita menggunakan >>as concat $ replicate(tetapi meneruskannya daftar n elemen bukan hanya n), dan =<<sebagai concatMap, mereplikasi lalu n kali setiap string dalam daftar dan menggabungkan hasilnya menjadi satu string.

The 0kasus diperlakukan secara terpisah karena akan mengembalikan string kosong.

JavaScript, 28 byte

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

Merupakan set menggunakan array. Solusi non-rekursif 38-byte:

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

Mengembalikan contoh string keluaran.

Mathematica, 27 byte

Saya punya dua solusi pada hitungan byte ini:

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

Perl 6 , 37 byte

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

Cobalah

Diperluas:

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

Kode

ƒ)¯sÙ

Menggunakan pengkodean CP-1252 . Cobalah online! atau Verifikasi semua kasus uji! .

Penjelasan

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

Retina , 22 byte

.+
$*
\`.
{{}
{

^$
{}

Cobalah online!

Penjelasan

.+
$*

Konversikan input ke unary.

\`.
{{}

Ganti setiap digit unary dengan {{}dan cetak hasilnya tanpa linefeed tambahan (\ ).

{

Lepaskan {s, sehingga sisanya }persis seperti yang masih harus kita cetak untuk menutup semua set. Namun, prosedur di atas gagal untuk input0 , di mana kami tidak akan mencetak apa pun. Begitu...

^$
{}

Jika string kosong, ganti dengan set kosong.

Brain-Flak , 135 byte

Termasuk +1 untuk -A

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

Cobalah online!

(({}())<                 # 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 byte

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

CJam , 11 byte

Lri{]La|}*p

Mencetak objek seperti set yang terdiri dari daftar daftar. CJam mencetak daftar kosong sebagai string kosong, karena daftar dan string hampir dapat dipertukarkan.

Cobalah online!

Penjelasan

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

Jawaban lama, 21 18 byte

Ini sebelum dikonfirmasi bahwa tidak apa-apa untuk mencetak struktur daftar bersarang. Menggunakan algoritma pengulangan string.

Disimpan 3 byte berkat Martin Ender!

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

Penjelasan

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.

Jelly , 6 byte

⁸,⁸Q$¡

Ini adalah tautan niladic yang membaca integer dari STDIN dan mengembalikan array yang tidak rata.

Cobalah online!

Bagaimana itu bekerja

⁸,⁸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 byte

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

Bukan cara terpendek, tetapi saya hanya harus melakukan ini dengan rekursi.

Cobalah online!

Kardinal , 51 50 byte

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

Cobalah online!

Penjelasan

%:#
x

Terima input dan kirim turun dan kiri dari #

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

Cetak "{" satu kali lalu cetak "{} {" n-1 kali jika n> 1 lalu cetak "{}" jika n> 0

       #

v <8/ ?<
>  8\

Tahan nilai input sampai loop pertama selesai

v"}"<
>?-?^

Cetak "}" sekali lalu ulangi n-1 kali jika n> 1

AHK, 55 byte

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

Ini bukan jawaban terpendek tapi saya menikmati ini karena kekhasan AutoHotkey membuat metode rekursi ini terlihat sangat salah. Ifdan Looppernyataan menganggap baris berikutnya adalah satu-satunya yang disertakan jika tanda kurung tidak digunakan. Kurung keriting adalah karakter pelarian sehingga Anda harus menghindarinya dengan kurung keriting lain untuk menggunakannya sebagai teks. Selain itu, variabel 1adalah argumen yang diteruskan pertama. Ketika saya membaca kode tanpa mengetahui informasi tersebut, logikanya terlihat seperti ini:

• Jika 1 = 0, maka set ssama dengan jawaban yang salah
• Ulangi dan tambahkan banyak tanda kurung ke awal dan beberapa ke akhir setiap waktu
• Kembali dengan mengirim string yang dihasilkan ke jendela saat ini

Tanpa semua karakter pelepasan braket, akan terlihat seperti ini:

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

JavaScript 50 byte

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

tinylisp , 52 byte

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

Cobalah online! (test harness).

Penjelasan

Perhatikan bahwa (cons x (cons y nil))cara Anda membuat daftar berisi xdan ydalam Lisp.

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

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

Mengambil keuntungan dari beberapa evaluasi dan rekursi hubung singkat.

Cobalah online!

Pure Bash , 49 48 41 byte

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

Cobalah online!

dc , 46 byte

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

Cobalah online!

Input pada stdin, output pada stdout.

Ini bekerja dengan menghitung formula untuk output yang diinginkan sebagai nomor basis-256. Perintah P di dc kemudian digunakan untuk mencetak nomor basis-256 sebagai string.

Penjelasan lebih lanjut:

Biarkan n menjadi input n. Program dc menghitung jumlah

A = lantai (256 ^ n / 255) * 125 (BF ditafsirkan oleh dc sebagai 11 * 10 + 15 = 125)

dan

B = lantai ((256 ^ n) ^ 3 / (8 ^ 8-1)) * 8092541 * (256 ^ n).

Untuk sebuah:

Perhatikan bahwa 1 + 256 + 256 ^ 2 + ... + 256 ^ (n-1) sama dengan (256 ^ n-1) / 255, dengan rumus untuk perkembangan geometrik, dan ini sama dengan lantai (256 ^ n / 255 ). Jadi ini adalah angka yang terdiri dari n 1 dalam basis 256.

Ketika Anda mengalikannya dengan 125 untuk mendapatkan A, hasilnya adalah angka yang terdiri dari n 125 dalam basis 256 (tentu saja 125 adalah satu digit dalam basis 256). Mungkin lebih baik menulis digit pada basis 256 sebagai angka hex; 125 adalah hex 7D, jadi A adalah angka dasar-256 yang terdiri dari n 7D berturut-turut.

B serupa:

Kali ini amati bahwa 1 + 16777216 + 16777216 ^ 2 + ... + 16777216 ^ (n-1) sama dengan (16777216 ^ n - 1) / 16777215, dan ini sama dengan lantai (16777216 ^ n / 16777215).

Sekarang, 256 ^ 3 = 16777216, dan 8 ^ 8-1 = 16777215, jadi inilah yang kami hitung sebagai lantai ((256 ^ n) ^ 3 / (8 ^ 8-1)).

Dari representasi deret geometri, angka dalam basis 256 ini adalah 100100100 ... 1001 dengan n dari angka 1 dan sisanya dari angka 0.

Ini dikalikan dengan 8092541, yaitu 7B7B7D dalam heksadesimal. Dalam basis 256, ini adalah angka tiga digit yang terdiri dari angka 7B, 7B, dan 7D (menulis angka-angka itu dalam hex untuk kenyamanan).

Oleh karena itu produk yang ditulis dalam basis 256 adalah angka 3n-digit yang terdiri dari 3 digit 7B 7B 7D yang diulang n kali.

Ini dikalikan dengan 256 ^ n, menghasilkan nomor basis-256 4n-digit, terdiri dari 3 digit 7B 7B 7D yang diulang n kali, diikuti oleh n 0's. Itu B.

Menambahkan A + B sekarang menghasilkan basis-digit 4n-digit 256 yang terdiri dari 3 digit 7B 7B 7D yang diulang n kali, diikuti oleh n 7D. Karena 7B dan 7D adalah kode ASCII untuk {dan }, masing-masing, ini adalah string yang terdiri dari n salinan {{}diikuti oleh n salinan }, yang persis seperti yang kita inginkan untuk n> 0. Perintah P di dc mencetak angka dasar-256 sebagai string, seperti yang kita butuhkan.

Sayangnya, n = 0 harus diperlakukan sebagai kasus khusus. Perhitungan di atas terjadi untuk menghasilkan hasil 0 untuk n = 0; dalam hal ini, saya baru saja mencetak kode hard-string {}.

Java 7, 61 byte

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

Cobalah online!

Batch, 88 byte

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

Brainf *** , 99 byte

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

(baris baru untuk estetika) Karena itu *** ***, dibutuhkan input sebagai kode ascii char (input "a" sesuai dengan 96)

Braineasy, 60 byte

Juga, dalam bahasa khusus saya (berbasis brainf **, juru bahasa di sini ):

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

Anda harus memasukkan kode program ke dalam interpreter karena saya malas.

05AB1E , 5 3 byte

F¯)

Cobalah online!

Versi ini setelah dia mengklarifikasi bahwa set tidak apa-apa.

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

Versi lama (yang memanfaatkan ø):

05AB1E , 5 4 byte

FX¸)

Cobalah online!

Di mana 1setara dengan ø.

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.