Dado um nível positivo de aninhamento de número inteiro ne uma sequência sde caracteres ascii imprimíveis ( para ~gerar um programa que, quando executado no mesmo idioma, gera um programa que gera um programa ... que gera a strings .

Um total de n programas deve ser gerado, todos os quais devem ser executados no mesmo idioma da sua resposta.

Nota: você pode gerar programas ou funções - qualquer coisa que você permita por padrão como envio.

Você pode inserir scom caracteres de escape, como um programa ou função em seu idioma usualmente inseria uma string.

Exemplo

Por exemplo, dado n=1e s="recursion", um programa Python 2 pode gerar:

print "recursion"

Executar isso resultaria em:

recursion

Dado n=2es = "PPCG", um programa Python 2 pode gerar:

print "print \"PPCG\" "

Executando estas saídas:

print "PPCG"

Executando estas saídas:

PPCG

Relacionado (+ inspiração do título): Mais um LUL e estou fora

Também relacionado (na sandbox - agora excluído, mas ainda pode ser visto com reputação suficiente): Recursão do código-fonte

Casos de teste

Verifique se o seu código funciona para os seguintes casos de teste (um por linha):

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éia , 2 bytes

Ṿ¡

Experimente 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 bytes

Guardado 3 bytes graças a @HermanLauenstein

Recebe entrada na sintaxe de currying (n)(s).

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

Exemplo

f(2)('PPCG')

Saída:

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

Qual será impresso:

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

Qual será impresso:

'PPCG'

Demo

Um exemplo mais complexo em alert()que foi substituído para que os resultados intermediários sejam impressos no console e executados 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'"));

Versão alternativa, 40 bytes

Sugerida por @Shaggy

Este retorna uma função anônima em vez de um 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 um parâmetro de linha de comando e sem STDIN.

Python 2 , 40 bytes

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

Experimente online!

-4 bytes graças ao xnor

Haskell, 17 bytes

A partir de quando escrevo isso, esta é a resposta mais curta para uma área específica para quem não joga golfe. idioma .

É uma função que pega se nnessa ordem e retorna o resultado ou o código fonte de uma expressão que, quando avaliada, retorna o próximo código fonte.

(!!).iterate show

Argumento por que isso conta:

1. As soluções podem ser funções.
2. Suas saídas podem ser funções.
3. Essas funções não têm parâmetros.
4. Em Haskell, como é preguiçoso e tudo é acompanhado, a definição mais natural - para fins de programação prática - de uma função de parâmetro 0 é a mesma que o resultado; a alternativa mais próxima, uma função de 1 parâmetro que ignora o parâmetro, é boba.

Se fé dado PPCGe 2como seus parâmetros, o resultado é o texto "\"PPCG\""(primeira função gerada), que quando avaliado retorna o texto "PPCG"(segunda função gerada) e, quando avaliado, retornaPPCG .

Obrigado a nimi por sugerir um encurtamento.

APL (Dyalog) , 24 23 bytes

-1 graças a ngn.

Este é um programa completo que solicita s, nimprime e imprime em STDOUT.

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

Experimente online! (o caso 17 Deep é omitido por exceder o limite de saída do TIO - funciona offline)

⍞ solicitar s

⊢ produzir que (separar ⎕e ⍞)

''''{… }⍣⎕ Solicite ne aplique esse lambda com uma única citação como argumento à esquerda, muitas vezes. ⍺representa o argumento da esquerda (a citação) e ⍵representa o argumento da direita (o texto de entrada):

 ⍵=⍺ Booleano em que o texto é igual a uma citação

 1+ Adicione um

 ⍵/⍨ replicar cada caractere do argumento o número correspondente de vezes

 ⍺, anexar uma cotação

 ⍺,⍨ acrescentar uma cotação

Isso funciona porque as seqüências de caracteres no APL são 'delimitadas e as aspas simples são duplicadas, enquanto outros caracteres não precisam ser escapados.

O Dyalog APL também é fornecido com um utilitário ( ⎕SE.Dyalog.Utils.repObj) que gera uma expressão de APL que é avaliada em seu argumento (semelhante ao não-valor de Jelly ). O programa a seguir é, portanto, equivalente ao acima, mas funciona para todas as matrizes:

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

Experimente online!

Firefox JavaScript, 41 35 bytes

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

O Firefox possui uma unevalstring legal , que faz o que parece - desvaloriza um determinado objeto, neste caso -.

Java 8, 95 93 bytes

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

-2 bytes graças a @Lynn .

Escapar caracteres especiais é tão irritante em Java ..

Experimente aqui e tente o método resultante aqui .

Explicação:

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 

Explicação adicional para a substituição do 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

Por que todas essas barras?

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

Subcarga , 11 bytes

(a(S)*)~^^S

Experimente online!

A entrada precisa começar na pilha, com o número no topo na forma de um número de igreja . Não sei se esse é um método de entrada válido, mas a especificação não tem entrada, e colocar a entrada no topo da pilha parece um método ocioso usado em tais linguagens.

GolfScript , 5 bytes

~{`}*

Experimente online!

QuadR , 8 bytes

Tradução simples da resposta de ngn .

Toma ncomo argumento e scomo entrada.

^|'|$
'&

Experimente online!

PCRE R EColoque todas as instâncias de

^|'|$ Início da linha OU Cotação OU Fim da linha

'& com uma cotação e a partida inteira

O argumento especifica quantas vezes repetir a transformação.

R , 62 bytes

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

Experimente online!

Chame assim: f(n,s)seguido de ncópias de()

Uma função nomeada; retorna uma função anônima. Tudo o que faz é modificar os valores padrão de formalsof f, permitindo que a função resultante seja chamada (e, em seguida, o resultado da chamada, ntimes). quando nchega0 , retornas .

R não é realmente tão ruim em escapar! Ele usa escape no estilo C, então você só precisa pegar a entrada, substituir "por \"e \com \\e depois envolver tudo " ".

Pitão, 21 bytes

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

Experimente aqui.

Infelizmente, a função recursiva (não o programa completo como acima) é mais longa (24 bytes):

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

APL (Dyalog Classic) , 19 bytes

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

Experimente online!

Rubi , 34 bytes

%pé um sinalizador printf específico do Ruby que obtém o inspectvalor de seu argumento, semelhante ao %rPython. $><<significa imprimir.

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

Experimente online!

Excel VBA (32 bits), 67 bytes

Versão restrita ao VBA do Excel de 32 bits porque 2^i avaliada sem erro no VBA de 32 bits, mas não no VBA de 64 bits

Anonymous VBE funo de janela de imediato que leva entradas ne sa partir de gamas [A1]e [B1]e gera uma função anónima que quando avaliado para apenas um terminal (depois de niterações) transmite apenas scomo aquele terminal

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

Entrada / Saída de amostra

[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