Um quine 1-up é um programa muito semelhante a um quine. A principal diferença é que, em vez de se imprimir uma vez, quando n cópias do programa são concatenadas, o resultado imprime o programa original n + 1 vezes.

Exemplo

Se o seu programa é Abc123:

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

Desafio

Seu desafio é criar a menor quantidade possível de 1 em 1 em qualquer idioma. As regras habituais de quine se aplicam; portanto, você não pode:

• Envie o programa vazio.
• Lida direta ou indiretamente ¹ o código fonte.
• Use built-ins de quining.

Isso é código-golfe, então o código mais curto em bytes vence.

^{1 Isso não inclui o uso de uma string ou bloco de código codificado como parte do seu programa.}

GolfScript, 12 bytes

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

Experimente online!

Explicação

Isso combina idéias da coluna GolfScript padrão:

{'.~'}.~

E meu quine recentemente descoberto :

":n`":n`

A idéia principal é novamente usar o nque é impresso implicitamente no final do programa para obter a cópia adicional do quine. Como a atribuição da variável não muda nada quando é feita novamente nas cópias subsequentes, isso adiciona apenas uma cópia. Aqui está um detalhamento do 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

{: ".~"][}.~

Experimente online!

Como o código fonte funciona

{: ".~"][}.~

{        }    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.

Se o código fonte acima for executado uma vez, a pilha terminará como

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

onde a cadeia vazia no início corresponde ao estado inicial da pilha (entrada vazia).

Duas cópias do código fonte deixariam um estado final de

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

três cópias um estado final de

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

e assim por diante.

O que acontece depois

Depois de executar o código fonte, o intérprete faz o seguinte.

1. Ele agrupa a pilha inteira em uma matriz e empurra essa matriz na pilha.

   Para duas cópias do código fonte, a pilha agora contém

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

2. É executado putscom a intenção de imprimir a pilha empacotada, seguida por um avanço de linha.

   putsé definido como {print n print}, assim faz o seguinte.

   1. printimprime a cópia embrulhada da pilha sem inspecioná-la (ou seja, sem convertê-la em sua representação de sequência). Isso envia

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

      (o código-fonte) para STDOUT e abre a cópia da pilha da parte superior da pilha.

      A pilha agora contém

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

   2. executa o bloco de código que definimos anteriormente.

      :começa salvando [{: ".~"][} ".~"]o caractere de espaço, ".~"empurra-se, ]agrupa-o ".~"em uma matriz e [define um novo marcador de matriz.

   3. n empurra uma sequência que consiste em um único avanço de linha.

      A pilha agora contém

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

   4. é executado mais uma vez. No entanto, foi redefinido quando o chamamos pela primeira vez e agora contém uma matriz, não um bloco de código.

      Na verdade, ele empurra [{: ".~"][} ".~"], deixando a pilha como

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

   5. Por fim, printimprime o item mais alto da pilha sem inspecioná-lo, enviando

      {: ".~"][}.~
      

      para STDOUT, aumentando o código-fonte 1.

Javascript ES6 (REPL), 55 bytes

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

Economizou 2 bytes graças a @ user81655!

Explicação

Aqui está a estrutura padrão do quine:

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

Você poderá ver essa estrutura dentro do envio. Mais explicações abaixo.

var a=-~a;

Este é o contador, padronizado como 1. Basicamente, ele nos diz quanto repetir a quantia e os incrementos ao mesmo tempo.

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

Esta é a parte correta. Nós essencialmente repetimos a sequência quine pelo contador + 1. As chamadas de função subsequentes substituirão a saída.

CJam, 14 bytes

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

Experimente online!

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

Depois que a última cópia do programa foi executada, a matriz que contém o bloco e a string ainda está na pilha, portanto é impressa implicitamente.

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

Há uma nova linha incorporada e nenhuma à direita. Isso 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()//

A função f()imprime uma cópia do quine. O programa inicial chama duas vezes. A primeira linha do código anexado se torna um comentário e apenas a segunda chamada f()é executada.

Ruby, 43 bytes

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

Por si só, isso é impresso 2-0ou 2vezes. Quando concatenada para outra cópia de si mesma, a declaração de impressão final se parece $><<s%s*n=2-01, o que significa que ela se produz apenas uma vez ( 01sendo octal 1). Portanto, apenas a cópia final da string é impressa duas vezes, as outras são impressas uma vez.

A atribuição inline para né apenas para que a ordem das operações funcione corretamente; Na verdade, o estado não está sendo passado de uma cópia para a seguinte.

NodeJS, 63 61 60 55 bytes

isso também funcionará em JavaScript (ES6) se você considerar várias mensagens do console separadas por novas linhas (não é necessário REPL)

Economizou 2 bytes graças a @ dev-null

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

Observe que há uma nova linha no final do código.

Este foi interessante, definitivamente um dos meus favoritos até agora.

Estou bastante confiante de que isso não pode ser jogado muito mais. (talvez a printfunção do SpiderMonkey ...)

Explicação

//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 muito interessante aqui, é apenas uma solução normal de rubi com um 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 em qualquer página de teste JS ou console no Firefox, assumindo que o espaço entre duas mensagens do console conte como uma nova linha.

Perl 6 , 58 53 bytes

Agradecimentos a Jo King por -5 bytes.

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

Baseado no quine de Jo King .

Experimente online!

Japonês, 40 bytes

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

Teste online! Explicação para vir.

Y

Não-competidor, 6 bytes

UCn*px

Y é um canhão de cabeça que eu tenho há um tempo, e isso me inspirou a escrevê-lo. É feito para desafios nos quais o seqüenciamento é fundamental, como esse. O código é dividido em links por caracteres de "nó". Nesse caso, nosso código é colocado em duas cadeias (originalmente), com o nó sendo C.

U  C  n* px
1  N    2

Uregistra uma sequência transcendental, ou seja, uma que abrange os links. Ele grava até encontrar outro U. Se um Unão for atingido até o final da string, ele será contornado. Além disso, Uestá incluído na string por padrão. Após gravar a string, prosseguimos para o nó C, que apenas nos move para o próximo link.

nempurra o número de correntes. Para o nosso caso base, este 2. Para uma sequência de Kcadeias, existem K+2cadeias, como existem Knós. *é repetição de string. pimprime a pilha inteira (nesse caso, uma sequência) e xfinaliza o programa.

Em um 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

Experimente aqui!

Braquilog , 20 bytes

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

Experimente online!

Modificado a partir deste 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.

Quando isso é concatenado consigo mesmo, todas as rotas, exceto a última, falham e o programa passa para a próxima, executando cada uma w₃e retornando todas as etapas, w₅exceto a última.

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

Experimente online!

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

Experimente online!

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

Experimente online!