Una quine 1-up es un programa que es muy similar a una quine. La principal diferencia es que, en lugar de imprimirse una vez, cuando se concatenan n copias del programa, el resultado imprime el programa original n + 1 veces.

Ejemplo

Si su programa es Abc123:

Abc123  ->  Abc123Abc123
Abc123Abc123  ->  Abc123Abc123Abc123
Abc123Abc123Abc123  -> Abc123Abc123Abc123Abc123

Reto

Su desafío es crear la quine 1-up válida más corta en cualquier idioma. Se aplican las reglas habituales de quine, por lo que no puede:

• Envía el programa vacío.
• Directamente o indirectamente lea ¹ el código fuente.
• Utilice las funciones integradas de comillas.

Este es el código de golf, por lo que gana el código más corto en bytes.

^{1 Esto no incluye el uso de una cadena codificada o un bloque de código como parte de su programa.}

GolfScript, 12 bytes

{`'.~'+:n}.~

Pruébalo en línea!

Explicación

Esto combina ideas del quine estándar de GolfScript:

{'.~'}.~

Y mi quine recientemente descubierta :

":n`":n`

La idea principal es nuevamente usar el nque está impreso implícitamente al final del programa para obtener la copia adicional de la quine. Dado que la asignación de la variable no cambia nada cuando se realiza nuevamente en copias posteriores, esto solo agregará una copia. Aquí hay un desglose del código:

{        # Standard quine framework. This pushes the block, duplicates it and runs the
         # second copy, such that it can process the first copy to create a quine.
  `      # Convert the block to its string representation.
  '.~'+  # Append the string '.~' to make a complete quine. This is simply left on the
         # stack to be printed at the end.
  :n     # Store the string in n such that one more copy is printed at the end.
}.~

GolfScript, 12 bytes

{: ".~"][}.~

Pruébalo en línea!

Cómo funciona el código fuente

{: ".~"][}.~

{        }    Define and push a code block.
          .~  Push a copy and execute it.
 :            Save the code block in the space character.
              Every subsequent space will now execute the code block.
   ".~"       Push that string.
       ]      Wrap everything up to the last [ in an array.
        [     Set a new array marker.

Si el código fuente anterior se ejecuta una vez, la pila terminará como

["" {: ".~"]} ".~"]

donde la cadena vacía al principio corresponde al estado inicial de la pila (entrada vacía).

Dos copias del código fuente dejarían un estado final de

["" {: ".~"]} ".~"] [{: ".~"]} ".~"]

tres copias de un estado final de

["" {: ".~"]} ".~"] [{: ".~"]} ".~"] [{: ".~"]} ".~"]

y así.

Que pasa despues

Después de ejecutar el código fuente, el intérprete hace lo siguiente.

1. Envuelve toda la pila en una matriz y empuja esa matriz en la pila.

   Para dos copias del código fuente, la pila ahora contiene

   ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [["" {: ".~"][} ".~"] [{: ".~"][} ".~"]]
   

2. Se ejecutó putscon la intención de imprimir la pila envuelta, seguido de un salto de línea.

   putsse define como {print n print}, por lo que hace lo siguiente.

   1. printimprime la copia envuelta de la pila sin inspeccionarla (es decir, sin convertirla en su representación de cadena). Esto envía

      {: ".~"][}.~{: ".~"][}.~
      

      (el código fuente) a STDOUT y muestra la copia de la pila desde la parte superior de la pila.

      La pila ahora contiene

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"]
      

   2. ejecuta el bloque de código que definimos anteriormente.

      :comienza guardando [{: ".~"][} ".~"]el carácter de espacio, luego se ".~"empuja a sí mismo, lo ]envuelve ".~"en una matriz y [establece un nuevo marcador de matriz.

   3. n empuja una cadena que consiste en un solo salto de línea.

      La pila ahora contiene

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n"
      

   4. se ejecuta una vez más. Sin embargo, se redefinió cuando lo llamamos por primera vez y ahora contiene una matriz, no un bloque de código.

      De hecho, empuja [{: ".~"][} ".~"], dejando la pila como

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n" [{: ".~"][} ".~"]
      

   5. Finalmente, printimprime el elemento de la pila superior sin inspeccionarlo, enviando

      {: ".~"][}.~
      

      a STDOUT, subiendo 1 el código fuente.

Javascript ES6 (REPL), 55 bytes

var a=-~a;$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

¡Guardado 2 bytes gracias a @ user81655!

Explicación

Aquí está el marco estándar de quine:

$=_=>`$=${$};$()`;$()

Debería poder ver este marco dentro del envío. Más explicación a continuación.

var a=-~a;

Este es el contador, predeterminado en 1. Básicamente, nos dice cuánto repetir el quine y los incrementos al mismo tiempo.

$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Esta es la parte quine. Esencialmente repetimos la cadena de quine por el contador + 1. Las llamadas a funciones posteriores anularán la salida.

CJam, 14 bytes

{"_~"]-2>_o}_~

Pruébalo en línea!

Cómo funciona

{"_~"]-2>_o}_~

{          }    Define a code block and push it on the stack.
            _~  Push and execute a copy of it.
 "_~"           Push that string.
     ]          Wrap the entire stack in an array.
      -2>       Discard all but the last two elements (block and string).
         _o     Push and print a copy of that array.

Después de que se haya ejecutado la última copia del programa, la matriz que contiene el bloque y la cadena todavía está en la pila, por lo que se imprime implícitamente.

Groovy, 83 bytes

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Hay una nueva línea incrustada y sin cola. Esto imprime:

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

La función f()imprime una copia de la quine. El programa inicial lo llama dos veces. La primera línea del código adjunto se convierte en un comentario y solo f()se ejecuta la segunda llamada a .

Ruby, 43 bytes

1;s="1;s=%p;$><<s%%s*n=2-0";$><<s%s*n=2-0

Por sí mismo, esto se imprime 2-0o se imprime 2veces. Cuando se concatena con otra copia de sí mismo, la declaración de impresión final se ve $><<s%s*n=2-01, lo que significa que se genera solo una vez ( 01siendo octal 1). Entonces, solo la copia final de la cadena se imprime dos veces, las otras se imprimen una vez.

La asignación en línea a nes solo para que el orden de las operaciones funcione correctamente; En realidad, el estado no se pasa de una copia a la siguiente.

NodoJS, 63 61 60 55 bytes

esto también funcionará en JavaScript (ES6) si considera que varios mensajes de la consola están separados por líneas nuevas (no se requiere REPL)

Guardado 2 bytes gracias a @ dev-null

(f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t()))()

tenga en cuenta que hay una nueva línea al final del código.

Este fue uno interesante, definitivamente uno de mis favoritos para este sitio hasta ahora.

Estoy bastante seguro de que esto no se puede jugar mucho más. (tal vez la printfunción de SpiderMonkey ...)

Explicación

//FIRST ITERATION
            console.log(`(f=${f})()`)                   //logs to the console a quine of the source code using function f's toString()
                                     ||                 //causes the expression to evaluate to the second part, since console.log's return value is falsy
                                       (_=>t)           //a function that returns function t when called
       t=_=>                                            //defines function t to be the code above. When called, t will log a quine and then return a function that returns t.
      (                                      )(t())     //call t twice. (one call is done via the t() as an ignored parameter) This will print the quine twice.
 f=_=>                                                  //define f as the above code.
(                                                  )()  //call function f with no arguments. this results in a function returning t. (the result of calling t once)
                                                        //this newline is to compensate for console.log's behavior of adding a newline to its output
//SECOND ITERATION
(                                                  )    //call the function that returns t that was returned from the first iteration. This expression will result in whatever that function returns, which is t.
 f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t())     //this part evaluates to a function, which is passed as a parameter to the function that returns t, that ignores its parameter.
                                                    ()  //call whatever the last expression returned, which is the function t, with no parameters. This will print the quine once.
                                                        //this call will result in a function returning t, just like from the first iteration, so we can add on more iterations at will.

Ruby, 55 bytes

n||=2;s="n||=2;s=%p;$><<(s%%s)*n;n=1;";$><<(s%s)*n;n=1;

Nada muy interesante aquí, es solo una quina de rubí normal con un contador.

JavaScript (ES6), 164 bytes

console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))
console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))

Funciona en cualquier página o consola de prueba de JS en Firefox, suponiendo que el espacio entre dos mensajes de la consola cuenta como una nueva línea.

Perl 6 , 58 53 bytes

Gracias a Jo King por -5 bytes.

<say "<$_>~~.EVAL for 0..!.++;">~~.EVAL for 0..!.++;

Basado en la quine de Jo King .

Pruébalo en línea!

Japt, 40 bytes

Oo("+Q ²pT°?1:2 é4;POo("+Q ²pT°?1:2 é4;P

¡Pruébelo en línea! Explicación por venir.

Y

Sin competencia, 6 bytes

UCn*px

Y es un cañón de cabeza que he tenido por un tiempo, y esto me inspiró a escribirlo. Está hecho para desafíos en los que la secuencia es clave, como esta. El código se divide en enlaces por caracteres de "nodo". En este caso, nuestro código se coloca en dos cadenas (originalmente), siendo el nodo C.

U  C  n* px
1  N    2

Uregistra una cadena trascendental, es decir, una que abarca enlaces. Graba hasta que se encuentra con otro U. Si a Uno se cumple al final de la cadena, se envuelve. Además, Use incluye en la cadena de forma predeterminada. Después de grabar la cadena, procedemos al nodo C, que simplemente nos mueve al siguiente enlace.

nempuja el número de cadenas. Para nuestro caso base, este 2. Para una secuencia de Kcadenas, hay K+2cadenas, como Knodos. *es la repittion de cadenas. pimprime toda la pila (en este caso, una cadena) y xfinaliza el programa.

En un texto:

UCn*px
U..... record that string
 C     next link
  n*   repeat that string twice.
    px print and terminate

UCn*pxUCn*pxUCn*px
U.....U            record string
 C                 next link
  n*               repeat that string four times (three Cs)
    px             print and terminate

Pruébalo aquí!

Brachylog , 20 bytes

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Pruébalo en línea!

Modificado de esta quine.

⊥                       Fail,
 ∨                      or
                w       print
  "⊥∨~kgjw₃w₅"          "⊥∨~kgjw₃w₅"
                 ₃      formatted
              gj        with itself;
                 ₃w₅    print it again at the end of the program if this route succeeds.

Cuando esto se concatena consigo mismo, cada ruta, excepto la última, falla y el programa pasa a la siguiente, ejecutando cada una w₃y retrocediendo cada una w₅excepto la última.

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Pruébalo en línea!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Pruébalo en línea!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Pruébalo en línea!