Syntax

~nicht
/\und
\/oder
twahr
ffalsch
P, Q, FISH, etc: Variablen

(Die Operatoren werden in der Rangfolge angegeben.)

Einführung

Einige Boolesche Formeln können in andere Formen geändert werden, um sie zu verkürzen. Zum Beispiel die Formel

~(~P /\ ~Q)

kann in die kürzere Form geändert werden

P\/Q

während die Formel

P \/ ~P

kann in die kürzere Form geändert werden

t

Herausforderung

In dieser Herausforderung sind Sie verpflichtet , ein Programm zu schreiben , dass, da jede Boolesche Formel nur /\, \/, ~, t, f, Klammern, boolean Variablen (in Großbuchstaben) und Leerzeichen, gibt eine kürzeste Form (da es mehr sein kann als eine kürzeste Form ) in Zeichen des Ausdrucks, der für alle Zuweisungen der Variablen äquivalent ist. Der kürzeste Code (in einer beliebigen Sprache) gewinnt. I / O kann auf jede vernünftige Weise erfolgen.

Da sich die Antworten nur schwer überprüfen lassen, ist es hilfreich (aber nicht erforderlich), eine kurze Erläuterung der Funktionsweise des Codes beizufügen.

Oh richtig, ich habe vergessen, meine Antwort jemals wirklich zu posten. Es verwendet im Wesentlichen denselben Ansatz wie die Antwort von KSab , gibt jedoch nur den kürzesten gültigen Ausdruck aus.

Python3, 493

e=lambda x:eval(x.replace('\\/','+').replace('/\\','%'),None,w)
class V(int):
 def __add__(s,o):return V(s|o)
 def __mod__(s,o):return V(s*o)
 def __invert__(s):return V(-s+1)
import re;from itertools import product as P;t=V(1);f=V(0);i=input();v=re.findall('[A-Z]+',i)
for k in range(1,len(i)):
 for m in P(''.join(v)+'~/\\tf',repeat=k):
  m=''.join(m)
  try:
   for d in P((V(0),V(1)),repeat=len(v)):
    w=dict(zip(v,d))
    if e(m)!=e(i):raise
  except:continue
  print(m);exit()
print(i)

Beachten Sie, dass der Hash, den ich zuvor berechnet habe, die abschließende Newline enthielt, bevor ich Golf gespielt def e(x): returnhabee=lambda x:

Python 616

Nicht besonders effizient, arbeitet aber in angemessener Zeit für Eingaben, deren Ergebnisse etwa 5 oder 6 Zeichen betragen. Um eine Zeichenfolge auf Übereinstimmung zu prüfen, durchläuft sie alle möglichen Kombinationen von Wahr- und Falschwerten für alle Variablen und stellt sicher, dass alle übereinstimmen. Damit prüft es jeden möglichen String, der aus den relevanten Zeichen besteht (nicht einmal notwendigerweise ein syntaktisch korrekter).

Tatsächlich wird jeder äquivalente Ausdruck (in jeder Größe) gedruckt und wird nie beendet.

Code:

c=['t','f'];o=['1 ','0 ']
def e(s,v):
 for k in v:s=s.replace(k,v[k])
 return eval(s)
def z(t,p='~/\\() '):
 w=[]
 if p=='':return[t]*(t not in['']+c)
 for s in t.split(p[0]):w.extend(z(s,p[1:]))
 w.sort(key=lambda v:-len(v));return w
def m(v):
 l=list('~\\/()')+v
 for s in l:yield s
 for r in m(v):
    for s in l:yield s+r
def n(x):
 if x<1:yield []
 else:
    for l in n(x-1):
     for b in o:yield[b]+l
t=raw_input();v=z(t)+c;l=len(v)
for s in m(v):
 g=1
 for y in n(l):
    y[-2:]=o;d=dict(zip(v+['/\\','\\/','~'],y+['and ','or ','not ']))
    try:
     if e(s,d)!=e(t,d):g=0
    except:g=0
 if g:print s

Eingabe / Ausgabe:

> ~(~P /\ ~Q)
Q\/P
P\/Q
...

> P /\ ~P
f
~t
...

> (P \/ Q) /\ P
P
(P)
...