Erstellen Sie ein Programm, das die grundlegenden Logikgatter simuliert.

Eingabe: Ein Wort mit Großbuchstaben, gefolgt von 2 1-stelligen Binärzahlen, die durch Leerzeichen wie z OR 1 0. Die Tore OR, AND, NOR, NAND, XOR, und XNORsind erforderlich.

Ausgang: Was der Ausgang des eingegebenen Logikgatters würde die beiden Zahlen gegeben: entweder 1 oder 0.

Beispiele:
AND 1 0 wird 0
XOR 0 1wird 1
OR 1 1wird 1
NAND 1 1wird0

Das ist Codegolf, also gewinnt der kürzeste Code.

Jelly , 13 10 Bytes

OSị“ʋN’BŻ¤

Probieren Sie es online!

Port von Peter Taylors Antwort.

Python 2 , 38 Bytes

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

Probieren Sie es online!

Eine gute alte Modulo-Kette, die auf die Summe der ASCII-Werte des Eingabe-Strings angewendet wird, was zu einer Lösung führt, die nur überpassend ist. Der gesamte ASCII-Wert ist für jede mögliche Eingabe unterschiedlich, mit der Ausnahme, dass diejenigen mit 0 1und 1 0dasselbe Ergebnis liefern, was sich ergibt, weil alle verwendeten Logikgatter symmetrisch sind.

Das *3trennt sonst benachbarte Werte für Eingänge, die sich nur in den Bits unterscheiden, da diese der Mod-Kette die Aufteilung erschweren. Die Länge und Größe der Zahlen in der Mod-Kette schafft ungefähr die richtige Menge an Entropie für 18 Binärausgänge.

Eine kürzere Lösung ist mit hash(s)oder sicherlich möglich id(s), aber ich habe diese vermieden, weil sie systemabhängig sind.

Python 2 , 50 Bytes

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

Probieren Sie es online!

Eine etwas prinzipiellere Lösung. Jedes Logikgatter liefert ein unterschiedliches Ergebnis für jede Anzahl von Nullen im Eingang, die als Drei-Bit-Zahl von 1 bis 6 codiert werden kann. Jedes mögliche Logikgatter wird durch Aufnehmen auf die entsprechende Zahl abgebildet (s*9)[35], die alle verschieden sind. Denn ORdies führt dazu, dass eines der Bits gelesen wird, damit das Zeichen 0oder sein kann 1, aber es stellt sich heraus, dass es funktioniert, um zu überprüfen, ob es das ist 0, und a 1wird 1trotzdem ein korrektes Ergebnis liefern .

JavaScript (ES6), 39 Byte

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

Probieren Sie es online!

Wie?

Wir können keine Leerzeichen analysieren parseInt(), egal auf welcher Basis wir arbeiten. Also fügen wir stattdessen eine Base-64-Darstellung der Eingabezeichenfolge ein. Dies kann =Füllzeichen erzeugen (die auch nicht analysiert werden parseInt()können), aber diese befinden sich garantiert am Ende der Zeichenfolge und können ignoriert werden.

Wir analysieren als Basis $34$ und wenden ein Modulo $86$ , gefolgt von einem Modulo $23$ , das die folgenden Ergebnisse liefert. Dies schließt Ungenauigkeiten aufgrund von Genauigkeitsverlusten ein. Das Endergebnis ist in $[0..19]$ , wobei der höchste Wahrheitsindex bei $18$ , was zu einer 19-Bit-Nachschlagebitmaske führt.

 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 Bytes)

q1bH%86825Yb=

Angenommen, die Eingabe enthält keine nachgestellte Zeile.

Online-Testsuite

Dies ist nur ein einfacher Hash, der die 24 möglichen Eingaben in 17 unterschiedliche, aber konsistente Werte abbildet und diese dann in einer komprimierten Tabelle nachschlägt.

Python 2 (36 Bytes)

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

Dies ist nur ein Teil der obigen CJam-Antwort. Testsuite mit dem Testframework von xnor.

05AB1E , 13 12 10 8 Bytes

ÇO₁*Ƶï%É

Hafen von @mazzys alternativer Berechnung, die im Kommentar zu seiner Powershell-Antwort erwähnt wurde (*256%339%2anstelle von*108%143%2).

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie komprimiere ich große ganze Zahlen? ) An, um zu verstehen, warum dies so Ƶïist339 .

Holzkohle , 32 Bytes

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

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung: Die komprimierte Zeichenfolge wird zu einer Liste der unterstützten Operationen erweitert, sodass der Index der angegebenen Operation entsprechend den Eingaben nach rechts verschoben wird und das so extrahierte Bit zum Ergebnis wird.

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

Die 74-Byte-Version funktioniert für alle 16 Binäroperationen, die ich willkürlich wie folgt benannt habe: NULL UND WENIGER ZWEITER ERSTER XOR ODER NOR XNOR NICHT ERSTES NGREATER ZWEITER NLESS NAND NZERO.

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes.

Mathematica, 55 Bytes

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

Funktion pur. Nimmt einen String als Eingabe und gibt ihn zurück Trueoder Falseals Ausgabe. Da Or, And, Nor, Nand, Xor, und Xnorsind alle Einbauten, verwenden wir , ToCamelCaseum den Bediener zu Pascal Fall zu ändern, wandeln sie in dem entsprechenden Symbol, und es an die beiden Argumente gelten.

J , 21 Bytes

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

Probieren Sie es online!

Port der Python 2-Lösung von xnor .

J , 30 Bytes

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

Probieren Sie es online!

Einige bisschen Spaß mit eval ".und Standard - Bibliothek (die bereits korrekt enthält AND, OR, XOR).

J , 41 Bytes

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

Probieren Sie es online!

Mehr J-Style-Ansatz.

Wie es funktioniert

Ein sehr allgemeiner J-Trick ist hier verborgen. Häufig hat die gewünschte Funktion die Struktur "Do F für einen Eingang, do H für den anderen und do G für beide Ergebnisse." Dann sollte es so funktionieren (F x) G H y. In stillschweigender Form ist es gleichbedeutend mit (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

Wenn Ges sich um ein asymmetrisches Grundelement handelt, tauschen Sie einfach das linke und das rechte Argument der Zielfunktion aus, und Sie können ein Byte speichern.

Nun zur obigen Antwort:

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

Inspiriert von xnor , aber die Sequenz *108%143%2ist kürzer als das Original*3%61%37%9%7%2

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

Testskript:

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

Ausgabe:

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 Bytes

*.ords.sum*108%143%2

Probieren Sie es online!

Ein Hafen von Mady's Ansatz . Alternativ *256%339%2funktioniert auch.

Perl 6 , 24 Bytes

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

Probieren Sie es online!

Ein Hafen von Xnors Antwort . Ich werde versuchen, eine kürzere zu finden, aber ich denke, das ist wahrscheinlich die beste, die es gibt.

JavaScript (Node.js) , 106 94 Bytes

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)

Probieren Sie es online!

Link zum Code und allen 24 Fällen.

+9 für vergessen, den XNOR-Fall abzubilden.

Java 10, 30 28 Bytes

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

Port von @mazzy 's Powershell Antwort .

Probieren Sie es online aus.

JavaScript (Node.js) , 45 Byte

Nur eine Portierung der hervorragenden Python 2-Antwort von xnor, die nach Zustimmung veröffentlicht wurde. Geben Sie stattdessen diese Antwort-Upvotes.

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

Probieren Sie es online!

Attache , 55 Bytes

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

Probieren Sie es online!

Eine eher brutale Lösung. Konvertiert die Eingabe in den entsprechenden Attache-Befehl und wertet ihn aus. (Attache verfügt über integrierte Funktionen für jedes der 6 Logikgatter.)

Ruby , 20 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

Grundsätzlich das gleiche wie Peter Taylors Antwort, aber Ruby macht es einfacher. Die magische Zahl ist anders, aber die Idee war dieselbe.