阿1向上喹是一个程序，它是非常类似于一个喹。一个主要的区别是，当连接n个程序副本时，结果不会打印自身一次，而是将原始程序打印n + 1次。

例

如果您的程序是Abc123：

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

挑战

您面临的挑战是创建任何语言中最短的有效1-up quine。通常采用奎因规则，因此您可能不会：

• 提交空程序。
• 直接或间接读取¹源代码。
• 使用内置的奎因。

这是代码高尔夫球，因此以字节为单位的最短代码获胜。

^{1这不包括在程序中使用硬编码的字符串或代码块。}

GolfScript，12个字节

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

在线尝试！

说明

它结合了标准GolfScript思路的思想：

{'.~'}.~

我最近发现的奎因：

":n`":n`

再次的主要思想是使用n在程序末尾隐式打印的内容，以获得额外的Quine副本。由于分配变量在后续副本中再次完成后不会更改任何内容，因此只会添加一个副本。这是代码的细分：

{        # 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个字节

{: ".~"][}.~

在线尝试！

源代码如何工作

{: ".~"][}.~

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

如果上述源代码执行一次，则堆栈将最终显示为

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

其中开头的空字符串对应于堆栈的初始状态（空输入）。

源代码的两个副本将保留最终状态

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

三份副本的最终状态

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

等等。

接下来发生什么

执行源代码后，解释器将执行以下操作。

1. 它将整个堆栈包装在一个数组中，然后将该数组压入堆栈。

   对于源代码的两个副本，堆栈现在包含

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

2. 执行该命令puts的目的是打印包裹的堆栈，然后换行。

   puts被定义为{print n print}，因此执行以下操作。

   1. print打印堆栈的包装副本而不检查它（即，不将其转换为字符串表示形式）。这发送

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

      （源代码）到STDOUT，并从堆栈顶部弹出堆栈副本。

      堆栈现在包含

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

   2. 执行我们之前定义的代码块。

      :首先保存[{: ".~"][} ".~"]空格字符，然后".~"将其推入，将其]包装".~"在一个数组中，然后[设置一个新的数组标记。

   3. n 推送由单个换行符组成的字符串。

      堆栈现在包含

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

   4. 再次执行。但是，当我们第一次调用它时已重新定义它，现在它包含一个数组，而不是代码块。

      实际上，它推动[{: ".~"][} ".~"]，将堆栈保留为

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

   5. 最后，print在不检查的情况下打印最上面的堆栈项目，然后发送

      {: ".~"][}.~
      

      到STDOUT，1-upup源代码。

Javascript ES6（REPL），55个字节

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

感谢@ user81655，节省了2个字节！

说明

这是标准的quine框架：

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

您应该能够在提交中看到此框架。下面有更多解释。

var a=-~a;

这是计数器，默认为1。基本上，它告诉我们重复多少个木偶并同时增加。

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

这是奎纳部分。我们本质上是用计数器+1重复琴弦。随后的函数调用将覆盖输出。

CJam，14个字节

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

在线尝试！

怎么运行的

{"_~"]-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.

执行完程序的最后一个副本后，包含该块和字符串的数组仍在堆栈上，因此将隐式打印该数组。

Groovy，83个字节

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()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

该功能f()打印一份奎纳。初始程序将其调用两次。附加代码的第一行成为注释，并且仅f()执行对的第二次调用。

Ruby，43个字节

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

就其本身而言，它会打印自身2-0或2时间。当连接到自身的另一个副本时，最终的打印语句看起来像$><<s%s*n=2-01，这意味着它仅输出一次（01八进制1）。因此，仅字符串的最终副本打印两次，其他字符串打印一次。

内联分配n只是为了使操作顺序正确地进行；状态实际上并没有从一个副本传递到下一个副本。

NodeJS，63 61 60 55字节

如果您认为多个控制台消息用换行符分隔，则在JavaScript（ES6）中也可以使用（不需要REPL）

@ dev-null节省了2个字节

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

请注意，代码末尾有换行符。

这是一个有趣的活动，到目前为止，绝对是我对此网站的最爱之一。

我相当有信心不能再打高尔夫球了。（也许是SpiderMonkey的print功能...）

说明

//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个字节

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

这里没什么有趣的，它只是一个带有柜台的普通红宝石奎因。

JavaScript（ES6），164个字节

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

假定两个控制台消息之间的间隔算作换行符，则可在Firefox中的任何JS测试页或控制台中使用。

Perl 6的，58 53个字节

感谢Jo King提供-5个字节。

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

基于Jo King的奎因。

在线尝试！

Japt，40个字节

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

在线测试！解释来了。

ÿ

非竞争性，6个字节

UCn*px

Y是我已经有一段时间的头炮了，这启发了我写它。诸如此类的挑战主要是需要排序。该代码按“节点”字符分为链接。在这种情况下，我们的代码（最初）分为两个链，节点为C。

U  C  n* px
1  N    2

U记录一个超越字符串，即跨越链接的字符串。它记录直到遇到另一个U。如果U在字符串末尾未满足a ，则会回绕。另外，U默认情况下，它包含在字符串中。记录完字符串后，我们进入node C，它仅将我们移至下一个链接。

n推动连锁店的数量。对于我们的基本情况，这是2。对于一系列K链，有K+2链，也有K节点。*是字符串替换。p打印整个堆栈（在这种情况下为一个字符串），并x终止程序。

在文本中：

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

在这里尝试！

Brachylog，20个字节

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

在线尝试！

从这个花样改过来的。

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

如果将其自身连接起来，则除最后一条路由外，其他所有路由均会失败，并且程序将继续执行下一条路由，并执行每条路由，w₃并回溯经过w₅除最后一条路由之外的所有路由。

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

在线尝试！

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

在线尝试！

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

在线尝试！