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!

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>

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.

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.

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 ̸≡.

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

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]

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

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

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.

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.