Nếu bạn nhớ lại thời đi học, bạn có thể nhớ việc học về Bàn chân lý . Chúng có vẻ nhàm chán, nhưng chúng là cơ sở cho logic và (một số người sẽ tranh luận) tất cả máy tính ...

Vấn đề

Nhiệm vụ của bạn, nếu bạn chọn chấp nhận nó là viết một chương trình, hàm hoặc widget mã có thể xuất ra một bảng chân lý được đưa vào.

Đầu vào

Đầu vào sẽ là một chuỗi (như cấu trúc dữ liệu) chứa câu lệnh logic để biến Bảng chân lý thành. Ví dụ:

p ∧ q

Điều này có nghĩa p and q(kết hợp logic) và sẽ xuất ra:

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

Lưu ý khoảng cách: Mục của cột nằm ở giữa tiêu đề

Nhân vật

Điểm qua các ký tự, không phải byte Các ký tự so sánh logic là đặc biệt và không phải lúc nào cũng giống như chúng. Sử dụng các ký tự sau:

Kết hợp logic (AND): ∧U + 2227

Rối loạn logic (OR): ∨U + 2228

Phủ định logic (KHÔNG) ~hoặc ¬U + 7e và U + ac tương ứng

Tiền thưởng

Tất cả những phần thưởng này là tùy chọn, nhưng sẽ đánh bật điểm số của bạn. Chọn bất kỳ.

Phủ định logic

Phủ định logic là một toán tử đơn nguyên trong các bảng chân lý. Nó tương đương với !hầu hết các ngôn ngữ dựa trên C. Nó làm cho false=> truevà ngược lại. Nó được ký hiệu bằng một ¬ hoặc ~ (bạn phải hỗ trợ cả hai). Hỗ trợ này sẽ đánh bật 10% số điểm của bạn. Tuy nhiên, bạn phải thêm một cột bổ sung để hiển thị kết quả của nó: Ví dụ:

~p ∧ q

sẽ xuất ra:

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

In đẹp

Các ký hiệu bảng bình thường là nhàm chán. Hãy làm cho nó đẹp lên! Định dạng in đẹp như sau cho p ∧ qnhư sau:

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

Chi tiết đặc biệt cho in ấn đẹp:

• Có 1 khoảng trống trong mỗi ô
• Giá trị ô vẫn ở giữa

Nếu bạn in đẹp các bảng của mình, từ mã của bạn và sau đó nhân với 0,6. Sử dụng chức năng này cho phần thưởng này:

score = 0.6 * code

Ví dụ

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

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Không có tài nguyên bên ngoài
• Nếu bạn sẽ phá vỡ các quy tắc, hãy khéo léo;)

Mã ngắn nhất (tính theo ký tự) sẽ thắng. Chúc may mắn!

JavaScript (ES6), 141

Chức năng đơn giản, không có tiền thưởng, 141 ký tự. (140 uft8, rộng 1 unicode)

Xử lý hàm phức tạp ~ hoặc, 254 ký tự (253 utf, rộng 1 unicode), điểm 229

Có thể lưu 6 byte bằng cách sử dụng alertthay vì console.log, nhưng alertđặc biệt không phù hợp để hiển thị bảng.

Kiểm tra chạy đoạn mã dưới đây trong trình duyệt tuân thủ EcmaScript 6 (đã được thử nghiệm với Firefox. Không hoạt động trong Chrome vì Chrome không hỗ trợ .... Ngoài ra, phiên bản phần thưởng sử dụng tiện ích mở rộng splitdành riêng cho 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>

Mẫu MediaWiki - 2347 ký tự

MediaWiki có một hàm mẫu được xây dựng có tên là {{#expr}}có thể xử lý các biểu thức logic. Đây phải là thử thách hoàn hảo cho các mẫu MediaWiki! Các tính năng như biến, vòng lặp và cú pháp có thể đọc được sẽ giúp một chút, mặc dù. Ngoài ra, thực tế là không có toán tử NOT cho hàm expr làm cho nó phức tạp hơn một chút.

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

Kiểm tra:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Kết quả:

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

Tôi giả sử MediaWiki> = 1.18, trong đó các phần mở rộng ParserFifts đi kèm với phần mềm.

Python - 288 ký tự (hình phạt +10 vì tôi không thể làm cho unicode hoạt động: c)

Không có tiền thưởng. Đây là câu trả lời đầu tiên của tôi.

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 là đầu vào.

EDIT: Đã xóa một vài khoảng trắng và hiện tại nó sử dụng hàm args làm đầu vào.

APL Dyalog , 58 48 ký tự

Yêu cầu ⎕IO←0, được mặc định trên nhiều hệ thống. Lấy chuỗi làm đối số.

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

Không có tiền thưởng, nhưng về mặt tích cực, bất kỳ nhà khai thác nào cũng hoạt động.

⍳4 bốn chỉ số đầu tiên (0 1 2 3)

⌽ đảo ngược (3 2 1 0)

2 2⊤ bảng Boolean hai bit

↓ chia thành danh sách hai yếu tố của danh sách (bit cao, bit thấp)

p q← lưu trữ dưới dạng p và q

≢ kiểm đếm chúng (2) *

9⍴ định hình lại theo chu kỳ đến độ dài 9 (2 2 2 2 2 2 2 2 2)

324⊤⍨ Do đó, mã hóa 324, tức là dưới dạng nhị phân 12 bit (1 0 1 0 0 0 1 0 0)

\⍨ sử dụng để mở rộng (chèn một khoảng trắng cho mỗi 0) ...

'FT '[... ] chuỗi "FT", được lập chỉ mục bởi

 ⍎⍵ đối số được thực thi (hợp lệ vì p và q hiện có giá trị)

 ⍪ biến nó thành một ma trận cột

 q, đặt trước một cột bao gồm q (1 1 0 0)

 q, đặt trước một cột bao gồm p (1 0 1 0)

(... )⍪ chèn một hàng ở trên, bao gồm

 ⍵ tranh luận

 'p q ', được bổ sung với chuỗi "p q"

* Xin vui lòng sao vấn đề này nếu bạn thấy ≢như ≢và không phải là ̸≡.

Julia, 161 byte

Không có tiền thưởng.

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)

Ung dung:

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

Toán học, 129 byte

Chơi gôn

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

Ung dung:

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

Không phải là một chuyên gia Mathicala, nhưng tôi thấy điều này khá thanh lịch so với việc phải làm so sánh nhân vật trực tiếp.

Tôi đã có một giải pháp hiệu quả cho việc phủ định, nhưng nó dài hơn việc giảm điểm sẽ diễn ra.

Tùy thuộc vào những gì đủ điều kiện để in đẹp, tôi có thể thử cho phần thưởng đó. Tôi cảm thấy việc xuất ra ASCII trong Mathematica sẽ rất tốn kém cho việc giảm điểm để bù lại, nhưng nếu hai tính năng chính là một đường viền chấm và phần đệm được chỉ định bên trong các ô, thì đó chỉ là một vài lựa chọn trong Grid.

Với bản in đẹp, 171 * 0,6 = 102,6 byte

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 byte

Không có tiền thưởng (có tiền thưởng ở cuối)

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

Cần Python3 để hỗ trợ Unicode ra khỏi hộp.

Dựa trên mã Python của DJgamer98, việc tìm ra bảng của anh ta không đúng.

Edit1: Tách thành các biến khác biệt và sử dụng biến chuỗi toán tử

Edit2: (ab) sử dụng F và T làm cả hai biến và ký tự chuỗi

Chỉnh sửa 3: Tiết kiệm một dung lượng nhờ NoOneIsHere

Có thưởng, 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 byte

335 ký tự ít hơn 10% để xử lý phủ định. Định dạng không đầy đủ nhưng gửi trước khi tôi thấy tác động của việc hoàn thành là gì.

Được đánh dấu là C / C ++ vì gcc và g ++ của tôi chấp nhận nó với -fpermissive và nó trông giống C hơn nhiều so với C ++ đối với tôi.

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

Tôi chắc chắn có thể có một vài điều chỉnh có thể được áp dụng. Trong thực tế, việc xử lý các thông báo thêm nhiều hơn 10% tiền thưởng.

Điều này không giả sử định dạng đầu vào như đã nêu, tức là 2 giá trị đầu vào (p và q), có hoặc không có tiền tố và không có gì khác, và tất cả các mã thông báo được phân tách bằng một khoảng trắng.

Ung dung:

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

và các bài kiểm tra:

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

Toán học, 128 ký tự

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

là nhân vật sử dụng riêng U+F3C7đại diện \[Transpose].

May mắn cho chúng tôi là những người chơi gôn Mathicala, ∧và ∨ đã đại diện Andvà Or, vì vậy tất cả những gì chúng tôi phải làm là chuyển đổi chuỗi đầu vào thành một biểu thức Mathicala và chúng tôi có thể thực hiện các thao tác logic tượng trưng trên nó.

Lưu ý rằng giải pháp này cũng sẽ xử lý Not( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻) và Nor( ⊽), nhưng nó không nhận được phần thưởng vì ~plà lỗi cú pháp trong Mathicala. Meh.

Giải trình

b=ToExpression@#

Chuyển đổi chuỗi đầu vào thành một biểu thức Mathicala và lưu trữ nó trong b.

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

Đây là danh sách mọi biểu hiện phụ có thể có của đầu vào. Mỗi người sẽ nhận được cột riêng của mình.

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

Đây là danh sách tất cả các biến xuất hiện trong đầu vào.

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

Hàm thuần túy nhận một biểu thức đầu vào #và trả về một danh sách các giá trị chân lý cho tất cả các kết hợp giá trị chân lý có thể có cho các biến.

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

Chuẩn bị biểu thức chính nó vào danh sách này.

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

Áp dụng chức năng này cho từng biểu thức con của đầu vào.

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

Sau đó thay true ( 0<1) bằng "T" và false (0>1 ) bằng "F".

(...)

Trao đổi hàng và cột.

Grid[...]

Hiển thị kết quả dưới dạng Grid .

TraditionalForm@Grid[...]

Chuyển đổi Gridhình thức truyền thống để nó sử dụng các biểu tượng ưa thích.