Étant donné un niveau d'imbrication d'entier positif net une chaîne sde caractères ascii imprimables ( à ~, produire un programme qui, lorsqu'il est exécuté dans la même langue, génère un programme qui génère un programme ... qui génère la chaîne s.

Un total de nprogrammes doit être généré, tous doivent être exécutés dans la même langue que votre réponse.

Remarque: vous pouvez produire des programmes ou des fonctions - tout ce qui vous est autorisé par défaut en tant que soumission.

Vous pouvez entrer savec des caractères d'échappement, comment un programme ou une fonction dans votre langue entrerait habituellement une chaîne.

Exemple

Par exemple, étant donné n=1et s="recursion", un programme Python 2 peut générer:

print "recursion"

L'exécution de ceci produirait:

recursion

Étant donné n=2et s = "PPCG", un programme Python 2 peut générer:

print "print \"PPCG\" "

Exécution de ces sorties:

print "PPCG"

Exécution de ces sorties:

PPCG

Connexes (+ inspiration du titre): Encore un LUL et je suis sorti

Également lié (dans le bac à sable - maintenant supprimé, mais peut toujours être affiché avec suffisamment de réputation): Récursion du code source

Cas de test

Assurez-vous que votre code fonctionne pour les cas de test suivants (un par ligne):

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

Gelée , 2 octets

Ṿ¡

Essayez-le en ligne!

Ṿ¡  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 octets

Enregistré 3 octets grâce à @HermanLauenstein

Prend une entrée dans la syntaxe de curry (n)(s).

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

Exemple

f(2)('PPCG')

Sortira:

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

Qui imprimera:

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

Qui imprimera:

'PPCG'

Démo

Un exemple plus complexe où alert()a été remplacé afin que les résultats intermédiaires soient imprimés sur la console et exécutés automatiquement.

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

Version alternative, 40 octets

Proposé par @Shaggy

Celui-ci renvoie une fonction anonyme au lieu d'un programme complet.

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

sh + coreutils, 31 octets

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

Prend ncomme paramètre de ligne de commande et ssur STDIN.

Python 2 , 40 octets

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

Essayez-le en ligne!

-4 octets grâce à xnor

Haskell, 17 octets

Au moment où j'écris ceci, c'est la réponse la plus courte pour un non-spécifique au golf langue .

C'est une fonction qui prend set ndans cet ordre, et retourne le résultat ou le code source d'une expression qui, une fois évaluée, retourne le code source suivant.

(!!).iterate show

Argument pour pourquoi cela compte:

1. Les solutions peuvent être des fonctions.
2. Leurs sorties peuvent être des fonctions.
3. Ces fonctions n'ont pas de paramètres.
4. Dans Haskell, étant donné qu'elle est paresseuse et que tout est curieux, la définition la plus naturelle - à des fins de programmation pratique - d'une fonction à 0 paramètre est la même que son résultat; l'alternative la plus proche, une fonction à 1 paramètre qui ignore le paramètre, est idiote.

Si fest donné PPCGet 2comme ses paramètres, le résultat est le texte "\"PPCG\""(première fonction générée) qui, lorsqu'il est évalué, renvoie le texte "PPCG"(deuxième fonction générée), et lorsqu'il est évalué, il renvoiePPCG .

Merci à nimi d' avoir proposé un raccourcissement.

APL (Dyalog) , 24 23 octets

-1 grâce à ngn.

Il s'agit d'un programme complet qui vous invite s, puis pour net imprime sur STDOUT.

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

Essayez-le en ligne! (le cas 17 Deep est omis car il dépasse la limite de sortie de TIO - fonctionne hors ligne)

⍞ demander s

⊢ céder que (pour séparer ⎕et ⍞)

''''{… }⍣⎕ Demander net appliquer ce lambda avec une seule citation comme argument de gauche autant de fois. ⍺représente l'argument de gauche (la citation) et ⍵est l'acronyme de droite (le texte d'entrée):

 ⍵=⍺ Booléen où le texte est égal à une citation

 1+ ajoute un

 ⍵/⍨ répliquer chaque caractère de l'argument le nombre de fois correspondant

 ⍺, ajouter un devis

 ⍺,⍨ joindre un devis

Cela fonctionne car les chaînes dans APL sont 'délimitées et les guillemets simples dans les chaînes sont doublés, alors qu'aucun autre caractère n'a besoin d'être échappé.

Dyalog APL est également livré avec un utilitaire ( ⎕SE.Dyalog.Utils.repObj) qui génère une expression APL qui évalue son argument (similaire à l'inégalité de Jelly ). Le programme suivant est donc équivalent au précédent, mais fonctionne pour tous les tableaux:

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

Essayez-le en ligne!

Firefox JavaScript, 41 35 octets

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

Firefox a une belle unevalchaîne qui fait ce que cela ressemble - égalise un objet donné, dans ce cas.

Java 8, 95 93 octets

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

-2 octets grâce à @Lynn .

Échapper à des caractères spéciaux est tellement ennuyeux en Java.

Essayez-le ici et essayez la méthode résultante ici .

Explication:

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 

Explication supplémentaire pour le remplacement de l'expression régulière:

.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

Pourquoi toutes ces barres obliques?

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

Sous-charge , 11 octets

(a(S)*)~^^S

Essayez-le en ligne!

L'entrée doit commencer sur la pile, avec le numéro en haut sous la forme d'un chiffre d'église . Je ne sais pas s'il s'agit d'une méthode d'entrée valide, mais la spécification n'a pas d'entrée, et placer l'entrée en haut de la pile semble être une méthode échouée utilisée dans de tels langages.

GolfScript , 5 octets

~{`}*

Essayez-le en ligne!

QuadR , 8 octets

Traduction simple de la réponse de ngn .

Prend ncomme argument et scomme entrée.

^|'|$
'&

Essayez-le en ligne!

PCRE R EPlacez toutes les instances de

^|'|$ Début de ligne OU Devis OU Fin de ligne

'& avec un devis et tout le match

L'argument spécifie combien de fois répéter la transformation.

R , 62 octets

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

Essayez-le en ligne!

Appelez-le ainsi: f(n,s)suivi den copies de()

Une fonction nommée; renvoie une fonction anonyme. Il ne fait que modifier les valeurs par défaut de formalsof f, permettant d'appeler la fonction résultante (puis le résultat de celle appelée, ntimes). quand natteint0 , il revients .

R n'est en fait pas trop mal à s'échapper! Il utilise l'échappement de style C, il vous suffit donc de prendre l'entrée, de remplacer "par \"et \avec \\, puis de boucler le tout " ".

Pyth, 21 octets

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

Essayez-le ici.

Malheureusement, la fonction récursive (pas le programme complet comme ci-dessus) est plus longue (24 octets):

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

APL (Dyalog Classic) , 19 octets

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

Essayez-le en ligne!

Rubis , 34 octets

%pest un indicateur printf spécifique à Ruby qui obtient la inspectvaleur de son argument, similaire à %rPython. $><<signifie imprimer.

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

Essayez-le en ligne!

Excel VBA (32 bits), 67 octets

Version limitée à Excel VBA 32 bits car 2^i évalue sans erreur dans VBA 32 bits, mais pas dans VBA 64 bits

Fonction de fenêtre immédiate VBE anonyme qui prend des entrées net sdes plages [A1]et [B1]et génère une fonction anonyme qui, lorsqu'elle est évaluée uniquement sur un terminal (aprèsn itérations), sort uniquement en stant que terminal

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

Exemple d'entrée / sortie

[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