ถ้าคุณจำกลับไปปีการศึกษาของคุณคุณอาจจำได้เรียนรู้เกี่ยวกับตารางความจริง ดูเหมือนว่าพวกเขาน่าเบื่อ แต่เป็นพื้นฐานสำหรับตรรกะและ (บางคนอาจโต้แย้ง) การคำนวณทั้งหมด ...

ปัญหา

ภารกิจของคุณคุณควรเลือกที่จะยอมรับมันคือการเขียนโปรแกรมฟังก์ชั่นหรือวิดเจ็ตของรหัสที่สามารถแสดงผลตารางความจริงที่ป้อนเข้า

อินพุต

การป้อนข้อมูลจะเป็นสตริง (เช่นโครงสร้างข้อมูล) ที่มีคำสั่งตรรกะเพื่อทำให้ตารางความจริงเป็น ตัวอย่างเช่น:

p ∧ q

นี่หมายถึงp and q(การเชื่อมโยงแบบลอจิคัล) และจะส่งออก:

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

สังเกตเห็นการเว้นวรรค: รายการของคอลัมน์อยู่ตรงกลางของส่วนหัว

ตัวละคร

ให้คะแนนผ่านตัวละครไม่ใช่ไบต์ ตัวอักขระเปรียบเทียบแบบลอจิกมีความพิเศษและไม่เหมือนกันเสมอ ใช้ตัวละครเหล่านี้:

การเชื่อมต่อแบบลอจิคัล (AND): ∧U + 2227

ความผิดพลาดเชิงตรรกะ (OR): ∨U + 2228

การปฏิเสธเชิงตรรกะ (NOT) ~หรือ¬U + 7e และ U + ac ตามลำดับ

โบนัส

โบนัสเหล่านี้เป็นตัวเลือก แต่จะทำให้คะแนนของคุณหายไป เลือกใด ๆ

การปฏิเสธเชิงตรรกะ

Logical Negation เป็นโอเปอเรเตอร์ unary ในตารางความจริง มันเทียบเท่ากับ!ในภาษา C-based ส่วนใหญ่ มันทำให้false=> trueและคีมจับในทางกลับกัน มันมีเครื่องหมาย¬ หรือ ~ (คุณต้องสนับสนุนทั้งสอง) การสนับสนุนสิ่งนี้จะทำให้คะแนนของคุณลดลง 10% อย่างไรก็ตามคุณต้องเพิ่มคอลัมน์เพิ่มเติมเพื่อแสดงผลลัพธ์: ตัวอย่างเช่น:

~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 | q | p ∧ q |
+---+---+-------+
| T | T |   T   |
+---+---+-------+
| T | F |   F   |
+---+---+-------+
| F | T |   F   |
+---+---+-------+
| F | F |   F   |
+---+---+-------+

รายละเอียดพิเศษสำหรับงานพิมพ์สวย:

• มีช่องว่างภายใน 1 ช่องในแต่ละเซลล์
• ค่าของเซลล์ยังคงอยู่กึ่งกลาง

ถ้าคุณสวยพิมพ์ตารางของคุณจากรหัสของคุณแล้วคูณด้วย 0.6 ใช้ฟังก์ชั่นนี้สำหรับโบนัสนี้:

score = 0.6 * code

ตัวอย่าง

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

กฎระเบียบ

• ช่องโหว่มาตรฐานใช้
• ไม่มีทรัพยากรภายนอก
• หากคุณกำลังฝ่าฝืนกฎจงฉลาด;)

ชนะรหัสที่สั้นที่สุด (เป็นตัวอักษร) โชคดี!

JavaScript (ES6), 141

ฟังก์ชั่นง่ายไม่มีโบนัส 141 ตัวอักษร (140 uft8 กว้าง 1 Unicode)

การจัดการฟังก์ชั่นที่ซับซ้อน ~ หรือ¬, 254 ตัวอักษร (253 ยูเอฟ, กว้าง 1 ยูนิโค้ด), คะแนน 229

สามารถบันทึกได้ 6 ไบต์โดยใช้alertแทนconsole.logแต่alertไม่เหมาะที่จะแสดงตาราง

ทดสอบการเรียกใช้ตัวอย่างด้านล่างในเบราว์เซอร์ที่สอดคล้องกับ EcmaScript 6 (ทดสอบกับ Firefox จะไม่ทำงานใน Chrome เนื่องจาก Chrome ไม่รองรับ...นอกจากนี้เวอร์ชันโบนัสจะใช้ส่วนขยายของsplitFirefox ที่เฉพาะเจาะจง)

/* 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>

เทมเพลต MediaWiki - 2347 ตัวอักษร

MediaWiki มีฟังก์ชั่นเทมเพลตในตัว{{#expr}}ที่เรียกว่าสามารถจัดการกับการแสดงออกทางตรรกะ นี่จะเป็นความท้าทายที่สมบูรณ์แบบสำหรับเทมเพลต MediaWiki! คุณลักษณะเช่นตัวแปรลูปและไวยากรณ์ที่อ่านได้จะช่วยได้บ้าง นอกจากนี้ข้อเท็จจริงที่ว่าไม่มีตัวดำเนินการ NOT สำหรับฟังก์ชัน expr ทำให้ซับซ้อนขึ้นเล็กน้อย

{{#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}}

ทดสอบ:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

ผลลัพธ์:

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

ฉันสมมติว่า MediaWiki> = 1.18 ซึ่งส่วนขยาย ParserFunctions มาพร้อมกับซอฟต์แวร์

Python - 288 ตัวอักษร (โทษปรับ +10 ทำให้ฉันไม่สามารถใช้งาน Unicode ได้: c)

ไม่มีโบนัส นี่คือคำตอบ 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 คืออินพุต

แก้ไข:ลบช่องว่างไม่กี่และตอนนี้มันใช้ฟังก์ชั่น args เป็นอินพุต

Dyalog APL , 58 48 ตัวอักษร

ต้องการ⎕IO←0ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ รับค่าสตริงเป็นอาร์กิวเมนต์

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

ไม่มีโบนัส แต่ในด้านบวกผู้ประกอบการใด ๆ ที่ทำงาน

⍳4 สี่ดัชนีแรก (0 1 2 3)

⌽ ย้อนกลับ (3 2 1 0)

2 2⊤ ตารางบูลีนสองบิต

↓ แบ่งออกเป็นสองรายการรายการ (high-bits, low-bits)

p q← เก็บเป็นpและq

≢ นับพวกเขา (2) *

9⍴ เปลี่ยนรูปร่างเป็นวงกลมให้มีความยาว 9 (2 2 2 2 2 2 2 2 2 2)

324⊤⍨ เข้ารหัส 324 จึงกล่าวคือเป็นไบนารีแบบ 12 บิต (1 0 1 0 0 0 1 0 0)

\⍨ ใช้เพื่อขยาย (แทรกช่องว่างสำหรับแต่ละ 0) ...

'FT '[... ] สตริง "FT" จัดทำดัชนีโดย

 ⍎⍵ อาร์กิวเมนต์ดำเนินการ (ใช้ได้ตั้งแต่pและqตอนนี้มีค่า)

 ⍪ ทำให้มันกลายเป็นเมทริกซ์คอลัมน์

 q, เติมคอลัมน์ที่ประกอบด้วยq (1 1 0 0)

 q, ต่อท้ายคอลัมน์ประกอบด้วยp (1 0 1 0)

(... )⍪ แทรกแถวด้านบนประกอบด้วย

 ⍵ อาร์กิวเมนต์

 'p q ', เติมด้วยสตริง "p q"

* กรุณาดาราปัญหานี้ถ้าคุณเห็น≢เป็นและไม่เป็น≢̸≡

Julia, 161 ไบต์

ไม่มีโบนัส

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)

Ungolfed:

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

Mathematica, 129 ไบต์

แข็งแรงเล่นกอล์ฟ:

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

Ungolfed:

(*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]]

ไม่ใช่ผู้เชี่ยวชาญทางคณิตศาสตร์ แต่ฉันพบว่ามันค่อนข้างหรูหราเมื่อเทียบกับการเปรียบเทียบตัวอักษรโดยตรง

ฉันมีวิธีแก้ปัญหาที่ใช้งานได้กับการปฏิเสธ แต่มันก็นานกว่าการลดคะแนนลง

ฉันอาจลองใช้โบนัสดังกล่าวทั้งนี้ขึ้นอยู่กับคุณสมบัติของการพิมพ์แบบสวย ฉันรู้สึกว่าการส่งออกใน ASCII ใน Mathematica นั้นแพงเกินไปสำหรับการลดคะแนนเพื่อชดเชย แต่ถ้าคุณสมบัติหลักสองอย่างคือเส้นประประและการเติมช่องว่างภายในเซลล์นั่นเป็นเพียงตัวเลือกคู่ใน Grid

ด้วยการพิมพ์ที่สวยงาม 171 * 0.6 = 102.6 ไบต์

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]

Python3, 145 139 120 119 ไบต์

ไม่มีโบนัส (พร้อมโบนัสในตอนท้าย)

 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])

ต้องการ Python3 สำหรับการสนับสนุน Unicode นอกกรอบ

ตามรหัส DJgamer98 Python การหาตารางของเขาไม่ถูกต้อง

แก้ไข 1: แบ่งออกเป็นตัวแปรที่แตกต่างและ ommiting ตัวแปรสตริงตัวดำเนินการ

Edit2: (ab) ใช้ F และ T เป็นทั้งตัวแปรและอักขระสตริง

แก้ไข 3: บันทึกหนึ่งช่องว่างด้วย NoOneIsHere

ด้วยโบนัส 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));

C / C ++ 302 Bytes

335 ตัวอักษรน้อยกว่า 10% สำหรับการจัดการการปฏิเสธ การจัดรูปแบบไม่สมบูรณ์ แต่ส่งก่อนที่ฉันจะเห็นผลกระทบของความสำเร็จคืออะไร

ทำเครื่องหมายเป็น C / C ++ เพราะ gcc และ g ++ ของฉันยอมรับด้วย -fpermissive และมันดู C มากกว่า 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");}}

ฉันแน่ใจว่าอาจมีการปรับแต่งเล็กน้อยที่สามารถใช้ได้ ในความเป็นจริงการจัดการ nots เพิ่มมากกว่า 10% โบนัสเอาออก

นี่ถือว่ารูปแบบการป้อนข้อมูลเป็นไปตามที่ระบุไว้เช่น 2 ค่าอินพุต (p และ q) โดยมีหรือไม่มีคำนำหน้าและไม่มีสิ่งอื่นใดและโทเค็นทั้งหมดคั่นด้วยช่องว่างเดียว

Ungolfed:

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");
   }
}

และการทดสอบ:

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;
}

Mathematica, 128 ตัวอักษร

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

คือการใช้อักขระส่วนตัวที่เป็นตัวแทนของU+F3C7\[Transpose]

โชคดีสำหรับนักกอล์ฟที่เรามาติกา∧และ∨ แล้วแทนAndและOrเพื่อให้ทุกสิ่งที่เราต้องทำคือการแปลงสายป้อนเข้าไปในการแสดงออก Mathematica และเราสามารถดำเนินการตรรกะสัญลักษณ์เกี่ยวกับมัน

โปรดทราบว่าโซลูชันนี้จะจัดการNot( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻) และNor( ⊽) แต่ไม่ได้รับโบนัสเนื่องจาก~pเป็นข้อผิดพลาดทางไวยากรณ์ใน Mathematica Meh

คำอธิบาย

b=ToExpression@#

แปลงสายป้อนเข้าไปในการแสดงออก Mathematica bและเก็บไว้ใน

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

นี่คือรายการทุกนิพจน์ย่อยที่เป็นไปได้ของอินพุต แต่ละคนจะได้รับคอลัมน์ของตัวเอง

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

นี่คือรายการของตัวแปรทั้งหมดที่ปรากฏในอินพุต

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

ฟังก์ชั่นบริสุทธิ์ซึ่งใช้เวลาในการแสดงออกป้อนข้อมูล#และส่งกลับรายการของค่าความจริงสำหรับการรวมกันของค่าความจริงที่เป็นไปได้ทั้งหมดสำหรับตัวแปร

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

ผนวกการแสดงออกของตัวเองไว้ในรายการนี้

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

ใช้ฟังก์ชันนี้กับแต่ละนิพจน์ย่อยของอินพุต

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

จากนั้นแทนที่จริง ( 0<1) ด้วย "T" และ false ( 0>1) ด้วย "F"

(...)

แลกเปลี่ยนแถวและคอลัมน์

Grid[...]

Gridแสดงผลเป็น

TraditionalForm@Grid[...]

แปลงเป็นGridรูปแบบดั้งเดิมเพื่อใช้สัญลักษณ์แฟนซี