Código de código propio código codeee codeeee

41

Escriba un programa (o función) (llamémoslo P1), que cuando se ejecuta, genera otro programa P2 del mismo lenguaje y exactamente 1 byte más largo que P1.

El programa P2 cuando se ejecuta, debería generar un tercer programa P3 que sea 1 byte más largo que P2. P3 debe generar un programa P4 que sea un byte más largo que P3, etc. Lo mismo para P5, P6, ..., P∞.

La cadena del programa debe ir indefinidamente o a un lugar donde el intérprete ya no pueda manejar (pero debe permanecer como un programa teóricamente válido en el lenguaje)

Reglas

Lagunas estándar prohibidas
Todos los programas de la cadena deben estar en un idioma.
No se da entrada. La salida va a stdout o al valor de retorno de la función
El programa debe finalizar después de un período de tiempo. Un programa que deja de generar resultados después de un cierto punto de tiempo pero nunca termina no califica

¡El programa más corto P1 en bytes en cada idioma gana!

code-golf quine iBug
fuente

2

@ Οurous ¿Qué ??? No

agregué

66

@iBug Independientemente, ¿las presentaciones pueden leer su propio código fuente?

Martin Ender

3

@iBug La etiqueta "quine" lo prohíbe por defecto, y generalmente hace que las respuestas sean más interesantes. Sin embargo, depende de ti.

Martin Ender

1

"puts <<2*2,2\nputs <<2*2,2\n\n2"crece en 2 en cada iteración en Ruby. No pude encontrar nada mejor. : - /. Interesante desafío!

Eric Duminil

1

Posible duplicado del programa que crea versiones más grandes de sí mismo (variante quine)

FireCubez

Respuestas:

28

JavaScript (ES6), 14 12 bytes

-2 bytes gracias a @Shaggy

f=_=>"f=_"+f

Fragmento de prueba

Mostrar fragmento de código

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

Expandir fragmento

Herman L
fuente

Me tomó un segundo descubrirlo. ¡Furtivo!

Shaggy

44

¿Puede alguien explicarme, no puedo entenderlo, cómo aumenta?

htmlcoderexe

2

@htmlcoderexe "f=_"antepone un extra _antes del nombre del parámetro, lo que hace que aumente de longitud cada iteración.

Herman L

9

7 , 4 bytes de ASCII

Pruébalo en línea!

Sé que 7 normalmente no está codificado en ASCII, pero esta vez es una codificación más conveniente, por lo que estamos agregando 1 byte con cada ejecución, no 3 bits.

Tampoco estoy seguro de si esto cuenta como trampa o no. (Es habitual no estar claro si un 7 quine está engañando, ya que se extiende a lo largo de la frontera de varias maneras). Puede hacer un argumento decente de que 0codifica el 6, pero en general no está claro de dónde provienen los caracteres resultantes " "en 7 porque tiene muchos comportamientos implícitos bastante extraños.

Este programa se imprime con 1adjunto, y lo hará incluso si le agrega una serie de 1s. Aquí hay un rastro de depuración comentado de 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(No quedan |en el programa, por lo que esaldrá inmediatamente del programa como un efecto secundario, lo que significa que el final 7nunca se ejecuta).

La confusión básica acerca de dónde provienen todos los caracteres es que la mayoría de los comandos en 7 solo producen datos cuando se ejecutan, y luego 6intenta reconstruir una secuencia de comandos que produciría el fragmento de datos dado; esto a menudo termina cerca, pero no idéntico al original. (Para fines de combinación, normalmente escribe un programa 7 de tal manera que el resultado será casi el mismo, normalmente diferirá en los 7s iniciales o finales ). Así, por ejemplo, se 1convierte en los datos 716, que es la forma más fácil de agregar 1a la cadena de datos actual. Originalmente lo produjimos con 16una secuencia de caracteres diferente (pero similar), eliminando destructivamente uno de los|marcadores con los que comenzaron los datos. (¡Creo que quizás el mejor argumento de que esto no es una quine literal es que la salida es diferente de la entrada!)

ais523
fuente

9

Haskell , 74 66 bytes

EDITAR:

-2 bytes por H.PWiz usando <>, luego -6 moviendo el (10*)<$>.

Esto ahora usa el <>operador recientemente libre (la Semigroupmultiplicación requiere que GHC 8.4 funcione sin importar).

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Pruébalo en línea! (Trucos con una importación ya que TIO aún no tiene GHC 8.4).

Cómo funciona

main=putStr$ es repetitivo para generar el siguiente valor de cadena.
fst<>showes una función que toma una tupla y devuelve una cadena que consiste en el primer elemento de la tupla concatenado con la representación de cadena de la tupla. Es decir
```
(fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)
```
(10*)<$>multiplica el último elemento de la siguiente tupla por 10, agregando un dígito 0a su representación de cadena.

Ørjan Johansen
fuente

1

Puede guardar al menos 2 bytes con(<>)

H.PWiz

@ H.PWiz Gracias, obtuve un poco más al mudarme (10*)<$>.

Ørjan Johansen el

8

C (gcc) , 134 132 bytes

Ligera reelaboración de la canina C quine. Terriblemente largo.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Pruébalo en línea!

gastropner
fuente

7

Fisión 2 , 7 bytes

'!+OR!"

Pruébalo en línea!

La quine de fisión estándar , pero con un extra !que imprime un 0x01 adicional al comienzo del código en cada iteración.

Martin Ender
fuente

7

Pari / GP , 35 bytes

(f=(x)->print1("(f="f")("1x")"))(1)

Pruébalo en línea!

alephalpha
fuente

4

Python 2 , 38 bytes

s="print's=%r;exec s'%(s+'#')";exec s

Pruébalo en línea!

totalmente humano
fuente

4

brainfuck , 420 bytes

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Pruébalo en línea!

Esta es una modificación en la quine "estándar" BrainFuck , con un .final que agrega un extra en .cada iteración.

La quine misma codifica los caracteres de Brainfuck como una pila de dígitos hexadecimales: específicamente, los dígitos hexadecimales de c-0x2b, que convenientemente son los siguientes:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

La codificación cubre dos fragmentos de código: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++empuja la codificación de la codificación misma, [[<++++++++++++++++>-]<+++++++++.<]recorre la pila e imprime todo.

nneonneo
fuente

3

Sucio , 9 bytes

'"n[!]a!␛

Pruébalo en línea!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Si se permite la lectura del código fuente:

Sucio , 8 bytes

Q[!]W33!

Pruébalo en línea!

Explicado:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Puede ser valido:

Sucio , 4 bytes

Q[‼]

Pruébalo en línea!

Imprime el código fuente con una nueva línea final.
(Y un montón de espacios, debido a un error. Sin embargo, funciona igual sin ellos).

Tenga en cuenta que solo funciona en el conjunto de caracteres nativos, y no cuando usa el front-end UTF8, por lo que para probarlo en TIO debe reemplazar el carácter que genera entre []s ‼, que es el equivalente UTF8 para lo que está imprimiendo .

Οurous
fuente

1

La versión de 4 bytes es definitivamente inválida.

Erik the Outgolfer

3

Java 8, 162146 bytes

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Pruébalo en línea.
Pruebe el primer programa de salida ; Pruebe el segundo programa de salida ; Prueba el tercer programa de salida .

Explicación:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -parte:

El String scontiene el código fuente sin formato.
%sse utiliza para ingresar esta cadena en sí misma con el s.format(...).
%c, %1$cy 34se usan para formatear las comillas dobles.
s.format(s,34,s) lo pone todo junto

Parte del desafío:

+1 agrega un 1 tanto al programa sin formato como al formato.
.replaceAll("1+$","");}: Debido a que solo queremos aumentar el conteo de bytes del programa en uno en lugar de dos, eliminamos los 1 finales antes de regresar.

Kevin Cruijssen
fuente

2

> <> , 9 bytes

#o<:}-1:"

Pruébalo en línea!

Variación en un clásico> <> quine, que simplemente agrega otro comando de duplicación para copiar #el frente.

Jo King
fuente

2

Perl 5 , 32 bytes

$_=q{say"\$_=q{$_
};eval"};eval

Pruébalo en línea!

Dom Hastings
fuente

2

GolfScript , 9 bytes

{'.~1'}.~

Pruébalo en línea!

CJam , 9 bytes

{"_~1"}_~

Pruébalo en línea!

Estoy publicando ambas soluciones en la misma respuesta, ya que son solo variaciones triviales entre sí y funcionan exactamente de la misma manera. Ambos se basan en la quine común de GolfScript {'.~'}.~(o {"_~"}_~en CJam), que se describe con más detalle, por ejemplo, en esta respuesta anterior mía.

La única diferencia es que esta variante agrega un 1byte al final de su salida. Como sucede, cualquier cadena de 1s (o cualquier otro literal entero sin ceros a la izquierda) es en sí misma una quiv trivial tanto en GolfScript como en CJam, por lo que cualquiera que esté presente al final del código anterior simplemente se copiará textualmente a la salida. Dado que GolfScript (y CJam) usan enteros de longitud arbitraria, esto funcionará para programas arbitrariamente largos, al menos mientras la computadora que ejecuta el código tenga suficiente memoria para almacenarlo.

Ilmari Karonen
fuente

2

Agregado , 76 72 61 bytes

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Pruébalo en línea!

Quine estándar que agrega un espacio al final de xcada iteración.

Primeras iteraciones:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

etc.

Adjunto, 72 bytes

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Pruébalo en línea!

Esto es simplemente una variación del formato estándar quine, con una variable yque se establece 10*ydespués de cada iteración

Las primeras iteraciones:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

etc.

Conor O'Brien
fuente

1

Swift 4 , 89 bytes

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Incluye una nueva línea final

Pruébalo en línea!

Herman L
fuente

1

Haskell , 88 bytes

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Pruébalo en línea! Crece anteponiendo #a la cadena de datos.

Laikoni
fuente

Puede ahorrar un poco showingiriendo más que solo una cadena y utilizando la coincidencia de patrones. Pruébalo en línea!

Ørjan Johansen

@ ØrjanJohansen Nice! A excepción del estándar Haskell quine subyacente, este es un enfoque completamente diferente, así que siéntase libre de publicarlo usted mismo.

Laikoni

OK, si piensas eso.

Ørjan Johansen

1

Stax , 20 18 bytes

"34s+cTZL"34s+cTZL

Ejecutar y depurarlo

Genera un espacio adicional antes de la segunda comilla cada iteración.

Explicación

Utiliza el programa "34s+cTZL "34s+cTZLpara explicar.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Weijun Zhou
fuente

1

Jstx , 4 bytes

£↕♣:

Pruébalo en línea!

Quantum64
fuente

1

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.

Copia directa de esta respuesta en un desafío relacionado. Dio la casualidad de que ya crecía en 1 byte cada iteración (un argumento fuerte para este desafío es un duplicado de ese o viceversa).

Draco18s
fuente

0

Jalea , 11 bytes

“⁾;⁶;ØV” ṘV

Pruébalo en línea!

usuario202729
fuente

0

Maravilla , 33 bytes

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Una variante interesante de la quine normal que agrega un 1 después de cada iteración.

Progresión:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Explicación

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Una de las partes interesantes de este quine es que Wonder puede trabajar con números de precisión arbitraria, por lo que la progresión no se interrumpirá después de una cierta cantidad de unos.

Mama Fun Roll
fuente

0

ColdFusion, 277 bytes

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Esta es una modificación trivial de mi quine ColdFusion que agrega una nueva línea cada vez que se llama.

Probado localmente en lucee-express-5.2.6.60

Dom Hastings
fuente

0

Lote de Windows, 38 36 bytes

echo|set/p"=q">q&copy/b/y %0+q %0
::

Este código crea un archivo llamado "q", que contiene la letra 'q', y luego lo agrega al archivo original. Tenga en cuenta que "::" es un alias para "rem" que no requiere un espacio adicional.

Guardado 2 bytes gracias al usuario 3493001.

Peter Ferrie
fuente

0

Gol> <> , 7 bytes

":r2ssH

Pruébalo en línea! Pruébalo en línea !! Pruébalo en línea !!!

Esta es una variación simple de la quine Gol> <> normal pero agrega una copia de Hcada vez que se ejecuta. Como el Hcomando detiene el programa, adicional Hal final no cambia el comportamiento.

Bubbler
fuente

0

T-SQL , 175 bytes

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Primero escribí un quine SQL, luego lo modifiqué para agregar un espacio extra (algo inspirado por esta respuesta ).

Razvan Socol
fuente

0

Befunge-98 (PyFunge) , 22 19 bytes

r:#,_ #;'D2/'<,,@;"

Pruébalo en línea!

Agrega un <antes de la última "cada generación.

IQuick 143
fuente

0

C # (compilador interactivo de Visual C #) , 89 bytes

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Inspirado por la respuesta de Kevin Cruijssen.

Pruébalo en línea!

Encarnación de la ignorancia
fuente