ハイパープログラミングに触発された：N + N、N×N、N ^ Nがすべて1つ。
@MartinEnderと@trichoplaxがサンドボックスで助けてくれたことに感謝します。

定義

ハイパークイン

定義hyperquineオーダーのNを QUINE状完全なプログラムまたは関数としてP を満たすに適用されるすべてのルール適切quines加えて、以下の構造を有し、そして。

Pは、同じ文字のn個のコピーで構成される文字^‡グループの連結です。ときPが実行され、出力が文字の1つの以上のコピーによって拡張、同じグループの連結です。

例

• ソースコードaabbccが出力を生成する仮想プログラミング言語ではaaabbbccc、このプログラムは次数2のハイパークインを構成します。

• 定義では、異なるグループの文字が異なる必要はありません。

  ソースコードaabbccが出力を生成する場合、aaaabbbbccccプログラムは1次のハイパークインです。ソースコードは6つの単一文字グループ、6文字のペアの出力で構成されています。

• ではGS2、空のプログラムを印刷\nし、プログラム\nを印刷\n\n。ただし、ハイパークインは、適切なクインのすべてのプロパティを満たさないため、ハイパークインで\nも\n\nありません。ソースコードのどの部分も、出力の別の部分をエンコードしません。

ハイパークインチェーン

次の制約を満たす、n個の完全なプログラムまたはn個の関数（P ₁、…、P _n）の有限シーケンスとして、長さnのハイパークインチェーンを定義します。

1. 出力P ₁、...、P _N-1であるP ₂、...、P _nはそれぞれ、。

2. P ₁、…、P _nはハイパークインです。

3. 次数P ₁、...、P _Nを形成狭義増加の配列に隣接する整数。

最後に、各初期間隔（P ₁、…、P _n）が長さnのハイパークインチェーンを構成するように、無限プログラムおよび関数（P ₁、P ₂、…）の無限シーケンスとして無限ハイパークインチェーンを定義します。

例

• ソースコードは、仮想的なプログラミング言語のaabbcc出力を生成aaabbbccc順に、出力を生成し、、 aaaabbbbcccc、ペア（aabbcc、aaabbbccc）長さのhyperquineチェーン構成2。

  aaaabbbbccccチェーンの最後のハイパークインの出力は、特定の出力を生成する必要がないことに注意してください。有効なソースコードである必要はありません。

• 場合は、前の例を続けるとaaaabbbbcccc、出力を生成するaaaaabbbbbccccc（トリプレットaabbcc、aaabbbccc、aaaabbbbcccc）長のhyperquine鎖構成3。

  このパターンが永遠に続けば、シーケンスは（aabbcc、aaabbbccc、aaaabbbbcccc、...）無限hyperquineチェーンを構成しています。

• 出力（abc、aabbcc）を持つプログラムのペア（aabbcc、aaaabbbbcccc）はハイパーキンチェーンではありません。これは、ハイパーキンの次数が両方とも1であるため、厳密に増加するシーケンスを形成しないためです。

• ハイパーキンの次数は1と4であるため、出力（aabbcc、aaaabbbbcccc）を持つプログラムのペア（aaaabbbbcccc、aaaaabbbbbccccc）はハイパーキンチェーンではありません。したがって、隣接する整数のシーケンスを形成しません。

ルール

仕事

選択したプログラミング言語で、重要なハイパーキンチェーン、つまり、少なくとも2つのハイパーキンで構成されるチェーンを記述します。

いつものように、あなたのプログラムはどんな形式でも入力を受け付けたり、独自のソースコードにアクセスしたりすることはできません。

インタプリタが暗黙的な改行を出力する場合、ハイパークインはこれを考慮する必要があります。

すべての標準的な抜け穴、特にクインに関連する抜け穴が適用されます。

得点

最長のハイパークインチェーンが勝ちます。2つ以上の提出物が結び付けられている場合、最短のハイパークイン（文字^‡で測定）で始まるこれらの提出物が勝ちます。いつものように、投稿時間は最後のタイブレーカーです。

^‡ _{ソースコード、出力、文字数、および実行に同じ文字エンコードを使用する必要があります。たとえば、インタープリターは各バイトを単一の文字として扱うため、Pythonプログラムprint 42は2文字のUTF-32送信ではありません。選択した言語が文字ベースではない場合、個々のバイトをすべて文字として扱います。}

Befunge-98、無限の順序、54 52 38 36バイト

2番目のアプローチ-無限の順序、36バイト

ASCII値は"文字列の解釈を中断するため（および59、;）、このプログラムは実際に34番目のハイパークインで中断しますが、その値の格納を実行されない位置（つまり）(0, 1)ではなくオフセットします(0, 0)。

1+::0*x01pn'!1+:#jr;,kg10@k!:kg10;#"

オンラインそれを試してみてください：1、2、10、34、42

説明

INSTRUCTIONS  STACK (PYTHON PSEUDOCODE)           EXPLANATION
1+            [n]                                 Push n many 1s onto the stack, then sum them up
::            [n]*(at least 3)                    Duplicate that sum at least twice
0*            [n]*(at least 2)+[0]                Push a whole lot of zeros, then multiply them all together
x             [n]*(at least 1)                    Pop a vector off the stack (n, 0) and set the IP delta to that; now the IP is only executing every nth character
01p           [n]*(at least 1)                    Place n in the program at coordinates (0, 1); this is just for storage
n             []                                  Clear the stack
'!1+          ['"']                               '!' is character 33; one less than 34, or '"'
:#jr          ['"']                               We duplicate the 34 (all we care is that it's a rather large number), then turn around and skip that many spaces
                                                  The IP, having jumped 34*n instructions to the left, is now way in the negatives
                                                  Execution resumes on the other side of the program (the following instructions have been reversed for readability
"             [the program of order 1]            The quote-at-the-end-of-the-program is a common trick for one-liner Befunge quines
#; ... ;                                          Jumps into a loop (when the IP hits one semicolon it skips to the next, restarting the loop)
01gk:         [(rest of string), char*(n+2)]      This duplicates the letter n+1 times*, leaving n+2 copies on the stack
!k@                                                If the number on the top of the stack is zero (i.e. we are printing), it will execute '@',
                                                  ending the program; otherwise, it will NOT execute '@' and will instead continue normally
                                                  Vague* 'k' instruction FTW
10gk,                                             If we aren't done yet, print the character n+1 times* (and restart the loop)

* 'k' is a very strange instruction. It pops a number off the stack; if the number is zero, it skips the command in front of it. If the number is greater than zero,
  it will execute the instruction that many times PLUS ONE. This is actually strangely advantageous in this program.

最初のアプローチ-注文34、52バイト（イントロスペクションを使用するため、技術的には合法ではありません）

上記の投稿の理由により、このプログラムは注文34で中断します（ただし、テストしていません）。

1+::0*x:00p'1\k:00gk,1#;:00g*0g00gk:$00gk,1+:'4-!k@;

オンラインでお試しください！

> <>、無限の順序、178バイト

プログラムには末尾の改行が含まれています。

^
.
*
&
:
&
+
*
2
b
*
*
6
9
$
0
)
*
4
8
:
~
.
*
&
:
&
+
*
2
b
*
*
2
b
$
0
)
i
:
-
1
o
a
&
:
&
o
~
.
*
&
:
&
+
*
7
7
*
*
4
6
$
0
)
0
:
-
1
$
o
:
$
&
:
&
&
,
*
8
b
-
1
l
}
*
3
d
'

オンラインそれを試してみてください： 1、2、3、10（最後の実行に時間がかかること。）

線形プログラムからソースを生成するRetinaスクリプト。

説明

主なアイデアは、実際の制御フローが繰り返しの影響を受けないように、クインを垂直に変えることです。たとえば、2番目のハイパークインは次のように始まります。

^^

..

**

最初の列だけを移動しているため、文字の繰り返しを心配する必要はありません。また、コードの大部分をで文字列として'プッシュすると、空行ごとにスペースがプッシュされ、繰り返しの数を判断する方法が提供されます。ただし、これらの空の行による制限がいくつかあります。

• 私たちは、使用することはできません"、これは追加のプッシュしてしまうため、QUINEの主要部分で文字コードとして大量にプッシュする32私たちは望んでいないのを。
• 使用できない?か!、その場合はスペースとなる次の文字のみをスキップするため（実際には次のコマンドをスキップしません）。

したがって、すべての制御フローは明示的なジャンプ（基本的には2D goto）で行われますが、その実際のオフセットは繰り返し回数に基づいて計算する必要があります。

それでは、実際のコードを見てみましょう。まず^、コードがボトムアップで実行されるようにします。読みやすくするために、実際のコードを実行順序で書き出してみましょう（そして、^二度と実行されないのでドロップします）：

'd3*}l1-b8*,&&:&$:o$1-:0)0$64**77*+&:&*.~o&:&ao1-:i)0$b2**b2*+&:&*.~:84*)0$96**b2*+&:&*.

これ'は、> <>（およびBefunge、私は推測します）の標準的なquiningテクニックです。文字列モードに切り替わります。つまり、検出された文字は、次の文字が検出されるまでスタックにプッシュされます'。空行には暗黙的にスペースが埋め込まれます。そのため、間にすべてのスペースが入ります。プログラムの最後の空行は無視されます。そのため、IPがラップアラウンドして'再びヒットした後、スタック'自体にプログラムの最初の列があります。

これを使用してプログラム全体を印刷する方法を見てみましょう。

d3*}    Put a 36 (the ') at the bottom of the stack. Now the stack holds
        a representation of the entire first column.
l1-     Push the depth of the stack, minus (so minus to ').
b8*,    Divide by 88. The original program has 89 lines. If we divide the 
        depth of the stack (minus 1) by 88, we get the order of the current
        hyperquine (due to all the spaces we've pushed).
&       Store the order of the hyperquine in the register.
        Begin of main loop:
&:&       Push a copy of the register onto the stack. Call that N.
          Begin of line-printing loop:
$:o$        Print a copy of the top character on the stack.
1-          Decrement N.
:0)         Check whether it's still positive (gives 0 or 1).
0$          Put a 0 underneath. This will be the x-coordinate of a jump.
64**        Multiply the conditional by 24. This is the number of commands
            in this inner loop.
77*+        Add this to 49, the offset of the end of the loop.
            The result is line we want to jump to in the order-1 hyperquine.
&:&*        Multiply by the order of the quine (so that we jump further on
            higher quine orders).
.         Jump. If N isn't zero yet, this repeats the inner loop. Otherwise
          we continue right here.
~         Discard N (now 0).
o         Output one last copy of the top character on the stack.
&:&       Push a copy of the register onto the stack. Call that N.
          Begin of linefeed-printing loop:
ao          Print a linefeed.
1-          Decrement N.
:i)         Check whether it's still non-negative (gives 0 or 1).
            The next bit is essentially the same loop structure as above,
            but with loop length 22 and offset 22:
0$
b2**
b2*+
&:&*
.         Jump. If N isn't -1 yet, this repeats the inner loop. Otherwise
          we continue right here.
          Begin of space-clearing loop:
~           Discard the top of the stack. On the first iteration this is the
            -1 from the previous loop. Afterwards, it's one of the spaces
            representing an empty line.
:84*)       Check if the top of the stack is a space.
            And another loop conditional. This one works the other way round:
            the difference is 54, which is the distance between the beginning
            of this loop and the main loop. The offset is the beginning
            of this loop, at 22 as above.
0$
96**
b2*+
&:&*
.         Jump. If the top of the stack is still a space this repeats the 
          inner loop. Otherwise we continue from the top of the main loop.

スタックが空になり、最初の内部ループが別の文字を出力できない場合、プログラムは終了します。