Wahrheitstabellen: Der Computer Ihres Urgroßvaters

13

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!

BürgermeisterMonty
quelle
4
Nach der Beschreibung klang es so, als ob es sich um willkürliche boolesche Ausdrücke handelte. Aber alle Beispiele (ohne Bonus) haben nur einen Operator. Ist dies auf einen einzigen Bediener beschränkt? Außerdem lauten die Namen der Werte in den Beispielen alle pund q. Sofern sie nicht immer diese Namen haben, möchten Sie möglicherweise in den Testbeispielen einige verschiedene Optionen anzeigen. Sind sie immer ein einzelner Buchstabe?
Reto Koradi
2
Da dies Nicht-ASCII-Zeichen verwendet, kann es sinnvoll sein, anzugeben, ob die Länge des Codes in Zeichen oder Bytes angegeben wird. Wenn es sich um Bytes handelt, ist es hilfreich zu wissen, wie viele Bytes die Unicode-Zeichen verwenden.
Reto Koradi
Vereinfachen Sie :). score = 0.6 * (code - 15)=.6 * code - 9
mınxomaτ
@RetoKoradi geändert. Ergebnis nach Zeichen, nicht nach Bytes
MayorMonty
@RetoKoradi Wenn das, was mein Geometrielehrer mir sagt, richtig ist, werden Sie nie mehr als p qund rin einer Wahrheitstabelle sehen;)
MayorMonty

Antworten:

6

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>

edc65
quelle
1
+1, ich liebe JavaScript und diese Lösung verdient eine positive Bewertung.
Arjun
JavaScript ist meine Muttersprache, aber ich lasse mich nicht davon beeinflussen! : D Gute Arbeit!
MayorMonty
6

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.

Löwe
quelle
2
Willkommen bei Programming Puzzles und Code Golf. Die Verwendung von MediaWiki ist nichts, woran ich gedacht hätte. +1. Es fehlt jedoch das zusätzliche Spaltenverhalten des Operators ¬/ ~. Wenn Sie es hinzufügen, qualifizieren Sie sich für einen 10%Bonus.
wizzwizz4
Mir ist gerade klar geworden, dass das Hinzufügen dieser Spalte die Anzahl der Zeichen erhöht, wenn ich keine verschachtelten Vorlagen verwenden kann (was könnte die Regeln ein bisschen überdehnen?) ... :)
Leo,
In diesem Fall sollten Sie die Negationsunterstützung wahrscheinlich entfernen, da Sie keine Boni dafür erhalten.
wizzwizz4
Ja, ich werde es untersuchen. Ich denke nicht, dass es große Auswirkungen auf die endgültige Platzierung haben wird ...: D
Leo
1
@leo Das ist großartig, und ich denke, die Verwendung von verschachtelten Vorlagen wäre in Ordnung, wenn Sie nur die Zeichenanzahl der beiden addieren, was heutzutage die akzeptierte Praxis zu sein scheint.
Harry
4

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.

DJgamer98
quelle
1
Willkommen bei PP & CG! Bitte stellen Sie sicher, dass Ihr Code den Regeln gemäß der Frage entspricht. Als Regelspezifikation muss Ihr Code eine Funktion, ein vollständiges Programm oder ein Codebit sein. Dies impliziert, dass die Eingabe STDIN oder Funktionsargumente (oder Äquivalent) sein MUSS. Happy Coding!
MayorMonty
3

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

Adam
quelle
2

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
Alex A.
quelle
1

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]
Xanderhall
quelle
1

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));
Karl Napf
quelle
Willkommen bei PPCG! Sie können ein Byte speichern, indem Sie das Leerzeichen danach entfernen q in c:.
NoOneIsHere
Edit2: Das ist kein Missbrauch. Seht hier , wo ich das erste Zeichen des Dateiinhalts als Dateinamen verwende!
Adám,
1

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;
}
original.legin
quelle
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.

Bildbeschreibung hier eingeben

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.

Genisis
quelle