관련 : Interquine

프로그램 A는 실행될 때 프로그램 B의 코드를 출력하고 B는 C의 소스를 출력하고 C는 A의 소스를 출력합니다.

이번에는 두 문자를 교환하고 다시 교환 할 수 없습니다 :)

요구 사항 :

• 모든 프로그램에서 단 하나의 언어
• 표준 허점 제한이 적용됩니다
• 모든 프로그램이 다릅니다. 자체 출력하는 하나의 프로그램은 자격이 없습니다. 서로 출력하는 2 개도 자격이 없습니다.
• 모든 프로그램이 비어 있지 않거나 길이가 1 바이트 이상입니다.
• stdin이 연결되어 있으므로 읽을 내용이 없습니다 /dev/null(가능한 경우이 규칙을 남용 할 수 있음 ). 출력은 표준 출력으로갑니다.
• 임의의 결과를 생성하는 기능을 사용하지 마십시오.

추가 :

• 가능한 경우 설명을 제공하십시오

점수는 가장 짧은 것의 길이입니다 (짧은 것에서 긴 프로그램을 생성 할 수 있습니까?). 모든 프로그램의 길이를 작성하고 가장 작은 숫자를 강조 표시하십시오. 후행 줄 바꿈은 포함되지 않습니다. 최저 점수가 이깁니다 .

파이썬 3 , 50 바이트

s='s=%r;print(s%%(s,%i*2%%7))';print(s%(s,1*2%7))

온라인으로 사용해보십시오!

마지막 표현에서 이동 1*2%7에 2*2%7에 4*2%7다시에 1*2%7.

RProgN 2 , 12 8 바이트

1
«\2*7%

설명

1   # Push the digit to the stack.

«\2*7%
«       # Define a function from here to the matching ». As there is no matching », define it from here to the end of the program, and continue running.
 \      # Flip the function under the constant number.
  2*    # Multiply by 2.
    7%  # Modulo 7.

RProgN이 기본적으로 출력하는 방식의 편리한 특성으로 인해 첫 번째 줄에서 1, 2, 4 사이에서 반복되는 숫자와 두 번째 줄에서 함수의 문자열 버전이 남습니다. @LeakyNun 의 Python Answer에서 영감을 얻었습니다

온라인으로 사용해보십시오!

CJam , 17 바이트

{sZZe\6Ye\"_~"}_~

{s6Ze\ZYe\"_~"}_~

{sZ6e\ZYe\"_~"}_~

온라인으로 사용해보십시오!

아마 최적은 아니지만 이것은 이전 도전에 대한 나의 접근 방식 의 수정 입니다 .

기본 아이디어는 동일하지만 두 가지 스왑을 수행하며 그 중 하나는 항상 작동하지 않습니다. 영향을받는 인덱스는 2, 3및 6:

1:     {sZZe\6Ye\"_~"}_~
ZZe\             does nothing
       {sZZe\6Ye\"_~"}_~
6Ye\     \   /
          \ /
           X
          / \
         /   \
2:     {s6Ze\ZYe\"_~"}_~
6Ze\      \  /
           \/    doesn't really do anything
           /\
          /  \
       {s6Ze\ZYe\"_~"}_~
ZYe\     \/
         /\
3:     {sZ6e\ZYe\"_~"}_~
Z6e\      \  /
           \/
           /\
          /  \
       {sZZe\6Ye\"_~"}_~
ZYe\     \/      doesn't really do anything 
         /\
1:     {sZZe\6Ye\"_~"}_~

CJam , 14 바이트

{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}{_]3/W="_~"}_~

온라인으로 사용해보십시오!

다른 프로그램의 길이는 각각 26 바이트와 38 바이트입니다.

설명

또 다른 접근법!

{       e# Again, the usual quine framework. In this case, there might
        e# be one or two additional copies of the block on the stack.
  _     e#   Duplicate the top copy of the block.
  ]     e#   Wrap all copies in an array.
  3/    e#   Split into chunks of 3. For the first two programs, this will
        e#   just wrap all of them in an array. For the third program, this
        e#   splits the fourth copy off from the first three.
  W=    e#   Select the last chunk. So `3/W=` does nothing for the first
        e#   two programs, but discards three copies once we get to four.
  "_~"  e#   Push the remainder of the program.
}_~

젤리 , 11 바이트

“Ḥ%7Øv;”Ṙv1

이것은 1 을 2 로 바꾸고 2 를 4 로 바꾸어 원래 프로그램을 생성하는 동일한 프로그램 을 생성했습니다.

온라인으로 사용해보십시오!

파이썬 3, 127, 127 및 127 바이트

a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(b%(b,a,c))

인쇄물

b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(c%(c,a,b))

인쇄물

c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';print(a%(a,b,c))

이것은 일반적인 Python quine을 기반으로 한 Interquine 질문에 대한 나의 대답을 기반으로합니다. 그리고 우리가 쿼드 인터 퀸 질문을받을 때 정확히 무엇을 해야하는지 알고 있습니다.)

CJam , 14 바이트

0{\)3%\"_~"}_~

1{\)3%\"_~"}_~

2{\)3%\"_~"}_~

온라인으로 사용해보십시오!

설명

0{      e# Again, the standard CJam quine framework, but this time we have a zero
        e# at the bottom of the stack.
  \     e#   Bring the 0 to the top.
  )     e#   Increment.
  3%    e#   Mod 3 to loop from 2 back to 0.
  \     e#   Put the result underneath the block again.
  "_~"  e#   Push the remainder of the source.
}_~

자바 스크립트 (ES6), 63 55 바이트

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

o1.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0) 
o2.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)
o3.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

<pre id="o1"></pre>
<pre id="o2"></pre>
<pre id="o3"></pre>

Function.prototype.toString(cheaty, 30 bytes)를 사용하는 대체 솔루션

(f=n=>`(f=${f})(${++n%3})`)(1)

람다 미적분 , 38 자, 44 바이트

모든 quines의 어머니를 기반으로 한 간단한 솔루션 : y-combinator :

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)

베타 축소를 사용하면 실제로 트리 인터 퀸이 있음을 알 수 있습니다.

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λy.y)(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
etc.

자바 8, 118 바이트

v->{int i=0;String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";return s.format(s,++i%3,34,s);}

int i=0;함수 / 출력 간의 차이 만 있습니다 0( 1또는 2).

설명:

온라인으로 사용해보십시오.

v->{                       // Method with empty unused parameter and String return-type
  int i=0;                 //  Integer, starting at 0, 1 or 2 depending on the version
                           //  (this is the only variation between the functions/outputs)
  String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";
                           //  String containing the unformatted source code
  return s.format(s,++i%3,s);}
                           //  Quine to get the source code, which we return as result
                           //  ++i%3 is used to cycle 0→1→2→0

추가 설명 :

quine- part :

• String s 형식화되지 않은 소스 코드를 포함합니다
• %s 이 문자열을 자체에 넣는 데 사용됩니다. s.format(...)
• %c, %2$c및 34(이중 따옴표를 포맷하는 데 사용됩니다 ")
• %%모듈로 부호를 형식화하는 데 사용됩니다 ( %)
• s.format(s,...,34,s) 다 합쳐

출력 / 기능의 차이 :

대부분의 다른 답변과 동일한 접근 방식 :

• int i중 하나에서 시작 0, 1또는2
• ++i%3이것은 다음에 변환 ( 0→1, 1→2, 2→0)

> <> , 15 바이트

1'~r2*7%nd3*>o<

온라인으로 사용해보십시오!

다른> <> quines와 동일한 일반 양식을 사용하지만 앞에 1, 2 및 4로 순환되는 추가 문자가 있습니다.