งาน

งานของคุณคือการเขียนฟังก์ชั่นหรือโปรแกรมในภาษาที่คุณเลือกซึ่งจะวิเคราะห์ข้อความสองสามข้อและพิจารณาว่าสามารถสรุปได้จากข้อความที่หมูสามารถบินได้หรือไม่

อินพุต

อินพุตเป็นสตริงที่สามารถอ่านได้จาก 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. ข้อความที่ให้นั้นถูกต้อง แต่ไม่สอดคล้องกัน (เช่นมีความขัดแย้งในข้อความที่ระบุ) ตั้งแต่อดีต fodso quodlibetเราตัดสินใจที่จะแสดงผล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. 

ผลลัพธ์:สิ่งที่คุณต้องการเนื่องจากสตริงไม่ตรงกับเกณฑ์ที่กล่าวถึงข้างต้น

ผู้ชนะ

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่ถูกต้องที่สั้นที่สุด (เป็นไบต์) ชนะ ผู้ชนะจะได้รับการคัดเลือกหนึ่งสัปดาห์หลังจากโพสต์คำตอบแรกที่ถูกต้อง

Perl, 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

Haskell, 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 #-}

มันทำงานได้โดยการรวบรวมชุดของลักษณะจากนั้นกรองชุดของคุณลักษณะ -> การประเมินค่าความจริงโดยใช้ความหมายในอินพุต ผลที่ได้รับการทดสอบแล้วเพื่อให้มั่นใจว่าทุกลักษณะที่สามารถกำหนดอย่างถูกต้องทั้งจริงและเท็จ (ความล้มเหลวที่นี่เป็นอดีต falso Quodlibetกรณี) ในที่สุดก็มองหาการประเมินค่าที่ตรงกับข้อเท็จจริงหมูตรวจสอบค่าสำหรับ "สามารถบินได้" ในการประเมินแต่ละครั้ง

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

แก้ไข:บันทึกไว้หลายไบต์โดยคำแนะนำของผู้มีความภาคภูมิใจจากนั้นจึงเพิ่มอีกสองสามรายการโดยแทนที่การรวมของ z และ "u% drop 2 z" ด้วยการผูกกับ "_: _: z" และ "u% z", การบันทึก 3

แก้ไข 2:บันทึกเพิ่มเติม ใช้เคล็ดลับ (#) = (,) เพื่อบันทึก 2 ไบต์และเรียนรู้เกี่ยวกับคำพ้องความหมายของรูปแบบ ( https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms ) แต่สัญกรณ์นั้นละเอียดเกินไปที่จะได้รับการประหยัดจาก กำจัดส่วนที่เหลือของคู่ในโปรแกรมนี้ บีบอัดเงินออมเพิ่มเติมโดยการเปลี่ยนรูปแบบที่ parser ค้นหา ตัวอย่างเช่น: ถ้าประโยคไม่ได้ขึ้นต้นด้วยหมูและเรามีอะไรเหลืออยู่ในสถานะ parser เราจะแยกประโยค "ทุกอย่างที่เป็น .. " สิ่งนี้บันทึกอักขระจำนวนมากในรูปแบบสำหรับ X และ%

Python, 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 ไปยังชุดคำสั่งจากนั้นคำนวณชุดข้อเสนอที่สามารถ->เข้าถึงได้จากข้อเสนอใด ๆ โดยใช้ fixpoint loop เมื่อใดก็ตามที่เราพบความแตกต่างที่เราโยน (และจับภายหลังบริการ) และพิมพ์ZeroDivisionErrorYes

ในที่สุดเราตรวจสอบว่า 'สามารถบินได้' (และ / หรือการปฏิเสธ) สามารถเข้าถึงได้จาก 'ข้อเสนอหมู' ''และพิมพ์คำตอบที่เหมาะสม

แก้ไข : นี่คือบั๊กกี้แก้ไข แก้ไขแล้ว.

ทับทิม 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, หรือNoMaybe

ตัวอย่างเช่น:

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

การทดสอบออนไลน์: http://ideone.com/fxLemg

รหัส ungolfed (รวมถึงการทดสอบหน่วย) มีให้บริการที่นี่