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.

Jalea , 13 10 bytes

OSị“ʋN’BŻ¤

Pruébalo en línea!

La respuesta del puerto de Peter Taylor.

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 .

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

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.

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.

Carbón , 32 bytes

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

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ρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

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

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.

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

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

Perl 6 , 20 bytes

*.ords.sum*108%143%2

Pruébalo en línea!

Un enfoque de puerto de maddy . Alternativamente, *256%339%2también funciona.

Perl 6 , 24 bytes

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

Pruébalo en línea!

Un puerto de la respuesta de xnor . Intentaré encontrar uno más corto, pero creo que probablemente sea lo mejor que hay.

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.

Java 10, 30 28 bytes

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

Puerto de la respuesta Powershell de @mazzy .

Pruébalo en línea.

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!

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

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.