Một 2 chiều xử lý phổ quát (2ULP) là một mạng lưới các cổng logic mà phải mất hai dây đầu vào Avà B, cũng như bốn đầu vào khác L_, L_a, L_b, và L_ab, và tạo ra một đầu ra duy nhất L(a, b)sử dụng bốn Lđầu vào là một hàm bảng sự thật:

• 2ULP trả về L_nếu Avà Blà cả hai 0.
• Nó trả về L_anếu A = 1và B = 0.
• Nó trả về L_bnếu A = 0và B = 1.
• Nó trả về L_abnếu Avà Blà cả hai 1.

Ví dụ, với các đầu vào L_ = 0, L_a = 1, L_b = 1, và L_ab = 0, sau đó đầu ra L(a, b)sẽ bằng A xor B.

Nhiệm vụ của bạn là xây dựng 2ULP chỉ sử dụng cổng NAND, sử dụng càng ít cổng NAND càng tốt. Để đơn giản hóa mọi thứ, bạn có thể sử dụng cổng AND, OR, NOT và XOR trong sơ đồ của mình, với các điểm tương ứng sau:

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

Mỗi điểm số này tương ứng với số lượng cổng NAND cần thiết để xây dựng cổng tương ứng.

Mạch logic sử dụng các cổng NAND ít nhất để tạo ra một chiến thắng xây dựng chính xác.

11 NAND

Xác định cổng MUX (giá 4) là

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

với bảng chân lý

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

Sau đó, đây là toán tử ternary quen thuộc MUX(P, Q, R) = P ? Q : R

Chúng tôi chỉ đơn giản là có

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

với chi phí 12, nhưng tiết kiệm một cổng tầm thường bằng cách sử dụng lại NOT Btừ hai MUXes bên trong .

chi phí: 4 * 4 * 14 + 4 * (13) + 13 * 3 + 3 * 3 + 24 * 1 + 4 = 352

Tôi không phải là người đàn ông boolean, đây là điều tốt nhất của tôi trong việc mã hóa những thứ này (tôi biết điều này sẽ không mang lại cho tôi nhiều điểm internet bất di bất dịch ..).

# 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

Bằng cách sử dụng ngôn ngữ Wolfram, tôi có thể nhận được một công thức 13 cổng :

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"] &

đầu ra nào:

Ở đây Ln, La, Lbvà Lablà L_, L_a, L_bvà L_abriêng trong OP.

sidenote: Kết quả của BooleanMinimizechức năng trong ngôn ngữ Wolfram bị giới hạn ở hai cấp độ NANDvà NOTkhi gọi BooleanMinimize[(*blabla*), "NAND"], vì vậy nó không tốt như công thức bốn cấp của Peter Taylor ở trên .