Die natürlichen Zahlen einschließlich 0 werden formal wie folgt als Mengen definiert :

• Nummer 0 ist definiert als die leere Menge, {}
• Für n ≥ 0 ist die Zahl n +1 definiert als n ∪ { n }.

Infolgedessen ist n = {0, 1, ..., n- 1}.

Die ersten Zahlen, die durch dieses Verfahren definiert werden, sind:

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

Herausforderung

Gegeben n, gib seine Darstellung als Menge aus.

Regeln

Der Ausgang kann konsequent jegliche Verwendung Klammer Charakter wie {}, [], ()oder <>. Beliebige Zeichen (wie 01) sind nicht erlaubt.

Anstelle eines Kommas wie oben kann das Trennzeichen ein beliebiges Interpunktionszeichen sein. oder es kann nicht vorhanden sein.

Leerzeichen (keine Zeilenumbrüche) können willkürlich und inkonsistent eingefügt werden.

Beispiel: Nummer 2 mit eckigen Klammern und Semikolon als Trennzeichen ist [[]; [[]]]oder gleich [ [ ]; [ [ ] ] ]oder gerade[ [ ] ;[ []]]

Die Reihenfolge, in der Elemente einer Menge angegeben werden, spielt keine Rolle. Sie können also eine beliebige Reihenfolge in der Darstellung verwenden. Dies sind beispielsweise einige gültige Ausgaben für 3:

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

Sie können ein Programm oder eine Funktion schreiben . Bei der Ausgabe kann es sich um eine Zeichenfolge handeln. Wenn Sie eine Funktion verwenden, können Sie eine verschachtelte Liste oder ein Array zurückgeben, dessen Zeichenfolgendarstellung der obigen entspricht.

Testfälle

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

Gelee , 3 Bytes

Ḷ߀

Dies ist eine monadische Verbindung. Probieren Sie es online!

Wie es funktioniert

Jede natürliche Zahl ist die Menge aller vorherigen natürlichen Zahlen, dh n = {0,…, n-1} . Da es keine natürlichen Zahlen vor 0 gibt, ist 0 = {} .

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

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

Python 2, 26 Bytes

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

Teste es auf Ideone .

JavaScript (ES6), 32 Byte

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

Einfach genug.

Perl 6 , 16 Bytes

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

Gibt eine verschachtelte Datenstruktur zurück.

Beispiel:

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

Erläuterung:

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

Ich bin neu in Ruby Golf, aber hier geht nichts. Vielen Dank an Jordan für das Speichern von 6 Bytes!

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

Dies ist eine rekursive Funktion f(um genau zu sein ein Proc) und benötigt ein Argument s. Es bildet den Proc- fOver ab 0...s, also die Reichweite [0, s).

Haskell, 32 27 Bytes

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

Probieren Sie es auf Ideone.

CJam , 14 Bytes

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

Probieren Sie es online!

Erläuterung

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

In jeder Iteration bildet der Block die Darstellung einer Zahl von der der vorhergehenden. Betrachten wir zur Veranschaulichung die zweite Iteration, bei der die Zahlendarstellung 2aus 1der Zeichenfolge aufgebaut ist "[[]]".

1. Der Stapel enthält "[[]]"
2. Nach Anweisung _(Duplikat) enthält es "[[]]","[[]]"
3. Nach Aussage )(Uncons) enthält "[[]]", "[[]","]"
4. Nach Aussage @(drehen) enthält "[[]", "]","[[]]"
5. Nach Aussage \(swap) enthält "[[]", "[[]]","]"
6. Nach Anweisung ](in Array packen) enthält es ["[[]" "[[]]" "]"], was als String angezeigt würde "[[][[]]]".

Cheddar, 17 Bytes

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

Kurze Rekursion + Kurze Reichweite + Kurze Iteration = Eine Herausforderung, bei der Cheddar sehr gut abschneidet

Nicht konkurrierend, 11 Bytes

n f->|>n=>f

Der =>Operator wurde hinzugefügt, nachdem diese Herausforderung freigegeben wurde, wodurch diese Antwort nicht konkurrierend war.

Das mag verwirrend aussehen, aber lassen Sie mich es vereinfachen:

n f -> |> n => f

Im Grunde nist der Eingang und fist die Funktion selbst. |>ngeneriert [0, n) und =>ordnet dies zu f.

05AB1E , 8 7 Bytes

)IF)©`®

Erläuterung

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

Probieren Sie es online!

Dank Adnan 1 Byte gespeichert.

Pyth, 4 Bytes

LyMb

Testsuite

L: Definieren Sie die Funktion ymit Eingabeb

yMb: yüber den Bereich abgebildet0, 1, ..., b-1

Bei der Eingabe 0 wird diese Zuordnung zurückgegeben []. Andernfalls werden yalle Zahlen bis zu zugeordnet b.

MATL , 13 Bytes

Xhi:"tY:Xh]&D

Probieren Sie es online!

Erläuterung

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 Bytes

Beinhaltet +1 für -p

Viele verschiedene Methoden scheinen entweder 27 oder 28 Bytes zu haben. z.B

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

Das Beste, was ich finden konnte, ist

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

da bei älteren perls kann man den platz vor dem löschen forund bekommt 26 bytes

Mathematica, 14 Bytes

Array[#0,#,0]&

Mathematica, 31 Bytes

Implementiert die Definition direkt als verschachtelte Liste. Verwendet eine unbenannte Funktion, die sich selbst rekursiv mit aufruft #0.

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

Retina , 24 18 Bytes

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

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

.+
$*1<>

Dadurch wird die Eingabe in unär umgewandelt <>und die Darstellung von angehängt 0.

+`1<
<<$'

Hier gibt das +an, dass diese Ersetzung in einer Schleife ausgeführt werden soll, bis sich die Zeichenfolge nicht mehr ändert. Es ist einfacher, dies durch die einzelnen Schritte zu erklären, die ich beim Golfspielen unternommen habe. Lassen Sie uns mit dieser Version der Ersetzung:

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

Dies entspricht der letzten 1unären Darstellung der verbleibenden Eingabe (um sie zu entfernen und die Eingabe zu dekrementieren) sowie dem Inhalt des aktuellen Satzes am Ende. Dieses wird dann durch ein neues Set ersetzt, das das vorherige sowie dessen Inhalt enthält. Allerdings können wir feststellen , dass $1durch folgt >in beiden Fällen und daher können wir es in der Aufnahme selbst enthalten und lassen sie aus dem Substitutionsmuster. Das führt zur Form

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

Jetzt können wir jedoch beobachten, dass (.*)nur das Suffix des Strings danach erfasst wird 1<und wir dieses Suffix am Ende sogar mit erneut einfügen $1. Da die Substitutionssyntax uns die Möglichkeit gibt, nach einer Übereinstimmung mit auf den Teil einer Zeichenfolge zu verweisen, $'können wir einfach beide Teile weglassen und erhalten die in der Antwort verwendete Version:

1<
<<$'

Unterlast , 14 Bytes

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

Probieren Sie es online!

Unterlast-Vollprogramme können keine Eingaben über eine unserer definierten Methoden annehmen. Dies ist also eine Funktion, die Eingaben vom Stapel als Church-Zahl (die normale Methode zum Definieren von Ganzzahlen in Unterlast) nimmt und Ausgaben an den Stapel als Zeichenfolge erzeugt .

Die (…)Gruppierungsmarkierungen sind erforderlich, um dies zu einer Funktion (wiederverwendbar) und nicht zu einem Snippet (nur einmal verwendbar) zu machen. Der Wrapper in der TIO-Verknüpfung ruft die betreffende Funktion mit destruktiv auf ^, kann jedoch wiederverwendet werden, indem eine Kopie davon erstellt und beim Aufrufen nur eine der Kopien verwendet wird. Es liefert auch Eingaben in das Programm (hier, (:*:*)dh 4) und druckt die Ausgabe mit S.

Erläuterung

Unterlast ist überraschenderweise für diese Aufgabe geeignet, wenn Turing-Tarpits unterwegs sind und nützliche Primitive wie "copy" und "surround with parenthes" enthalten. (Irgendwie schlägt Underload, normalerweise eine sehr ausführliche Sprache, Mathematica, normalerweise eine Sprache, die aufgrund einer großen Anzahl von eingebauten Funktionen durch geeignetere eingebaute Funktionen gewinnt!) So funktioniert das Programm:

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

Die Funktionsexponentierung bewirkt effektiv, dass sich die Schritte der Funktion so oft wiederholen, z. B. (:a*) ³ (:a*:a*:a*). Das ist die idiomatische Art, eine Schleife zu schreiben, die sich in Underload so oft wiederholt. (Sie können feststellen, dass ~^dies auf zwei verschiedene Arten beschrieben wurde. Dies liegt daran, dass Ganzzahlen in Unterlast als auf diese Ganzzahl spezialisierte Funktionsexponentierung definiert sind. Um eine Funktionsexponentierung durchzuführen, versuchen Sie einfach, eine Ganzzahl so auszuführen, als wäre sie eine Funktion .)

Pari / GP , 23 Bytes

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

Probieren Sie es online!

APL (NARS), 15 Zeichen, 30 Byte

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

Prüfung:

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

Ich weiß nicht, ob dies akzeptiert werden würde ... Zilde ist ⍬ hier repräsentiert es die Leersammlung {}, wenn ich das Zilde-Element oder ein Element voller Zilde drucken möchte, und Zilde hat alles eingeschlossen, was passiert, ist, nichts zu drucken ... also, um zu sehen, Zilde muss man eine Funktion definieren, die ich es nenne o (o←⎕fmt ). Ich nicht in die Zählung ein, weil das Element und seine Struktur existieren, auch wenn das System sie nicht druckt. Es ist möglich, wenn io 0 ist

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

könnte auch 12 Zeichen Lösung sein ...

Brachylog , 14 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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

Beispielsweise:

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

Schläger 119 Bytes

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

Testen (In Racket {} ist dasselbe wie () und die Standardausgabe ist ()):

(f 4)

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

So sehen Sie jede Zahl deutlich (0 bis 3):

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

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

Batch, 74 Bytes

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

Verwendet die Tatsache, dass jede Antwort gleich der vorherigen Antwort ist, die nach der führenden in sich eingefügt wurde {. Die ersten Ausgaben lauten wie folgt:

{}

{{}}

{{{}}{}}

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

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

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