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.

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!

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

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

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

HQ9 +, HQ9 ++ y similares, 2 caracteres

QQ

Esta es la salida:

QQQQ

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

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.

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

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.

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.

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()

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

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.

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.

Windows .BAT, 25

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

Crece a ritmo exponencial.

Versión SH equivalente aquí .

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

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.

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.

Encantamientos rúnicos , 6 bytes

"'<S@>

Pruébalo en línea!

Este fue raro. Todo lo que tenía que hacer era eliminar un ~quine original encontrado por Jo King .

Cada ejecución adicional agrega otra <al final, por ejemplo:

"'<S@><<<<<<<<<

Todo lo cual no hace nada.

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.

PHP, 38

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

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

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);

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 -)))

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.

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.

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:

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

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

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.

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.

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