0 içeren doğal sayılar, aşağıdaki şekilde resmen kümeler olarak tanımlanır :

• Sayı 0, boş küme olarak tanımlanır, {}
• İçin n 0, sayı ≥ n + 1 olarak tanımlanmaktadır n ∪ { n }.

Sonuç olarak, n = {0, 1, ..., n -1}.

Bu prosedür tarafından tanımlanan ilk sayılar:

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

Meydan okuma

Verilen n, kümesini temsil eder.

kurallar

Çıkış, daima herhangi bir kullanabilir dirseği gibi bir karakter {}, [], ()ya da <>. İsteğe bağlı karakterlere (örneğin 01) izin verilmez.

Yukarıdaki gibi virgül yerine, ayırıcı herhangi bir noktalama işareti olabilir; ya da mevcut olmayabilir.

Boşluklar (yeni satırlar değil) keyfi ve tutarsız bir şekilde dahil edilebilir.

Örneğin, köşeli ayraçlı ve 2 numaralı, ayırıcı olarak noktalı virgül [[]; [[]]], veya eşdeğer [ [ ]; [ [ ] ] ]veya hatta[ [ ] ;[ []]]

Sipariş kümesinin elemanları önemli değildir belirtilen edildiği. Böylece gösterimde herhangi bir sipariş kullanabilirsiniz. Örneğin, bunlar için bazı geçerli çıktılar 3:

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

Bir program veya işlev yazabilirsiniz . Çıktı bir dize olabilir veya bir işlev kullanıyorsanız, dize gösterimi yukarıdakine uyan bir iç içe liste veya dizi döndürebilirsiniz.

Test durumları

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

Jöle , 3 bayt

Ḷ߀

Bu monadik bir bağlantıdır. Çevrimiçi deneyin!

Nasıl çalışır

Her doğal sayı, önceki tüm doğal sayıların kümesidir; yani, n = {0,…, n-1} . 0'dan önce doğal sayılar olmadığından , 0 = {} var .

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

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

Python 2, 26 bayt

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

İdeone üzerinde test et .

JavaScript (ES6), 32 bayt

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

Yeterince basit.

Perl 6 , 16 bayt

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

İç içe veri yapısını döndürür.

Örnek:

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

Açıklama:

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

Yakut golf oynamak için yeniyim ama işte hiçbir şey yok. Ürdün'e 6 byte kaydettiğin için teşekkürler!

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

Bu özyinelemeli bir işlevdir f(bir proc, belirli olması için) ve bir argüman alır s. Bu proc eşler füzerinde 0...smenzil olan [0, s).

Haskell, 32 27 bayt

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

Ideone'da dene.

CJam , 14 bayt

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

Çevrimiçi deneyin!

açıklama

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

Her yinelemede, blok bir öncekinden bir sayının temsilini oluşturur. Göstermek için, sayının temsilinin dize olandan 2üretildiği ikinci yinelemeyi düşünelim .1"[[]]"

1. Yığın içerir "[[]]"
2. İfadeden sonra _(çoğaltılarak) "[[]]","[[]]"
3. Deyimi sonra )İçerdiği (uncons) "[[]]", "[[]","]"
4. Deyimi sonra @İçerdiği (dönüşümlü) "[[]", "]","[[]]"
5. İfadeden sonra \(takas) içerir"[[]" ,"[[]]" ,"]"
6. İfadeden sonra ](diziye paketlenir) ["[[]" "[[]]" "]"], dizge olarak gösterilecektir "[[][[]]]".

Çedar, 17 bayt

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

Kısa özyineleme + Kısa menzil + Kısa yineleme = Çedarın çok iyi yaptığı bir zorluk

Rekabet etmeyen, 11 bayt

n f->|>n=>f

=>Bu meydan okuma Bu cevap dışı yarışan yapım yayımlandıktan sonra operatör eklendi.

Bu kafa karıştırıcı görünebilir ama basitleştireyim:

n f -> |> n => f

temel nolarak giriş ve ffonksiyonun kendisidir. |>n[0, n) oluşturur ve =>üzerinde harita oluşturur f.

05AB1E , 8 7 bayt

)IF)©`®

açıklama

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

Çevrimiçi deneyin!

Adnan sayesinde 1 byte kurtarıldı.

Pyth, 4 bayt

LyMb

Test odası

L: Fonksiyonu ygiriş ile tanımlayınb

yMb: yaralık boyunca eşlenmiş0, 1, ..., b-1

0 girişinde bu harita geri döner []. Aksi takdirde, ytüm sayıların üzerinde eşlenene dönerb .

MATL , 13 bayt

Xhi:"tY:Xh]&D

Çevrimiçi deneyin!

açıklama

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 bayt

İçin +1 içerir -p

Birçok farklı yöntemin hepsi ya 27 ya da 28 bayt olarak görünmektedir. Örneğin

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

Bulabildiğim en iyi şey

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

çünkü eski perls’de önce boşluğu bırakıp for26 bayt

Mathematica, 14 bayt

Array[#0,#,0]&

Mathematica, 31 bayt

Tanımı iç içe geçmiş bir liste olarak doğrudan uygular. Tekrarlayan bir şekilde kendisini kullanarak çağıran adsız bir işlev kullanır #0.

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

Retina , 24 18 bayt

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

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

.+
$*1<>

Bu girdiyi birliğe çevirir ve ekler <>, gösterimi 0.

+`1<
<<$'

Burada, +bu değişimin, dize değişmeyi bırakana kadar bir döngüde çalıştırılması gerektiğini belirtir. Bunu golf oynamak için attığım bireysel adımlardan geçerek açıklamak daha kolay. Değişimin bu versiyonuyla görüşelim:

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

Bu 1, kalan girişin birleşik temsili sonuncusuyla (onu kaldırmak ve girişi azaltmak için) ve sonunda ayarlanan akımın içeriğiyle eşleşir . Bu daha sonra içeriğini olduğu kadar öncekini içeren yeni bir set ile değiştirilir. Ancak, $1bunu >her iki durumda da takip ettiğimizi fark edebiliriz ve bu nedenle onu yakalamanın kendisine ekleyebilir ve yerine koyma biçiminden çıkartabiliriz. Bu forma götürür

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

Bununla birlikte, şimdi (.*)sadece dizenin son ekini yakaladığını 1<ve sonunda bu eki yeniden yerleştirdiğimizi görebiliyoruz $1. İkame sözdizimi bize bir eşleşmeden sonra bir dizgenin parçasına atıfta bulunmamızın bir yolunu verdiğinden $', bu iki parçayı da ihmal edebilir ve cevapta kullanılan sürümle son bulabiliriz:

1<
<<$'

Düşük yük , 14 bayt

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

Çevrimiçi deneyin!

Alttaki dolu programlar, tanımlanmış yöntemlerimizden hiçbiriyle girdi alamazlar; bu nedenle, yığıntan bir Kilise rakamı (Alt Yükte tamsayıları tanımlamanın normal yolu) olarak girdiyi alan ve dizeye çıktıyı üreten bir işlevdir. .

(…)Gruplama markörler yerine bir pasajı (yalnızca kullanılabilir bir defa) daha bu bir fonksiyonu (yeniden kullanılabilir) hale getirmek için gereklidir. TIO bağlantısındaki sarıcı, söz konusu işlevi yıkıcı kullanarak kullanır ^, ancak bir kopyasını alarak ve onu çağırırken yalnızca bir kopyasını tüketerek yeniden kullanılabilir. Ayrıca programa girdi sağlar (burada (:*:*), yani 4) ve çıktıyı kullanarak yazdırır.S .

açıklama

Düşük yük, Turing tarpits ilerledikçe “kopya” ve “parantezle çevreleyen” gibi yararlı ilkellere sahip olan bu görev için şaşırtıcı bir şekilde uygundur. (Her nasılsa, normalde çok ayrıntılı bir dil olan Underload, normalde çok sayıda yerleşik yapıya sahip olan ve daha uygun yapılara sahip olan bir dil olan Mathematica'yı yener!) Programın çalışması:

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

İşlevsel üstelleştirme, işlev basamaklarının birçok kez tekrar etmesini sağlar; örneğin, to (:a*)olur (:a*:a*:a*). Bu, Underload'da verilen sayıda tekrar eden bir döngü yazmanın aptalca yoludur. ( ~^Yukarıda iki farklı yolun tanımlandığını not edebilirsiniz ; bunun nedeni, Underload'daki tam sayıların, o tamsayı için özel işlev tanımlaması olarak tanımlanmasıdır; bu nedenle, bir işlev üssünü yapmak için, basitçe bir işlevmiş gibi bir tamsayı çalıştırmayı denersiniz. .)

Pari / GP , 23 bayt

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

Çevrimiçi deneyin!

APL (NARS), 15 karakter, 30 bayt

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

Ölçek:

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

Bunun kabul edilip edilmeyeceğini bilmiyorum ... Zilde ⍬ burada, Zilde öğesini veya Zilde dolu bir öğeyi yazdırmak istersem {} geçersiz kümesini temsil ediyor ve Zilde olanları, hiçbir şeyin yazdırılmamasını içeriyordu ... Zilde görmek için bir işlev tanımlamak zorundadır. Ben onu çağırırım o ( o←⎕fmt) Sayıya girmiyorum, çünkü eleman ve yapısı, sys yazmıyor olsa bile var.

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

çok 12 karakterli çözüm olabilir ...

Brachylog , 14 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Örneğin:

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

Raket 119 bayt

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

Test Etme (Raket İçinde {} () ile aynıdır ve varsayılan çıktı ()):

(f 4)

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

Her numarayı net bir şekilde görmek için (0 - 3):

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

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

Toplu iş, 74 bayt

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

Her cevabın öncüden sonra kendisine verilen önceki cevaba eşit olduğu gerçeğini kullanır {. İlk birkaç çıktı şöyle:

{}

{{}}

{{{}}{}}

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

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

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