Syntaxe

~pas
/\et
\/ou
tvrai
ffaux
P, Q, FISH, etc: les variables

(Les opérateurs sont indiqués par ordre de priorité)

introduction

Certaines formules booléennes peuvent être modifiées en différentes formes pour les raccourcir. Par exemple, la formule

~(~P /\ ~Q)

peut être changé en forme plus courte

P\/Q

tandis que la formule

P \/ ~P

peut être changé en forme plus courte

t

Défi

Dans ce défi, vous devez écrire un programme qui, étant donné une formule booléenne en utilisant seulement /\, \/, ~, t, f, entre parenthèses, les variables booléennes (en majuscules), et les espaces, émet une forme plus courte (car il peut y avoir plus d'une forme plus courte ) en caractères de cette expression qui est équivalente pour toutes les affectations des variables. Le code le plus court (dans n'importe quelle langue) gagne. Les E / S peuvent être effectuées de toute manière raisonnable.

De plus, comme les réponses sont difficiles à vérifier, il serait utile (mais pas obligatoire) d'inclure une brève explication du fonctionnement du code.

Oh oui, j'ai oublié de poster ma réponse. Il utilise essentiellement la même approche exacte que celle utilisée par la réponse de KSab , mais n'imprime que l'expression valide la plus courte.

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)

Notez que le hachage que j'ai calculé plus tôt incluait la nouvelle ligne de fin et était avant de jouer def e(x): returnau golf poure=lambda x:

Python 616

Pas particulièrement efficace, mais fonctionne dans un délai raisonnable pour les entrées dont les résultats sont d'environ 5 ou 6 caractères. Pour vérifier une chaîne pour voir si elle correspond, elle parcourt toutes les combinaisons possibles de valeurs vrai / faux pour toutes les variables et s'assure que chacune est d'accord. En utilisant cela, il vérifie chaque chaîne possible composée des caractères pertinents (pas même nécessairement une syntaxiquement correcte).

Il affichera en fait toutes les expressions équivalentes (de toutes les tailles) et ne se terminera jamais.

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

Entrée / sortie:

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

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

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