Eğitim yıllarınızı hatırlarsanız, Doğruluk Tablolarını öğrendiğinizi hatırlayabilirsiniz . Sıkıcı görünüyordu, ama mantığın temelini oluşturuyorlar ve (bazıları tartışıyorlardı) tüm bilgisayarları ...

Sorun

Göreviniz, kabul etmeyi seçerseniz, bir program, fonksiyon veya kod verilen bir doğruluk tablosu çıktısı verebilecek bir widget yazmaktır.

Giriş

Girdi, Doğruluk Tablosunu oluşturmak için mantık deyimini içeren bir dize (veri yapısı gibi) olacaktır. Örneğin:

p ∧ q

Bu p and q(mantıksal iletim) anlamına gelir ve çıktı:

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

Boşluğa dikkat edin: Sütun öğesi başlığın ortasında

Karakterler

Baytlarla değil karakterlerle puanlama Mantık karşılaştırma karakterleri özeldir ve her zaman göründükleri gibi değildir. Şu karakterleri kullanın:

Mantıksal Bağlaç (AND): ∧U + 2227

Mantıksal Ayrılma (VEYA): ∨U + 2228

Mantıksal Negatif (NOT) ~veya ¬U + 7e ve U + ac

Bonuslar

Tüm bu bonuslar isteğe bağlıdır, ancak puanınızı düşürür. Herhangi birini seçin.

Mantıksal Olumsuzluk

Mantıksal Olumsuzluk, doğruluk tablolarında tek bir operatördür. !Çoğu C tabanlı dilde eşdeğerdir . false=> trueVe tersini yapar . Bir ¬ veya ile işaretlidir ~(her ikisini de desteklemelisiniz). Bunu desteklemek puanınızın% 10'unu kesecektir. Ancak sonuçlarını göstermek için ek bir sütun eklemelisiniz: Örneğin:

~p ∧ q

çıktı olacak:

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

Güzel Baskı

Normal tablo gösterimi sıkıcıdır. Hadi güzel yapalım! Güzel baskı formatı aşağıdaki p ∧ qgibidir:

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

Güzel baskı için özel detaylar:

• Her hücrede 1 boşluk dolgusu vardır
• Hücre değerleri hala ortalanmış

Tablolarınızı güzel bir şekilde yazdırırsanız, kodunuzdan sonra 0.6 ile çarpın. Bu bonus için bu işlevi kullanın:

score = 0.6 * code

Örnekler

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

kurallar

• Standart boşluklar geçerlidir
• Harici kaynak yok
• Kuralları ihlal edecekseniz, akıllı olun;)

En kısa Kod (karakter cinsinden) kazanır. İyi şanslar!

JavaScript (ES6), 141

Basit fonksiyon, bonus yok, 141 karakter. (140 uft8, 1 unicode genişliğinde)

Karmaşık fonksiyon yönetimi ~ veya ¬, 254 karakter (253 utf, 1 unicode genişliğinde), skor 229

alertBunun yerine kullanarak 6 bayt kaydedilebilir console.log, ancak alerttabloları görüntülemek özellikle uygun değildir.

Aşağıdaki snippet'i EcmaScript 6 uyumlu bir tarayıcıda çalıştırmayı test edin (Firefox ile test edilmiştir. Chrome desteklemediği için Chrome'da çalışmaz .... Ayrıca, bonus sürümü splitFirefox'a özgü bir uzantı kullanır ).

/* 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 şablonu - 2347 karakter

MediaWiki'nin {{#expr}}mantıksal ifadeleri işleyebilen yerleşik bir şablon işlevi vardır . Bu MediaWiki şablonları için mükemmel bir meydan okuma olmalı! Değişkenler, döngüler ve okunabilir bir sözdizimi gibi özellikler biraz yardımcı olabilirdi. Ayrıca, expr işlevi için NOT operatörü olmaması, onu biraz daha karmaşık hale getirdi.

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

Ölçek:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Sonuç:

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

ParserFunctions uzantıları yazılım ile birlikte geliyor MediaWiki> = 1.18, varsayalım.

Python - 288 karakter (+10 ceza çünkü unicode çalışamadım: c)

Bonus yok. Bu benim ilk codegolf cevabım.

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 girdidir.

EDIT: Birkaç boşluk kaldırıldı ve artık girdi olarak işlev argümanlarını kullanıyor.

Dyalog APL , 58 48 karakter

⎕IO←0Birçok sistemde varsayılan olan gerektirir . Dizeyi argüman olarak alır.

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

Bonus yok, ama artı tarafta, herhangi bir operatör çalışıyor.

⍳4 ilk dört endeks (0 1 2 3)

⌽ geri (3 2 1 0)

2 2⊤ iki bit Boole tablosu

↓ iki elemanlı liste listesine bölün (yüksek bitler, düşük bitler)

p q←p ve q  olarak sakla

≢ taksitli (2) *

9⍴ uzunluğu 9'a kadar periyodik olarak yeniden şekillendirin (2 2 2 2 2 2 2 2 2)

324⊤⍨ böylece 324'ü ikili olarak kodlayın (1 0 1 0 0 0 1 0 0)

\⍨ bunu genişletmek için kullanın (her 0 için bir boşluk ekleyin) ...

'FT '[... ] dizini "FT"

 ⍎⍵ çalıştırılan argüman ( p ve q artık değerleri olduğundan)

 ⍪ bunu bir sütun matrisine dönüştür

 q, Başa eklenen oluşan bir kolon q (1 1 0 0)

 q,p'den  oluşan bir sütunun önüne (1 0 1 0)

(... aşağıdakilerden )⍪ oluşan bir satır ekleyin

 ⍵ argüman

 'p q ', "p q" dizesi ile eklenmiş

* Yıldızı Lütfen bu sorunu görürseniz ≢olarak ≢değil, olduğu gibi ̸≡.

Julia, 161 bayt

Bonus yok.

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 Bayt

golfed:

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

Bir Mathematica uzmanı değil, ama doğrudan karakter karşılaştırması yapmakla karşılaştırıldığında bunu oldukça zarif buldum.

Olumsuzluk için işe yarayan bir çözümüm vardı, ancak bu puan düşüşünün başlayacağından daha uzundu.

Güzel baskı için neyin uygun olduğuna bağlı olarak, bu bonusu deneyebilirim. Mathematica'da ASCII'de çıktı almak, puan azaltmanın telafi edilmesi için çok pahalı olacağını hissediyorum, ancak iki ana özellik noktalı bir kenarlık ve hücrelerin içinde belirtilen dolgu ise, Grid'de sadece birkaç seçenek var.

Güzel baskı ile 171 * 0.6 = 102.6 Bayt

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 Bayt

Bonus yok (sonunda bonus ile)

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

Kutusundan çıkarılmış Unicode desteği için Python3'e ihtiyaç var.

DJgamer98 Python koduna dayanarak, masasının doğru olmadığını anlamak.

Edit1: Farklı değişkenlere bölme ve işleç dizesi değişkenini takma

Edit2: (ab) F ve T'yi hem değişken hem de dize karakteri olarak kullanma

Edit3: NoOneIsHere sayesinde bir yerden tasarruf

Bonus ile, 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 Bayt

335 karakter daha az% 10 olumsuzlama için. Biçimlendirme tamamlanmadı ancak tamamlamanın etkisinin ne olduğunu görmeden gönderiyorum.

C / C ++ olarak işaretlendi çünkü gcc ve g ++ bunu -fpississive ile kabul ediyor ve bana C ++ 'dan çok daha fazla C gibi görünüyor.

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

Eminim uygulanabilecek birkaç değişiklik var. Aslında, notları işlemek% 10'dan fazla bonus kaldırır.

Bu, girdi biçiminin belirtildiği gibi olduğunu varsayar, yani önek olmadan veya başka bir şey olmadan veya başka bir şey olmadan 2 giriş değeri (p ve q) ve tüm simgeler tek bir boşlukla sınırlanır.

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

ve testler:

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"})]&

özel kullanım karakter U+F3C7temsil \[Transpose].

Neyse ki bizim için Mathematica golfçüler ∧ve ∨ zaten temsil Andve Orböylece tek yapmamız gereken girdi dizesini bir Mathematica ifadesine dönüştürmek ve üzerinde sembolik mantıksal işlemler yapabiliriz.

Bu çözümün Not( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻) ve Nor( ⊽) işlevlerini de ele alacağını unutmayın, ancak ~pMathematica'da sözdizimi hatası olduğu için bonusu almaz . Meh.

açıklama

b=ToExpression@#

Giriş dizesini bir Mathematica ifadesine dönüştürür ve içine kaydeder b.

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

Bu, girdinin olası her alt ifadesinin bir listesidir. Her biri kendi sütununu alacaktır.

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

Bu, girdide görünen tüm değişkenlerin listesidir.

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

Girdi ifadesini alan #ve değişkenler için olası tüm doğruluk değerleri kombinasyonları için doğruluk değerleri listesini döndüren saf işlev .

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

İfadenin kendisini bu listeye ekler.

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

Bu işlevi girdinin her alt ifadesine uygular.

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

Ardından true ( 0<1) yerine "T" ve false ( 0>1) yerine "F" yazın.

(...)

Satırları ve sütunları değiş tokuş edin.

Grid[...]

Sonucu a olarak görüntüleyin Grid.

TraditionalForm@Grid[...]

GridSüslü sembolleri kullanması için geleneksel forma dönüştürün .