คุณได้รับชุดของคำสั่งตรรกะ ความท้าทายของคุณคือการลบสิ่งที่ขัดแย้งกับคนอื่น แต่ในทางที่ดีที่สุด (เช่นลบข้อความจำนวนน้อยที่สุด)

ท้าทาย

คุณจะเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เป็นรายการของข้อความสั่งให้ลบจำนวนข้อความที่น้อยที่สุดเพื่อให้มีวิธีแก้ปัญหาและให้ผลลัพธ์ที่เหลือ

ตรรกะ

คำสั่งประกอบด้วยตัวแปร 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

ระบบลอจิกประกอบด้วย 1 หรือมากกว่างบ

วิธีการแก้ปัญหาให้กับระบบตรรกะเป็นรัฐที่ทั้งหมดเป็นงบเป็นจริงพร้อมกัน

ตัวอย่างของระบบลอจิก:

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)

เอาท์พุต

คุณต้องส่งคืนชุดคำสั่งที่ลดลง (อาจ) ในรูปแบบที่แน่นอนที่คุณได้รับ อีกครั้งรายการที่สามารถจัดรูปแบบเป็นอาร์เรย์ของสตริงหรือสตริงที่คั่นด้วยขึ้นบรรทัดใหม่หรือคั่นด้วยช่องว่าง

กฎระเบียบ

• คุณควรลบจำนวนงบน้อยที่สุดเสมอ หากมีวิธีแก้ปัญหาที่เป็นไปได้หลายอย่างให้ส่งหนึ่งในนั้น
• คุณอาจสมมติว่าอินพุตมีคำสั่งอย่างน้อย 1 คำสั่งเสมอและจะไม่มีคำสั่งใด ๆ ซ้ำในอินพุต
• คุณอาจไม่คิดว่าเอาท์พุทมักจะมีคำสั่ง (ดูตัวอย่าง)
• การใช้ช่องโหว่มาตรฐานขัดแย้งกับคำตอบของคุณว่าถูกต้องและหนึ่งในนั้นต้องถูกลบออก
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

ตัวอย่าง

การป้อนข้อมูล:

A^(-A)

เอาท์พุท:

(nothing)

การป้อนข้อมูล:

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

เอาท์พุท:

A^B A<->B

การป้อนข้อมูล:

["AvB","A^B"]

เอาท์พุท:

["AvB","A^B"]

Ruby, 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 = ศูนย์จากภายในรูบีดังนั้นคุณจะไม่ได้รับคำเตือนมากมายเกี่ยวกับการกำหนดค่าคงที่ใหม่
• โปรดทราบว่าจริง ๆ แล้วมันตั้งค่าตัวแปร "v" เช่นกัน แต่ก็ไม่ได้สร้างความแตกต่าง
• ใช้ค่าความจริงเพราะพวกเขามีตัวดำเนินการที่จำเป็นทั้งหมดอยู่แล้วยกเว้นนัย น่าเสียดายที่ Ruby ไม่มีคลาสบูลีนดังนั้นเราต้องลิง-patch Object เพื่อให้ได้ความหมาย :)
• อาจทำให้สั้นลงหากเราตั้งค่าตัวแปรตัวพิมพ์ใหญ่ทั้งหมด แต่จากนั้นจะใช้เวลานานในการรัน น่าจะมีข้อแม้ในคำถามเกี่ยวกับเรื่องนั้น

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 ไบต์

ตอนนี้ไม่ได้ตีกอล์ฟมากนัก แต่ฉันคิดว่าฉันจะเอาลูกบอลกลิ้งไปพร้อมคำตอบ ลองมันนี่ , 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)