Hacer un quine

Parece fácil ¿verdad? Bueno, esta línea debe aparecer más su primer carácter, que luego se muestra más su segundo carácter, y así sucesivamente.

De esta manera, la quine debería generar en varias generaciones dos copias.

Ejemplo: permite que su código sea x. Ejecutarlo debería dar salida x + x[:1]. Ejecutar el programa resultante debería generar, x + x[:2]etc.

Si su código fue foobar, ejecutar esto debería generar foobarf. Ejecutar esto debería dar salida foobarfo. Y así sucesivamente siguiendo este patrón:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Su programa debe tener más de 2 bytes y debe generar solo UN carácter adicional de su propio código en cada iteración.

zsh ,110 108 100 bytes

a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

Pruébalo en línea!

Entonces es posible.

Explicación

a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

R, 289 bytes

s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

crédito a esta quine por inspiración. Solo funciona si se ejecuta en el mismo entorno R que la quine anterior.

Alice , 29 bytes

4P.a+80pa2*&wdt,kd&w74*,.ok@

Pruébalo en línea!

El carácter no imprimible es 0x18.

Explicación

El problema con las habituales "fungeoid quines es que si repetimos todo el código fuente, también obtenemos más "y la cadena ya no cubre todo el código fuente. Supongo que es por eso que la respuesta existente utiliza el genfoque de trampa en su lugar.

Esta respuesta utiliza el "enfoque basado en, pero en lugar de incluir un "en la fuente, lo escribimos en el programa en tiempo de ejecución. De esa manera, solo habrá uno "independientemente de la frecuencia con la que se repita el programa (porque solo lo escribimos en una coordenada específica, independientemente del tamaño del programa).

La idea general es, entonces, que creamos una representación del código fuente completo en la pila, pero solo recorremos los primeros 29 caracteres (es decir, la longitud del programa) con la longitud del bucle determinada por el tamaño del código. Por lo tanto, en realidad podemos agregar caracteres arbitrarios (excepto los avances de línea) después @y el resultado siempre será una repetición cíclica del programa central, un carácter más largo que la fuente.

4P   Push 4! = 24. This is the code point of the unprintable, which we're 
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all 
     characters after it (including those from extraneous repetitions). Then 
     on top we have the characters that come in front of the `"`. 
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Perl 5 , 83 bytes (incluida la nueva línea final)

$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

Pruébalo en línea!

El buen __DATA__token antiguo hace que sea fácil agregar una cadena arbitraria a cualquier programa Perl, al que el programa principal puede acceder a través del <DATA>identificador de archivo (y en realidad lo usa __END__, lo que hace lo mismo para la compatibilidad con versiones anteriores, en lugar de __DATA__guardar dos bytes adicionales) .

Tenga en cuenta que este programa no lee su propio código fuente, sino solo los datos de entrada adicionales agregados a su fuente después del __END__token. En efecto, el __END__token y todo lo que sigue funciona como una cadena literal terminada al final de la entrada.

También tenga en cuenta que, para cumplir exactamente con las especificaciones, este programa debe terminar en una nueva línea. Si no es así, la nueva línea se agrega automáticamente después de la segunda de __END__todos modos, pero la salida de la primera iteración ya no será exactamente igual al código más su primer byte.

Befunge-98 , 30 bytes

0>:#;0g:840#;+*#1-#,_$a3*%0g,@

Pruébalo en línea!

Intenté usar Befunge-98, que usa una quine terminada en espacio que también cuenta cuántos caracteres han sido superados. Sin embargo, utiliza el gcomando.

PHP, 146 bytes

ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

Debe ejecutarse usando la -rlínea de comando.

Encantamientos rúnicos , 61 bytes

803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

Pruébalo en línea!

Utiliza un enfoque similar al de la respuesta de Alice: escribe reflexivamente el "comando de cadena en el código para que solo haya uno. El resto es una gran cantidad de manipulación de cadenas y pilas para recuperar el programa original, cuántos bytes adicionales se necesitan e imprimir los trozos necesarios.

La }͍secuencia gira la representación de cadena en memoria para que 803X4+kwaparezca al principio en lugar de al final, debido a la posición del "y no hay una manera más fácil de manejar esta operación sin tener que calcular muchos números incómodos .

Mientras que el programa original es de 61 bytes, su longitud de cadena es de solo 50, lo que es fácil de construir ya 5Xque fue una coincidencia que no fuera necesario rellenarlo después de contener todas las funciones necesarias (por ejemplo, un programa de longitud 49 sería más fácil codificar como 50con un byte de relleno que codificar un literal 49, mientras 51que se codificaría como 5X3+o 53, teniendo que tener en cuenta sus propios bytes adicionales).