Una bambola nidificante russa, più comunemente nota come bambola matrioska , è una bambola che contiene una versione più piccola di se stessa, ^{che contiene quindi un'altra versione più piccola di se stessa, che contiene una versione più piccola di se stessa, che contiene una versione più piccola di se stessa, che contiene una versione più piccola di se stesso ...} - fino a quando l'ultimo è vuoto. Un esempio:

Oggi il tuo obiettivo è emulare questa tradizione russa scrivendo un programma o una funzione che, quando si contiene N volte, si stamperà contenente N-1 copie di se stesso volte.

Ad esempio, il programma bambola abcdavrà il programma N = 3 abababcdcdcd, che stamperà il programma N = 2 ababcdcd, che stampa il programma N = 1 originale abcd, che infine stampa N = 0, che è vuoto. Questo dovrebbe teoricamente funzionare per qualsiasi valore ragionevole di N.

Regole:

• Ecco un programma TIO per aiutarti a generare programmi per bambole in base al tuo programma
• Si applicano le regole standard di Quine
• Si applicano scappatoie standard
• 'Contiene' significa direttamente al centro della versione precedente, quindi la soluzione deve avere un numero pari positivo di byte. Un programma di lunghezza 10 avrà una copia dell'originale inserito dopo il quinto byte, quindi un altro dopo il decimo byte ecc.
• Nell'output è consentito un singolo spazio bianco finale
• Dato che si tratta di code-golf , il tuo obiettivo è rendere il tuo programma N = 1 il più breve possibile.
• Una spiegazione del tuo codice sarebbe apprezzata

Sottocarico , 4 byte

N = 1: provalo online.

 ()S

N = 2: provalo online.

 ( ()S)S

N = 3: provalo online.

 ( ( ()S)S)S

Spiegazione:

Autoesplicativo, ma lo aggiungo comunque.

• (...)S stampa qualsiasi cosa tra parentesi su STDOUT
• Lo spazio che precede è un no-op per rendere il conteggio dei byte pari e rispettare le regole della sfida.

JavaScript, 36 32 byte

Sfrutta il fatto che Function.prototype.toString()non accetta argomenti e quindi ignora quelli che gli sono passati.

In parte ispirato dalla soluzione di user202729 .

f=_=>f.toString( ).slice(14,-16)

Provalo

o.innerHTML=["<span>Five</span>",(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString( ).slice(14,-16) ).slice(14,-16) ).slice(14,-16) ).slice(14,-16) ).slice(14,-16))(),"<span>Four</span>",(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString( ).slice(14,-16) ).slice(14,-16) ).slice(14,-16) ).slice(14,-16))(),"<span>Three</span>",(f=_=>f.toString(f=_=>f.toString(f=_=>f.toString( ).slice(14,-16) ).slice(14,-16) ).slice(14,-16))(),"<span>Two</span>",(f=_=>f.toString(f=_=>f.toString( ).slice(14,-16) ).slice(14,-16))(),"<span>One</span>",(f=_=>f.toString( ).slice(14,-16))(),"<span>Thunderbirds Are Go!</span>"].join`\n`

span{font-weight:bold;font-size:16px;line-height:1.5em;text-transform:uppercase;}span:last-child{font-size:8px;}

<pre id=o></pre>

JavaScript (Node.js) , 46 byte

Programma completo. Quindi console.logè necessario.

Utilizzare un'idea da questa risposta per salvare alcuni byte.

l=console.log;   g=_=>{};l((''+g).slice(4,-1))

Provalo online! Provalo online due volte! Provalo online, tre volte!

Il mio approccio è simile a quello utilizzato nella risposta di Kevin Cruijssen , trovare una struttura annidabile (una funzione in questo caso).

Gelatina , 16 byte

Ṿḣ-9Ḋð}“““““““““

Provalo online!

Raddoppiato: provalo online!

Triplicato: provalo online!

Jelly non ha alcuna struttura annidabile, ma i suoi letterali stringa sono auto-terminati.

Ṿḣ-9Ḋ    First chain. (monadic)
Ṿ        UneṾal. (to string)
 ḣ-9     Take the ḣead, ends at the -9'th character.
    Ḋ    Ḋequeue, remove the first character.

     ð             Terminate the first chain, start a new one.
      }            Convert the last monadic chain to a dyadic one.
       “““““““““   String literal.
                   This matches the pattern <dyad> <nilad>, so applies
                   the the corresponding rules. This way a link can take data
                   to the right of it.

Proverà approcci diversi per vedere se possono essere più brevi.

DipDup , 2 byte

[]

Spinge l'elenco nello stack e lo stampa senza le parentesi più esterne.

N = 1: provalo online!

N = 2: provalo online!

N = 3: provalo online!

dc , 4 byte

 []p

Analogamente ad altre risposte, poiché le stringhe dchanno delimitatori start ( [) e end ( ]) (ovvero, "non eseguono entrambi i compiti, ecc.), Sono annidabili senza alcuno sforzo reale. pper stampare.

N = 1: provalo online!

N = 2: provalo nidificato!

N = 3: provalo nesteder!

Tcl , 12 byte

puts {}     

Provalo online!

È solo un'altra lingua che ha anche questo.