ここでホール1を見つけます。

実行すると、独自のソースコードブロックを複数回出力するquineを作成します。実際には、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＃などの言語はすでに不利な立場にあるため、完全に機能するコードを出力する必要はありません。関数に呼び出され（それが呼び出され）、次のクインを出力できる場合は、問題ありません。

これはコードゴルフなので、最短のコードが勝ちます！

CJam、31バイト

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

CJamインタープリターでオンラインで試してください。

考え

素数性をチェックするには、ウィルソンの定理を使用します。これは、整数n> 1は（n-1）の場合にのみ素数であると述べています！-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*}_~

これは間違いなくさらにゴルフすることができます。

使い方：

{                               }_~   "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";

]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ているため、カーネルが後続のquineの実行間で終了する（または少なくともリセットされる）ことを前提としています[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コード自体のコピーを作成します。また、少し変です。はい、ここで2つの文字列を乗算していますが、それは意味のある結果にはなりません。QUINE_PREFIX2つの文字列の前QUINE_SUFFIXにすべてのコードが含まれ、2つの文字列の後にすべてのコードが含まれます。現在は通常Apply（または@@）を使用して、リストを一連の引数に変換します。しかし、あなたはいずれかを置き換えることができますHeadとApply例えば乗算- 。したがって、これが製品であるにもかかわらず、それを自分の関数の2つの引数に変えることができます。その関数は：

#<>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トリックは、1つの引数が与えられたときと2 つの引数が与えられたときのf :gようfに動作しgます。したがって、書き出すとすると、のf :;'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)
#