Stwórz program, który symuluje podstawowe bramki logiczne.

Wprowadzanie: słowo pisane wielkimi literami, po których następuje 2 1-cyfrowe liczby binarne, oddzielone spacjami, np OR 1 0. Bramy OR, AND, NOR, NAND, XOR, i XNORsą potrzebne.

Dane wyjściowe: Jakie dane wyjściowe wprowadzonej bramki logicznej otrzymają dwie liczby: 1 lub 0.

Przykłady:
AND 1 0 staje 0
XOR 0 1się 1
OR 1 1staje się 1
NAND 1 1staje0

To jest codegolf, więc wygrywa najkrótszy kod.

Galaretka , 13 10 bajtów

OSị“ʋN’BŻ¤

Wypróbuj online!

Odpowiedź Porta Petera Taylora.

Python 2 , 38 bajtów

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

Wypróbuj online!

Dobry stary łańcuch modulo zastosowany do sumy wartości ASCII ciągu wejściowego, dzięki czemu rozwiązanie jest po prostu zbyt dobre. Całkowita wartość ASCII jest odrębna dla każdego możliwego wejścia, z wyjątkiem tych, które dają 0 1i 1 0dają ten sam wynik, co działa, ponieważ wszystkie użyte bramki logiczne są symetryczne.

*3Oddziela się inaczej sąsiadujące wartości wejściowych, które różnią się tylko w bitach, ponieważ te sprawiają, że trudno modyfikacji łańcucha się rozdzielić. Długość i rozmiar liczb w łańcuchu modów tworzy w przybliżeniu odpowiednią ilość entropii, aby zmieścić 18 wyjść binarnych.

Krótsze rozwiązanie jest z pewnością możliwe przy użyciu hash(s)lub id(s), ale unikałem ich, ponieważ są zależne od systemu.

Python 2 , 50 bajtów

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

Wypróbuj online!

Nieco bardziej zasadnicze rozwiązanie. Każda bramka logiczna daje inny wynik dla każdej liczby zer na wejściu, kodowana jako liczba 3-bitowa od 1 do 6. Każda możliwa bramka logiczna jest odwzorowywana na odpowiednią liczbę przez wzięcie (s*9)[35], które wszystkie są odrębne. Ponieważ kończy się to ORczytaniem jednego z bitów, aby postać mogła być 0lub 1, ale okazuje się, że działa, aby sprawdzić, czy tak 0, a a i 1tak poprawnie da 1wynik.

JavaScript (ES6), 39 bajtów

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

Wypróbuj online!

W jaki sposób?

Nie możemy analizować spacji parseInt()niezależnie od tego, z jaką bazą pracujemy. Zamiast tego wstrzykuje się reprezentację ciągu wejściowego w formacie 64. Może to generować =znaki wypełniające (których nie można przeanalizować za pomocą parseInt()żadnego z nich), ale z pewnością są one umieszczone na końcu łańcucha i można je bezpiecznie zignorować.

$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 bajtów)

q1bH%86825Yb=

Zakłada, że ​​dane wejściowe nie zawierają końcowego nowego wiersza.

Zestaw testów online

To tylko prosty skrót, który mapuje 24 możliwe dane wejściowe na 17 różnych, ale spójnych wartości, a następnie wyszukuje je w skompresowanej tabeli.

Python 2 (36 bajtów)

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

To tylko część powyższej odpowiedzi CJam. Zestaw testowy przy użyciu frameworka testowego xnor.

05AB1E , 13 12 10 8 bajtów

ÇO₁*Ƶï%É

Alternatywne obliczenia Port @mazzy wymienione w komentarzu do jego odpowiedzi Powershell ( *256%339%2zamiast *108%143%2).

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Zobacz moją wskazówkę 05AB1E (rozdział Jak kompresować duże liczby całkowite? ), Aby zrozumieć, dlaczego tak Ƶïjest 339.

Węgiel drzewny , 32 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Skompresowany ciąg rozwija się do listy obsługiwanych operacji, tak że indeks danej operacji jest następnie przesuwany w prawo zgodnie z danymi wejściowymi, a wyodrębniony bit staje się wynikiem.

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

Wersja 74-bajtowa działa dla wszystkich 16 operacji binarnych, które arbitralnie nazwałem następująco: ZERO I MNIEJ DRUGIEJ WIELKIEJ PIERWSZEJ XOR LUB NOR XNOR NFIRST NGREATER NSECOND NLESS NAND NZERO.

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

Wypróbuj online! Link jest do pełnej wersji kodu.

Mathematica, 55 bajtów

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

Czysta funkcja. Bierze ciąg jako dane wejściowe i zwraca Truelub Falsedane wyjściowe. Ponieważ Or, And, Nor, Nand, Xor, i Xnorsą Zabudowy, używamy ToCamelCasedo zmiany operatora Pascal przypadku, konwertować je do równoważnej symbolu, i zastosować go do dwóch argumentów.

J , 21 bajtów

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

Wypróbuj online!

Port Python 2 w roztworze XNOR .

J , 30 bajtów

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

Wypróbuj online!

Niektórzy trochę zabawy z eval ".i biblioteki standardowej (który już zawiera poprawne AND, OR, XOR).

J , 41 bajtów

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

Wypróbuj online!

Więcej podejścia w stylu J.

Jak to działa

Ukryta jest tutaj bardzo ogólna sztuczka J. Często pożądana funkcja ma strukturę „Wykonaj F na jednym wejściu, wykonaj H na drugim, a następnie wykonaj G na obu wynikach”. To powinno działać jak (F x) G H y. W milczącej formie jest to równoważne z (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

Jeśli Gjest to asymetryczny prymityw, po prostu zamień lewy i prawy argument funkcji docelowej, a my możemy zapisać bajt.

Przejdźmy do powyższej odpowiedzi:

({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 bajtów

Zainspirowany przez xnor , ale sekwencja *108%143%2jest krótsza niż oryginalna*3%61%37%9%7%2

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

Skrypt testowy:

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

Wynik:

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 bajtów

*.ords.sum*108%143%2

Wypróbuj online!

Port podejścia Maddy . Alternatywnie *256%339%2działa również.

Perl 6 , 24 bajtów

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

Wypróbuj online!

Port odpowiedzi xnora . Spróbuję znaleźć krótszy, ale myślę, że to chyba najlepsza z możliwych.

JavaScript (Node.js) , 106 94 bajtów

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)

Wypróbuj online!

Link do kodu i wszystkich 24 przypadków.

+9 za zapomnienie do zmapowania skrzynki XNOR.

Java 10, 30 28 bajtów

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

Port odpowiedzi Powershell @mazzy .

Wypróbuj online.

JavaScript (Node.js) , 45 bajtów

Tylko część doskonałej odpowiedzi xnor na Python 2 opublikowanej za zgodą, proszę podać tę odpowiedź zamiast tego.

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

Wypróbuj online!

Attache , 55 bajtów

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

Wypróbuj online!

Raczej brutalne rozwiązanie. Konwertuje dane wejściowe na odpowiednie polecenie Attache i ocenia je. (Attache ma wbudowane funkcje dla każdej z 6 bramek logicznych).

Ruby , 20 bajtów

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

Wypróbuj online!

Jak to działa:

Zasadniczo to samo co odpowiedź Petera Taylora, ale Ruby to ułatwia. Magiczna liczba jest inna, ale pomysł był taki sam.