Programas de encadenamiento

26

Reto

En este desafío, escribirá el primer programa, p 1 , 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.

Downgoat
fuente
¿Las secuencias p1p2p3...serán siempre de p1 a pn ?
Alce
@ Moose Sí, siempre será de p1 a pn.
Downgoat
55
Este es un problema interesante. La secuencia del programa es bastante fácil; El encadenamiento es más difícil.
Conor O'Brien
¿Se permite acceder a los archivos?
Lynn
Si pero @Mauris del contenido del archivo y el nombre de cuenta de bytes deben contarse en el número total de bytes para cada programa que se utiliza en.
Downgoat

Respuestas:

49

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.

Alce
fuente
9

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.

Nikolai97
fuente
+1 por usar un método diferente (que el mío). Este es el tipo de respuesta creativa que esperaba.
Moose
+1 para Lua, y elegir un refrigerador, si es un método más largo que las otras respuestas: P
cat
Jaja, gracias, estaba muy orgulloso de haber logrado hacer esto con un lenguaje que no era golf y bastante detallado :)
Nikolai97
4

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!

Addison Crump
fuente
4

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!

Addison Crump
fuente
4

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.

quintapia
fuente
2

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.

Conor O'Brien
fuente
2

Rubí, 318 bytes

p 1 :

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 1 , 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 _%_
daniero
fuente
1

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.

LegionMammal978
fuente
0

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();
SuperJedi224
fuente
0

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/

usuario59178
fuente