2ウェイ汎用ロジックプロセッサ（2ULP）は、二つの入力線とる論理ゲートのネットワークであるAとB、同様に他の4つの入力をL_、L_a、L_b、およびL_ab、単一の出力を生成するL(a, b)4つの使ってL真理値表関数として入力：

• とが両方のL_場合A、2ULPが返されます。B0
• それは返すL_a場合A = 1とB = 0。
• それは返すL_b場合A = 0とB = 1。
• それは返すL_ab場合AとBの両方です1。

例えば、入力所与L_ = 0、L_a = 1、L_b = 1、及びL_ab = 0、出力はL(a, b)に等しくなりますA xor B。

あなたの仕事は、NANDゲートのみを使用して、できるだけ少ないNANDゲートを使用して2ULPを構築することです。物事を簡略化するために、図でAND、OR、NOT、およびXORゲートを使用し、以下の対応するスコアを使用できます。

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

これらのスコアはそれぞれ、対応するゲートを構成するために必要なNANDゲートの数に対応しています。

最も少ないNANDゲートを使用して正しい構成を生成する論理回路が優先されます。

11個のNAND

ゲートMUX（コスト4）を次のように定義します。

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

真理値表付き

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

次に、これはおなじみの三項演算子です MUX(P, Q, R) = P ? Q : R

私たちは単に

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

コスト12ですがNOT B、2つの内部MUXes からのを再利用することで、1ゲートの節約が簡単になります。

コスト：4 * 4 * 14 + 4 *（13）+ 13 * 3 + 3 * 3 + 24 * 1 + 4 = 352

私はブーリアンではありません。これはこのことをコーディングするのに最高です（これで多くの想像上のインターネットポイントが得られるとは限りません）。

# 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

Wolfram言語を使用することで13ゲートの公式を得ることができます：

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

出力：

ここでLn、La、LbとLabしているL_、L_a、L_bおよびL_ab別途OPに。

追記：結果BooleanMinimize機能のWolfram言語では、2つのレベルに制限されているNANDとNOTとして呼び出すときにBooleanMinimize[(*blabla*), "NAND"]、それはのように良いようではありませんので、上記のピーター・テイラーの4レベルの式。