일련의 논리 문이 제공됩니다. 당신의 도전은 다른 것들과 모순되지만 최적의 방법으로 (즉, 최소한의 진술을 제거하는) 것을 제거하는 것입니다.

도전

명령문 목록을 입력으로 사용 하고 솔루션 이있는 나머지 명령문 을 출력하는 최소 개수 의 명령문을 제거하는 프로그램 또는 함수를 작성합니다 .

논리

문장은 변수 A-Z 와 그 사이의 연산자 로 구성됩니다 .

5 있습니다 운영자 : -(하지), v(나), ^(그리고), ->(경우) 및 <->(IFF)가.

진실 표 :

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

이 연산자 는 괄호와 함께 결합 될 수 있습니다 ().

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

논리 시스템 은 하나 이상의 문 으로 구성됩니다 .

솔루션 받는 로직 시스템 의 모든 상태 문이 동시에 해당.

논리 시스템의 예 :

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

유일한 해결책 은 A = 1, B = 0입니다.

A^B
-(B<->A)

이것은 해결책 이 없습니다 . 아무의 조합 A과 B의 모두 진술 사실이다.

입력

입력 으로 일련의 명령문 을 수신합니다 . 이것은 STDIN 또는 함수 인수를 통해 취할 수 있으며, 배열 (편리한 형식으로) 또는 개행으로 구분되거나 공백으로 구분 된 문자열로 형식화됩니다.

진술은 다음과 같은 형식으로되어 있습니다 (거의 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" / "^" / "->" / "<->"

예문 :

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

산출

수령 한 정확한 양식으로 축소 된 진술 문을 반환해야합니다. 다시, 목록은 문자열 배열 또는 줄 바꾸기로 구분되거나 공백으로 구분 된 문자열로 형식화 될 수 있습니다.

규칙

• 최소한의 명령문 만 제거해야합니다. 가능한 솔루션이 여러 개인 경우 그 중 하나를 출력하십시오.
• 입력에 항상 적어도 하나의 명령문이 있고 입력에 명령문이 반복되지 않는다고 가정 할 수 있습니다.
• 출력에 항상 명령문이 있다고 가정하지 않아도됩니다. (예시 참조)
• 표준 허점을 사용하면 답변이 유효하고 모순되며 그 중 하나를 제거해야합니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

예

입력:

A^(-A)

산출:

(nothing)

입력:

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

산출:

A^B A<->B

입력:

["AvB","A^B"]

산출:

["AvB","A^B"]

루비, 299 298 283 279 바이트

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

• 식의 배열을 기대합니다.
• 실행하려면 루비 내부에서 $ VERBOSE = nil을 설정하여 상수 재정의에 대한 경고가 많이 발생하지 않도록하십시오.
• 실제로 변수 "v"도 설정하지만 차이는 없습니다.
• 함축을 제외하고 필요한 모든 연산자가 이미 있기 때문에 진리 값을 사용합니다. 불행히도 Ruby에는 부울 클래스가 없으므로 의미를 얻으려면 Object를 원숭이 패치해야합니다. :)
• 대문자 변수를 모두 설정하면 짧아 질 수 있지만 실행하는 데 많은 시간이 걸립니다. 아마도 그것에 대한 질문에주의를 기울여야합니다.

언 골프 드 :

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

파이썬 3, 431 바이트

지금 당장 골프는 아니지만, 나는 대답으로 공을 굴릴 것이라고 생각합니다. 그것을 시도 여기 , g()주요 기능입니다.

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)