Reto

En este desafío, escribirá el primer programa, p ₁ , de una secuencia infinita de programas, en el que ejecutar p _n genera / genera el programa p _{n + 1} . Al concatenar los primeros n> = 2 programas, la secuencia debería salir n.

Ejemplo

Digamos que los primeros 4 programas son:

p1 p2 p3 p4

Si tuviera que ejecutar p1, debería generar:

p2

Si tuviera que ejecutar p1p2, debería generar:

2

Si tuviera que ejecutarlo p1p2p3p4debería salir:

4

Si tuviera que ejecutar p4, debería generar el siguiente programa en la secuencia:

p5

Tanteo

Su puntaje es el recuento de bytes de los primeros 10programas.

Pyth, 12

p1:

l"1

p2: 1

p3: 1

etc.

p1p2p3:

l"111 

Salida: 3

Explicación:

l        length
 "1      string "1"

En la primera ejecución, esto da salida a la longitud de una sola cadena de caracteres, 1. Esto también pasa a ser un programa Pyth válido, que sale de 1nuevo. Por lo tanto, pn + 1 es siempre 1. Cuando los programas están encadenados, p1genera la longitud de los programas encadenados, 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;

Sin golf:

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

Explicación:

La primera línea toma toda la fuente del programa. Luego comparamos la duración de todo el programa con 1 + la duración de un solo programa. Si el tamaño del programa actual es menor que este valor, se imprime la fuente, que es el siguiente programa, p2, y salimos. Cada iteración es solo una quine. Cuando se juntan varios de estos, el condicional falla, e imprimimos la duración del programa concatenado dividido por la duración de un programa, que es el número de programas concatenados, n.

Vitsy , 19 bytes

No se trata de cadenas aquí, sino que usa trucos de métodos.

p1

1ml1-\+N
1

p2

1

p3

1

Etc., etc.

Explicación a continuación:

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.

Pruébalo en línea!

Vitsy , 14 bytes

Similar a las respuestas de Pyth y Jolf, estoy mapeando cadenas. La única diferencia es que uso las funciones de ajuste de línea para asegurarme de obtener siempre la longitud correcta.

p1

'l3-N

p2

1

Reemplace 1 con cualquier número único.

p3 y así sucesivamente coinciden con este patrón, y puede hacerlo hasta que Integer.MAX_VALUE, la restricción entera del idioma.

Explicación:

'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.

Pruébalo en línea!

En serio, 15 bytes

Primer programa, 6 bytes (contiene un no imprimible):

5Ql-.

Hex Dump:

35516c2d2e7f

Este programa imprime 1 : Pruébelo en línea

El resto de los programas son todos 1, un programa válido que se imprime como la respuesta de Pyth. El programa original imprime la longitud de su código fuente menos 5 y termina inmediatamente. 1Los s agregados al final aumentan la longitud del código fuente en 1 byte cada vez, pero nunca se ejecutan.

Jolf , 14 bytes

Pruébalo aquí!

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

Cuando se ejecuta, esto imprime 1. Por lo tanto, p2 = 1. Ejecución de p2rendimientos 1. Por lo tanto, para todos N > 1, pN = 1.

Observe p1p2: a-1q41. Esto se transmite a:

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

Dado que la impresión implícita se deshabilita después de la primera impresión, esto se imprime 2, ya que la longitud del código fuente menos 4 es 2. Y una y otra vez.

Rubí, 318 bytes

p ₁ :

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

Cada programa separado p _i genera esta línea de una línea:_="_=%p;puts _%%_";puts _%_ .

Cuando agrega estas quines al final de p ₁ , terminan como líneas en el DATAobjeto porque están debajo de la magia __END__.

Aquí hay una prueba:

$ 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

Los diez primeros programas concatenados se ven así (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

Primer programa (utiliza el indicador del 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("\"","\"\""));}}

Tercer 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("\"","\"\""));}}

Tienes la idea.

Javascript ES6, puntaje 483 455

Programa 1, 77 bytes:

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

Programa 2 y más allá, 42 bytes cada uno:

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 y más allá de 139 bytes:

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

usar 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 una versión ligeramente golfizada de la técnica php quine detallada aquí: http://10types.co.uk/the-lab/a-minimal-php-quine/