แรงบันดาลใจจากHyperprogramming: N + N, N × N, N ^ N ทั้งหมดในที่เดียว
ขอบคุณ @MartinEnder และ @trichoplax สำหรับความช่วยเหลือในกล่องทราย

คำนิยาม

Hyperquines

กำหนดhyperquineของnคำสั่งเป็นโปรแกรมหรือฟังก์ชันPเหมือนเต็มquine ที่ตรงกับกฎทั้งหมดที่ใช้กับquines ที่เหมาะสมและนอกจากนี้มีโครงสร้างดังต่อไปนี้

Pคือการรวมกันของกลุ่มอักขระ^‡ที่ประกอบด้วยสำเนาnตัวอักษรเดียวกัน เมื่อPจะถูกดำเนินการในการส่งออกคือการเรียงต่อกันในกลุ่มเดียวกันเติมโดยสำเนาอีกหนึ่งของตัวละคร

ตัวอย่าง

• ในการเขียนโปรแกรมภาษาสมมุติที่รหัสที่มาaabbccสร้างการส่งออกaaabbbcccโปรแกรมนี้ถือว่า hyperquine สั่งซื้อ2

• คำจำกัดความไม่ต้องการให้อักขระของกลุ่มต่างกันจะแตกต่างกัน

  ถ้าซอร์สโค้ดaabbccสร้างเอาท์พุทaaaabbbbcccc, โปรแกรมเป็น hyperquine ของการสั่งซื้อ1 ; ซอร์สโค้ดประกอบด้วยกลุ่มอักขระเดี่ยวหกกลุ่มเอาต์พุตของอักขระหกคู่

• ในGS2โปรแกรมที่ว่างเปล่าจะพิมพ์ออก\nมาและโปรแกรมจะ\nพิมพ์\n\nออกมา แต่ไม่\nว่ามิได้\n\nมี hyperquines เนื่องจากพวกเขาพวกเขาไม่ตอบสนองคุณสมบัติทั้งหมดของquines ที่เหมาะสม ; ไม่มีส่วนใดของรหัสที่มาเข้ารหัสส่วนต่าง ๆของผลลัพธ์

โซ่ไฮเปอร์วิน

นิยามhyperquine chain of length nเป็นลำดับที่แน่นอนของn full programs หรือn function
(P ₁ , …, P _n )ที่สอดคล้องกับข้อ จำกัด ดังต่อไปนี้

1. เอาต์พุตของP ₁ , …, P _n-1คือP ₂ , …, P _n , ตามลำดับ

2. P ₁ , …, P _nคือไฮเปอร์คิ

3. คำสั่งของP ₁ , …, P _nสร้างลำดับของจำนวนเต็มที่อยู่ติดกันอย่างเคร่งครัด

สุดท้ายกำหนดห่วงโซ่ hyperquine อนันต์เป็นลำดับอนันต์ของโปรแกรมเต็มหรือฟังก์ชั่น(P ₁ , P ₂ , ... )เช่นกันว่าช่วงเวลาเริ่มต้น(P ₁ , ... , P _n )ที่ถือว่าเป็นห่วงโซ่ hyperquine ของความยาวn

ตัวอย่าง

• ในการเขียนโปรแกรมภาษาสมมุติที่รหัสที่มาaabbccสร้างการส่งออกaaabbbcccซึ่งในที่สุดก็สร้างเอาท์พุทaaaabbbbccccคู่ ( aabbcc, aaabbbccc) ที่ถือว่าเป็นห่วงโซ่ hyperquine ของความยาว2

  โปรดทราบว่าaaaabbbbcccc- ผลลัพธ์ของไฮเปอร์ควินล่าสุดในสายโซ่ - ไม่จำเป็นต้องสร้างเอาต์พุตเฉพาะ ไม่จำเป็นต้องเป็นซอร์สโค้ดที่ถูกต้อง

• อย่างต่อเนื่องตัวอย่างก่อนหน้านี้ถ้าaaaabbbbccccสร้างเอาท์พุทaaaaabbbbbccccc, แฝด ( aabbcc, aaabbbccc, aaaabbbbcccc) ที่ถือว่าเป็นห่วงโซ่ hyperquine ของความยาว3

  หากรูปแบบนี้ยังคงอยู่ตลอดไปลำดับ ( aabbcc, aaabbbccc, aaaabbbbcccc, ... ) ถือว่าเป็นห่วงโซ่ hyperquine อนันต์

• คู่ของโปรแกรม ( abc, aabbcc) ที่มีเอาต์พุต ( aabbcc, aaaabbbbcccc) ไม่ได้เป็นไฮเปอร์วินซีนเนื่องจากคำสั่งของไฮเปอร์วินเป็นทั้ง1ดังนั้นพวกเขาจึงไม่ได้เรียงลำดับที่เพิ่มขึ้นอย่างเข้มงวด

• คู่ของโปรแกรม ( aabbcc, aaaabbbbcccc) ที่มีเอาท์พุต ( aaaabbbbcccc, aaaaabbbbbccccc) ไม่ใช่สายไฮเปอร์ควินเนื่องจากคำสั่งของไฮควินเป็น1และ4ดังนั้นจึงไม่ได้สร้างลำดับของจำนวนเต็มที่อยู่ติดกัน

กฎระเบียบ

งาน

ในภาษาการเขียนโปรแกรมที่คุณเลือกให้เขียนไฮเปอร์ควิโนนที่ไม่สำคัญเช่นเชนที่ประกอบด้วยไฮเปอร์คินอย่างน้อย2ตัว

ตามปกติโปรแกรมของคุณจะไม่รับอินพุตหรือเข้าถึงซอร์สโค้ดของตัวเองในรูปแบบใด ๆ

หากล่ามของคุณพิมพ์บรรทัดใหม่โดยนัยไฮเปอร์ไลน์ของคุณจะต้องคำนึงถึงสิ่งนี้

มีช่องโหว่มาตรฐานทั้งหมดโดยเฉพาะที่เกี่ยวข้องกับควินิน

เกณฑ์การให้คะแนน

ห่วงโซ่ hyperquine ที่ยาวที่สุดชนะ หากมีการเชื่อมโยงการส่งสองครั้งขึ้นไปการส่งระหว่างสิ่งเหล่านี้ที่เริ่มต้นด้วย hyperquine ที่สั้นที่สุด (วัดเป็นอักขระ^‡ ) จะชนะ ตามปกติเวลาการโพสต์คือ tiebreaker สุดท้าย

^‡ _{คุณต้องใช้การเข้ารหัสอักขระเดียวกันสำหรับซอร์สโค้ดเอาต์พุตจำนวนตัวอักษรและการดำเนินการ ตัวอย่างเช่นโปรแกรม Python print 42เป็นได้ 2 ตัว UTF-32 ส่งตั้งแต่ถือว่าล่ามแต่ละไบต์เป็นตัวเดียว หากภาษาที่คุณเลือกไม่ได้อิงกับตัวอักษรให้ถือว่าไบต์แต่ละตัวเป็นตัวอักษร}

Befunge-98 , infinite order, 54 52 38 36 bytes

วิธีที่สอง - ลำดับไม่สิ้นสุด 36 ไบต์

โปรแกรมนี้จะแยกกันที่ไฮเปอร์ควินที่ 34 เนื่องจากค่า ASCII ของ"จะรบกวนการตีความสตริง (และที่ 59, ;) แต่เราชดเชยการจัดเก็บค่านั้นเป็นตำแหน่งที่จะไม่ถูกดำเนินการ (เช่น(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 ไบต์

โปรแกรมมี linefeed ต่อท้าย

^
.
*
&
:
&
+
*
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 เพื่อสร้างแหล่งที่มาจากโปรแกรมเชิงเส้น

คำอธิบาย

แนวคิดหลักคือการเปลี่ยนแนวตั้งควินเพื่อให้การควบคุมการไหลที่แท้จริงไม่ได้รับผลกระทบจากการซ้ำซ้อน เช่นไฮเปอร์ควินินที่สองเริ่มต้นเช่น:

^^

..

**

เนื่องจากเราย้ายเฉพาะในคอลัมน์แรกเราจึงไม่ต้องกังวลเกี่ยวกับตัวละครซ้ำ นอกจากนี้เมื่อเรากดรหัสส่วนใหญ่เป็นสตริงด้วย'สิ่งนี้จะเพิ่มที่ว่างสำหรับแต่ละบรรทัดว่างซึ่งทำให้เราสามารถกำหนดจำนวนการทำซ้ำได้ ที่กล่าวว่ามีข้อ จำกัด บางประการเนื่องจากบรรทัดว่างเหล่านี้:

• เราไม่สามารถใช้"เพื่อผลักดันตัวเลขขนาดใหญ่เป็นรหัสตัวอักษรในส่วนหลักของควินินเพราะจะเป็นการเพิ่มจำนวน32ที่ไม่ต้องการ
• เราไม่สามารถใช้?หรือ!เพราะพวกเขาเพียงข้ามตัวอักษรถัดไปซึ่งจะเป็นช่องว่างในกรณีนั้น (ดังนั้นพวกเขาจะไม่ข้ามคำสั่งถัดไป)

ดังนั้นการควบคุมการไหลทั้งหมดจะกระทำโดยการกระโดดอย่างชัดเจน (โดยทั่วไปคือ 2D goto) ซึ่งมีการหักล้างจริงที่เราจำเป็นต้องคำนวณตามจำนวนการทำซ้ำ

ลองดูรหัสจริง เราเริ่มต้นด้วย^รหัสจะถูกประมวลผลจากล่างขึ้นบน เพื่อให้ง่ายต่อการอ่านลองเขียนรหัสจริงตามลำดับการดำเนินการ (และปล่อย^เพราะมันไม่เคยถูกเรียกใช้อีกครั้ง):

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

นี่'เป็นเทคนิคการ quining มาตรฐานสำหรับ> <> (และฉันคิดว่า Befunge) มันสลับไปที่โหมดสตริงซึ่งหมายความว่าตัวละครที่พบจะถูกผลักลงบนสแต็กจนกว่า'จะพบต่อไป เส้นที่ว่างเปล่าจะถูกบุด้วยปริยายโดยมีช่องว่างซึ่งเป็นสาเหตุที่ทำให้เราได้ช่องว่างทั้งหมดระหว่างนั้น บรรทัดว่างที่ท้ายโปรแกรมจะถูกละเว้น ดังนั้นหลังจากที่ 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.

โปรแกรมจะหยุดทำงานเมื่อสแต็กว่างเปล่าและลูปภายในแรกไม่สามารถพิมพ์อักขระอื่นได้