Criar uma impressora inteira versátil é bom e tudo mais, mas escrever um código único que imprime muitos números diferentes é complicado. Não seria mais fácil criar um script que gera um número, mas também fornece um novo script para obter o próximo número?

Desafio:

Escreva um código que produza um único número inteiro Ne um código executável. O próximo código deve ser exibido N+1e um código que pode ser exibido N+2. Continue esse caminho até chegar N = 15. (O último número impresso deve ser 15).

Regras:

• Nenhuma entrada (suponha que a entrada esteja vazia).
• Programa completo ou função ou outros formatos convenientes são permitidos.
• O primeiro código deve ser exibido 1.
• Você não pode gerar zeros à esquerda. Ou seja, você não pode imprimir 01para 1.
• A saída deve estar no formato N, Code_for_N+1. Observe que a saída é separada por vírgula e um espaço único. O código para N+1não possui aspas. N , Code_for_N+1não é aceito (espaço na frente da vírgula). As novas linhas à direita estão OK.
• O primeiro caractere (s) da saída deve ser o número. (Sem espaços à esquerda ou ans = N).
• O número impresso não deve fazer parte do próximo código (o código pode conter esse número, mas você não pode usar o número de saída como parte do código)
  • Exemplo: A produção de N=2pode ser: 2, printer 2. Nesse caso, printer 2é o código para N=3. Você não pode usar toda a saída: 2, printer 2como código para N=3.
• Os scripts podem estar em diferentes idiomas
• Os tipos de dados são irrelevantes (o número pode ser uma sequência), mas não pode ser cercado por nada (aspas, parênteses etc.).
• Se houver um código emitido para N=15ele, ele deve imprimir STOP!(consulte o bônus) ou não imprimir nada (nem mesmo um espaço ou nova linha).
  • O código para N=15não pode falhar (mas a saída para STDERR está OK).
  • Você é desqualificado se o código de saída for N=15impresso 16ou qualquer outra coisa (exceto a caixa de bônus).
• Operadores de quine embutidos não são permitidos.
• Não é permitido acessar o arquivo de origem através do sistema de arquivos.

Bônus:

-10 bytes se o código que imprime 15 também produz um código que imprime " STOP!"

Exemplos usando a sintaxe Python: (obviamente, eles funcionarão apenas para os números inteiros selecionados, não de 1 a 15.)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

Regras de golfe padrão se aplicam! O menor código (para N = 1) em bytes ganha!

Pitão + ///, 15 bytes - 10 = 5

pPt`S15", STOP!

Isso é impresso 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP!em Pyth, retirando range(1,15+1)e retirando os colchetes de início e de fim e imprimindo-o imediatamente seguido de ", PARAR!".

Os próximos quatorze programas estão em ///, que gera diretamente todos os programas que não contêm /ou \. Então o segundo programa

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

dá 2e o terceiro programa 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. O penúltimo programa,, 15, STOP!imprime 15, STOP!, então o último programa é justo STOP!.

JavaScript, 131238 - 10 = 131228 bytes

A abordagem ingênua acabou pior do que o esperado. Em retrospectiva, eu deveria ter esperado. Mas pensei em compartilhar de qualquer maneira. Código completo aqui.

Ideia: escapar iterativamente e adicionar o N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam, 26 25 24 bytes

1{", "2$)@"_~"](_F<@*}_~

Experimente online.

Os programas subsequentes simplesmente têm o primeiro número incrementado. Isso executa o programa 16 vezes.

Ou com bônus pela mesma pontuação:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

Experimente online.

Os programas subsequentes simplesmente têm o primeiro número incrementado. Isso executa o programa 16 vezes.

Solução alternativa para o bônus:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript (ES6), 62 61 bytes - 10 bônus = 51 pontuação

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

Explicação

Uma solução que não lê seu próprio código-fonte e também não é ridiculamente longa.

O primeiro programa constrói todos os outros 15 programas e os aninha dentro de si, usando uma função recursiva. Eu resolvo o problema da barra invertida aninhando as próprias funções (que são convertidas em cadeias durante a saída) em vez de cadeias.

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

Teste

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab, 226 212 - 10 = 202 bytes

Obrigado a @StewieGriffin por alguns bytes =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

A primeira parte é uma string que representa a segunda linha (abaixo), o código real (apenas deslocado por 9). No Matlab, seqüências de caracteres são matrizes preenchidas com caracteres, para que você possa executar facilmente os turnos apenas adicionando / subtraindo um escalar. Portanto, o programa apenas imprime a mesma sequência * novamente, mais a mesma sequência, mas alterada, o que resulta no código.

* Não exatamente: o primeiro byte é o contador que precisa ser aumentado a cada iteração.

O truque com a corda foi descaradamente roubado daqui.

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

Aqui as últimas linhas da sequência copiadas do console:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript, 50 47 44 42 44 ^* bytes

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

É uma função que extrai seu próprio corpo (apenas a) e faz substituições nele. Obter o corpo da função com um recurso interno do JavaScript, embora não seja explicitamente um operador quine (se for inválido, removerá a resposta).

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

No caso de ele não funcionar corretamente encaixado lá (porque para mim não), você pode ver um exemplo lá .

^{* - parece que o snippet produz o resultado sem a=, impossibilitando outras chamadas}

Python 2.7.10, 196 92 - 10 = 82 bytes

Whee !!! Isso foi divertido. Muito mais curto agora. : P

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Explicação:

Comecei com isso:

a='a=%r;print a%%a';print a%a

Isso é apenas uma solução simples. É isso que, com um contador adicionado:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

né uma variável de contador que é impressa no início. Então, quando imprimirn= peça, ela substitui n+1a %d. Então a partir daqui, ele contará infinitamente.

E aqui está a versão final. Ele adiciona uma cláusula if para parar aos 15 e imprime "STOP!" também.

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Código antigo:

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

Nunca vai ganhar, mas divertido. : P Muito mais curto agora, embora ainda não tenha chance. : P

PowerShell, (215-10) = 205 197 167 106 104 103 bytes

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{(Se sua única ferramenta for o PowerShell, todo problema parecerá um prego. Aguarde ...)}

Essencialmente, começamos com a configuração $digual a uma string big-ole-longa de um quase- Quine do código original. Ele produz 1e, em seguida, $dcom o operador de formato -fpara preencher corretamente o {0}, {1}, {2}ins stand-, incrementando o {2}número na ,1*{2}seção por um de cada vez.

A ,x*yoperação no PowerShell cria uma nova matriz de yitens, cada um dos quais é igual a x. Por exemplo, ,2*3é equivalente a @(2,2,2).

Isso significa que a primeira saída será 1, $c=(,1*2).length;$d=(etc...), portanto, quando o segundo código for executado, $cserá igual à contagem da matriz @(1,1)ou 2etc. Observe que $cnão é usada como variável no código original, apenas nas execuções subseqüentes.

Para quando imprime 15 simplesmente calculando se $cé igual 15e depois indexando em uma matriz, o 0º elemento é $c, $dcomo descrito acima, o outro é justo 15. Assim, quando $ctiver 15 anos, produzirá 15e nada mais. Não se qualifica para o bônus, porque "15, {0}STOP!{0}"tem 5 caracteres a mais para que o -10 valha a pena.

Requer um terminal PowerShell de largura> ~ 150. Ou para remover manualmente a quebra de linha extra (que o terminal insere de maneira útil na quebra de saída) ao copiar e colar o código. Ou para você capturar a saída em uma variável e depois executar novamente essa variável. Etc.

_{Editar 1 - salvou alguns bytes removendo o "STOP!" redação.
Editar 2 - Durr, não use .length de cada vez, basta chamá-lo uma vez.
Editar 3 - Não precisa ser um quine, para que a execução inicial possa ser muito menor.
Edit 4 - Mudou o uso de strings para matrizes para calcular $c, que salvaram dois bytes. Tenho certeza de que isso é quase ideal para essa abordagem.
Edição 5 - Salva outro byte contando diretamente a igualdade, em vez de modificar}

JavaScript, 79 - 10 = 69 bytes

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Sem usar de Function.prototype.toStringforma alguma.

Anterior, 57 - 10 = 47 bytes

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

Este é incrível. Experimente aqui .

Lote, 73 + 5 - 10 = 68 bytes

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Requer, CMD /V:ONentão eu adicionei 5 bytes para isso.

Python 2.7, 107 caracteres

Usando recursão e não escrevendo um quine, pensei que poderia economizar muito, o que é verdade, mas não é bom o suficiente. Embora não seja um vencedor, acho que é divertido compartilhar essa abordagem.

Comecei criando uma string para N = 4, escapando dos caracteres \e ".

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

Então eu criei uma função lambda que cria essa string, com base em um índice inicial e um índice de parada, usando recursão. É isso:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Use-o assim:

print l(1,15)

Saída: [32902 caracteres, muito tempo para manipular]

Então, parece que minha abordagem de complexidade kolmogorov não é tão bem-sucedida ;-)

SMBF , 28 bytes

\x10representa um byte literal (valor decimal 16). O número inteiro é emitido como um número inteiro (byte). Portanto, a saída do primeiro caractere é \x01. O programa então imprime ",". Ao imprimir sua própria fonte, ela imprime um extra +no início.

+.<-<<.>.>[[<]>.[.>]<[-]], \x10

Explicação:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Observe que você não pode executar isso em um intérprete padrão, pois requer um literal hexadecimal na entrada. Você também precisa de um terminal especial para que a saída hexadecimal funcione corretamente.

Bash, 78 74 73 - 10 = 63 bytes (exemplo, não é possível vencer)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Chegando tarde, mas o bash de serra não havia sido tentado, então tente. Primeiro desafio do golfo e quebra-cabeça tipo quine. Eles são divertidos!

Explicação:

Isso funciona porque as aetapas de 1 a 15 são unsetseguidas p. O script (armazenado p) imprime os dois se estiverem sete "PARE!" de outra forma. O inicialmente unset aé set0, porque aparece em uma expansão aritmética.

, 30 caracteres / 47 bytes (não competitivo)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

Finalmente encontrei uma boa e verdadeira solução para 𝔼𝕊𝕄𝕚𝕟.

Explicação

Aqui está o verdadeiro quine que eu usei: ⟮ⒸⅩ222+ᶈ0

Você vê isso na minha resposta? Felizmente, vocês serão capazes de expandir a partir daí.

Barril + PHP, 19-10 = 10 bytes

ï_(. \,,,)\!POTS(,

Conta de 1 a 15 e depois para. TIO

Barril, 13 bytes

ï_(. \,,,).