Crea un programma che simuli le porte logiche di base.

Input: una parola in maiuscolo seguita da 2 numeri binari di 1 cifra, separati da spazi, ad esempio OR 1 0. I cancelli OR, AND, NOR, NAND, XOR, e XNORsono necessari.

Uscita: quale uscita del gate logico inserito verrà data con i due numeri: 1 o 0.

Esempi:
AND 1 0 diventa 0
XOR 0 1diventa 1
OR 1 1diventa 1
NAND 1 1diventa0

Questo è codegolf, quindi vince il codice più corto.

Gelatina , 13 10 byte

OSị“ʋN’BŻ¤

Provalo online!

La risposta di Port of Peter Taylor.

Python 2 , 38 byte

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

Provalo online!

Una buona vecchia catena modulo applicata alla somma dei valori ASCII della stringa di input, creando una soluzione che si sta semplicemente adattando. Il valore ASCII totale è distinto per ogni possibile input, ad eccezione di quelli con 0 1e 1 0danno lo stesso risultato, il che è risolto perché tutte le porte logiche utilizzate sono simmetriche.

La *3separa valori altrimenti adiacenti per ingressi che differiscono solo nel bit, poiché questi rendono difficile per la catena mod contempla. La lunghezza e la dimensione dei numeri nella catena mod crea all'incirca la giusta quantità di entropia per adattarsi a 18 uscite binarie.

Una soluzione più breve è sicuramente possibile utilizzando hash(s)o id(s), ma le ho evitate perché dipendono dal sistema.

Python 2 , 50 byte

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

Provalo online!

Una soluzione leggermente più basata sui principi. Ciascuna porta logica fornisce un risultato diverso per ogni conteggio di zero nell'ingresso, codificabile come numero a tre bit da 1 a 6. Ogni porta logica possibile viene mappata sul numero corrispondente prendendo (s*9)[35], che sono tutti distinti. Perché OR, questo finisce per leggere uno dei bit in modo che il personaggio possa essere 0o 1, ma risulta funzionare per verificare se lo è 0, e una 1volontà darà 1comunque correttamente un risultato.

JavaScript (ES6), 39 byte

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

Provalo online!

Come?

Non possiamo analizzare gli spazi con parseInt(), indipendentemente dalla base con cui stiamo lavorando. Quindi iniettiamo invece una rappresentazione base-64 della stringa di input. Questo può generare =caratteri di riempimento (che non possono essere analizzati con parseInt()nessuno dei due), ma questi sono garantiti per essere posizionati alla fine della stringa e possono essere tranquillamente ignorati.

Analizziamo come base $34$ e applichiamo un modulo $86$ , seguito da un modulo $23$ , che fornisce i seguenti risultati. Ciò include imprecisioni dovute alla perdita di precisione. Il risultato finale è in $[0..19]$ , con l'indice di verità più alto a$18$ , portando a una maschera di bit di ricerca a 19 bit.

 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=

Suppone che l'input sia senza una nuova riga finale.

Suite di test online

Questo è solo un semplice hash che mappa i 24 possibili input in 17 valori distinti ma coerenti e poi li cerca in una tabella compressa.

Python 2 (36 byte)

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

Questa è solo una porta della risposta CJam sopra. Suite di test utilizzando il framework di test di xnor.

05AB1E , 13 12 10 8 byte

ÇO₁*Ƶï%É

Il calcolo alternativo di Port of @mazzy menzionato nel commento sulla sua risposta Powershell (*256%339%2 anziché *108%143%2).

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come comprimere grandi numeri interi? ) Per capire il motivo per cui Ƶïè 339.

Carbone , 32 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: La stringa compressa si espande in un elenco delle operazioni supportate in modo che l'indice di una determinata operazione venga quindi spostato a destra in base agli input e il bit così estratto diventa il risultato.

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

La versione a 74 byte funziona per tutte le 16 operazioni binarie, che ho arbitrariamente nominato come segue: ZERO E MENO SECONDO MAGGIORE PRIMO XOR O NÉ X NOR NFIRST NGREATER NSECOND NLESS NAND NZERO.

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

Mathematica, 55 byte

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

Funzione pura. Prende una stringa come input e restituisce Trueo Falsecome output. Dal momento che Or, And, Nor, Nand,Xor , e Xnorsono tutti built-in, si usa ToCamelCaseper cambiare l'operatore a caso Pascal, convertirlo al simbolo equivalente, e applicarlo ai due argomenti.

J , 21 byte

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

Provalo online!

Porto di soluzione Python 2 xnor .

J , 30 byte

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

Provalo online!

Alcuni po 'di divertimento con eval ".e libreria standard (che include già corretto AND, OR,XOR ).

J , 41 byte

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

Provalo online!

Approccio più in stile J.

Come funziona

Un trucco J molto generale è nascosto qui. Spesso, la funzione desiderata ha la struttura "Do F su un input, do H sull'altro e quindi do G su entrambi i risultati." Quindi dovrebbe funzionare come (F x) G H y. In forma tacita, equivale a (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

Se G è una primitiva asimmetrica, basta scambiare gli argomenti sinistro e destro della funzione target e possiamo salvare un byte.

Ora passiamo alla risposta sopra:

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

Ispirato da xnor , ma la sequenza *108%143%2è più breve dell'originale*3%61%37%9%7%2

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

Script di prova:

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

Produzione:

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

Provalo online!

Una porta di approccio di Maddy . In alternativa, *256%339%2funziona anche.

Perl 6 , 24 byte

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

Provalo online!

Un porto di risposta xnor . Proverò a trovarne uno più corto, ma penso che sia probabilmente il migliore che esista.

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)

Provalo online!

Link al codice e tutti i 24 casi.

+9 per dimenticato di mappare il caso XNOR.

Java 10, 30 28 byte

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

Porto di risposta @mazzy Powershell .

Provalo online.

JavaScript (Node.js) , 45 byte

Solo una porta della superba risposta di Python 2 di xnor pubblicata su consenso, si prega di dare a quella risposta voti invece di questo.

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

Provalo online!

Attache , 55 byte

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

Provalo online!

Una soluzione piuttosto brutale. Converte l'input nel relativo comando Attache e lo valuta. (Attache ha built-in per ciascuna delle 6 porte logiche.)

Rubino , 20 byte

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

Provalo online!

Come funziona:

Sostanzialmente uguale alla risposta di Peter Taylor, ma Ruby lo rende più semplice. Il numero magico è diverso ma l'idea era la stessa.