Diese Konstruktion repräsentiert die natürlichen Zahlen.

In dieser Darstellung ist 0 als leere Menge definiert und für alle anderen Zahlen ist n die Vereinigung von {0} und {n-1}.

Um beispielsweise 3 zu konstruieren, können wir dem Algorithmus folgen:

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

Aufgabe

Wie Sie vielleicht erraten haben, besteht Ihre Aufgabe darin, eine natürliche Zahl (einschließlich Null) aufzunehmen und ihre Konstruktion auszugeben.

Sie können entweder als Zeichenfolge oder als festgelegtes Objekt ausgeben, wenn Ihre Sprache solche Objekte unterstützt.

Wenn Sie sich für die Ausgabe als Zeichenfolge entscheiden, sollten Sie einen Satz mit geschweiften Klammern ( {}) darstellen. Optional können Sie die leere Menge als darstellen ø(andernfalls sollte es sich um eine Menge ohne Einträge handeln {}). Sie können auch Kommas und Leerzeichen zwischen und nach den Einträgen in der Gruppe einfügen.

Bestellen Sie ist nicht wichtig, aber Sie können nicht irgendwelche sich wiederholende Elemente in den Sätzen Sie Ausgang (zB {ø,ø})

Das ist Code-Golf, also ist das Ziel, die wenigsten Bytes zu haben

Testfälle

Hier sind einige Testfälle mit einigen Beispielausgaben.

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

Python , 28 Bytes

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

Probieren Sie es online!

Dies ist eine ziemlich fade Lösung für das Problem. Für Zahlen größer als Null können Sie die Darstellung mit der Zeichenfolgenformel erhalten "{{}"*x+"}"*x. Dies funktioniert jedoch nicht für Null, wenn dies die leere Zeichenfolge ist. Wir können diese Tatsache nutzen, um einen Kurzschluss orzu verursachen und den leeren Satz zurückzugeben.

Ich wollte Pythons eingebaute Set-Objekte verwenden, um dieses Problem zu lösen, aber leider:

TypeError: unhashable type: 'set'

Sie können Sets nicht in Sets in Python einfügen.

Haskell , 37 Bytes

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

Probieren Sie es online!

Bis vor 10 Minuten hätte eine Antwort wie diese keinen Sinn für mich ergeben. Alle Credits gehen auf diese Tippantwort .

Grundsätzlich verwenden wir >>as concat $ replicate(aber übergeben ihm eine Liste mit n Elementen anstelle von einfach n) und =<<as , wobei wir concatMapdann jede Zeichenfolge in der Liste n-mal replizieren und das Ergebnis in eine einzelne Zeichenfolge verketten.

Der 0Fall wird separat behandelt, als würde er eine leere Zeichenfolge zurückgeben.

JavaScript, 28 Bytes

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

Stellt Mengen mithilfe von Arrays dar. Nicht rekursive 38-Byte-Lösung:

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

Gibt die Beispielausgabezeichenfolgen zurück.

Mathematica, 27 Bytes

Bei dieser Anzahl von Bytes habe ich zwei Lösungen:

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

Perl 6 , 37 Bytes

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

Versuch es

Erweitert:

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

Code

ƒ)¯sÙ

Verwendet die CP-1252- Codierung. Probieren Sie es online! oder Überprüfen Sie alle Testfälle! .

Erläuterung

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

Netzhaut , 22 Bytes

.+
$*
\`.
{{}
{

^$
{}

Probieren Sie es online!

Erläuterung

.+
$*

Konvertieren Sie die Eingabe in Unary.

\`.
{{}

Ersetzen Sie jede unäre Ziffer durch {{}und drucken Sie das Ergebnis ohne nachfolgenden Zeilenvorschub ( \).

{

Entfernen Sie die Öffnungen {, damit die verbleibenden }genau diejenigen sind, die noch gedruckt werden müssen, um alle Sätze zu schließen. Das obige Verfahren schlägt jedoch bei Eingaben fehl 0, bei denen wir nichts drucken würden. So...

^$
{}

Wenn die Zeichenfolge leer ist, ersetzen Sie sie durch die leere Menge.

Brain-Flak , 135 Bytes

Beinhaltet +1 für -A

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

Probieren Sie es 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 Bytes

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

CJam , 11 Bytes

Lri{]La|}*p

Druckt ein satzartiges Objekt, das aus Listen von Listen besteht. CJam druckt leere Listen als leere Zeichenfolgen, da Listen und Zeichenfolgen fast austauschbar sind.

Probieren Sie es online!

Erläuterung

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

Alte Antwort, 21 18 Bytes

Dies war, bevor bestätigt wurde, dass das Drucken einer verschachtelten Listenstruktur in Ordnung war. Verwendet den Algorithmus für die Zeichenfolgenwiederholung.

3 Bytes gespart dank Martin Ender!

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

Erläuterung

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.

Gelee , 6 Bytes

⁸,⁸Q$¡

Dies ist eine niladische Verknüpfung, die eine Ganzzahl aus STDIN liest und ein unregelmäßiges Array zurückgibt.

Probieren Sie es online!

Wie es funktioniert

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

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

Nicht der kürzeste Weg, aber ich musste dies nur mit Rekursion tun.

Probieren Sie es online!

Kardinal , 51 Bytes

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

Probieren Sie es online!

Erläuterung

%:#
x

Eingaben empfangen und von der # nach unten und links senden

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

"{" Einmal drucken, dann "{} {" n-1 mal drucken, wenn n> 1, dann "{}" drucken, wenn n> 0

       #

v <8/ ?<
>  8\

Halten Sie den Eingabewert fest, bis die erste Schleife abgeschlossen ist

v"}"<
>?-?^

Gib "}" einmal aus und wiederhole dann n-1 mal, wenn n> 1 ist

AHK, 55 Bytes

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

Es ist nicht die kürzeste Antwort, aber ich habe es genossen, weil die Eigenheiten von AutoHotkey diese Rekursionsmethode super falsch aussehen lassen . Ifund LoopAnweisungen gehen davon aus, dass die nächste Zeile das einzige ist, was enthalten ist, wenn keine Klammern verwendet werden. Geschweifte Klammern sind Escape-Zeichen, daher müssen Sie sie mit anderen geschweiften Klammern maskieren, um sie als Text zu verwenden. Die Variable 1ist auch das erste übergebene Argument. Wenn ich den Code lese, ohne diese Leckerbissen zu kennen, sieht die Logik folgendermaßen aus :

• Wenn 1 = 0, dann setze sgleich die falsche Antwort
• Machen Sie eine Schleife und fügen Sie jedes Mal ein paar Klammern am Anfang und ein paar am Ende hinzu
• Zurück, indem Sie die resultierende Zeichenfolge an das aktuelle Fenster senden

Ohne alle Klammer-Escape-Zeichen würde das so aussehen:

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

JavaScript 50 Bytes

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

tinylisp , 52 bytes

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

Probieren Sie es online! (Testgeschirr).

Erläuterung

Beachten Sie, dass (cons x (cons y nil))Sie auf diese Weise eine Liste mit xund yin Lisp erstellen .

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

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

Nutzen Sie einige Kurzschlussauswertung und Rekursion.

Probieren Sie es online!

Pure Bash , 49 48 41 Bytes

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

Probieren Sie es online!

Gleichstrom , 46 Bytes

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

Probieren Sie es online!

Input on stdin, Output on stdout.

Dies funktioniert, indem eine Formel für die gewünschte Ausgabe als Basis-256-Zahl berechnet wird. Der Befehl P in dc wird dann verwendet, um die Basis-256-Zahl als Zeichenfolge auszudrucken.

Weitere Erklärung:

Sei n die Eingabe n. Das DC-Programm berechnet die Summe von

A = Etage (256 ^ n / 255) * 125 (BF wird von dc als 11 * 10 + 15 = 125 interpretiert)

und

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

Für ein:

Beachten Sie, dass 1 + 256 + 256 ^ 2 + ... + 256 ^ (n-1) nach der Formel für einen geometrischen Verlauf (256 ^ n-1) / 255 entspricht, und dies entspricht dem Wert für floor (256 ^ n / 255) ). Das ist also die Zahl, die aus n Einsen in der Basis 256 besteht.

Wenn Sie es mit 125 multiplizieren, um A zu erhalten, ist das Ergebnis die Zahl, die aus n 125 in der Basis 256 besteht (125 ist natürlich eine einzelne Ziffer in der Basis 256). Es ist wahrscheinlich besser, die Ziffern in Basis 256 als Hexadezimalzahlen zu schreiben. 125 ist hex 7D, also ist A die Basis-256-Zahl, die aus n 7Ds in einer Reihe besteht.

B ist ähnlich:

Diesmal ist zu beachten, dass 1 + 16777216 + 16777216 ^ 2 + ... + 16777216 ^ (n-1) gleich (16777216 ^ n - 1) / 16777215 ist, und dies entspricht Floor (16777216 ^ n / 16777215).

Nun, 256 ^ 3 = 16777216 und 8 ^ 8-1 = 16777215, also berechnen wir dies als Floor ((256 ^ n) ^ 3 / (8 ^ 8-1)).

Aus der geometrischen Reihendarstellung ergibt sich für die Basis 256 eine Zahl von 100100100 ... 1001, wobei n der Ziffern 1 und der Rest der Ziffern 0 sind.

Dies wird mit 8092541 multipliziert, was hexadezimal 7B7B7D ist. In der Basis 256 ist dies eine dreistellige Zahl, die aus den Ziffern 7B, 7B und 7D besteht (diese Ziffern werden der Einfachheit halber hexadezimal geschrieben).

Daraus folgt, dass das in die Basis 256 geschriebene Produkt eine 3n-stellige Zahl ist, die aus den 3 Ziffern 7B, 7B, 7D besteht, die n-mal wiederholt werden.

Dies wird mit 256 ^ n multipliziert, was zu einer 4n-stelligen Basis-256-Zahl führt, die aus den 3 Ziffern 7B, 7B, 7D besteht, die n-mal wiederholt werden, gefolgt von n 0en. Das ist b

Das Addieren von A + B ergibt nun die 4n-stellige Basis-256-Zahl, die aus den 3 Ziffern 7B, 7B, 7D besteht, die n-mal wiederholt werden, gefolgt von n 7D. Da 7B und 7D die ASCII-Codes für {und sind} , ist dies der String, der aus n Kopien von {{}gefolgt von n Kopien von besteht. Dies ist }genau das, was wir für n> 0 wollen. Der P-Befehl in dc gibt eine Base-256-Zahl aus als schnur, so wie wir sie brauchen.

Leider muss n = 0 als Sonderfall behandelt werden. Die obige Berechnung ergibt zufällig ein Ergebnis von 0 für n = 0; In diesem Fall habe ich den Druck der Zeichenfolge nur hartcodiert {}.

Java 7, 61 Bytes

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

Probieren Sie es online!

Stapel, 88 Bytes

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

Brainf *** , 99 Bytes

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

(Newline für Ästhetik) Da es sich um Brainf *** handelt, werden Eingaben als ASCII-Zeichencodes verwendet (Eingabe "a" entspricht 96).

Braineasy, 60 Bytes

Auch in meiner benutzerdefinierten Sprache (brainf ** basiert, Dolmetscher hier ):

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

Sie müssen die Programmeingabe in den Interpreter fest codieren, weil ich faul bin.

05AB1E , 5 3 Bytes

F¯)

Probieren Sie es online!

Diese Version ist, nachdem er klargestellt hat, dass Sets in Ordnung sind.

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

Alte Version (die ø verwendet):

05AB1E , 5 4 Bytes

FX¸)

Probieren Sie es online!

Wo 1ist gleichbedeutend mit ø.

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.