폴리 퀸은 quine과 polyglot입니다. ¹ 최소한 두 개의 다른 언어로 유효한 quine을 작성해야합니다. 이것은 코드 골프이므로 가장 짧은 대답 (바이트)이 이깁니다.

_{¹ 나는 그것을 만들었다. 또는 오히려 Geobits는 . 그러나 그는 첫 번째 사람도 아니었다 .}

Quines에 대한 규칙

만 사실 quines 허용됩니다. 즉, 당신은 STDOUT에 그대로 전체 소스 코드를 인쇄 할 필요 없이 :

• 직접 또는 간접적으로 소스 코드를 읽습니다.
• 단순히 먹이를주는 모든 표현을 평가하고 인쇄하는 REPL 환경에 의존합니다.
• 어떤 경우에는 소스를 인쇄하는 언어 기능에 의존합니다.
• 오류 메시지 또는 STDERR을 사용하여 quine의 일부 또는 전부를 쓰십시오. STDOUT이 유효한 quine이고 오류 메시지가 포함되지 않는 한 STDERR에 내용을 쓰거나 경고 / 치명적이지 않은 오류가 발생할 수 있습니다.

또한 코드 에는 문자열 리터럴이 포함 되어야 합니다.

폴리 글 로트 규칙

사용 된 두 언어는 분명히 달라야합니다. 특히:

• 같은 언어의 다른 버전이 아니어야합니다 (예 : Python 2와 Python 3).
• 같은 언어의 다른 방언이어서는 안됩니다 (예 : Pascal vs. Delphi).
• 한 언어는 다른 언어의 하위 집합이 아닐 수 있습니다 (예 : C와 C ++).

CJam / GolfScript, 34 바이트

{"__X.0#@@?LL
;~"N}__X.0#@@?LL
;~

바이트 카운트는 후행 줄 바꿈을 포함합니다. 프로그램이 없으면 퀴네가 아니기 때문입니다.

CJam과 GolfScript는 일부 측면에서 매우 유사하지만 많은 차이점이 있습니다. 이것을 "정직한"폴리 퀸으로 만들기 위해 가능한 한 그 차이 에 의존하기로 결정했습니다 . 블록 및 문자열 구문 (언어가 너무 많은 다른 언어와 공유 함)을 제외하고 코드의 어느 부분도 두 언어에서 정확히 동일하지 않습니다.

온라인 GolfScript 인터프리터에 버그가 있습니다. 이 프로그램은 공식 통역사와 만 작동합니다.

예제 실행

$ cat polyquine
{"__X.0#@@?LL
;~"N}__X.0#@@?LL
;~
$ md5sum polyquine <(cjam polyquine) <(golfscript polyquine)
e2f1f3cd68abbbceec58080513f98d9a  polyquine
e2f1f3cd68abbbceec58080513f98d9a  /dev/fd/63
e2f1f3cd68abbbceec58080513f98d9a  /dev/fd/62

작동 방식 (CJam)

" Push that block.                                                                        ";

{"__X.0#@@?LL
;~"N}

" Push two copies of the block, 1 (computed as 1**0) and rotate the block copies on top.  ";

__X.0#@@

" If 1 is truthy (oh, the uncertainty), execute the first copy; else, execute the second.
  Evaluating the block pushes the string it contains; N pushes a linefeed.                ";

?

" Push two empty arrays.                                                                  ";

LL

" Discard one empty array and dump the second.                                            ";

;~

" (implicit) Print all items on the stack.                                                ";

작동 방식 (GolfScript)

# Push that block.

{"__X.0#@@?LL
;~"N}

# Push a copy of the block; _ and X are noops, # initiates an inline comment.

__X.0#@@?LL

# Discard the 0 and execute the copy of the block.
# Evaluating the block pushes the string it contains; N is a noop.

;~

# (implicit) Print all items on the stack, followed by a linefeed.

CJam / GolfScript, 12 바이트

{"0$~"N}0$~

언어의 차이를 최대한 피하는 치어 리 솔루션.

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

• CJam
• GolfScript

작동 방식 (CJam)

 "0$~"       " Push that string.                                                          ";
      N      " Push a linefeed.                                                           ";
{      }0$~  " Push a copy of the block and execute it.                                   ";
             " (implicit) Print the stack.                                                ";

작동 방식 (GolfScript)

 "0$~"       # Push that string.
      N      # Undefined token (noop).
{      }0$~  # Push a copy of the block and execute it.
             # (implicit) Print the stack, followed by a linefeed.

C # / 자바, 746 바이트

Java의 문자를 동일한 유니 코드 시퀀스로 작성할 수있는 속성을 사용합니다. 우리가있는 경우 AC # 컴파일러 및 대한 지시를 B자바에 대한 명령, 우리는 다음 코드를 사용할 수 있습니다 :

//\u000A\u002F\u002A
A//\u002A\u002FB

C #을 사용하여 다음과 같은 방법으로 "인식"됩니다.

//\u000A\u002F\u002A
A//\u002A\u002FB

그리고 Java에 의한 다음과 같은 방법으로 :

//
/*
A//*/B

\u000A줄 바꿈으로 인해 \u002Fis /and \u002Ais *in Java입니다.

최종 폴리 글로 퀸은 다음과 같습니다.

//\u000A\u002F\u002A
using System;//\u002A\u002F
class Program{public static void//\u000A\u002F\u002A
Main//\u002A\u002Fmain
(String[]z){String s="//@#'^using System;//'#^class Program{public static void//@#'^Main//'#main^(String[]z){String s=!$!,t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&'!,s};for(int i=0;i<7;i++)t=t.//@#'^Replace//'#replace^(!!+(char)a[i],b[i]);//@#'^Console.Write//'#System.out.printf^(t);}}",t=s;int[]a=new int[]{33,94,38,64,35,39,36};String[]b=new String[]{"\"","\n","\\","\\u000A","\\u002F","\\u002A",s};for(int i=0;i<7;i++)t=t.//\u000A\u002F\u002A
Replace//\u002A\u002Freplace
(""+(char)a[i],b[i]);//\u000A\u002F\u002A
Console.Write//\u002A\u002FSystem.out.printf
(t);}}

그러나 언어의 세부 정보 때문에 크기가 너무 큽니다.

ideone.com 볼 수 있습니다 편집 : C #을 , 자바 .

Python 3 및 JavaScript, 134 바이트

내 (최종?) 시도는 다음과 같습니다.

a='eval(a.split(" ")[2%-4]),1//2# q=String.fromCharCode(39);console.log("a="+q+a+q+a.slice(-8)) print(a[-12:]%a) a=%r;eval(a)';eval(a)

특히 JavaScript로 작은 따옴표를 얻는 더 좋은 방법을 알고 있다면 아마 조금 더 골프를 칠 수 있습니다.

정리하면 프로그램은 다음과 같습니다.

a='a long string';eval(a)

이 eval()함수는 두 언어 모두에서 표현식을 평가합니다. 따라서 긴 문자열이 실행됩니다.

eval(a.split(" ")[2%-4]),1//2# ... the rest gets commented out

긴 문자열을 공백으로 나누고로 색인을 생성 한 하위 문자열을 평가합니다 2%-4. JavaScript는 모듈러스 연산자가 음수에 대해 다르게 동작하기 때문에 세 번째 하위 문자열 ( 2 % -4 == 2)과 마지막 두 번째 ( 2 % -4 == -2) Python 을 실행합니다 .

나머지 문자열은 두 언어 모두에서 무시됩니다. JavaScript는에서 멈추고 //, 파이썬은이를 정수 나누기로보고에서 멈 춥니 다 #.

따라서 JavaScript는 소스 코드를 콘솔에 인쇄합니다.

q=String.fromCharCode(39);console.log("a="+q+a+q+a.slice(-8))

그리고 여기 파이썬이 있습니다 :

print(a[-12:]%a)

둘 다 프로그램의 템플릿 인 문자열의 마지막 부분을 사용합니다.

a=%r;eval(a)

루비 / 펄 / PHP, 52

$b='$b=%c%s%c;printf$b,39,$b,39;';printf$b,39,$b,39;

Christopher Durr 의 Perl quine 에서 복사 한 그대로 .

이것은 규칙 남용입니다. Ruby와 Perl은 확실히 같은 언어가 아니며 Perl도 Ruby의 하위 집합이 아닙니다 (예 : 연결된 Perl quines의 대부분은 Ruby에서 작동하지 않습니다). 그러나 루비는 원하는 경우 Perl과 비슷하게 보이도록 설계되었으며, 골프를 할 때 많은 일이 발생합니다.

배쉬 / 골프 스크립트, 73

.~0 () 
{ 
    declare "-f" @* ".~0" " () 
"+@n.;
    echo '.~0;'
}
.~0;

처음 3 줄 각각에 후행 공백이 있습니다.

배쉬 / 골프 스크립트, 78

alias :a~a.='eval "alias :a~a."\
;set [61 39]+a[39]+n"":a;echo ":a~a."'
:a~a.

PHP / 펄-171

#<?PHP$s=1;$t="";
$a='%s<%cPHP$s=1;$t="";%c$a=%c%s%c;$t==$s?$t="#":$s;printf($a,$t,63,10,39,$a,39,10,63);%c#%c>';$t==$s?$t="#":$s;printf($a,$t,63,10,39,$a,39,10,63);
#?>

로 실행 :

$ php quine.pl
$ perl quine.pl

php코드가 실제로 실행 (단지 자체를 인쇄하지 않음).

배쉬 / 루비, 104 82

"tee`#";puts <<a*2+'a'#`" -<<'a';echo a
"tee`#";puts <<a*2+'a'#`" -<<'a';echo a
a

이전 버전 :

"alias" "puts=f()(tee -;echo a);f"
puts <<a *2+"a"
"alias" "puts=f()(tee -;echo a);f"
puts <<a *2+"a"
a

Bash / Ruby, 정의되지 않은 동작이없는 128

"alias" 'puts=f()(a=`cat`;echo "$a
$a
a");f'
puts <<'a' *2+"a"
"alias" 'puts=f()(a=`cat`;echo "$a
$a
a");f'
puts <<'a' *2+"a"
a

망상 / befunge-98, 28 바이트 [비경쟁]

<@,+1!',k- ';';Oc'43'q@$;!0"

망상을보십시오! 98을 사랑하십시오!

;s의 사이 에있는 것은 무시되고 망상을 위해 s !사이 ;의 세그먼트로 건너 뜁니다 . 따라서 망상은 다음과 같습니다.

<@,+1!',k- ';';Oc'43'q@$;!0"
<                             move left
                           "  capture string
                          0   push zero
                        ;!    skip `;` (end program)
                       $      drop zero
                     q@       reverse TOS
                 '43'         push 34 (")
                c             convert to char
               O              output all
              ;               end program

Befunge는 다음을 본다 :

<@,+1!',k- ';';Oc'43'q@$;!0"
<                            move left
                           " capture string
                         !0  push 1
              ;         ;    skip this
         - ';'               push 27
       ,k                    output top 27 chars
   +1!'                      push 34 (")
  ,                          output "
 @                           end program

루비 / 수학, 225 바이트

여기 내 자신의 매우 뛰어난 폴리 퀸 (예와 개념 증명으로 사용)이 있습니다.

s="s=%p;puts s%%s;#Print[StringReplace[s,{(f=FromCharacterCode)@{37,112}->ToString@InputForm@s,f@{37,37}->f@37}]]&@1";puts s%s;#Print[StringReplace[s,{(f=FromCharacterCode)@{37,112}->ToString@InputForm@s,f@{37,37}->f@37}]]&@1

첫 번째 부분은 이 Ruby quine을 기반 으로 하며 기본적으로 다음과 같습니다.

s="s=%p;puts s%%s;#MathematicaCode";puts s%s;#MathematicaCode

Mathematica에서 문자열 할당은 정확히 동일합니다. 는 puts s%s4 개 문자의 산물로 해석됩니다 : puts문자열 s, %(마지막 REPL 결과 나 Out[0]는 먼저 평가 표현 인 경우) 및 다른 s. 물론 그것은 완전히 의미가 없지만 Mathematica는 ;출력을 신경 쓰지 않고 억제하므로 자동으로 처리됩니다. 그런 다음 #Mathematica는 계속하면서 나머지 줄은 Ruby에 대한 주석으로 만듭니다.

Mathematica 코드의 가장 큰 부분은 문자열 리터럴을 사용하지 않고 Ruby의 형식 문자열 처리를 시뮬레이션하는 것입니다. FromCharacterCode@{37,112}이다 %p하고 FromCharacterCode@{37,112}있다 %%. 전자는 문자열 자체로 대체되고 InputForm, 인용 부호를 추가하면 후자는 single 로 대체됩니다 %. 결과는 Printed입니다. 마지막 캐치는 #앞면에서 처리하는 방법 입니다. 이것은 순수한 (익명) 함수의 첫 번째 인수에 대한 Mathematica의 상징입니다. 그래서 우리가하는 일은 argument로 함수를 추가 하고 즉시 호출 하여 순수한 함수를 만드는 것입니다 . a 앞에 함수 호출을 추가하면 결과에 "곱하기"&111Mathematica는 함수가 어떤 종류의 것을 반환하든 상관없이 다시 삼키는 것입니다.

> <> 및 CJam, 165 바이트

"~~~~~~~~~~~~~~~~~~~~~~~r00gol?!v93*0.Hi
'                               <       .1*5av!?log10oar~~~r
'"`{"`"\"_~e#.21 <.2+4*96;!?log10oa"}_~e#.21 <.2+4*96;!?log10oa

CJam에게 프로그램은 여러 줄 문자열 리터럴로 시작합니다. 이로 이스케이프 된 `후 표준 quine을 사용하여 quine 코드와 후행 주석을 인쇄합니다.

> <>에서 첫 번째는 첫 번째 "전체 행을 통과하는 문자열 리터럴을 시작하여 모든 문자를 스택으로 푸시합니다. 그런 다음 후행 공백 (입력이 채워 져서 생성됨)이 삭제 된 후 스택이 반전됩니다. 스택의 모든 문자 (예 : 전체 첫 번째 행)가 출력 된 다음 두 번째 행으로 이동합니다.

두 번째 행은 반대 방향이라는 점을 제외하고는 본질적으로 동일한 작업을 수행하므로 스택을 뒤집을 필요가 없습니다. (어쨌든 나는 후행 공백을 삭제해야하기 때문에 수행합니다.)

마지막으로 세 번째 줄로 넘어갑니다. 유일한 큰 차이점은 CJam 블록을 건너 뛰어야한다는 것입니다 .. 단일 인용 부호는 전체 줄을 다시 캡처하여 출력합니다.

C / PHP, 266 304 300 282 241 203 + 10 바이트

//<?php
function main($a){printf($a="%c//<?php%cfunction main(%ca){printf(%ca=%c%s%c,13,10,36,36,34,%ca,34,36,10,10,10);}%c#if 0%cmain();%c#endif",13,10,36,36,34,$a,34,36,10,10,10);}
#if 0
main();
#endif

C에서 컴파일하려면 GCC 컴파일러 플래그가 필요하기 때문에 +10 바이트 -Dfunction=.

작동 방식 (PHP) :

• PHP 인터프리터 <?php는 HTML 보다 먼저 모든 것을 인쇄합니다 . //HTML의 주석이 아니므로 간단히 인쇄됩니다.
• main변수가있는 함수로 선언됩니다 a.
• printf//표준 C / PHP quining 방법을 사용하여 캐리지 리턴 (이미 인쇄 된을 무시 ) 및 소스 코드를 인쇄 합니다.
• #if 0 PHP에서는 무시됩니다.
• main($a)빈 변수를 초기화합니다 a. (이전 error_reporting(0)에 호출로 인한 오류를 무시 하는 데 사용됨 main())
• #endif PHP에서도 무시됩니다.

작동 방식 (C) :

• //<?php 한 줄 주석이므로 무시됩니다.
• function키워드 인해 명령 줄 컴파일러 인수에 무시됩니다 -Dfunction=.
• GCC와 Clang은 변수가로 시작하거나 포함하는지 상관하지 않습니다 $. (이것은 하루를 구했습니다.)
• printf 표준 C / PHP quining 방법을 사용하여 캐리지 리턴 (이 경우에는 사용할 수 없음)과 소스 코드를 인쇄합니다.
• #if 0endifPHP가 호출 할 수 있도록 모든 것을 무시합니다 main.
• #endif "무시"블록을 종료합니다.

Wumpus / > <> / Befunge-98 28 바이트

"]#34[~#28&o@,k+deg0 #o#!g00

Wumpus에서 사용해보십시오! , > <>에 그것을보십시오! , 비 펀지-98에 그것을보십시오!

작동 방식 :

범퍼 스 코드 :

  " Start string literal
    Bounce off end of line and come back
  " End string literal
   ] Push top of stack to bottom
    #34 Push double quote
       [~ Get bottom of stack and swap it with the double quote
         #28 Push 28
            &o@ Print the top 28 items on stack and terminate program

> <> 코드 :

  " Start string literal
    Wrap when it reaches the end of the line
  " End string literal
   ]# Clear stack and reflect
  " Wrapping string literal again, but backwards
                     g00 Get the character from cell 0 (")
                 #o#! Skip into the printing loop
                      Exit with an error

Befunge-98 코드 :

  " Wrapping string literal
   ] Turn right
   ] Turn right again, going West
  " Wrapping string literal going West
                 !g00 Get double quote and invert it
              #o# Skip over the o instruction
           g0   Get double quote
        +de Push 27
     @,k    Print 27+1 items from the stack and terminate program.

05AB1E / 2sable, 14 바이트, 비경쟁

0"D34çý"D34çý

온라인으로 사용해보십시오! (05AB1E)
온라인으로 사용해보십시오! (2 가능)

2sable은 05AB1E에서 파생되었으며 비슷하지만 큰 차이가 있습니다.

후행 줄 바꿈.

C / TCL, 337 바이트

#define set char*f= 
#define F 
#define proc main(){ 
set F "#define set char*f= 
#define F 
#define proc main(){ 
set F %c%s%c; 
proc /* {} {} 
puts -nonewline %cformat %cF 34 %cF 34 91 36 36] 
set a {*/printf(f,34,f,34,91,36,36);} 
"; 
proc /* {} {} 
puts -nonewline [format $F 34 $F 34 91 36 36] 
set a {*/printf(f,34,f,34,91,36,36);} 

C / Vim 4.0, 1636 바이트

제어 문자를 포함합니다.

map () {}/*
map g ;data0df"f"cf"
f"cf"
f"D2kyyP;g6k2dd4x5jA"JxA","JxA","jyyPkJxA"jok;g2kdd4xkJx3jdd
map ;g O"vdldd0i# 0# 1# 2# 3# 4# 5# #0lx2lx2lx2lx2lx2lx2lx:s/##/#/g
o:s//"/gk0y2lj02lp"addk@ao:s//\\/gk0ly2lj02lp"addk@ao:s///gk04ly2lj02lp05l"vp"addk@ao:s///gk05ly2lj02lp05l"vp"vp"addk@ao:s//
/gk06ly2lj02lp05l"vp"vp"vp"addk@ao:s//
/gk02ly2lj02lp05l"vp"addk@a
unmap ()

map ;data o*/ char*g[]={"map () {}/*#2map g ;data0df#0f#0cf#0#5#3f#0cf#0#5#3f#0D2kyyP;g6k2dd4x5jA#0#3JxA#0,#0#3JxA#0,#0#3jyyPkJxA#0#3jo#3k;g2kdd4xkJx3jdd#2map ;g O#4#4#4#4#3#0vdldd0i## 0## 1## 2## 3## 4## 5## ###30lx2lx2lx2lx2lx2lx2lx:s/####/##/g#5o:s//#0/g#3k0y2lj02lp#0addk@ao:s//#1#1/g#3k0ly2lj02lp#0addk@ao:s//#4#4#3/g#3k04ly2lj02lp05l#0vp#0addk@ao:s///g#3k05ly2lj02lp05l#0vp#0vp#0addk@ao:s//#4#4#5/g#3k06ly2lj02lp05l#0vp#0vp#0vp#0addk@ao:s//#4#4#5/g#3k02ly2lj02lp05l#0vp#0addk@a#2unmap ()#2#2map ;data o*/ char*g[]={","#A#0#a#0,#0#b#0,#0#c#0#C#2","}; /*#3#2#2#0*/  print(char*s){char*t=s,c,d;while(c=*t++)if(c==35){c=*t++;if(c==35)putchar(c);else if(c==48)putchar(34);else if(c==49)putchar(92);else if(c==50)printf(#0#1n#0);else if(c==51)putchar(27);else if(c==52)putchar(22);else if(c==53)putchar(13);else if(c>64&&c<91)print(g[c-65]);else printf(g[c-97]);}else putchar(c);}  main(){print(g[1]);}"}; /*

"*/  print(char*s){char*t=s,c,d;while(c=*t++)if(c==35){c=*t++;if(c==35)putchar(c);else if(c==48)putchar(34);else if(c==49)putchar(92);else if(c==50)printf("\n");else if(c==51)putchar(27);else if(c==52)putchar(22);else if(c==53)putchar(13);else if(c>64&&c<91)print(g[c-65]);else printf(g[c-97]);}else putchar(c);}  main(){print(g[1]);}

Vim에는 다음 세트가 있어야합니다.

set noai
set wm=0
set nosi
set tw=0
set nogdefault

C / 리스프, 555 바이트

t(setq /*;*/){}main(){char q='\"',s='\\';char*a= 
"~%t(setq /*;*/){}main(){char q='~A';char*a= 
~S;char*b=/* 
)(setq a ~S) 
(setq */ ~S;printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);}~%";char*b=/* 
)(setq a "\\\"',s='\\\\") 
(setq */ " 
t(setq /*;*/){}main(){char q='%c%c',s='%c%c';char*a= 
%c%s%c;char*b=/* 
)(setq a %c%c%c%c%c',s='%c%c%c%c%c) 
(setq */ %c%s%c;printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);} 
";printf(b,s,q,s,s,q,a,q,q,s,s,s,q,s,s,s,s,q,q,b,q/* 
)(format t /* a /* a */);} 

의도적으로 첫 줄을 비 웁니다.

Perl / Javascript (SpiderMonkey), 106 바이트

$_='$q=+[]?h^O:unescape("%27");print("$_="+$q+$_+$q+";eval($_)"||(q($_),"=$q$_$q;",q(eval($_))))';eval($_)

온라인 Perl을 사용해보십시오!
온라인 JavaScript를 사용해보십시오!

설명

quine 데이터는 $_두 언어로 저장되고 evaled는 Perl의 표준 절차입니다. TIO에서 SpiderMonkey를 선택 했으므로 print기능이 있지만 + 20 바이트 동안 브라우저로 쉽게 포팅 할 수 있습니다 ( s 정의 eval("print=alert");의 시작 부분에 추가 $_).

Perl은 저장된 데이터를보고 평소 $_와 같이 데이터를 저장 eval합니다. 이후 +[]truthy 펄에, '저장된다 $q의 stringwise-XOR로 h하고 O. 마지막 트릭은 printJavaScript의 첫 번째 부분 인 +Perl에서 모든 항목을 숫자로 취급하고 합한을 호출하는 것입니다 . 0그런 다음 ||연산자를 사용하여 실제로 원하는 (q($_),"=$q$_$q;",q(eval($_)))것을 반환 합니다 "\$_=$q$_$q;eval(\$_)".

자바 스크립트에서 +[]반환 0, 우리는 전화, 그래서 unescape("%27")가게 '에서 $q(불행하게도 atob... SpirderMonkey에 doesm't의 존재). 에 대한 호출 에서 JavaScript의 연결 연산자 print이므로 +첫 번째 블록은 원하는 출력을 작성하고 두 번째 부분 ||은 무시됩니다.

트릭에 대한 Patrick Roberts의 의견 에 감사드립니다 unescape!

Perl / JavaScript (브라우저), 108 바이트

$_='eval("q=_=>_+``;printf=console.log");printf(q`$_=%s%s%s;eval($_)`,$q=+[]?h^O:atob("Jw"),$_,$q)';eval($_)

온라인 Perl을 사용해보십시오!

$_='eval("q=_=>_+``;printf=console.log");printf(q`$_=%s%s%s;eval($_)`,$q=+[]?h^O:atob("Jw"),$_,$q)';eval($_)

설명

quine 데이터를 $_두 언어로 저장 한 다음 evalPerl의 표준 절차와 거의 같습니다.

Perl은 저장된 데이터를보고 평소 $_와 같이 데이터를 저장 eval합니다. eval내에서 $_실행 및 구문 분석에 실패하지만 이후되고 eval, 에러하지 않습니다. printf다음 단일 인용 문자열로, 호출 q()로, `단지 사용하는 등의 delimter 같은 `명령을 초래하는 것은 다음의 첫 번째 사용, 쉘에서 실행되고 $q있기 때문에, +[]펄 truthy이다, '에 저장됩니다 $q의 stringwise-XOR로 h와 O.

자바 스크립트에서 eval내 블록 $_기능 설정은 q, 즉, returnA와 인수이야 String및 별칭 console.log을을 printf하기 때문에, console.log같은 형식의 문자열 printf펄한다. 때 printf호출 +[]반환 0, 그래서 우리는 atob디코딩 '하고 저장 하기 위해 호출 합니다 $q.

Perl 5 / Ruby / JavaScript (Node.js) / Bash / Python 2 / PHP , 1031 바이트

s=1//2;_=r'''<?#/.__id__;s=+0;#';read -d '' q<<'';s=\';Q='echo s=1//2\;_=r$s$s$s\<\?\#/.__id__\;s=+0\;#$s\;read -d $s$s q\<\<$s$s\;s=\\$s\;Q=$s$Q$s\;eval\ \$Q;echo $q';eval $Q
$_='eval("0"?0?"def strtr(s,f,t);s.tr(f,t) end;class String;def chr(n);self+n.chr end;end":"$u=strtr=(s,f,t)=>[...f].reduce((s,a,i)=>s.replace(RegExp(a,`g`),t[i]),s);printf=console.log;(S=String).prototype.chr=function(n){return this+S.fromCharCode(n)}":[]&&"sub strtr{eval q(q(X)=~y/X/X/r)=~s/X/shift/ger}");printf(strtr("%s<?#/.__id__;s=+0;#j;read -d jj q<<jj;s=zj;Q=jecho s=1//2z;_=rksksksz<z?z#/.__id__z;s=+0z;#ksz;read -d ksks qz<z<ksksz;s=zzksz;Q=kskQksz;evalz zkQ;echo kqj;eval kQwk_=j%sj;eval(k_);//;#jjj;f=jjjs=1//2;_=r%%s%%s%%s;f=%%s%%s%%s;q=_[18]*3;print f%%%%(q,_,q,q,f,q)jjj;q=_[18]*3;print f%%(q,_,q,q,f,q)%s","jkwz","".chr(39).chr(36).chr(10).chr(92).chr(92)),[]&&"s=1//2;_=r".chr(39).chr(39).chr(39),$_,$u?"":"".chr(10));';eval($_);//;#''';f='''s=1//2;_=r%s%s%s;f=%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)''';q=_[18]*3;print f%(q,_,q,q,f,q)

온라인으로 확인하십시오!

이 답변에 대한 업데이트를 기반으로 다른 순열을 인쇄하는 코드를 최적화하려고 시도했지만 결국 Bash를 추가하여 더 많은 바이트를 추가했습니다. 이것이 첫 번째 시도 (300 바이트 이상 절약)보다 더 최적화되어 있지만 여전히 더 골프를 칠 수 있다고 확신합니다.

대체 Perl 5 / Ruby / JavaScript (Node.js) / Bash / Python 2 / PHP , 1040 바이트

s=1//2;_=r'''<?#/.__id__;s=+0;#';read -d '' q<<'';s=\';Q='echo s=1//2\;_=r$s$s$s\<\?\#/.__id__\;s=+0\;#$s\;read -d $s$s q\<\<$s$s\;s=\\$s\;Q=$s$Q$s\;eval\ \$Q;echo $q';eval $Q
$_='$z=0?"$&".next+92 .chr+10 .chr: 0..a||eval("printf=console.log;unescape`$%27%5C%0Ak`");$q=$z[1]?$z[1]:h^O;printf("%s%s%s%s<?#/.__id__;s=+0;#%s;read -d %s%s q<<%s%s;s=%s%s;Q=%secho s=1//2%s;_=r%ss%ss%ss%s<%s?%s#/.__id__%s;s=+0%s;#%ss%s;read -d %ss%ss q%s<%s<%ss%ss%s;s=%s%s%ss%s;Q=%ss%sQ%ss%s;eval%s %s%sQ;echo %sq%s;eval %sQ%s%s_=%s%s%s;eval(%s_);//;#%s%s%s;f=%s%s%ss=1//2;_=r%%s%%s%%s;f=%%s%%s%%s;q=_[18]*3;print f%%%%(q,_,q,q,f,q)%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)%s",[]&&"s=1//2;_=r",$r=[]&&$q,$r,$r,$q,$q,$q,$q,$q,$b=$z[2]?$z[2]:chr(92),$q,$q,$b,$d=$z[0]?$z[0]:h^L,$d,$d,$b,$b,$b,$b,$b,$d,$b,$d,$d,$b,$b,$d,$d,$b,$b,$b,$d,$b,$d,$d,$d,$b,$b,$b,$d,$d,$q,$d,$n=$z[3]?$z[3]:chr(10),$d,$q,$_,$q,$d,$q,$q,$q,$q,$q,$q,$q,$q,$q,$z[4]?"":$n);';eval($_);//;#''';f='''s=1//2;_=r%s%s%s;f=%s%s%s;q=_[18]*3;print f%%(q,_,q,q,f,q)''';q=_[18]*3;print f%(q,_,q,q,f,q)

온라인으로 확인하십시오!

내 원래 접근 방식에 조금 더 가깝지만 인수에 대한 반복 printf은 여전히 ​​미쳤습니다. 위치 인수를 사용하면 Chrome에서만 작동하며 $sin %1$s이 보간 되기 때문에 PHP에서도 작업하기가 까다 롭지 만 두 바이트의 접근 방식을 사용하여 많은 바이트를 절약 할 수 있습니다 ...

C / dc, 152 바이트

z1d//[[z1d//]P91PP93P[dx]Pq 
;main(){char*a="z1d//[[z1d//]P91PP93P[dx]Pq%c;main(){char*a=%c%s%c;printf(a,10,34,a,34);}//]dx";printf(a,10,34,a,34);}//]dx

댓글 활용하기

Perl 5 / Ruby / PHP / JavaScript (브라우저), 153 바이트

$_='$z=0?"$&".next: 0..a||eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);",$d=$z[0]?$z[0]:h^L,$q=$z[1]?$z[1]:h^O,$_,$q,$d);';eval($_);

온라인 Perl을 사용해보십시오!
루비 온라인을 사용해보십시오!
온라인으로 PHP를 사용해보십시오!

$_='$z=0?"$&".next: 0..a||eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);",$d=$z[0]?$z[0]:h^L,$q=$z[1]?$z[1]:h^O,$_,$q,$d);';eval($_);