I numeri naturali compreso 0 sono definiti formalmente come set, nel modo seguente :

• Il numero 0 è definito come set vuoto, {}
• Per n ≥ 0, il numero n +1 è definito come n ∪ { n }.

Di conseguenza, n = {0, 1, ..., n -1}.

I primi numeri, definiti da questa procedura, sono:

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

Sfida

Dato n , emette la sua rappresentazione come un insieme.

Regole

L'uscita può sempre usare qualsiasi staffa personaggio così come {}, [], ()o <>. Personaggi arbitrari (come01 ) non sono ammessi.

Invece di una virgola come sopra, il separatore può essere qualsiasi segno di punteggiatura; o potrebbe essere inesistente.

Gli spazi (non le nuove righe) possono essere inclusi in modo arbitrario e incoerente.

Ad esempio, il numero 2 con parentesi quadre e punto e virgola come separatore è [[]; [[]]], o equivalentemente [ [ ]; [ [ ] ] ], o pari[ [ ] ;[ []]]

L' ordine in cui sono specificati gli elementi di un set non ha importanza. Quindi puoi usare qualsiasi ordine nella rappresentazione. Ad esempio, questi sono alcuni output validi per 3:

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

È possibile scrivere un programma o una funzione . L'output può essere una stringa o, se si utilizza una funzione, è possibile restituire un elenco o un array nidificati la cui rappresentazione di stringa è conforme a quanto sopra.

Casi test

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

Gelatina , 3 byte

Ḷ߀

Questo è un collegamento monadico. Provalo online!

Come funziona

Ogni numero naturale è l'insieme di tutti i numeri naturali precedenti, ovvero n = {0,…, n-1} . Poiché non ci sono numeri naturali che precedono 0 , abbiamo 0 = {} .

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

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

Python 2, 26 byte

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

Provalo su Ideone .

JavaScript (ES6), 32 byte

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

Abbastanza semplice.

Perl 6 , 16 byte

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

Restituisce la struttura dati nidificata.

Esempio:

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

Spiegazione:

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

}

Rubino, 27 21 byte

Sono nuovo nel golf ruby, ma qui non c'è niente. Grazie alla Giordania per aver salvato 6 byte!

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

Questa è una funzione ricorsiva f(un proc, per essere precisi) e accetta un argomento s. Mappa il proc fsu 0...s, che è l'intervallo [0, s).

Haskell, 32 27 byte

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

Provalo su Ideone.

CJam , 14 byte

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

Provalo online!

Spiegazione

"[]"            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 ogni iterazione, il blocco costruisce la rappresentazione di un numero da quello del precedente. Per illustrare, consideriamo la seconda iterazione, in cui la rappresentazione del numero 2è costruita da quella di 1, che è la stringa "[[]]".

1. La pila contiene "[[]]"
2. Dopo l'istruzione _(duplicato) che contiene "[[]]","[[]]"
3. Dopo la dichiarazione )(uncons) contiene "[[]]", "[[]","]"
4. Dopo la rilevazione @(Ruota) contiene "[[]", "]","[[]]"
5. Dopo la rilevazione \(swap) che contiene "[[]", "[[]]","]"
6. ]Contiene l' istruzione after (pack in array) ["[[]" "[[]]" "]"], che verrebbe visualizzata come stringa "[[][[]]]".

Cheddar, 17 byte

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

Breve ricorsione + Breve raggio + Breve iterazione = Una sfida in cui il cheddar fa molto bene

Non competitivo, 11 byte

n f->|>n=>f

L' =>operatore è stato aggiunto dopo il rilascio di questa sfida rendendo questa risposta non competitiva.

Questo può sembrare confuso ma permettimi di semplificarlo:

n f -> |> n => f

fondamentalmente nè l'input ed fè la funzione stessa. |>ngenera [0, n) e =>mappa oltre f.

05AB1E , 8 7 byte

)IF)©`®

Spiegazione

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

Provalo online!

Salvato 1 byte grazie ad Adnan.

Pyth, 4 byte

LyMb

Suite di test

L: Definisce la funzione ycon inputb

yMb: ymappato sull'intervallo0, 1, ..., b-1

Sull'ingresso 0, questa mappa ritorna []. Altrimenti, restituisce ymappato su tutti i numeri fino a b.

MATL , 13 byte

Xhi:"tY:Xh]&D

Provalo online!

Spiegazione

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 byte

Include +1 per -p

Molti metodi diversi sembrano finire come 27 o 28 byte. per esempio

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

Il meglio che ho trovato è

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

poiché su perls più vecchi è possibile eliminare lo spazio prima di fore ottenere 26 byte

Mathematica, 14 byte

Array[#0,#,0]&

Mathematica, 31 byte

Implementa direttamente la definizione come un elenco nidificato. Utilizza una funzione senza nome che si chiama ricorsivamente usando se stessa #0.

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

Retina , 24 18 byte

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

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

.+
$*1<>

Questo converte l'input in unario e aggiunge <>, la rappresentazione di 0.

+`1<
<<$'

Qui, +indica che questa sostituzione deve essere eseguita in un ciclo fino a quando la stringa non smette di cambiare. È più facile spiegarlo seguendo i singoli passaggi che ho seguito giocando a golf. Facciamo con questa versione della sostituzione:

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

Questo corrisponde all'ultima 1rappresentazione unaria dell'input rimanente (per rimuoverlo e decrementare l'input), così come il contenuto dell'insieme corrente alla fine. Questo viene quindi sostituito con un nuovo set contenente quello precedente e il suo contenuto. Tuttavia, possiamo notare che $1è seguito >in entrambi i casi e quindi possiamo includerlo nella cattura stessa e ometterlo dal modello di sostituzione. Questo porta al modulo

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

Tuttavia, ora possiamo osservare che (.*)dopo acquisisce il suffisso della stringa 1<e reinseriamo questo suffisso alla fine con $1. Poiché la sintassi di sostituzione ci dà un modo per fare riferimento alla parte di una stringa dopo una corrispondenza con $', possiamo semplicemente omettere entrambe le parti e finire con la versione utilizzata nella risposta:

1<
<<$'

Sottocarico , 14 byte

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

Provalo online!

I programmi completi di underload non possono ricevere input tramite nessuno dei nostri metodi definiti, quindi questa è una funzione che accetta input dallo stack come un numero Church (il modo normale per definire numeri interi in Underload) e produce output nello stack come una stringa .

I (…)marker di raggruppamento sono richiesti per rendere questa una funzione (riutilizzabile) piuttosto che uno snippet (utilizzabile una sola volta). Il wrapper nel collegamento TIO chiama la funzione in questione in modo distruttivo utilizzando ^, ma potrebbe essere riutilizzato facendone una copia e consumando solo una delle copie quando la chiama. Fornisce inoltre input al programma (qui (:*:*), ad esempio 4) e stampa l'output utilizzando S.

Spiegazione

Underload è sorprendentemente adatto a questo compito mentre vanno i tarpit di Turing, con primitivi utili come "copia" e "circonda tra parentesi". (In qualche modo, Underload, normalmente un linguaggio molto dettagliato, sta battendo Mathematica, normalmente un linguaggio che vince a causa del fatto di avere un enorme set di builtin, tramite avere builtin più appropriati!) Ecco come funziona il programma:

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

L'esponenziazione della funzione fa sì che i passaggi della funzione si ripetano più volte, quindi, ad esempio, (:a*)sarebbe ³ (:a*:a*:a*). Questo è il modo idiomatico di scrivere un ciclo che si ripete un dato numero di volte in Underload. (Puoi notare che il ~^metodo è descritto in due modi diversi sopra; questo perché gli interi in Underload sono definiti come esponenziali della funzione specializzati in quell'intero, quindi per fare una esponenziazione delle funzioni, devi semplicemente provare a eseguire un intero come se fosse una funzione .)

Pari / GP , 23 byte

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

Provalo online!

APL (NARS), 15 caratteri, 30 byte

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

Non so se questo sarebbe accettato ... Zilde è ⍬ qui rappresenta il set di vuoti {} se voglio stampare l'elemento Zilde o un elemento pieno di Zilde, e Zilde racchiude tutto ciò che accade è stampare nulla ... quindi per vedere Zilde bisogna definire una funzione che io chiamo o (o←⎕fmt ) non inserisco nel conteggio perché l'elemento e la sua struttura esistono anche se il sys non lo stampa ... È possibile se io è 0

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

potrebbe anche essere una soluzione di 12 caratteri ...

Brachylog , 14 byte

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

Provalo online!

Spiegazione

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 byte

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

Per esempio:

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

Racchetta 119 byte

(λ(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 (In Racket {} è uguale a () e l'output predefinito è ()):

(f 4)

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

Per vedere chiaramente ogni numero (da 0 a 3):

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

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

Lotto, 74 byte

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

Usa il fatto che ogni risposta è uguale alla risposta precedente inserita in se stessa dopo la prima {. Le prime uscite sono le seguenti:

{}

{{}}

{{{}}{}}

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

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

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