Un procesador de lógica universal de 2 vías (2ULP) es una red de puertas lógicas que toma dos cables de entrada Ay B, así como otras cuatro entradas L_, L_a, L_b, y L_ab, y produce una única salida L(a, b)usando las cuatro Lentradas como una función de tabla de verdad:

• El 2ULP devuelve L_si Ay Bson ambos 0.
• Devuelve L_asi A = 1y B = 0.
• Devuelve L_bsi A = 0y B = 1.
• Devuelve L_absi Ay Bson ambos 1.

Por ejemplo, dadas las entradas L_ = 0, L_a = 1, L_b = 1, y L_ab = 0, a continuación, la salida L(a, b)será igual a A xor B.

Su tarea es construir un 2ULP usando solo puertas NAND, usando la menor cantidad posible de puertas NAND. Para simplificar las cosas, puede usar las compuertas AND, OR, NOT y XOR en su diagrama, con los siguientes puntajes correspondientes:

• NOT: 1
• AND: 2
• OR: 3
• XOR: 4

Cada uno de estos puntajes corresponde al número de puertas NAND que se necesitan para construir la puerta correspondiente.

El circuito lógico que utiliza la menor cantidad de compuertas NAND para producir una construcción correcta gana.

11 NANDs

Defina la puerta MUX (costo 4) como

MUX(P, Q, R) = (P NAND Q) NAND (NOT P NAND R)

con tabla de verdad

P Q R    (P NAND Q)   (NOT P NAND R)    MUX
0 0 0        1               1           0
0 0 1        1               0           1
0 1 0        1               1           0
0 1 1        1               0           1
1 0 0        1               1           0
1 0 1        1               1           0
1 1 0        0               1           1
1 1 1        0               1           1

Entonces este es el operador ternario familiar MUX(P, Q, R) = P ? Q : R

Simplemente tenemos

2ULP = MUX(A, MUX(B, L_ab, L_a), MUX(B, L_b, L_))

por un costo de 12, pero hay un ahorro trivial de una puerta al reutilizar el NOT Bde los dos interiores MUX.

costo: 4 * 4 * 14 + 4 * (13) + 13 * 3 + 3 * 3 + 24 * 1 + 4 = 352

No soy un hombre booleano, este es mi mejor en la codificación de estas cosas (sé que esto no me dará muchos puntos de Internet inimaginables ...).

# l1 is for a=F , b=F
# l2 is for a=F , b=T
# l3 is for a=T , b=F
# l4 is for a=T , b=T

2ULP(l1,l2,l3,l4,a,b) =
 (l1&l2&l3&l4)|             # always true
 (!l1&l2&l3&l4)&(a|b)|      # a=F,b=F->F; ee in T
 (l1&!l2&l3&l4)&(!a&b)|     # a=F,b=T->F; ee in T
 (!l1&!l2&l3&l4)&(a)|       # a=F,b=F->F; a=F,b=T->F; a=T,b=F->T; a=T,b=T->T; 
 (l1&l2&!l3&l4)&(a&!b)|     # a=T,b=F->F, ee in T
 (!l1&l2&!l3&l4)&(b)|       # a=T,b=F->F, ee in T
 (!l1&!l2&!l3&l4)&(a&b)|    # a=T,b=T->T, ee in F
 (l1&l2&l3&!l4)&(!(a|b))|   # a=T,b=T->F, ee in T
 (!l1&l2&l3&!l4)&(!(avb))|  # a=T,b=F->T, a=F,b=T->T, ee in T , note v is the exor.
 (l1&!l2&l3&!l4)&(!b)|      # T when b=T
 (!l1&!l2&l3&!l4)&(a&!b)|   # T when a=T,b=F
 (l1&l2&!l3&!l4)&(!a)|      # T when a=F
 (!l1&l2&!l3&!l4)&(!a&b)|   # T when a=F,B=T
 (l1&!l2&!l3&!l4)&(!(a|b))  # T when a=F,B=F

Al usar el lenguaje Wolfram puedo obtener una fórmula de 13 puertas :

logicfunc = Function[{a, b, Ln, La, Lb, Lab},
                   {a, b, Ln, La, Lb, Lab} -> Switch[{a, b},
                          {0, 0}, Ln, {1, 0}, La, {0, 1}, Lb, {1, 1}, Lab]
                  ];
trueRuleTable = Flatten[Outer[logicfunc, ##]] & @@ ConstantArray[{0, 1}, 6] /. {0 -> False, 1 -> True};
BooleanFunction[trueRuleTable, {a, b, Ln, La, Lb, Lab}] // BooleanMinimize[#, "NAND"] &

que salidas:

Aquí Ln, La, Lby Labson el L_, L_a, L_by L_abpor separado en OP.

nota al margen: Los resultados de la BooleanMinimizefunción en el lenguaje Wolfram se limitan a dos niveles NANDy NOTcuando se invoca como BooleanMinimize[(*blabla*), "NAND"], por lo que no es tan bueno como la fórmula de cuatro niveles de Peter Taylor anterior .