1-平均你的平均成本


34

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

如果您的程序是Abc123

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

挑战

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

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

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

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


2
如果n受到某种数据类型限制(最大整数大小等)的限制,可以吗?
Luis Mendo

2
@LuisMendo我认为可以,只要您可以支持合理数量的重复(也许100次)即可。
ETHproductions 2016年

使用内置的quining方法读取源代码的长度可以吗?
科纳·奥布赖恩

2
@CᴏɴᴏʀO'Bʀɪᴇɴ这似乎有点像将源代码本身交给我,因为您仍在获取有关源代码的信息。所以不行。
ETHproductions 2016年

Answers:


13

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

12

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源代码。


11

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重复琴弦。随后的函数调用将覆盖输出。


这可能只是我,但这似乎无法打印任何内容。(是否使用JSFiddle测试过,是否重要?)
jrich

嗯,您应该使用Firefox控制台。(并在每次运行后重新加载以重置a)。
Mama Fun Roll

我认为您不需要var
Cyoce '16

不,我这样做是因为a最初是不确定的。使用var允许我们使用它。
Mama Fun Roll

7

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.

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


4

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()执行对的第二次调用。


4

Ruby,43个字节

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

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

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


4

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.

我喜欢它首先戴上太阳镜的样子。(f=_=我可能有点太累了。
Ben Leggiero

2

Ruby,55个字节

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

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


2

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测试页或控制台中使用。


许多通用语言的道具!
本·莱吉耶罗

缩短windowthis
Mama Fun Roll



1

ÿ

非竞争性,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

在这里尝试!


那么,U除了奎因以外的实际用途是什么?(恭喜7k,顺便说一句)
ETHproductions 2016年

@ETHproductions U可用于捕获跨越链接的字符串,也能够捕获并使用拆卸到程序的链接。谢谢!:D
Conor O'Brien

1

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₅

在线尝试!

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.