Truth Tables: Komputer kakek buyut Anda


13

Jika Anda ingat kembali ke tahun-tahun sekolah Anda, Anda mungkin ingat belajar tentang Tabel Kebenaran . Mereka tampak membosankan, tetapi mereka adalah dasar untuk logika dan (beberapa akan berpendapat) semua komputasi ...


Masalah

Misi Anda, yang harus Anda pilih untuk menerimanya adalah menulis sebuah program, fungsi, atau widget kode yang dapat menampilkan tabel kebenaran yang diberikan input.

Memasukkan

Input akan berupa string (seperti struktur data) yang berisi pernyataan logika untuk membuat Tabel Kebenaran menjadi. Sebagai contoh:

p ∧ q

Ini berarti p and q(konjungsi logis) dan akan menampilkan:

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

Perhatikan spasi: Item kolom berada di tengah header

Karakter

Skor melalui karakter, bukan byte Karakter perbandingan logika adalah spesial dan tidak selalu seperti apa mereka. Gunakan karakter ini:

Logical Conjunction (AND): U + 2227

Logical Disjunction (OR): U + 2228

Logical Negation (NOT) ~atau ¬U + 7e dan U + ac


Bonus

Semua bonus ini bersifat opsional, tetapi akan menghilangkan poin Anda. Pilih apa saja.

Negasi logis

Logical Negation adalah operator unary di tabel kebenaran. Ini setara dengan !di sebagian besar bahasa berbasis C. Itu membuat false=> truedan sebaliknya. Ini dinotasikan dengan a ¬ atau ~ (Anda harus mendukung keduanya). Mendukung ini akan menjatuhkan 10% dari skor Anda. Namun, Anda harus menambahkan kolom tambahan untuk menunjukkan hasilnya: Misalnya:

~p ∧ q

akan menampilkan:

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

Cukup Cetak

Notasi tabel normal membosankan. Mari kita buat cantik! Format cetak cantik adalah sebagai berikut p ∧ qadalah sebagai berikut:

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

Detail khusus untuk pencetakan cantik:

  • Ada 1 ruang padding di setiap sel
  • Nilai sel masih terpusat

Jika Anda cukup mencetak tabel Anda, dari kode Anda dan kemudian kalikan dengan 0,6. Gunakan fungsi ini untuk bonus ini:

score = 0.6 * code

Contohnya

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

Aturan

  • Celah standar berlaku
  • Tidak ada sumber daya eksternal
  • Jika Anda melanggar aturan, cerdaslah;)

Kode Terpendek (dalam karakter) menang. Semoga berhasil!


4
Dari deskripsi itu terdengar seperti ini adalah ekspresi Boolean yang sewenang-wenang. Tetapi semua contoh (tanpa bonus) hanya memiliki satu operator. Apakah ini dibatasi untuk satu operator? Juga, nama-nama nilai dalam contoh semua pdan q. Kecuali mereka selalu memiliki nama-nama ini, Anda mungkin ingin menunjukkan beberapa opsi berbeda dalam contoh pengujian. Apakah mereka selalu satu huruf?
Reto Koradi

2
Karena ini menggunakan karakter non-ASCII, mungkin lebih baik untuk menentukan apakah panjang kode dihitung dalam karakter atau byte. Jika ini byte, akan sangat membantu untuk mengetahui berapa banyak byte yang digunakan karakter unicode.
Reto Koradi

Sederhanakan :). score = 0.6 * (code - 15)=.6 * code - 9
mınxomaτ

@RetoKoradi Berubah. Skor berdasarkan karakter, bukan byte
MayorMonty

@RetoKoradi Jika apa yang dikatakan guru geometri saya benar, Anda tidak akan pernah melihat lebih dari itu p qdan rdi tabel kebenaran;)
MayorMonty

Jawaban:


6

JavaScript (ES6), 141

Fungsi sederhana, tanpa bonus, 141 karakter. (140 uft8, 1 lebar unicode)

Penanganan fungsi kompleks ~ atau ¬, 254 karakter (253 utf, 1 lebar unicode), skor 229

Bisa menghemat 6 byte menggunakan alertbukan console.log, tetapi alertsangat tidak layak untuk menampilkan tabel.

Tes menjalankan cuplikan di bawah ini di peramban yang mendukung EcmaScript 6 (diuji dengan Firefox. Tidak akan berfungsi di Chrome karena Chrome tidak mendukung .... Juga, versi bonus menggunakan ekstensi splityang khusus untuk Firefox).

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


1
+1, saya suka JavaScript dan solusi ini layak mendapat upvote.
Arjun

JavaScript adalah bahasa ibu saya, tetapi saya tidak akan membiarkan itu mempengaruhi saya! : D Kerja Bagus!
MayorMonty

6

Kerangka MediaWiki - 2347 karakter

MediaWiki memiliki fungsi templat buatan yang disebut {{#expr}}yang dapat menangani ekspresi logis. Ini harus menjadi tantangan sempurna untuk template MediaWiki! Namun, fitur seperti variabel, loop, dan sintaks yang dapat dibaca sedikit membantu. Juga, fakta bahwa tidak ada operator TIDAK untuk fungsi expr membuatnya sedikit lebih kompleks.

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

Uji:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Hasil:

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

Saya mengasumsikan MediaWiki> = 1.18, di mana ekstensi ParserFunctions dibundel dengan perangkat lunak.


2
Selamat datang di Programming Puzzles and Code Golf. Menggunakan MediaWiki bukanlah sesuatu yang saya pikirkan; +1. Namun, perilaku kolom tambahan dari ¬/ ~operator adalah hilang; jika Anda menambahkannya, Anda akan memenuhi syarat untuk 10%bonus.
wizzwizz4

Saya baru menyadari bahwa, kecuali saya dapat menggunakan templat bersarang (yang mungkin meregangkan aturan agak terlalu jauh?), Menambahkan kolom itu benar-benar akan meningkatkan jumlah karakter ... :)
leo

Dalam hal ini, Anda mungkin harus menghapus dukungan negasi, karena Anda tidak mendapatkan bonus untuk itu.
wizzwizz4

Yup, akan melihatnya. Saya tidak berpikir itu akan memiliki banyak dampak pada peringkat akhir sekalipun ...: D
leo

1
@leo Ini bagus, dan saya pikir menggunakan templat bersarang akan baik-baik saja jika Anda hanya menambahkan jumlah karakter keduanya, yang tampaknya menjadi praktik yang diterima saat ini.
Harry

4

Python - 288 karakter (+10 penalti karena saya tidak bisa mengaktifkan unicode: c)

Tidak ada bonus. Ini adalah jawaban codegolf pertama saya.

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 adalah input.

EDIT: Menghapus beberapa spasi dan sekarang menggunakan argumen fungsi sebagai input.


1
Selamat datang di PP&CG! Pastikan kode Anda mengikuti aturan, sesuai dengan pertanyaan. Sebagai spesifikasi aturan, kode Anda harus berupa fungsi, program lengkap atau sedikit kode. Ini menyiratkan bahwa input HARUS STDIN atau argumen fungsi (atau setara) Happy Coding!
MayorMonty

3

Dyalog APL , 58 48 karakter

Membutuhkan ⎕IO←0, yang merupakan standar pada banyak sistem. Mengambil string sebagai argumen.

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

Tidak ada bonus, tetapi di sisi positifnya, operator mana pun bekerja.

⍳4 empat indeks pertama (0 1 2 3)

 membalikkan (3 2 1 0)

2 2⊤ tabel Boolean dua-bit

 dibagi menjadi dua daftar elemen daftar (bit tinggi, bit rendah)

p q← simpan sebagai p dan q

 tally mereka (2) *

9⍴ cyclically membentuk kembali bahwa untuk panjang 9 (2 2 2 2 2 2 2 2 2)

324⊤⍨ encode 324 demikian, yaitu sebagai biner 12-bit (1 0 1 0 0 0 1 0 0)

\⍨ gunakan itu untuk memperluas (masukkan spasi untuk setiap 0) ...

'FT '[... ] string "FT", diindeks oleh

⍎⍵ argumen yang dieksekusi (valid karena p dan q sekarang memiliki nilai)

buat itu menjadi matriks kolom

q, tambahkan kolom yang terdiri dari q (1 1 0 0)

q, tambahkan kolom yang terdiri dari p (1 0 1 0)

(... )⍪ masukkan baris di atas, terdiri dari

 argumen

'p q ', diawali dengan string "p q"


* Silakan beri bintang pada masalah ini jika Anda melihatnya sebagai ≢bukan ̸≡.


2

Julia, 161 byte

Tidak ada bonus.

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)

Tidak Disatukan:

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

1

Mathematica, 129 Bytes

Golf:

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

Tidak Disatukan:

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

Bukan ahli Mathematica, tapi saya menemukan ini agak elegan dibandingkan harus melakukan perbandingan karakter langsung.

Saya punya solusi yang bekerja untuk negasi, tapi itu lebih lama dari pengurangan skor.

Tergantung pada apa yang memenuhi syarat untuk pencetakan cantik, saya mungkin mencoba untuk bonus itu. Saya merasa seperti keluaran dalam ASCII di Mathematica akan jauh terlalu mahal untuk pengurangan skor untuk mengimbangi, tetapi jika dua fitur utama adalah perbatasan bertitik dan padding tertentu di dalam sel, itu hanya beberapa pilihan dalam Grid.

Dengan pencetakan cantik, 171 * 0,6 = 102,6 Bytes

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]

1

Python3, 145 139 120 119 Bytes

Tanpa bonus (dengan bonus di akhir)

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

Membutuhkan Python3 untuk dukungan Unicode di luar kotak.

Berdasarkan kode Python DJgamer98, mencari tahu mejanya tidak benar.

Sunting1: Memisahkan menjadi variabel yang berbeda dan menghilangkan variabel string operator

Edit2: (ab) menggunakan F dan T sebagai variabel dan karakter string

Sunting3: Menghemat satu ruang berkat NoOneIsHere

Dengan Bonus, 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));

Selamat datang di PPCG! Anda dapat menyimpan byte dengan menghapus spasi setelahnya q in c:.
NoOneIsHere

Sunting2: Itu bukan penyalahgunaan. Lihat di sini , di mana saya menggunakan karakter pertama dari isi file sebagai nama file!
Adám

1

C / C ++ 302 Bytes

335 karakter kurang 10% untuk menangani negasi. Memformat tidak lengkap tetapi mengirimkan sebelum saya melihat apa dampak penyelesaiannya.

Ditandai sebagai C / C ++ karena gcc dan g ++ saya menerimanya dengan -fpermissive dan terlihat jauh lebih seperti C daripada C ++ bagi saya.

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

Saya yakin mungkin ada beberapa penyesuaian yang bisa diterapkan. Bahkan menangani si miskin menambahkan lebih dari 10% bonus yang dihapus.

Ini mengasumsikan format input seperti yang dinyatakan, yaitu 2 nilai input (p dan q), dengan atau tanpa awalan dan tidak ada yang lain, dan semua token dibatasi oleh ruang tunggal.

Tidak Disatukan:

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

dan tes:

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

0

Mathematica, 128 karakter

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

adalah karakter penggunaan pribadi yang U+F3C7mewakili \[Transpose].

Untungnya bagi kami pegolf Mathematica, dan sudah mewakili AnddanOr , jadi yang harus kita lakukan adalah mengonversi string input menjadi ekspresi Mathematica dan kita bisa melakukan operasi logis simbolis di dalamnya.

Perhatikan bahwa solusi ini juga akan menangani Not( ¬), Implies( ), Equivalent( ), Xor( ), Nand( ), Xor( ), dan Nor( ), tetapi tidak mendapatkan bonus karena ~pada kesalahan sintaksis di Mathematica. Ah.

masukkan deskripsi gambar di sini

Penjelasan

b=ToExpression@#

Mengubah string input menjadi ekspresi Mathematica dan menyimpannya di b.

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

Ini adalah daftar setiap kemungkinan subekspresi dari input. Masing-masing akan menerima kolomnya sendiri.

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

Ini adalah daftar semua variabel yang muncul di input.

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

Fungsi murni yang mengambil ekspresi input #dan mengembalikan daftar nilai kebenaran untuk semua kemungkinan kombinasi nilai kebenaran untuk variabel.

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

Tambahkan ekspresi itu sendiri ke daftar ini.

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

Menerapkan fungsi ini untuk setiap subekspresi dari input.

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

Kemudian ganti true ( 0<1) dengan "T" dan false ( 0>1) dengan "F".

(...)

Pertukaran baris dan kolom.

Grid[...]

Tampilkan hasilnya sebagai a Grid .

TraditionalForm@Grid[...]

Konversikan Gridke bentuk tradisional sehingga menggunakan simbol mewah.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.