Jeśli pamiętasz swoje lata szkolne, możesz pamiętać o poznawaniu tabel prawdy . Wydawały się nudne, ale są podstawą logiki i (niektórzy twierdzą) wszystkich komputerów ...

Problem

Twoim zadaniem, jeśli zdecydujesz się to zaakceptować, jest napisanie programu, funkcji lub widżetu kodu, który może wypisać dane wejściowe z tabeli prawdy.

Wejście

Dane wejściowe będą ciągiem (podobnym do struktury danych) zawierającym instrukcję logiczną, z której zostanie utworzona tablica prawdy. Na przykład:

p ∧ q

Oznacza to p and q(sprzężenie logiczne) i spowoduje:

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

Zwróć uwagę na odstępy: element kolumny znajduje się na środku nagłówka

Postacie

Ocena za pomocą znaków, a nie bajtów Znaki porównania logicznego są wyjątkowe i nie zawsze wyglądają. Użyj tych znaków:

Logiczna koniunkcja (AND): ∧U + 2227

Logiczne rozłączenie (OR): ∨U + 2228

Negacja logiczna (NOT) ~lub odpowiednio ¬U + 7e i U + ac

Bonusy

Wszystkie te bonusy są opcjonalne, ale powalą punkty na Twój wynik. Wybierz dowolny.

Logiczna negacja

Logiczna negacja jest jednym operatorem w tabelach prawdy. Jest to odpowiednik !w większości języków opartych na C. To sprawia, że false=> truei odwrotnie. Jest oznaczony symbolem ¬ lub ~ (musisz obsługiwać oba). Wspieranie tego powali 10% twojego wyniku. Musisz jednak dodać dodatkową kolumnę, aby pokazać jej wyniki: Na przykład:

~p ∧ q

wyświetli:

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

Ładny druk

Normalny zapis w tabeli jest nudny. Zróbmy to ładnie! Ładny format wydruku p ∧ qjest następujący:

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

Specjalne szczegóły dla ładnego drukowania:

• W każdej komórce znajduje się 1 dopełnienie spacji
• Wartości komórek są nadal wyśrodkowane

Jeśli ładnie wydrukujesz swoje tabele, z kodu, a następnie pomnóż przez 0,6. Użyj tej funkcji, aby uzyskać ten bonus:

score = 0.6 * code

Przykłady

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

Zasady

• Obowiązują standardowe luki
• Brak zasobów zewnętrznych
• Jeśli masz zamiar złamać zasady, bądź sprytny;)

Najkrótszy kod (w znakach) wygrywa. Powodzenia!

JavaScript (ES6), 141

Prosta funkcja, bez premii, 141 znaków. (140 uft8, 1 szerokość Unicode)

Złożona funkcja obsługująca ~ lub ¬, 254 znaki (253 utf, 1 szerokość Unicode), wynik 229

Może zaoszczędzić 6 bajtów alertzamiast console.log, ale alertjest szczególnie nieodpowiedni do wyświetlania tabel.

Przetestuj poniższy fragment kodu w przeglądarce zgodnej z EcmaScript 6 (testowany z Firefoksem. Nie będzie działał w Chrome, ponieważ Chrome nie obsługuje .... Ponadto, wersja bonusowa używa tego rozszerzenia splitspecyficznego dla Firefoksa).

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

Szablon MediaWiki - 2347 znaków

MediaWiki ma wbudowaną funkcję szablonu o nazwie, {{#expr}}która może obsługiwać wyrażenia logiczne. To musi być idealne wyzwanie dla szablonów MediaWiki! Jednak pomogłyby takie funkcje, jak zmienne, pętle i czytelna składnia. Również fakt, że nie ma operatora NOT dla funkcji expr, spowodował, że była ona nieco bardziej złożona.

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

Test:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Wynik:

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

Zakładam, że MediaWiki> = 1.18, w którym rozszerzenia ParserFunctions są dostarczane wraz z oprogramowaniem.

Python - 288 znaków (+10 kar, ponieważ nie mogłem zmusić Unicode do działania: c)

Brak bonusów. To moja pierwsza odpowiedź na 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 jest wejściem.

EDYCJA: Usunięto kilka spacji i używa teraz argumentów funkcji jako danych wejściowych.

Dyalog APL , 58 48 znaków

Wymaga ⎕IO←0, co jest domyślne w wielu systemach. Bierze ciąg jako argument.

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

Brak bonusów, ale na plus każdy operator działa.

⍳4 pierwsze cztery wskaźniki (0 1 2 3)

⌽ rewers (3 2 1 0)

2 2⊤ dwubitowy stół boolowski

↓ podzielony na dwuelementową listę list (high-bit, low-bit)

p q← zapisz jako p i q

≢ podsumuj je (2) *

9⍴ cyklicznie przekształcaj to do długości 9 (2 2 2 2 2 2 2 2 2)

324⊤⍨ w ten sposób koduje 324, tj. jako 12-bitowy plik binarny (1 0 1 0 0 0 1 0 0)

\⍨ użyj tego, aby rozwinąć (wstaw spację dla każdego 0) ...

'FT '[... ] ciąg „FT”, indeksowany przez

 ⍎⍵ wykonany argument (poprawny, ponieważ p i q mają teraz wartości)

 ⍪ zrób to w matrycę kolumny

 q, wstaw kolumnę składającą się z q (1 1 0 0)

 q, wstaw kolumnę składającą się z p (1 0 1 0)

(... )⍪ wstaw wiersz powyżej, składający się z

 ⍵ argument

 'p q ', poprzedzony ciągiem „p q”

* Oznacz ten problem gwiazdką, jeśli widzisz ≢jako ≢i nie jako ̸≡.

Julia, 161 bajtów

Brak bonusów.

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)

Nie golfowany:

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 bajtów

Gra w golfa:

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

Nie golfowany:

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

Nie jestem ekspertem od matematyki, ale uznałem to za dość eleganckie w porównaniu do konieczności bezpośredniego porównywania postaci.

Miałem rozwiązanie, które działało na negację, ale było dłuższe, niż obniżenie wyniku.

W zależności od tego, co kwalifikuje się do ładnego drukowania, mogę spróbować tego bonusu. Wydaje mi się, że wyświetlanie w ASCII w Mathematica byłoby zbyt drogie, aby zrównoważyć wynik, ale jeśli dwie główne cechy to kropkowana ramka i określone wypełnienie w komórkach, to tylko kilka opcji w siatce.

Z ładnym drukiem, 171 * 0,6 = 102,6 Bajtów

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 bajtów

Bez premii (z premią na końcu)

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

Potrzebuję Python3 do obsługi Unicode po wyjęciu z pudełka.

Oparty na kodzie Python DJgamer98, ustalenie, że jego stół jest niewłaściwy.

Edycja1: Podział na odrębne zmienne i odrzucenie zmiennej łańcuchowej operatora

Edycja2: (ab) używając F i T jako zmiennych i znaków łańcuchowych

Edycja3: Oszczędność jednego miejsca dzięki NoOneIsHere

Z premią, 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 bajtów

335 znaków mniej niż 10% na obsługę negacji. Formatowanie niekompletne, ale przesłanie, zanim zobaczę, jaki jest wpływ zakończenia.

Oznaczone jako C / C ++, ponieważ moje gcc i g ++ akceptują to z opcją -fpermissive i dla mnie wygląda to bardziej C niż 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");}}

Jestem pewien, że jest kilka poprawek, które można zastosować. W rzeczywistości obsługa notatek dodaje więcej niż 10% usunięć premii.

Zakłada się, że format wejściowy jest zgodny z podanymi, tj. 2 wartości wejściowe (p i q), z prefiksem non i bez oraz bez innych elementów i bez nich oraz wszystkie tokeny rozdzielone pojedynczą spacją.

Nie golfowany:

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

i testy:

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 znaków

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

jest znakiem U+F3C7reprezentującym prywatny użytek \[Transpose].

Na szczęście dla nas golfistów Mathematica, ∧i ∨ już reprezentacji Andi Ortak wszystko co musimy zrobić, to przekształcić ciąg wejściowy na wypowiedzi Mathematica i możemy zrobić symboliczne operacje logiczne na nim.

Zauważ, że to rozwiązanie będzie również obsługiwać Not( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand( ⊼), Xor( ⊻) i Nor( ⊽), ale nie dostanie premii, ponieważ ~pjest to błąd składniowy w Mathematica. Meh

Wyjaśnienie

b=ToExpression@#

Konwertuje ciąg wejściowy na wyrażenie Mathematica i przechowuje go w b.

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

Jest to lista wszystkich możliwych podwyrażeń danych wejściowych. Każdy otrzyma własną kolumnę.

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

To jest lista wszystkich zmiennych pojawiających się na wejściu.

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

Czysta funkcja, która przyjmuje wyrażenie wejściowe #i zwraca listę wartości prawdy dla wszystkich możliwych kombinacji wartości prawdy dla zmiennych.

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

Dołącza samo wyrażenie do tej listy.

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

Stosuje tę funkcję do każdego podwyrażenia wejścia.

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

Następnie zamień true ( 0<1) na „T”, a false ( 0>1) na „F”.

(...)

Zamień wiersze i kolumny.

Grid[...]

Wyświetl wynik jako Grid.

TraditionalForm@Grid[...]

Konwertuj na Gridtradycyjną formę, aby używała fantazyjnych symboli.