기본 논리 게이트를 시뮬레이트하는 프로그램을 작성하십시오.

입력 : 모두 대문자로 된 단어 다음에 공백으로 구분 된 2 자리 숫자 2 진수 (예 :) OR 1 0. 게이트는 OR, AND, NOR, NAND, XOR, 및이 XNOR요구된다.

출력 : 입력 된 논리 게이트의 출력에 1 또는 0의 두 숫자가 제공됩니다.

예 :이
AND 1 0 되고이 0
XOR 0 1된다 1
OR 1 1된다 1
NAND 1 1된다0

이것은 codegolf이므로 가장 짧은 코드가 승리합니다.

젤리 , 13 10 바이트

OSị“ʋN’BŻ¤

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

피터 테일러 항구의 답변.

파이썬 2 , 38 바이트

lambda s:sum(map(ord,s))*3%61%37%9%7%2

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

입력 문자열의 ASCII 값의 합에 적용되는 우수한 ol '모듈러스 체인이 너무 적합합니다. 총 ASCII 값과 해당하는 것을 제외하고, 각각의 가능한 입력 구별되는 0 1그리고 1 0사용 된 모든 논리 회로가 대칭이기 때문에 아웃 동작 인 동일한 결과를 제공한다.

은 *3그것이 하드 개조 쇄 분열하는 화장이 때문에, 비트 만의 서로 다른 입력에 달리 인접 값을 분리한다. 모드 체인의 숫자 길이와 크기는 18 개의 이진 출력에 맞도록 대략적인 양의 엔트로피를 만듭니다.

더 짧은 솔루션을 사용하여 확실히 가능하다 hash(s)거나 id(s), 그러나 시스템에 의존하기 때문에 나는이를 피했다.

파이썬 2 , 50 바이트

lambda s:'_AX0NRD'.find((s*9)[35])>>s.count('0')&1

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

약간 더 원칙적인 솔루션. 각 논리 게이트는 1에서 6까지의 3 비트 숫자로 인코딩 할 수있는 입력의 각 0 카운트에 대해 다른 결과를 제공합니다. 가능한 모든 논리 게이트는 (s*9)[35]모두 고유 한을 사용하여 해당 숫자에 매핑됩니다 . 를 들어 OR,이 비트 중 하나를 읽는 바람이 캐릭터가 될 수 있도록 0하거나 1,하지만이 있는지 확인하는 작업에 밝혀 0, 그리고이 1정확하게 줄 것이다 1어쨌든 결과입니다.

자바 스크립트 (ES6), 39 바이트

s=>341139>>parseInt(btoa(s),34)%86%23&1

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

어떻게?

우리는 parseInt()어떤 기반을 사용하든 공간을 파싱 할 수 없습니다 . 대신 입력 문자열의 base-64 표현을 삽입합니다. =패딩 문자를 생성 할 수 있지만 (파싱 할 수 없음 parseInt()),이 문자 는 문자열 끝에 위치하며 무시해도됩니다.

$34$$86$$23$$[0..19]$$18$

 input      | to base-64     | parsed as base-34 | mod 86 | mod 23 | output
------------+----------------+-------------------+--------+--------+--------
 "AND 0 0"  | "QU5EIDAgMA==" |  1632500708709782 |   26   |    3   |    0
 "AND 0 1"  | "QU5EIDAgMQ==" |  1632500708709798 |   42   |   19   |    0
 "AND 1 0"  | "QU5EIDEgMA==" |  1632500708866998 |   34   |   11   |    0
 "AND 1 1"  | "QU5EIDEgMQ==" |  1632500708867014 |   50   |    4   |    1
 "OR 0 0"   | "T1IgMCAw"     |     1525562056532 |   52   |    6   |    0
 "OR 0 1"   | "T1IgMCAx"     |     1525562056533 |   53   |    7   |    1
 "OR 1 0"   | "T1IgMSAw"     |     1525562075028 |   58   |   12   |    1
 "OR 1 1"   | "T1IgMSAx"     |     1525562075029 |   59   |   13   |    1
 "XOR 0 0"  | "WE9SIDAgMA==" |  1968461683492630 |   48   |    2   |    0
 "XOR 0 1"  | "WE9SIDAgMQ==" |  1968461683492646 |   64   |   18   |    1
 "XOR 1 0"  | "WE9SIDEgMA==" |  1968461683649846 |   56   |   10   |    1
 "XOR 1 1"  | "WE9SIDEgMQ==" |  1968461683649862 |   72   |    3   |    0
 "NAND 0 0" | "TkFORCAwIDA=" | 61109384461626344 |   62   |   16   |    1
 "NAND 0 1" | "TkFORCAwIDE=" | 61109384461626350 |   70   |    1   |    1
 "NAND 1 0" | "TkFORCAxIDA=" | 61109384461665650 |   64   |   18   |    1
 "NAND 1 1" | "TkFORCAxIDE=" | 61109384461665656 |   72   |    3   |    0
 "NOR 0 0"  | "Tk9SIDAgMA==" |  1797025468622614 |   76   |    7   |    1
 "NOR 0 1"  | "Tk9SIDAgMQ==" |  1797025468622630 |    6   |    6   |    0
 "NOR 1 0"  | "Tk9SIDEgMA==" |  1797025468779830 |   84   |   15   |    0
 "NOR 1 1"  | "Tk9SIDEgMQ==" |  1797025468779846 |   14   |   14   |    0
 "XNOR 0 0" | "WE5PUiAwIDA=" | 66920415258533864 |    0   |    0   |    1
 "XNOR 0 1" | "WE5PUiAwIDE=" | 66920415258533870 |    8   |    8   |    0
 "XNOR 1 0" | "WE5PUiAxIDA=" | 66920415258573170 |    2   |    2   |    0
 "XNOR 1 1" | "WE5PUiAxIDE=" | 66920415258573176 |   10   |   10   |    1

CJam (13 바이트)

q1bH%86825Yb=

입력에 후행 줄 바꿈이 없다고 가정합니다.

온라인 테스트 스위트

24 개의 가능한 입력을 17 개의 고유하지만 일관된 값으로 매핑 한 다음 압축 된 테이블에서 조회하는 간단한 해시입니다.

파이썬 2 (36 바이트)

lambda s:76165>>sum(map(ord,s))%17&1

이것은 위의 CJam 답변의 포트 일뿐입니다. xnor의 테스트 프레임 워크를 사용하는 테스트 스위트 .

05AB1E , 13 12 10 8 바이트

ÇO₁*Ƶï%É

Powershell 답변에 대한 의견에서 언급 된 @mazzy 포트 의 대체 계산 ( *256%339%2대신 *108%143%2).

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Ç            # Convert each character in the (implicit) input to a unicode value
 O           # Sum them together
  ₁*         # Multiply it by 256
    Ƶï%      # Then take modulo-339
        É    # And finally check if it's odd (short for %2), and output implicitly

내이 05AB1E 팁을 참조하십시오 (섹션 얼마나 큰 정수를 압축하는 방법을? ) 이유를 이해하는 Ƶï것입니다 339.

숯 , 32 바이트

§01÷⌕⪪”＆⌈4Ｙ⍘ＬH⦄vü|⦃³Ｕ}×▷” Ｓ∨⁺ＮＮ⁴

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명 : 압축 된 문자열이 지원되는 조작 목록으로 확장되어 주어진 조작의 색인이 입력에 따라 오른쪽으로 이동하여 추출 된 비트가 결과가됩니다.

XOR     001
AND     010
OR      011
NOR     100
NAND    101
XNOR    110
inputs  011
        010

74 바이트 버전은 16 개의 바이너리 작업 모두에서 작동하며 임의로 제로 및 적은 두 번째 더 큰 첫 번째 XOR 또는 NOR XNOR NFIRST NGREATER NSECOND NLESS NANDS NZERO로 이름을 지정했습니다.

§10÷÷⌕⪪”＆↖VρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

수학, 55 바이트

Symbol[ToCamelCase@#][#2=="1",#3=="1"]&@@StringSplit@#&

순수한 기능. 문자열을 입력 및 리턴 True또는 False출력 으로 취합니다 . 이후 Or, And, Nor, Nand, Xor, 그리고 Xnor모든 내장 기능은, 우리가 사용하는 ToCamelCase파스칼 경우에 연산자를 변경하려면 해당하는 심볼로 변환하고, 두 개의 인수에 적용합니다.

J , 21 바이트

2|7|9|37|61|3*1#.3&u:

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

xnor의 Python 2 솔루션 포트 .

J , 30 바이트

XNOR=:=/
NAND=:*:/
NOR=:+:/
".

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

평가와 재미의 일부 비트 ".와 표준 라이브러리 (이미 올바른 포함 AND, OR, XOR).

J , 41 바이트

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

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

더 많은 J 스타일 접근법.

작동 원리

매우 일반적인 J 트릭이 여기에 숨겨져 있습니다. 종종 원하는 함수는 "한 입력에는 F를하고 다른 입력에는 H를하고 두 결과에 대해 G를한다"라는 구조를 가지고 있습니다. 그런 다음처럼 작동해야합니다 (F x) G H y. 암묵적인 형태로 (G~F)~H다음 과 같습니다 .

x ((G~F)~H) y
x (G~F)~ H y
(H y) (G~F) x
(H y) G~ F x
(F x) G H y

G비대칭 프리미티브 인 경우 대상 함수의 왼쪽 및 오른쪽 인수를 바꾸면 바이트를 저장할 수 있습니다.

위의 답변으로 넘어갑니다.

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

1 i.~' XXNNA'E.~_2&}.  Processing right argument (X): the operation's name
                _2&}.  Drop two chars from the end
1 i.~' XXNNA'E.~       Find the first match's index as substring
                       Resulting mapping is [OR, XOR, XNOR, NOR, NAND, AND]

7 6 9 8 14 1 b./  Processing left argument (Y): all logic operations on the bits
7 6 9 8 14 1 b.   Given two bits as left and right args, compute the six logic functions
               /  Reduce by above

X{Y  Operation on both: Take the value at the index

파워 쉘, 36 34 바이트

xnor 에서 영감을 얻었 지만 시퀀스 *108%143%2는 원본보다 짧습니다.*3%61%37%9%7%2

$args|% t*y|%{$n+=108*$_};$n%143%2

테스트 스크립트 :

$f = {

 $args|% t*y|%{$n+=108*$_};$n%143%2
#$args|% t*y|%{$n+=3*$_};$n%61%37%9%7%2   # sequence by xnor

}

@(
    ,("AND 0 0", 0)
    ,("AND 0 1", 0)
    ,("AND 1 0", 0)
    ,("AND 1 1", 1)
    ,("XOR 0 0", 0)
    ,("XOR 0 1", 1)
    ,("XOR 1 0", 1)
    ,("XOR 1 1", 0)
    ,("OR 0 0", 0)
    ,("OR 0 1", 1)
    ,("OR 1 0", 1)
    ,("OR 1 1", 1)
    ,("NAND 0 0", 1)
    ,("NAND 0 1", 1)
    ,("NAND 1 0", 1)
    ,("NAND 1 1", 0)
    ,("NOR 0 0", 1)
    ,("NOR 0 1", 0)
    ,("NOR 1 0", 0)
    ,("NOR 1 1", 0)
    ,("XNOR 0 0", 1)
    ,("XNOR 0 1", 0)
    ,("XNOR 1 0", 0)
    ,("XNOR 1 1", 1)

) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $s=$r"
}

산출:

True: AND 0 0=0
True: AND 0 1=0
True: AND 1 0=0
True: AND 1 1=1
True: XOR 0 0=0
True: XOR 0 1=1
True: XOR 1 0=1
True: XOR 1 1=0
True: OR 0 0=0
True: OR 0 1=1
True: OR 1 0=1
True: OR 1 1=1
True: NAND 0 0=1
True: NAND 0 1=1
True: NAND 1 0=1
True: NAND 1 1=0
True: NOR 0 0=1
True: NOR 0 1=0
True: NOR 1 0=0
True: NOR 1 1=0
True: XNOR 0 0=1
True: XNOR 0 1=0
True: XNOR 1 0=0
True: XNOR 1 1=1

펄 6 , 20 바이트

*.ords.sum*108%143%2

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

매디의 접근 의 항구 . 또는 *256%339%2작동합니다.

펄 6 , 24 바이트

*.ords.sum*3%61%37%9%7%2

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

xnor의 답변 포트입니다 . 나는 더 짧은 것을 찾는 데 갈 것이지만 아마도 그것이 가장 좋은 것이라고 생각합니다.

자바 스크립트 (Node.js) , 106 94 바이트

x=>([a,c,d]=x.split` `,g=[c&d,c^d,c|d]["OR".search(a.slice(1+(b=/N[^D]/.test(a))))+1],b?1-g:g)

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

코드와 24 가지 사례 모두에 연결하십시오.

XNOR 사례를 매핑하지 못한 경우 +9

자바 10, 30 28 바이트

s->s.chars().sum()*108%143%2

@mazzy 의 Powershell 답변 포트 .

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

자바 스크립트 (Node.js) , 45 바이트

동의에 따라 게시 된 xnor의 뛰어난 Python 2 답변 포트만 해당 답변 대신 의견을 제시하십시오.

x=>Buffer(x).reduce((a,b)=>a+b)*3%61%37%9%7%2

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

첨부 , 55 바이트

{Eval!$"${Sum!Id''Downcase!SplitAt!_}${N=>__2}"}@@Split

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

다소 잔인한 해결책. 입력을 관련 첨부 명령으로 변환하고 평가합니다. (Attache에는 6 개의 논리 게이트 각각에 내장되어 있습니다.)

루비 , 20 바이트

->s{76277[s.sum%17]}

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

작동 방식 :

기본적으로 Peter Taylor의 답변과 동일하지만 Ruby가 더 쉬워졌습니다. 마법의 숫자는 다르지만 아이디어는 동일합니다.