Size bir dizi mantık ifadesi verilir. Zorluğunuz, diğerleriyle çelişen, ancak en uygun şekilde kaldırmaktır (yani, minimum sayıda ifadeyi kaldırmak).

Meydan okuma

Bir program veya girdi olarak ifadelerin bir listesini alan bir çözüm yazacaksınız, bir çözüm bulunacak ve geri kalan çıktıyı çıkaracak şekilde minimum sayıda ifadeyi kaldıracaksınız .

Mantık

İfadeler değişkenler A-Z ve aralarındaki operatörlerden oluşur .

5 operatör vardır : -(değil), v(veya), ^(ve), ->(if) ve <->(iff).

Doğruluk tablosu:

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

Bu operatörler parantez ile birleştirilebilir ():

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

Mantık sistemleri 1 veya daha fazla ifadeden oluşur .

Mantık sistemine bir çözüm , tüm ifadelerin aynı anda doğru olduğu bir durumdur .

Mantık sistemlerine örnekler:

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

Tek çözüm olduğunu A = 1, B = 0.

A^B
-(B<->A)

Bunun çözümü yok ; ifadelerin hiçbir kombinasyonu olmadan Ave Bher iki ifade de doğrudur.

Giriş

Girdi olarak bir dizi ifade alacaksınız . Bu, STDIN veya bir dizi (uygun biçimde) veya yeni satırla ayrılmış veya boşlukla ayrılmış bir dize olarak biçimlendirilmiş işlev bağımsız değişkenleriyle alınabilir.

İfadeleri (Neredeyse- aşağıdaki biçimde olacaktır 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" / "^" / "->" / "<->"

Örnek ifadeler:

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

Çıktı

(Muhtemelen) azaltılmış ifade kümesini tam olarak aldığınız biçimde geri göndermelisiniz. Yine, liste bir dize dizisi veya satırsonu veya boşlukla ayrılmış bir dize olarak biçimlendirilebilir.

kurallar

• Her zaman minimum sayıda ifadeyi kaldırmalısınız. Birden fazla olası çözüm varsa, bunlardan birini alın.
• Girdinin her zaman en az 1 deyim içerdiğini ve girdide hiçbir deyimin tekrarlanmadığını varsayabilirsiniz.
• Çıktının her zaman bir ifade içerdiğini varsayamazsınız. (örneklere bakın)
• Standart boşlukların kullanılması yanıtınızın geçerli olmasıyla çelişir ve bunlardan biri kaldırılmalıdır.
• Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

Örnekler

Giriş:

A^(-A)

Çıktı:

(nothing)

Giriş:

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

Çıktı:

A^B A<->B

Giriş:

["AvB","A^B"]

Çıktı:

["AvB","A^B"]

Yakut, 299 298 283 279 bayt

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

• Bir ifade dizisi bekler.
• Çalıştıracaksanız, sabitleri yeniden tanımlamakla ilgili çok fazla uyarı almamak için ruby ​​içinden $ VERBOSE = nil değerini ayarlayın.
• Aslında "v" değişkenini de ayarladığını, ancak bir fark yaratmadığını unutmayın.
• Doğruluk değerlerini kullanır, çünkü ima hariç, gerekli tüm operatörlere zaten sahiptirler. Ne yazık ki Ruby'nin boolean sınıfı yok, bu yüzden ima etmek için Object'i yamalamak zorundayız :)
• BÜTÜN büyük harf değişkenleri ayarlasaydık daha kısa yapabilirdi, ama daha sonra çalışması çok zaman alacaktı. Muhtemelen bununla ilgili soruda bir uyarı olmalı.

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 bayt

Şu anda çok golf değil, ama topu bir cevapla yuvarlayacağımı düşünüyorum. Deneyin burada , g()ana fonksiyonudur.

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)