在此处找到孔1 。

创建一个运行时输出多次自己的源代码块的工具。实际上，它必须输出n次，其中n是下一个质数。

我认为一个例子最能说明问题。

[MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]

每个程序将在下一个质数输出其基本“块”（即[MY QUINE]）。

不允许使用内置函数来计算数字是否为质数（如isPrime函数）或确定下一个质数（如nextPrime（）函数）。

• 这意味着不允许列出除数的函数
• 同样禁止返回素数分解的函数

这应该是一个真实的信息（除了一些余地，请参阅下一点），因此您不应阅读自己的源代码。

由于Java和C＃等语言已经处于不利地位，因此您无需输出完全有效的代码。如果可以将其放在一个函数中（即被调用）并输出下一个Quine，那么您就很好。

这是代码高尔夫球，所以最短的代码胜出！

CJam，31个字节

{'_'~]-3>U):U{)__,1>:*)\%}g*}_~

在CJam解释器中在线尝试。

理念

为了检查素数，我们将使用威尔逊定理，该定理指出，当且仅当（n-1）时，整数n> 1是素数！≡-1（mod n），当且仅当（n-1）时才成立！+ 1％n == 0。

码

{                           }_~ e# Define a block and execute a copy.
                                e# The original block will be on top of the stack.
 '_'~]                          e# Push those characters and wrap the stack in an array.
      -3>                       e# Keep only the last three elements (QUINE).
         U):U                   e# Increment U (initially 0).
             {           }g     e# Do-while loop:
              )__               e# Increment the integer I on the stack (initially U).
                 ,1>            e#   Push [1 ... I-1].
                    :*          e#   Multiply all to push factorial(I-1).
                      )\%       e#   Push factorial(I-1) + 1 % I.
                                e# While the result is non-zero, repeat.
                                e# This pushes the next prime after U.
                           *    e# Repeat QUINE that many times.

CJam，36 35字节

{]W="_~"]U):U{)_,{)1$\%!},,2>}g*}_~

这可绝对进一步golfed。

怎么运行的：

{                               }_~   "Copy this code block and execute the copy";
 ]W=                                  "Take just the last element from the stack";
                                      "The other thing on stack is the block from above";
    "_~"]                             "Put "_~" on stack and wrap the 2 things in an array";
                                      "At this point, the string representation of stack"
                                      "elements is identical to the source code";
         U):U                         "Increment U and update U's value. This  variable"
                                      "actually counts the number of [Quine] blocks";
             {)_,{)1$\%!},,2>}g       "Find the next prime number"
                               *      "Repeat the array that many times, thus repeat the"
                                      "[Quine] block, the next prime times";

感谢Martin提醒我这个]W=窍门:)

在这里在线尝试

Mathematica，248222字节

编辑：修复了与素数相关的函数的用法，但也改进了奎因。

编辑：感谢丹尼斯为我介绍了威尔逊定理。

1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#\2&@@("*"&,For[i=n,Mod[++i!/i+1,i]>0,0];i]")&,For[i=n,Mod[++i!/i+1,i]>0,0];i]

假设内核在两次运行之后退出（或至少n被重置），因为内核依赖于运行n第一个实例之前未定义[MyQuine]。

可以将其缩短很多，但是我对藜的经验不足，尤其是在Mathematica中。

这里是一个解释：

1;

这没有任何作用，但是如果将其连接到上一个藜的末尾，它将最后一个表达式的结果乘以1（是空操作），并且分号会抑制输出。这样可以确保仅最后的副本可以[MyQuine]打印任何内容。

n=If[ValueQ@n,n+1,1];

初始化n为1的第一个副本，[MyQuine]然后1在以后的每个副本中递增-即仅计算其中有多少个副本n。

立即跳到最后：

For[i=n,Mod[++i!/i+1,i]>0,0];i

这将使用威尔逊定理找到下一个质数。

StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("QUINE_PREFIX"*"QUINE_SUFFIX")&,NEXTPRIME[n]]

这是实际的奎因。它创建NextPrime@n代码本身的副本。这也有点奇怪。是的，我在这里将两个字符串相乘，没有，那没有有意义的结果。QUINE_PREFIX包含两个字符串之前的所有代码，并QUINE_SUFFIX包含两个字符串之后的所有代码。现在，通常您使用Apply（或@@）将列表转换为一系列参数。但是，您可以将任何内容替换Head为Apply-例如乘法。因此，尽管这是一个产品，我仍然可以将其转换为函数的两个参数。该功能可以：

#<>ToString[1##,InputForm]<>#2

其中#，第一个参数（前缀字符串）在哪里，#2第二个参数（后缀字符串）##在两个参数的序列中。我需要先1保留乘数-否则##会溅到的参数列表中ToString。无论如何，ToString[1##,InputForm]&@@("abc"*"def")退货"abc"*"def"……正是我所需要的！

我认为，围绕我需要的所有信息，eval基于基调的信息在这里更为合适。我稍后或明天再调查。

J-60字符

像其他答案一样使用下一个素数方法。（4 p:有点）

((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''

一个可爱的J小技巧是，当给定一个参数和给定两个参数时，其f :g行为类似于。因此，如果您将其写出来，请说出话来就像，这很棒，因为这是一个装箱列表，其内容为项目，长度为出现次数。fgf :;'a'f :;'a'f :;'a'f'a';'a';'a''a'

因此，我们可以将其简化为一种怪异的东西。在f我们使用的模样(foo $~ bar)，在foo构造字符串的一部分，我们重复一遍又一遍，bar寻找下一个素数和60相乘，在字符串的长度foo。

   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
180
   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
300

Python 2.7、214

from sys import*;R,s=range,chr(35)
def N(n):
 if n<3:return n+1
 for p in R(n+1,n+n):
    for i in R(2, p):
     if p%i==0:break
     else:return p
P=file(argv[0]).read();print(P.split(s)[0]+s)*N(P.count(chr(37)));exit(0)
#