Logische Gatter manuell

13

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.

code-golf  logic-gates  hashing  code-golf  code-golf  number  array-manipulation  integer  code-golf  string  unicode  text-processing  cops-and-robbers  boggle  cops-and-robbers  boggle  code-golf  ascii-art  code-golf  word-puzzle  king-of-the-hill  python  code-golf  sequence  kolmogorov-complexity  code-golf  source-layout  code-golf  string  kolmogorov-complexity  math  number  code-golf  date  code-golf  combinatorics  recursion  game  king-of-the-hill  javascript  code-golf  array-manipulation  code-golf  radiation-hardening  self-referential  code-golf  integer  code-golf  number  code-golf  set-theory  code-golf  sequence  code-golf  string  sorting  natural-language  code-golf  decision-problem  number-theory  primes  code-golf  code-golf  ascii-art  code-challenge  array-manipulation  sorting  rubiks-cube  regular-expression  code-golf  counting  file-system  recursion  code-golf  string  kolmogorov-complexity  color  code-golf  game  code-challenge  permutations  encode  restricted-time  decode  code-golf  math  decision-problem  matrix  integer  palindrome  code-golf  matrix  statistics  king-of-the-hill  king-of-the-hill  python  card-games  code-golf  string  natural-language  code-golf  sequence  number-theory 
— qazwsx
quelle
Können wir ein Array als Eingabe aufnehmen?
— Quintec
Nein @ Quintec Sie können nicht
— Qazwsx
3
Können wir als True / False ausgeben?
— Xnor
5
sure @xnor (auch relevanter Benutzername)
— qazwsx

Antworten:

29

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 .

— xnor
quelle
Verdammt, ich habe nach meinen eigenen Mod-Werten gesucht, aber du hast mich geschlagen. Haben Sie Ihre Strategien dafür irgendwo aufgeschrieben, da meine Brute-Force-Methoden in der Regel sehr lange dauern
— Jo King
2
@JoKing Ich habe im Grunde total brachiale Kraft auf *a%b%c%d%e%2, nichts wirklich Schlaues . Das einzig interessante war, *die Mods vorzustellen; Andere Formate habe ich nicht ausprobiert.
— xnor
Wow, das ist einfach umwerfend! Ich erwarte nicht einmal eine Hash-ähnliche Methode, um das zu tun. Darf ich aus Ihrer Antwort einen 45-Byte-JS-Port machen ?
— Shieru Asakoto
@ ShieruAsakoto Auf jeden Fall.
— Xnor
1
@xnor Ich habe genau die gleiche Methode verwendet wie Sie, daher würde ich es nicht für mich nehmen, es selbst zu posten, aber das können 36 Bytes sein .
— Nedla2004
10

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
— Arnauld
quelle
: o kürzer als die portierte Antwort
— Shieru Asakoto
Aber ... es scheint nicht zu funktionieren NOR?
— Shieru Asakoto
@ShieruAsakoto Vielen Dank, dass Sie es bemerkt haben. Ich habe es einfach vergessen NOR. Jetzt behoben.
— Arnauld
6

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.

— Peter Taylor
quelle
4

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 .

— Kevin Cruijssen
quelle
3

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.

— Neil
quelle
+1 Eher beeindruckt vom vollen 16-Operationen-Programm!
— theREALyumdub
3

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.

— LegionMammal978
quelle
3

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
— Bubbler
quelle
Erwägen Sie, den Trick in die J-Tipps zum Golfen aufzunehmen, falls Sie dies noch nicht getan haben. Ordentliches Zeug. Auch ich bin ein großer Fan der Eval-Lösung.
— Cole
3

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
— mazzy
quelle
1
Ihr *16%95%7%2scheitert jedoch für die XNORFälle. Sie könnten verwenden @ nedla2004 's*6%68%41%9%2 , die 2 Bytes kürzer als ist @xnor ist einer, though.
— Kevin Cruijssen
1
Vielen Dank!!!! Ich habe hinzugefügt xnor. Ich finde das *108%143attraktiver :) Außerdem gibt es ein schönes Paar *256%339. Dieses Paar ist noch besser für Sprachen, die mit Bits und Bytes umgehen können.
— mazzy
1
Ah schön! Ein Port aus Ihrer Antwort speichert auch 2 Bytes in meiner Java-Antwort . :) Und es ist eine 10-Byte-Alternative für meine 05AB1E-Antwort mit *256%339.
— Kevin Cruijssen
2

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.

— Shieru Asakoto
quelle
Vielleicht sehe ich etwas nicht, aber wo soll ich die Eingabe eingeben? Die Eingabe-Registerkarte führt nichts aus.
— Qazwsx
@qazwsx Dies ist eine Lambda-Funktion, die standardmäßig zulässig ist.
— Shieru Asakoto
1
@qazwsx Der Link zeigt die Ausgaben für jede mögliche Eingabe. Diese Antwort ist eine Funktion. Wenn Sie sie also manuell testen möchten, können Sie die Fußzeile console.log(f("AND", 1, 1));
— Mego
@qazwsx Und bitte machen Sie das Abstimmungsergebnis wieder rückgängig. Das ist doch nicht ungültig.
— Shieru Asakoto
oh ich verstehe ich habe die downvote zurückgesetzt
— qazwsx
1

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!

— Shieru Asakoto
quelle
— Kevin Cruijssen
— Kevin Cruijssen
Vielleicht eine gute Idee, dies zuerst in eine Community-Antwort umzuwandeln? Fügen Sie dann diese JS-Ports hier als Sammlung hinzu.
— Shieru Asakoto
Vielleicht. Nicht sicher. Normalerweise füge ich einfach mehrere Antworten hinzu, wenn es mehrere Alternativen mit derselben Byteanzahl gibt. Die Powershell-Antwort von mazzy hat sogar eine kürzere gefunden: 41 Bytes .
— Kevin Cruijssen
1

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

— Conor O'Brien
quelle
1

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.

— GB
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.