Desafio

Neste desafio, você escreverá o primeiro programa, p ₁ , de uma sequência infinita de programas, na qual executar p _n gera / gera o programa p _{n + 1} . Ao concatenar os primeiros n> = 2 programas, a sequência deve ser exibida n.

Exemplo

Digamos que os 4 primeiros programas sejam:

p1 p2 p3 p4

Se eu fosse executar p1, ele deveria gerar :

p2

Se eu fosse executar p1p2, ele deveria gerar :

2

Se eu fosse executá- p1p2p3p4lo, deveria gerar :

4

Se eu fosse executar p4, ele deveria gerar o próximo programa na sequência:

p5

Pontuação

Sua pontuação é a contagem de bytes dos primeiros 10programas.

Pyth, 12

p1:

l"1

p2: 1

p3: 1

etc ..

p1p2p3:

l"111 

Saída: 3

Explicação:

l        length
 "1      string "1"

Na primeira execução, isso gera o comprimento de uma única sequência de caracteres 1,. Isso também é um programa Pyth válido, com saída 1novamente. Portanto, pn + 1 é sempre 1. Quando os programas são encadeados, p1gera a duração dos programas encadeados, que será n.

Lua, 950 900 bytes

s=io.open(arg[0]):read()if#s<95 then print(s)do return end end print(#s/90) do return end;

Ungolfed:

s=io.open(arg[0]):read'*a'
if #s < 96 then 
    print(s)
    do return end 
end 
print(#s/90) 
do return end;

Explicação:

A primeira linha pega toda a fonte do programa. Em seguida, comparamos a duração de todo o programa com 1 + a duração de um único programa. Se o tamanho do programa atual for menor que esse valor, a fonte será impressa, que é o próximo programa, p2, e sairemos. Cada iteração é apenas uma solução. Quando vários deles são reunidos, o condicional falha e imprimimos o tamanho do programa concatenado dividido pelo tamanho de um programa, que é o número de programas concatenados, n.

Vitsy , 19 bytes

Não lidando com strings aqui, mas usando truques de método.

p1

1ml1-\+N
1

p2

1

p3

1

E assim por diante.

Explicação abaixo:

1ml1-\+N
1m       Execute the first index of lines (the bit with the ones)
  l1-    Get the length minus 1.
     \+  Add them all up.
       N Output as number.

1        Push one to the stack.

Experimente online!

Vitsy , 14 bytes

Semelhante às respostas de Pyth e Jolf, estou mapeando strings. A única diferença é que eu uso os recursos de quebra de linha para garantir sempre o comprimento certo.

p1

'l3-N

p2

1

Substitua 1 por qualquer número único.

p3 e assim por diante correspondem a esse padrão, e você pode fazer isso até Integer.MAX_VALUEa restrição de número inteiro do idioma.

Explicação:

'l3-N
'     Wrap around the line until finding another '. Since no ' is found before the
      End of the line, it wraps around.
 l    Get the length of the stack.
  3-  Subtract three.
    N Output as number.

Experimente online!

Sério, 15 bytes

Primeiro programa, 6 bytes (contém um não imprimível):

5Ql-.

Hex Dump:

35516c2d2e7f

Este programa imprime 1: Experimente online

O restante dos programas são todos 1, um programa válido que se imprime exatamente como a resposta Pyth. O programa original imprime o comprimento do seu código-fonte menos 5 e termina imediatamente. 1s anexados ao final aumentam o comprimento do código fonte em 1 byte de cada vez, mas nunca são executados.

Jolf , 14 bytes

Experimente aqui!

a-lq4
a      print
  lq   the length of the source code
 -  4  minus 4

Quando executado, isso é impresso 1. Assim p2 = 1,. Executando p2rendimentos 1. Assim, para todos N > 1, pN = 1.

Observe p1p2: a-1q41. Isso transpila para:

alert(sub(length("a-lq41"),4));
1;

Como a impressão implícita é desativada após a primeira impressão, ela é impressa 2, pois o comprimento do código-fonte menos 4 é 2. E assim por diante.

Ruby, 318 bytes

p ₁ :

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__

Cada programa p separado _i saídas deste Quine de uma linha: _="_=%p;puts _%%_";puts _%_.

Quando você adiciona esses quines ao final de p ₁ , eles acabam como linhas no DATAobjeto porque estão abaixo da mágica __END__.

Aqui está um teste:

$ ruby chain.rb                                    # running p1
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p2
_="_=%p;puts _%%_";puts _%_

$ ruby -e '_="_=%p;puts _%%_";puts _%_'            # running p3
_="_=%p;puts _%%_";puts _%_

$ # Concatenating p2 and p3 to p1:
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb
$ ruby -e '_="_=%p;puts _%%_";puts _%_' >> chain.rb

$ ruby chain.rb                                    # running p1p2p3
3

Os dez primeiros programas concatenados têm a seguinte aparência (318 bytes):

x=DATA.readlines.size
_="_=%p;puts _%%_"
puts x>0?x+1:_%_
__END__
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_
_="_=%p;puts _%%_";puts _%_

C #, 2099 + 7 = 2106 bytes

Primeiro programa (usa sinalizador de compilador /main:A):

class A{static void Main(){int a=System.Reflection.Assembly.GetEntryAssembly().GetTypes().Length;var b=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a>1?"{2}":b,0,b.Replace("\"","\"\""),a);}}

Segundo programa:

class A0{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,0+1,a.Replace("\"","\"\""));}}

Terceiro programa:

class A1{static void Main(){var a=@"class A{0}{{static void Main(){{var a=@""{1}"";System.Console.Write(a,{0}+1,a.Replace(""\"""",""\""\""""));}}}}";System.Console.Write(a,1+1,a.Replace("\"","\"\""));}}

Você entendeu a ideia.

Javascript ES6, pontuação 483 455

Programa 1, 77 bytes:

v=1;setTimeout(_=>alert(v>1?v:'a=_=>this.v?v++:alert("a="+a+";a();");a();'));

Programa 2 e além, 42 bytes cada:

a=_=>this.v?v++:alert("a="+a+";a();");a();

PHP, 1470 bytes

Programa 1: 219 bytes:

class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();

programa 2 e além de 139 bytes:

if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));

use como:

php -r "class O{public$n=1;function __destruct(){echo($n=$this->n)>1?$n:'if(!$o->n++)echo str_replace(chr(9),$a=aWYoISRvLT5uKyspZWNobyBzdHJfcmVwbGFjZShjaHIoOSksJGE9CSxiYXNlNjRfZGVjb2RlKCRhKSk7,base64_decode($a));';}}$o=new O();"

Utiliza uma versão ligeiramente modificada, a técnica php quine detalhada aqui: http://10types.co.uk/the-lab/a-minimal-php-quine/