Quine de crecimiento lento

30

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.

IQuick 143
fuente
3
Sospecho que este desafío es imposible en la mayoría de los idiomas, dado que la lectura del código fuente está prohibida por defecto.
Ørjan Johansen
12
@ ØrjanJohansen y luego aparece Dennis
Rod
2
@ Rod Bueno, no dije todo , es solo que muchos / la mayoría de los idiomas no tienen una forma obvia de agregar fragmentos arbitrarios de código al final de tal manera que (1) no dé un error de sintaxis (2) El programa puede detectar el cambio.
Ørjan Johansen
3
Dado que esta es una quina muy inusual, ¿aún no se permiten las lagunas habituales?
Draconis

Respuestas:

15

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.
jimmy23013
fuente
1
Relacionado: codegolf.stackexchange.com/q/100930/25180
jimmy23013
11

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.

Giuseppe
fuente
vendrá una explicación ... No lo he probado 288 veces todavía, pero estoy bastante convencido de que es correcto
Giuseppe
Probablemente debería ser de 289 bytes ya que la línea agrega un carácter de nueva línea allí, pero de todos modos es genial que lo hayas resuelto
IQuick 143
Ah, tienes razón, estúpido catañadiendo nuevas líneas.
Giuseppe
¿Pero es este un programa completo? ¿Los códigos generados son programas completos?
jimmy23013
@ jimmy23013 Por lo que puedo decir, esta respuesta y el código generado son programas completos. No hay mainninguna otra estructura obligatoria como esa en R. Además, la pregunta no solicita explícitamente un programa completo, por lo que una función o similar funcionaría.
Steadybox
5

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.
Martin Ender
fuente
Gran solución Me gusta la explicación
IQuick 143
4

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.

Ilmari Karonen
fuente
2

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.

IQuick 143
fuente
Es posible que desee mencionar en la primera línea que no es competencia / trampa, solo para desalentar cualquier voto negativo que de otro modo podría recibir.
quintopia
2

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.

jimmy23013
fuente
¡No parece funcionar cuando lo intento en línea! , es solo una quine ordinaria.
Ørjan Johansen
@ ØrjanJohansen Deberías ejecutarlo con php -r 'command'.
jimmy23013
Gah, no puedo hacer que funcione. TIO parece ignorar los argumentos -r.
Ørjan Johansen
@ ØrjanJohansen Así es como debes probarlo.
jimmy23013 17/0318
Ajá. Debo haber entendido mal algo en aquel entonces. Ahora me las arreglé para que funcione también con PHP como configuración de idioma .
Ørjan Johansen
2

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

Draco18s
fuente