Logic Gates Manualmente


13

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.


Possiamo prendere un array come input?
Quintec,

no @Quintec non puoi
qazwsx il

3
Possiamo produrre come Vero / Falso?
xnor

5
sure @xnor (anche nome utente rilevante)
qazwsx

Risposte:



29

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.


Accidenti, stavo cercando i miei valori mod, ma mi hai battuto. Hai mai scritto le tue strategie per questo ovunque, perché i miei metodi di forza bruta tendono a richiedere molto tempo
Jo King,

2
@JoKing In pratica ho esercitato una forza bruta totale *a%b%c%d%e%2, niente di veramente intelligente. L'unica cosa interessante era mettere un *mod davanti alle mod; Non ho provato altri formati.
xnor

Wow, è sbalorditivo! Non mi aspetto nemmeno un metodo simile a un hash per farlo. Posso creare una porta JS a 45 byte della tua risposta ?
Shieru Asakoto,

@ShieruAsakoto Sicuramente, provaci.
xnor

1
@xnor Ho usato esattamente lo stesso metodo che hai fatto tu, quindi non mi sentirei bene pubblicandolo da solo, ma questo può essere di 36 byte .
nedla2004,

10

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 a18 , 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

: o più breve della risposta
trasmessa

Ma ... sembra non funzionare NOR?
Shieru Asakoto,

@ShieruAsakoto Grazie per averlo notato. Ho appena dimenticato NOR. Ora risolto.
Arnauld

6

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.


4

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.


3

Carbone , 32 byte

§01÷⌕⪪”&⌈4Y⍘LH⦄vü|⦃³U}×▷” S∨⁺NN⁴

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ρS´↥cj/v⊗J[Rf↓⪫?9KO↘Y⦄;↙W´C>η=⁴⌕✳AKXIB|⊖\`⊖:B�J/≧vF@$h⧴” S∨N²∨N⁴

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


+1 Piuttosto colpito dal programma completo di 16 operazioni!
theREALyumdub,

3

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.


3

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

Prendi in considerazione l'idea di pubblicare il trucco nei suggerimenti J per giocare a golf se non l'hai già fatto. Roba ordinata. Inoltre sono un grande fan della soluzione eval.
Cole

3

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

1
I tuoi *16%95%7%2fallimenti per i XNORcasi, però. Si potrebbe usare @ nedla2004 's*6%68%41%9%2 , che è di 2 byte più breve di @xnor ' s uno, però.
Kevin Cruijssen,

1
Grazie!!!! Ho aggiunto xnor. Penso che *108%143sia più attraente :) Inoltre, c'è una bella coppia *256%339. Questa coppia è ancora migliore per le lingue che sanno come lavorare con bit e byte.
mazzy

1
Ah, carino! Una porta dalla tua risposta salva anche 2 byte nella mia risposta Java . :) Ed è un'alternativa di 10 byte per il mio risposta 05AB1E utilizzando *256%339.
Kevin Cruijssen,


2

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.


forse non vedo qualcosa, ma dove devo digitare l'input? La scheda di input non fa nulla.
qazwsx,

@qazwsx Questa è una funzione lambda, che per impostazione predefinita è consentita.
Shieru Asakoto,

1
@qazwsx Il collegamento mostra gli output per ogni possibile input. Questa risposta è una funzione, quindi se si desidera testarlo manualmente, è possibile sostituire il piè di pagina con ad es.console.log(f("AND", 1, 1));
Mego

@qazwsx E per favore ripristina il downvote. Dopo tutto ciò non è valido.
Shieru Asakoto,

Oh, capisco. ho ripristinato il downvote
qazwsx


1

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!




Forse è una buona idea convertire prima questa in una risposta della community? Quindi aggiungi quelle porte JS come raccolta qui.
Shieru Asakoto,

Forse. Non sono sicuro. Di solito aggiungo più risposte se ci sono più alternative con lo stesso numero di byte. Mazzy PowerShell risposta s' anche trovato uno più corto però: 41 byte .
Kevin Cruijssen,

1

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


1

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.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.