自我成长编码编码编码编码

41

编写一个程序（或函数）（我们称其为P1），然后在运行时输出另一个相同语言的程序P2，并且比P1长1个字节。

程序P2运行时，应输出比P2长1个字节的第三个程序P3。P3必须输出比P3长一个字节的程序P4，依此类推。P5，P6，...，P∞相同。

程序链应无限期运行，或到达解释器不再处理的地方（但必须保留为该语言中理论上有效的程序）

规则

  • 禁止标准漏洞
  • 链中的所有程序都应使用一种语言
  • 没有输入。输出转到标准输出或函数返回值
  • 该程序必须在一段时间后结束。在特定时间点后停止生成输出但永不终止的程序不符合条件

每种语言中以字节为单位的最短程序P1获胜！

code-golf  quine 
— iBug
source
2
@Οurous什么？我自己没有添加该标签……
— iBug
6
@iBug无论如何，提交内容是否可以阅读自己的源代码？
— 马丁·恩德
3
@iBug默认情况下，“ quine”标签禁止使用它，这样做通常会使答案更有趣。不过，这取决于您。
— 马丁·恩德
1
"puts <<2*2,2\nputs <<2*2,2\n\n2"在Ruby中，每次迭代都会增加2。我找不到更好的东西。：-/。有趣的挑战！
— 埃里克·杜米尼尔
1
— FireCubez

Answers:

28

JavaScript（ES6），14个12字节

-2个字节，感谢@Shaggy

f=_=>"f=_"+f

测试片段

显示代码段

— 赫尔曼·L
source
花了我一点时间来发现这一点。鬼！
— 粗野的
4
有人可以解释一下，我不能把它缠住，它如何增加？
— htmlcoderexe
2
@htmlcoderexe 在参数名称之前添加了"f=_"一个额外_的名称，这导致它在每次迭代时都增加了长度。
— Herman L
9

7、4个字节的ASCII

1603

在线尝试！

我知道7通常不是用ASCII编码的，但是这次是更方便的编码，因此我们每次运行都添加1字节，而不是3位。

我也不确定这是否算作弊。（通常不清楚7 quine是否在作弊，因为它以多种方式跨越边界线。）您可以提出一个不错的论点，即对0编码6，但通常不清楚结果字符“来自哪里”。 ”中的“第7部分”，因为它具有许多相当奇怪的隐式行为。

该程序将自己打印并带有1附加内容，即使您在其上附加了多个1s 也会执行此操作。这是注释后的调试跟踪160311：

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

（|程序中没有剩余的内容，因此e会立即退出程序，这是一个副作用，这意味着final 7永远不会运行）。

关于所有字符来自何处的基本困惑是，7中的大多数命令在运行时仅产生数据，然后6尝试重建将产生给定数据片段的命令序列。这通常会接近但不等同于原始版本。（出于队列目的，通常以这样的方式编写7程序，使结果几乎相同，通常前导或尾随7s 有所不同。）因此，例如，1数据中的变为716，这是最简单的追加方式1到当前数据字符串。我们最初16使用不同（但相似）的字符序列制作了该文件，但破坏性地删除了其中一个|标记开始的数据。（我猜这也许不是最好的说法，最好的论据是输出不同于输入！）

— ais523
source
9

Haskell，74 66字节

编辑：

  • 使用H.PWiz通过-2个字节<>，然后通过移动-6 个字节(10*)<$>。

现在，它使用新释放的<>运算符（Semigroup乘法，要求GHC 8.4无需导入即可工作。）

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

在线尝试！（由于TIO还没有GHC 8.4，因此进行了进口欺诈。）

这个怎么运作

  • main=putStr$ 是样板输出以下字符串值。

  • fst<>show是一个接受元组的函数，并返回一个字符串，该字符串由元组的第一个元素与元组的字符串表示形式连接而成。即

    (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

  • (10*)<$>将以下元组的最后一个元素乘以10，并0在其字符串表示形式中添加一个数字。

— ØrjanJohansen
source
1
您可以使用(<>)
— H.PWiz
@ H.PWiz谢谢，通过移动获得了更多(10*)<$>。
— 与Orjan约翰森
8

C（gcc），134132字节

规范C quine的轻微重做。可怕的长。

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

在线尝试！

— 腹肌
source
4

brainfuck，420个字节

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

在线尝试！

这是对“标准” BrainFuck quine的修改，.结尾处有一个，在.每次迭代时附加一个。

quine本身将Brainfuck字符编码为十六进制数字的堆栈：具体来说，的十六进制数字c-0x2b方便地如下所示：

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

编码涵盖两个代码段：>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++推入编码本身的编码，[[<++++++++++++++++>-]<+++++++++.<]遍历堆栈并打印所有内容。

— Nonneneo
source
3

脏的 9字节

'"n[!]a!␛

在线尝试！

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

如果允许读取源代码：

脏 8字节

Q[!]W33!

在线尝试！

解释：

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

可能有效：

脏，4个字节

Q[‼]

在线尝试！

它用尾随换行符打印源代码。
（以及一堆空格，由于一个错误。尽管没有空格，它的工作原理也一样。）

请注意，它仅适用于本机字符集，而不能在使用UTF8前端时使用-因此，要在TIO上进行尝试，您需要将[]s 之间输出的字符替换为‼，这与打印的UTF8等价。

— 巨大
source
1
4字节版本绝对无效。
— 暴民埃里克（Erik the Outgolfer）
3

Java的8，162个 146字节

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

在线尝试。
尝试第一个输出程序；尝试第二个输出程序 ; 尝试第三个输出程序。

说明：

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -part：

  • 该String s包含未格式化的源代码。
  • %s用于将String本身输入s.format(...)。
  • %c，%1$c以及34用于格式化双引号。
  • s.format(s,34,s) 放在一起

挑战部分：

  • +1 向未格式化和格式化的程序都添加1。
  • .replaceAll("1+$","");}：因为我们只想将程序字节数增加1而不是2，所以我们在返回之前删除所有尾随的1。
— 凯文·克鲁伊森
source
2

GolfScript，9个字节

{'.~1'}.~

在线尝试！

CJam，9个字节

{"_~1"}_~

在线尝试！

我将这两种解决方案发布在同一答案中，因为它们只是彼此的琐碎变体，并且以完全相同的方式工作。它们都基于通用的GolfScript quine {'.~'}.~（或{"_~"}_~在CJam中），例如，在我之前的答案中有更详细的描述。

唯一的区别是此变体1在其输出末尾附加一个字节。碰巧的是，任何1s 字符串（或任何其他没有前导零的整数文字）本身在GolfScript和CJam中都是琐碎的事情，因此，上面代码末尾已经存在的任何字符串都将被简单地逐字复制到输出中。由于GolfScript（和CJam）使用任意长度的整数，因此这对于任意长的程序都适用，至少只要运行该代码的计算机有足够的内存来存储它即可。

— 伊玛里·卡洛宁（Ilmari Karonen）
source
2

附件，76 72 61字节

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

在线尝试！

标准quine，x在每次迭代后的末尾添加一个空格。

前几次迭代：

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]


Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]


Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

等等

附件，72字节

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

在线尝试！

这只是标准格式quine的变体y，10*y每个迭代后将变量设置为

前几个迭代：

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]


y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]


y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

等等

— 科纳·奥布莱恩
source
1

Haskell，88个字节

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

在线尝试！通过添加#到数据字符串来增长。

— 莱科尼
source
您可以通过show输入多个字符串和使用模式匹配来节省一些时间。在线尝试！
— 与Orjan约翰森
@ØrjanJohansen不错！除了底层的标准Haskell quine，这是一种完全不同的方法，因此可以自己发布。
— Laikoni
好的，如果您是这样的话。
— 与Orjan约翰森
1

Stax，20 18字节

"34s+cTZL"34s+cTZL

运行并调试

每次迭代在第二个引号之前生成一个额外的空间。

说明

用程序"34s+cTZL "34s+cTZL解释。

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.
— 周卫军
source
1

符文附魔，6字节

"'<S@>

在线尝试！

这一个很奇怪。我要做的就是~从乔·金（Jo King）发现的原始麦片中取出一个。

每增加一次运行<，都会在末尾追加另一个运行，例如：

"'<S@><<<<<<<<<

所有这些都不起作用。

直接回答有关挑战的答案。恰好它每次迭代都已经增长了1个字节（此挑战的有力论据是那个挑战的重复，反之亦然）。

— 德拉科
source
0

奇迹，33字节

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

正常quine上的一个有趣变体，在每次迭代后附加1。

进度：

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

说明

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

这种方法的有趣之处之一是，Wonder可以以任意精度工作，因此，经过一定数量的运算后，进度不会中断。

— 妈妈趣味卷
source
0

ColdFusion，277个字节

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

这是对ColdFusion quine的琐碎修改，在每次调用时都会增加一个换行符。

在lucee-express-5.2.6.60上进行本地测试

— 唐·黑斯廷斯
source
0

Windows批处理，38 36字节

echo|set/p"=q">q&copy/b/y %0+q %0
::

此代码创建一个名为“ q”的文件，其中包含字母“ q”，然后将其附加到原始文件中。请注意，“ ::”是“ rem”的别名，不需要额外的空间。

感谢user3493001，节省了2个字节。

— 彼得·弗里
source
0

T-SQL，175字节

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

首先，我编写了一个SQL quine，然后对其进行了修改，以增加一个额外的空间（受此回答启发）。

— 拉兹万·索科尔（Razvan Socol）
source
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.