Gerar programas em tamanho crescente

21

Neste desafio, você escreverá um programa que emite um programa com o dobro da duração do programa original. O programa emitido deve gerar um novo programa ou um programa com o dobro de seu comprimento.

Exemplos

Se meu programa for a:

< a
> aa

< aa
> aaaa

< aaaa
> aaaaaaaa

Regras

  • Sem embutidos de quine
  • O programa original deve ter pelo menos um byte
  • A sequência deve teoricamente funcionar infinitamente
  • Seu programa não tem permissão para ler nada (arquivo, stdio)

Sua pontuação é do tamanho do programa original.

Downgoat
fonte
Que tal acessar o arquivo lendo / acessando o local onde o código está contido?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ que não é permitido, pois isso violaria as regras que eu acredito.
Downgoat 15/01/16
2
@ Doᴡɴɢᴏᴀᴛ as regras Quine são recomendados pelo wiki tag, mas não se aplicam automaticamente
Martin Ender
11
Você pode
usar o seguinte

Respostas:

12

CJam, 10 bytes

{"_~"+_}_~

Teste aqui.

Explicação

{"_~" e# Generalised quine framework, leaves the block and the string "_~"
      e# on the stack. 
+     e# Prepend the block to the string.
_     e# Duplicate the resulting array.
}_~
Martin Ender
fonte
GolfScript não está morto! Ilmari tem uma resposta para uma pergunta semelhante que faz isso em exatamente 10 bytes.
Justin
8

JavaScript, 62 61 37 bytes


Obrigado a @ Doᴡɴɢᴏᴀᴛ pela ajuda!


Original [37 bytes]:

f=_=>'f='+'_'.repeat((10+f).length)+f

Filho [74 bytes]:

f=______________________________________=>'f='+'_'.repeat((10+f).length)+f

Neto [148 bytes]:

f=________________________________________________________________________________________________________________=>'f='+'_'.repeat((10+f).length)+f


Alternativo (com impressão no console e como um programa completo):

Original [61 bytes]:

f=_=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()

Filho [122 bytes]:

f=______________________________________________________________=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()

Neto [244 bytes]:

f=________________________________________________________________________________________________________________________________________________________________________________________=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()



Como funciona!

1.   f=_=>   Defina a função f comoconsole.log(...)

2.   ;f()   Execute a função f.

3.   (na função f)  

  • console.log(...)   Imprima o seguinte:

    • f=   texto literal "f ="
    • ${'_'.repeat((0+f).length+5)   "_" repetido para o comprimento de f, alterado para incluir caracteres não incluídos na string de f
    • +f}   A stringificação da função f
    • ;f()   texto literal "; f ()"

Notas

  • console.logé necessário em vez de alertporque alertparece não funcionar bem com seqüências muito longas (pelo menos na configuração da minha máquina / navegador)
  • Os _são inseridos no nome do parâmetro (não utilizado) da função f, para garantir que sejam incluídos na string de f.
  • O aprimoramento principal (além de se livrar da console.log) da primeira solução em relação à segunda: adicionar 10à função em vez de 0convertê-la em string o torna um byte mais longo, eliminando a necessidade de adicionar 1 ao comprimento posteriormente, economizando um byte.
jrich
fonte
0+ftambém deve trabalhar para lançar a função de uma corda
Downgoat
48 bytes:(f=_=>`(f=${'_'.repeat((0+f).length+5)+f})()`)()
Downgoat
@ Doᴡɴɢᴏᴀᴛ Esqueceu que retornar o resultado geralmente é aceitável. Atualizará.
jrich
@ Na verdade, como escrever respostas como funções é geralmente aceito, a solução precisa chamar a função?
jrich
Claro, você pode fazer
Downgoat
6

Capítulo 0.15 , 19 14 bytes

"66*2-rIDdr$O.

Original , filho , neto .

Explicação

"66*2-      $O.    Standard quine formulation

      r            Reverse stack
       I           Push length of stack
        D          Pop n and duplicate top of stack n times
         d         Duplicate top of stack
          r        Reverse stack

O que o bit entre rs faz é duplicar o período final vezes o suficiente para atender ao critério de duplicação. .é o caractere "parar programa", então os muitos períodos no final não fazem nada, exceto estar lá.

El'endia Starman
fonte
3

CJam, 12 bytes

{"_~"1$1$}_~

Quando executado, isso imprimirá

{"_~"1$1$}_~{"_~"1$1$}_~

que, por sua vez, imprimirá

{"_~"1$1$}_~{"_~"1$1$}_~{"_~"1$1$}_~{"_~"1$1$}_~

e assim por diante.

Experimente online!

Dennis
fonte
2

Python 3, 51 bytes

x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)

Isso inclui uma nova linha à direita.

Quais saídas:

x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)
x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)
Zweedeend
fonte
2

GolfScript, 11 bytes

{: ".~"]}.~

Experimente online!

Como o código fonte funciona

{: ".~"]}.~

{       }    Define and push a code block.
         .~  Push a copy and execute it.
 :           Save the code block in the space character.
             Every subsequent space will now execute the code block.
   ".~"      Push that string.
       ]     Wrap the entire stack in an array.

Se o código fonte acima for executado uma vez, a pilha terminará como

["" {: ".~"]} ".~"]

onde a cadeia vazia no início corresponde ao estado inicial da pilha (entrada vazia).

Duas cópias do código fonte deixariam um estado final de

[["" {: ".~"]} ".~"] {: ".~"]} ".~"]

e assim por diante.

O que acontece depois

Depois de executar o código fonte, o intérprete faz o seguinte:

  1. Ele agrupa a pilha inteira em uma matriz e empurra essa matriz na pilha.

    Para uma única cópia do código fonte, a pilha agora contém

    ["" {: ".~"]} ".~"] [["" {: ".~"]} ".~"]]
    
  2. É executado putscom a intenção de imprimir a pilha empacotada, seguida por um avanço de linha.

    putsé definido como {print n print}, assim faz o seguinte.

    1. printimprime a cópia embrulhada da pilha sem inspecioná-la (ou seja, sem convertê-la em sua representação de sequência). Isso envia

      {: ".~"]}.~
      

      para STDOUT e abre a cópia da pilha da parte superior da pilha.

      A pilha agora contém

      ["" {: ".~"]} ".~"]
      
    2. executa o bloco de código que definimos anteriormente.

      :começa salvando ["" {: ".~"]} ".~"]o caractere de espaço, ".~"empurra a si próprio e ]agrupa a pilha em uma matriz.

    3. n empurra uma sequência que consiste em um único avanço de linha.

      A pilha agora contém

      [["" {: ".~"]} ".~"] ".~"] "\n"
      
    4. é executado mais uma vez. No entanto, foi redefinido quando o chamamos pela primeira vez e agora contém uma matriz, não um bloco de código.

      Na verdade, ele empurra ["" {: ".~"]} ".~"], deixando a pilha como

      [["" {: ".~"]} ".~"] ".~"] "\n" ["" {: ".~"]} ".~"]
      
    5. Por fim, printimprime o item mais alto da pilha sem inspecioná-lo, enviando

      {: ".~"]}.~
      

      para STDOUT.

Dennis
fonte
1

, 26 caracteres / 36 bytes

⟮ô`\u27ee⦃ᶈ0}\u27ef
`ď2)⟯

Try it here (Firefox only).

Observe que há uma nova linha à direita.

Explicação

Quine padrão: ⟮ⒸⅩ222+ᶈ0

Modificações:

  • Usar ô função para gerar todos os resultados do quines em vez do último resultado (como feito usando a saída implícita)
  • Usar \u27ee⦃ᶈ0}\u27ef\n e feche o bloco de cópias para evitar conflitos com os blocos de cópias posteriores.
  • Use ď2para repetir a string duas vezes.
Mama Fun Roll
fonte