Натхненний гіперпрограмуванням: N + N, N × N, N ^ N все в одному .
Дякуємо @MartinEnder та @trichoplax за допомогу в пісочниці.

Визначення

Гіперкіни

Визначте гіперкіну порядку n як повну програму або функцію P , подібну квінові , яка задовольняє всім правилам, що стосуються належних квінок, і, крім того, має таку структуру.

Р являє собою об'єднання символів ^‡ груп, що складаються з п копій одного і того ж символу. Коли P виконується, вихід - це конкатенація тих самих груп, що доповнюється ще однією копією символу.

Приклади

• У гіпотетичній мові програмування, де вихідний код aabbccгенерує вихід aaabbbccc, ця програма являє собою гіперкіну порядку 2 .

• Визначення не вимагає, щоб символи різних груп були різними.

  Якщо вихідний код aabbccгенерує вихід aaaabbbbcccc, програма є гіперквіном порядку 1 ; вихідний код складається з шести одно символьних груп, вихід із шести пар символів.

• У GS2 порожня програма друкується \n, а програма \nдрукується \n\n. Однак \nні \n\nгіперквіни, ні вони не є, оскільки вони не задовольняють усім властивостям належних квінок ; жодна частина вихідного коду не кодує іншу частину виводу.

Гіперкінні ланцюги

Визначте ланцюг гіперквінів довжиною n як кінцеву послідовність n повних програм або n функцій
(P ₁ ,…, P _n ), яка задовольняє наступним обмеженням.

1. Виходи P ₁ ,…, P _n-1 - P ₂ ,…, P _n відповідно.

2. P ₁ ,…, P _n - гіперквіни.

3. Порядки P ₁ ,…, P _n утворюють суворо зростаючу послідовність суміжних цілих чисел.

Нарешті, визначте нескінченний ланцюг гіперквінів як нескінченну послідовність повних програм або функцій (P ₁ , P ₂ , ...) таким чином, що кожен початковий інтервал (P ₁ , ..., P _n ) являє собою ланцюг гіперквінів довжиною n .

Приклади

• У гіпотетичній мові програмування, де вихідний код aabbccгенерує висновок aaabbbccc, який, у свою чергу, генерує вихід aaaabbbbcccc, пара ( aabbcc, aaabbbccc) утворює ланцюг гіперквінів довжиною 2 .

  Зауважте, що aaaabbbbcccc- вихід останнього гіперквіну в ланцюзі - не повинен давати конкретний вихід; він навіть не повинен бути дійсним вихідним кодом.

• Продовжуючи попередній приклад, якщо aaaabbbbccccформує вихідний сигнал aaaaabbbbbccccc, триплет ( aabbcc, aaabbbccc, aaaabbbbcccc) являє собою hyperquine ланцюг довжиною 3 .

  Якщо ця картина триває вічно, послідовність ( aabbcc, aaabbbccc, aaaabbbbcccc...) являє собою нескінченний ланцюг hyperquine.

• Пара програм ( abc, aabbcc) з виходами ( aabbcc, aaaabbbbcccc) не є ланцюгом гіперхінів, оскільки порядки гіперквінерів є обома 1 , тому вони не утворюють суворо зростаючої послідовності.

• Пара програм ( aabbcc, aaaabbbbcccc) з виходами ( aaaabbbbcccc, aaaaabbbbbccccc) не є ланцюгом гіперхінів, оскільки порядки гіперквіней дорівнює 1 і 4 , тому вони не утворюють послідовності суміжних цілих чисел.

Правила

Завдання

У мові програмування за вашим вибором, написати нетривіальний hyperquine ланцюг, тобто ланцюг , яка складається , щонайменше , 2 hyperquines.

Як завжди, ваші програми можуть не приймати жодного вводу чи доступу до власного вихідного коду в будь-якій формі.

Якщо ваш перекладач друкує неявну нову лінію, ваші гіперквіни повинні це враховувати.

Застосовуються всі стандартні лазівки, особливо ті, що стосуються королеви.

Оцінка балів

Виграє найдовший ланцюг гіперкінів . Якщо два чи більше подань зв'язані, подання серед них, що починається з найкоротшого гіперквіну (вимірюється символами ^‡ ), виграє. Як завжди, час публікації - це остаточний перелом.

^‡ _{Ви повинні використовувати одне й те саме кодування символів для вихідного коду, виводу, кількості символів та виконання. Наприклад, програма Python print 42- це не двозначне подання UTF-32, оскільки інтерпретатор розглядає кожен байт як один символ. Якщо ваша мова вибору не базується на символах, розглядайте всі байти як символи.}

Befunge-98 , нескінченний порядок, 54 52 38 36 байт

Другий підхід - нескінченний порядок, 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 байт

Програма містить зворотний канал.

^
.
*
&
:
&
+
*
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 (Цей останній потребує певного часу.)

Сценарій сітківки для створення джерела з лінійної програми.

Пояснення

Основна ідея полягає в тому, щоб повернути лапку вертикально, щоб фактичний потік управління не впливав на повторення. Наприклад, друга гіперкіна починається так:

^^

..

**

Оскільки ми рухаємося лише через перший стовпець, нам не потрібно турбуватися про повторювані символи. Крім того, коли ми натискаємо більшість коду як рядок ', це дасть пробіл для кожного порожнього рядка, що дає нам можливість визначити кількість повторень. Однак, у цих порожніх рядків є деякі обмеження:

• Ми не можемо використати "великі числа як символьні коди в основній частині quine, тому що це підштовхне додаткові 32s, які ми не хочемо.
• Ми не можемо використовувати ?або !тому, що вони пропускають лише наступний символ, який у цьому випадку буде пробілом (тому вони фактично не пропускають наступну команду).

Отже, весь потік управління здійснюється з явними стрибками (в основному 2D goto), фактичні зміщення яких нам потрібно обчислити, виходячи з кількості повторень.

Тож давайте подивимось на власне код. Почнемо з ^того, що код виконується знизу вгору. Для легшого читання давайте випишемо фактичний код у порядку виконання (і відкиньте його, ^тому що він більше ніколи не виконується):

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

Це 'стандартна техніка квинінгу для> <> (і 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.

Програма закінчується, коли стек порожній і перший внутрішній цикл не може надрукувати інший символ.