Buat program yang mensimulasikan gerbang logika dasar.

Input: Kata all-caps diikuti oleh 2 1 digit angka biner, dipisahkan oleh spasi, seperti OR 1 0. Gerbang OR, AND, NOR, NAND, XOR, dan XNORdiperlukan.

Output: Apa output dari gerbang logika yang dimasukkan akan diberi dua angka: 1 atau 0.

Contoh:
AND 1 0 menjadi 0
XOR 0 1menjadi 1
OR 1 1menjadi 1
NAND 1 1menjadi0

Ini codegolf, jadi kode terpendek menang.

Jelly , 13 10 byte

OSị“ʋN’BŻ¤

Cobalah online!

Jawaban Port of Peter Taylor.

Python 2 , 38 byte

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

Cobalah online!

Rantai modulo yang bagus diterapkan pada jumlah nilai ASCII dari string input, membuat solusi yang hanya overfitting. Nilai ASCII total berbeda untuk setiap input yang mungkin, kecuali bahwa mereka dengan 0 1dan 1 0memberikan hasil yang sama, yang berhasil karena semua gerbang logika yang digunakan adalah simetris.

Yang *3memisahkan nilai-nilai yang berdekatan untuk input yang hanya berbeda dalam bit, karena ini membuat sulit bagi rantai mod untuk berpisah. Panjang dan ukuran angka dalam rantai mod menghasilkan kira-kira jumlah entropi yang tepat agar sesuai dengan 18 keluaran biner.

Solusi yang lebih pendek tentu mungkin menggunakan hash(s)atau id(s), tapi saya menghindari ini karena mereka tergantung pada sistem.

Python 2 , 50 byte

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

Cobalah online!

Solusi yang sedikit lebih berprinsip. Setiap gerbang logika memberikan hasil yang berbeda untuk setiap hitungan nol dalam input, dikodekan sebagai angka tiga-bit dari 1 hingga 6. Setiap gerbang logika yang mungkin dipetakan ke nomor yang sesuai dengan mengambil (s*9)[35], yang semuanya berbeda. Karena OR, ini akhirnya membaca salah satu bit sehingga karakter bisa 0atau 1, tetapi ternyata bekerja untuk memeriksa apakah itu 0, dan1 akan memberikan 1hasil yang benar.

JavaScript (ES6), 39 byte

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

Cobalah online!

Bagaimana?

Kami tidak dapat memilah ruang parseInt(), tidak peduli basis apa yang sedang kami kerjakan. Jadi kami menyuntikkan representasi basis-64 dari string input sebagai gantinya. Ini dapat menghasilkan =karakter padding (yang tidak dapat diuraikan denganparseInt() baik), tetapi yang ini dijamin berada di akhir string dan dapat diabaikan dengan aman.

$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 byte)

q1bH%86825Yb=

Mengasumsikan input tanpa baris baru yang tertinggal.

Test suite online

Ini hanya sebuah hash sederhana yang memetakan 24 input yang mungkin menjadi 17 nilai yang berbeda namun konsisten dan kemudian melihatnya dalam tabel terkompresi.

Python 2 (36 byte)

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

Ini hanya port jawaban CJam di atas. Test suite menggunakan kerangka kerja pengujian xnor.

05AB1E , 13 12 10 8 byte

ÇO₁*Ƶï%É

Port perhitungan alternatif @mazzy disebutkan dalam komentar pada jawaban Powershell-nya ( *256%339%2bukan*108%143%2 ).

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Ç            # 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

Lihat ini 05AB1E ujung tambang (bagian Cara kompres bilangan bulat besar? ) Untuk memahami mengapa Ƶïadalah 339.

Arang , 32 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: String terkompresi memperluas ke daftar operasi yang didukung sehingga indeks operasi yang diberikan kemudian bergeser ke kanan sesuai dengan input dan bit dengan demikian diekstraksi menjadi hasilnya.

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

Versi 74-byte berfungsi untuk semua 16 operasi biner, yang saya sewenang-wenang menyebutkan sebagai berikut: NOL DAN KURANG DUA LEBIH BESAR PERTAMA XOR ATAU NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NZERO.

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode.

Mathematica, 55 byte

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

Fungsi murni. Mengambil string sebagai input dan mengembalikan Trueatau Falsesebagai output. Sejak Or, And, Nor, Nand, Xor, dan Xnorsemua built-in, kami menggunakan ToCamelCaseuntuk mengubah operator untuk kasus Pascal, mengubahnya menjadi simbol setara, dan menerapkannya pada dua argumen.

J , 21 byte

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

Cobalah online!

Port solusi xnor's Python 2 .

J , 30 byte

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

Cobalah online!

Beberapa sedikit bersenang-senang dengan eval ".perpustakaan dan standar (yang sudah termasuk yang benar AND, OR, XOR).

J , 41 byte

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

Cobalah online!

Lebih banyak pendekatan J-style.

Bagaimana itu bekerja

Trik J yang sangat umum disembunyikan di sini. Seringkali, fungsi yang diinginkan memiliki struktur "Lakukan F pada satu input, lakukan H pada yang lain, dan kemudian lakukan G pada kedua hasil." Maka harus beroperasi seperti (F x) G H y. Dalam bentuk diam-diam, itu setara dengan (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

Jika Gprimitif asimetris, cukup tukar argumen kiri dan kanan dari fungsi target, dan kita dapat menyimpan byte.

Sekarang ke jawaban di atas:

({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 byte

Terinspirasi oleh xnor , tetapi urutannya *108%143%2lebih pendek dari aslinya*3%61%37%9%7%2

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

Skrip uji:

$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"
}

Keluaran:

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 byte

*.ords.sum*108%143%2

Cobalah online!

Pelabuhan pendekatan maddy . Atau, *256%339%2juga berfungsi.

Perl 6 , 24 byte

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

Cobalah online!

Port jawaban xnor . Saya akan mencari yang lebih pendek, tapi saya pikir itu mungkin yang terbaik.

JavaScript (Node.js) , 106 94 byte

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)

Cobalah online!

Tautan ke kode dan semua 24 kasus.

+9 karena lupa memetakan case XNOR.

Java 10, 30 28 byte

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

Port dari @mazzy menjawab Powershell .

Cobalah online.

JavaScript (Node.js) , 45 byte

Hanya port jawaban Python 2 xnor yang luar biasa yang diposting atas persetujuan, tolong berikan jawaban itu sebagai gantinya.

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

Cobalah online!

Attache , 55 byte

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

Cobalah online!

Solusi yang agak brutal. Mengonversi input ke perintah Attache yang relevan dan mengevaluasinya. (Attache memiliki built-in untuk masing-masing dari 6 gerbang logika.)

Ruby , 20 byte

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

Cobalah online!

Bagaimana itu bekerja:

Pada dasarnya sama dengan jawaban Peter Taylor, tetapi Ruby membuatnya lebih mudah. Angka ajaib berbeda tetapi idenya sama.