एक तर्क प्रणाली को ठीक करना

Question

आपको लॉजिक स्टेटमेंट्स का एक सेट दिया जाता है। आपकी चुनौती किसी भी व्यक्ति को हटाने की है जो दूसरों के विपरीत है, लेकिन इष्टतम तरीके से (यानी कम से कम संख्या में बयानों को हटाते हुए)।

चुनौती

आप एक प्रोग्राम या एक फ़ंक्शन लिखेंगे जो इनपुट को बयानों की सूची के रूप में लेता है, कम से कम संख्या में बयान निकालता है जैसे कि एक समाधान होता है और बाकी को आउटपुट करता है।

तर्क

विवरण में उनके बीच चर 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"]

Comments

मुझे नहीं पता कि क्या यह प्रासंगिक है, लेकिन यह समस्या अधिकतम सेट पैकिंग पर आती है, जो एनपी-पूर्ण है।

— Leif Willerts

आपके व्याकरण के अनुसार, उदाहरण में तीसरा कथन सही नहीं है ( (AvB)->-Bहोना चाहिए (AvB)->(-B))

— गर्वित हैकेलर

@proudhaskeller धन्यवाद, सही किया।

— पुरकाकूदरी

भी, कोष्ठक A<->(Q^C))v((-B)vHमिश-मैश्ड हैं।

— गर्वित हैकेलर

@proudhaskeller फिर से धन्यवाद।

— पुरकाकूदरी

Answer 1

रूबी, 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" को भी सेट करता है, लेकिन इससे कोई फर्क नहीं पड़ता।
• सत्य मूल्यों का उपयोग करता है क्योंकि उनके पास निहित होने के अलावा, पहले से ही सभी आवश्यक ऑपरेटर हैं। दुर्भाग्य से रूबी के पास बूलियन क्लास नहीं है इसलिए हमें निहितार्थ प्राप्त करने के लिए बंदर-पैच ऑब्जेक्ट करना होगा :)
• यदि हम सिर्फ अपरकेस वैरिएबल को सेट करते हैं, तो इसे कम किया जा सकता है, लेकिन तब इसे चलाने के लिए भारी मात्रा में समय लगेगा। शायद उस बारे में सवाल में एक चेतावनी होनी चाहिए।

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

Answer 2

पायथन 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)

Comments

बहुत ही शांत। मैं इसे 428 पर ले आया: repl.it/BCzp

— PurkkaKoodari

जिस तरह से आप सत्य मूल्यों की मॉडलिंग कर रहे हैं उसके साथ एक समस्या है। उदाहरण के लिए, जी ("ए (एवीए) <-> ए") को अपना इनपुट वापस देना चाहिए, लेकिन यह काम नहीं करता है क्योंकि यदि ए = 1, तो एवीए = 2।

— इब्राहिम कोम्परेर

अहा, आप सही कह रहे हैं, इस ओर इशारा करने के लिए धन्यवाद। इसे वापस करने के लिए "और" अभी के लिए मैं तुलना करने के लिए एक छोटे तरीके के बारे में सोच नहीं सकता था। इसके अलावा गोल्फ परिवर्तन के लिए धन्यवाद Pietu!

— मैदाभेरदशेर

मुझे विश्वास vहै or।

— पुरकाकूदरी

...हाँ। धन्यवाद।

— TheMadHaberdasher