Wie man eine Wahrheitstabelle in einen kleinstmöglichen if / else Block verwandelt

Wie kann ich eine Wahrheitstabelle in einen komprimierten if-Block verwandeln?

Angenommen, ich habe diese Wahrheitstabelle, in der A und B Bedingungen und x, y und z mögliche Aktionen sind:

A B | x y z
-------------
0 0 | 0 0 1
0 1 | 0 0 1
1 0 | 0 1 0
1 1 | 1 0 0

Dies könnte sich wie folgt umwandeln, wenn block:

if(A)
{
    if(B)
    {
        do(x)
    }
    else
    {
        do(y)
    }
}
else
{
    do(z)
}

Dies ist ein einfaches Beispiel, aber ich habe häufig mehrere Bedingungen, die auf unterschiedliche Weise kombiniert unterschiedliche Ausgaben ergeben sollten, und es wird schwierig, die kompakteste und eleganteste Art und Weise zu finden, um ihre Logik in einem if-Block darzustellen.

Wenn Sie von einer Karnaugh-Karte aus entwerfen, kann der Code auch so aussehen:

//                   a      b
def actionMap = [ false: [false: { z() },
                          true:  { z() }],
                  true:  [false: { x() },
                          true:  { y() }]]

actionMap[a][b]()

In C # .NET können Sie eine Dictionary-Klasse verwenden, um das Ergebnis ohne IF ELSE zu erhalten. Das Schöne daran ist:

1. Es ist lesbar
2. Neue Schlüssel sind eindeutig (andernfalls wird eine Fehlermeldung angezeigt)
3. Reihenfolge spielt keine Rolle
4. Einträge einfach hinzufügen oder entfernen

Wenn Sie kein Äquivalent zur Dictionary-Klasse haben, können Sie dasselbe in einer binären Suchfunktion tun.

//A B | x y z
//-------------
//0 0 | 0 0 1
//0 1 | 0 0 1
//1 0 | 0 1 0
//1 1 | 1 0 0
// Create a Dictionary object and populate it
Dictionary<string, string> _decisionTable = new Dictionary<string, string>() { 
    { "0,0", "0,0,1" }, 
    { "0,1", "0,0,1" }, 
    { "1,0", "0,1,0" }, 
    { "1,1", "1,0,0"} 
};

//usage example: Find the values of X,Y,Z for A=1,B=0
Console.WriteLine(_decisionTable["1,0"]);
Console.Read();

Was Sie wollen, ist ein Rete-Algorithmus . Auf diese Weise werden automatisch eine Reihe von Regeln gekämmt und gemäß Ihrer Beschreibung in einem Baum priorisiert.

Es gibt eine Reihe von kommerziellen "Rules Engine" -Systemen, die dies in sehr großem Maßstab tun (Millionen von Regeln), bei denen die Ausführungsgeschwindigkeit von entscheidender Bedeutung ist.

Hier ist Ihre Bibliothek :) Und Sie müssen keine vollständige K-Tabelle übergeben, sondern nur Felder, die Sie interessieren :) Es wird davon ausgegangen, dass der AND-Operator in der Wahrheitstabelle steht. Wenn Sie mehr Operatoren verwenden möchten, sollten Sie in der Lage sein, diese neu zu schreiben. Sie können eine beliebige Anzahl von Argumenten haben. Eingeschrieben pythonund getestet.

def x():
    print "xxxx"

def y():
    print "yyyyy"

def z(): #this is default function
    print "zzzzz"

def A():
    return 3 == 1

def B():
    return 2 == 2


def insert(statements,function):
    rows.append({ "statements":statements, "function":function })

def execute():
    for row in rows:
        print "==============="
        flag = 1

        for index, val in enumerate(row["statements"]):
            #for first pass of lopp, index is 0, for second its 1....
            #if any function returns result different than one in our row, 
            # we wont execute funtion of that row (mark row as not executable)
            if funcs[index]() != val:
                flag = 0

        if flag == 1:
            #we execute function 
            row["function"]()
        else: z() #we call default function


funcs = [A,B]  #so we can access functions by index key
rows = []

insert( (0,0), y)
insert( (0,1), y)
insert( (1,0), x)
insert( (1,1), x)
insert( (0,1), x)

execute()

Ordnen Sie die Eingaben einem einzelnen Wert zu und schalten Sie ihn ein:

#define X(a, b) (!!(a) * 2 + !!(b))
switch(X(A, B)) {
case X(0, 0):
    ...
    break;
case X(0, 1):
    ...
    break;
case X(1, 0):
    ...
    break;
case X(1, 1):
    ...
    break;
}
#undef X

Eine Nachschlagetabelle mit Funktionszeigern kann in einigen Situationen gut funktionieren. In C können Sie beispielsweise Folgendes tun:

typedef void(*VoidFunc)(void);

void do(int a, int b)
{
    static VoidFunc myFunctions[4] = {z, z, y, x}; // the lookup table

    VoidFunc theFunction = myFunctions[ a * 2 + b ];
    theFunction();
}

Dies ist eine gute Lösung, wenn die Anzahl der Eingaben relativ gering ist, da die Anzahl der Einträge in der Tabelle 2 ^^ n sein muss, wobei n die Anzahl der Eingaben ist. 7 oder 8 Eingänge sind möglicherweise überschaubar, 10 oder 12 werden unangenehm. Wenn Sie so viele Eingaben haben, versuchen Sie zunächst, diese auf andere Weise zu vereinfachen (z. B. durch Karnaugh-Karten).

Schauen Sie sich die Software "Gorgeous Karnaugh" an - sie kann Wahrheitstabellen akzeptieren, die genau wie Ihre Stichprobe sind, analytische boolesche Formeldefinitionen akzeptieren, Lua-Skripte akzeptieren, um Wahrheitstabellen zu erstellen. Als Nächstes zeichnet die Software "Gorgeous Karnaugh" die K-Maps für die genommenen Eingaben, die Sie manuell oder mit dem Logik-Minimierer "Espresso" minimieren können, und erstellt Ausgaben für C / C ++ und einige Hardwaresprachen. Schauen Sie auf die Seite mit den zusammenfassenden Funktionen für "Gorgeous Karnaugh" ( http://purefractalsolutions.com/show.php?a=xgk/gkm)