मुझे गलत साबित करो!

Question

परिचय

जीवन में आपका मिशन सरल है: इंटरनेट पर लोगों को गलत साबित करें!
ऐसा करने के लिए आप आमतौर पर उनके बयानों का सावधानीपूर्वक विश्लेषण करते हैं और उनमें विरोधाभास को इंगित करते हैं।
यह इसे स्वचालित करने का समय है, लेकिन जैसा कि हम आलसी हैं, हम कम से कम प्रयास (पढ़ें: सबसे छोटा कोड) के साथ लोगों को गलत साबित करना चाहते हैं।

विशिष्टता

इनपुट

आपका इनपुट सामान्य सामान्य रूप में एक सूत्र होगा । प्रारूप के लिए, आप नीचे दिए गए प्रारूप का उपयोग कर सकते हैं या अपनी स्वयं की परिभाषा दे सकते हैं, अपनी भाषा की जरूरतों पर (हालांकि आप शुद्ध CNF की तुलना में प्रारूप में अधिक सांकेतिक शब्दों में बदलना नहीं कर सकते हैं)। परीक्षण-मामले (यहां) हालांकि नीचे प्रारूप में दिए गए हैं (हालांकि यह बहुत मुश्किल नहीं होगा कि आप अपना खुद का सृजन करें)।

आपका इनपुट चर की एक सूची की एक सूची में आ जाएगा (आप इसे स्ट्रिंग के रूप में भी पढ़ सकते हैं / तार की आवश्यकता हो सकती है)। इनपुट क्लॉज़ेज़ के सेट के रूप में लिखे गए सामान्य सामान्य रूप (CNF) का एक सूत्र है , प्रत्येक दो सूचियों की सूची है। क्लॉज में पहली सूची पॉजिटिव शाब्दिक (वेरिएबल्स) को एनकोड करती है, दूसरी लिस्ट में नेगेटिव (निगेटिव) लिटरल (वैरिएबल) को एनकोड करती है। खण्ड में प्रत्येक चर एक साथ OR'ed है और सभी खंड एक साथ AND'ed हैं।

इसे स्पष्ट करने के लिए: इसे [[[A,B],[C]],[[C,A],[B]],[[B],[A]]]पढ़ा जा सकता है:
(A OR B OR (NOT C)) AND (C OR A OR (NOT B)) AND (B OR (NOT A))

उत्पादन

आउटपुट बूलियन है, उदाहरण के लिए या तो कुछ सत्य मूल्य या कुछ मिथ्या मूल्य।

क्या करें?

यह सरल है: जांचें कि क्या हाथ में दिया गया फॉर्मूला संतोषजनक है, जैसे कि क्या सभी वेरिएबल्स के लिए सही और गलत के कुछ असाइनमेंट मौजूद हैं जैसे कि समग्र फॉर्मूला "सही" देता है। यदि फॉर्मूला सैटिस्फैक्टिव है और "असत्य" अगर यह नहीं है तो आपका आउटपुट "सही" होगा।
फन-फैक्ट: यह सामान्य मामले में एनपी-पूर्ण समस्या है।
नोट: ट्रुथ-टेबल बनाना और चेक करना कि क्या कोई परिणामी प्रविष्टि सत्य है, अनुमति है।

कॉर्नर केस

यदि आपको एक रिक्त 3-स्तरीय सूची मिलती है, तो उस खंड में ऐसा (सकारात्मक / नकारात्मक) वैरिएबल नहीं है - एक वैध इनपुट।
आप चाहें तो अन्य कोने के मामलों को अपरिभाषित छोड़ सकते हैं।
आप किसी खाली फॉर्मूले (प्रथम स्तर की सूची) पर भी वापस लौट सकते हैं और खाली खंड (2 स्तर की सूची) पर गलत हो सकते हैं।

किसी जीत?

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा जवाब है!
मानक नियम निश्चित रूप से लागू होते हैं।

परीक्षण के मामलों

[[[P],[Q,R]],[[Q,R],[P]],[[Q],[P,R]]] -> true
[[[],[P]],[[S],[]],[[R],[P]],[[U],[Q]],[[X],[R]],[[Q],[S]],[[],[P,U]],[[W],[Q,U]]] -> true
[[[],[P,Q]],[[Q,P],[]],[[P],[Q]],[[Q],[P]]] -> false
[[[P],[]],[[],[P,S]],[[P,T],[]],[[Q],[R]],[[],[R,S]],[[],[P,Q,R]],[[],[P]]] -> false
optional behavior (not mandatory, may be left undefined):
[] -> true (empty formula)
[[]] -> false (empty clause)
[[[],[]]] -> false (empty clause)

Comments

क्या हम इनपुट के रूप में ले सकते हैं (A OR B OR (NOT C)) AND (C OR A OR (NOT B)) AND (B OR (NOT A))?

— Adám

@ Adám, जैसा कि चुनौती में निर्दिष्ट किया गया है, प्रारूप पूरी तरह से आपके ऊपर है, जब तक कि यह सूची-आधारित की तुलना में अधिक जानकारी को एन्कोड नहीं करता है। (जैसे आपने जो फॉर्म्युलेशन दिया है वह पूरी तरह से अनुमति है)

— SEJPM

@SEJPM यदि मैं संकेतन को सही ढंग से समझता हूं, मुझे लगता है कि तीसरे और चौथे परीक्षण के मामले सही होने चाहिए। मैंने प्रतिस्थापित करने की कोशिश की (पी, क्यू) = (११) और (पी, क्यू, आर, एस, टी) = (०,०,०,०,०) और दोनों को सच पाया, इसलिए कम से कम एक होना चाहिए मामला जहां अभिव्यक्ति सही है।

— बसुकक्सुआन

@busukxuan, मुझे 100% यकीन है कि तीसरा और चौथा झूठा है। 3 के लिए): यह {{P,Q},{P,!Q},{!P,Q},{!P,!Q}}(इस क्रम में नहीं) है जो आसानी से दिखाया जा सकता है एक विरोधाभास है। 4 के लिए): यह तुच्छ रूप से एक विरोधाभास है क्योंकि यह वह है P AND ... AND (NOT P)जो स्पष्ट रूप से पी के किसी भी मूल्य के लिए सच नहीं हो सकता है

— SEJPM

मज़ेदार कोड को वास्तव में लिखने के लिए अधिक प्रयास की आवश्यकता होती है।

— user6245072

Answer 1

गणितज्ञ, 12 बाइट्स

SatisfiableQ

ठीक है, वहाँ एक में निर्मित है ...

इनपुट प्रारूप है And[Or[a, b, Not[c], Not[d]], Or[...], ...]। यह खाली उप-अभिव्यक्तियों के लिए सही ढंग से काम करता है , क्योंकि Or[]है Falseऔर And[]है True।

रिकॉर्ड के लिए, एक समाधान जो चुनौती से सूची-आधारित प्रारूप प्राप्त करता है और रूपांतरण स्वयं 44 बाइट करता है, लेकिन ओपी ने एक टिप्पणी में स्पष्ट किया कि कोई भी प्रारूप तब तक ठीक है जब तक कि वह किसी अतिरिक्त जानकारी को एन्कोड नहीं करता है:

SatisfiableQ[Or@@Join[#,Not/@#2]&@@@And@@#]&

Comments

क्योंकि गणितज्ञ ...

— लीक नून

गणितज्ञ के पास वास्तव में बिलियन की एक पागल संख्या है ।_।

— TuxCrafting

@ T @xCräftîñg वास्तव में ।

— jpmc26

स्प्लिट-सेकंड के लिए, मुझे लगा कि यह उत्तर एक अस्पष्ट, स्टैक्ड-बेस्ड एसोलैंग में लिखा गया है, जहां, केवल मौका द्वारा, कमांड अनुक्रम S a t i s f i a b l e Qसमस्या को हल करेगा। तभी, पढ़ने की समझ ने दरवाजे पर दस्तक दी ...

— ojdo

Answer 2

हास्केल, 203 200 बाइट्स

t=1<3
e%((t,f):r)=or((e<$>t)++map(not.e)f)&&e%r
e%_=t
u v b e s|s==v=b|t=e s
s e[]c=1<0
s e(v:w)c=e%c||s(u v t e)w c||s(u v(1<0)e)w c
g v[]=v
g v((t,f):r)=g(v++[x|x<-t++f,notElem x v])r
g[]>>=s(\x->t)

यह चुनौती एक बिल्ट-इन-उत्तर का हकदार है, इसलिए यहां आप जाएं। इसे आइडोन पर आज़माएं । एल्गोरिथ्म बस सभी चर असाइनमेंट की कोशिश करता है और जांचता है कि उनमें से कोई एक सूत्र को संतुष्ट करता है या नहीं।

इनपुट के रूप में है [([],["P","Q"]),(["Q","P"],[]),(["P"],["Q"]),(["Q"],["P"])], हालांकि तार के बजाय समानता के साथ हर प्रकार काम करेगा।

अघोषित कोड:

type Variable   = String
type CNF        = [([Variable], [Variable])]
type Evaluation = (Variable -> Bool)

satisfies :: Evaluation -> CNF -> Bool
satisfies eval [] = True
satisfies eval ((t,f):r) = or(map eval t ++ map (not.eval) f) && satisfies eval r

update :: Evaluation -> Variable -> Bool -> Evaluation
update eval s b var = if var == s then b else eval var

search :: Evaluation -> [Variable] -> CNF -> Bool
search eval [] cnf = False
search eval (v:vars) cnf = satisfies eval cnf || search (update eval v True) vars cnf || search (update eval v False) vars cnf 

getVars :: CNF -> [Variable] -> [Variable]
getVars [] vars = vars
getVars ((t,f):cnf) vars = getVars cnf (vars ++ [v |v<-(t++f), notElem v vars])

isSat :: CNF -> Bool
isSat cnf = search (\x->True) (getVars cnf []) cnf

Answer 3

जावास्क्रिप्ट 6, 69 बी

x=>f=(v,e)=>(e=v.pop())?[0,1].some(t=>f([...v],eval(e+'=t'))):eval(x)

उपयोग:

f('a|b')(['a','b'])
true