写一个Quine Suite


30

我们遇到了很多挑战,但是许多奎因格式相似,因此可以使我们的奎因产生一些差异。

您的任务是用相同的语言(至少2种)创建一系列程序,所有程序都输出自己的源代码,但是,这些程序都不能共享任何字符。

例如,如果您使用以下程序创建程序:

printf+qw(printf+qw(%s)x2)x2

您的下一个程序不能包含以下任何一项:

%()+2finpqrstwx

等等。

规则

  • 您可以使用unicode字符,但仍必须以字节为单位。
  • 所有程序都必须符合社区对适当的标准的定义。这意味着,空字符串不算作有效的quine。
  • 禁止出现标准漏洞。
  • 只要满足上述定义,就可以使用功能或完整程序。
  • 禁止使用与符号无关的语言(包括Lenguage和Headsecks)。
  • 大多数程序都胜出,总代码最短的是决胜局。

由于票数接近,我将取消
Dom Hastings

我注意到沙盒注释提到允许函数提交,但是挑战没有说明任何问题-我假设相反的是quines。
与Orjan约翰森

2
相关(注意逆向挑战的种类-您的奎因必须互相输出而不是自己输出)
Nathaniel

1
尾随换行符怎么办?如果我的一根提包印有一个,那另一根提要避免这样做吗?(我怀疑大多数答案都不会这样做。)
Nathaniel

2
@DomHastings我找不到元问题,所以我问了一个
纳撒尼尔(Nathaniel)'18年

Answers:


27

V 3,5个基内斯,46个字节

2A2A

在线尝试!

十六进制转储:

00000000: 3241 3241                                2A2A

说明:

2     " 2 times...
 A    " (A)ppend the following text...
  2A  "   '2A'

5­­­a5­­­a

在线尝试!

十六进制转储:

00000000: 35ad adad 6135 adad ad61                 5...a5...a

说明:

5---        " 5 - 3 times...
    a       " (a)ppend the following text...
     5---a  "   '5---a'

1«I1«I

在线尝试!

十六进制转储:

00000000: 31ab 4931 ab49                           1.I1.I

说明:

1«      " 1 + 1 times...
  I     " (I)nsert the following text...
   1«I  "   '1«I'

这是他们开始变得时髦的地方...

ñi34x@-qPÉÑ~ÿ

在线尝试!

十六进制转储:

00000000: f169 1633 341b 7840 2d71 50c9 d17e ff    .i.34.x@-qP..~.

说明:

ñ                       " Wrap all the following in macro '"q':
 i<C-v>34               "   Insert character code 34 `"`
         <esc>          "   Return to normal mode
              x         "   Delete the character we just inserted. Now, running `@-` will be equal to running `"`
                  P     "   Paste...
               @-       "   From Register...
                 q      "   "q
                   ÉÑ   "   Insert 'Ñ' at the beginning of this line
                     ~  "   Toggle the case of the character we just inserted
                      ÿ "   Black magic

:norm é:":p

在线尝试!

十六进制转储:

00000000: 3a6e 6f72 6d20 e93a 223a 70              :norm .:":p

说明:

:norm       " Run the following commands as if typed:
      é:    "   insert ':'. Somehow also does black magic and resets the value of '":`
        ":p "   Paste the last ex command to be run ('norm é:":p')

这个答案充满了黑魔法。醌1和4不是新奇的,但是其他3个都从未发现过,因此今天才发现其中一半以上。


8
第三个程序是拖钓。“你是一个normie :p
mbomb007 '18

4
@ mbomb007强制性REEEEEE--
魔术

17

果冻2 3 4 5 quines,14 18 81 65 59 56 326 265 247 229 216字节

3个字节

”ṘṘ

在线尝试!

标准奎因。”Ṙ是的一个字符字面量打印此字符串表示形式,然后隐式打印该字符串。

4字节

⁾⁾ḤḤ

在线尝试!

以两个字符串文字开始,并将其参数加倍。使用字符串输入,将映射到每个字符。因此对字符串⁾Ḥ产生作用⁾⁾ḤḤ,即源代码。

11字节

ȮṾṖƊ}“ȮṾṖƊ}

在线尝试!

在右侧,“ȮṾṖƊ}是的字符串文字ȮṾṖƊ}。字符串关闭字符默认在EOF处添加。

在字符串文字的左侧,Ɗ将其包装ȮṾṖ为单个monad,然后}将其转换为使用其正确参数(字符串文字)的dyad。Ȯ打印字符串(ȮṾṖƊ}),创建字符串()的字符串表示形式“ȮṾṖƊ}”删除字符。该字符串“ȮṾṖƊ}保留在monad之后,并进行隐式打印。

38 49 36字节

32,52,52,7884,106,64,44,7884 44Ọj@,Ọ

在线尝试!

我第一次在Jelly打高尔夫球时使用过空间。

开头的数字列表包含ord代码中其余字符的字符。之后:

jṛ44Ọ$,Ọ
j           Join this list with...
 ṛ          right argument. Avoiding using ¤ so I can use it in the next program.
  44Ọ       chr(44)==',': [106, ',', ...]
     $      Causes Ọ to act on 44 before j acts on it.
      ,     Pair this list with...
       Ọ    chr of each number in the list. Yields jṛ44Ọ$,Ọ

270个198 180 162字节

⁽¢_;⁽⁽¤;⁽¡_;⁽⁽¡;⁽¡¤;⁽$+;⁽⁽y;⁽Ẹ$;⁽⁺$;⁽AƑ;⁽?€;⁽b⁽;⁽¢¡;⁽_⁽;⁽¡¡;⁽¤ị;⁽ØJ;⁽µṭ;⁽€⁽;⁽¡S;⁽;⁽;⁽¡ʠ;⁽¤ị;⁽ØJ;⁽¤F;⁽ḊṄ;⁽ȧF
¢_⁽¤¡_⁽¡¡¤$+⁽yẸ$⁺$AƑ?€b⁽¢¡_⁽¡¡¤ịØJµṭ€⁽¡S;⁽¡ʠ¤ịØJ¤FḊṄȧF

在线尝试!

使用基数为250的数字并将其索引到Jelly代码页中。通过更改算法节省了72个字节。使用每个数字索引到Jelly的代码页,但现在将整数转换回以250为基数,然后索引到Jelly的代码页,基本上将第一行中需要的文字数量减半。这也减少了所需的唯一字符的数量,但我想不出一种方法来制作更多的奎因。

我用了⁾“”它创建的字符串文字和ØJ其创建数字的字符串。我想不出其他任何制作琴弦的方法。我仍然有数字9‘’可用的,所以如果有一个使从数字的字符串的另一种方式有可能使另一个奎因。


13

Haskell,3 quines,1119字节

Quine 1,51个字节

IO直接打印到标准输出的匿名操作。

putStr`mappend`print`id`"putStr`mappend`print`id`"

在线尝试!

Quine 2,265字节

该函数f接受一个虚拟参数并返回一个字符串。

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,90,52,82,89,52,51,51,94,84,24,24,39,34,34,106,95,102,110,0,94,50,89,0,90,52,82,82,82,106,95,102,110,0,48,24,24,39,35,106,95,102,110,0,40,24,24,39,37,37,84,24,24,45,37,37,84,24,24,90,84,50,94,52]

在线尝试!

Quine 3,803个字节

LANGUAGE编译后的所有内容都是一个带有虚参数并返回字符串的函数。

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&'#'&'L'&'A'&'N'&'G'&'U'&'A'&'G'&'E'&' '&'C'&'P'&'P'&'#'&'-'&'}'&'('%'\\'&'q'&'('&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'z'&')'&'y'&'('&'#'&')'&'_'&'-'&'>'&'('&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'&'%'\''&':'&'q'&':'&'k'&':'&'q'&':'&'x'&')'&'#'&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'%'%'\''&':'&'q'&':'%'\''%'\\'%'\\'%'\''&':'&'k'&':'&'q'&':'&'x'&')'&'$'&'y'&'('&':'&')'&'#'&'y'&'('&':'&')'&'$'&' '%'\\'&'x'&'-'&'>'&'x'&')'&'z'&')'%'\''%'\\'%'\''%'\''&'_'&'_'&'T'&'I'&'M'&'E'&'_'&'_'&'('%'\\'&'('&'?'&')'&'v'&' '&'k'&' '&'x'&'-'&'>'&'v'&'$'&'k'&'?'&'x'&')'&'$'&' '%'\\'&'('&'&'&')'&'('&'%'&')'&'v'&'-'&'>'&'v'

在线尝试!

性格

Quine 1:


"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

 #$%&'()-:>?ACEGILMNPTU\_kqvxyz{}

怎么运行的

Quine 1

putStr`mappend`print`id`"putStr`mappend`print`id`"

Quine 1是我最近的Golf you quine答案的修改版(H.PWiz进行了改进):

  • 由于不需要完整的程序,因此main=已被删除。
  • <>$已由它们的近义词mappend和代替id

这样可以释放重要角色,=<>并释放$其他藜的有用操作者。

奎因2

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,......]

Quine 2使用了与我最近的Mutually Exclusive Quines答案的程序2相似的方法,但是适应于直接本身,特别是避免使用Quine 3 所需的字符文字。这两种方法都是在show函数,幸好目前还没有使用过任何字符。

这种方法使用制表符代替空格,但是为了便于阅读,我在下面使用空格。

  • g是quine数据,作为代码末尾的整数列表。每个数字代表其余代码中的一个字符。
    • 数字被移位9,因此制表符为0。通过使函数和变量名的小写字母适合两位数,可以使编码稍微短一些。
  • b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] 是将数字转换为字符(实际上是一个字符的字符串)的函数。
    • [[show 9!!0,show 1!!0..]!!6..]是一个以制表符开头的字符范围,该制表符以索引!!c
    • 制表符本身是通过索引到另一个范围而产生的[show 9!!0,show 1!!0..],从数字字符开始'9''1'然后以8的步长向下跳。
    • 数字字符是通过索引到show相应数字的字符串中而产生的。
  • f c=[b=<<g]!!0++show g是主要功能。c是一个伪参数。
    • b=<<g用于=<<将每个数字转换g为其字符。(使用=<<而不是例如map,为什么b需要将其返回的字符包装在列表中。)
    • show g给出g的列表的字符串表示形式,并且++连接字符串。
    • 由于=<<优先级低于++,因此需要一些包围。为了避免使用()(保留给quine 3),请[...]!!0使用一个元素将其索引到列表中。

Quine 3

通过设计其他quines,quine 3仍可以访问括号,lambda表达式,字符文字和字符串/列表构造函数:。这足以构造一个 quine代码附加到字符串的函数。

不幸的是,y已使用了所有小写​​的元音(有时除外),没有留下有用的字母数字内置函数。也[]""消失了。这就没有任何正常的方法来构造一个空字符串来开始伪装代码。

但是,几乎所有大写字母仍然可用,因此可以使用LANGUAGE杂凑来获得语言扩展。再次幸运的是,CPP(启用C预处理程序)是唯一仅使用大写字母命名的语言扩展。CPP宏通常具有大写名称。

因此,要获取必需的空字符串,quine enables会CPP使用__TIME__宏使用以下形式的字符串常量"??:??:??"(方便地保证始终具有相同的长度),并在其上进行模式匹配。

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&......

语言编译后,该信息包含一个lambda表达式,将其参数绑定到这四个参数(保留最终的虚拟参数_供以后使用):

  • q绑定到'\'',给出一个单引号字符;
  • _:_:_:_:_:_:_:_:z绑定到__TIME__,也就是类似的字符串"??:??:??",从而生成z一个空字符串;
  • y绑定到(\(?)v k x->v$k?x)一个lambda组合器,该组合器用于帮助将quine数据从左侧关联(“ foldl”)转换为右侧关联(“ foldr”)形式;
  • 运算符(#)绑定到\(&)(%)v->v&'{'&'-'&...quine数据本身。

quine数据以Church编码的形式给出,它是带有参数的lambda表达式(&)(%)v

  • 通过将表达式应用于特定值以实例化(&)(%)并且v,该编码既可以用于构建喹的核心代码或重建喹数据表示本身。
  • 通过Haskell的默认固定性规则,&%成为lambda内的左关联运算符。因此,字符参数与初始v从左开始。
  • 对于大多数字符k,有一个对应的&'k'
  • kis '\需要在字符文字中转义时,编码改为%'\k'

由于数据编码是左关联的,但是字符串是以右关联的方式构建的,因此y = (\(?)v k x->v$k?x)引入了组合器来弥合失配。

  • y(...)旨在构建合适的函数以用作五进制数据(&)(%)运算符。
  • v是一个从字符串到字符串的函数(quine数据的预期v示例)。
  • k是一个字符,x一个字符串以及?一个将它们组合成新字符串的运算符。(对于核心代码,(?)=(:)对于实际重建quine数据表示,它更加复杂。)
  • 因此y(?)v k = \x->v$k?x是从字符串到字符串的另一个函数。
  • 例如,这是如何改变关联性的(&)=y(:)

    (v&k1&k2&k3) x
    = (((v&k1)&k2)&k3) x
    = y(:)(y(:)(y(:)v k1)k2)k3 x
    = y(:)(y(:)v k1)k2 (k3:x)
    = y(:)v k1 (k2:(k3:x))
    = v (k1:(k2:(k3:x)))
    = v (k1:k2:k3:x)

更一般而言,何时(#)是quine数据函数,并且f1,f2是将字符与字符串组合的函数:

(y(f1)#y(f2)$v) x
= (...(y(f1)(y(f1)v '{') '-')...) x
= v(f1 '{' (f1 '-' (... x)))

将quine数据函数与(&)=y(f1)和一起使用(%)=y(f2),这将使用规定的f1f2将quine数据的字符与组合x,然后将结果字符串传递给v

主要lambda表达式的主体将所有内容组合在一起:

(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z
  • '&':q:k:q:x对于字符串k前面&'k'的字符x,而'%':q:'\\':k:q:x前面的字符则%'\k'是其原始quine数据形式。
  • 因此y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x,正确的参数是用于重建quine数据表示形式的,前置到最后一个z(空字符串)然后传递给以下函数的参数。
  • y(:)#y(:) 是将quine的核心代码添加到字符串之前的正确参数,而无需进行其他修改。
  • 最终\x->x,返回的与构造的quine无关。

9

Perl 6,3 quines,274字节

Quine 1,52个字节

my&d={S{\d}=$_};say
d
Q{my&d={S{\d}=$_};say
d
Q{4}}

在线尝试!

Quine 2,102字节

printf	|(q[printf	|(q[@]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))

在线尝试!

Quine 3,120个字节

<'.EVAL'.UC,' GIVEN ',「「PRINT "<'.EVAL'.UC,' GIVEN ',「「".UC,.UC,"」」>.LC",".EVAL.EVAL".UC」」>.lc.EVAL.EVAL

在线尝试!

验证不同的字节集

弄到第三根奎奴藜有很多技巧。Perl 6的输出有4种方法(即我所知道的), ,,say 和。无论和输出换行,因为我不能同时使用。,,都含有和。通过使用大写字母可以部分解决此问题。从那里开始,我认为不可能得到4根奎因...(尽管也许像putprintprintfsayputputprintprintfptEVALPRINTshell "echo 'quine'"可能)

然后,我们可以通过使用不同类型的空格来分隔运算符,空格,制表符和换行符来解决间距问题。

说明:

Quine 1:

my&d={        };         # Declare a function d which 
      S{\d}=$_           # Which substitutes a digit with the string again
                say      # Print with a newline
d                        # The function
Q{my&d={S{\d}=$_};say    # Applied to the string with the program
d
Q{4}}                    # With a digit where the it should be inserted again

Quine 2:

这是格式的quine printf |(q[printf q[%s]]xx 2),即,它将字符串的副本格式化为自身。但是s,由于先前的quine中已经使用了,所以我们无法使用say。因此,我们~|@和上使用了字符串OR运算符()!3来生成%s零件,但是我们无法同时对格式字符串和要插入的字符串进行操作,因此我们必须处理Z~多余的字符串和空字符串,尽管我们然后不能使用它们,来将两者分开,所以我们然后Xx qw[1 0]将字符串乘以1和0。

printf |(                                  )      # Print with formatting
         q[...]       # The string of the program
               xx 2   # Duplicated
                    Z~| (                 )     # String or'd with
                         q[...]                 # A copy to insert the %s
                                Xx              # String multiplied to
                                   qw[1 0]      # itself and an empty string

Quine 3:

这是一个EVAL quine,它会尽力使所有内容变为大写,以避免与其他quines冲突。这涉及很多EVAL s和很多lc并且uc要在大小写之间转换。

<...>.lc.EVAL        # Evaluate the lowercase version of the string which results in
.EVAL  given  「print "<'.eval'.uc,' given ',「「".uc,.uc,"」」>.lc",".eval.eval".uc」
             .EVAL   # Evaluate again 

.EVAL  given  「...」   # Set the string to $_ and pass it to .EVAL
print "<'.eval'.uc,' given ',「「".uc       # Print the first half of the quine uppercased
                                   ,.uc   # Print the string uppercased
                                       ,"」」>.lc"  # Print the .lc part lowercased
                                                ,".eval.eval".uc # Print the EVAL part uppercased

9

MathGolf4 5 6 quines,193,535字节

9字节

ÿ'ÿ⌐_'ÿ⌐_

在线尝试!

45字节

û]∙ûxôû¬ûûûûû╡¬ûô╡û╡xûxxû¬ô]∙xô¬ûûû╡¬ô╡╡xxx¬ô

在线尝试!

49个字节

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ

在线尝试!

99字节

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~

在线尝试!

4488字节

♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((DÄß─·ö♠,♦M-$*DÄß─ö7($$$qq$Äq╘

在线尝试!

188,845字节

我真的不能链接到这个,所以这是一个Perl 6程序,它可以生成实际的quine

验证独特性

我绝对可以从中抽出另一个绳结,尽管我认为我已经用尽了将字符串直接推入堆栈的方法,所以我不得不诉诸于陌生的方法。当我尝试第六根藜时,甚至陌生人的方法也来了。在某些情况下,quines可能会更短,但是我正在减少准备中使用的字节。

好的,从技术上讲,我也许可以再做一个quine,因为我仍然需要一些运算符(推送字符串,增量字符串,重复项,映射,弹出),这是使我们受限的循环。该{}是唯一的运营商,可以可以指示任意长度的代码块,我真的需要他们在第6奎因。我可以使用其他一些代码块,但是它们是有限的,并且我怀疑循环部分会这么短,因为我们用尽了简单的运算符。

好的,一些迟来的解释:

所有的奎因几乎具有相同的结构:

  • 将一个字符串或字符串列表或字符列表推入堆栈。
  • 将所有内容合并为一个列表
  • 复制清单
  • 映射副本,打印/推送用于获取原始字符的字符
  • 将原始字符列表打印为字符串

Quine 1:

这基本上与我在普通quine问题中发布的内容相同。

ÿ'ÿ⌐_'ÿ⌐_
ÿ            Push the next 4 bytes as a string
 'ÿ⌐_        Stack ["'ÿ⌐_"]
     'ÿ      Push the byte ÿ (I realise I could have used this in a later quine)
       ⌐     Rotate the ÿ to the bottom of the stack : ["ÿ", "'ÿ⌐_"]
        _    Duplicate top of stack: ["ÿ", "'ÿ⌐_", "'ÿ⌐_"]
             Implicitly print stack joined together : ÿ'ÿ⌐_'ÿ⌐_

奎因2

û                Push the next 2 bytes as a string
 ]∙              Stack: ["]∙û"]
   û  û...      Repeat this for the rest of the code
           ]              Wrap the stack in an array : [["]∙","xô"...]]
            ∙             Triplicate                 : [[..],[..],[..]]
             x            Reverse the top array
              ô           Loop over the array, executing the next 6 instructions
                          Stack: [[..],[..],str]
               ¬          Rotate the stack : [str,[..],[..]]
                ûûû╡      Push the string "ûû" and discard the left character
                    ¬     Rotate the "û" to the bottom : ["û",str,[..],[..]]
                          This produces the initialisation part
                     ô    Loop over the array with the next 6 characters again
                      ╡╡xxx¬      Basically discard the string
                            ô     Flatten the last copy of the array onto the stack
                                  Implicitly output the code

Quine 3:

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ
ù...          Push the next 3 bytes as a string
              You know how this goes
    a         Wrap the top element in an array
     6æ       Repeat the next 4 instructions 6 times
       \      Swap the two top items
        a     Wrap the top item in an array
         \    Swap back
          +   Combine the two arrays
              This puts all the strings into a single array
           6            Push a 6
            ┼           Push the element two items down (the array)
             \          Swap with the 6 (this basically duplicates the array)
              ùùùù      Push "ùùù"
                  \§    Swap and get the 6th character (wrapping)
                    \   Swap with array : ["ù", [..]]
                     +  Prepend to array (implicitly mapping)
                      Σ\Σ     Join both the lists to strings and output

Quine 4:

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~
""             Push the empty string
  "..."        Push some code : ['','...']
       `       Copy the top two elements of the stack : ['','...','','...']
        ~      Evaluate the top element as code : ['','...','']
▐              Prepend the empty string to the code
  ⌠            Push a space and increment by 2 to get a quote
   ▌           Prepend to the array
     ⌠▌ ⌠▌ ⌠   Repeat three more times, leaving the last on top : ['', '""...','"']
              ⌠⌠...       Push a space and increment until it reaches a '`'
                    ⌠⌠... Repeat for the '~' : ['','"""...','"','`','~']
                          Implicitly output

Quine 5:

♠              Push 256
 ((...         Decrement until it reaches the correct byte representing the code
               Repeat for each character of the code
      DÄ       Repeat the next instruction 14 times
        ß      Wrap the top 4 elements in an array
         ─     Flatten the resulting monstrosity
          ·    Triplicate the array
           ö   Map the next 7 instructions over the array
                      Stack : [[..],[..],num]
            ♠         Push 128
             ,        Reverse subtraction : [[..],[..],128-num
              ♦M-$    Push the ( character
                  *   Repeat it 128-num times
                   DÄß─         Gather that up in an array and flatten again
                       ö        Map the next 6 instructions
                        7($$$qq
                    7($$$q    Print a ♠, without newline
                              q   Print the brackets without newline
                                  Stack : [[..],[..]]
                               $     Map the number to their values in the code page
                                Äq   Map print over each element
                                  ╘  Discard the last element of the stack

Quine 6:

之所以这样奎因是这样长得比别人是递增的字符串使用Unicode表示,这真的很烂在代码中的某些字符,特别是当我们试图创建字符代码,其膨胀的代码超过8000个字符,然后使表示部分膨胀很多。

⌂         Push an * character
 ))...    Increment until we reach the right character + 8
      ♫{ }            Repeat 10000 times
        α             Wrap the top two elements in an array
          ♫{     }    Then repeat 10000 times
            m{{}}     Shallowly flatten the array
                  h∞<     Double the array
                     m{          Map the doubled array to
                       ïí½<¿{    If it is the first half of the array
                             ⌂⌂  Push two asterisks
                               )))...    Increment into a '⌂' (there are something like 8000 )s here, with a couple of ! to help
                                     @   Rotate the top three elements
                                         Stack : ["⌂",char,"*"]
                                      0{     α4<{}=}←  Repeat while the asterisk is not the char
                                        ⌂⌡)   Push a )
                                           @  Rotate it under the char
                                            ) Increment the asterisk
                                                     ;;   Pop the extra copies of the character
                                                       }{  Else
                                                         ⌡⌡⌡⌡}   Subtract 8 from the character
                                                              }{}  End map and flatten array
                                                                   Print implicitly

如果MathGolf在字符串是否使用本机代码页方面保持一致,则可以大大减少最后一个问题。


我对您的独创性感到惊讶,我希望您能提出一些解释。我从最初的quine挑战中认识到第一个,但是其余的看起来好像他们花了很长时间才提出来。
maxb

@maxb我正在研究第六根藜,一旦发布或放弃它,我都会发布解释。顺便说一句,chr / ord和递增字符命令似乎不一致。第一个使用代码页,第二个使用典型的unicode(这就是使6根提琴很长的原因)
Jo King

我意识到实现它的一段时间后,我只是使用chr/ord了其中之一,我认为应该同时使用代码页。
maxb

6

Python 2中,2个基内斯,434 353 349 446个字节

这主要只是看我是否可以在Python中做到这一点。

30个字节(包括结尾的换行符):

z='z=%r;print z%%z';print z%z

和416个字节,没有结尾的换行符:

exec"696d706f7274207379730a793d222222696d706f7274207379730a793d7b7d0a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222220a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f6465282268657822292729".decode("hex")

(由于Lynn而使行进了81个字节,但由于关心换行符而增加了负担。)

说明

第一个只是标准的简短Python quine,但修改后不使用_。由于这是Python 2,因此也不会使用()

第二个考虑了一下。长字符串使用hex编解码器进行编码(从而确保它仅包含0- 9a- f)并解码为

import sys
y="""import sys
y={}
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')"""
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')

这使用quinerickery来获取自己的源代码,然后使用进行编码,然后使用hex_codec进行打印,并exec"".decode("hex")使用sys.stdout.write来避免打印换行符。运行此代码将输出第二个quine,这就是我生成它的方式。

我怀疑在Python中不可能有两个以上的代码,尽管我想看错了!

如果你不介意eval quines

ØrjanJohansen建议将以下内容用于预编码的第二个提子

y="""import sys
sys.stdout.write('exec"'+('y='+'"'*3+y+'"'*3+';exec y').encode("hex")+'".decode("hex")')""";exec y

对于以下输出,其得分为30 + 248 = 278个字节:

exec"793d222222696d706f7274207379730a7379732e7374646f75742e777269746528276578656322272b2827793d272b2722272a332b792b2722272a332b273b65786563207927292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222223b657865632079".decode("hex")

exec以这种方式使用不是根据PPCG 适当的quine规则作弊,但对我来说却有些作弊(优雅而聪明,但仍然很作弊),因为某些字符同时用作代码和数据。(尽管我的版本确实使用exec,但是代码和数据是分开的。)因此,我的得分保持在446。


1
"hex"可以代替"hex_codec",但可以节省一些字节!
Lynn '18

1
如果尾随换行很重要,为什么不只在第一行结尾添加空白行呢?
mbomb007 '18

1
这样。我了解这是使用exec / eval语言的非常标准的quine技巧。
与Orjan约翰森

1
为什么不重用与第一个奎纳相同的格式?像这样?
乔·金

2
print '<tab>',最后不添加空格。:使用此您可以85字节off乔国王的建议下tio.run/...
OVS

5

Japt2 3基内斯,106个 172字节

第一个是我的N char quine答案的漂亮版本。

[91,57,49,100,185,44,85,44,186,57,51,100,185,44,186,49,48,100,185,44,186,85,109,100,185,172,93,172]
[91d¹,U,º93d¹,º10d¹,ºUmd¹¬]¬

在这里尝试

第二个提要ETHProduction的较大好提要,这是Japt的一个很好的标准提要。

"iQ ²"iQ ²

在这里尝试

第三个使用``和代码异或来存储数据。

T=`f=fR;Zff-R-ReX%`;`T=\``+T+Tc^#

在这里尝试

由于()'仍然可用,它可能是可能的挤出一个更奎因。


1
我确实非常想尝试打第一个高尔夫球,但是我知道,随着啤酒的加入,一旦我尝试改变一个角色,我的大脑就会爆炸!妈的家伙!
毛茸茸的

@Shaggy "'[+U+']+R+(Umd)¬"q mc如果有任何帮助,请抓住底线并一直进行到第一行,以进行快速更新。
Nit

我还重构了第一个解决方案,使其具有更多可用的核心符号,现在实际上可以再添加一个Quine。
Nit

Wait, now your score is higher!
Shaggy

@Shaggy Intentionally so, I'm trying to make room for another quine, not make it shorter.
Nit

4

Gol><>, 2 3 quines, 17 28 27 26 bytes

6 bytes

"r2ssH

Try it online!

11 10 9 bytes

'3d*Wo{|;

Try it online!

11 bytes

Eh`#Ma0piS0

Try it online!

Gol><> has three ways to print any char:

  • o Pop one value and print as char
  • H Pop everything, print as char, and halt
  • S"..." Print string literal without affecting the stack at all

But I couldn't find a way to write a quine using S"..." as the only output method, so I came up with the above two, utilizing the two kinds of string literals.

The third one (by Jo King) uses the p command to create the " in S" on the fly, which in turn prints everything except the zero at the end. Then Eh prints the zero and exits.

Now that we used up all the output commands AND the p command, I believe it's impossible to create another quine (unless someone comes up with the S" quine without p).


How about this for S"..."?
Jo King

3

Ruby, 2 quines, 27 + 44 = 71 bytes

$><<<<2*2<<2
$><<<<2*2<<2
2

Try it online!

s=%q{s=%q{S};s[?S]=s;puts s};s[?S]=s;puts s

Try it online!

I'm mainly limited by methods of output, here. There are quite a few ways of manipulating strings, but aside from $><< all the usable output methods seem to intersect too much. I think there might be a way out with eval but it's tricky having to nest multiple string manipulations of different kinds.


3

Javascript ES6, 2 quines, 43 + 22 = 65 bytes

Quine 1:

(function f(){return[,f,'))'].join('(')}())

Quine 2:

g=z=>"g="+g+";g``";g``

You could save a few bytes by not invoking the functions and then by using a template literal in the second one.
Shaggy

2
So JavaScript outgolfs japt
dylnan

@dylnan Not until it adds a third quine.
Nit

@Shaggy hey, thanks for your input, but I'm confused - shouldn't a quine be a full program? If it can be a function, must it print only itself? So would g=z=>"g="+g be a valid JS quine?
Pedro A

1
@Nit I'll see what I can do :P when dylnan commented, japt had only 2 quines as well
Pedro A

3

><>, 2 quines, 8 + 16 = 24 bytes

8 bytes

#o<}-1:"

Try it online!

Taken from this answer.


16 bytes

'r3d*d8*7+e0p>>|

Try it online!

This is based on the 'r3d*>o< quine, except o and < cannot be used, so I replaced < with | and dynamically created o (111 = 8*13 + 7) and placed it where the 2nd > is.


2 quines is the limit

Unfortunately, we're limited by the number of output commands. n is not useful because it only outputs numbers, so o must be executed in any quine. The only way to dynamically create o is with p. So one quine can use o, and another can create it with p, but there can be no 3rd quine.

It might be possible to have a third quine leave the source code on the stack if that counts.


2

Java 10, 2 quines, 1448 1248 bytes

1350 1122 bytes

\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0022\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0025\u0063\u0025\u0073\u0025\u0031\u0024\u0063\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0025\u0031\u0024\u0063\u0025\u0063\u0025\u0033\u0024\u0063\u0075\u0025\u0025\u0030\u0034\u0058\u0025\u0031\u0024\u0063\u002C\u0063\u0029\u0029\u003B\u007D\u0022\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0022\u005C\u005C\u0075\u0025\u0030\u0034\u0058\u0022\u002C\u0063\u0029\u0029\u003B\u007D

Try it online.

Equivalent to:

v->{var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";r.format(r,34,r,92).chars().forEach(c->System.out.printf("\\u%04X",c));}

Explanation:

v->{                   // Method with empty unused parameter and no return-type
  var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";
                       //  Unformatted source code
  r.format(r,34,r,92)  //  Formatted quine
   .chars()            //  Loop over the characters as integers
   .forEach(c->System.out.printf("\\u%04X",c));}
                       //   Print "\u" with hexadecimal value of these characters

126 bytes

v->{int i='}'-'[';var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";System.console().printf(s,i,s,i);}

System.console() will return null when none is provided, so TIO returns a NullPointerException in this case.

To prove it's a working quine, replace System.console() with System.out: Try it online.

Explanation:

v->{              // Method with empty unused parameter and no return-type
  int i='}'-'[';  //  Integer `i` = 34 (unicode value for double-quote)
  var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";
                  //  Unformatted source code
  System.console().printf(s,i,s,i);}
                  //  Print formatted quine

General explanation:

In Java a is usually done like this:

  • The String s contains the unformatted source code.
  • %s is used to input this String into itself with the s.format(...).
  • %c, %1$c and the 34 are used to format the double-quotes.
  • s.format(s,34,s) puts it all together.

In which case the shortest quine lambda-function in Java 10 would be this (82 bytes):

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

Try it online.

Since the only way to have two quines in Java is using the unicode version with \uHEXA, which is converted to characters during compilation, I'm unable to use the characters 0123456789ABCDEF\u in the non-unicode version. So, the smaller non-unicode version will use System.console() instead of return or System.out (both containing a 'u'), and will use '}'-'[' and two times %c instead of 34 and %1$c.

Some things to note about the unicode version:

  • I'm on purpose using %04X instead of %04x (for uppercase Hexadecimal instead of lowercase).
  • I'm using 92, %c and %3$c to format the slashes.
  • Using a capital \U instead of lowercase \u isn't allowed apparently, otherwise I would have just used return in the shorter non-unicode version.
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.