Tabele prawdy: Komputer twojego pradziadka

13

Jeśli pamiętasz swoje lata szkolne, możesz pamiętać o poznawaniu tabel prawdy . Wydawały się nudne, ale są podstawą logiki i (niektórzy twierdzą) wszystkich komputerów ...


Problem

Twoim zadaniem, jeśli zdecydujesz się to zaakceptować, jest napisanie programu, funkcji lub widżetu kodu, który może wypisać dane wejściowe z tabeli prawdy.

Wejście

Dane wejściowe będą ciągiem (podobnym do struktury danych) zawierającym instrukcję logiczną, z której zostanie utworzona tablica prawdy. Na przykład:

p ∧ q

Oznacza to p and q(sprzężenie logiczne) i spowoduje:

 p  q  p ∧ q
 T  T    T
 T  F    F
 F  T    F
 F  F    F            

Zwróć uwagę na odstępy: element kolumny znajduje się na środku nagłówka

Postacie

Ocena za pomocą znaków, a nie bajtów Znaki porównania logicznego są wyjątkowe i nie zawsze wyglądają. Użyj tych znaków:

Logiczna koniunkcja (AND): U + 2227

Logiczne rozłączenie (OR): U + 2228

Negacja logiczna (NOT) ~lub odpowiednio ¬U + 7e i U + ac


Bonusy

Wszystkie te bonusy są opcjonalne, ale powalą punkty na Twój wynik. Wybierz dowolny.

Logiczna negacja

Logiczna negacja jest jednym operatorem w tabelach prawdy. Jest to odpowiednik !w większości języków opartych na C. To sprawia, że false=> truei odwrotnie. Jest oznaczony symbolem ¬ lub ~ (musisz obsługiwać oba). Wspieranie tego powali 10% twojego wyniku. Musisz jednak dodać dodatkową kolumnę, aby pokazać jej wyniki: Na przykład:

~p ∧ q

wyświetli:

p  ~p  q  ~p ∧ q
T  F   T     F
T  F   F     F
F  T   T     T
F  T   F     F

Ładny druk

Normalny zapis w tabeli jest nudny. Zróbmy to ładnie! Ładny format wydruku p ∧ qjest następujący:

+---+---+-------+
| p | q | p ∧ q |
+---+---+-------+
| T | T |   T   |
+---+---+-------+
| T | F |   F   |
+---+---+-------+
| F | T |   F   |
+---+---+-------+
| F | F |   F   |
+---+---+-------+

Specjalne szczegóły dla ładnego drukowania:

  • W każdej komórce znajduje się 1 dopełnienie spacji
  • Wartości komórek są nadal wyśrodkowane

Jeśli ładnie wydrukujesz swoje tabele, z kodu, a następnie pomnóż przez 0,6. Użyj tej funkcji, aby uzyskać ten bonus:

score = 0.6 * code

Przykłady

p ∧ q:

p  q  p ∧ q
T  T    T
T  F    F
F  T    F
F  F    F

p ∨ q:

p  q  p ∨ q
T  T    T
T  F    T
F  T    T
F  F    F

~p ∧ q:

p  ~p  q  ~p ∧ q
T   F  T     F
T   F  F     F
F   T  T     T
F   T  F     F

~p ∨ q:

p  ~p  q  ~p ∧ q
T   F  T     T
T   F  F     F
F   T  T     T
F   T  F     T

Zasady

  • Obowiązują standardowe luki
  • Brak zasobów zewnętrznych
  • Jeśli masz zamiar złamać zasady, bądź sprytny;)

Najkrótszy kod (w znakach) wygrywa. Powodzenia!

MayorMonty
źródło
4
Z opisu brzmiało to tak, jakby były to dowolne wyrażenia logiczne. Ale wszystkie przykłady (bez premii) mają tylko jednego operatora. Czy jest to ograniczone do jednego operatora? Ponadto nazwy wartości w przykładach to wszystkie pi q. Jeśli nie zawsze mają te nazwy, możesz pokazać kilka różnych opcji w przykładach testowych. Czy zawsze są jedną literą?
Reto Koradi,
2
Ponieważ używa to znaków spoza ASCII, może być wskazane, czy długość kodu jest liczona w znakach, czy bajtach. Jeśli to bajty, warto wiedzieć, ile bajtów używają znaki Unicode.
Reto Koradi,
Uproszczać :). score = 0.6 * (code - 15)=.6 * code - 9
mınxomaτ
@RetoKoradi Zmieniono. Wynik według znaków, a nie bajtów
MayorMonty,
@RetoKoradi Jeśli to, co mój nauczyciel powiedział mi geometria jest prawidłowa nigdy nie zobaczysz więcej wtedy p qi rw tabeli prawdy;)
MayorMonty

Odpowiedzi:

6

JavaScript (ES6), 141

Prosta funkcja, bez premii, 141 znaków. (140 uft8, 1 szerokość Unicode)

Złożona funkcja obsługująca ~ lub ¬, 254 znaki (253 utf, 1 szerokość Unicode), wynik 229

Może zaoszczędzić 6 bajtów alertzamiast console.log, ale alertjest szczególnie nieodpowiedni do wyświetlania tabel.

Przetestuj poniższy fragment kodu w przeglądarce zgodnej z EcmaScript 6 (testowany z Firefoksem. Nie będzie działał w Chrome, ponieważ Chrome nie obsługuje .... Ponadto, wersja bonusowa używa tego rozszerzenia splitspecyficznego dla Firefoksa).

/* TEST: redirect console.log into the snippet body */ console.log=x=>O.innerHTML+=x+'\n'

// Simple
F=s=>{[a,o,b]=[...s],z='  ',r=a+z+b+z+a+` ${o} ${b}
`;for(w='FT',n=4;n--;r+=w[c]+z+w[e]+z+z+w[o<'∧'?c|e:c&e]+`
`)c=n&1,e=n>>1;console.log(r)}

// Simple, more readable
f=s=>{
   [a,o,b]=[...s]
   r=a+'  '+b+'  '+a+` ${o} ${b}\n`
   for(w='FT',n=4; n--; )
   {
     c = n&1, e = n>>1, x=o<'∧' ? c|e : c&e
     r += w[c]+'  '+w[e]+'    '+w[x]+'\n'
   }
   console.log(r)
}

// 10% Bonus
B=s=>{[a,o,b]=s.split(/([∧∨])/),t=a>'z',u=b>'z',z='  ',r=(t?a[1]+z:'')+a+z+(u?b[1]+z:'')+b+z+a+` ${o} ${b}
`;for(s=v=>'FT'[v]+z,n=4;n--;r+=s(c)+(t?s(d)+' ':'')+s(e)+(u?s(f)+' ':'')+(t?'   ':z)+s(o<'∧'?d|f:d&f)+`
`)c=n&1,d=c^t,e=n>>1,f=e^u;console.log(r)}

Test1 = ['q∨p','q∧p']
Test2 = Test1.concat([
  '~q∨p','q∨~p','~q∨~p','~q∧p','q∧~p','~q∧~p',
  '¬q∨p','q∨¬p','¬q∨¬p','¬q∧p','q∧¬p','¬q∧¬p'
])


console.log('SIMPLE')
Test1.forEach(t=>F(t));

console.log('BONUS')
Test2.forEach(t=>B(t));
<pre id=O></pre>

edc65
źródło
1
+1, uwielbiam JavaScript, a to rozwiązanie zasługuje na uznanie.
Arjun,
JavaScript jest moim językiem ojczystym, ale nie pozwolę, aby to na mnie wpłynęło! : D Dobra robota!
MayorMonty,
6

Szablon MediaWiki - 2347 znaków

MediaWiki ma wbudowaną funkcję szablonu o nazwie, {{#expr}}która może obsługiwać wyrażenia logiczne. To musi być idealne wyzwanie dla szablonów MediaWiki! Jednak pomogłyby takie funkcje, jak zmienne, pętle i czytelna składnia. Również fakt, że nie ma operatora NOT dla funkcji expr, spowodował, że była ona nieco bardziej złożona.

{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}} {{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}} {{{1}}}<br>T T &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|0|1}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|0|1}}|0|1}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>T F &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|0|1}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|1|0}}|1|0}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>F T &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|1|0}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|0|1}}|0|1}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}<br>F F &nbsp;{{#if:{{#pos:{{#sub:{{#replace:{{{1}}}|~|¬}}|0|1}}|¬}}|&nbsp;|}} {{#replace:{{#replace:{{#expr:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{#replace:{{{1}}}|~|¬}}|{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{#replace:{{#replace:{{{1}}}|~|}}|¬|}}|0|1}}}}|1|0}}}}|{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}|{{#if:{{#pos:{{#replace:{{{1}}}|~|¬}}|¬{{#sub:{{{1}}}|{{#expr:{{#len:{{{1}}}}}-1}}|{{#len:{{{1}}}}}}}}}|1|0}}|1|0}}|¬|}}|∧|and}}|∨|or}}}}|1|T}}|0|F}}

Test:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Wynik:

X Y ¬X ∧ ~Y
T T    F
T F    F
F T    F
F F    T

p q p ∨ q
T T   T
T F   T
F T   T
F F   F

Zakładam, że MediaWiki> = 1.18, w którym rozszerzenia ParserFunctions są dostarczane wraz z oprogramowaniem.

Lew
źródło
2
Witamy w Programowaniu łamigłówek i Code Golf. Korzystanie z MediaWiki nie jest czymś, o czym myślałem; +1. Brakuje jednak dodatkowego zachowania kolumny dla operatora ¬/ ~; jeśli go dodasz, będziesz kwalifikować się do 10%premii.
wizzwizz4
Właśnie zdałem sobie sprawę, że jeśli nie będę mógł użyć szablonów zagnieżdżonych (co może nieco rozciągać reguły?), Prawidłowe dodanie tej kolumny zwiększyłoby liczbę znaków ... :)
leo
W takim przypadku powinieneś prawdopodobnie usunąć wsparcie negacji, ponieważ nie otrzymujesz za to żadnych bonusów.
wizzwizz4
Tak, spojrzę na to. Nie sądzę jednak, żeby miało to duży wpływ na ostateczny ranking ...: D
leo
1
@leo To świetnie, i myślę, że użycie szablonów zagnieżdżonych byłoby w porządku, gdybyś po prostu dodał liczbę ich dwóch, co wydaje się być obecnie przyjętą praktyką.
Harry
4

Python - 288 znaków (+10 kar, ponieważ nie mogłem zmusić Unicode do działania: c)

Brak bonusów. To moja pierwsza odpowiedź na codegolf.

def f(i):
    i=i.split(" ")
    print i[0],i[2],
    for f in i[0:3]: print f,
    print ""
    for t in["TT","TF","FT","FF"]:
        p,q=t[0],t[1]
        y = t[0]+" "+t[1]
        if i[1]=="^": r=(False,True)[p==q]
        if i[1]=="v": r=(False,True)[p!=q]
        if r: y+="   T"
        else: y+="   F"
        print y

i jest wejściem.

EDYCJA: Usunięto kilka spacji i używa teraz argumentów funkcji jako danych wejściowych.

DJgamer98
źródło
1
Witamy w PP&CG! Upewnij się, że Twój kod jest zgodny z zasadami, zgodnie z pytaniem. Zgodnie ze specyfikacją reguły kod musi być funkcją, pełnym programem lub bitem kodu. Oznacza to, że wejście MUSI być STDIN lub argumentami funkcji (lub równoważnymi) Happy Coding!
MayorMonty,
3

Dyalog APL , 58 48 znaków

Wymaga ⎕IO←0, co jest domyślne w wielu systemach. Bierze ciąg jako argument.

{('p q ',⍵)⍪'FT '[p,q,⍪⍎⍵]\⍨324⊤⍨9⍴≢p q←↓2 2⊤⌽⍳4}

Brak bonusów, ale na plus każdy operator działa.

⍳4 pierwsze cztery wskaźniki (0 1 2 3)

 rewers (3 2 1 0)

2 2⊤ dwubitowy stół boolowski

 podzielony na dwuelementową listę list (high-bit, low-bit)

p q← zapisz jako p i q

 podsumuj je (2) *

9⍴ cyklicznie przekształcaj to do długości 9 (2 2 2 2 2 2 2 2 2)

324⊤⍨ w ten sposób koduje 324, tj. jako 12-bitowy plik binarny (1 0 1 0 0 0 1 0 0)

\⍨ użyj tego, aby rozwinąć (wstaw spację dla każdego 0) ...

'FT '[... ] ciąg „FT”, indeksowany przez

⍎⍵ wykonany argument (poprawny, ponieważ p i q mają teraz wartości)

zrób to w matrycę kolumny

q, wstaw kolumnę składającą się z q (1 1 0 0)

q, wstaw kolumnę składającą się z p (1 0 1 0)

(... )⍪ wstaw wiersz powyżej, składający się z

 argument

'p q ', poprzedzony ciągiem „p q”


* Oznacz ten problem gwiazdką, jeśli widzisz jako ≢i nie jako ̸≡.

Adám
źródło
2

Julia, 161 bajtów

Brak bonusów.

s->(S=split(s);P=println;p=S[1];q=S[3];a=[&,|][(S[2]=="∨")+1];c="  ";P(p,c,q,c,s);for t=["TT","TF","FT","FF"] P(t[1],c,t[2],c^2,"FT"[a(t[1]>'F',t[2]>'F')+1])end)

Nie golfowany:

function f(s::String)
    # Split the input on spaces
    S = split(s)

    # Separate out the pieces of the statement
    p = S[1]
    q = S[3]
    a = [&, |][(S[2] == "∨") + 1]

    # Print the header
    println(p, "  ", q, "  ", s)

    # Create the table entries in a loop
    for t = ["TT", "TF", "FT", "FF"]
        println(t[1], "  ", t[2], "    ", "FT"[a(t[1] > 'F', t[2] > 'F') + 1])
    end
end
Alex A.
źródło
1

Mathematica, 129 bajtów

Gra w golfa:

t=InputString[];s=Append[StringCases[t,LetterCharacter],t];Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s]]

Nie golfowany:

(*Take input*)
t=InputString[];
(* Find all occurrences of letters and append the final statement.*)
s=Append[StringCases[t,LetterCharacter],t];
(* Evaluate the list as expressions and create a boolean table of True/False values, then display as a table. *)
(* To satisfy the output conditions, we must convert each True/False to T/F *)
Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s]]

Nie jestem ekspertem od matematyki, ale uznałem to za dość eleganckie w porównaniu do konieczności bezpośredniego porównywania postaci.

Miałem rozwiązanie, które działało na negację, ale było dłuższe, niż obniżenie wyniku.

W zależności od tego, co kwalifikuje się do ładnego drukowania, mogę spróbować tego bonusu. Wydaje mi się, że wyświetlanie w ASCII w Mathematica byłoby zbyt drogie, aby zrównoważyć wynik, ale jeśli dwie główne cechy to kropkowana ramka i określone wypełnienie w komórkach, to tylko kilka opcji w siatce.

Z ładnym drukiem, 171 * 0,6 = 102,6 Bajtów

t=InputString[];s=Append[StringCases[t,LetterCharacter],t];Grid[Prepend[Map[If[#,"T","F"]&,BooleanTable[ToExpression[s]],{2}],s],Spacings->1,Frame->All,FrameStyle->Dashed]
Xanderhall
źródło
1

Python3, 145 139 120 119 bajtów

Bez premii (z premią na końcu)

 def f(s):
 a,m,b=s.split(" ");print(a,b,s);F,T,c=0,1,"FT"
 for p in c:
  for q in c:print(p,q," ",c[eval(p+"+*"[m=="∧"]+q)>0])

Potrzebuję Python3 do obsługi Unicode po wyjęciu z pudełka.

Oparty na kodzie Python DJgamer98, ustalenie, że jego stół jest niewłaściwy.

Edycja1: Podział na odrębne zmienne i odrzucenie zmiennej łańcuchowej operatora

Edycja2: (ab) używając F i T jako zmiennych i znaków łańcuchowych

Edycja3: Oszczędność jednego miejsca dzięki NoOneIsHere

Z premią, 215 * 0,6 = 129

def f(s):
 r="+---"*3+"----+"
 a,m,b=s.split(" ");F,T,c=0,1,"FT"
 print("%s\n| %s | %s | %s |\n%s"%(r,a,b,s,r));
 for p in c:
  for q in c: print("| %s | %s |   %s   |\n%s"%(p,q,c[eval(p+"+*"[m=="∧"]+q)>0],r));
Karl Napf
źródło
Witamy w PPCG! Możesz zapisać bajt, usuwając spację po q in c:.
NoOneIsHere
Edycja2: To nie jest nadużycie. Zobacz tutaj , gdzie używam pierwszego znaku zawartości pliku jako nazwy pliku!
Adám
1

C / C ++ 302 bajtów

335 znaków mniej niż 10% na obsługę negacji. Formatowanie niekompletne, ale przesłanie, zanim zobaczę, jaki jest wpływ zakończenia.

Oznaczone jako C / C ++, ponieważ moje gcc i g ++ akceptują to z opcją -fpermissive i dla mnie wygląda to bardziej C niż C ++.

#include <stdio.h>
void T(char*S) { int (*P)(char*,...)=printf;char*v[2]={"F","T"};for(int m=4;m--;){P("|");char*s=S;int x=m&1;X:P(" %s |",v[x]);if(*++s!=' '){x=x^1;goto X;}char*o=++s;s+=3;int y=(m>>1)&1;Y:P(" %s |",v[y]);if(*++s){y=y^1;goto Y;}int g;for(g=o-S+1;g--;)P(" ");P(*++o==39?v[x&y]:v[x|y]);for(g=s-o;g--;)P(" ");P("|\n");}}

Jestem pewien, że jest kilka poprawek, które można zastosować. W rzeczywistości obsługa notatek dodaje więcej niż 10% usunięć premii.

Zakłada się, że format wejściowy jest zgodny z podanymi, tj. 2 wartości wejściowe (p i q), z prefiksem non i bez oraz bez innych elementów i bez nich oraz wszystkie tokeny rozdzielone pojedynczą spacją.

Nie golfowany:

void ungolfed(char* S)
{
   int (*P)(char*,...) = printf;         // useful lookup stuff
   char* v[2] = {"F","T"};

   for(int m = 4; m--;) {                // loop over all 2 bit bit patterns (truth table inputs)

      P("|");                            // start of line format
      char* s=S;                         // iterator to start of equation for each bit pattern

      int x = m&1;                       // input 1 (aka. p which I called x here to be awkward)
X:    P(" %s |",v[x]);                   // input 1 output and format

      if(*++s!=' ') {                    // if next character is not a space then input must be prefixed with the not character
         x=x^1;                          // so negate the input
         goto X;                         // and redo input 1 output
      }

      char* o = ++s;                     // remember where the operator is
      s+=3;                              // and skip it and following space

      int y = (m>>1)&1;                  // input 2 (aka. q which I called y obviously) processing as for input 1
Y:    P(" %s |",v[y]);

      if(*++s) {
         y=y^1;
         goto Y;
      }

      int g;

      for(g=o-S+1;g--;) P(" ");         // pre-result value padding

      P(*++o==39?v[x&y]:v[x|y]);      // result

      for(g=s-o;g--;) P(" ");           // post-result value padding and format
      P("|\n");
   }
}

i testy:

int main()
{
   T("p \x22\x27 q");  // p & q
   puts("");

   T("p \x22\x28 q");  // p | q
   puts("");

   T("\x7ep \x22\x27 q");  // ~p & q
   puts("");

   T("\xacp \x22\x28 q");  // ~p | q
   puts("");

   T("p \x22\x28 \xacq");  // p | ~q
   puts("");

   return 0;
}
original.legin
źródło
0

Mathematica, 128 znaków

TraditionalForm@Grid[({#}~Join~BooleanTable[#,Cases[b,_Symbol,{0,∞}]]&/@Cases[b=ToExpression@#,_,{0,∞}]/.{0<1->"T",0>1->"F"})]&

jest znakiem U+F3C7reprezentującym prywatny użytek \[Transpose].

Na szczęście dla nas golfistów Mathematica, i już reprezentacji Andi Ortak wszystko co musimy zrobić, to przekształcić ciąg wejściowy na wypowiedzi Mathematica i możemy zrobić symboliczne operacje logiczne na nim.

Zauważ, że to rozwiązanie będzie również obsługiwać Not( ¬), Implies( ), Equivalent( ), Xor( ), Nand( ), Xor( ) i Nor( ), ale nie dostanie premii, ponieważ ~pjest to błąd składniowy w Mathematica. Meh

wprowadź opis zdjęcia tutaj

Wyjaśnienie

b=ToExpression@#

Konwertuje ciąg wejściowy na wyrażenie Mathematica i przechowuje go w b.

Cases[b=ToExpression@#,_,{0,∞}]

Jest to lista wszystkich możliwych podwyrażeń danych wejściowych. Każdy otrzyma własną kolumnę.

Cases[b,_Symbol,{0,∞}]

To jest lista wszystkich zmiennych pojawiających się na wejściu.

BooleanTable[#,Cases[b,_Symbol,{0,∞}]]&

Czysta funkcja, która przyjmuje wyrażenie wejściowe #i zwraca listę wartości prawdy dla wszystkich możliwych kombinacji wartości prawdy dla zmiennych.

{#}~Join~BooleanTable[...]

Dołącza samo wyrażenie do tej listy.

.../@Cases[b=ToExpression@#,_,{0,∞}]

Stosuje tę funkcję do każdego podwyrażenia wejścia.

.../.{0<1->"T",0>1->"F"}

Następnie zamień true ( 0<1) na „T”, a false ( 0>1) na „F”.

(...)

Zamień wiersze i kolumny.

Grid[...]

Wyświetl wynik jako Grid.

TraditionalForm@Grid[...]

Konwertuj na Gridtradycyjną formę, aby używała fantazyjnych symboli.

ngenisis
źródło