Programa que crea versiones más grandes de sí mismo (variante quine)

109

Debe escribir un programa que genere el código fuente que es

  1. Más grande que el programa original (carácter sabio)
  2. Imprimirá otro programa más grande que sí mismo cuando se ejecute (es decir, el nuevo programa también es una respuesta válida a este desafío)

Este es el código de golf, por lo que gana la respuesta más corta.

PyRulez
fuente
44
@ Kevin, la definición es recursiva. La salida debe ser un programa cuya salida sea más grande que sí misma y una respuesta a esta pregunta. Así que la salida de la salida debe ser mayor que el de salida, y la salida de la salida de la salida debe ser aún mayor, etc
ugoren
8
Creo que deberías aclarar tus reglas. Por un lado, cualquier código adicional generado por dicho programa es "obviamente inútil"; por otra parte, todo el código adicional en la salida es "útil" ya que promueve el objetivo de responder a este desafío.
Jason C
55
Perdón por destruir tu desafío. :^)
Justin
2
Creo que este desafío sería mucho mejor como un concurso de popularidad que un código de golf. ¡Permitiría mucha más creatividad!
corsiKa
30
Naturalmente, dicho programa debería conocerse como una quinina.
Jonathan Van Matre

Respuestas:

89

GS2 (8636 extensivo) , 0 bytes



Esto imprime una nueva línea nueva, que imprime dos líneas nuevas, que imprime tres líneas nuevas, etc.

Pruébalo en línea!

Dennis
fuente
3
¿No es técnicamente no competitivo ya que gs2 es más nuevo que el desafío?
DJMcMayhem
24
Este compromiso es anterior al desafío en un mes y medio. Lo acabo de probar y funciona según lo previsto.
Dennis
1
¿Cómo no es esto una escapatoria?
Mama Fun Roll
14
@MamaFunRoll ¿Por qué sería? Esto no es diferente de un programa Retina vacío que imprime 1 , un programa Jelly vacío que imprime 0 o un programa Stuck vacío que imprime Hello, World! .
Dennis
2
@Cyoce Simplemente sucede que una nueva línea genera otra nueva línea en GS2.
Esolanging Fruit
299

H9 + : 1 char

9

Eso es correcto. Un personaje Emite la letra a 99 botellas de cerveza , que es un programa válido. Todos los datos extraños no cuentan, pero hay muchos 9s allí.

La salida del programa generado es la letra de 99 botellas de cerveza 59 veces.

Esta función proporciona el número de veces que se emiten las letras si ejecuta los ntiempos del programa (si mi cálculo es correcto):

f(n) = 59n-1
Justin
fuente
32
Un programa de 0 caracteres en un idioma dado, dado que es válido, probablemente generará 0 caracteres. Y dado que 0 * x = 0 para cualquier valor finito x, puedo afirmar que mi programa de salida es en realidad 9999999999999999 veces más grande que el código fuente.
nitro2k01
39
@JohannesH. Para todos los problemas (solucionables) existe un lenguaje de programación que resuelve el problema en 0 caracteres.
Cruncher
15
Todavía me conmuevo por el nombre de "Teorema de Cruncher", a menos que ya se haya descubierto.
Erty Seidohl
22
Una característica interesante es que también contendrá 2*59^n-2instancias de "¡Hola, mundo!", Debido a la "h" en "el".
AJMansfield
8
Parece que has sido vencido.
PyRulez
118

GolfScript, 9 caracteres

{.'.~'}.~

Este código genera:

{.'.~'}{.'.~'}.~

que salidas:

{.'.~'}{.'.~'}{.'.~'}.~

que salidas:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

y así.

Creo que esta es la respuesta más corta en un lenguaje de programación "real" completo de Turing hasta ahora.

Explicación:

Básicamente, el código original anterior es una "capa de quine": genera una quine normal seguida por sí misma.

En GolfScript, cualquier literal de bloque de código (por ejemplo {foo}), si no se altera en la pila, es una quine. Por lo tanto, por sí solo, {.'.~'}simplemente se genera, como lo haría cualquier otro bloque de código.

Al .~final del código toma el último bloque de código en la pila, lo duplica y ejecuta la copia. Cuando se ejecuta, el código .'.~'dentro del bloque de código duplica el elemento superior de la pila (es decir, la copia de sí mismo) y agrega la cadena .~.

Al final del programa, el intérprete de GolfScript stringifica y genera todo en la pila, que, en este caso, consiste en un {.'.~'}bloque más que en la entrada, más la cadena .~.

Prima:

Agregar un ]antes del primero .(para recopilar todos los bloques de código de la pila en una matriz antes de que se dupliquen) hace que crezca exponencialmente:

{].'.~'}.~

salidas:

{].'.~'}{].'.~'}.~

que salidas:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

que salidas:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

y así.

Ilmari Karonen
fuente
196
{].'.~'}.~︵ ┻━┻
nitro2k01
2
bit.ly/1cQXJyA
Jason C
2
@ nitro2k01 mis primeros pensamientos exactamente: D
Songo
1
¿Es "real" entre comillas porque HQ9 + no es real o porque GolfScript no es real, o ambos?
Roger Pate
1
@thepiercingarrow el código fuente se parece a esto
Rod
108

Java 7: 0 caracteres



Guardar como archivo Blank.java. Si lo guarda como cualquier otro archivo, reemplace cualquier instancia de Blankcon el nombre de archivo apropiado.

Luego, ejecute en la línea de comando a través de la primera compilación, luego ejecute. Si la compilación falla, deténgase.

Enumero esto como Java 7 porque podría generar resultados diferentes para diferentes versiones de Java.

Primeras pocas salidas (enviadas a stderr):

Error: Could not find or load main class Blank
Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors
Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors
Justin
fuente
23
"Debe escribir un programa que generará el código fuente que es" Se puede decir que la salida no es el código fuente. Y además, dependiendo de la definición de salida (si la salida debe provenir específicamente de stdout) nada es realmente salida.
nitro2k01
43
@ nitro2k01 Cito lo mismo: "Debe escribir un programa que genere el código fuente ". Cualquier cosa es el código fuente. Pero solo algunas cosas son código fuente válido . Además, no se especificó lo que se considera salida, por lo que tengo libertad allí.
Justin
15
@PyRulez Eso es correcto. Exploté tus reglas. No necesita aceptar esta respuesta. Cuando publiqué esto, sabía que seguiría una controversia, completa con muchos votos hacia arriba y hacia abajo. Sin embargo, decidí que valdría la pena.
Justin
29
¿Estás seguro de que el programa mismo imprimió la salida? ¿No era solo el compilador? El programa nunca se compila y en sí mismo no se interpreta ni se ejecuta, por lo que no pudo producir ningún resultado.
VX
12
@ blabla999 No estoy de acuerdo: la gente no prueba estos desafíos porque alguien más hace algo loco. Simplemente nos desafiamos a hacerlo de otra manera. Como dice Mark Rosewater, "Las restricciones
generan
79

HQ9 +, HQ9 ++ y similares, 2 caracteres

QQ

Esta es la salida:

QQQQ
Victor Stafusa
fuente
36
Vi esto y pensé "Oh no, nada puede superar esto". Empecé a tratar de encontrar algo, luego me golpeó. Entonces publiqué una respuesta.
Justin
1
@Quincunx Bravo, votó por su respuesta.
Victor Stafusa
44
@Quincunx No, creo que es 2^2^n, donde el programa inicial es la generación 0. La duración se repite m -> m^2.
Vortico
3
@Vortico Buen punto. Aunque lo dije mal, quise decir: a la longitud del código n, la salida se convierte n^n. Sin embargo, eso es falso; cuando la longitud del código es n, la longitud de la salida esn^2
Justin
2
Sin embargo, es divertido porque incluso las dos primeras iteraciones son posibles contendientes para esta pregunta.
PyRulez
29

Rubí 27

Una versión muy ligeramente modificada de esto ( vía ):

puts <<3*3,3
puts <<3*3,3
3

El número de veces que putsse imprime -line crece exponencialmente.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283
daniero
fuente
17
Respuesta inspirada por los Kaiser Chiefs
Ben Jackson
25

Cálculo Lambda - 29

Un término lambda simple

(λu.(u u)(u u))(λu.(u u)(u u))

La reducción de este término en una reducción beta produce

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

Y así sucesivamente y así sucesivamente. Es una variante simple del clásico, (λu.u u)(λu.u u)que es una quine en el cálculo lambda, la doble aplicación automática aquí significa que obtenemos el doble de salida.

jozefg
fuente
77
Yo diría que en el cálculo lambda, "ejecutar" un término lambda significa calcular su forma normal, no realizar una sola reducción beta. Además, un término puede contener múltiples redexes, por lo tanto, "reducir una sola redex" es una operación ambigua.
Petr Pudlák
2
Tiene razón, pero dado que este término no tiene una forma normal, tiene sentido hablar de esto en términos de reducción de pequeños pasos. Dado que el cálculo lambda carece de una evaluación de conjunto inherente, puedo definir "ejecutarlo" para reducir una sola redex redex de nivel superior con semántica llamada por nombre ¿no?
jozefg
3
Bueno, los términos sin forma normal corresponden a programas que no terminan. Y el problema con la redex de nivel superior es que un término puede tener dos redexes, ninguno de los cuales es un sub-término de otro. Podría elegir algún criterio para reducir, pero yo diría que se está alejando mucho de la semántica de cálculo lambda estándar. (De todos modos, aprecio tu idea novedosa.)
Petr Pudlák
2
(λx.xxx) (λx.xxx): 20
Fabio F.
2
(λx. xx) (λx. xxx) se reduce a eso en un solo paso
Ben Millwood
23

SH script, 9

cat $0 $0

Crece a ritmo exponencial.

Ejecútelo sh whatever.sho configúrelo como ejecutable.

La versión de Windows está aquí .

Jason C
fuente
2
Cuando escribo este comentario, la página de Quine Wiki dice que leer del sistema de archivos es una trampa.
Lord Ratte
3
@LordRatte Por otro lado, el desafío no era escribir una quine.
Jason C
20

dc 11

Bastante sencillo:

6579792
dfP

La primera línea se repite una vez cada generación:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

La última línea consta de las siguientes instrucciones: dduplica el último valor puesto en la pila (6579792) (para que obtengamos una copia más cada vez que la ejecutamos), fimprime la pila completa (que es un montón de ese mismo número) y Pimprime el número (6579792) como una secuencia de bytes, que se muestra como dfP.

daniero
fuente
16

código rojo (solución recursiva)

Este es el código del guerrero más fácil de escribir en redcode , el famoso Imp:

MOV 0, 1

Cuando se ejecuta, el código escribe una copia de su única instrucción en la siguiente dirección en la memoria; luego lo ejecuta, etc.

Thomas Baruchel
fuente
15

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Esto podría acortarse reemplazando __ file__ con un nombre de archivo de un solo carácter y guardando el archivo así, pero sentí que esta respuesta estaba más en el espíritu de la pregunta. Después de una iteración, genera:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()
usuario1547129
fuente
3
Esto no es una quine. Ver la definición .
Petr Pudlák
14
@ PetrPudlák Tampoco hay ningún programa en esta pregunta. Este es un problema de variante de quine, no un quining estricto.
AJMansfield
6

Smalltalk, 125 61 57

La versión de golf parece casi ilegible, así que explicaré primero (y usaré identificadores reales).

Esta es una variante del método de auto-modificación "weirdest-way-to-produce-a-stack-overflow".

El método imprime un mensaje de saludo y su fuente actual (solo para la demostración). Luego, el código se modifica para generar una cadena más larga y se instala. Finalmente, el nuevo código se llama recursivamente.

Para protegerme de una fuga inmediata, permite al usuario confirmar en cada ciclo.

compilar en objeto:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

comience el show enviando "eatMe_alice" a cualquier objeto; nil hará:

nil eatMe_alice

Una buena variante es no llamar al nuevo código de forma recursiva, sino iterativa, desconectando la pila de llamadas y volviendo a ingresar al nuevo método. Esto tiene la ventaja de no conducir a una excepción de recursión. Para hacer esto, reemplace la llamada recursiva ("self eatMe_alice") por:

thisContext resend

Golf:

Obviamente, no se solicitó la impresión y la auto llamada, por lo que lo más corto (para el golf) es simplemente agregar un comentario a mi propia fuente y devolverlo. Como efecto secundario, también se instala para la próxima llamada ...

x|s|Object compile:(s:=thisContext method source,'""').^s
blabla999
fuente
5

SH script, 12 8 7

Almacenar un archivo con

sed p *

en su propio directorio vacío y ejecutar desde este directorio usando sh [file]o establecer ejecutable.


Antigua alternativa con 8 caracteres , pero no necesita su propio directorio. Almacenar un archivo con

sed p $0

y ejecutar usando sh [file]o establecer ejecutable.

Antigua alternativa con 12 caracteres :

sed -i- p $0

En realidad, esto se enviará al archivo del programa en sí, pero no se especificó dónde generarlo. Se replica a sí mismo a una tasa exponencial.

Jens Erat
fuente
1
Es posible que todavía tenga la oportunidad de usar ed, no quería mirar a través de su página de manual ...
Jens Erat
4

JavaScript, 41 , 40 caracteres

function f(){console.log(f+"f(f())")}f()

La primera vez que lo ejecuta, se genera con otro ;f()al final. Las ejecuciones posteriores de la salida dan como resultado que cada fuente de "entrada" se imprima dos veces.

alertsería más corto console.logpero no considero que los diálogos de alertas múltiples sean "la" salida, aunque parece razonable llamar a varias líneas en la consola como salida.

DocMax
fuente
Puede guardar un byte en "f(f())"lugar de"f();f()"
Hedi
Esto no parece funcionar para mí ...
Destructible Lemon
3

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Crece a ritmo exponencial.

Versión SH equivalente aquí .

Jason C
fuente
3

reticular, 11 bytes, no competitiva

"'34'coo1o;

Este es el marco de trabajo estándar, excepto que 1se imprime un extra después de cada iteración. Pruébalo en línea!

Primeras pocas salidas:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111
Conor O'Brien
fuente
3

Microscript II, 6 bytes

Sin competencia, el lenguaje es posterior al desafío.

"qp"qp

La primera iteración agrega un extra qpal final, y cada iteración sucesiva agrega una copia extra de este programa original al principio.

SuperJedi224
fuente
3

J , 1 byte

'

Pruébalo en línea!

La cita abierta da, obviamente, el error de la cita abierta:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Tenga en cuenta que, por la naturaleza del intérprete J, los errores se imprimen en STDOUT , no en STDERR.

Cuando lo anterior se ejecuta como código, imprime:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Entonces

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

y así. Cada vez que se ejecuta el código, la segunda línea se rellena a la izquierda con cuatro bytes |   , cumpliendo el requisito de este desafío.

J , variante quine adecuada, 25 bytes

echo,~'echo,:~(,quote)'''

Pruébalo en línea!

Salidas

echo,:~(,quote)'echo,:~(,quote)'

Y luego sale dos veces, en líneas separadas:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

entonces

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

y así.

El primer resultado es una variante simple de J quine estándar . El agregado se ,:~concatena verticalmente, donde la matriz 2D resultante se imprime como dos filas de la misma cadena.

Bubbler
fuente
2

EcmaScript 6 (51 bytes):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Produce una versión más larga de sí mismo, que puede producir una versión más larga de sí mismo, que puede producir una versión más larga de sí mismo, etc.

Cepillo de dientes
fuente
2

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Agregará un punto y coma en cada ejecución.

ComFreek
fuente
¿Los códigos de punto y coma son inútiles?
Justin
3
@Quincunx Son, tienes razón. Sin embargo, ¿qué consideraría código útil?
ComFreek
Tal vez podrías poner en el ';'. Entonces obtendrás salidas más largas.
Justin
1
¿por qué no <?=fgets(fopen(__FILE__,'r')).';';?
Ismael Miguel
1
;<?echo fgets(fopen(__FILE__,'r'));
jimmy23013
2

ECMAScript 6 (38 caracteres)

(f=_=>'(f='+f+')();(f='+f+')();')();

Qué salidas:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Editar

Podrías hacer (28 caracteres):

(f=_=>'(f='+f+')();'+f())();

Sin embargo, se repetirá infinitamente y nunca devolverá nada ... pero esto se puede resolver haciendo algo como esto (42 caracteres):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Lo que dará salida:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);
MT0
fuente
3
+_+ =_=+1 para emoticones
TuxCrafting
2

Lisp común, 16 caracteres

(print `(or ,-))

Por supuesto, es solo interactivo, pero ser capaz de hacer referencia al formulario actual de nivel superior es probablemente la mejor manera de minimizar un programa no trivial que cumpla con la especificación.

Lo que sería realmente interesante es lo que explota más rápido. Tal vez algo como

(print `(progn ,@(loop repeat (length -) collect -)))

Stuart Olsen
fuente
+1 para Common Lisp. Me parece que puedes saltarte `y ,?
daniero
@daniero Sin la cita, solo imprime el programa original, sin crecer nunca. En ese punto, también puede omitir el or:(print -)
Stuart Olsen
2

Julia, 66 caracteres

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Salida (134 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Resultado de ejecutar el resultado (268 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

próximo resultado (536 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Siguiente resultado (1072 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Espero que esto sea de acuerdo con las reglas.

Produce una salida más grande, y la salida en sí misma es un código fuente válido que produce una salida más grande nuevamente.

ML
fuente
¿La salida, cuando se ejecuta, producirá una entrada válida?
PyRulez
En el primer ejemplo, la salida es un código válido. Es un literal de cadena que contiene 5 puntos. En el segundo ejemplo, ingresar el prompt de julia no haría nada. Simplemente pensé que solo dar a la respuesta un carácter de nueva línea presionando enter produce una salida más larga que la entrada.
ML
¿"....." producirá una versión más grande de sí mismo?
PyRulez
Ah, ahora entiendo. Acabo de notar que tenía que ser recursivo ... hora de corregir mi solución. Gracias por la pista.
ML
1
Supongo que el código está de acuerdo con las reglas ahora.
ML
2

05AB1E, 15 bytes, sin competencia

0"DÐ34çý"DÐ34çý

Pruébalo en línea!

Impresiones 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
que imprime 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
etc.

Oliver Ni
fuente
Ambas instancias de DDpueden ser reemplazadas por Ð.
Emigna
1
¿Por qué no competir?
MD XF
2

Evoloop, rectángulo 9 × 9 (81 celdas)

El autómata celular Evoloop incluido con Golly admite patrones que se replican a sí mismos de forma "parecida a un quine". Específicamente, estos patrones contienen cada uno un "programa"; un patrón se reproduce ejecutando primero el programa (que crea el "cuerpo" de la hija) y luego copiando el programa en la hija.

Lo anterior se aplica al autómata celular más famoso "Langton's Loops", así como a Evoloop, pero Evoloop tiene una diferencia interesante, que es que es fácil crear un patrón que crezca en cada generación sucesiva.

(¡Mucho más interesante, en mi opinión, es el hecho de que Evoloop es un simple autómata celular que contiene patrones que se reproducen y evolucionan de una manera muy realista! Creo que los únicos autómatas celulares conocidos que hacen esto son Evoloop y sus descendientes Sin embargo, una deficiencia de Evoloop es que existe un "mejor" genoma particular; la evolución siempre converge a este genoma).

Ahora, hay dos deficiencias en esta presentación. Una es que no está claro cuál es la "salida" de un autómata celular. Pero creo que un autómata autorreproductor está "lo suficientemente cerca" de ser una quine; ciertamente no es menos interesante! La otra deficiencia es que estos patrones no solo crean una sola copia de sí mismos; cada copia del patrón original intenta crear infinitas copias de sí mismo, y estas copias terminan interactuando entre sí de una manera destructiva. Entonces, creo que he cumplido los requisitos de este desafío en espíritu, pero no en la carta.

Sin más preámbulos, el patrón es:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Aquí está el patrón nuevamente, en un formato que se puede copiar y pegar en Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

De acuerdo, pero ¿cómo se ve? Se parece a esto:

Un patrón en un autómata celular que crea copias cada vez más grandes de sí mismo.

En la animación anterior, puede ver que el patrón inicial crea una hija más grande, que crea una nieta más grande, luego una bisnieta más grande y, finalmente, una tataranieta aún más grande que comienza a construir una tercera tataranieta aún más grande. nieta. Si ejecutaras este patrón durante mucho tiempo, continuaría así para siempre (o tal vez eventualmente serían superados por los organismos evolucionados, que son capaces de reproducirse mucho más rápido; no estoy seguro).

Tanner Swett
fuente
1

LOTE, 26

Coloque este código en cualquier archivo .bat y continuará ejecutándose (en un bucle infinito) y el archivo también crecerá.

echo echo %0 ^>^> %0 >> %0
ub3rst4r
fuente
Esto no funciona del todo, %0es el comando utilizado para invocar el script, que puede no tener una .BATextensión. Puede usar %~nx0para obtener el nombre de archivo completo del archivo por lotes.
Jason C
@JasonC AFAIK, no necesita .batque se ejecute. Si el nombre del archivo es execute.bat, puede ingresar executeo execute.bat. Ambos funcionarán.
ub3rst4r
El propio archivo debe tener una .batextensión de ejecutar, pero se puede salir de la extensión cuando lo ejecutas (cuando se escribe un comando sin extensión, Windows intenta .com, .exey, a continuación .bat, en ese orden). Si el nombre del archivo es hello.bat, entonces >> %0escribirá un archivo llamado hello, que no es el original hello.bat(y no se puede ejecutar).
Jason C
1

PYG (6)

P(Q,Q)

Imprime su propio código fuente, separado por nuevas líneas. La segunda generación sería

P(Q,Q)
P(Q,Q)

Etcétera.

ɐɔıʇǝɥʇuʎs
fuente
1

ACEITE , 83 bytes

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Primero imprime dos líneas con un cero en ellas, y luego compara cada línea con la línea 1, si son iguales (que es el caso cuando el archivo está agotado), imprimimos lo que está en la celda 26. La salida resultante se verá igual, excepto con un agregado 33, que no hace nada. La próxima vez, se agregará otra línea, y así sucesivamente.

L3viatán
fuente
1

Ayuda, WarDoq! , 1 byte.

H

Impresiones Hello, World!.

Otros caracteres que H son código fuente válido (y seguro) (que imprime otras variantes de Hello World).

n4melyh4xor
fuente
También funciona en (variantes de) HQ9 +.
CalculatorFeline
@CalculatorFeline en HQ9 + esto no continuaría creciendo.
Martin Ender