Wenn Sie sich an Ihre Schulzeit erinnern, erinnern Sie sich vielleicht an das Lernen von Wahrheitstabellen . Sie schienen langweilig, aber sie sind Grundlage für Logik und (einige würden argumentieren) alle Computer ...

Problem

Wenn Sie dies akzeptieren möchten, besteht Ihre Mission darin, ein Programm, eine Funktion oder ein Widget aus Code zu schreiben, mit dem eine Wahrheitstabelle ausgegeben werden kann.

Eingang

Die Eingabe ist eine Zeichenfolge (wie eine Datenstruktur), die die logische Anweisung enthält, in die die Wahrheitstabelle umgewandelt werden soll. Beispielsweise:

p ∧ q

Dies bedeutet p and q(logische Konjunktion) und gibt Folgendes aus:

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

Beachten Sie den Abstand: Das Element der Spalte befindet sich in der Mitte der Überschrift

Zeichen

Punktzahl über Zeichen, nicht Bytes Die logischen Vergleichszeichen sind etwas Besonderes und nicht immer so, wie sie aussehen. Verwenden Sie diese Zeichen:

Logische Verknüpfung (AND): ∧U + 2227

Logische Disjunktion (OR): ∨U + 2228

Logische Negation (NOT) ~oder ¬U + 7e bzw. U + ac

Boni

Alle diese Boni sind optional, bringen aber Punkte aus Ihrer Punktzahl. Wählen Sie eine aus.

Logische Verneinung

Logische Negation ist ein unärer Operator in Wahrheitstabellen. Dies entspricht den !meisten C-basierten Sprachen. Es macht false=> trueund umgekehrt. Es ist mit einem ¬ oder gekennzeichnet ~ (Sie müssen beide unterstützen). Wenn Sie dies unterstützen, können Sie 10% Ihrer Punktzahl verlieren. Sie müssen jedoch eine zusätzliche Spalte hinzufügen, um die Ergebnisse anzuzeigen: Beispiel:

~p ∧ q

wird ausgeben:

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

Hübscher Druck

Die normale Tischnotation ist langweilig. Lass es uns hübsch machen! Hübsches Druckformat ist wie folgt für p ∧ qist wie folgt:

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

Spezielle Details für hübsches Drucken:

• In jeder Zelle befindet sich ein Leerzeichen
• Zellwerte sind weiterhin zentriert

Wenn Sie Ihre Tabellen schön drucken, aus Ihrem Code und dann mit 0,6 multiplizieren. Nutzen Sie diese Funktion für diesen Bonus:

score = 0.6 * code

Beispiele

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

Regeln

• Es gelten Standardlücken
• Keine externen Ressourcen
• Wenn du die Regeln brechen willst, sei schlau;)

Kürzester Code (in Zeichen) gewinnt. Viel Glück!

JavaScript (ES6), 141

Einfache Funktion, kein Bonus, 141 Zeichen. (140 uft8, 1 Unicode breit)

Komplexe Funktionsbearbeitung ~ oder ¬, 254 Zeichen (253 utf, 1 Unicode-Breite), Punktzahl 229

Könnte 6 Bytes speichern verwenden alertstatt console.log, sondern alertist besonders ungeeignet Anzeige Tabellen.

Testen Sie die Ausführung des folgenden Snippets in einem EcmaScript 6-kompatiblen Browser (getestet mit Firefox. Funktioniert nicht in Chrome, da Chrome dies nicht unterstützt .... Außerdem verwendet die Bonusversion eine Erweiterung split, die Firefox-spezifisch ist.).

/* 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-Vorlage - 2347 Zeichen

MediaWiki verfügt über eine eingebaute Vorlagenfunktion {{#expr}}, die logische Ausdrücke verarbeiten kann. Dies muss die perfekte Herausforderung für MediaWiki-Vorlagen sein! Funktionen wie Variablen, Schleifen und eine lesbare Syntax hätten jedoch ein wenig geholfen. Auch die Tatsache, dass es keinen NOT-Operator für die expr-Funktion gibt, machte sie etwas komplexer.

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

Prüfung:

{{TemplateName|¬X ∧ ~Y}}

{{TemplateName|p ∨ q}}

Ergebnis:

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

Ich gehe von MediaWiki> = 1.18 aus, wo die ParserFunctions-Erweiterungen mit der Software mitgeliefert werden.

Python - 288 Zeichen (+10 Strafe, weil ich den Unicode nicht zum Laufen bringen konnte: c)

Keine Prämien. Dies ist meine allererste Codegolf-Antwort.

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 ist der Eingang.

BEARBEITEN: Einige Leerzeichen wurden entfernt und es werden nun Funktionsargumente als Eingabe verwendet.

Dyalog APL , 58 48 Zeichen

Benötigt ⎕IO←0, was bei vielen Systemen Standard ist. Nimmt string als Argument.

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

Keine Boni, aber auf der positiven Seite arbeitet jeder Bediener.

⍳4 erste vier Indizes (0 1 2 3)

⌽ umgekehrt (3 2 1 0)

2 2⊤ Zwei-Bit-Boolesche Tabelle

↓ Aufteilung in Listen mit zwei Elementen (High-Bits, Low-Bits)

p q← speichern als p und q

≢ teile sie mit (2) *

9⍴ zyklisch umformen auf Länge 9 (2 2 2 2 2 2 2 2 2)

324⊤⍨ Codiere also 324, dh als 12-Bit-Binär (1 0 1 0 0 0 1 0 0)

\⍨ benutze das um zu erweitern (füge ein Leerzeichen für jede 0 ein) ...

'FT '[... ] der String "FT", indiziert von

 ⍎⍵ das ausgeführte Argument (gültig, da p und q jetzt Werte haben)

 ⍪ machen Sie das in eine Spaltenmatrix

 q, Stellt eine Spalte voran, die aus q besteht (1 1 0 0)

 q, Stellen Sie eine Spalte voran, die aus p besteht (1 0 1 0) besteht

(... )⍪ oben eine Zeile einfügen, bestehend aus

 ⍵ das Argument

 'p q ', vorangestellt mit der Zeichenfolge "p q"

* Bitte markieren Sie diese Ausgabe, wenn Sie ≢als ≢und nicht als sehen ̸≡.

Julia, 161 Bytes

Keine Prämien.

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 Bytes

Golf gespielt:

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

Kein Mathematica-Experte, aber ich fand das ziemlich elegant im Vergleich zum direkten Zeichenvergleich.

Ich hatte eine Lösung, die für die Verneinung funktionierte, aber es war länger, als die Punkteverringerung abheben würde.

Je nachdem, was für hübsches Drucken geeignet ist, könnte ich diesen Bonus versuchen. Ich bin der Meinung, dass die Ausgabe in ASCII in Mathematica viel zu teuer wäre, um die Punktzahlreduzierung zu kompensieren. Wenn die beiden Hauptmerkmale jedoch ein gepunkteter Rand und eine festgelegte Auffüllung in den Zellen sind, sind dies nur einige Optionen in Grid.

Bei schönem Druck sind 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

Kein Bonus (mit Bonus am Ende)

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

Python3 für Unicode wird sofort benötigt.

Basierend auf dem Python-Code von DJgamer98 ist es nicht richtig, seinen Tisch herauszufinden.

Edit1: Aufteilen in verschiedene Variablen und Übernehmen der Operatorzeichenfolgenvariablen

Edit2: (ab) Verwenden von F und T als Variablen und Zeichenfolgen

Edit3: Einen Platz sparen dank NoOneIsHere

Mit 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 Zeichen weniger 10% für die Negation. Unvollständige Formatierung, aber Übermittlung, bevor ich sehe, wie sich die Fertigstellung auswirkt.

Als C / C ++ markiert, weil mein gcc und g ++ es mit -fpermissive akzeptieren und es für mich weitaus C-ähnlicher aussieht als 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");}}

Ich bin sicher, es gibt wahrscheinlich ein paar Optimierungen, die angewendet werden könnten. In der Tat erhöht die Behandlung der Notizen den Bonus um mehr als 10%.

Dies setzt voraus, dass das Eingabeformat wie angegeben ist, dh 2 Eingabewerte (p und q), mit oder ohne das Nicht-Präfix und nichts anderes, und alle Token, die durch ein einzelnes Leerzeichen begrenzt sind.

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

und die tests:

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 Zeichen

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

ist das Zeichen U+F3C7für den privaten Gebrauch \[Transpose].

Zum Glück für uns Mathematica-Golfer, ∧und ∨ schon vertreten AndundOr , so alles , was wir tun müssen, ist die Eingabezeichenfolge in einen Mathematica - Ausdruck umwandeln und wir können auf ihn symbolische logische Operationen tun.

Beachten Sie, dass diese Lösung auch Not( ¬), Implies( ), Equivalent( ⧦), Xor( ⊻), Nand(⊼ ), Xor( ⊻) und Nor( ⊽) behandelt, den Bonus jedoch nicht erhält, da ~pes sich in Mathematica um einen Syntaxfehler handelt. Meh.

Erläuterung

b=ToExpression@#

Konvertiert die Eingabezeichenfolge in einen Mathematica-Ausdruck und speichert ihn in b.

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

Dies ist eine Liste aller möglichen Unterausdrücke der Eingabe. Jeder erhält eine eigene Spalte.

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

Dies ist eine Liste aller Variablen, die in der Eingabe angezeigt werden.

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

Reine Funktion, die einen Eingabeausdruck verwendet #und eine Liste von Wahrheitswerten für alle möglichen Kombinationen von Wahrheitswerten für die Variablen zurückgibt.

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

Stellt den Ausdruck selbst vor diese Liste.

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

Wendet diese Funktion auf jeden Unterausdruck der Eingabe an.

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

Ersetzen Sie dann true ( 0<1) durch "T" und false ( 0>1) durch "F".

(...)

Tauschen Sie Zeilen und Spalten aus.

Grid[...]

Zeigen Sie das Ergebnis als an Grid.

TraditionalForm@Grid[...]

Konvertieren Sie die GridForm in die traditionelle Form, sodass die ausgefallenen Symbole verwendet werden.