Viene fornita una serie di istruzioni logiche. La tua sfida è quella di rimuovere quelli che contraddicono gli altri, ma in modo ottimale (cioè rimuovere un numero minimo di affermazioni).

Sfida

Scriverai un programma o una funzione che accetta come input un elenco di istruzioni, rimuove il numero minimo di istruzioni in modo che esista una soluzione e produca il resto.

Logica

Le dichiarazioni sono costituite da variabili A-Z e operatori tra di loro.

Vi sono 5 operatori : -(not), v(o), ^(and), ->(if) e <->(iff).

Tabella della verità:

A | B | -A | AvB | A^B | A->B | A<->B
0 | 0 |  1 |  0  |  0  |   1  |   1
0 | 1 |  1 |  1  |  0  |   1  |   0
1 | 0 |  0 |  1  |  0  |   0  |   0
1 | 1 |  0 |  1  |  1  |   1  |   1

Questi operatori possono essere combinati insieme alla parentesi ():

A | B | -(AvB) | Av(-A) | A^(-A) | (AvB)->(-B)
0 | 0 |    1   |    1   |    0   |      1
0 | 1 |    0   |    1   |    0   |      0
1 | 0 |    0   |    1   |    0   |      1
1 | 1 |    0   |    1   |    0   |      0

I sistemi logici sono composti da 1 o più istruzioni .

Una soluzione al sistema logico è uno stato in cui tutte le istruzioni sono contemporaneamente vere.

Esempi di sistemi logici:

AvB
-(A<->B)
(AvB)->(-B)

L'unica soluzione è A = 1, B = 0.

A^B
-(B<->A)

Questo non ha soluzione ; senza alcuna combinazione di Aed Bentrambe le affermazioni sono vere.

Ingresso

Riceverai una serie di dichiarazioni come input. Questo può essere preso tramite STDIN o argomenti di funzione, formattati come un array (in un formato conveniente) o una stringa separata da nuova riga o separata da spazio.

Le dichiarazioni saranno nella seguente forma (in quasi - ABNF ):

statement        = variable / operation
operation        = not-operation / binary-operation
not-operation    = "-" operand
binary-operation = operand binary-operator operand
operand          = variable / "(" operation ")"
variable         = "A"-"Z"
binary-operator  = "v" / "^" / "->" / "<->"

Esempi di dichiarazioni:

A
Av(-B)
(A<->(Q^C))v((-B)vH)

Produzione

È necessario restituire l'insieme (possibilmente) ridotto di dichiarazioni, nella forma esatta in cui sono state ricevute. Anche in questo caso, l'elenco può essere formattato come una matrice di stringhe o come stringa separata da nuova riga o separata da spazio.

Regole

• È necessario rimuovere sempre il numero minimo di istruzioni. Se sono disponibili più soluzioni, creane una.
• Si può presumere che l'input contenga sempre almeno 1 istruzione e che nessuna input venga ripetuta nell'input.
• Non si può presumere che l'output contenga sempre un'istruzione. (vedi esempi)
• L'uso di scappatoie standard è in contrasto con la tua risposta valida e una di esse deve essere rimossa.
• Questo è code-golf , quindi vince la risposta più breve in byte.

Esempi

Ingresso:

A^(-A)

Produzione:

(nothing)

Ingresso:

A^B A<->(-B) A<->B

Produzione:

A^B A<->B

Ingresso:

["AvB","A^B"]

Produzione:

["AvB","A^B"]

Rubino, 299 298 283 279 byte

class Object;def * o;!self|o;end;def s;w=join.gsub(/\W/,"").chars.uniq;n=w.size;(0..2**n).any?{|i|n.times{|j|eval(w[j]+"=#{i[j]>0}")};all?{|e|eval([%w[<-> ==],%w[-> *],%w[- !],%w[^ &],%w[v |]].inject(e){|x,i|x.gsub(*i)})}}?self:combination(size-1).map(&:s).max_by(&:size);end;end

• Si aspetta una serie di espressioni.
• Se lo eseguirai, imposta $ VERBOSE = zero dall'interno del rubino in modo da non ricevere molti avvisi sulla ridefinizione delle costanti.
• Nota che in realtà imposta anche la variabile "v" ma non fa differenza.
• Utilizza i valori di verità perché hanno già tutti gli operatori richiesti, tranne le implicazioni. Sfortunatamente Ruby non ha una classe booleana, quindi dobbiamo scimmiottare l'Oggetto per ottenere implicazioni :)
• Potrebbe renderlo più breve se impostassimo TUTTE le variabili maiuscole, ma ci vorrebbe molto tempo per essere eseguito. Probabilmente dovrebbe avere un avvertimento nella domanda al riguardo.

Ungolfed:

class Object
  def * o 
    !self|o
  end 
end

def sat? exs 
  #exs: an array of expressions
  s=[%w[<-> ==], %w[-> *], "-!", "^&", %w[v ||]]

  w=exs.join.gsub(/\W/,"").chars.uniq #variable names
  n=w.size
  if (0...2**n).any? {|i|
    n.times do |vi|
      eval("#{w[vi]}=#{i[vi]==1}")
    end 
    exs.all?{|ex|eval(s.inject(ex){|x,i|x.gsub(i[0],i[1])})}
  }
    exs
  else
    exs.combination(exs.size-1).map{|sm|sat?(sm)}.max_by(&:size)
  end
end

Python 3, 431 byte

Non molto golfista in questo momento, ma immagino che farei rotolare la palla con una risposta. Provalo qui , g()è la funzione principale.

import re,itertools as H
def g(i):
 y=re.sub(r'\W','',''.join(set(i)).upper());l=i.split()
 def e(s):
  def f(a):
   for v,w in a:exec(v+'='+w)
   return eval(re.sub('[^A-Z()]+',lambda x:{'v':' or ','^':'*','<->':'==','->':'<=','-':'not '}[x.group()],s))
  return[c for c in H.product("01",repeat=len(y))if f(zip(y,c))]
 for n in range(len(l),-1,-1):
  for q in H.combinations(l,n):
   if e('('+')^('.join(q)+')'):return' '.join(q)