क्या सूअर उड़ने में सक्षम हैं?

Question

कार्य

आपका कार्य अपनी पसंद की भाषा में एक समारोह या एक कार्यक्रम लिखना है जो कुछ बयानों का विश्लेषण करता है और यह निर्धारित करता है कि क्या उन बयानों से यह निष्कर्ष निकाला जा सकता है कि सूअर उड़ने में सक्षम हैं।

इनपुट

इनपुट एक स्ट्रिंग है जिसे STDIN से पढ़ा जा सकता है, एक फ़ंक्शन तर्क के रूप में लिया जाता है या एक फ़ाइल में संग्रहीत किया जा सकता है। निम्नलिखित EBNF का उपयोग करके इनपुट का वर्णन किया जा सकता है:

input = statement , {statement};
statement = (("Pigs are ", attribute) | ("Everything that is ", attribute, "is also ", attribute)), ". ";
attribute = [not], ("able to fly" | singleAttribute);
singleAttribute = letter, {letter};
letter = "a" | "b" | "c" | "d" | "e" | "f" | "g"
       | "h" | "i" | "j" | "k" | "l" | "m" | "n"
       | "o" | "p" | "q" | "r" | "s" | "t" | "u"
       | "v" | "w" | "x" | "y" | "z" ;

उदाहरण इनपुट (नीचे अधिक उदाहरण देखें):

Pigs are green. Everything that is green is also intelligent. Everything that is able to fly is also not intelligent. Pigs are sweet. 

उत्पादन

आउटपुट आपके फ़ंक्शन द्वारा वापस किया जा सकता है, फ़ाइल में लिखा जा सकता है या STDOUT में प्रिंट किया जा सकता है। 5 अलग-अलग मामलों को संभाला जाना है:

1. दिए गए कथन मान्य, सुसंगत हैं और तार्किक परिणाम के रूप में हैं जो सूअर उड़ सकते हैं। उस स्थिति में, आपको आउटपुट करना होगा Yes।
2. दिए गए कथन मान्य हैं, सुसंगत हैं और तार्किक परिणाम के रूप में हैं कि सूअर उड़ नहीं सकते हैं। उस स्थिति में, आपको आउटपुट करना होगा No।
3. यह दिए गए, मान्य और सुसंगत बयानों से निष्कर्ष नहीं निकाला जा सकता है कि सूअर उड़ सकते हैं या नहीं। उस स्थिति में, आपको आउटपुट करना होगा Maybe।
4. दिए गए कथन मान्य हैं, लेकिन सुसंगत नहीं हैं (अर्थात दिए गए कथनों में विरोधाभास है)। चूंकि एक्स फाल्सो क्वॉडलिबेट है , हम Yesउस मामले में आउटपुट का फैसला करते हैं ।
5. दिए गए कथन मान्य नहीं हैं, अर्थात वे दिए गए EBNF के अनुसार प्रारूपित नहीं हैं। उस स्थिति में, आप जो चाहें कर सकते हैं।

विवरण

• आप मान सकते हैं कि दी गई विशेषताएँ एक-दूसरे से स्वतंत्र हैं। इसलिए, उदाहरण के लिए, एक सूअर युवा और बूढ़ा, हरा, लाल और नीला हो सकता है, बिना किसी असंगति के। हालांकि, एक सुअर एक ही समय में 'हरा' और 'हरा नहीं' हो सकता है, यह एक विरोधाभास है और इसे (4) में वर्णित किया जाना चाहिए।
• हर विशेषता के लिए, मान लें कि ब्रह्मांड में कम से कम एक ऑब्जेक्ट (जरूरी नहीं कि एक सुअर) है जिसमें दी गई विशेषता है, और एक ऑब्जेक्ट जिसमें यह नहीं है।

उदाहरण इनपुट और आउटपुट

इनपुट:

Pigs are green. Everything that is green is also intelligent. Everything that is able to fly is also not intelligent. 

आउटपुट: चूंकि सूअर हरे होते हैं और इसलिए बुद्धिमान होते हैं, और जो कुछ उड़ने में सक्षम है वह बुद्धिमान नहीं है, सूअर उड़ नहीं सकते हैं। आउटपुट है No।

इनपुट:

Pigs are old. Everything that is not able to fly is also not old. 

आउटपुट: यदि सूअर उड़ने में सक्षम नहीं थे, तो वे भी पुराने नहीं थे। लेकिन जैसा कि वे पुराने हैं, आपको आउटपुट करना होगा Yes।

इनपुट:

Everything that is sweet is also not old. Everything that is intelligent is also blue. 

आउटपुट: Maybe।

इनपुट:

Pigs are not able to fly. Everything that is red is also sweet. Everything that is sweet is also not red. 

आउटपुट: हालांकि पहला कथन यह बताता है कि सूअर उड़ नहीं सकते, निम्नलिखित कथन एक दूसरे के विपरीत हैं और इसलिए आउटपुट होना चाहिए Yes।

इनपुट:

Pigs are very smart. Pigs are able to fly. 

आउटपुट: जो कुछ भी आप चाहते हैं, जैसा कि स्ट्रिंग ऊपर उल्लिखित मानदंडों से मेल नहीं खाती है।

विजेता

यह कोड-गोल्फ है , इसलिए सबसे छोटा सही उत्तर (बाइट्स में) जीतता है। पहला सही उत्तर पोस्ट किए जाने के एक सप्ताह बाद विजेता को चुना जाएगा।

Comments

तीसरा उदाहरण हाँ क्यों देता है?

— xem

मैं एक उत्तर लिखने पर विचार कर रहा हूं जो इनपुट को प्रोलॉग कोड में बदल देता है।

— ताल

आप केवल यह निष्कर्ष निकाल सकते हैं कि लाल कुछ भी मौजूद नहीं है। मीठी, गैर-लाल चीजें ठीक हैं।

— 232 पर user2357112

मैं और अधिक उदाहरणों की उम्मीद कर रहा था, बस इसलिए मैं उन्हें खुद कर सकता हूं।

— cjfaure

@xem: पूर्व फाल्सो क्वॉडलिबेट, इसे विकिपीडिया पर विस्फोट के सिद्धांत के रूप में देखें। यदि एक विरोधाभास मौजूद है, तो कुछ भी साबित किया जा सकता है। अतः यदि exist ईश्वर का अस्तित्व ’सत्य है और does ईश्वर का अस्तित्व नहीं है’ सत्य है, तो कुछ भी सत्य दिखाया जा सकता है, इसलिए सूअर उड़ सकता है, यह सच साबित हो सकता है।

— फाइटरमैगथेफिशन

Answer 1

पर्ल, 363 353 350 347 343 297 266 264

$_=<>;s/able to fly/X/g;$m=' ?(not )?\b(P|\w+)';$h{$1?N.$2:$2}{$3?N.$4:$4}=$h{$3?$4:N.$4}{$1?$2:N.$2}=1while s/$m.{8}$m\.//;map{%x=0,r($_,$_)}%h;sub r{($a,$b)=@_;$e+=$h{$a}{N.$b};$x{$b}++or$h{$a}{$b}=1,map{r($a,$_)}%{$h{$b}}}print$e|$h{P}{X}?Yes:$h{P}{NX}?No:Maybe

Ungolfed / स्पष्टीकरण:

# Read one line from STDIN
$_=<>;
# Replaces special attribute with X
s/able to fly/X/g;
# Prepare attribute match
$m=' ?(not )?\b(P|\w+)';
# Match "Everything that is A is also B. "
#                        "\bA........ \bB\."
# Match "Pigs are B. "
#     "\bP........\bB\."
while(s/$m.{8}$m\.//)
{
  # Add facts for A => B and !B => !A, where A may equal "P" for "Pigs are"
  # Facts are stored as a hash of hashes %h; keys%h are the source attributes;
  # keys%{$h{$a}} are the attributes that follow from attribute $a
  # A "not attribute" is stored as "Nattribute", while a "attribute" is just stored as "attribute"
  $h{$1?N.$2:$2}{$3?N.$4:$4}=$h{$3?$4:N.$4}{$1?$2:N.$2}=1
}
# For all known source attributes ... (this should really be keys%h but we dont mind the extra hashrefs)
map{%x=0,r($_,$_)}%h;
sub r
{
  ($a,$b)=@_;
  # ... remember that we hit a negation and therefor an inconsistency ...
  # If we check/add $b and find an existing "N$b" that means that attribute $b is supposed to be true and not true at the same time
  # It is cheaper bytewise to just add up all consistency errors (remember each fact has a hard value of 1) than to exit right here
  $e+=$h{$a}{N.$b};
  # ... remember that we processed this attribute for the current source attribute so we prevent loops ...
  $x{$b}++or
  # ... add a new fact and then follow the chains (again omitting keys).
  $h{$a}{$b}=1,map{r($a,$_)}%{$h{$b}}
}
# Did we happen on an inconsistency? Do pigs fly? Dont pigs fly? Maybe (Bitwise or is okay too)
print$e|$h{P}{X}?Yes:$h{P}{NX}?No:Maybe

Comments

बहुत अच्छा होगा यदि आप हमें बता सकते हैं कि यह कैसे काम करता है / कुछ टिप्पणियां लिखता है!

— निर्दोष

और अधिक टिप्पणियों के लिए एक और upvote ... विशेष रूप से कुछ भी अधिक स्पष्टीकरण की आवश्यकता है?

— थाइलॉन

और भी टिप्पणियाँ

— जोड़ दीं

@AlanBerndt ने एक पोस्टफिक्स का सुझाव दिया। चूँकि वह टिप्पणी नहीं कर सकता है और मैं स्वीकृत नहीं कर सकता। मैं धन्यवाद कहना चाहूंगा! यहाँ।

— थाइलैंड

Answer 2

हास्केल, 586 566 547 बाइट्स

मैंने इस धारणा पर लिखा है कि प्रत्येक संपत्ति P के लिए कुछ x और y मौजूद होना चाहिए जैसे P (x) सत्य है और P (y) गलत है; इस धारणा के बिना, चौथे उदाहरण के इनपुट में विरोधाभास नहीं होगा और "नहीं" का जवाब देगा।

#define X p s q m
#define W where
t=0<1;f=0>1;y="Yes"
l=length;r=filter;h=head;(#)=(,)
u 0=[[]];u n=[x:y|x<-[t,f],y<-u$n-1]
c l=all(==h l)l#and l
X[]|or[fst$c$map(!!(n-1))e|n<-[1..l$h e]]=y|z t=y|z f="No"|t="Maybe"W e=m$u$l s;z m=t#m==(c$map h$q e)
X("Pigs":_:y)=p v((r$(==a).(!!k)).q)m z W((k,v),z,a)=s%y
X(_:_:_:y)=p w q((r(\x->(x!!j/=a)||(x!!k==b))).m)v W((j,u),_:_:z,a)=s%y;((k,w),v,b)=u%z
s%("not":w)=(i,u,not p)W(i,u,p)=s%w
s%(_:"to":_:w)=(0#s,w,t)
s%(w:z)=(maybe(l s,s++[w#l s])(#s)$lookup w s,z,t)
main=interact$p[""#0]id id.words.r(/='.')

इसे ghc कमांड लाइन विकल्प "-cpp" के साथ संकलित किया जाना चाहिए। इनपुट EOF (^ D) द्वारा समाप्त किया जाना चाहिए। आप इसे http://melpon.org/wandbox/ पर ऑनलाइन आज़मा सकते हैं , लेकिन आप कमांड लाइन विकल्प सेट नहीं कर सकते। इसके बजाय, आप भाषा विकल्प के साथ कार्यक्रम को उपसर्ग कर सकते हैं

{-# LANGUAGE CPP #-}

यह लक्षणों के सेट को इकट्ठा करके काम करता है, फिर इनपुट में निहितार्थ का उपयोग करके विशेषता के सेट -> सत्य मूल्यांकन को फ़िल्टर करता है। फिर परिणाम को यह सुनिश्चित करने के लिए परीक्षण किया जाता है कि प्रत्येक विशेषता को सही और गलत दोनों को सौंपा जा सकता है (यहां विफलता पूर्व फाल्सो क्वॉडलिबेट मामला है)। अंत में, यह मूल्यांकन के लिए दिखता है जो सुअर के तथ्यों से मेल खाता है, प्रत्येक मूल्यांकन में "उड़ान भरने में सक्षम" के लिए मूल्य की जांच कर रहा है।

काफी कुछ बाइट्स थ्रेडिंग अवस्था के आसपास खो गए थे: अब तक देखे गए लक्षणों का समूह, पिग-फैक्ट-चयनकर्ता फ़ंक्शन और निहितार्थ द्वारा निर्धारित फ़िल्टरिंग फ़ंक्शन। संभवतः सटीक विचार एक अशुद्ध भाषा में बहुत कम होगा।

संपादित करें: हेकेलर के सुझाव पर कई बाइट्स सहेजे, फिर z और "u% drop 2 z" के बंधन को "_: _: z" और "u% z" के साथ बांधकर, 3 की बचत करके एक जोड़े को अतिरिक्त किया।

संपादन 2: कुछ और सहेजे गए। 2 बाइट्स को बचाने के लिए (#) = (), चाल का इस्तेमाल किया और पैटर्न समानार्थक शब्द के बारे में सीखा ( https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms ), लेकिन नोटेशन को भी एक बचत प्राप्त करने के लिए सत्यापित किया गया था (#) इस कार्यक्रम में बाकी जोड़ियों को खत्म करना। पार्सर द्वारा खोजे जाने वाले पैटर्न को बदलकर कुछ और बचत करना। उदाहरण के लिए: यदि एक वाक्य सूअरों के साथ शुरू नहीं होता है और हमारे पास पार्सर राज्य में कुछ भी बचा है, तो हम "सब कुछ .." वाक्य को पार्स करते हैं। इसने X और% के पैटर्न में बहुत सारे पात्रों को बचाया।

Comments

आपकी धारणा सही है, मैं पहली बार में इसका उल्लेख करना भूल गया था, लेकिन मैंने अब इसे विवरण अनुभाग में जोड़ दिया है!

— 6

आपको अपने बाइट काउंट में झंडे शामिल करने चाहिए ( कोड-गोल्फ के लिए टैग विकी देखें )। इसलिए, यह 607 बाइट्स है।

— nyuszika7h

क्या यह वास्तव में सही है? लिंक में केवल यूनिकोड एनकोडिंग से संबंधित झंडे का उल्लेख है; मेटा C ++ झंडे -D (एक स्पष्ट धोखा) बनाम -dd = c ++ 11 के बारे में एक समान मुद्दे का उल्लेख करता है (एक विशिष्ट भाषा भिन्नता का चयन, इसलिए शायद ठीक है)। IMO का उपयोग किए गए झंडे Haskell98 के बजाय सामान्य जीएचसी विस्तार को सक्षम करने के लिए हैं, इसलिए अनुरूप -std = c ++ 11। Ref: meta.codegolf.stackexchange.com/questions/1859/…

— मैट नूनन

यू की अपनी दूसरी परिभाषा को आप बदल सकते हैं u n=(:)<$>[t,f]<*>u(n-1)(हालाँकि इसके लिए आपको Control.Applicative आयात करने की आवश्यकता होगी, इसलिए दूसरे विचार में यह और भी बुरा है)

— गर्व हैकेलर

आप कर सकते हैं के साथ सी की परिभाषा की जगहc l=(all(==l!!0)l,and l)

— गर्व haskeller

Answer 3

पायथन, 547 536 525 521 513 509 497 503 501

m=map
o='not ';R={'':{''}}
S=lambda x,y:filter(len,m(str.strip,x.split(y)))
N=lambda a:[o+a,a[4:]][a[:4]==o]
def C(s):a,c=S(s[19:],'is also');return[(a,c),(N(c),N(a))]
X=lambda A:A&set(m(N,A))and 1/0 or A
for a,c in sum(m(lambda x:[('',x[9:])]if'P'==x[0]else C(x),S(raw_input(),'.')),[]):R.setdefault(a,{a}).add(c)
def F(s):
 i,n={s},{s}
 while 1:
  for r in i:n|=R.get(r,n)
  if X(i)>=n:return i
  i|=n
try:a='able to fly';n=N(a);c={n:'No','':'Maybe'}[''.join({a,n}&m(F,R)[0])]
except:c='Yes'
print c

a -> bइनपुट में प्रत्येक के लिए, हम दिए गए क्लॉज़ और इसके निषेध not b -> not a को क्लॉज़ के सेट में ->जोड़ते हैं और फिर उन प्रस्तावों के सेट की गणना करते हैं जो किसी भी प्रस्ताव से फिक्स-लूप का उपयोग करके उपलब्ध हैं। जब भी हम एक विरोधाभास का सामना करते हैं, हम (और बाद में पकड़) को ए ZeroDivisionErrorऔर प्रिंट करते हैं Yes।

अंत में, हम यह जांचते हैं कि क्या 'उड़ने में सक्षम' (और / या इसकी अवहेलना) 'सूअर' के प्रस्ताव से आने योग्य है ''और उपयुक्त प्रतिक्रिया को प्रिंट करता है।

संपादित करें : यह छोटी गाड़ी है, इसे ठीक करना। फिक्स्ड।

Comments

आपको tryब्लॉक को एक ही लाइन पर लगाकर 2 बाइट्स को बचाने में सक्षम होना चाहिए जैसेtry:

— भूमिगत

@undergroundmonorail: उस जगह के लिए धन्यवाद! उसे बदल दिया।

— user2361830

Answer 4

रूबी 1.9.3 ( 365 364 362)

h='able to fly'
i="(not )?(#{h}|\\w+)"
o=->s{n=Regexp.new(i+" (is also|are) "+i).match s
[[n[2],!n[1]],[n[5],!n[4]]]}
c=e=!z=[]
w=->r{z.member?(r)||(z<<(a,b=r)
c|=a[0]==b[0]&&a[1]!=b[1]
w[[[b[0],!b[1]],[a[0],!a[1]]]]
z.map{|q|q[1]==r[0]&&w[[q[0],r[1]]]})}
y=->x{z.member?([[p='Pigs',!e],[h,x]])}
f=->x{x.split(?.).map{|s|w[o[s]]}
c|y[!e]?'Yes':y[e]?'No':'Maybe'}

प्रयोग

कोड परिभाषित करता है ऊपर एक समारोह fहै, जो एक पैरामीटर शाब्दिक इनपुट और रिटर्न का प्रतिनिधित्व करने लग जाते हैं Yes, Noया Maybe।

उदाहरण के लिए:

f['Pigs are old. Everything that is not able to fly is also not old.']
=> "Yes"

ऑनलाइन टेस्ट: http://ideone.com/fxLemg

यहां अनगॉल्ड कोड (यूनिट टेस्ट सहित) उपलब्ध है ।

Comments

* उपलब्ध हैं (हेडर "ऑनलाइन टेस्ट" के तहत)। Plurals, मेरे अच्छे दोस्त।

— स्टेन स्ट्रम

@StanStrum धन्यवाद! मैं पाठ संशोधित - मेरा मतलब है कोड है उपलब्ध है और यह भी इकाई परीक्षण भी शामिल है।

— क्रिस्टियन लुपस्कु