Liczby naturalne, w tym 0, są formalnie zdefiniowane jako zbiory, w następujący sposób :

• Liczba 0 jest zdefiniowana jako pusty zestaw, {}
• Dla n ≥ 0 liczba n +1 jest zdefiniowana jako n ∪ { n }.

W konsekwencji n = {0, 1, ..., n -1}.

Pierwsze liczby zdefiniowane w tej procedurze to:

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

Wyzwanie

Biorąc pod uwagę n, wypisz jego reprezentację jako zbiór.

Zasady

Wyjście może konsekwentnie używać wspornik charakteru takie jak {}, [], ()lub <>. Dowolne znaki (takie jak 01) są niedozwolone.

Zamiast przecinka, jak powyżej, separatorem może być dowolny znak interpunkcyjny; lub może nie istnieć.

Spacje (nie nowe wiersze) mogą być wprowadzane arbitralnie i niekonsekwentnie.

Na przykład liczba 2 z nawiasami kwadratowymi i średnikiem jako separatorem jest [[]; [[]]]lub jest równoważna [ [ ]; [ [ ] ] ]lub nawet[ [ ] ;[ []]]

Kolejność w której elementy zestawu są określone nie ma znaczenia. Możesz więc użyć dowolnej kolejności w reprezentacji. Na przykład są to niektóre prawidłowe dane wyjściowe dla 3:

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

Możesz napisać program lub funkcję . Dane wyjściowe mogą być łańcuchem lub, jeśli używasz funkcji, możesz zwrócić zagnieżdżoną listę lub tablicę, których ciąg znaków jest zgodny z powyższym.

Przypadki testowe

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

Galaretka , 3 bajty

Ḷ߀

To jest monadyczny link. Wypróbuj online!

Jak to działa

Każda liczba naturalna jest zbiorem wszystkich poprzednich liczb naturalnych, tj. N = {0,…, n-1} . Ponieważ nie ma liczb naturalnych poprzedzających 0 , mamy 0 = {} .

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

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

Python 2, 26 bajtów

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

Przetestuj na Ideone .

JavaScript (ES6), 32 bajty

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

Wystarczająco proste.

Perl 6 , 16 bajtów

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

Zwraca zagnieżdżoną strukturę danych.

Przykład:

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

Wyjaśnienie:

{   # 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 bajtów

Jestem nowy w rubinowym golfie, ale tutaj nic nie idzie. Dzięki Jordanowi za oszczędność 6 bajtów!

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

Jest to funkcja rekurencyjna f(konkretnie proc) i wymaga argumentu s. To odwzorowuje proc fciągu 0...s, który jest zasięg [0, s).

Haskell, 32 27 bajtów

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

Wypróbuj na Ideone.

CJam , 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

W każdej iteracji blok buduje reprezentację liczby na podstawie liczby poprzedniej. Aby to zilustrować, rozważmy drugą iterację, w której reprezentacja liczby 2jest zbudowana z tej 1, która jest łańcuchem "[[]]".

1. Stos zawiera "[[]]"
2. Po wyciągu _(duplikacie) zawiera "[[]]":"[[]]"
3. Po wypowiedzi )(uncons) zawiera "[[]]", "[[]","]"
4. Po oświadczenie @(Obrót) zawiera "[[]", "]","[[]]"
5. Po oświadczenie \(swap) zawiera "[[]", "[[]]","]"
6. Po instrukcji ](spakuj do tablicy) zawiera ona ["[[]" "[[]]" "]"], która byłaby wyświetlana jako ciąg "[[][[]]]".

Cheddar, 17 bajtów

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

Krótka rekurencja + Krótki zasięg + Krótka iteracja = Wyzwanie, w którym cheddar ma się bardzo dobrze

Nie konkuruje, 11 bajtów

n f->|>n=>f

=>Operator został dodany po to wyzwanie został zwolniony dzięki czemu ta odpowiedź nie konkurują.

Może to wyglądać na mylące, ale pozwolę sobie uprościć:

n f -> |> n => f

w zasadzie njest wejściem i fsamą funkcją. |>ngeneruje [0, n) i =>odwraca mapy f.

05AB1E , 8 7 bajtów

)IF)©`®

Wyjaśnienie

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

Wypróbuj online!

Zaoszczędzono 1 bajt dzięki Adnanowi.

Pyth, 4 bajty

LyMb

Zestaw testowy

L: Zdefiniuj funkcję za ypomocą wejściab

yMb: yodwzorowany w zakresie0, 1, ..., b-1

Na wejściu 0 mapa powraca []. W przeciwnym razie zwraca ymapowane na wszystkie liczby do b.

MATL , 13 bajtów

Xhi:"tY:Xh]&D

Wypróbuj online!

Wyjaśnienie

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 bajtów

Obejmuje +1 dla -p

Wydaje się, że wiele różnych metod kończy się na 27 lub 28 bajtów. na przykład

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

Najlepsze, co mogłem znaleźć, to

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

ponieważ na starszych perlach możesz upuścić miejsce przed fori uzyskać 26 bajtów

Mathematica, 14 bajtów

Array[#0,#,0]&

Mathematica, 31 bajtów

Prosto implementuje definicję jako listę zagnieżdżoną. Używa nienazwanej funkcji, która rekurencyjnie wywołuje się za pomocą #0.

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

Siatkówka , 24 18 bajtów

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

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

.+
$*1<>

Konwertuje to dane wejściowe na jednoargumentowe i dołącza <>reprezentację 0.

+`1<
<<$'

Tutaj +wskazuje, że to podstawienie powinno być uruchamiane w pętli, aż łańcuch przestanie się zmieniać. Łatwiej to wyjaśnić, przechodząc przez poszczególne etapy gry w golfa. Let's z tą wersją podstawienia:

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

Jest to zgodne z ostatnią 1jednostkową reprezentacją pozostałych danych wejściowych (aby je usunąć i zmniejszyć dane wejściowe), a także zawartością bieżącego zestawu na końcu. Jest on następnie zastępowany nowym zestawem zawierającym poprzedni oraz jego zawartość. Możemy jednak zauważyć, że $1następuje to >w obu przypadkach, a zatem możemy uwzględnić go w samym przechwytywaniu i pominąć we wzorcu podstawiania. To prowadzi do formy

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

Jednak teraz możemy zauważyć, że (.*)po prostu przechwytuje sufiks łańcucha po, 1<a nawet wstawiamy ten sufiks na końcu za pomocą $1. Ponieważ składnia podstawienia daje nam możliwość odwołania się do części ciągu po dopasowaniu $', możemy po prostu pominąć obie te części i skończyć na wersji użytej w odpowiedzi:

1<
<<$'

Niedociążenie , 14 bajtów

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

Wypróbuj online!

Pełne programy niedociążenia nie mogą pobierać danych wejściowych za pomocą żadnej z naszych zdefiniowanych metod, więc jest to funkcja, która pobiera dane wejściowe ze stosu jako liczby kościelnej (normalny sposób definiowania liczb całkowitych w programie Niedociążenie) i generuje dane wyjściowe do stosu jako ciąg .

Do (…)grupowania markery mają obowiązek dokonać tej funkcji (wielokrotnego użytku), a nie tylko użyteczny fragmencie (raz). Opakowanie w łączu TIO wywołuje tę funkcję destrukcyjnie przy użyciu ^, ale można ją ponownie wykorzystać, wykonując jej kopię i zużywając tylko jedną z kopii podczas wywoływania. Dostarcza również dane wejściowe do programu (tutaj (:*:*), tj. 4) i drukuje dane wyjściowe za pomocą S.

Wyjaśnienie

Niedociążenie zaskakująco nadaje się do tego zadania, gdy pojawiają się plandeki Turinga, mające takie przydatne prymitywy, jak „kopiuj” i „otaczaj nawiasami”. (W jakiś sposób niedociążenie, zwykle bardzo szczegółowy język, pokonuje Mathematica, zwykle język, który wygrywa dzięki posiadaniu ogromnego zestawu wbudowanych funkcji, dzięki bardziej odpowiednim wbudowanym funkcjom!) Oto, jak działa program:

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

Potęgowanie funkcji skutecznie powoduje, że kroki funkcji powtarzają się tyle razy, więc np (:a*). Byłoby ³ (:a*:a*:a*). Jest to idiomatyczny sposób napisania pętli, która powtarza określoną liczbę razy w trybie niedociążenia. (Możesz zauważyć, że ~^opisano to na dwa różne sposoby powyżej; to dlatego, że liczby całkowite w niedociążeniu są zdefiniowane jako potęgowanie funkcji specjalizowane dla tej liczby całkowitej, więc aby wykonać potęgowanie funkcji, po prostu spróbuj wykonać liczbę całkowitą tak, jakby była funkcją .)

Pari / GP , 23 bajty

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

Wypróbuj online!

APL (NARS), 15 znaków, 30 bajtów

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

test:

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

Nie wiem, czy to zostanie zaakceptowane ... Zilde jest ⍬ tutaj reprezentuje zestaw pustek {}, jeśli chcę wydrukować element Zilde lub jeden element pełen Zilde, a Zilde załączyła wszystko, co się dzieje, to nie drukuj nic ... więc dla zobaczenia Zilde należy zdefiniować jedną funkcję, którą nazywam o ( o←⎕fmt) Nie wstawiam do licznika, ponieważ element i jego struktura istnieją nawet, jeśli sys go nie wydrukuje ... Jest to możliwe, jeśli io wynosi 0

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

rozwiązanie może mieć również 12 znaków ...

Brachylog , 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajty

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

Na przykład:

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

Rakieta 119 bajtów

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

Nie golfowany:

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

Testowanie (w Racket {} jest takie samo jak (), a domyślnym wyjściem jest ()):

(f 4)

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

Aby wyraźnie zobaczyć każdą liczbę (od 0 do 3):

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

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

Partia, 74 bajty

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

Wykorzystuje fakt, że każda odpowiedź jest równa poprzedniej odpowiedzi wstawionej do siebie po prowadzeniu {. Pierwsze kilka wyników jest następujące:

{}

{{}}

{{{}}{}}

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

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

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