하이퍼 프로그래밍에서 영감을 얻음 : N + N, NxN, N ^ N 모두 하나로 .
샌드 박스에 대한 도움을 주신 @MartinEnder와 @trichoplax에게 감사합니다.

정의

하이퍼 퀸

차수 n 의 하이퍼 퀸 을 퀴인 과 같은 전체 프로그램 또는 함수 P 로 정의하여 적절한 퀴네에 적용되는 모든 규칙을 충족하고 또한 다음과 같은 구조를 갖습니다.

P는 캐릭터의 연쇄이다 ^‡ 구성 그룹 N 개의 동일한 문자의 사본. 경우 P가 실행되면, 출력 문자의 하나 이상의 카피에서 동일한 증강 기의 연결이다.

예

• 소스 코드 aabbcc가 출력을 생성 하는 가상 프로그래밍 언어 aaabbbccc에서이 프로그램은 차수 2 의 하이퍼 퀸을 구성합니다 .

• 정의 에 따라 다른 그룹의 문자가 다를 필요 는 없습니다 .

  소스 코드 aabbcc가 출력을 생성하면 aaaabbbbcccc프로그램은 차수 1 의 하이퍼 퀸입니다 . 소스 코드는 6 개의 단일 문자 그룹, 6 개의 문자 쌍 출력으로 구성됩니다.

• 에서 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 _n ) 이 길이 n 의 하이퍼 퀸 체인을 구성 하도록 무한 하이퍼 퀸 체인 을 완전한 프로그램 또는 함수 (P ₁ , P ₂ ,…) 의 무한 시퀀스로 정의하십시오 .

예

• 소스 코드는 가상의 프로그래밍 언어로 aabbcc출력 생성 aaabbbccc차례로 출력 생성하고, aaaabbbbcccc상기 한 쌍의 ( aabbcc, aaabbbccc) 길이 hyperquine 체인 구성 2 .

  참고 aaaabbbbcccc- 체인의 마지막 hyperquine의 출력이 - 특정 출력을 생성 할 필요가 없습니다 유효한 소스 코드 일 필요도 없습니다.

• 만약, 이전의 예를 계속 aaaabbbbcccc출력 생성 aaaaabbbbbccccc의 트리플렛 ( aabbcc, aaabbbccc, aaaabbbbcccc)의 길이 hyperquine 체인 구성 3 .

  이 패턴이 영원히 계속되면, 시퀀스 ( aabbcc, aaabbbccc, aaaabbbbcccc...) hyperquine 무한 체인을 구성한다.

• 프로그램 (쌍 abc, aabbcc출력을 갖는)은 ( aabbcc, aaaabbbbcccc)이다 하지 hyperquines의 순서는 모두 때문에, hyperquine 쇄 1 가 엄격 증가 시퀀스를 형성하지 않도록.

• 프로그램 (쌍 aabbcc, aaaabbbbcccc출력을 갖는)은 ( aaaabbbbcccc, aaaaabbbbbccccc)이다 하지 hyperquines의 명령이 때문에, hyperquine 쇄 1 과 4 가 인접하는 정수의 시퀀스를 형성하지 않도록.

규칙

태스크

A의 프로그래밍 언어 선택의, 즉 비 사소한 hyperquine 체인, 적어도 구성 체인 쓰기 2 hyperquines합니다.

평소와 같이 프로그램은 어떤 형식으로도 입력을 받거나 자신의 소스 코드에 액세스 할 수 없습니다.

통역사가 암시 적 개행을 인쇄하는 경우 하이퍼 퀸 이이를 설명해야합니다.

모든 표준 허점 ( 특히 퀴네 관련 구멍)이 적용됩니다.

채점

가장 긴 하이퍼 퀸 체인이 이깁니다. 두 개 이상의 제출이 연결되어있는 경우, 가장 짧은 hyperquine 시작이 중 제출 (문자 단위로 측정 ^‡ 승). 평소와 같이 게시 시간이 최종 순위 결정자입니다.

^‡ _{당신은 소스 코드, 출력, 글자 수, 및 실행을위한 동일한 문자 인코딩을 사용해야합니다. 예를 들어, 인터프리터는 각 바이트를 단일 문자로 취급하므로 Python 프로그램 print 42은 2 문자 UTF-32 제출 이 아닙니다 . 선택한 언어가 문자 기반이 아닌 경우 모든 개별 바이트를 문자로 취급하십시오.}

Befunge-98 , 무한 순서, 54 52 38 36 바이트

두 번째 접근 방식-무한 순서, 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 스크립트.

설명

주요 아이디어는 실제 제어 흐름이 반복의 영향을받지 않도록 퀴인을 수직으로 돌리는 것입니다. 예를 들어 두 번째 하이퍼 퀴니는 다음과 같이 시작됩니다.

^^

..

**

첫 번째 열만 이동하므로 반복되는 문자에 대해 걱정할 필요가 없습니다. 또한 코드의 대부분을 문자열로 '푸시하면 빈 줄마다 공백이 생기므로 반복 횟수를 결정할 수 있습니다. 그러나 빈 줄로 인해 몇 가지 제한 사항이 있습니다.

• "quine의 주요 부분에서 큰 숫자를 문자 코드로 푸시 하는 데 사용할 수 없습니다 32. 원하지 않는 추가 코드를 푸시하기 때문 입니다.
• 우리는 사용할 수 없습니다 ?또는 !그들은 단지 (실제로 다음 명령을 건너 뛸 것 때문에)이 경우에 공백이 될 다음 문자를 건너 뛸 수 있기 때문이다.

따라서 모든 제어 흐름은 명시적인 점프 (기본적으로 2D 이동)로 수행되며 반복 횟수에 따라 실제 오프셋을 계산해야합니다.

실제 코드를 보자. 우리 ^는 코드가 상향식으로 시작 되도록 시작 합니다. 더 쉽게 읽을 수 있도록 실제 코드를 실행 순서대로 작성하고 ^다시 실행되지 않기 때문에 삭제하십시오 .

'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.

스택이 비어 있고 첫 번째 내부 루프가 다른 문자를 인쇄하지 못하면 프로그램이 종료됩니다.