Você recebe um conjunto de instruções lógicas. Seu desafio é remover todos os que contradizem os outros, mas da maneira ideal (por exemplo, remover um número mínimo de declarações).
Desafio
Você escreverá um programa ou uma função que recebe como entrada uma lista de instruções, remove o número mínimo de instruções de forma que exista uma solução e gera o restante.
Lógica
As instruções consistem em variáveis A-Z
e operadores entre elas.
Existem 5 operadores : -
(não), v
(ou), ^
(e), ->
(se) e <->
(iff).
Tabela da verdade:
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
Esses operadores podem ser combinados com parênteses ()
:
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
Os sistemas lógicos consistem em 1 ou mais instruções .
Uma solução para o sistema lógico é um estado em que todas as instruções são simultaneamente verdadeiras.
Exemplos de sistemas lógicos:
AvB
-(A<->B)
(AvB)->(-B)
A única solução é A = 1, B = 0
.
A^B
-(B<->A)
Este não tem solução ; sem combinação de A
e B
ambas as afirmações são verdadeiras.
Entrada
Você receberá um conjunto de instruções como entrada. Isso pode ser obtido via STDIN ou argumentos de função, formatados como uma matriz (em um formato conveniente) ou como uma sequência de nova linha ou espaço.
As declarações terão a seguinte forma (quase no 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" / "^" / "->" / "<->"
Exemplos de instruções:
A
Av(-B)
(A<->(Q^C))v((-B)vH)
Resultado
Você deve retornar o conjunto (possivelmente) reduzido de instruções, na forma exata em que as recebeu. Mais uma vez, a lista pode ser formatada como uma matriz de cadeias ou uma cadeia separada por nova linha ou separada por espaço.
Regras
- Você sempre deve remover o número mínimo de instruções. Se houver várias soluções possíveis, imprima uma delas.
- Você pode assumir que a entrada sempre contém pelo menos 1 instrução e que nenhuma instrução é repetida na entrada.
- Você não pode assumir que a saída sempre contém uma declaração. (veja exemplos)
- O uso de brechas padrão contradiz que sua resposta seja válida e uma delas deve ser removida.
- Isso é código-golfe , então a resposta mais curta em bytes vence.
Exemplos
Entrada:
A^(-A)
Resultado:
(nothing)
Entrada:
A^B A<->(-B) A<->B
Resultado:
A^B A<->B
Entrada:
["AvB","A^B"]
Resultado:
["AvB","A^B"]
(AvB)->-B
deve ser (AvB)->(-B)
)
A<->(Q^C))v((-B)vH
são misturados.