基本的な論理ゲートをシミュレートするプログラムを作成します。

入力：スペースなどで区切られた、2つの1桁の2進数が続く、すべて大文字の単語OR 1 0。門OR、AND、NOR、NAND、XOR、およびXNOR必要とされています。

出力：入力された論理ゲートの出力には、1または0の2つの数値が与えられます。

例：
AND 1 0なります0
XOR 0 1なり1
OR 1 1ます1
NAND 1 1なります0

これはcodegolfなので、最短のコードが優先されます。

ゼリー、13 10バイト

OSị“ʋN’BŻ¤

オンラインでお試しください！

ピーター・テイラー港の答え。

Python 2、38バイト

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

オンラインでお試しください！

入力文字列のASCII値の合計に適用される優れたol 'モジュロチェーンで、過剰適合のソリューションを作成します。総ASCII値を有するもの以外は、各可能な入力のために区別され0 1かつ1 0使用されるすべての論理ゲートが対称であるため、アウト動作で同じ結果を与えます。

これ*3は、ビットのみが異なる入力のその他の隣接する値を分離します。これらは、MODチェーンの分割を困難にするためです。modチェーンの数値の長さとサイズは、18個のバイナリ出力に適合するおおよその量のエントロピーを作成します。

hash(s)またはを使用するとid(s)、より短いソリューションが確実に可能になりますが、システムに依存するため、これらは避けました。

Python 2、50バイト

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

オンラインでお試しください！

もう少し原理的なソリューション。各ロジックゲートは、入力のゼロカウントごとに異なる結果を提供します。1〜6の3ビット数としてエンコードできます。可能なロジックゲートは、それぞれ(s*9)[35]異なるを取ることにより、対応する数にマッピングされます。以下のためORの文字があることことができるようにビットのうちの1つを読み込むまで、この強風0または1、それはそれはだかどうかを確認する作業に判明0し、1正しく与える1とにかく結果を。

JavaScript（ES6）、39バイト

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

オンラインでお試しください！

どうやって？

parseInt()どのベースを使用していても、でスペースを解析することはできません。そのため、代わりに入力文字列のbase-64表現を注入します。これにより、=パディング文字（parseInt()どちらでも解析できない）が生成される場合がありますが、これらは文字列の末尾にあることが保証されており、無視しても安全です。

ベース$34$として解析し、モジュロ$86$を適用し、その後にモジュロ$23$を適用すると、次の結果が得られます。これには、精度の低下による不正確さが含まれます。最終結果は$[0..19]$にあり、最高の真実のインデックスは$18$で、19ビットのルックアップビットマスクになります。

 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の異なるが一貫性のある値にマップし、それらを圧縮テーブルで検索する単純なハッシュです。

Python 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個のすべてのバイナリ操作で機能します。これは、任意に次のように名前を付けました。

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

オンラインでお試しください！リンクは、コードの詳細バージョンです。

Mathematica、55バイト

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

純粋な機能。文字列を入力として受け取り、出力TrueまたはFalse出力として使用します。以来Or、And、Nor、Nand、Xor、およびXnorすべての組み込み関数があり、我々が使用ToCamelCaseパスカルケースにオペレータを変更するには、同等のシンボルに変換し、2つの引数に適用します。

J、21バイト

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

オンラインでお試しください！

xnorのPython 2ソリューションのポート。

J、30バイト

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

オンラインでお試しください！

evalを持つ楽しみのいくつかのビット".（既に正しいが含まれており、標準ライブラリ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

Powershell、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

Perl 6、20バイト

*.ords.sum*108%143%2

オンラインでお試しください！

マディのアプローチのポート。または、*256%339%2機能します。

Perl 6、24バイト

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

オンラインでお試しください！

xnorの回答の移植版。私はもっ​​と短いものを見つけることに挑戦しますが、おそらくそれが最高だと思います。

JavaScript（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。

Javaの10、30の 28バイト

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

@mazzyのPowershell回答のポート。

オンラインでお試しください。

JavaScript（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コマンドに変換し、評価します。（Attacheには、6つの論理ゲートのそれぞれにビルトインがあります。）

ルビー、20バイト

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

オンラインでお試しください！

使い方：

基本的にはPeter Taylorの答えと同じですが、Rubyはそれを簡単にします。マジックナンバーは異なりますが、アイデアは同じでした。