Dato un livello di nidificazione di numeri interi positivi ne una stringa sdi caratteri ASCII stampabili ( a ~, genera un programma che, quando eseguito nella stessa lingua, genera un programma che genera un programma ... che genera la stringa s.

nDovrebbero essere generati un totale di programmi, che dovrebbero essere eseguiti nella stessa lingua della risposta.

Nota: è possibile emettere programmi o funzioni, tutto ciò che è consentito per impostazione predefinita come invio.

Puoi inserire scon caratteri di escape, come un programma o una funzione nella tua lingua in genere inseriscono una stringa.

Esempio

Ad esempio, dato n=1e s="recursion", un programma Python 2 potrebbe produrre:

print "recursion"

L'esecuzione di questo produrrebbe:

recursion

Dato n=2e s = "PPCG", un programma Python 2 potrebbe generare:

print "print \"PPCG\" "

Esecuzione di questo output:

print "PPCG"

Esecuzione di questo output:

PPCG

Correlati (+ titolo ispiratore): ancora una volta LUL e sono fuori

Anche correlato (nella sandbox - ora eliminato, ma può ancora essere visualizzato con sufficiente reputazione): ricorsione del codice sorgente

Casi test

Assicurarsi che il codice funzioni per i seguenti casi di test (uno per riga):

n s
2 PPCG
4 Robert'); DROP TABLE Students;--
17 Deep
2 Spaces In Here
3 "Don't forget quotes!"
5 'Backt`cks might be a h`tch'
6 5%s
8 [Brackets]<Are>(Great){Usually}
3 !"#$%&'()*+,-./ 0123456789:;<=>?@ABCDEFGHIJKLMN
6 OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
7 THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
3 the quick brown fox jumps over the lazy dog

Gelatina , 2 byte

Ṿ¡

Provalo online!

Ṿ¡  Main link; left argument (text) is x, right argument (repetitions) is y
 ¡  Repeat y times:
Ṿ   Uneval x; produce code that outputs x

hehe builtins

JavaScript (ES6), 47 44 byte

Salvato 3 byte grazie a @HermanLauenstein

Accetta input nella sintassi del curry (n)(s).

n=>g=s=>`alert(atob("${btoa(--n?g(s):s)}"))`

Esempio

f(2)('PPCG')

Uscita:

'alert(atob("YWxlcnQoYXRvYigiVUZCRFJ3PT0iKSk="))'

Che stamperà:

'alert(atob("UFBDRw=="))'

Che stamperà:

'PPCG'

dimostrazione

Un esempio più complesso in cui alert()è stato ignorato in modo che i risultati intermedi vengano stampati sulla console ed eseguiti automaticamente.

let f =

n=>g=s=>`alert(atob("${btoa(--n?g(s):s)}"))`

alert = s => { console.log(s); try { eval(s); } catch(e) {} }

alert(f(5)("'Backt`cks might be a h`tch'"));

Versione alternativa, 40 byte

Suggerito da @Shaggy

Questo restituisce una funzione anonima anziché un programma completo.

n=>g=s=>`_=>atob("${btoa(--n?g(s):s)}")`

sh + coreutils, 31 byte

yes exec sed 1d \$0|sed $1q;cat

Accetta ncome parametro della riga di comando e ssu STDIN.

Python 2 , 40 byte

f=lambda r,t:r and"print%r"%f(r-1,t)or t

Provalo online!

-4 byte grazie a xnor

Haskell, 17 byte

A partire da quando scrivo questo, questa è la risposta più breve per un linguaggio non specifico per il golf .

È una funzione che accetta se nin quell'ordine e restituisce il risultato o il codice sorgente di un'espressione che, quando valutato, restituisce il codice sorgente successivo.

(!!).iterate show

Argomento per cui questo conta:

1. Le soluzioni possono essere funzioni.
2. Le loro uscite possono essere funzioni.
3. Queste funzioni non hanno parametri.
4. In Haskell, dato che è pigro e tutto è curry, il più naturale - ai fini della programmazione pratica - la definizione di una funzione con parametro 0 è la stessa del suo risultato; l'alternativa più vicina, una funzione a 1 parametro che ignora il parametro, è sciocca.

Se fè dato PPCGe 2come i suoi parametri, il risultato è il testo "\"PPCG\""(prima funzione generata), che quando valutato restituisce il testo "PPCG"(seconda funzione generata), e quando viene valutato restituisce PPCG.

Grazie a nimi per aver suggerito un accorciamento.

APL (Dyalog) , 24 23 byte

-1 grazie a ngn.

Questo è un programma completo che richiede se quindi nstampa e stampa su STDOUT.

''''{⍺,⍨⍺,⍵/⍨1+⍵=⍺}⍣⎕⊢⍞

Provalo online! (il caso Deep 17 viene omesso poiché supera il limite di output di TIO - funziona offline)

⍞ richiedere s

⊢ cedere che (separare ⎕e ⍞)

''''{... }⍣⎕ richiede ne applica questo lambda con una sola citazione come argomento sinistro che molte volte. ⍺sta per l'argomento di sinistra (la citazione) ed ⍵è l'argomento di destra (il testo di input):

 ⍵=⍺ Booleano in cui il testo è uguale a una citazione

 1+ Aggiungi uno

 ⍵/⍨ replicare ogni carattere dell'argomento il numero corrispondente di volte

 ⍺, anteporre un preventivo

 ⍺,⍨ aggiungere un preventivo

Ciò funziona perché le stringhe in APL sono 'delimitate e le virgolette singole nelle stringhe sono raddoppiate, mentre nessun altro carattere deve essere sottoposto a escape.

Dyalog APL viene inoltre fornito con un'utilità ( ⎕SE.Dyalog.Utils.repObj) che genera un'espressione APL che valuta il suo argomento (simile al diseguale di Jelly ). Il seguente programma è quindi equivalente a quanto sopra, ma funziona per tutti gli array:

⎕SE.Dyalog.Utils.repObj⍣⎕⊢⎕

Provalo online!

Firefox JavaScript, 41 35 byte

f=(s,n)=>"_=>"+uneval(--n?f(s,n):s)

Firefox ha un bel uneval, che fa quello che sembra - annulla un determinato oggetto, in questo caso - stringa.

Java 8, 95 93 byte

String c(String s,int n){return"v->\""+(n-->1?c(s,n).replaceAll("[\\\\\"]","\\\\$0"):s)+'"';}

-2 byte grazie a @Lynn .

Fuggire personaggi speciali è così fastidioso in Java ..

Provalo qui e prova qui il metodo risultante .

Spiegazione:

String c(String s,int n){  // Method with String and int parameters and String return-type
  return"v->\""+           //  Return literal "v->" + a leading double-quote +
   (n-->1?                 //   If `n` is larger than 1:
     c(s,n)                //    Recursive-call,
      .replaceAll("[\\\\\"]","\\\\$0")
                           //    with all double-quotes ('"') and slashes ('\') escaped
    :                      //   Else:
     s)                    //    The input String
   +'"';                   //   + a trailing double quote
}                          // End of method 

Spiegazione aggiuntiva per la sostituzione di regex:

.replaceAll("[\\\\\"]","\\\\$0")
.replaceAll("        ","      ")  // Replace the match of the 1st String, with the 2nd
             [      ]             //  One of these inner characters:
              \\\\                //   Escaped slash ('\')
                  \"              //   Escaped double-quote ('"')
                                  //  And replace them with:
                        \\\\      //   Escaped slash ('\'),
                            $0    //   plus found match

Perché tutte queste barre?

\   →  \\       // Escapes a single slash for the regex
\\  →  \\\\     // Escapes both regex-escaped slashes for the String
"   →  \"       // Escapes a double-quote for the String

Sottocarico , 11 byte

(a(S)*)~^^S

Provalo online!

L'input deve iniziare in pila, con il numero in alto sotto forma di un numero di chiesa . Non so se questo è un metodo di input valido, ma la specifica non ha input e posizionare l'input nella parte superiore dello stack sembra un metodo bloccato utilizzato in tali lingue.

GolfScript , 5 byte

~{`}*

Provalo online!

QuadR , 8 byte

Traduzione semplice della risposta di ngn .

Prende ncome argomento e scome input.

^|'|$
'&

Provalo online!

PCRE R EPosizionare tutte le istanze di

^|'|$ Inizio riga O Preventivo O Fine riga

'& con un preventivo e l'intera partita

L'argomento specifica quante volte ripetere la trasformazione.

R , 62 byte

f=function(n,s){"if"(n,{formals(f)$n=n-1;formals(f)$s=s;f},s)}

Provalo online!

Chiamalo così: f(n,s)seguito dan copie di()

Una funzione denominata; restituisce una funzione anonima. Tutto ciò che fa è modificare i valori predefiniti di formalsof f, consentendo di chiamare la funzione risultante (e quindi il risultato di quella chiamata, nvolte). quando nraggiunge 0, ritornas .

R in realtà non è poi così male a fuggire! Utilizza l'escaping in stile C, quindi devi solo prendere l'input, sostituirlo "con \"e \con \\e quindi avvolgere il tutto " ".

Pyth, 21 byte

L++NsXbJ,N\\+L\\JNyFz

Provalo qui.

Sfortunatamente la funzione ricorsiva (non programma completo come sopra) è più lunga (24 byte):

M?GgtG++NsXHJ,N\\+L\\JNH

APL (Dyalog Classic) , 19 byte

'^|''|$'⎕r'''&'⍣⎕⊢⍞

Provalo online!

Rubino , 34 byte

%pè un flag printf specifico di Ruby che ottiene il inspectvalore del suo argomento, simile a quello %rin Python. $><<significa stampa.

f=->n,s{"$><<%p"%(n>1?f[n-1,s]:s)}

Provalo online!

Excel VBA (32 bit), 67 byte

Versione limitata a VBA Excel a 32 bit perché viene 2^ivalutata senza errori in VBA a 32 bit, ma non in VBA a 64 bit

Funzione di finestra immediata VBE anonima che accetta input ne sda intervalli [A1]e [B1]restituisce una funzione anonima che, se valutata fino a un solo terminale (dopo niterazioni), genera solo squel terminale

For i=0To[A1-1]:q=q+"?"+String(2^i,34):Next:?q[B1]Replace(q,"?","")

Ingresso / uscita campione

[A1:B1]=Array(7, "PPCG")
For i=0To[A1-1]:q=q+"?"+String(2^i,34):Next:?q[B1]Replace(q,"?","")
?"?""?""""?""""""""?""""""""""""""""?""""""""""""""""""""""""""""""""?""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""PPCG"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
?"?""?""""?""""""""?""""""""""""""""?""""""""""""""""""""""""""""""""PPCG"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
?"?""?""""?""""""""?""""""""""""""""PPCG"""""""""""""""""""""""""""""""
?"?""?""""?""""""""PPCG"""""""""""""""
?"?""?""""PPCG"""""""
?"?""PPCG"""
?"PPCG"
PPCG