Bạn được cung cấp một tập hợp các câu lệnh logic. Thách thức của bạn là loại bỏ bất kỳ cái nào mâu thuẫn với những cái khác, nhưng theo cách tối ưu (nghĩa là loại bỏ một số lượng tối thiểu các câu lệnh).

Thử thách

Bạn sẽ viết một chương trình hoặc một hàm lấy đầu vào một danh sách các câu lệnh, loại bỏ số lượng câu lệnh tối thiểu sao cho có một giải pháp và đưa ra phần còn lại.

Hợp lý

Báo cáo bao gồm các biến A-Z và toán tử giữa chúng.

Có 5 toán tử : -(không), v(hoặc), ^(và), ->(nếu) và <->(iff).

Bảng chân lý:

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

Các toán tử này có thể được kết hợp cùng với dấu ngoặc đơn ():

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

Hệ thống logic bao gồm 1 hoặc nhiều câu lệnh .

Một giải pháp cho hệ thống logic là một trạng thái trong đó tất cả các câu lệnh đều đồng thời đúng.

Ví dụ về hệ thống logic:

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

Giải pháp duy nhất là A = 1, B = 0.

A^B
-(B<->A)

Điều này không có giải pháp ; không có sự kết hợp Avà Bcả hai tuyên bố là đúng.

Đầu vào

Bạn sẽ nhận được một tập hợp các câu lệnh làm đầu vào. Điều này có thể được thực hiện thông qua STDIN hoặc các đối số hàm, được định dạng dưới dạng một mảng (ở định dạng thuận tiện) hoặc chuỗi phân tách dòng mới hoặc phân tách bằng dấu cách.

Các báo cáo sẽ có dạng sau (gần như- 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" / "^" / "->" / "<->"

Ví dụ báo cáo:

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

Đầu ra

Bạn phải trả lại tập hợp các câu lệnh được giảm (có thể), ở dạng chính xác mà bạn đã nhận được chúng. Một lần nữa, danh sách có thể được định dạng dưới dạng một chuỗi các chuỗi hoặc một chuỗi phân tách dòng mới hoặc phân tách bằng dấu cách.

Quy tắc

• Bạn nên luôn luôn loại bỏ số lượng báo cáo tối thiểu. Nếu có nhiều giải pháp có thể, hãy xuất một trong số chúng.
• Bạn có thể giả sử rằng đầu vào luôn chứa ít nhất 1 câu lệnh và không có câu lệnh nào được lặp lại trong đầu vào.
• Bạn không thể cho rằng đầu ra luôn chứa một câu lệnh. (xem ví dụ)
• Sử dụng sơ hở tiêu chuẩn mâu thuẫn với câu trả lời của bạn là hợp lệ và một trong số chúng phải được loại bỏ.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Ví dụ

Đầu vào:

A^(-A)

Đầu ra:

(nothing)

Đầu vào:

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

Đầu ra:

A^B A<->B

Đầu vào:

["AvB","A^B"]

Đầu ra:

["AvB","A^B"]

Ruby, 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

• Mong đợi một mảng các biểu thức.
• Nếu bạn định chạy nó, hãy đặt $ VERBOSE = nil từ bên trong viên ruby ​​để bạn không nhận được nhiều cảnh báo về việc xác định lại hằng số.
• Lưu ý rằng nó thực sự cũng đặt biến "v" nhưng nó không tạo ra sự khác biệt.
• Sử dụng các giá trị thật vì chúng đã có tất cả các toán tử cần thiết, ngoại trừ hàm ý. Thật không may, Ruby không có lớp boolean nên chúng tôi phải vá khỉ để có được hàm ý :)
• Có thể làm cho nó ngắn hơn nếu chúng ta chỉ đặt TẤT CẢ các biến chữ hoa, nhưng sau đó sẽ mất một lượng lớn thời gian để chạy. Có lẽ nên có một cảnh báo trong câu hỏi về điều đó.

Ung dung:

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

Không phải là chơi gôn ngay bây giờ, nhưng tôi nghĩ rằng tôi sẽ nhận được câu trả lời. Hãy thử nó ở đây , g()là chức năng chính.

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)