Dado un nivel de anidamiento de entero positivo ny una cadena sde caracteres ascii imprimibles ( para ~generar un programa que, cuando se ejecuta en el mismo idioma, genera un programa que genera un programa ... que genera la cadena) s.

Se ndebe generar un total de programas, todos los cuales se deben ejecutar en el mismo idioma que su respuesta.

Nota: puede generar programas o funciones, cualquier cosa que se le permita de forma predeterminada como envío.

Puede ingresar scon caracteres de escape, cómo un programa o función en su idioma generalmente ingresará una cadena.

Ejemplo

Por ejemplo, dado n=1y s="recursion", un programa Python 2 podría generar:

print "recursion"

Ejecutar esto generaría:

recursion

Dado n=2y s = "PPCG", un programa Python 2 podría generar:

print "print \"PPCG\" "

Ejecutando estas salidas:

print "PPCG"

Ejecutando estas salidas:

PPCG

Relacionado (+ inspiración del título): un LUL más y estoy fuera

También relacionado (en sandbox, ahora eliminado, pero aún se puede ver con suficiente reputación): Recursión de código fuente

Casos de prueba

Asegúrese de que su código funcione para los siguientes casos de prueba (uno por línea):

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

Jalea , 2 bytes

Ṿ¡

Pruébalo en línea!

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

jeje incorporado

JavaScript (ES6), 47 44 bytes

Guardado 3 bytes gracias a @HermanLauenstein

Toma entrada en la sintaxis de curry (n)(s).

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

Ejemplo

f(2)('PPCG')

Saldrá:

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

Que imprimirá:

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

Que imprimirá:

'PPCG'

Manifestación

Un ejemplo más complejo donde alert()se ha anulado para que los resultados intermedios se impriman en la consola y se ejecuten automáticamente.

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'"));

Versión alternativa, 40 bytes.

Sugerido por @Shaggy

Este devuelve una función anónima en lugar de un programa completo.

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

sh + coreutils, 31 bytes

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

Toma ncomo parámetro de línea de comandos y sen STDIN.

Python 2 , 40 bytes

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

Pruébalo en línea!

-4 bytes gracias a xnor

Haskell, 17 bytes

A partir de cuando escribo esto, esta es la respuesta más corta para un lenguaje no específico de golf .

Es una función que toma sy nen ese orden, y devuelve el resultado o el código fuente de una expresión que, cuando se evalúa, devuelve el siguiente código fuente.

(!!).iterate show

Argumento de por qué esto cuenta:

1. Se permite que las soluciones sean funciones.
2. Sus salidas pueden ser funciones.
3. Esas funciones no tienen parámetros.
4. En Haskell, dado que es perezoso y todo es curry, lo más natural, para fines de programación práctica, la definición de una función de parámetro 0 es la misma que su resultado; La alternativa más cercana, una función de 1 parámetro que ignora el parámetro, es una tontería.

Si fse proporciona PPCGy 2como sus parámetros, el resultado es el texto "\"PPCG\""(primera función generada), que cuando se evalúa devuelve el texto "PPCG"(segunda función generada), y cuando se evalúa, devuelve PPCG.

Gracias a nimi por sugerir un acortamiento.

APL (Dyalog) , 24 23 bytes

-1 gracias a ngn.

Este es un programa completo que solicita sy luego nimprime en STDOUT.

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

Pruébalo en línea! (el caso 17 Deep se omite porque excede el límite de salida de TIO; funciona sin conexión)

⍞ solicitar s

⊢ ceder eso (para separar ⎕y ⍞)

''''{... }⍣⎕ mensaje para ny aplicar este lambda con una comilla simple como argumento de la izquierda que en muchas ocasiones. ⍺representa el argumento izquierdo (la cita) y ⍵es el argumento correcto (el texto de entrada):

 ⍵=⍺ Booleano donde el texto es igual a una cita

 1+ Agrega uno

 ⍵/⍨ replicar cada carácter del argumento el número correspondiente de veces

 ⍺, anteponer una cotización

 ⍺,⍨ agregar una cita

Esto funciona porque las cadenas en APL están 'delimitadas y las comillas simples en las cadenas se duplican, mientras que ningún otro carácter necesita escapar.

Dyalog APL también se envía con una utilidad ( ⎕SE.Dyalog.Utils.repObj) que genera una expresión APL que se evalúa según su argumento (similar al novato de Jelly ). Por lo tanto, el siguiente programa es equivalente al anterior, pero funciona para todas las matrices:

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

Pruébalo en línea!

Firefox JavaScript, 41 35 bytes

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

Firefox tiene una unevalcadena agradable , que hace lo que parece: desvaloriza un objeto determinado, en este caso.

Java 8, 95 93 bytes

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

-2 bytes gracias a @Lynn .

Escapar de caracteres especiales es muy molesto en Java.

Pruébelo aquí y pruebe el método resultante aquí .

Explicación:

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 

Explicación adicional para el reemplazo de expresiones regulares:

.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

¿Por qué todas estas barras?

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

Baja carga , 11 bytes

(a(S)*)~^^S

Pruébalo en línea!

La entrada debe comenzar en la pila, con el número en la parte superior en forma de un número de iglesia . No sé si este es un método de entrada válido, pero la especificación no tiene entrada, y colocar la entrada en la parte superior de la pila parece un método varado utilizado en dichos idiomas.

GolfScript , 5 bytes

~{`}*

Pruébalo en línea!

QuadR , 8 bytes

Traducción simple de la respuesta de ngn .

Toma ncomo argumento y scomo entrada.

^|'|$
'&

Pruébalo en línea!

PCRE R EColoque todas las instancias de

^|'|$ Comienzo de línea O Cita O Fin de línea

'& con una cita y todo el partido

El argumento especifica cuántas veces repetir la transformación.

R , 62 bytes

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

Pruébalo en línea!

Llámalo así: f(n,s)seguido de ncopias de()

Una función con nombre; devuelve una función anónima Todo lo que hace es modificar los valores predeterminados de formalsof f, permitiendo que se llame a la función resultante (y luego el resultado de esa llamada, nveces). cuando nllega 0, vuelve s.

¡R no es realmente malo para escapar! Utiliza el escape de estilo C, por lo que solo tiene que tomar la entrada, reemplazar "con \"y \con \\, y luego envolver todo " ".

Pyth, 21 bytes

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

Pruébalo aquí

Lamentablemente, la función recursiva (no es un programa completo como el anterior) es más larga (24 bytes):

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

APL (Dyalog Classic) , 19 bytes

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

Pruébalo en línea!

Ruby , 34 bytes

%pes un indicador printf específico de Ruby que obtiene el inspectvalor de su argumento, similar a %rPython. $><<significa imprimir.

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

Pruébalo en línea!

Excel VBA (32 bits), 67 bytes

Versión restringida a Excel VBA de 32 bits porque se 2^ievalúa sin error en VBA de 32 bits, pero no en VBA de 64 bits

Función de ventana inmediata anónima VBE que toma entradas ny sde rangos [A1]y [B1]emite una función anónima que cuando se evalúa solo en un terminal (después de las niteraciones) se genera solo scomo ese terminal

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

Muestra de entrada / salida

[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