2 개의 입력과 1 개의 출력으로 16 개의 로직 게이트를 모두 골라보세요!


63

예를 들어, 게이트 A and B는 2 개의 입력과 1 개의 출력을 가진 로직 게이트입니다.

정확히 16 개가 있습니다.

  • 각 논리 게이트는 두 가지 입력을 취하는데,이 입력은 진실하거나 거짓 일 수 있으므로 4 가지 입력이 가능합니다
  • 4 개의 가능한 입력 중 각각은 진실과 거짓의 결과를 가질 수 있습니다
  • 따라서 2 ^ 4 개의 가능한 논리 게이트가 있으며 이는 16입니다.

당신의 임무는 16 개의 프로그램 / 기능을 모두 작성하는 것입니다.

기능 / 프로그램 은 독립적이어야합니다 .

true / falsey 값을 출력하는 한 유효합니다. 즉 , and에 대해 생성 된 경우에도 A or BPython으로 구현할 수 있습니다 .lambda a,b:a+b2A=TrueB=True

점수는 각 기능 / 프로그램에 사용 된 총 바이트입니다.

논리 게이트 목록

  1. 0,0,0,0 ( false)
  2. 0,0,0,1 ( and)
  3. 0,0,1,0 ( A and not B)
  4. 0,0,1,1 ( A)
  5. 0,1,0,0 ( not A and B)
  6. 0,1,0,1 ( B)
  7. 0,1,1,0 ( xor)
  8. 0,1,1,1 ( or)
  9. 1,0,0,0 ( nor)
  10. 1,0,0,1 (개 xnor)
  11. 1,0,1,0 ( not B)
  12. 1,0,1,1 (개 B implies A)
  13. 1,1,0,0 ( not A)
  14. 1,1,0,1 ( A implies B)
  15. 1,1,1,0 ( nand)
  16. 1,1,1,1 ( true)

첫 번째 숫자는에 대한 출력 A=false, B=false이고 두 번째 숫자는에 대한 출력 A=false, B=true이고 세 번째 숫자는에 대한 출력 A=true, B=false이고 네 번째 숫자는에 대한 출력입니다 A=true, B=true.

리더 보드


2
기능 / 프로그램이 코드를 공유 할 수 있습니다. 이것은 무엇을 의미 하는가? 또한 프로그램이 다른 언어로되어 있습니까?
Lynn

2
나는 혼란스러운 설명을 발견했다. "각각의 가능한 4 가지 입력 중 진실하고 허위 한 결과를 얻을 수있다". 이것이 8 (4 * 2) 상태를 의미하지 않습니까?
DavidC

4
누락 된 이름은 AND-NOT 게이트입니다 (A AND NOT B 및 B AND NOT A).
Mego

14
그래서 다시 일어났다. 18 가지 대답이 있는데, 대부분 간단하고 정확하다. 그 어느 곳에서도 문제는 "무엇을 묻고 있는지 불분명하다". 난 당신이 도전을 좋아하지 않아, 계속 다른 도전을 닫지 마십시오!
edc65

4
@dorukayhan 참조 : 공허한 진실
Sp3000

답변:


110

도미노 , 122,000 바이트 또는 72 타일

바이트 수는의 크기가 저장된 파일 입니다 0.122 MB.

도미노 컴퓨팅 은 영감이었습니다. Tabletop Simulator 라는 가상 현실 Steam 게임을 통해 이러한 모든 것을 대칭 (및 그 이상)까지 테스트했습니다 .

세부

  • I / O
    • 시작 -명확성을 위해 포함되며 (총계로 계산되지 않음) 기능을 '호출'또는 '실행'합니다. 입력에 [Yellow] 가 주어진 후 '눌려 져야' 합니다.
    • 입력 A- 명확성을 위해 포함되어 있으며 (총계로 계산되지 않음) '누르고'는 1그렇지 않으면 [녹색] 을 나타냅니다 .
    • 입력 B- 명확성을 위해 포함되며 (총계로 계산되지 않음) '누르고'는 1그렇지 않으면 [푸른] 을 나타냅니다 .
    • 출력 -총계로 계산됩니다. 논리 게이트의 결과를 선언하는 것은 도미노입니다 [Black] .
  • T / F
    • 타락 된 출력 도미노는 True또는1
    • 스탠딩 출력 도미노는 False또는0
  • 누르면
    • 입력하거나 체인을 시작하려면 금속 대리석을 스폰하십시오.
    • 리프트 강도를 100%
    • 원하는 도미노 위에서 대리석을 들어 올리십시오.
    • 대리석을 떨어 뜨려 라

여기에 이미지 설명을 입력하십시오

게이츠

  • 거짓, 1
    • 여기에 이미지 설명을 입력하십시오
  • 그리고, 6 4
    • 여기에 이미지 설명을 입력하십시오
  • A가 아닌 B, 4 3
    • 여기에 이미지 설명을 입력하십시오
  • A, 1
    • 여기에 이미지 설명을 입력하십시오
  • A와 B가 아님, 4 3
    • 여기에 이미지 설명을 입력하십시오
  • B, 1
    • 여기에 이미지 설명을 입력하십시오
  • xor, 15 11
    • 여기에 이미지 설명을 입력하십시오
  • 또는 1
    • 여기에 이미지 설명을 입력하십시오
  • 또는 3 2
    • 여기에 이미지 설명을 입력하십시오
  • xnor, 17 13
    • 여기에 이미지 설명을 입력하십시오
  • B가 아닌 2
    • 여기에 이미지 설명을 입력하십시오
  • B는 A, 7 6을 의미합니다.
    • 여기에 이미지 설명을 입력하십시오
  • A가 아님, 2
    • 여기에 이미지 설명을 입력하십시오
  • A는 B, 7 6을 의미합니다
    • 여기에 이미지 설명을 입력하십시오
  • 낸드, 16 15
    • 여기에 이미지 설명을 입력하십시오
    • 사실, 1
    • 여기에 이미지 설명을 입력하십시오

TL; DR

나는 도미노 친화적 인 도전을 기다리고 / 원하고 있었고 이것을 보았을 때 나는 그것을 통과시킬 수 없었습니다. 유일한 문제는 더 이상 아무도 도미노를 소유하지 않았다는 것입니다! 결국 나는 더블 12 를주고 샀다 . 이 세트에는 91 개의 타일이있어 일반적인 (긴) '시간 지연'방법 대신 '함수 호출'/ 시작 도미노가 있다는 아이디어를 얻었습니다. 90도 회전에 대한 크레딧은 dominoesdouble07의 채널에 속합니다 .

물리적 도미노 이러한를 구축 한 후에는 한 지배 유효한 솔루션은 디지털해야한다는 메타에. 그래서 저는이 게이트를 Tabletop Simulator 에서 다시 만들었습니다 . 안타깝게도 TS와 현실은 도미노 물리학에 동의하지 않습니다. 11 개의 도미노를 추가해야했지만 8을 절약했습니다. 전체적으로 가상 도미노는 구축 및 테스트 ( Ctrl+ Z) 측면에서 약 x150 정도 더 효과적입니다 .

최신 정보

  • -9 [17-03-13] 단축xor xnor nand
  • [17-03-04] 워크숍 파일에 대한 링크 추가
  • +11 [17-03-03] 디지털 추가 xnorxor
  • -8 [17-03-03] 모든 게이트를 디지털화했습니다 ( xor및 제외 xnor). Tabletop에서의 차단은 2가 아닌 1 개의 도미노 만 필요합니다.
  • [16-09-23] 축소 된 이미지
  • -11 [16-09-18] xor를 다시 거의 반으로 자릅니다. xnor의 경우 @DJMcMayhem과 xor의 경우 Joe 에게 감사합니다 .
  • -31 [16-08-31] 일부 사진을 업데이트하고 일부 타일을 면도하고 xor 를 반으로 자릅니다.
  • [16-08-28] 사진 추가

43
+1 PPCG에서 더 많은 도미노 골프가 필요합니다
Beta Decay


7
와. 이것은 내가이 사이트에서 본 가장 독창적 인 답변 중 하나입니다.
DJMcMayhem

3
xnor를 함께 뭉개 서 5 개가 아니라 4 개가있는 경우 도미노 하나를 제거 할 수있는 것처럼 보입니다.
DJMcMayhem

2
시간을내어 유효한 답변을 작성해 주셔서 감사합니다. 그러나 소스 파일에 대한 링크는 찾기가 약간 어렵습니다. 일반적으로 헤더의 링크는 언어 자체로 연결됩니다. 그래서 그 것을 증기 게임에 연결 한 다음 실제 "소스 파일"에 대한 링크를 답변 본문에 별도의 명확하게 레이블이 지정된 링크에 넣습니다.
Martin Ender

45

헥사 고니 , 89 바이트

XOR 솔루션에 필요한 영감을 주신 FryAmTheEggman에게 감사합니다.

0000 !@
0001 ?.|@!
0010 #?#!)@
0011 ?!@
0100 +?|@!?
0101 ??!@
0110 ?<@!!<_\~(
0111 ?<<@!
1000 )\!#?@{
1001 (~?/@#!
1010 ??|@!)
1011 \#??!1@
1100 ?(~!@
1101 ?.|@!)
1110 ?$@#)!<
1111 1!@

모든 프로그램 0은 거짓과 1참으로 사용됩니다.

온라인으로 사용해보십시오! 이것은 테스트 스위트가 아니며 다른 프로그램으로 복사하여 직접 입력해야합니다.

위의 솔루션은 최적의 2 바이트 내에 있습니다 (진실한 / 거짓 해석을 완화하지 않는 한). 나는 즉, 최대 7 바이트 (안에, 측면 길이 2에 맞게 모든 프로그램 이상 이일에 가까운에 대한 무력 검색을 실행하도록 한 매우 모든 프로그램을 - 나는 무엇을 모든 유효한 프로그램의 요구와 무엇에 대한 몇 가지 가정을 만들어 없음 유효한 프로그램). 검색 결과 16 개의 가능한 게이트 중 15 개에 대한 솔루션이 발견되었으며 종종 하나 이상의 게이트에 대한 솔루션이 발견되었습니다. 이 pastebin 에서 동등한 대안으로 그룹화 한 모든 대체 솔루션 목록을 찾을 수 있습니다 . 위에 표시된 것은 가장 간단하거나 가장 흥미로운 솔루션이기 때문에 선택한 것이므로 내일 설명을 추가하겠습니다.

16 번째 게이트 : XOR은 7 바이트로 구현할 수없는 유일한 게이트입니다. 더 큰 프로그램에 대한 무차별 대입 검색은 불행히도 현재 가지고있는 코드로는 불가능합니다. 그래서 XOR은 손으로 작성해야했습니다. 지금까지 찾은 가장 짧은 것은 FryAmTheEggman의 실패한 (그러나 매우 가까운) 시도를 기반으로하는 위의 10 바이트 프로그램입니다. 8 바이트 또는 9 바이트 솔루션이 존재할 수 있지만 그 외에는 모든 솔루션이 실제로 최적이어야합니다.

설명

경고 : 텍스트 벽. 이러한 높은 압축 Hexagony 프로그램의 실제 작동 방식에 관심이있는 사람이라면 누구나 아래에 각 프로그램에 대한 설명을 포함 시켰습니다. 설명을 합리적으로 짧게 유지하기 위해 둘 이상의 최적의 프로그램이 존재하는 경우 각 게이트에 대해 가장 간단한 솔루션을 선택하려고했습니다. 그러나 그들 중 일부는 여전히 마음을 흔들 리므로 좀 더 정교해질 가치가 있다고 생각했습니다.

0000: 거짓

나는 우리가 이것에 대한 다이어그램이 필요하다고 생각하지 않습니다.

 ! @
. . .
 . .

전체 메모리 그리드가 0으로 초기화되므로 !간단히 0 을 인쇄 @하고 프로그램을 종료하십시오.

이것은 또한 유일한 2 바이트 솔루션입니다.

0001: 그리고

 ? .
| @ !
 . .

이것은 기본적으로 단락을 구현 합니다. 아래의 회색 다이어그램은 프로그램의 시작 부분을 보여줍니다. 여기서 첫 번째 입력을 읽고 ?명령 포인터 (IP)가 |미러가 반영 하는 왼쪽 모서리를 감 습니다. 이제 코너는 조건부로 작동하므로 첫 번째 입력 값에 따라 두 개의 다른 실행 경로가 있습니다. 빨간색 다이어그램은 다음에 대한 제어 흐름 A = 0과 녹색 다이어그램을 보여줍니다 A = 1.

나는 나는 나는

보시다시피, Ais 0인 경우 간단히 인쇄하고 종료합니다 (모두 .가 없음을 기억하십시오 ). 그러나 Ais 1인 경우 IP는 첫 번째 행을 다시 통과하여 B대신 읽고 인쇄합니다.

이 게이트에는 총 16 개의 5 바이트 솔루션이 있습니다. 그 중 하나는 포티하여, 본질적으로 상기와 동일하다 >대신 |하거나 교체 .효과적으로 무 조작 없다 명령과 함께 퍼팅 또는 ?제 2 위치에 :

?.|@!    .?|@!    ?=|@!    =?|@!    ?_|@!    _?|@!    ?0|@!
?.>@!    .?>@!    ?=>@!    =?>@!    ?_>@!    _?>@!    ?0>@!

그리고 다른 두 가지 솔루션이 있습니다 (서로 동일합니다). 이것들은 동일한 단락 논리를 구현하지만 실행 경로는 약간 더 미묘합니다 (독자에게 연습으로 남겨 두십시오).

?<!@|
?<!@<

0010: A와 B가 아님

 # ?
# ! )
 @ .

이것은 또한 단락의 형태를 구현하지만 #제어 흐름 의 사용으로 인해 훨씬 까다 롭습니다. #조건부 IP 스위치입니다. Hexagony 실제로 표시된 여섯 개 IP를 함께 제공 05자신의 시계 가장자리를 따라 가리키는 그리드의 여섯 개 모서리에서 시작 (프로그램은 항상 IP로 시작 0). a #에 도달하면 현재 값이 modulo로 취해지고 6해당 IP로 제어 흐름이 계속됩니다. 어떤 기능을 사용하여이 기능을 추가했는지는 확실하지 않지만 놀라운 프로그램 (예 : 이와 같은)을 허용합니다.

우리는 세 가지 경우를 구별 할 것입니다. 때 A = 0값이 항상 있기 때문에,이 프로그램은 매우 간단 0경우 #에는 IP 스위칭이 발생하지 않도록 발생 :

나는

#아무것도하지 않고, ?읽 거나 A(아무것도하지 않음), #아무것도하지 않고,을 !인쇄하고 0, )증가 시키며 (이것은 중요합니다. 그렇지 않으면 IP가 세 번째 줄로 넘어 가지 않습니다) @프로그램을 종료합니다. 충분히 간단합니다. 이제 사례를 고려해 보겠습니다 (A, B) = (1, 0).

나는

빨간색 경로는 여전히 IP에 해당하며 IP 0의 녹색 경로를 추가했습니다 1. ?읽은 후 A( 1이번) #오른쪽 상단에서 시작하는 IP로 전환됩니다. 즉 ( )를 ?읽을 수 있습니다 . 이제 해당 증가 등의 것을 왼쪽 상단 모서리에 아무것도하지 않고, 우리는 IP로 남아있다 . 인쇄물 이 인쇄 되고 IP가 왼쪽 대각선을 감 쌉니다. 여전히 아무것도하지 않고 프로그램을 종료합니다.B0)1#1!1#@

마지막으로 두 입력이 모두있는 이상한 경우 1:

나는

이번에는 두 번째 입력도 1되고으로 )증가합니다 2. 즉, 의미 #왼쪽 상단 모서리에 원인이 다른 IP로 IP 스위치를 2파란색으로 표시합니다. 그 길에서, 우리는 먼저 3( 더 이상 관련이 없지만) 그것을 더 증가시킨 다음 ?세 번째 로 전달합니다 . 이제 EOF에 도달 했으므로 (즉, 입력이 소진되었습니다)를 ?반환 0하고 !인쇄 한 @다음 프로그램을 종료합니다.

특히이 게이트에 대한 유일한 6 바이트 솔루션입니다.

0011: A

 ? !
@ . .
 . .

이것은 다이어그램이 필요 없을 정도로 간단합니다 : ?reads A, !printes, @terminates.

이것이이 게이트에 대한 유일한 3 바이트 솔루션입니다. (원칙적으로 할 수도 ,;@있지만 검색에 포함되지 않았습니다 ;. 왜냐하면 !이 작업을 위해 바이트를 절약 할 수 있다고 생각하지 않기 때문 입니다.)

0100: B가 아닌 A

 + ?
| @ !
 ? .

이것은 "형제"보다 훨씬 간단 0010합니다. 제어 흐름은 실제로 0001(And)에 대해 위에서 본 것과 동일 합니다. 인 경우 A = 0IP는 하단 라인을 통과하여 B종료하기 전에 해당 라인을 읽고 인쇄합니다. 만약 A = 1그 IP는 읽기, 다시 첫 번째 라인을 통과 B,하지만은 +않은 두 개의 메모리가가하는 모든 현재 값을 재설정 그래서 가장자리를 추가 0, 그래서 !항상 인쇄 0.

이것에 대한 6 바이트 대안이 많이 있습니다 (총 42 개). 첫째, 위와 동등한 솔루션이 많이 있습니다. 우리는 다시 사이에서 자유롭게 선택할 수 |>, 그리고 +우리에게 빈 우위를 제공 다른 명령으로 대체 할 수있다 :

"?|@!?    &?|@!?    '?|@!?    *?|@!?    +?|@!?    -?|@!?    ^?|@!?    {?|@!?    }?|@!?
"?>@!?    &?>@!?    '?>@!?    *?>@!?    +?>@!?    -?>@!?    ^?>@!?    {?>@!?    }?>@!?

또한 ]대신에 사용할 수도 있습니다 ?. ]다음 1분기 로 이동하여 (즉 , IP 선택 )이 분기는 대신 ?오른쪽 상단 모서리의 를 다시 사용합니다 . 그것은 또 다른 18 가지 해결책을 제공합니다.

"?|@!]    &?|@!]    '?|@!]    *?|@!]    +?|@!]    -?|@!]    ^?|@!]    {?|@!]    }?|@!]
"?>@!]    &?>@!]    '?>@!]    *?>@!]    +?>@!]    -?>@!]    ^?>@!]    {?>@!]    }?>@!]

그리고 다양한 레벨의 크레이지와 다르게 작동하는 6 가지 다른 솔루션이 있습니다.

/[<@!?    ?(#!@]    ?(#>@!    ?/@#/!    [<<@!?    [@$\!?

0101: B

 ? ?
! @ .
 . .

또 하나의 간단한 것 : read A, read B, print B, terminate. 그러나 실제로 이것에 대한 대안이 있습니다. 때문에 A단 하나의 문자입니다, 우리는 또한 그것을 읽을 수 있습니다 ,:

,?!@

그리고 하나 ?를 사용하고 거울을 사용하여 두 번 통과 시키는 옵션도 있습니다 .

?|@!    ?>@!

0110: 소르

  ? < @
 ! ! < _
\ ~ ( . .
 . . . .
  . . .

위에서 말했듯이, 이것은 측면 길이 2에 맞지 않는 유일한 게이트이므로 FryAmTheEggman과 저 자신이 손으로 쓴 솔루션이며 최적이 아닐 가능성이 높습니다. 구별해야 할 두 가지 경우가 있습니다. 경우 A = 0제어 흐름 (이 경우 우리는 인쇄해야하기 때문에 매우 간단하다 B)

나는

우리는 빨간 길에서 시작합니다. ?읽고 A, <제로 왼쪽으로 편향 지점이다. IP는 맨 아래로 감싼 다음 _또 다른 미러이며 IP가 모퉁이에 도달하면 왼쪽 상단으로 감싼 다음 파란색 경로를 계속합니다. ?읽고 B, !그것을 인쇄합니다. 이제 (그것을 줄입니다. 이는 값이 양수가 아님을 보증하기 때문에 중요합니다 ( 현재 0또는 어느 쪽이든 -1). 그러면 IP 랩이 오른쪽 @끝으로 이동하여 프로그램 이 종료됩니다.

A = 1상황이 조금 까다로워 질 때 . 이 경우 우리 not B는 그 자체로는 너무 어렵지는 않지만 print 경로를 원하지만 실행 경로는 약간 복잡합니다.

나는

이번에 <는 IP를 오른쪽으로 편향시킨 다음 <미러 역할 만합니다. 따라서 IP는 동일한 경로를 거꾸로 통과하여 다시 B만나면 읽 ?습니다. IP가 오른쪽 구석을 감싸고 녹색 경로를 계속합니다. 다음 (~으로 "감소, -1 곱하기" 가 발생 하여이를 교환 0하여 1계산합니다 not B. \거울 일 뿐이며 !원하는 결과를 인쇄합니다. 그런 다음 ?다른 숫자를 반환하려고하지만 0을 반환합니다. IP는 이제 파란색 경로의 왼쪽 하단에서 계속됩니다. (감소, <반영,(IP가 모퉁이에 도달하면 현재 값이 음수가되도록 다시 감소합니다. 오른쪽 하단 대각선을 가로 질러 이동 한 다음 마지막으로 @프로그램을 종료합니다.

0111: 또는

 ? <
< @ !
 . .

더 단락.

나는 나는

A = 0경우 (빨간색 경로)는 약간 혼란 스럽습니다. 에 의해는 IP가, 왼쪽으로 편향 왼쪽 하단에 랩 도착, 즉시 반영됩니다 <사람 및 반환 ?읽을 B. 그 다음의 rigt 코너에 랩 인쇄 B!하고 종료합니다.

A = 1경우 (녹색 경로) 조금 더 간단합니다. <우리가 단순히 인쇄 할 수 있도록 지점은 IP를 잘 편향 !, 다시 왼쪽 상단에 포장, 및에서 종료 @.

다른 5 바이트 솔루션은 하나만 있습니다.

\>?@!

본질적으로 동일하게 작동하지만 실제 실행 경로는 상당히 다르며 분기 대신 모서리를 사용합니다 <.

1000: 노

 ) \
! # ?
 @ {

이 검색에서 내가 가장 좋아하는 프로그램 일 수 있습니다. 가장 멋진 점은이 구현이 nor실제로 최대 5 개의 입력에서 작동 한다는 것입니다 . 나는 이것을 설명하기 위해 메모리 모델의 세부 사항에 조금 들어가야 할 것이다. 따라서 빠른 새로 고침으로 Hexagony의 메모리 모델은 개별 육각형 격자로, 각 모서리 에는 정수 값 (처음에는 모두 0)이 있습니다. 메모리 포인터 (MP)가 있으며 그 가장자리를 따라 가장자리와 방향을 나타냅니다 (현재 가장자리 앞뒤에 인접한 두 개의 가장자리가 있으며 의미있는 왼쪽 및 오른쪽 이웃이 있습니다). 다음은 MP가 빨간색으로 표시된 상태에서 사용할 가장자리의 다이어그램입니다.

나는

먼저 두 입력이 모두있는 경우를 고려해 보겠습니다 0.

나는

우리는 단순히 에지 증가 회색 경로에 시작 1있도록 #IP로 전환 1, 파란색 경로를하다 오른쪽 상단에서 시작. \아무것도하지 않고 ?입력을 읽습니다. )입력을 증가시키는 왼쪽 상단으로 줄 바꿈합니다 . 이제 입력이 0 인 한, 결과는 1이므로 #아무것도하지 않습니다. 그런 다음 {MP를 왼쪽으로, 즉 A 에서 B 로의 첫 번째 반복에서 이동합니다 . 이 에지는 여전히 초기 값이 0이므로 IP는 오른쪽 상단 모서리와 새로운 메모리 에지로 다시 랩핑됩니다. 따라서이 루프는 ?0 을 읽는 한 계속해서 MP를 B 에서 육각형 주위로 이동시킵니다.CD 등. ?입력이거나 EOF이기 때문에 0을 리턴 하는지 는 중요하지 않습니다 .

이 루프를 6 번 반복 한 후 A로{ 돌아갑니다 . 이번에는 가장자리가 이미 첫 번째 반복 의 값 을 유지 하므로 IP가 왼쪽 모서리로 줄 바꿈하여 대신 녹색 경로를 계속합니다. 단순히를 출력 하고 프로그램을 종료합니다.1!1@

이제 입력 중 하나가 1무엇입니까?

나는

그런 다음 어느 시점에서 그것을 ?읽고 증가시킵니다 . 즉, 이제 IP를 다시 전환하고 빨간색 경로의 오른쪽 모서리에서 계속 진행합니다. 다른 입력 (있는 경우)을 읽습니다. 실제로 중요하지 않으며 한 가장자리를 더 이동시킵니다. 이것은 사용되지 않은 에지 여야하므로 최대 5 개의 입력에 작동합니다. IP는 오른쪽 상단으로 감싸 져 즉시 반영되어 왼쪽 모서리로 감 깁니다. 사용하지 않는 가장자리를 인쇄하고 다시 IP로 전환합니다 . 그 IP는 여전히 남서쪽 (회색 경로)으로 가면서 기다리고 있었으므로 즉시 충돌 하고 프로그램을 종료합니다.1)2#?{!0#0#@

이 게이트에는 총 7 개의 7 바이트 솔루션이 있습니다. 그중 5 개는 이것과 동일하게 작동하고 다른 명령을 사용하여 사용하지 않는 가장자리로 이동합니다 (다른 육각형 주위 또는 다른 방향으로 걸을 수 있음).

)\!#?@"    )\!#?@'    )\!#?@^    )\!#?@{    )\!#?@}

그리고 두 개의 입력에서만 작동하지만 실행 경로가 실제로 더 지저분한 솔루션의 또 다른 클래스가 있습니다.

?]!|<)@    ?]!|<1@

1001: 평등

 ( ~
? / @
 # !

또한 조건부 IP 선택을 매우 영리하게 사용합니다. 우리는 사이에 다시 구분해야 A = 0하고 A = 1. 첫 번째 경우에는 인쇄 not B하고, 두 번째 경우에는 인쇄 하고 싶습니다 B. 들어 A = 0우리는 또한에 대한 두 경우를 구별 B. 시작하자 A = B = 0:

나는

우리는 회색 길에서 시작합니다. (~무시 될 수 있으며, IP는 (여전히 회색 경로) 왼쪽 코너에 랩과 읽기 A?. (그래서 우리는 얻을 감소시키고 -1왼쪽 하단 및 IP 랩. 앞에서 말했듯이 IP를 선택하기 전에 #모듈로 값을 취 6하므로 -1실제로 값은 IP를 가져 5옵니다.이 경로는 빨간색 경로의 왼쪽 모서리에서 시작합니다. ?읽고 B, (우리가 IP에 남아뿐만 아니라 있도록 감소율 5우리가 공격 할 때 #다시. ~는 무효화 -1는 IP가, 오른쪽 하단 모서리에 래핑을 인쇄하도록 1하고 종료합니다.

나는

경우 지금 B입니다 1대신, 현재의 값이 될 것입니다 0우리가 공격 할 때 #두 번째로 우리가 IP로 전환, 0(녹색 경로에 현재). 즉, 히트 ?수득 세 번째로 0, !그것과 출력 @이 종료.

나는

마지막으로 A = 1. 이번에 #는 처음 공격 할 때 현재 값이 이미 0 이므로 5처음에는 IP 로 전환되지 않습니다 . 우리는 단순히 녹색 길을 계속 이어갑니다. ?이제 0을 제공하지 않고 B대신 반환 합니다. !그것을 인쇄하고 @다시 종료합니다.

이 게이트에는 총 3 바이트의 7 바이트 솔루션이 있습니다. 다른 두 개는 서로 매우 다르게 작동하며을 더 이상 사용 #합니다. 특히 그들은 ,(정수 대신 문자 코드를 읽는) 하나 이상의 값을 읽은 다음 해당 값 modulo 6을 사용하여 IP를 선택합니다. 예쁜 견과류입니다.

),)#?@!

?~#,~!@

1010: B가 아님

 ? ?
| @ !
 ) .

이것은 매우 간단합니다. 실행 경로는 우리가 이미 알고있는 수평 브랜치 and입니다. ??읽고 A즉시 B. 이후에 반영 |하고 들면 분기 B = 0우리 바닥 지점을 실행할 것이며, 여기서 )에 대한 값을 증분 1한 다음, 인쇄된다 !. 상단 분기 (있는 경우 B = 1)에서 ?단순히 가장자리를 재설정 0한 다음 인쇄합니다 !.

이 게이트에는 8 바이트의 6 바이트 프로그램이 있습니다. 그중 4 개는 >대신 |또는 1대신 )(또는 둘 다)을 사용하여 거의 동일합니다 .

??>@!)    ??>@!1    ??|@!)    ??|@!1

?은 거울 때문에 두 번 사용되는 단일 을 사용합니다 . 우리가 그랬던 것처럼 부정은 어떻게 xor하나와 (~~).

?>!)~@    ?>!~(@

마지막으로 두 가지 솔루션은 조건부 IP 스위치를 사용합니다. 왜 복잡한 솔루션도 작동하는 경우 간단한 방법을 사용해야하기 때문입니다.

??#)!@    ??#1!@

1011: B는 A를 의미

 \ #
? ? !
 1 @

이것은 다소 정교한 IP 스위칭을 사용합니다. A = 1이번에 는 케이스가 더 간단하기 때문에 시작하겠습니다 .

여기에 이미지 설명을 입력하십시오

우리는 읽고 회색 경로에 시작 A하여 ?다음 명중 #. 이것이 IP (녹색 경로)로 전환 되기 때문 A입니다 . 는 즉시 IP 상단 왼쪽 감싸는 것이 판독 출력한다 (불필요하게)하고 종료한다.11!B

A = 0일이 좀 더 흥미로워 질 때 . 먼저 고려해 봅시다 A = B = 0:

여기에 이미지 설명을 입력하십시오

이번에 #는 아무것도하지 않으며 IP 0(그 시점부터 빨간색 경로) 에 남아 있습니다 . ?읽기 B1로 바뀝니다 1. 왼쪽 상단에 줄 바꿈을 한 후 #다시 맞았 으므로 결국 녹색 경로 1를 끝내고 이전 과 같이 인쇄 하여 종료합니다.

마지막으로 (A, B) = (0, 1)허위 경우는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

명확성을 위해 초기 회색 경로를 제거했지만 프로그램은 같은 방식으로 시작하여 이전과 같이 빨간색 경로로 끝납니다. 이번에는 두 번째로 ?돌아갑니다 1. 이제 우리는 발생 1. 이 시점에서 Hexagony에서 실제로 숫자가 수행하는 작업을 이해하는 것이 중요합니다 (지금까지는 0에서만 사용했습니다). 숫자가 발생하면 현재 값에 10을 곱한 다음 숫자가 추가됩니다. 일반적으로 소스 코드에 10 진수를 그대로 쓰는 데 사용되지만 B = 1실제로는 값에 매핑됩니다 11. 우리가 쳤을 때 그래서 #,이 모듈로 촬영 6주고를 5따라서 우리는 IP로 전환 5(대신 1이전)과 파란색 경로에 계속. 타격?세 번째는 0을 반환하므로이를 !인쇄하고 두 번째 후에 ?는 IP가 프로그램이 종료되는 오른쪽 하단으로 줄 바꿈됩니다.

여기에는 4 바이트의 7 바이트 솔루션이 있으며 모두 다르게 작동합니다.

#)/!?@$    <!?_@#1    \#??!1@    |/)#?@!

1100: 아님

 ? (
~ ! @
 . .

그냥 간단한 선형 하나를 읽어 A?,와 부정 (~으로 인쇄 !와 함께 종료 @.

하나의 대안 솔루션이 있으며 그 ~)대신에 부정적입니다 .

?~)!@

1101: A는 B를 의미

 ? .
| @ !
 ) .

이것은 우리가 방금 말한 반대의 의미보다 훨씬 간단합니다. 다시 같은 수평 브랜치 프로그램 중 하나입니다 and. 경우 A이며 0, 그것은 단순히 증가됩니다 1하단 지점에 인쇄. 그렇지 않으면 상단 분기가 다시 실행 되어 대신 ?읽은 B다음 !인쇄됩니다.

있다 주로 인해 효과가없는 작전의 자유로운 선택, 여기에 대안 (총 66 개 솔루션). 시작을 위해 위와 같은 솔루션을 우리가 할 수있는 것과 똑같은 방식으로 변화 and시킬 수 있으며 ), 1다음 중에서 선택할 수도 있습니다 .

?.|@!)    .?|@!)    ?=|@!)    =?|@!)    ?_|@!)    _?|@!)    ?0|@!)
?.|@!1    .?|@!1    ?=|@!1    =?|@!1    ?_|@!1    _?|@!1    ?0|@!1
?.>@!)    .?>@!)    ?=>@!)    =?>@!)    ?_>@!)    _?>@!)    ?0>@!)
?.>@!1    .?>@!1    ?=>@!1    =?>@!1    ?_>@!1    _?>@!1    ?0>@!1

그리고 첫 번째 명령은 거의 임의로 선택 할 수있는 조건 IP 선택을 사용하여 다른 버전이있다, 사이의 선택도있다 )1이러한 옵션 중 일부는 :

"?#1!@    &?#1!@    '?#1!@    )?#1!@    *?#1!@    +?#1!@    -?#1!@    .?#1!@    
0?#1!@    1?#1!@    2?#1!@    3?#1!@    4?#1!@    5?#1!@    6?#1!@    7?#1!@    
8?#1!@    9?#1!@    =?#1!@    ^?#1!@    _?#1!@    {?#1!@    }?#1!@

"?#)!@    &?#)!@    '?#)!@              *?#)!@    +?#)!@    -?#)!@    
0?#)!@              2?#)!@              4?#)!@              6?#)!@    
8?#)!@                        ^?#)!@    _?#)!@    {?#)!@    }?#)!@

1110낸드

 ? $
@ # )
 ! <

마지막 복잡한 것. 아직도 읽고 있다면 거의 다 읽었을 것입니다. :) A = 0먼저 살펴 보자 .

여기에 이미지 설명을 입력하십시오

?읽고 A우리는 때렸다 $. 이것은 Befunge와 같은 점프 명령으로 #, 다음 명령을 건너 뛰어에서 종료하지 않습니다 @. 대신 IP는에서 계속됩니다 #. 그러나 Ais 이기 때문에 0이것은 아무것도하지 않습니다. IP 가 인쇄 되는 맨 아래 경로에서 계속 IP 주소 )를 증가시킵니다 . 편향이 왼쪽 코너에 랩과 프로그램이 종료 오른쪽에있는 IP.11<

다음으로 입력이 이루어지면 다음과 (A, B) = (1, 0)같은 상황이 발생합니다.

여기에 이미지 설명을 입력하십시오

그것은 본질적에서 것을 제외하고 이전과 동일 년대 #우리가 IP로 전환 1(녹색 경로), 그러나 이후 B입니다 0우리가 IP로 전환 0우리가 쳤을 때 #그것을 인쇄하는 두 번째 (지금 파란색 경로), 1이전을.

마지막으로 A = B = 1사례는 다음과 같습니다.

여기에 이미지 설명을 입력하십시오

이번에 #는 두 번째로도 현재 값이 그대로 유지 1되어 IP를 다시 변경하지 않습니다. 는 <그것을 반영하고 우리가 친 세 번째는 ?우리는 0을 얻는다. 따라서 IP는 왼쪽 하단으로 줄 바꿈 !하여 0을 인쇄하고 프로그램을 종료합니다.

이를 위해 총 9 바이트의 7 바이트 솔루션이 있습니다. 첫 번째 대안은 단순히 다음 1대신 사용 합니다 ).

?$@#1!<

그런 다음 진행중인 IP 스위칭의 양에 따라 두 가지 솔루션이 있습니다.

)?#_[!@    1?#_[!@

이것들은 실제로 제 생각을 불렀습니다. 흥미로운 부분은 IP 전환이 지연된 조건으로 사용될 수 있다는 것입니다. 언어의 IP 전환 규칙은 현재 IP가 전환이 일어나기 전에 다른 단계를 밟는 규칙입니다. 이 단계가 코너를 통과하는 경우 현재 값은 IP로 다시 전환 할 경우 IP가 어떤 분기를 계속할 것인지 결정합니다. 입력이이면 정확히 발생합니다 A = B = 1. 이것이 언어를 어떻게 설계했는지와 일치하지만, 스펙에 대한 이러한 의미를 결코 알지 못했기 때문에 언어가 새로운 트릭을 가르쳐 줄 때 좋습니다 : D.

그런 다음 IP 전환 량이 훨씬 더 나쁜 세 번째 솔루션이 있습니다 (비록 지연된 조건 적 효과를 사용하지는 않지만).

>?1]#!@

그리고 또 다른 것이 있습니다.

?$@#)!<

그리고 조건없는 IP 스위칭을 사용하고 대신 분기와 코너를 통해 모든 논리를 구현하는 다음과 같은 네 가지 솔루션이 있습니다.

]<?<@!)    ]<?<@!1    ]|?<@!)    ]|?<@!1

1111: 사실

 1 !
@ . .
 . .

끝을 위해 간단한 것을 얻었습니다 : edge to 1, print with !, terminate with @. :)

물론 한 가지 대안이 있습니다.

)!@

평소와 같이 Timwi의 HexagonyColorer로 생성 된 모든 제어 흐름 다이어그램 과 EsotericIDE로 메모리 다이어그램이 생성됩니다 .


9
Aaaaaand the tl; dr상은 ... (명쾌하게, 큰 대답과 잘 쓰여진 +1)
Bassdrop Cumberwubwubwub

4
이것이 더 이상 채팅에 참여하지 않는 이유입니다 ??
Optimizer

늦었지만 잔인한 힘 코드에 대한 링크를 추가 할 수 있습니까?
nedla2004

@ nedla2004 나는 보통 그것들을 지키지 않지만 항상 이 스크립트 의 수정 된 버전입니다 .
Martin Ender

40

APL, 22 20 18 바이트

참과 거짓 항목은 완전한 프로그램이며 나머지 14 개는 기능입니다. (Adám에게 감사합니다.)

0000 false              0 (complete program)
0001 p and q            ∧
0010 p and not q        >
0011 p                  ⊣
0100 not p and q        <
0101 q                  ⊢
0110 xor                ≠
0111 p or q             ∨
1000 not p and not q    ⍱
1001 eq                 =
1010 not q              ~⊢
1011 p or not q         ≥
1100 not p              ~⊣
1101 not p or q         ≤
1110 not p or not q     ⍲
1111 true               1 (complete program)

여기에서 시도하십시오.


1
atops의 멋진 사용 +1! 0000 및 1111을 trad-fns 0및 로 만들어 두 바이트를 절약 할 수 있습니다 1.
Adám

tfn을 허용하지만 첫 번째 줄을 세지 않는 합의가 있습니다. 이는 프로그램 이름 = filename의 파일을 프로그램 컨테이너로 사용하는 언어에서 파일 이름을 계산하지 않는 것에 해당합니다.
Adám


10
젤리 : 19 바이트 이것은 18 바이트입니다. 이것이 데니스능가 했다는 의미는 아닙니까 ? +1입니다.
NoOneIsHere6

29

최종 게임에서 체스 / 약국 체스 플레이어, 70 조각

그 도미노 답변에서 영감을 받아 다른 게임 에서이 명예를 가져야한다고 결정했습니다.

조각이 어떻게 움직이는 지에 대한 몇 가지 규칙을 취했습니다. 모든 상황에서 최적의 움직임을 연구하고 싶지는 않기 때문에 백인 움직임에 대한 규칙은 간단합니다. 우선 순위 순으로 홍보하지 않습니다. 같은 공간으로 이동할 수있는 공간이 두 개인 경우 둘 중 하나로 이동할 수 있습니다 (따라서 둘 이상의 사각형으로 이동할 수있는 경우 동일한 색상 임). 공격하는 조각이 잃어버린 조각보다 가치가 높으면 흰색은 캡처 된 경우에도 무언가로 캡처됩니다. 값은 다음과 같습니다.pawn<knight=bishop<rook<queen

입력은 루크의 존재 여부입니다. 루크는 중요한 경우에만 이름 A와 B로 레이블이 지정됩니다. 루크가 전환 될 때 게이트가 동일하게 작동하면 레이블이 지정되지 않습니다.

출력은 흰색 사각형이 끝나는 사각형의 색입니다. 흰색 = 1, 검은 색 = 0

이미지가 나오기 전에 이미지가 좋지 않은 것에 대해 사과하고 싶습니다. 나는 카메라를 안정적으로 유지하는 데별로 좋지 않습니다.

거짓, 4 :

그릇된

그리고 4 :

여기에 이미지 설명을 입력하십시오

A와 B가 아닌 5 (이것은 3으로 줄 수 있지만 지금 보드는 없습니다) :

여기에 이미지 설명을 입력하십시오

A, 4 :

여기에 이미지 설명을 입력하십시오

A와 B, 5가 아님 (저는 이것을 3으로 줄일 수 있지만 지금은 보드가 없습니다) :

여기에 이미지 설명을 입력하십시오

B, 4 :

여기에 이미지 설명을 입력하십시오

Xor, 5 (4로 만드는 방법을 알고 있지만 지금은 보드가 없습니다) :

여기에 이미지 설명을 입력하십시오

또는 4 :

여기에 이미지 설명을 입력하십시오

도 4 :

여기에 이미지 설명을 입력하십시오

Xnor, 5 (4로 만드는 방법을 알고 있지만 지금은 보드가 없습니다) :

여기에 이미지 설명을 입력하십시오

B가 아닌 4 :

여기에 이미지 설명을 입력하십시오

B는 A, 5를 의미합니다 (이것은 3으로 줄 수 있지만 지금 보드는 없습니다).

여기에 이미지 설명을 입력하십시오

A가 아님, 4 :

여기에 이미지 설명을 입력하십시오

A는 B, 5를 의미합니다 (이것은 3으로 줄 수 있지만 지금 보드는 없습니다).

여기에 이미지 설명을 입력하십시오

낸드, 4 :

여기에 이미지 설명을 입력하십시오

사실 4 :

여기에 이미지 설명을 입력하십시오


1
와우, 나는 체스에서의 프로그래밍이 가능하다는 것을 전혀 몰랐다.
Beta Decay

2
흠, 나는 현재 체스 판에 접근 할 수 없다. 아마도 A는 B / B가 폰 움직임이 킹스 운동에 미치는 영향 때문에 a / etc가 이해하기 어렵다는 것을 암시한다고 말할 것입니다. 아마도 그 두 가지에 대한 더 나은 설명을 추가해야합니다
Destructible Lemon

D : 내가 올바르게 이해하고 있다면, 보드와 피스 위치는 프로그램과 같습니다. 루크가 입력이므로 올바른 색상이면 사각형에 배치 할 수 있습니까?
NonlinearFruit

루크의 입력은 보드에 존재하는지 여부입니다. 대칭 게이트가 아닌 경우에는 a와 b로 표시됩니다 (다른 a와 b가 중요한 경우). 또한 나는 2 조각을 골프로 칠 수있는 방법을 깨달았지만 지금은 보드가 없습니다. 그림판을 사용해야합니다 :)
Destructible Lemon

당신의 "그리고"경우에, 오른쪽 루크를 제거하면, 왕이 아래로 (흰색으로) 움직이지 못하게하는 이유는 무엇입니까?
Nathan Merrill

27

젤리 , 19 바이트

0 0 0 0 ¤  1 byte  Empty niladic chain. Returns default argument 0.
0 0 0 1 &  1 byte  Bitwise AND.
0 0 1 0 >  1 byte  Greater than.
0 0 1 1    0 bytes Empty link. Returns left argument.
0 1 0 0 <  1 byte  Less than.
0 1 0 1 ị  1 byte  At-index (x,y -> [y][x]). Returns right argument.
0 1 1 0 ^  1 byte  Bitwise XOR.
0 1 1 1 |  1 byte  Bitwise OR.
1 0 0 0 |¬ 2 byte  Logical NOT of bitwise OR.
1 0 0 1 =  1 byte  Equals.
1 0 1 0 ¬} 2 bytes Logical NOT of right argument.
1 0 1 1 *  1 byte  Exponentiation.
1 1 0 0 ¬  1 byte  Logical NOT of left argument.
1 1 0 1 >¬ 2 bytes Logical NOT of greater than.
1 1 1 0 &¬ 2 bytes Logical NOT of bitwise AND.
1 1 1 1 !  1 byte  Factorial.

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


13
Factorial을 사용하여 0 또는 1을 1로 변환하는 것을 좋아합니다.
Neil

젤리 UTF-8입니까? 예 다음 경우 ¤¬2 바이트가 아닌 1이다
VI.

1
@Vi. Jelly는 UTF-8을 지원하지만 256 바이트 문자를 각각 단일 바이트로 인코딩하는 사용자 지정 코드 페이지도 지원합니다. 헤더 의 바이트 링크가이를 가리 킵니다.
Dennis

0 0 1 0 > 1 byte Greater than.두 번째 입력이 음수이면 이것이 실패하지 않습니까?
MD XF

@MFXF 우리가 지원하는 진실성과 허위 가치를 선택할 수 있습니다.
Dennis

24

NAND 로직 게이트-31 게이트

원래 일련 NAND 게이트 질문을 만든 사람 으로서이 게이트 를 사용하여 다른 논리 게이트 문제를 해결할 수있는 기회를 놓치지 못했습니다.

여기에 이미지 설명을 입력하십시오

이러한 각 다이어그램에서 상단 입력은 A이고 하단 입력은 B입니다.


5
@xnor는 그의 논리 게이트가 D를 만들기 위해 가장 많은 NAND 게이트를 요구하는 게이트임을 알기 위해 아플 수도 있습니다.
Joe Z.

최소한 Logisim을 사용하여 코드를 포맷 할 수 있습니까?
mbomb007

1
@ mbomb007 나중에 편집하겠습니다. Logisim에 익숙하지 않으므로 시간이 걸릴 수 있습니다.
Joe Z.

3
그러나 나는 필기를 더 좋아합니다.
Leaky Nun

1
또는
redstone을

22

비트 순환 태그 , 118 비트 = 14.75 바이트

비트 순환 태그는 아마도 가장 간단한 Turing-complete 언어 일 것입니다. 비트리스트로 구성된 프로그램 테이프와 데이터 테이프가 있습니다. 프로그램 테이프는 다음과 같이 데이터 테이프가 비워 질 때까지 주기적으로 해석됩니다.

  • 0: 데이터 테이프에서 첫 번째 비트를 삭제합니다.
  • 1x: 데이터 테이프의 첫 번째 비트가 1 인 경우 비트 x를 데이터 테이프에 추가하십시오 .

1과 2 개의 입력 비트로 데이터 테이프를 초기화합니다 (데이터 테이프가 완전히 0으로 구성된 경우 1을 생성 할 방법이 없기 때문에 1이 필요함). 마지막으로 삭제 된 데이터 비트를 게이트의 출력으로 사용합니다 .

  • 0,0,0,0 ( false) :001
  • 0,0,0,1 ( and) :1001001
  • 0,0,1,0 ( A and not B) :0110100
  • 0,0,1,1 ( A) :1001
  • 0,1,0,0 ( not A and B) :0100
  • 0,1,0,1 ( B) :0
  • 0,1,1,0 ( xor) :0110110010
  • 0,1,1,1 ( or) :0110
  • 1,0,0,0 ( nor) :1101001000
  • 1,0,0,1 ( xnor) :110101001100
  • 1,0,1,0 ( not B) :1100100
  • 1,0,1,1 ( B implies A) :110101101000
  • 1,1,0,0 ( not A) :11010000
  • 1,1,0,1 ( A implies B) :11010011001
  • 1,1,1,0 ( nand) :10110100100010
  • 1,1,1,1 ( true) :1100

축하합니다!
Leaky Nun

후행 1false필수입니까?
CalculatorFeline

@CalculatorFeline 예, 0테이프에 a를 추가하여 마지막에 삭제할 수 있습니다.
Anders Kaseorg

아 그 + 포장을 잊어 버렸습니다. 영리한!
CalculatorFeline

20

파이썬 2, 137 바이트

[].sort
min
int.__rshift__
round
range
{}.get
cmp
max
lambda a,b:a<1>b
lambda a,b:a==b
lambda a,b:b<1
pow
{0:1,1:0}.get
{0:1}.get
lambda a,b:a+b<2
slice

min(True,False)(또는 min(1,0)) 와 같은 입력을 받습니다. Truthy-Falsey의 올바른 가치를 갖기 만하면되는 출력을 크게 활용합니다. 가능하면 내장형을 사용하여 비용이 많이 드는 것을 피하십시오 lambda. 코드를 사용하여 작동하는 내장 기능을 검색했습니다.

내가 가장 좋아하는 것은 {0:1}.get손으로 생각한 것입니다. 사전 {0:1}은 키 0를 값에 매핑합니다 1. 이 get메서드는 키와 기본값을 사용하여 키와 일치하는 값을 출력하거나 해당 키가없는 경우 기본값을 출력합니다. 따라서 a를 출력하는 유일한 방법 0{0:1}.get(1,0)1와 기본값 이없는 as 0입니다. 다른 사전을 가진 다른 변형을 얻을 수 있지만 가장 짧은 변형이 있습니다.

built_in_names = list(__builtins__) 

object_names = ["int","(0)","(1)"] + \
["True","False","0L","1L","0j","1j"] + \
["str", "''", "'0'","'1'","'a'"] + \
["list", "[]", "[0]", "[1]","['']","[[]]","[{}]"] + \
["set","set()","{0}","{1}","{''}"] + \
["dict","{}","{0:0}","{0:1}","{1:0}","{1:1}","{0:0,1:0}", "{0:0,1:1}","{0:1,1:0}","{0:1,1:1}"] + \
["id"]

object_method_names = [object_name+"."+method_name 
for object_name in object_names 
for method_name in dir(eval(object_name))]

additional_func_names = [
"lambda a,b:0",
"lambda a,b:1",
"lambda a,b:a",
"lambda a,b:b",
"lambda a,b:b<1",
"lambda a,b:a<1",
"lambda a,b:a+b",
"lambda a,b:a*b",
"lambda a,b:a==b",
"lambda a,b:a-b",
"lambda a,b:a<=b",
"lambda a,b:a>=b", 
"lambda a,b:a>b", 
"lambda a,b:a<b", 
"lambda a,b:a<1>b", 
"lambda a,b:a+b<2"]

func_names = built_in_names + object_method_names + additional_func_names

t=True
f=False

cases = [(f,f),(f,t),(t,f),(t,t)]

def signature(func):
    table = [bool(func(x,y)) for x,y in cases]
    table_string = ''.join([str(int(val)) for val in table])
    return table_string

d={}

for func_name in func_names:
    try:
        func = eval(func_name) 
        result = signature(func)
        if result not in d or len(func_name)<len(d[result]):
            d[result]=func_name
    except:
        pass

total_length = sum(len(func) for sig,func in d.items())

print total_length
print

for sig in sorted(d):
    print d[sig]

int __lt__나 같은 내장 메소드를 사용할 수 없습니까 __eq__? 이것들은 바이트 수를 더욱 감소시킬 것이다 : int.__gt__대신에 lambda a,b:b<1, int.__eq__대신 lambda a,b:a==b
Gábor Fekete

@ GáborFekete 이것과 파이썬 2 int의 오프로드 비교 때문에 존재하지 않습니다 cmp. 나는 이것을 파이썬 3에서 시도하지 않았다.
xnor

아 지금 봤어!
Gábor Fekete

기능을 사용하여 4 바이트를 저장 not하기위한 0001, False- ideone
조나단 앨런

1
@JonathanAllan 영리하지만, not할 수 없기 때문에 함수의 요구 사항을 충족시키지 못한다고 생각합니다 f=not;f(3,4). not가정 된 함수 인수 는 입력으로 사용할 수있는 함수가 아닌 것처럼 3+작동하는 것처럼 튜플처럼 보이기 때문에 문자열 이 작동 합니다. 3+(4)3+4
xnor

20

이동 (게임), 33 석, 73 교차점

도미노와 체스를 사용할 수 있다면 이것입니다. 풀 19x19 Go 보드에서 너무 골프를 칠 수는 없습니다. 그래서 작은 직사각형 보드를 사용했습니다. 입력은 1과 2로 표시된 돌이 있는지 여부입니다. 출력은 검은 색의 승리 여부입니다. 그것은 지역 점수, 0.5 komi, 상황 슈퍼 코, 자살 없음을 사용합니다. 모두 검은 색으로 재생합니다. 일부에는 여러 가지 솔루션이 제공됩니다.

흰색 승리 (2, 1x5) :

➊━━━➋

1과 2 (3, 2x3) :

➊◯➋
┗┷┛

2가 아닌 1 (2, 1x5) :

╺➊━➁╸

1 (2, 1x5) :

╺➊➁━╸ 
╺➊━━➁
➀━➁━╸

1과 2가 아님 (2, 1x5) :

╺➋━➀╸

2 (2, 1x5) :

╺➋➀━╸

1 xor 2 (2, 2x3) :

➀┯➁
┗┷┛

1 또는 2 (2, 1x5) :

╺➊━➋╸
➀━━━➁

1 또는 2 (2, 1x4) :

➊━━➋
╺➀➁╸

1 = 2 (2, 1x7) :

╺━➀━➁━╸

2가 아님 (2, 1x3) :

➀➁╸

1 또는 2 (2, 1x4) :

➀➁━╸
➀━➁╸
╺➊➁╸
➋➊━╸
➋━➊╸

1이 아님 (2, 1x3)

➁➀╸

1 또는 2가 아님 (2, 1x4) :

➁➀━╸

1 nand 2 (2, 1x3) :

➊━➋

검은 승리 (2, 1x3) :

➊➋╸
➀━➁
➊━➁

이 페이지가 도움이되었습니다 : http://www.mathpuzzle.com/go.html

누군가 1x9 보드에서 1과 2에 대한 2 석재 솔루션을 찾을 수 있습니다 ...


1
자살에 대한 규칙은 무엇입니까? 허용되지 않습니까? 한쪽이 보드 전체를 채우면 어떻게됩니까? 자살로 간주됩니까?
Martin Ender

@MartinEnder 허용되지 않습니다. 그렇습니다. 자살로 간주됩니다.
jimmy23013

1x7 솔루션이 잘못되었습니다. 내가 고치려고 노력하고 있습니다 ...
jimmy23013

15

자바 스크립트 ES6, 124 바이트

a=>0
Math.min
parseInt
a=>a
a=>b=>a<b
a=>b=>b
a=>b=>a^b
Math.max
a=>b=>~a&~b
a=>b=>a==b
a=>b=>~b
Math.pow
a=>~a
a=>b=>a<=b
a=>b=>~a|~b
a=>1

나는 지금 람다를 심각하게 싫어한다.


1
내가 어떤 프로그램과 일부 기능을 쓸 수있어 있다면 ... 난 당신이 바꿀 수 있다고 생각 a=>b=>0a=>0하고 그것을 호출 문법이라고 (a=>0)(a,b)만 4 개 항목을.
jimmy23013

네, 고마워요!
Mama Fun Roll

2
Math.min대신에 a=>b=>a&b. Math.max대신에 a=>b=>a|b. Math.pow대신에 a=>b=>a>=b.
Conor O'Brien

1
또한 NaN은 거짓이기 때문에 parseInt대신에 할 수 있습니다 a=>b=>a>b.
Conor O'Brien

1
@algmyr !NaN=> true, !!NaN=>false
Mama Fun Roll

14

망막 , 62 39 바이트

@MartinEnder 덕분에 23 바이트 !

0000 false              1 byte : 2
0001 p and q            2 bytes: 11
0010 p and not q        2 bytes: 10
0011 p                  2 bytes: ^1
0100 not p and q        2 bytes: 01
0101 q                  2 bytes: 1$
0110 xor                5 bytes: 01|10
0111 p or q             1 byte : 1
1000 not p and not q    2 bytes: 00
1001 xnor               5 bytes: (.)\1
1010 not q              2 bytes: 0$
1011 p or not q         5 bytes: ^1|0$
1100 not p              2 bytes: ^0
1101 not p or q         5 bytes: ^0|1$
1110 not p or not q     1 byte : 0
1111 true               0 bytes: 

로 입력을 PQ받습니다.

0~ 사이의 정수를 출력합니다 3. 0거짓이고, 다른 사람들은 진실합니다.

설명

그들은 모두 정규식 입니다.

예를 들어, 또는 01|10와만 일치 합니다.0110

년은 0000, 2입력에 없을 것, 그래서 일치하지 않습니다.

에서은 1111, 그것은 거기에 빈 문자열을 일치합니다 4.


^1|0$1 개의 문자열 만 일치해야합니다. 무슨 일이야?
CalculatorFeline

@CalculatorFeline [ 1입력 시작시] 또는 [ 0입력 종료시 ] 와 일치 합니다. ... 너무 그걸 얻기 위해 나에게 분을 툭
ETHproductions

우선 순위, 여러분 ....
Leaky Nun

^1|0$보다 읽기 어렵다고 생각 1.|.0합니다.
전체적으로

10

스택 고양이 , 67 + 64 = 131 바이트

+64는 -nm각 프로그램에 플래그를 적용하는 것 입니다. -n는 숫자 I / O를 나타내며 -m마지막 문자에서 소스 코드를 미러링합니다. 모든 제출에는 기술적으로 이러한 플래그가 필요하지 않지만 일관성과 단순성을 위해 동일한 방식으로 점수를 매 깁니다.

-2 -2 -3 -3     !I                0 0 0 0     <I!+
-4 -4 -4  1     |!T*I             0 0 0 1     [>I=I_
-4 -4  3 -2     *I*_              0 0 1 0     :I*=I:
-2 -2  3  3     T*I               0 0 1 1     [<!>X
-2  1 -2 -2     _*T*I             0 1 0 0     *|!TI:
-2  1 -3  1     !-|_I             0 1 0 1     <!I!>X
-2  3  3 -2     ^T*I              0 1 1 0     ^:]<_I
-2  3  3  3     -_T*I             0 1 1 1     *I<-I!
 2 -3 -3 -3     -*|_I             1 0 0 0     ^{!:}I_
 2 -3 -3  2     _|*I              1 0 0 1     _|[<I!:
 1 -2  1 -2     :]I*:             1 0 1 0     _!:|]X
 1 -2  1  1     *I\<X             1 0 1 1     *>I>!I
 2  2 -3 -3     -*I               1 1 0 0     I^:!
 2  2 -3  2     _*I_              1 1 0 1     |I|^:!
 1  2  2 -1     |!:^I             1 1 1 0     -I*<*I
 1  1  1  1     *<X               1 1 1 1     +I+

()Stack Cats에서는 요소가 양수인지 아닌지 (예 : 0 또는 음수) 여부를 확인하므로 각각 진실 / 거짓에 사용합니다. 두 번째 열은 단지 관심을 끌기위한 것이며, 0/ 1s를 출력으로 사용하여 최상의 게이트를 나열합니다 (총 점수 90).

입력은 STDIN을 통해 구분 기호로 구분 된 비트입니다. 온라인으로 사용해보십시오!


Stack Cats는 뒤집을 수있는 난해한 언어로 프로그램에 반사 대칭이 있습니다. 코드 조각 f(예 :)이 주어지면 >[[(!-)/, 거울 이미지 (예 \(-!)]]<)는 역을 계산합니다 f^-1. 이와 같이, 컴퓨팅, 심지어 길이 프로그램 (또는 무한 루프에 박히) 아무것도하지 않고, 단지 상기 비 단순 프로그램은 홀수 길이를 갖는 f g f^-1위치를 g중심 연산자이다.

소스 코드의 절반은 항상 중복되므로 생략 할 수 있으며 -m플래그를 사용 하여 코드를 실행 하면 실제 소스 코드를 검색하기 위해 소스 코드가 마지막 문자 위에 미러링되어야 함을 나타냅니다. 예를 들어, 프로그램 *<X은 실제로 *<X>*대칭입니다.

Stack Cats에서의 골프는 직관적이지 않기 때문에 위의 프로그램은 무차별적인 힘으로 찾아야했습니다. 대부분은 놀라 울 정도로 복잡하지만 시간이 있으면 몇 가지를 설명하고이 답변에 추가하겠습니다. 현재 0/ 1버전에 대한 설명과 대안 은 Github 저장소 에서 확인할 수 있습니다 .


1
Note that the +64 is from applying the -nm flags to each program.3 * 16 = 48 또는 2 * 16 = 32, 어느 쪽이든 64는 hai입니다
cat

@cat 공간도 계산해야하므로 플래그는 프로그램 당 4입니다.
FryAmTheEggman 2016 년


1 년이 지났습니다. 아직 시간 있어요?
CalculatorFeline

8

하스켈, 78 76 75 바이트

  1. _#_=2<1
  2. &&
  3. >
  4. pure
  5. <
  6. _#b=b
  7. /=
  8. ||
  9. (not.).max
  10. ==
  11. _#b=not b
  12. >=
  13. a#_=not a
  14. <=
  15. (not.).min
  16. _#_=1<2

편집 : @cole 덕분에 -1 바이트.


난 그냥 "친구, _#_표준 운영자가 아닙니다!" 그리고 나는 깨달았다 ... 잘했다.
MathematicalOrchid

4 수pure

@cole : 감사합니다. 와우, 2015 년 pure에 도입 Prelude되었으므로이 도전 당시에 사용할 수있었습니다.
니미

6

Brachylog , 36 34 바이트

0000 false              \     Backtrack (always false)
0001 p and q            1.    Unify input and output with 1
0010 p and not q        >.    Input > Output
0011 p                  1     Unify input with 1
0100 not p and q        <.    Input < Output
0101 q                  ,1.   Unify output with 1
0110 xor                '.    Input and output cannot unify
0111 p or q             1;1.  Unify input with 1 or unify output with 1
1000 not p and not q    0.    Unify input and output with 0
1001 eq                 .     Unify input with output
1010 not q              ,0.   Unify output with 0
1011 p or not q         >=.   Input >= Output
1100 not p              0     Unify input with 0
1101 not p or q         <=.   Input <= Output
1110 not p or not q     0;0.  Unify input with 0 or unify output with 0
1111 true                     Empty program (always true)

이것은 0잘못된 가치와 1진실 된 가치로 기대합니다. 반환 true또는 false. p는 Input이고 q는 Output입니다.


출력은 어떻게 입력합니까?
Leaky Nun

1
@LeakyNun 입력과 같습니다. 쿼리하는 기본 술어에는 호출 InputOutput규칙에 따라 두 개의 인수가 있지만 값을 둘 다로 설정하거나 둘 다에서 값을 리턴 할 수 있습니다.
치명적인

1
이 작업에 가장 적합한 도구는 다음과 같습니다 .P
Conor O'Brien

6

프롤로그, 147145 바이트

@SQB 덕분에 2 바이트 획득

a(a,a).       % 0000 false
b(1,1).       % 0001 P and Q
c(1,0).       % 0010 P and not Q
d(1,_).       % 0011 P
e(0,1).       % 0100 not P and Q
f(_,1).       % 0101 Q
g(P,Q):-P\=Q. % 0110 P xor Q
h(1,_).       % 0111 P or Q
h(0,1).
i(0,0).       % 1000 not P and not Q
j(P,P).       % 1001 P == Q                 
k(_,0).       % 1010 not Q
m(P,Q):-P>=Q. % 1011 P or not Q
n(0,_).       % 1100 not P              
r(P,Q):-P=<Q. % 1101 not P or Q         
s(0,_).       % 1110 not P or not Q
s(1,0).
t(_,_).       % 1111 true

검색어 x(P,Q).x해당하는 문자와 존재 P하고 Q0 또는 1로 설정
반환 true또는 false.

테스트를 포함한 SWISH 예 - runTest.실행을 시작하십시오.


그것은 a(2,2).거짓을 지원합니까 ?
jimmy23013

2가 거짓이라고 가정하면 가능할 것 같습니다. 그것이 허용되는지 확실하지 않습니다.
치명적인

@ jimmy23013 사실, a(a,a).(또는 다른 문자)도 작동 a하며 진실성에 대한 수용 가능한 입력이 아니므로 좋습니다. 제안 해 주셔서 감사합니다.
치명적인

6

NTFJ, 86 바이트

0000 false              ~
0001 p and q            |:|
0010 p and not q        :||:|
0011 p                  $
0100 not p and q        #{:||:|
0101 q                  #{$
0110 xor                :#{:#{:||#}:|||
0111 p or q             :|#{:||
1000 not p and not q    :|#{:||:|
1001 eq                 :#{:#{:||#}:|||:|
1010 not q              #{$:|
1011 p or not q         #{:||
1100 not p              $:|
1101 not p or q         :||
1110 not p or not q     |
1111 true               #

여기 사용해보십시오! 그러나 먼저 아래를 읽으십시오.

입력은 스택에 암시 적입니다. 결과는 쌓입니다. 0과 1을 나타내 거나 출력 *하려면 16 바이트 ( 각 끝에 하나씩)를 추가하십시오 . 또는 인쇄 하려면 160 바이트를 추가하십시오 . ( 각각에 넣기 .)0x000x0101~~##~~~#{@*

NTFJ의 유일한 이항 연산자는 NAND이므로 이들 각각은 NAND 형식으로 작성됩니다.

그들 각각을 살펴 보자.

0 : 거짓

~

~거짓 비트를 나타냅니다. 충분히 간단합니다. 입력은 스택의 맨 아래에 암시 적이므로 맨 위에 남습니다.

1 : p와 q

|:|

NTFJ는 스택에서 작동합니다. :복제 명령입니다. 그 관찰 p and qnot (p nand q)저것 not q = q nand q.

Command | Stack
        | p q
   |    | (p nand q)
   :    | (p nand q) (p nand q)
   |    | (p nand q) nand (p nand q)
        | => not (p nand q)
        | => p and q

(참고하고, :|라고 할 수있는 부정 하고 |:|말할 수있다 )

2 : p와 q가 아님

:||:|

이것은 단지 부정 :|과 연결 이라는 것을 관찰하십시오 |:|.

Command | Stack
        | p q
  :|    | p (not q)
  |:|   | p and (not q)

3 : p

$

$스택에서 항목을 팝합니다. 그래 ... 그래

4 : p와 q가 아님

#{:||:|

이것은 #{시작 부분을 제외하고 2와 동일 합니다. #1 (참 비트)을 누르고 {스택을 왼쪽으로 한 번 회전합니다. 충분히 간단합니다.

5 : q

#{$

왼쪽으로 한 번 회전하고 떨어 뜨립니다.

6 : xor

:#{:#{:||#}:|||

관찰 :

p xor q = (p and (not q)) or ((not p) and q)                ; by experimentation (trust me)
        = (not ((not p) nand q)) or (not (p nand (not q)))  ; by definition of nand
        = not (((not p) nand q) and (p nand (not q)))       ; by De Morgan's laws
        = ((not p) nand q) nand (p nand (not q))            ; by definition of nand

그러나 스택을 완전히 복제 할 방법은 없습니다. 그래서 우리는 각을 가지고해야 할거야 p, q정상에 그것을 복제.

Command | Stack
        | p q
   :    | p q q
  #{    | q q p
   :    | q q p p
  #{    | q p p q
  :|    | q p p (not q)
   |    | q p (p nand (not q))
  #}    | (p nand (not q)) q p
  :|    | (p nand (not q)) q (not p)
   |    | (p nand (not q)) (q nand (not p))
   |    | (p nand (not q)) nand (q nand (not p))

따라서 xor가 있습니다.

7 : p 또는 q

:|#{:||

맨을 무효화하고, 맨 아래로 가져오고, 부정하고, 함께 묶습니다. 기본적으로 p or q = (not p) nand (not q).

8 : p가 아닌 q

:|#{:||:|

이것은 단순히 7의 부정입니다.

9 : EQ

:#{:#{:||#}:|||:|

이것은 xnor 이거나 xor가 아닙니다. 다시 간단합니다.

10 : 아님

#{$:|

5. 부정

11 : p 또는 q

#{:||

Negate p, nand. (not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws).

12 : P가 아님

$:|

버리고 멈추고 부정하십시오.

13 : p 또는 q가 아님

:||

데 모건의 법칙으로 다시 하루를 구할 수 있습니다! 11과 동일한 프로세스로 q대신 대신 부정 합니다 p.

14 : p가 아닌 q

|

이것은 단지 흉내 낸 낸드입니다.

15 : 사실

#

# 진정한 비트입니다.


그냥 왜 ...> _>
Rɪᴋᴇʀ

idk 정확히 어떻게 작동하지만 꽤 멋진 것 같습니다 +1
Downgoat

5는 왜 빈 프로그램이 :|아닌가?
Joffan

6

마인 크래프트, 89 블록

다음 사진에서 모두 파란색 블록은 입력 A 용이고 주황색 블록은 입력 B 용입니다.

16. TRUE 게이트-1 블록

여기에 이미지 설명을 입력하십시오

15. NAND 게이트-1x2x3 = 6 블록

여기에 이미지 설명을 입력하십시오

14. A => B-1x2x3 = 6 블록여기에 이미지 설명을 입력하십시오

13. NOT A-2 블록 여기에 이미지 설명을 입력하십시오

12. B => A-1x2x3 = 6 블록여기에 이미지 설명을 입력하십시오

11. NOT B-2 블록 여기에 이미지 설명을 입력하십시오

10. XNOR-1x3x4 = 12 블록 여기에 이미지 설명을 입력하십시오

9. NOR-1x2x3 = 6 블록여기에 이미지 설명을 입력하십시오

8. OR-1 블록 여기에 이미지 설명을 입력하십시오

7. XOR-1x3x4 = 12 블록 여기에 이미지 설명을 입력하십시오

6. B-1 블록 여기에 이미지 설명을 입력하십시오

5.! A & B-1x2x5 = 10 블록 여기에 이미지 설명을 입력하십시오

4. A-1 블록 여기에 이미지 설명을 입력하십시오

3. A &! B-1x2x5 = 10 블록 여기에 이미지 설명을 입력하십시오

2. AND-2x2x3 = 12 블록 여기에 이미지 설명을 입력하십시오

1. FALSE-1 블록 여기에 이미지 설명을 입력하십시오


2
두 번째 이미지부터 마지막 ​​이미지 (AND)까지 횃불을 블록 뒷면 (즉, 레버 반대쪽)에 올려 6 개의 블록을 절약 할 수 있습니다. 중간에 토치를 교환하여 먼지를 제거하고 상단의 먼지를 제거하여 1x2x3 = 6 블록으로 만듭니다.
Luca H

5

수학, 67 바이트

0>1&
And
#&&!#2&
#&
!#&&#2&
#2&
Xor
Or
Nor
Xnor
!#2&
#||!#2&
!#&
!#||#2&
Nand
1>0&

이들 각각은 함수로 평가되므로 다음과 같이 사용할 수 있습니다.

#&&!#2&[True, False]
Xor[True, False]

아, Mathematica에서 정수만 진실 / 거짓이라면, 그 4 개의 긴 정수는 상당히 단축되었을 수 있습니다.


정수가 진실 / 거짓이 아닌 경우 if 문에 정수를 넣으면 어떻게됩니까?
코너 오브라이언

3
@ CᴏɴᴏʀO'Bʀɪᴇɴ 그것은 평가되지 않은 채 남아 있습니다.
Martin Ender 2016 년

5

MATL, 34 23 바이트

주문을 받았으면 좋겠다! 0은 거짓, 0이 아닌 것은 진실입니다. 각 함수는 두 개의 암시 적 입력을 사용합니다 (일부 입력은 무시할 수 있음). 첫 번째 입력은을이고, 두 번째는 B.이다 입력 할 수 0/ 1허 / 또는 대 T/ F.

테스트 사례 3에 대한 TryItOnline 예제 는 다음과 같습니다 .

사용하여 4 바이트를 저장 *하기위한 and사용하여 다른 4, 및 >/가 <대신 ~wY&/ w~Y&나는 데니스 답을 본 후에!

1.  0,0,0,0 0 (ignores input, just returns a zero)
2.  0,0,0,1 * (and)
3.  0,0,1,0 < (not-A and B)
4.  0,0,1,1 D (A)
5.  0,1,0,0 > (not-B and A)
6.  0,1,0,1 xD (discard A, display B)
7.  0,1,1,0 Y~ (xor)
8.  0,1,1,1 + (or)
9.  1,0,0,0 +~ (not-or)
10. 1,0,0,1 = (A=B)
11. 1,0,1,0 x~ (not-B)
12. 1,0,1,1 <~ (not-B or A)
13. 1,1,0,0 ~ (not-A)
14. 1,1,0,1 ~+ (not-A or B)
15. 1,1,1,0 *~ (not(A and B))
16. 1,1,1,1 1 (just returns 1)

10
여섯 번째는 재미 있다고 생각합니다.
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ 6 번이 최고예요. 12 번도 좋아요! xD!
David

"같지 않은"기능이 없습니까?
Leaky Nun

아니오 (적어도 그렇게 생각하지 않습니다)
David

2
@David 저는 7 번을 다음으로 대체 할 수 있다고 생각합니다.-
Luis Mendo

5

dc, 37 바이트

dc( "데스크 계산기")는 스택 기반 포스트 픽스 계산기 인 표준 유닉스 명령입니다. 비트 연산이없고 비교 연산자는 매크로를 실행할 때만 사용할 수 있습니다 (바이트 가치가 없음). 정수 부분은 그 중 일부를 구성합니다.

이 스크립트 는 스택에서 예상 01값을 가져오고 결과를 스택에 그대로 둡니다.

0,0,0,0 (false)              0
0,0,0,1 (and)                *         a*b
0,0,1,0                      -1+2/     (a-b+1)/2
0,0,1,1 (A)                  r         reverse a, b: a now on top
0,1,0,0                      -1-2/     (a-b-1)/2
0,1,0,1 (B)                            (0 bytes) do nothing: b on top
0,1,1,0 (xor)                -         a-b
0,1,1,1 (or)                 +         a+b                  
1,0,0,0 (nor)                +v1-      sqrt(a+b) -1
1,0,0,1 (xnor)               +1-       a+b-1
1,0,1,0 (not B)              1-        b-1
1,0,1,1 (if B then A)        -1+       a-b+1
1,1,0,0 (not A)              r1-       a-1
1,1,0,1 (if A then B)        -1-       a-b-1            
1,1,1,0 (nand)               *1-       a*b - 1
1,1,1,1 (true)               1

5

미로 , 85 바이트

2 바이트를 절약 한 Sp3000에 감사합니다.

!@
??&!@
??~&!@
?!@
?~?&!@
??!@
??$!@
??|!@
??|#$!@
??$#$!@
?#?$!@
?#?$|!@
?#$!@
?#$?|!@
??&#$!@
1!@

이 모든 프로그램은 두 개의 정수 0또는 1STDIN (숫자가 아닌 구분 기호 사용)을 읽고 STDOUT 으로 0또는 1STDOUT으로 결과를 인쇄하는 전체 프로그램 입니다.

온라인으로 사용해보십시오! (테스트 스위트가 아니므로 다른 프로그램과 입력을 수동으로 시도해야합니다.)

설명에 관해서는, 이것들은 모두 간단합니다. 모든 프로그램은 선형이며 사용중인 명령은 다음을 수행합니다.

?   Read integer from STDIN and push.
!   Pop integer and write to STDOUT.
@   Terminate program.
&   Bitwise AND of top two stack items.
|   Bitwise OR of top two stack items.
$   Bitwise XOR of top two stack items.
~   Bitwise NOT of top stack item.
#   Push stack depth (which is always 1 when I use it in the above programs).
1   On an empty stack, this pushes 1.

내가 사용하는 #것은 항상와 결합 $하여 계산 하는 데 사용됩니다 . 즉 XOR 1논리적 부정을 위해 사용됩니다. ~이후 &에 결과 -1또는 에서 원하지 않는 비트가 모두 삭제 되므로 몇 가지 경우에만 대신 사용할 수있었습니다 -2.


5

IA-32 기계 코드, 63 바이트

분해와 함께 코드의 16 진수 덤프 :

0000  33 c0     xor eax, eax;
      c3        ret;

0001  91        xchg eax, ecx;
      23 c2     and eax, edx;
      c3        ret;

0010  3b d1     cmp edx, ecx;
      d6        _emit 0xd6;
      c3        ret;

0011  91        xchg eax, ecx;
      c3        ret;

0100  3b ca     cmp ecx, edx;
      d6        _emit 0xd6;
      c3        ret;

0101  92        xchg eax, edx;
      c3        ret;

0110  91        xchg eax, ecx;
      33 c2     xor eax, edx;
      c3        ret;

0111  8d 04 11  lea eax, [ecx + edx];
      c3        ret;

1000  91        xchg eax, ecx; // code provided by l4m2
      09 d0     or eax, edx;
      48        dec eax;
      c3        ret;

1001  3b ca     cmp ecx, edx;
      0f 94 c0  sete al;
      c3        ret;

1010  92        xchg eax, edx;
      48        dec eax;
      c3        ret;

1011  39 d1     cmp ecx, edx; // code provided by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1100  91        xchg eax, ecx;
      48        dec eax;
      c3        ret;

1101  3b d1     cmp edx, ecx; // code inspired by l4m2
      d6        _emit 0xd6;
      40        inc aex;
      c3        ret;

1110  8d 44 11 fe   lea eax, [ecx+edx-2] // code provided by l4m2
      c3        ret;

1111  91        xchg eax, ecx;
      40        inc eax;
      c3        ret;

표준 코딩 규칙 인 input in ecxedx, output in 과 같은 표준 코딩 규칙을 사용하므로 코드가 예상보다 깁니다 al. 이것은 C로 표현 될 수있다

unsigned char __fastcall func(int, int);

MS Visual Studio가 문서화되지 않은 SALCopcode를 이해하지 못하는 것 같으므로 이름 대신 해당 코드를 사용해야했습니다.

덕분에 당신은 l4m2 코드 샘플 중 일부를 개선!


1
1110 8D4411FE LEA EAX, [ECX+EDX-2]
l4m2

5

C 34 바이트

#define g(n,a,b)((n-1)>>3-b-2*a)&1

n은 사용할 함수 번호이지만 거부 될 것이라고 생각하므로 다른 것을 제안합니다.

C 244 바이트 (메모리 사용)

typedef int z[2][2];
z a={0,0,0,0};
z b={0,0,0,1};
z c={0,0,1,0};
z d={0,0,1,1};
z e={0,1,0,0};
z f={0,1,0,1};
z g={0,1,1,0};
z h={0,1,1,1};
z i={1,0,0,0};
z j={1,0,0,1};
z k={1,0,1,0};
z l={1,0,1,1};
z m={1,1,0,0};
z n={1,1,0,1};
z o={1,1,1,0};
z p={1,1,1,1};

이중 인덱스 배열을 사용합니다. n[0][1]이다(A implies B)(0,1)

138 바이트

방금 Forth를 배웠습니다. gforth에서도 실행되는 Ansi Forth와 호환된다고 가정합니다.

: z create dup , 1+ does> @ -rot 3 swap - swap 2* - rshift 1 and ; 
0 
z a z b z c z d z e z f z g z h z i z j z k z l z m z n z o z p 
drop

기능 z는 제공된 이름으로 새로운 기능을 생성 한 다음 로직 게이트 번호를 스택 상단에서 새로운 기능 주소로 넣습니다. 다음 선언을 위해 스택에 다음 (n + 1) 논리 게이트 함수를 남겨 둡니다.

당신은 그것을 테스트 할 수 있습니다 :
그리고 AB

0 0 b . cr 
0 1 b . cr
1 0 b . cr 
1 1 b . cr   

스택 "cr"의 "."인쇄 상단은 캐리지 리턴입니다.


각 기능에 대한 코드 스 니펫 만 제공하면됩니다.
CalculatorFeline

4

C, 268 바이트

#define c(a,b)0      // 0000 
#define d(a,b)a&b    // 0001 
#define e(a,b)a>b    // 0010 
#define f(a,b)a      // 0011 
#define g(a,b)a<b    // 0100 
#define h(a,b)b      // 0101 
#define i(a,b)a^b    // 0110 
#define j(a,b)a|b    // 0111 
#define k(a,b)!b>a   // 1000 
#define l(a,b)a==b   // 1001 
#define m(a,b)!b     // 1010 
#define n(a,b)!b|a   // 1011 
#define o(a,b)!a     // 1100 
#define p(a,b)!a|b   // 1101 
#define q(a,b)!b|!a  // 1110 
#define r(a,b)1      // 1111 

매크로는 기능보다 짧게 보입니다.


4

Brian & Chuck , 183 바이트

4 바이트를 절약 한 Sp3000에 감사합니다.

일부 프로그램에는 인쇄 할 수없는 문자가 포함되어 있습니다. 특히, 모든 \x01것을 <SOH>(0x01) 제어 문자 로 바꿔야 합니다.

0000
?
#>.
0001
,-?,-?>?\x01
#}>.
0010
,-?,?>?\x01
#}>.
0011
,?\x01+?
#>.
0100
,?,-?>?\x01
#}>.
0101
,,?\x01+?
#>.
0110
,?>},?>?_\x01
#}+{>?_}>.
0111
,\x01?,?>?
#{>.
1000
,?,?>?\x01
#}>.
1001
,-?>},?>?_\x01
#}+{>>?_}>.
1010
,,-?\x01+?
#>.
1011
,\x01?,-?>?
#{>.
1100
,-?\x01+?
#>.
1101
,\x01-?,?>?
#{>.
1110
,\x01-?,-?>?
#{>.
1111
?
#>+.

입력 및 출력은 바이트 값을 사용 하므로 입력은 두 개의 0x00 또는 0x01 바이트 (구분자 제외) 여야하며 출력은 그러한 바이트 중 하나입니다. 제어 흐름 명령 만이 ?0을 거짓으로 간주하고 다른 모든 것은 진실로 간주 하기 때문에 이것은 실제로 B & C에 대한 진실 / 거짓에 대한 가장 합리적인 정의입니다 .

설명

먼저 빠른 B & C 입문서 :

  • 모든 프로그램은 두 개의 Brainfuck과 같은 인스턴스로 구성되며 각 인스턴스는 자체 라인에 작성됩니다. 우리는 첫번째 브라이언 과 두번째를 이라고 부릅니다 . Brian에서 실행이 시작됩니다.
  • 각 프로그램의 테이프는 다른 프로그램의 소스 코드이고 각 프로그램의 명령 포인터는 다른 프로그램의 테이프 헤드입니다.
  • Brian만이 ,(입력 바이트) 명령을 사용할 수 있고 Chuck만이 .(출력 바이트) 명령을 사용할 수 있습니다 .
  • Brainfuck의 []루프가 존재하지 않습니다. 대신, ?테이프 헤드 아래의 현재 값이 0이 아닌 경우 다른 인스턴스로 제어를 전환하는 제어 흐름 만 있습니다 .
  • 이외에도 >하고 <, 거기 {}본질적 브레인 퍽 단편에 상당 [<]하고 [>]이들은 그 방향으로 다음의 제로 위치에 테이프 헤드를 이동, 즉,. 가장 큰 차이점은 {테이프의 값에 관계없이 테이프의 왼쪽 끝에서 중지 할 수 있다는 것입니다.
  • 편의를 위해, 어떤 _(이 잡을하기 위해 사소 프로그램에 매우 유용으로 소스 코드들 널 바이트로 대체 {하고 }).

모든 프로그램에서 척의 테이프는로 시작합니다 #. 이것은 실제로 무엇이든 될 수 있습니다. ?테이프 헤드가 실행을 시작하기 전에 하나의 셀을 이동하도록 작동합니다 (따라서 유효한 명령 일 경우 조건 자체는 실행되지 않습니다). 따라서 코드의 첫 번째 척 셀을 사용할 수 없습니다.

5 가지 종류의 프로그램이 있으며, 나중에 자세히 설명하겠습니다. 지금은 복잡성을 높이기 위해 여기에 나열하고 있습니다.

0000, 1111: 상수 함수

?
#>.
?
#>+.

이것들은 매우 간단합니다. 무조건 척으로 전환합니다. 척은 테이프 헤드를 사용하지 않는 셀로 오른쪽으로 이동하여 직접 인쇄하거나 먼저 증가시켜 인쇄 1합니다.

0011, 0101, 1010, 1100: 함수는 하나 개의 입력에 따라

,?\x01+?
#>.
,,?\x01+?
#>.
,,-?\x01+?
#>.
,-?\x01+?
#>.

우리가 시작 여부에 따라 ,또는 ,,우리와 협력하고 AB. 첫 번째 예를 살펴 보겠습니다 0011(예 :) A. 값을 읽은 후 해당 값 ?의 조건부로 사용 합니다. 인 경우 A = 1테이프 헤드를 오른쪽으로 이동하고 문자 그대로 포함 된 1바이트를 인쇄하는 척으로 전환합니다 . 그렇지 않으면 제어는 Brian에 남아 있습니다. 여기서 1 바이트는 작동하지 않습니다. 그런 다음 입력을 잘 증가시켜 +0이 아닌지 확인한 다음 을 사용하여 척으로 전환하십시오 ?. 이번에 >는 사용하지 않는 셀을 오른쪽으로 이동 한 다음로 인쇄합니다 0.

값 중 하나를 부정하기 위해 간단히 값을 줄입니다 -. 이것은 변 1으로 0하고 0으로 -1늘어나는만큼 비제 따라서 truthy 인 ?관한 것이다.

0001, 0010, 0100, 1000하나 개 truthy 결과 바이너리 기능

,-?,-?>?\x01
#}>.
,-?,?>?\x01
#}>.
,?,-?>?\x01
#}>.
,?,?>?\x01
#}>.

이것은 두 가지 입력으로 작업하기 위해 이전 아이디어의 확장입니다. 1000(NOR) 의 예를 보자 . 로 두 입력을 (잠재적으로) 읽습니다 ,?. 그 중 하나 인 경우, 1상기 ?척에 스위치. 그는 테이프 헤드를 }(Brian의 코드 다음의 빈 셀로) 끝으로 이동하고 다른 셀을 >(여전히 0으로) 이동하여로 인쇄합니다 ..

그러나 두 입력이 모두 0이면 제어는 여전히 Brian을 사용합니다. >그런 다음 Chuck with로 전환 할 }때이 명령 실행 되지 않도록 테이프 헤드를 움직 입니다 ?. 이제 Chuck이하는 일은 -cell >.로만 이동하여 1인쇄합니다.

필요에 따라 입력 중 하나 또는 둘 다를 무효화하여 다른 세 가지 기능을 쉽게 얻을 수 있습니다.

0111, 1011, 1101, 1110세 truthy 결과 바이너리 기능

,\x01?,?>?
#{>.
,\x01?,-?>?
#{>.
,\x01-?,?>?
#{>.
,\x01-?,-?>?
#{>.

결과 를 부정하기 위해 이전 아이디어를 약간 수정했습니다 (즉, 0모든 Brian을 통과했을 때 인쇄 1). 0111(OR)을 예로 들어 봅시다 . 임베디드 1바이트는 no-op이므로 여전히로 시작합니다 ,?,?. 두 입력 중 하나가 1Chuck로 전환되면 테이프 헤드를 시작으로 다시 이동합니다 {. >.테이프 헤드를 해당 1바이트 로 이동하여 인쇄합니다.

두 입력이 모두 0이면 Brian과 함께 유지하면서 테이프 헤드를 위로 {이동하여 건너 뛴 다음 척으로 전환하십시오. 그가 >.이번에 실행 하면 Brian의 코드 뒤에 빈 셀로 이동하여를 인쇄합니다 0.

다시, 우리는 하나 또는 두 개의 입력을 부정함으로써 다른 기능들을 쉽게 얻을 수 있습니다.

0110, 1001: 두 가지 진실한 결과를 가진 이진 함수

,?>},?>?_\x01
#}+{>?_}>.
,-?>},?>?_\x01
#}+{>>?_}>.

이것은 조금 까다 롭습니다. 이전 기능은 단락 될 수 있기 때문에 합리적으로 간단 했습니다. 첫 번째 입력의 값으로 출력을 결정할 수 있으며 그렇지 않은 경우 다른 입력을 봅니다. 이 두 기능의 경우 항상 두 입력을 모두 살펴 봐야합니다.

기본적인 아이디어는 두 번째 입력을 선택할 것인지를 결정하는 첫 번째 입력을 사용하는 것입니다 01나 사이에 10. 의가 보자 0110예를 들어 (XOR)를 :

고려하십시오 A = 0. 이 경우에는 그대로 출력하고 싶습니다 B. ,읽고 A, ?아무것도하지 않는다. >다음 (0이 아닌) 셀로 이동 }하여 _on Chuck로 이동합니다. 여기서 우리는 B함께 읽고 다시 ,사용 ?합니다. 경우 B였다 0뿐만 아니라, 우리는있어 여전히 브라이언에. Brian의 소스 코드에 포함 된 인쇄물을 인쇄 하도록 on Chuck를 >건너 뛰고 전환 합니다. 경우 였다 반면에, 척은 실행 않습니다 로 이동하는 (가) 그래서 이미 브라이언의 코드를 다음 인쇄 대신 -byte합니다.}?>.0B1}_>.1

그렇다면 A = 1Chuck로 바로 전환하면 누가 실행 }+{>?합니다. 이것이하는 일은 _Brian의 소스 코드에서 로 이동하여 1와 함께 +로 바꾼 다음 시작으로 돌아가서 제어를 다시 전달하기 전에 하나의 셀을 오른쪽으로 이동하여 {Brian의 건너 뛰기를 건너 뜁니다 . 이번에는 Brian read 's , if 및 Chuck 다음에 Brian 's 옆에있는 셀 이 대신 사용됩니다 . 또한, Chuck 's 는 갭이었던 것을 바로 건너 뛰고 테이프의 끝까지 이동하여 대신 0 을 인쇄합니다. 이 방법으로 인쇄하고 있습니다 .?>BB = 0>.?10B = 1}>.not B

동등성을 구현하기 위해 A조건으로 사용하기 전에 부정 했습니다. 이 때문에 처음으로 다시 이동할 때 >Chuck에 다른 것을 추가 하여 건너 뛸 필요가 있습니다 -.


4

ClojureScript, 88 84 76 74 바이트

nilfalsefalsy이며, 다른 모든 값은 truthy 있습니다. 부울은 산술과 부등식을 위해 0/1로 강제됩니다. 함수가 잘못된 수의 인수를 취할 수 있습니다.

0000   nil?            ; previously: (fn[]nil)
0001   and
0010   <
0011   true?           ; previously: (fn[x]x)
0100   >
0101   (fn[x y]y)
0110   not=
0111   or
1000   #(= 0(+ % %2))
1001   =
1010   #(not %2)
1011   <=
1100   not
1101   >=
1110   #(= 0(* % %2))
1111   /               ; previously: (fn[]4), inc

0거짓 되지 않습니까?
Leaky Nun

2
ClojureScript에는 없습니다.
MattPutnam

@LeakyNun Clojure와 같은 대부분의 LISP 또는 함수형 프로그래밍 언어에는 해당되지 않음
cat

@cat 대부분의 기능적인 프로그래밍 언어에서 ! 예를 들어, 파이썬은로 평가 not not(0)되는데 False, 이는 잘못된 값입니다.
Outgolfer Erik

3
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Er ... 파이썬은 순전히 기능적이거나 내가 말하는 기능적 언어의 유형이 아닙니다. 파이썬은 필수적이며, 더 작은 (잘못 실행 된) 기능적 측면이 있습니다. 얼랑, 하스켈 (나는 생각한다), 일반 LISP, Clojure의, 라켓, 계획, 요소, 표준 ML, 목표 CAML 등 0은 다른 값과 결과 truthy하고, 거짓 (에 대한 기호 #f, f, false, 등)입니다 그릇된. 다른 모든 값은 대부분의 기능적 언어에서 진실합니다.
고양이

4

브레인 퍽 , 184 (178) 174 바이트

입력 / 출력은 U + 0000 및 U + 0001을 사용합니다.

0000 .
0001 ,[,[->+<]]>.
0010 ,[,-[+>+<]]>.
0011 ,.
0100 ,-[,[->+<]]>.
0101 ,,.
0110 ,>,[-<->]<[>>+<]>.
0111 ,-[,-[+>-<]]>+.
1000 ,-[,-[+>+<]]>.
1001 ,>,[-<->]<[>>-<]>+.
1010 ,,-[+>+<]>.
1011 ,-[,[->-<]]>+.
1100 ,-[+>+<]>.
1101 ,[,-[+>-<]]>+.
1110 ,[,[->-<]]>+.
1111 +.

조건부 두 번째 입력을 읽는 것은 비싸 보입니다. 예를 들어, 0001당신이 할 수 없었습니다 ,[,>]<.(시작 셀에서 왼쪽으로 갈 수있는 통역사가 제공 되었습니까)?
Martin Ender

@ MartinEnder 나는 Dennis의 대답을 여기에 복사하지 않을 것이라고 생각했습니다.
Leaky Nun

4

Brain-Flak , 418 , 316 바이트

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

입력은 프로그램 시작시 스택에서 맨 위 두 숫자 (참은 거짓이면 0)이고 출력은 프로그램 끝에서 스택의 맨 위가되도록하십시오 (그렇지 않으면 거짓이면 0).

false, 4 바이트 ( Leaky Nun 제공 )

(<>)

36 바이트

(({}{}[(())()])){{}{}(((<{}>)))}{}{}

A가 아닌 B, 40 바이트

((({}){}{}[(())()])){{}{}(((<{}>)))}{}{}

A, 6 바이트

({}<>)

A와 B가 아님, 38 바이트

((({}){}{}[(())])){{}{}(((<{}>)))}{}{}

B, 2 바이트

{}

xor, 34 바이트

(({}{}[(())])){{}{}(((<{}>)))}{}{}

또는 6 바이트

({}{})

또는 34 바이트

(({}{}<(())>)){{}{}(((<{}>)))}{}{}

xnor, 10 바이트

({}{}[()])

B가 아닌, 34 바이트

{}(({}<(())>)){{}{}(((<{}>)))}{}{}

B는 A, 14 바이트를 의미

(({}){}{}[()])

A가 아닌 34 바이트

(({}<{}(())>)){{}{}(((<{}>)))}{}{}

A는 B, 16 바이트를 의미합니다

(({}){}{}[()()])

낸드, 12 바이트

({}{}[()()])

true, 6 바이트

<>(())

설명

이것들의 대부분은 매우 유사하기 때문에 나는 그것들 각각이 어떻게 작동하는지 정확하게 설명하지 않을 것입니다. 그러나 16 개가 모두 어떻게 작동하는지 명확하게하기 위해 최선을 다합니다.

먼저 동일한 값 중 3 개를 반환하는 게이트가 있습니다 (예 : 2, 3, 5, 8, 9, 12, 14 및 15). 이들은 모두 같은 패턴을 따릅니다. 먼저 입력을 2 자리수로, B를 1 자리수로하여 2 비트 숫자로 변환합니다. 이 스 니펫으로 수행됩니다 (({}){}{}). 그런 다음 분리하려는 두 비트 입력의 값을 뺍니다 ({}[value]). (실제 코드에서 빼기와 변환은 한 단계로 수행되어 바이트를 절약합니다). 필요한 경우 not과 함께 사용할 수 있습니다 (({}<(())>)){{}{}(((<{}>)))}{}{}.

다음으로 : and, nor, or, xor, xnor. 이것들은 위의 것과 비슷하게 작동합니다. 실제로 이들 중 일부는 위에 포함되어 있지만이 방법은 더 짧습니다. 여기서 사용한 트릭은 이것들이 각각 A B의 합에 해당한다는 것입니다. 예를 들어 xor는 A + B = 1이면 true로 평가하고 그렇지 않으면 false로 평가합니다. 먼저 AB를 추가하고 관련 금액을 뺍니다. 로 표현됩니다 ({}{}[0,1,2 or 3]). 그런 다음 필요한 경우

다음은 A가 아니라 B가 아닌 A, B입니다. 불필요한 값을 제거하여 시작한 다음 부정하거나 마칩니다.

마지막으로 두 가지 단순 요소가 있습니다 : 참과 거짓. 이를 위해 올바른 값을 오프 스택으로 푸시합니다. <>nilad 반환 그래서 우리는 제로 값으로 스위치를 사용하여 2 바이트를 저장할 수 있습니다 제로.

가장 효율적인 솔루션 (아마도 Brain-Flak에서 가장 효율적인 솔루션)은 아니지만, 이것들을 작성하는 것이 즐겁습니다.


(<>)충분하다 false; 또한 (<{}{}>)8 바이트입니다
Leaky Nun

와우 나는 도전에 대한 훨씬 더 엄격한 정의를 가졌다. 감사합니다. 나는 이것을 크게 줄일 것입니다
밀 마법사

무슨 소리 야?
Leaky Nun

기존 입력을 제거하고 그 자리에 결과를 배치해야한다고 생각했습니다. (<>)입력을 남겨두고 다른 스택에 0을 넣습니다.
밀 마법사

1
암시 적 제로로 <>충분 하지 false않습니까? 또한 a빈 프로그램이 될 수 있다고 생각 합니다. true할 수 있습니다 <>[][](: P 바이트를 저장하지만 멋진 외모하지 않습니다).
CalculatorFeline

4

ProgFk , 18.5 17.5 바이트

ProgFk의 명령어가 니블로 지정되어 있으므로 아래 코드는 16 진수로, 줄당 하나의 논리 게이트와 바이트 사이에 공백이 있습니다.

3
E1
DE 2D
<empty>
DE 1
1
E3
E2
E2 D
E3 D
1D
DE 2
D
DE 1D
E1 D
4

설명

ProgFk 는 테이프 기반 esolang (Brainfuck과 유사)이며 각 셀은 비트이며 명령은 니블 (4 바이트)로 제공됩니다. 명령어는 명령어 포인터가 가리키는 셀에서 작동합니다. 입력 (과 제 1 및 제 2 셀에 부여 A하고 B각각 제 1 및 제 2 세포 임) 및 명령 포인터는 최초 셀에서 시작한다. 출력은 첫 번째 셀에 저장됩니다.

사용되는 각 명령어는 아래에 설명되어 있습니다.

1   Increment the instruction pointer.
2   Decrement the instruction pointer.
3   Set the current bit to 0.
4   Set the current bit to 1.
D   Perform a NOT on the current bit.
E   The next instruction is an extended instruction.

Extended instructions:
1   Set the current bit to the current bit AND the next bit.
2   Set the current bit to the current bit OR the next bit.
3   Set the current bit to the current bit XOR the next bit.
6   Swap the current bit and the next bit.

@LeakyNun 덕분에 바이트를 절약했습니다!


4

실제로 24 바이트

이러한 프로그램은 A\nB( \n줄 바꿈 을 나타내는) 입력을 가져 오며 B는 스택의 맨 위에 있고 A는 아래에 있습니다. False로 표시 0True양의 정수로 표현된다.

é0  (false: clear stack, push 0)
*   (and: multiply)
<   (A and not B: less-than)
X   (A: discard B)
>   (B and not A: greater-than)
@X  (B: discard A)
^   (A xor B: xor)
|   (A or B: or)
|Y  (A nor B: or, boolean negate)
=   (A xnor B: equals)
@XY (not B: discard A, boolean negate B)
≤   (if B then A: less-than-or-equal)
XY  (not A: discard B, boolean negate)
≥   (if A then B: greater-than-or-equal)
*Y  (A nand B: multiply, boolean negate)
é1  (true: clear stack, push 1)

3 바이트의 Leaky Nun 덕분에

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.