Puertas lógicas manualmente

13

Haga un programa que simule las puertas lógicas básicas.

Entrada: una palabra en mayúsculas seguida de 2 números binarios de 1 dígito, separados por espacios, como OR 1 0. Las puertas OR, AND, NOR, NAND, XOR, y XNORson necesarios.

Salida: a la salida de la puerta lógica ingresada se le darían los dos números: 1 o 0.

Ejemplos:
AND 1 0 se 0
XOR 0 1convierte 1
OR 1 1se 1
NAND 1 1convierte se convierte en se convierte0

Este es codegolf, por lo que gana el código más corto.

qazwsx
fuente
¿Podemos tomar una matriz como entrada?
Quintec
no @Quintec no puedes
qazwsx
3
¿Podemos mostrar como Verdadero / Falso?
xnor
55
sure @xnor (también nombre de usuario relevante)
qazwsx

Respuestas:

29

Python 2 , 38 bytes

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

Pruébalo en línea!

Se aplicó una buena cadena de módulos a la suma de los valores ASCII de la cadena de entrada, lo que constituye una solución que simplemente se sobreajusta. El valor ASCII total es distinto para cada entrada posible, excepto que aquellos con0 1 y1 0 dan el mismo resultado, lo que funciona porque todas las puertas lógicas utilizadas son simétricas.

El *3separa los valores adyacentes para entradas que difieren solo en los bits, ya que dificultan la división de la cadena de modulación. La longitud y el tamaño de los números en la cadena de modulación crean aproximadamente la cantidad correcta de entropía para ajustarse a 18 salidas binarias.

Seguramente es posible usar una solución más corta con hash(s)o id(s), pero los evité porque dependen del sistema.


Python 2 , 50 bytes

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

Pruébalo en línea!

Una solución un poco más basada en principios. Cada puerta lógica proporciona un resultado diferente para cada recuento de ceros en la entrada, codificable como un número de tres bits del 1 al 6. Cada puerta lógica posible se asigna al número correspondiente mediante la toma (s*9)[35], que son todas distintas. Porque OR, esto termina leyendo uno de los bits para que el personaje pueda ser 0o 1, pero resulta que funciona para verificar si es así 0, y a de todos modos 1dará un 1resultado correcto .

xnor
fuente
Maldición, estaba buscando mis propios valores de mod, pero me ganaste. ¿Ha escrito sus estrategias para esto en cualquier lugar, porque mis métodos de fuerza bruta tienden a tomar mucho tiempo?
Jo King
2
@JoKing Básicamente hice fuerza bruta total *a%b%c%d%e%2, nada realmente inteligente. Lo único interesante fue poner un *antes de las modificaciones; No probé otros formatos.
xnor
¡Guau, eso es alucinante! Ni siquiera espero que un método similar a un hash haga eso. ¿Puedo hacer un puerto JS de 45 bytes de su respuesta ?
Shieru Asakoto
@ShieruAsakoto Definitivamente, adelante.
xnor
1
@xnor Usé exactamente el mismo método que tú, así que no me sentiría bien publicarlo por mi cuenta, pero esto puede ser de 36 bytes .
nedla2004
10

JavaScript (ES6), 39 bytes

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

Pruébalo en línea!

¿Cómo?

No podemos analizar espacios con parseInt()ninguna base con la que estemos trabajando. Entonces, inyectamos una representación en base 64 de la cadena de entrada. Esto puede generar =caracteres de relleno (que tampoco se pueden analizar parseInt()), pero se garantiza que estos se ubicarán al final de la cadena y se pueden ignorar de forma segura.

Analizamos como base 34 y aplicamos un módulo 86 , seguido de un módulo 23 , que da los siguientes resultados. Esto incluye imprecisiones debido a la pérdida de precisión. El resultado final está en [0..19] , con el índice de verdad más alto en 18 años , lo que lleva a una máscara de bits de búsqueda de 19 bits.

 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
fuente
: o más corto que la respuesta portada
Shieru Asakoto
Pero ... parece que no funciona NOR?
Shieru Asakoto
@ ShieruAsakoto Gracias por notarlo. Solo lo olvidé NOR. Ahora arreglado.
Arnauld
6

CJam (13 bytes)

q1bH%86825Yb=

Asume que la entrada es sin una nueva línea final.

Conjunto de pruebas en línea

Este es solo un hash simple que mapea las 24 entradas posibles en 17 valores distintos pero consistentes y luego las busca en una tabla comprimida.

Python 2 (36 bytes)

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

Este es solo un puerto de la respuesta CJam anterior. Conjunto de pruebas usando marco de pruebas de XNOR.

Peter Taylor
fuente
4

05AB1E , 13 12 10 8 bytes

ÇO₁*Ƶï%É

El cálculo alternativo del puerto de @mazzy mencionado en el comentario sobre su respuesta Powershell (en *256%339%2lugar de *108%143%2).

Pruébalo en línea o verifique todos los casos de prueba .

Explicación:

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

Ver este consejo 05AB1E mío (sección Cómo comprimir grandes números enteros? ) Para entender por qué Ƶïes 339.

Kevin Cruijssen
fuente
3

Carbón , 32 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: La cadena comprimida se expande a una lista de las operaciones admitidas para que el índice de la operación dada se desplace a la derecha de acuerdo con las entradas y el bit así extraído se convierta en el resultado.

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

La versión de 74 bytes funciona para las 16 operaciones binarias, que he nombrado arbitrariamente de la siguiente manera: CERO Y MENOS SEGUNDO MAYOR PRIMERO XOR O NOR XNOR 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⁴

Pruébalo en línea! El enlace es a la versión detallada del código.

Neil
fuente
+1 ¡Más bien impresionado con el programa completo de 16 operaciones!
theREALyumdub
3

Mathematica, 55 bytes

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

Pura función. Toma una cadena como entrada y devuelve Trueo Falsecomo salida. Dado que Or, And, Nor, Nand, Xor, y Xnortodos somos muebles empotrados, se utiliza ToCamelCasepara cambiar el operador para el caso de Pascal, convertirlo en el símbolo equivalente, y aplicarlo a los dos argumentos.

LegionMammal978
fuente
3

J , 21 bytes

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

Pruébalo en línea!

Puerto de la solución Python 2 de xnor .


J , 30 bytes

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

Pruébalo en línea!

Algunos poco de diversión con eval ".biblioteca y estándar (que ya incluye correcta AND, OR, XOR).


J , 41 bytes

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

Pruébalo en línea!

Más enfoque estilo J.

Cómo funciona

Aquí se esconde un truco J muy general. A menudo, la función deseada tiene la estructura "Hacer F en una entrada, hacer H en la otra y luego hacer G en ambos resultados". Entonces debería funcionar como (F x) G H y. En forma tácita, es equivalente 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

Si Ges una primitiva asimétrica, simplemente intercambie los argumentos izquierdo y derecho de la función de destino, y podemos guardar un byte.

Ahora a la respuesta anterior:

({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
fuente
Considera publicar el truco en los consejos J para jugar golf si aún no lo has hecho. Cosas ordenadas. También soy un gran admirador de la solución eval.
cole
3

Powershell, 36 34 bytes

Inspirado por xnor , pero la secuencia *108%143%2es más corta que la original*3%61%37%9%7%2

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

Script de prueba:

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

Salida:

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
fuente
1
Sin embargo, su *16%95%7%2falla para los XNORcasos. Usted podría utilizar @ nedla2004 's*6%68%41%9%2 , que es de 2 bytes más corto que @xnor ' s uno, sin embargo.
Kevin Cruijssen
1
¡¡¡¡Gracias!!!! He añadido xnor. Creo que *108%143es más atractivo :) Además, hay un buen par *256%339. Este par es aún mejor para los idiomas que saben cómo trabajar con bits y bytes.
mazzy
1
¡Oh bien! Un puerto de su respuesta también guarda 2 bytes en mi respuesta Java . :) Y es una alternativa de 10 bytes para mi respuesta 05AB1E usando *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)

Pruébalo en línea!

Enlace al código y los 24 casos.

+9 por olvidar mapear el caso XNOR.

Shieru Asakoto
fuente
tal vez no estoy viendo algo, pero ¿dónde escribo la entrada? La pestaña de entrada no hace nada.
qazwsx
@qazwsx Esta es una función lambda, que por defecto está permitida.
Shieru Asakoto
1
@qazwsx El enlace muestra las salidas para cada entrada posible. Esta respuesta es una función, por lo que si desea probarla manualmente, puede reemplazar el pie de página con, por ejemplo,console.log(f("AND", 1, 1));
Mego
@qazwsx Y revierta el voto negativo . Esto no es inválido después de todo.
Shieru Asakoto
Oh ya veo. i revertido los downvote
qazwsx
1

JavaScript (Node.js) , 45 bytes

Solo un puerto de la excelente respuesta de Python 2 de xnor publicada con el consentimiento, por favor, da esa respuesta en lugar de esto.

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

Pruébalo en línea!

Shieru Asakoto
fuente
¿Quizás sea una buena idea convertir esto en una respuesta comunitaria primero? Luego agregue esos puertos JS como una colección aquí.
Shieru Asakoto
Quizás. No estoy seguro. Por lo general, solo agrego múltiples respuestas si hay múltiples alternativas con el mismo número de bytes. La respuesta Powershell de mazzy incluso encontró una más corta: 41 bytes .
Kevin Cruijssen
1

Adjunto , 55 bytes

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

Pruébalo en línea!

Una solución bastante brutal. Convierte la entrada en el comando Attache relevante y lo evalúa. (Attache tiene incorporados para cada una de las 6 puertas lógicas).

Conor O'Brien
fuente
1

Rubí , 20 bytes.

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

Pruébalo en línea!

Cómo funciona:

Básicamente lo mismo que la respuesta de Peter Taylor, pero Ruby lo hace más fácil. El número mágico es diferente pero la idea era la misma.

GB
fuente