이 의견에서 영감을 얻은 ...

이 도전 과제를 게시하기 전에 사양을 확정하는 데 도움을 주신 Step Hen , Wheat-Wizard 및 Dennis 사용자에게 감사 합니다!

이것은 강도의 실입니다! 경찰의 실은 여기로

이 과제 에서는 언어가 더 이상 프로그래밍 언어라는 기준을 충족시키지 못하도록 코드를 실행해야합니다. 그 도전에서, 그것은 언어가 더 이상 할 수 없도록 만드는 것을 의미합니다 ...

• 숫자 입력 및 출력

• 두 숫자를 더해라

• 특정 숫자가 소수인지 테스트합니다.

이것은 두 가지 다른 목표를 가진 두 가지 도전 이있는 경찰과 강도 도전입니다 : 경찰 은 언어를 거의 사용할 수 없게 만드는 코드를 작성하려고 시도 하며 강도 는 경찰을 허용하는 숨겨진 해결 방법을 찾습니다. 그들의 언어를 회복하기 위해.

경찰은 두 가지 코드 스 니펫을 작성합니다.

1. 입력 / 출력 및 수치 연산을위한 내장 함수를 제거하여 언어를 거의 사용할 수없는 언어. 이 코드는 충돌하거나 종료 할 수 없습니다 . 이 스 니펫 끝에 코드를 추가 할 수 있어야하며 해당 코드 가 평가 됩니다. 과

2. 두 개의 숫자를 입력으로 사용하여 코드를 더한 다음 합계를 출력하는 코드 조각입니다. 이 스 니펫은 첫 번째 스 니펫을 실행 한 후에도 여전히 올바르게 작동해야합니다. 두 스 니펫이 결합되면 두 개의 숫자를 추가하는 전체 프로그램을 구성하거나 두 개의 숫자를 추가하는 함수를 정의해야합니다. 이 스 니펫은 모호한 동작에 의존하고 찾기 어려울 것입니다.

경찰은 또한 표준 입 / 출력 방법을 선택할 것 입니다. 그러나 사용중인 형식 (입력 및 출력)을 정확하게 나타내야합니다. 답을 해독하려면 동일한 입력 / 출력 형식을 따라야합니다. 그렇지 않으면 균열이 계산되지 않습니다.

경찰의 답변은 항상 공개합니다

• 첫 번째 스 니펫 (두 번째는 아님).

• 언어 (마이너 버전 포함, 대부분의 제출물은 이상한 대소 문자를 사용하므로)

• 함수인지 전체 프로그램인지를 포함한 IO 형식. 강도 는 유효한 균열이되도록 동일한 형식을 사용해야합니다.

• 그들의 대답이 작동하는 데 필요한 이상한 경우. 예를 들어, Linux에서만 실행 되거나 인터넷 연결이 필요합니다 .

강도는 경찰의 제출물 중 하나를보고 해킹을 시도해야합니다. 스 니펫 2로 작동 할 수 있는 유효한 스 니펫을 작성 하여 언어를 사용할 수 있습니다 (언어를 거의 사용할 수 없게 된 후 두 숫자를 더함). 경찰이 처음 작성한 것과 동일한 스니 펫일 필요 는 없습니다 . 답변이 깨지면 코드를이 스레드에 답변으로 게시하고 경찰 답변에 대한 주석으로 답변 링크를 게시하십시오. 그런 다음 해당 게시물이 수정되었음을 표시하도록 편집됩니다.

다음은 예입니다. 첫 번째 스 니펫의 경우 다음 Python 3 프로그램을 경찰 답변으로 볼 수 있습니다.

파이썬 3

print=None

STDIN에서 입력을 받아 STDOUT으로 출력

유효한 두 번째 스 니펫은

import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

이것은 두 숫자를 입력으로 취하고 두 스 니펫을 함께 결합하더라도 합계를 출력하기 때문에 유효합니다.

print=None
import sys
a,b=int(input()),int(input())
sys.stdout.write(a+b)

이것은 그들의 대답에 유효한 균열입니다.

경찰의 답변이 일주일 내내 크랙되지 않은 경우, 두 번째 스 니펫에서 편집하여 자신의 답변이 안전하다고 표시 할 수 있습니다 . 안전하도록 편집 한 후에는 더 이상 크래킹을 시도하지 않을 수 있습니다. 그들이 안전하다고 편집하지 않으면, 그들이 할 때까지 계속 크래킹을 시도 할 수 있습니다.

강도 스레드의 승자는 가장 큰 답을 얻은 사용자이며, 타이 브레이커는 N 개의 균열에 도달 한 시간 입니다. (따라서 두 명의 다른 사용자가 각각 5 개의 균열을 가지고 있다면, 5 번째 균열을 먼저 게시 한 사용자가 승자가됩니다.) 충분한 시간이 지난 후, 나는 가장 많은 표를 얻은 승자의 대답을 받아들입니다.

즐기세요!

규칙 설명

• 첫 번째 스 니펫은 입력하지 않고 올바르게 실행해야합니다 . 원하는대로 출력 할 수 있으며이 출력은 무시됩니다. 스 니펫이 완료된 후에는 두 번째 스 니펫이 올바르게 실행됩니다.

• 답변이 유효 하려면 두 번째 스 니펫 이 실제로 실행 되어야합니다. 이것은 다음과 같은 대답을 의미합니다

  import sys
  sys.exit()
  

  언어를 위반하지 않기 때문에 유효하지 않습니다. 단순히 종료됩니다.

• 안전을 유지 한 후 점수는 두 스 니펫 의 바이트 수 입니다 .

• 이것은 다시가는 일에 당신의 대답에 필요한 이상한 가장자리 사례를 보여주세요 ... 당신의 제출은 충분한 정보를 포함해야합니다 전에 존재가 재현 될 밝혀 후에 공개된다. 이것은 귀하의 답변이 안전 해지면 다음에서 편집하는 경우를 의미합니다. 여기 내 답변이 있습니다. 아, BTW 이것은 솔라리스에서 실행할 때만 작동합니다. 귀하의 답변이 유효하지 않으며 삭제되며 당첨 될 자격이없는 것으로 간주됩니다.

• 합계를 출력 한 후 두 번째 스 니펫이 중단 될 수 있습니다. 출력이 여전히 올바른 한 (예를 들어, STDERR로 출력하도록 선택한 후 많은 충돌 정보를 얻는 경우 이는 유효하지 않습니다)

리더 보드

다음은 점수와 이름 (알파벳) 순으로 하나 이상의 균열이있는 모든 사용자의 목록입니다. 균열을 제출하면 그에 따라 점수를 업데이트하십시오.

#User                       #Score
Ilmari Karonen              8

Dennis                      5

Olivier Grégoire            4

Sisyphus                    3
Veedrac                     3

Arnold Palmer               2
Bruce Forte                 2
DJMcMayhem                  2
Dom Hastings                2
ppperry                     2

1bluston                    1
2012rcampion                1
Ben                         1
BlackCap                    1
Christian Sievers           1
Cody Gray                   1
HyperNeutrino               1
Joshua                      1
Kaz                         1
Mark                        1
Mayube                      1
Xnor                        1
zbw                         1

Olivier Grégoire의 Java 8

class A {
  public A() {
    String[] args = System.lineSeparator().split(",");
    System.out.print(Integer.parseInt(args[0]) + Integer.parseInt(args[1]));
  }
}

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

올리비에가 있기 때문에 명시 적으로 허용 VM 인수를 사용하여 설정 속성을 통해 입력을 전달, 나는 입력이 VM 인수에 제공되도록 지정할 수 있습니다 -Dline.separator=X,Y, X그리고 Y추가 할 수가 있습니다. 즉, 숫자 17과 25를 추가하려면 프로그램을 다음과 같이 호출해야합니다.

java -Dline.separator=17,25 Main

커맨드 라인에서 Java 프로그램을 실행할 수있는 것보다 모든 시스템에서 작동해야한다고 생각합니다. 명령 줄이없는 시스템에서도 시스템 속성을 설정하는 다른 동등한 메커니즘을 사용하여 입력을 VM에 전달할 수 있습니다.

추신. 이전의 크래킹 시도는 다음과 같습니다. JVM 특정 기능을 사용하여 유효하지 않은 것으로 간주됩니다.

class SecurityManager extends sun.awt.AWTSecurityManager {
  static {
    String[] args = System.getProperty("sun.java.command").split(" ");
    int a = Integer.parseInt(args[args.length-2]);
    int b = Integer.parseInt(args[args.length-1]);
    System.out.println(a+b);
  }
}

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

이것은 이전 보다 훨씬 덜 장황한 것으로 판명되었습니다 . 어려운 부분은 SecurityManager" java."로 시작하는 네임 스페이스에없는 서브 클래스를 찾는 것이 었습니다 . 이것이 여전히 의도 된 해결책은 아니지만 작동합니다. *

^{*) TIO에서는 최소한; sun.awt.AWTSecurityManager클래스와 sun.java.command속성을 공식적으로 문서화하지 않는 것, 모두의 JVM에서 사용하지 못할 수 있습니다.}

Sisyphus의 C (GCC / Linux)

이 코드 조각은 제공된 함수 close를 닫고 fd를 닫는 대신 원하는 코드를 실행하도록 재정의하는 새로운 기능 (클래식 코드 삽입)을 시작합니다 .

}
int close(int x) {
  int a, b;
  scanf("%d %d", &a, &b);
  printf("%d\n", a + b);

  exit(0);

파이썬, 밀 마법사의 솔루션 여기

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
f=lambda\
:[]                                                      # my code starts here
sys.setrecursionlimit(1000)
print(int(input())+int(input()))

내 말은, 당신은 재귀 제한을 다시 설정할 수 있으며 나쁜 일은 발생하지 않습니다 ...

TIO에서 작동

노트

이것은 처음으로 CnR 제출이므로, 규칙을 어기면 알려 주시면 삭제하겠습니다.

벤 하스켈

import Prelude(getLine,print)
a=a
[]++s=s
(a:as)++s=a:(as++s)
r""=""
r(c:s)=(r s)++[c]
t(_:r)=r
ts l=l:ts(t l)
x[_](v:_)=v
x(_:r)(_:s)=x r s
d(a:_:_:_:_:_:_:_:_:_:r)=a:d r
(a:_)!!""=a
l!!(n:m)=d(x['0'..n](ts l))!!m
a+b=[[0..]!!a..]!!b
a-b=let n=[0..]!!a;m=[0..]!!b in
    case [n..m] of
      [] ->   x[m..n][0..]
      l  -> -(x l    [0..])
add('-':x)('-':y)= -(r x+r y)
add('-':x)y=r y-r x
add x('-':y)=r x-r y
add x y=x+y
main=do a<-getLine;b<-getLine;print(add a b)

나는 아직도 문자 숫자와 문자를 (내가 사용이 0, '0'그리고 '-'), 그리고 [a..]하고 [a..b]있는 매우 유용합니다. 그리고 나는 단항식 -이 있지만 없이는 할 수있다.

나는 다시 ++구현하는 r( reverse)와 정의 t하고 ts있는은 tail과 tails. x a b의 nth 요소를 리턴합니다 b. 여기서 n길이는 a1 을 뺀 길이입니다 . x일반적으로로 정의 될 수 있습니다 snd.last.zip. 함수d 는 목록을 가져와 10의 배수 인 해당 위치의 요소가 포함 된 목록을 반환합니다. l!!s수익 n의 일 요소 l, s의 반전 캐릭터 라인 표현입니다 n. 차이 +와 마찬가지로 역 문자열로 주어진 두 자연수의 합계를 정수로 반환합니다 -. add문자열로 주어진 두 음의 정수의 합을 정수로 반환합니다.

이것이 Ben이 생각한 것과 다소 비슷한 지 궁금합니다.

Conor O'Brien의 C (gcc)

void post_main() __attribute__ ((destructor));

void post_main()
{
    int a, b;
    char sum[11];
    void *stdin = fdopen(0, "r");

    fscanf(stdin, "%u %u", &a, &b);
    sprintf(sum, "%u", a + b);
    write(1, sum, strlen(sum));
}

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

밀 마법사에 의한 파이썬 2 (4 번째 반복)

import sys
if set("".join(open(__file__).read().split('\n')[4:]))-set(' &)(,.:[]a`cdfijmonrt~'):sys.setrecursionlimit(1)
for m in sys.modules:sys.modules[m]=None
del sys;f=lambda\
c,d:(`int([]in[])`[:[]in[]]).join([((c)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),c)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),((d)and`dict([((int([]in[])),(int([]in[])))])`[(int([]in[[]])):][(int([]in[[]]))].join([`dict([((int([]in[])),(int([]in[])))])`[(int([]in[]))],`dict([((int([]in[])),d)])`[(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):][(int([]in[[]])):]])or`int([]in[])`[:[]in[]]).format((int([]in[]))),`(int([]in[]))`]).rfind(`(int([]in[]))`)

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

악용 없음, 문자 만 사용하여 추가하는 기능 ' &)(,.:[]a`cdfijmonrt~'의도 한대로 (실제로는 '(),.:[]`acdfijmnort') .

나는 그것을 짧게 만들려고하지 않았다. 방금 0과 같은 중간 값과 빈 문자열에 대한 하위 표현식을 작성하고 문자열로 대체했습니다.

def f(c,d):
	FALSE = []in[]
	TRUE = []in[[]]
	ZERO = int([]in[])
	ONE = int(TRUE)
	EMPTY = `int([]in[])`[:[]in[]]
	ZERO_STR = `ZERO`
	ONE_STR = `ONE`

	ZERO_DICT = dict([(ZERO,ZERO)])
	ZERO_DICT_STR = `ZERO_DICT`

	OPEN_BRACE = ZERO_DICT_STR[ZERO]
	COLON = ZERO_DICT_STR[ONE:][ONE]
	CLOSE_BRACE = ZERO_DICT_STR[ONE:][ONE:][ONE:][ONE:][ONE]

	C_STR = `c`
	D_STR = `d`

	FORMAT_STR_C = ''.join([OPEN_BRACE, ZERO_STR, COLON, C_STR, CLOSE_BRACE])
	FORMAT_STR_D = ''.join([OPEN_BRACE, ZERO_STR, COLON, D_STR, CLOSE_BRACE])

	LENGTH_C_STR = c and FORMAT_STR_C.format(ONE_STR) or EMPTY
	LENGTH_D_STR = d and FORMAT_STR_D.format(ONE_STR) or EMPTY

	TOTAL_STR = EMPTY.join([LENGTH_C_STR, LENGTH_D_STR, ZERO_STR])
	RESULT = TOTAL_STR.find(ZERO_STR)

	return RESULT

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

핵심 아이디어는 문자열 형식 '{0:5}'.format('1')이 숫자 0을 같은 길이로 5채우는 것 '1 '입니다. 를 사용하여 이러한 두 문자열을 연결 ''.join하면 길이의 합이 입력 숫자의 합입니다. 그런 다음 우리는0 를 끝까지.find() 하고 최종 위치, 즉 합계를 호출 합니다.

'{0:5}'형식화 할 문자열 은로 {:}작성된 사전의 문자열 reprs 에서 문자를 추출하여 생성됩니다 dict. 각 연속 소환의 문자열 repr은 5가있는 곳에 배치됩니다. 나는 같은 dict을 사용하고 싶었다.{0:5} 그 자체 repr에는 그것을 엉망으로 만드는 공간이 포함되어 있습니다.

문자열 sub의 최소 길이는 1이므로 0의 입력은 프로세스를 엉망으로 and/or만듭니다.이 경우에는 빈 문자열을 제공해야합니다.

Laikoni의 Haskell

main=main--
 & ((+) <$> readLn <*> readLn >>= print)
i&o=o

Joshua의 x86 16 비트 리얼 모드 어셈블리

    int  0x3                  ; <---  this is the "robber" portion

    ; -- begin code to print numbers in real-mode asm using ROM BIOS video interrupts --
    add  dx, cx               ; add input values together
    mov  ax, dx               ; move result into AX
    push WORD 0xB800
    pop  ds                   ; DS == starting address of text-mode video buffer
    xor  cx, cx               ; digit counter
    xor  di, di               ; position counter
    mov  bx, 0xA              ; divisor

    test ax, ax               ; is number negative?
    jns  .GetDigits
    neg  ax                   ; convert negative number to positive
    mov  WORD ds:[di], 0x4F2D ; output leading negative sign, in white-on-red
    add  di, 2                ; increment position counter

.GetDigits:
    xor  dx, dx
    div  bx                   ; divide DX:AX by 10 (AX == quotient, DX == remainder)
    push dx                   ; push digit onto stack
    inc  cx                   ; increment digit counter
    test ax, ax
    jnz  .GetDigits           ; keep looping until we've got 'em all

.PrintDigits:
    pop  dx                   ; get digit off of stack
    dec  cx                   ; decrement digit counter
    mov  dh, 0x4F             ; high byte: color attribute (white-on-red)
    add  dl, 0x30             ; low  byte: convert to ASCII
    mov  WORD ds:[di], dx     ; output digit
    add  di, 2                ; increment position counter
    test cx, cx
    jnz  .PrintDigits         ; keep looping until we've printed 'em all

    cli
    hlt

설명:

Joshua의 코드에서 소개 된 "손상"은 CPU를 단일 단계 모드로 만드는 트랩 플래그 (TF)의 설정입니다. 이것은 CPU가 type-1 인터럽트로 중지 (트랩)하기 전에 한 번에 하나의 명령 만 실행됨을 의미합니다. 이것이 디버거가 단일 스테핑 코드를 구현할 수있게 해주는 것인데, 매우 편리하지만 디버거 컨텍스트 외부에서 코드를 실행하려면 실제 PITA입니다!

트랩 플래그를 설정하는 코드는 다음과 같습니다.

pushf               ; push the FLAGS register onto the top of the stack
mov bp, sp          ; load the pointer to the top of the stack into BP
or word [bp], 256   ; bitwise-OR the WORD at the top of the stack (the copy of FLAGS)
                    ;  with 0x100, which turns on bit 8 (TF)
popf                ; pop the modified flags back off the stack into FLAGS

트랩 플래그를 구현한다는 것은 CPU 트랩 이전에 정확히 하나의 명령을 실행할 수있는 기회를 의미합니다. POPF . 따라서 우리는 이것을 하나의 카운트로 만들어야합니다.

트릭은 INT 3인터럽트 번호 3을 호출 하는 명령입니다. 이것이 코드를 "깨뜨리는"이유는 두 가지입니다.

1. 트랩 플래그는 인터럽트 핸들러에서 지워집니다. 이것은 인텔 디자인의 일부일 뿐이지 만 기본적으로 위생적인 ​​이유로 인해 수행 된 것 같습니다. 트랩 플래그의 구현이 유형 1 인터럽트 TF가 그렇다면, 각 명령의 실행 후 호출 있다는 것을 기억 되지 , 클리어 INT 1것 자체가 인터럽트를-는 트리거 모든 방법을 아래로 인터럽트 될 것이다. 또한 명확한 TF를 인터럽트하면 라이브러리 함수 호출을 자동으로 처리하는 IDE와 마찬가지로 코드 디버깅이 쉬워집니다.

2. 인터럽트가 작동하는 방식은 기본적으로 원거리와 동일합니다 CALL. 주소가 전역 인터럽트 벡터 테이블의 해당 위치에 저장된 인터럽트 핸들러를 호출합니다. 이 테이블은 address 0x0000:0000에서 시작 하여 4 바이트 segment:offset형식으로 저장 되므로 주소 계산은 4에 인터럽트 벡터 / 숫자를 곱하는 것만 큼 간단합니다. 이 경우 인터럽트 3을 호출하므로 4x3 = 12가됩니다.

   … 여호수아가 우리를 위해 이것을 신중하게 설정했음을 알 수 있습니다. 트랩 플래그를 활성화하기 전에 다음 코드를 갖습니다.

   mov  di, 12
   mov  [di], si
   mov  [di + 2], bp
   

   한 세트 0x0000:000C(인터럽트 핸들러 INT 3로) BP:SI. 즉 INT 3, 호출 될 때마다 FLAGS 레지스터를 스택으로 푸시 한 다음 리턴 주소를 보낸 다음 분기로 분기 BP:SI하여 트랩 플래그가 해제 된 컨텍스트에서 코드를 다시 실행할 수 있습니다.

모두 내리막 길 INT 3입니다. 두 숫자를 더하고 결과를 인쇄하기 만하면됩니다. 이것은 다른 언어 에서처럼 어셈블리 언어에서 간단하지 않기 때문에 대부분의 코드가 사용됩니다.

Joshua는 강도가 원하는 I / O 메커니즘을 지정할 수 있도록 허용하므로 값이 DX및 CX레지스터에 전달된다고 가정하는 간단한 접근 방식을 취하고 있습니다. 이것들은 그의 "프롤로그 (prologue)"코드에 의해 어디에서나 혼잡 해지지 않기 때문에 합리적입니다.

그런 다음 ASCII 바이트를 비디오 메모리에 직접 저장하여 출력합니다. 비디오 버퍼는 0xB800:0000텍스트 모드 CGA, EGA 및 / 또는 VGA에서 시작하므로 인쇄를 시작합니다. 형식은 다음과 같습니다. 하위 바이트의 문자 및 상위 바이트의 색상 속성입니다. 이는 각 문자가 2 바이트 오프셋에 있음을 의미합니다. 우리는 숫자 (base-10)의 각 숫자를 반복하여 ASCII로 변환하고 한 번에 하나씩 화면에 인쇄합니다. 예, 이것은 많은 코드입니다. 어셈블리 언어에 도움이되는 라이브러리 함수는 없습니다. 이것은 거의 확실하게 최적화 될 수 있지만 작업에 지쳤습니다 ...

출력이 표시되면 코드가 충돌하거나 무엇이든 할 수 있으므로 인터럽트를 지우고 CPU를 중지합니다.

TwiNight의 Python 2

print input()+input() #

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

파이썬 3 , ppperry 의 두 번째 도전

와우, 재미 있었다! 나는 이것을 해결하는 것을 즐겼다.

편집 : 좋아, 나는 고쳤다. 클래스가 컴퓨터와 TIO의 서브 클래스 목록에서 다른 색인에있는 것처럼 보이므로 둘 다 작동하게하고 TIO를 추가했습니다.

import sys
for mod in sys.modules.values():mod.__dict__.clear()
1+1

# My code begins here
str = "Hello!".__class__
int = (37).__class__
object = str.__base__

def find_subclass(superclass, name):
	for cls in superclass.__subclasses__():
		if cls.__name__ == name:
			return cls

_io_IOBase      = find_subclass(object, '_IOBase')        # <class '_io._IOBase'>
_io_RawIOBase   = find_subclass(_io_IOBase, '_RawIOBase') # <class '_io._RawIOBase'>
_ioFileIO       = find_subclass(_io_RawIOBase, 'FileIO')  # <class '_io.FileIO'>
stdout = _ioFileIO('stdout', mode='w', opener=lambda name,flags: 1) # FD for stdout is 1
stdin  = _ioFileIO('stdin',  mode='r', opener=lambda name,flags: 0) # FD for stdin is 0
nums = str(stdin.read(), encoding='utf-8').split()
stdout.write(str(int(nums[0]) + int(nums[1])).encode('utf-8') + b'\n')
stdout.flush()

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

하스켈 by zbw

{-#OPTIONS_GHC -fth -w#-}
module M where

import Language.Haskell.TH.Syntax
import System.IO.Unsafe

a = $( runIO $ TupE[] <$
              do x <- readLn :: IO Integer
                 y <- readLn
                 print $ x + y )

런타임에 코드를 실행할 수 없습니까? 컴파일 타임에 실행하십시오!

이것은 많은 재미였습니다. 나는이 도전 전에 템플릿 haskell을 몰랐습니다.

하이퍼 뉴트리노의 젤리

+

매우 간단합니다. 줄 바꿈은 첫 번째 링크가 호출되지 않도록합니다.

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

밀 마법사에 의한 파이썬 2

import sys
c="".join(open(__file__).read().split('\n')[4:])
if set(c)-set(' &)(,.:[]a`cdfijmonrt~')or"import"in c:sys.setrecursionlimit(1)
sys.modules['sys'],sys.modules['os']=None,None;del sys;f=lambda\
a,b:a+b
__import__('sysconfig').__dict__['os'].__dict__['sys'].setrecursionlimit(1000)
print(f(1,2))

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

LordFarquaad의 Java

소스 레벨에서 객체에 대한 액세스를 차단하는 것은 정말 똑똑했고 테스트 할 때 성가시다!

public class java {
  public static void main(String[] s) {
    //there is no executable code in snippet one.
    //your code here.
    try {
      ClassLoader cl = ClassLoader.getSystemClassLoader();
      Object in = cl.loadClass("java.lang.System").getDeclaredField("in").get(null);
      Object out = cl.loadClass("java.lang.System").getDeclaredField("out").get(null);
      Object scanner = cl.loadClass("java.util.Scanner").getConstructor(cl.loadClass("java.io.InputStream")).newInstance(in);
      int i = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner);
      int j = (Integer)cl.loadClass("java.util.Scanner").getMethod("nextInt").invoke(scanner);
      cl.loadClass("java.io.PrintStream").getMethod("println", Object.class).invoke(out, i+j);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  class Class {}
  class Method {}
  class System {}
  class FileDescriptor {}
  class Logger {}
  class Runtime {}
  class Scanner {}
}

히스 토크 라트의 루비

BEGIN{exit(gets.to_i + gets.to_i)}

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

일 마리 카로 넨 (Ilmari Karonen)

모호한 명사에 대한 맹렬한 학대 ... 내 코드는로 시작합니다 factory is a room. 이전 줄은 경찰의 코드입니다. add 1 and 1예를 들어 2를 얻으려면 입력하십시오 .

For reading a command: Rule fails

factory is a room.
The adder one is a thing. The adder two is a thing. The adder one is in factory. The adder two is in factory.
Before reading a command: change the text of the player's command to "examine adder"

For printing a parser error: 
    if the player's command includes "add [number] ":
        let N be the number understood;
        if the player's command includes "and [number]":
            say the number understood plus N;

자바, 로마 그래프

public class Main {
    public static void main(String... args){
        System.setOut(null);
        System.setErr(null);

        System.setOut(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.out)));
        System.setErr(new java.io.PrintStream(new java.io.FileOutputStream(java.io.FileDescriptor.err)));
        System.out.println("This");
        System.err.println("works");
    }
}

초기 값으로 설정 stdout하고 stderr다시 설정 합니다.

수입품 대신 정규화 된 이름을 사용할 수 있다고 생각합니다. 잘못되면 나를 수정하십시오 (이것은 내 첫 번째 게시물입니다.) 이것은 아마도 리플렉션을 사용하여 수행 될 수 있습니다.

편집 : 여기 만 사용하는 반사 솔루션이 있습니다 java.lang.reflect.*.

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String... args) {
        System.setOut(null);
        System.setErr(null);

        try {
            Class<?> psClass = Class.forName("java.io.PrintStream");
            Class<?> fsClass = Class.forName("java.io.FileOutputStream");
            Class<?> osClass = Class.forName("java.io.OutputStream");
            Class<?> fdClass = Class.forName("java.io.FileDescriptor");
            Class<System> sClass = System.class;
            Constructor psCtor = psClass.getConstructor(osClass);
            Constructor fsCtor = fsClass.getConstructor(fdClass);

            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);

            Object sout = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("out").get(null)));
            Field outField = sClass.getDeclaredField("out");
            modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
            outField.set(null, sout);

            Object serr = psCtor.newInstance(fsCtor.newInstance(fdClass.getDeclaredField("err").get(null)));
            Field errField = sClass.getDeclaredField("err");
            modifiersField.setInt(errField, outField.getModifiers() & ~Modifier.FINAL);
            errField.set(null, serr);

            System.out.println("This");
            System.err.println("works");
        } catch (Exception ignore) {
        }
    }
}

Daniel Franklin의 JavaScript

location="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+"

약간 가벼운 솔루션으로 간주 될 수 있지만 Chromium 59 / Linux에서는 다음과 같은 경고 메시지가 표시 되더라도 작동합니다.

향후 버전에서는 데이터로 시작되는 컨텐츠 시작 최상위 프레임 탐색 : URL을 차단합니다. 자세한 내용은 https://goo.gl/BaZAea를 참조 하십시오 .

추신. 이번에는 경고없이 또 다른 균열이 있습니다.

Node.prototype.removeChild=function(){}
document.body.innerHTML='<iframe src="data:text/html;base64,PHNjcmlwdD5jb25zb2xlLmxvZygxKnByb21wdCgpKzEqcHJvbXB0KCkpPC9zY3JpcHQ+"/>'

Olivier Grégoire의 Java 8

엄청나게 장황한 도전을 위해 엄청나게 장황한 균열. :) 이름을 지정할 수없는 클래스를 사용하여 간접적으로 작업해야하는 고통은 분명합니다.

    try {
      Class loader = Class.class.getMethod("getClassLoader").getReturnType();
      Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null);
      Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer");
      Class system  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System");
      Class filein  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.io.FileInputStream");

      InputStream cmd = (InputStream) filein.getConstructor(String.class).newInstance("/proc/self/cmdline");
      byte[] buf = new byte[65536];
      int len = cmd.read(buf);
      String[] args = new String(buf, 0, len).split("\0");
      
      int a = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-2]);
      int b = (int) integer.getMethod("parseInt", String.class).invoke(null, args[args.length-1]);

      Object out = system.getField("out").get(null);
      out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b));
    } catch (Exception e) {
      throw new Error(e);
    }
  }
}
class ClassLoader {
  public static ClassLoader getSystemClassLoader() { return new ClassLoader(); }
  public ClassLoader loadClass(String s) { return this; }
  public ClassLoader getDeclaredField(String s) { return this; }
  public ClassLoader getMethod(String s) { return this; }
  public ClassLoader getMethod(String s, Class c) { return this; }
  public InputStream get (Object o) { return new FakeInputStream(); }
  public void invoke(Object o, SecurityManager sm) {}
}
class FakeInputStream extends InputStream {
  public int read() {
    return -1;

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

추신. Olivier가 명령 줄 인수를 통해 입력을 받았다는 것을 분명히하기 전에 작성된 이전의 시도는 다음과 같습니다. 위의 균열과 달리, 이것은 Linux에 국한되지 않습니다.

    try {
      Class loader = Class.class.getMethod("getClassLoader").getReturnType();
      Object sysLoader = loader.getMethod("getSystemClassLoader").invoke(null);
      Class integer = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.Integer");
      Class system  = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.lang.System");
      Class scanner = (Class) loader.getMethod("loadClass", String.class).invoke(sysLoader, "java.util.Scanner");

      InputStream in = (InputStream) system.getField("in").get(null);
      Object scanIn = scanner.getConstructor(InputStream.class).newInstance(in);

      int a = (int) scanner.getMethod("nextInt").invoke(scanIn);
      int b = (int) scanner.getMethod("nextInt").invoke(scanIn);

      Object out = system.getField("out").get(null);
      out.getClass().getMethod("println", String.class).invoke(out, ""+(a+b));
    } catch (Exception e) {
      throw new Error(e);
    }
  }
}
class ClassLoader {
  public static ClassLoader getSystemClassLoader() { return new ClassLoader(); }
  public ClassLoader loadClass(String s) { return this; }
  public ClassLoader getDeclaredField(String s) { return this; }
  public ClassLoader getMethod(String s) { return this; }
  public ClassLoader getMethod(String s, Class c) { return this; }
  public InputStream get (Object o) { return new FakeInputStream(); }
  public void invoke(Object o, SecurityManager sm) {}
}
class FakeInputStream extends InputStream {
  public int read() {
    return -1;

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

raznagul의 C # (. NET 코어)

나는 이것이 의도 된 해결책이 아니라고 가정합니다.

int a;
int b;

using (var f = new System.IO.FileStream("/dev/stdin", System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
using (var fs = new System.IO.StreamReader(f))
{
a = int.Parse(fs.ReadLine());
b = int.Parse(fs.ReadLine());
}
}
using (var f = new System.IO.FileStream("/dev/stdout", System.IO.FileMode.Open, System.IO.FileAccess.Write))
{
using (var fs = new System.IO.StreamWriter(f))
{
fs.WriteLine((a + b).ToString());
}
}

Java, racer290 작성

이것은 메서드 static이전에 이니셜 라이저가 호출 되는 기본적인 간과였습니다 main. 그것은 좋은 시도였습니다 : 나는 처음에 당황 throw new Error()했지만 결국 길을 찾았습니다.)

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException {

    try {

        System.class.getField("in").set(null, null);
        System.class.getField("out").set(null, null);
        System.class.getField("err").set(null, null);

        System.class.getMethod("getSecurityManager", new Class[0]).setAccessible(false);

        File.class.getField("fs").set(null, null);

        for (Method m : Class.class.getMethods()) {

            m.setAccessible(false);

        }

        SecurityManager mngr = new SecurityManager() {

            @Override
            public void checkPermission(Permission p) {

                throw new Error("Muahaha!");

            }

            @Override
            public void checkLink(String s) {

                throw new Error("Not this way, my friend!");

            }

        };

        System.setSecurityManager(mngr);

    } catch (Throwable t) {

    }
    // My code here, I guess...
} static {
  java.util.Scanner s = new java.util.Scanner(System.in);
  System.out.println(s.nextInt()+s.nextInt());

    // End of my code
}

Kevin Cruijssen의 Java

잘 구성되어 있습니다. 이 문제를 해결하는 방법을 모든 사람이 올바르게 숙고하도록하는 많은 코드. "나중에 코드를 입력하십시오"는 큰 힌트였습니다.

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileDescriptor;
import java.io.FilePermission;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

  // Put everything in a static block so it is run before the static main method 
  // and any trailing (static) initializer-blocks:
  static {
    try {
      initializing();
    } catch (final Exception e) {
    }
  }

  static void initializing() throws Exception {
    // Overwrite System.out, System.err and System.in:
    System.setOut(new PrintStream(new ByteArrayOutputStream()));
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
    System.setIn(new ByteArrayInputStream(new byte[0]));

    // Enable reflection for System.out, System.err and System.in:
    final Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    final Class<?> fdClass = java.io.FileDescriptor.class;
    final Field outField = fdClass.getDeclaredField("out");
    outField.setAccessible(true);
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    final Field errField = fdClass.getDeclaredField("err");
    errField.setAccessible(true);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    final Field inField = fdClass.getDeclaredField("in");
    inField.setAccessible(true);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);

    // Replace existing System.out FileDescriptor with a new (useless) one:
    outField.set(null, new FileDescriptor());
    // Replace existing System.err FileDescriptor with a new (useless) one:
    errField.set(null, new FileDescriptor());
    // Replace existing System.in FileDescriptor with a new (useless) one:
    inField.set(null, new FileDescriptor());

    // Disable reflection for System.out, System.err, System.in again:
    modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
    modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
    inField.setAccessible(false);
    errField.setAccessible(false);
    outField.setAccessible(false);
    modifiersField.setAccessible(false);

    // Overwrite the SecurityManager:
    System.setSecurityManager(new SecurityManager() {

      private boolean exitAllowed = false;

      @Override
      public void checkExec(final String cmd) {
        throw new SecurityException();
      }

      @Override
      public void checkPermission(final java.security.Permission perm) {
        final String name = perm.getName();
        // You're not allowed to read/write files:
        if (name.equals("setIO") || name.equals("writeFileDescriptor")
            || name.equals("readFileDescriptor")
            || ((perm instanceof FilePermission) && name.startsWith("/proc/self/fd/"))) {
          throw new SecurityException();
        }
        // You're not allowed to overwrite the Security settings:
        if (name.equals("setSecurityManager") || name.equals("suppressAccessChecks")) {
          throw new SecurityException();
        }
        // You're not allowed to use reflection anymore:
        if (name.equals("getModifiers") || name.equals("get") || name.equals("set")
            || name.equals("setBoolean") || name.equals("setByte")
            || name.equals("setChar") || name.equals("setShort") || name.equals("setInt")
            || name.equals("setLong") || name.equals("setFloat") || name.equals("setDouble")
            || name.equals("setFieldAccessor") || name.equals("setFieldAccessor")) {
          throw new SecurityException();
        }
        // When you try to leave the current VM it will stop the program:
        if (name.startsWith("exitVM") && !this.exitAllowed) {
          this.exitAllowed = true;
          System.exit(0);
        }

        // You know what, nothing is allowed!
        throw new SecurityException("Mhuahahahaha!");
      }
    });
  }

  public static void main(String[] args) {
    // Overwritting all given arguments:
    args = new String[0];

    // Exit the program before you can do anything!
    System.exit(0);
  }
}

class System {
  static void exit(int n) {}
  static void setSecurityManager(SecurityManager sm) {
    java.util.Scanner scanner =new java.util.Scanner(java.lang.System.in);
    java.lang.System.out.println(scanner.nextInt() + scanner.nextInt());
  }
  static void setIn(Object o) {}
  static void setOut(Object o) {}
  static void setErr(Object o) {}
}

여기에서 시도하십시오.

Grant Davis의 자바 스크립트

document.body.innerHTML='<iframe/>'
w=frames[0]
w.console.log(1*w.prompt()+1*w.prompt())

about:blankChromium 59 / Linux 의 페이지에서 (cop post에 지정된대로) JS 콘솔에서 작동 합니다.

cQuents , Step Hen , 3 바이트

+BC

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

그의 이상한 언어가 어떻게 작동하는지 알아 내기 위해 Step Hen와 많은 대화를 나 but습니다.

그의 코드는 #|1,1:A입니다. #|1,1기본 입력으로 프로그램에 입력 된 내용에 2 1이 추가됨을 의미합니다. (IE가 47과 53을 통과하면 입력은 [47, 53, 1, 1]입니다.

:단순히 모드를 설정하면 설정된 n경우 순서대로 항목을 n출력하고 그렇지 않으면 전체 순서를 출력합니다.

마지막으로 A첫 번째 입력을 얻습니다.

우리는 4 개 입력을 가지고 있기 때문에 [47, 53, 1, 1], 추가BC 끝에 하면 2, 3 번째 입력도 가져오고 4 번째 입력은 암시 적으로됩니다 n.

우리의 시퀀스는이므로 ABC대수적으로 구문 분석됩니다 A*B*C. 우리는 그것을 원하지 않지만 +A와 B 사이에 A를 삽입하면 입력이 A+B*C어디에 A있고 B입력 C이며 1이됩니다.

raznagul의 C # (. NET 코어)

var console = typeof(System.ConsoleCancelEventArgs).Assembly.GetType("System.Console");
var readLine = console.GetMethod("ReadLine");
var writeLine = console.GetMethod("WriteLine", new Type[] { typeof(int) });
int a = Int32.Parse((string) readLine.Invoke(null, null));
int b = Int32.Parse((string) readLine.Invoke(null, null));
writeLine.Invoke(null, new object[] {a+b});

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

실제로 C #을 알고 있다면 아마도 시간이 덜 걸렸을 것입니다. 그러나 Jon Skeet 의 설명서를 약간 탐색 하고 약간의 도움을 받아 작동하는 것을 함께 모을 수있었습니다.

@DJMcMayhem의 Vim 도전

vim 을 종료 할 수 없었기 때문에 오랜 시간이 지났습니다. 내 솔루션은 다음과 같습니다 ( 23바이트 보다 훨씬 큽니다 -아마도 의도 된 솔루션이 아닙니다) :

i
echo "
12
39
"|awk '{s'$(python -c "print(''.join([chr(43),chr(61)]))")'$1} END {print s}'<Esc>vgg!bash

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

아이디어는 단순히 파이프에 두 개의 정수입니다 awk통해 bash때문에, =그리고 +장애인 난 작은 해결 방법 사용했다 있었다. awk라인으로 확장 :

"|awk '{s'+='} END {print s}

편집 : 원래 의도는 입력이 이미 버퍼에 있지만 더 어렵지는 않을 것입니다. 주요 어려움은 추가 작업을 얻는 것이 었습니다.

@DJMcMayhem이 제안한 수정 사항은 다음과 같습니다. 온라인으로 사용해보십시오!

Poke의 Java 7

  }
  public static void main(java.lang.String[]a) throws Exception {
    int x = Integer.parseInt(a[0]);
    int y = Integer.parseInt(a[1]);
    java.lang.System.out.println(x+y);
  }
}
class String {
}
class System {
  public static java.io.InputStream in = new java.io.ByteArrayInputStream(new byte[0]), out = in, err = in;
  public static void setProperties (Object o) {

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

Linux 고유의 트릭이 필요하지 String않으며 규정되지 않은 System클래스 이름 의 간단한 마스킹입니다 . 이것은 아마도 의도 된 해결책은 아니지만 작동합니다.

Ilmari Karonen의 GolfScript

"#{var 'add', Gblock.new('gpush gpop + gpop')}";
add

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

@ATaco의 RProgN2

"+-/*÷^"{²[[\=};
{"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"={"d"="g"=g~d&gd~&|}"±"={"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬|}:1\2\Š1{[H‹|"H"=};H}"×"={"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK|}"+"=

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

이것은 내가 줄 수있는 최선의 대답은 아니지만 숫자를 다시 추가 할 수 있습니다. 실제로 실제로 처리하고 적절한 스택 처리를 수행 한 경우 아마도 이것을 꽤 골프화 할 수는 있지만 지금은 대답에 만족합니다.

ATaco의 원래 게시물에서 그는 효과적으로 모든 주요 산술 연산자를 재 입력하여 입력을 파괴했습니다. 이 문제를 해결하기 위해 이진 연산의 측면에서 추가 된 부분을 재정의했습니다. RProgN2 에 이진 부정 연산자 또는 xor가 .

참고 : 입력을 테스트하려면 두 자리 이상의 숫자가 양식에 있어야합니다. "XX..." n 개념 또는 문자열이 아닌 한 RProgN2가 각 문자를 그대로 사용하므로 실제 숫자로 변환되는 이어야합니다. 편집 : @ATaco는 여러 자리 숫자 앞에 '$'를 추가하면 같은 일을 할 것이라고 지적했습니다.

편집 : 여기 내 솔루션의 논리가 있습니다. 보시다시피 가장 세련된 코드는 아니지만 작동합니다.

{"D"=11{‹1D&¬\D›]"D"=}:]1\2\Š1{[\D‹|"D"=};D¬{1"D"=1\2\Š1{[D‹"D"=};}{[}?D}"~"= # Defines the ~ operator which negates a number
{"D"=                                                                   }     # Remove the top of the stack and assign D with the popped value
     11                                                                       # Push 2 1's to the stack.  The first is used as a counter, the second if the initial truthy value for the loop
       {             }:                                                       # Start a while loop if the top of the stack (popped) is truthy (removes final falsey value)
        ‹                                                                     # Left shift the counter variable
         1D&¬                                                                 # Push negation of last bit of D
             \                                                                # Swap the counter (index 1) and the negated bit (index 0)
              D›]"D"=                                                         # Push D, right shift it, duplicate the value on the stack, then pop and assign the top to D
                       ]1\                                                    # Duplicate the counter, push 1, and swap the counter to the top of the stack
                          2\Š                                                 # Push 2, swap with the counter, then take the log (log_2(counter))
                             1{         };                                    # Run the for loop "for (i=1;i<=log_2(counter);i+=1)"
                               [\                                             # Pop off i, then swap the original counter with the next bit to append
                                 D‹|"D"=                                      # Left shift D, or it with the next bit, then assign D the new value
                                          D¬                                  # Need to check if D was 0 or not (in the case of 0b11...1~)
                                            {                     }{ }?       # Conditional on the truthiness of not D
                                             1"D"=                            # If D was 0, we assign it as 1, then start to bit shift it up
                                                  1\2\Š1{       };            # Same for loop as earlier since the original counter is still on the top of the stack
                                                         [D‹"D"=              # Pop off i, left shift D, then reassign it
                                                                    [         # Else D was non-zero, so just pop off the counter we've been carrying around
                                                                       D      # Push the final value to the top of the stack as a return
                                                                         "~"= # Assign the function between the {}'s to the character '~'

{"d"="g"=g~d&gd~&|}"±"=                                                       # Defines the ± operator which performs a single bit xor
{"d"="g"=         }                                                           # Assign d and g the first and second values on the stack respectively
         g~d&                                                                 # Push ~g&d to the top of the stack
             gd~&                                                             # Push g&~d to the top of the stack
                 |                                                            # Or the top 2 values giving us (~g&d)|(g&~d)
                   "±"=                                                       # Assign this function to the ± operator

{"H"="I"=11{‹H1&I1&±\H›"H"=I›"I"=H¬¬I¬¬|}:1\2\Š1{[H‹|"H"=};H}"×"=             # Defines the × operator which performs a full number xor
{"H"="I"=                                                   }                 # Store the top 2 stack values in H and I (in that order)
         11{                            }:                                    # Another while loop with the first one being a counter for later, and the second is our truthy value to start the loop
            ‹H1&I1&±                                                          # Left shift the counter, then push the bit xor of H's and I's lowest bit ((H&1)±(I&1) in infix notation)
                    \                                                         # Swap the calculated bit and the counter
                     H›"H"=I›"I"=                                             # Right shift both variables and store the values back in them
                                 H¬¬I¬¬|                                      # Effectively pushing the value (H!=0 | I != 0)
                                          1\2\Š1{        };                   # Same for loop as the ones above
                                                 [H‹|"H"=                     # Pop off the for loop counter, left shift H, or it with the next bit, and reassign
                                                           H                  # Push the final computed xor value to the top of the stack
                                                             "×"=             # Assign this whole function to the × operator

{"J"="K"=1{JK&‹JK×"K"=]"J"=}:JK|}"+"=                                         # Finally, a function redefining addition as the "+" operator
{"J"="K"=                       }                                             # Store the top 2 stack values in J and K respectively
         1{                }:                                                 # An initial truthy value to start the while loop and the loop itself
           JK&‹                                                               # Push (J&K)<<1 to the stack
               JK×                                                            # Compute the full xor of J and K (J^K in Python)
                  "K"=                                                        # Assign K the value of J xor K
                      ]"J"=                                                   # Duplicate (J&K)<<1 and assign 1 copy to J, leaving (J&K)<<1 as our while check (while ((J&K)<<1))
                             JK|                                              # Finally push the value J|K to the stack to get the addition
                                 "+"=                                         # Assign this function to the "+" operator, restoring it

자바 스크립트 (Node.js를) 에 의해 jrich , 298 바이트

나는 이것이 의도 된 해결책이 아니라고 생각하지만, 잘 수행되면 선언 된 함수의 이름을 얻는 방법을 알아 내려고 노력했습니다! :)

var p=process,f;(_=>{var w=p.stdout.write,n='f'+(Math.random()*1e7|0),l=1
f=p.stdout.write=a=>eval(`(function ${n}(a){while(l&&((typeof a)[0]!='s'||'f'+a!=n));a=l?l="":a;w.apply(p.stdout,arguments);})`)(a)})();
process.stderr.write.call(process.stdout,''+((0|process.argv[2])+(0|process.argv[3])));

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