Bài tập, nhiệm vụ

Nhiệm vụ của bạn là viết một chức năng hoặc một chương trình bằng ngôn ngữ bạn chọn để phân tích một vài câu lệnh và xác định xem liệu nó có thể được kết luận từ những câu mà lợn có thể bay hay không.

Đầu vào

Đầu vào là một Chuỗi có thể được đọc từ STDIN, được lấy làm đối số chức năng hoặc thậm chí được lưu trữ trong một tệp. Đầu vào có thể được mô tả bằng EBNF sau:

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" ;

Ví dụ đầu vào (xem thêm ví dụ bên dưới):

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

Đầu ra

Đầu ra có thể được trả về bởi chức năng của bạn, được ghi vào một tệp hoặc in ra STDOUT. Có 5 trường hợp khác nhau sẽ được xử lý:

1. Các tuyên bố đã cho là hợp lệ, nhất quán và có kết quả hợp lý là lợn có thể bay. Trong trường hợp đó, bạn phải xuất ra Yes.
2. Các tuyên bố đã cho là hợp lệ, nhất quán và có kết quả hợp lý là lợn không thể bay. Trong trường hợp đó, bạn phải xuất ra No.
3. Không thể kết luận từ các tuyên bố nhất định, hợp lệ và nhất quán cho dù lợn có thể bay hay không. Trong trường hợp đó, bạn phải xuất ra Maybe.
4. Các tuyên bố đã cho là hợp lệ, nhưng không nhất quán (nghĩa là có mâu thuẫn trong các tuyên bố đã cho). Kể từ ex falso quodlibet , chúng tôi quyết định đầu ra Yestrong trường hợp đó.
5. Các báo cáo đã cho là không hợp lệ, tức là chúng không được định dạng theo EBNF đã cho. Trong trường hợp đó, bạn có thể làm bất cứ điều gì bạn muốn.

Chi tiết

• Bạn có thể cho rằng các thuộc tính đã cho là độc lập với nhau. Vì vậy, ví dụ, một con lợn có thể trẻ và già, xanh, đỏ và xanh cùng một lúc mà không gây ra bất kỳ sự mâu thuẫn nào. Tuy nhiên, một con lợn có thể không 'xanh' và 'không xanh' cùng một lúc, đó là một mâu thuẫn và nên được xử lý như mô tả trong (4).
• Đối với mọi thuộc tính, giả sử rằng có ít nhất một đối tượng (không nhất thiết là lợn) trong vũ trụ có thuộc tính đã cho và một đối tượng không có đối tượng đó.

Ví dụ Đầu vào & Đầu ra

Đầu vào:

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

Đầu ra: Vì Lợn có màu xanh và do đó thông minh, và mọi thứ có thể bay đều không thông minh, lợn không thể bay. Đầu ra là No.

Đầu vào:

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

Đầu ra: Nếu lợn không thể bay, chúng cũng không già. Nhưng vì chúng đã cũ, bạn phải xuất ra Yes.

Đầu vào:

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

Đầu ra : Maybe .

Đầu vào:

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

Đầu ra: Mặc dù câu lệnh đầu tiên ngụ ý rằng lợn không thể bay, nhưng các câu lệnh sau mâu thuẫn với nhau và do đó đầu ra phải là Yes.

Đầu vào:

Pigs are very smart. Pigs are able to fly. 

Đầu ra: Bất cứ điều gì bạn muốn, vì Chuỗi không khớp với các tiêu chí được đề cập ở trên.

Người chiến thắng

Đây là môn đánh gôn , vì vậy câu trả lời đúng ngắn nhất (tính bằng byte) sẽ thắng. Người chiến thắng sẽ được chọn một tuần sau khi câu trả lời đúng đầu tiên được đăng.

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 / Giải thích:

# 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 byte

Tôi đã viết điều này với giả định rằng với mọi thuộc tính P phải tồn tại một số x và y sao cho P (x) là đúng và P (y) là sai; không có giả định này, đầu vào ví dụ thứ tư sẽ không có mâu thuẫn và sẽ trả lời "Không".

#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(/='.')

Điều này nên được biên dịch với tùy chọn dòng lệnh ghc "-cpp". Đầu vào phải được chấm dứt bởi EOF (^ D). Bạn có thể dùng thử trực tuyến tại http://melpon.org/wandbox/ , nhưng bạn không thể đặt tùy chọn dòng lệnh. Thay vào đó, bạn có thể tiền tố chương trình với tùy chọn ngôn ngữ

{-# LANGUAGE CPP #-}

Nó hoạt động bằng cách thu thập tập hợp các đặc điểm, sau đó lọc tập hợp các đặc điểm -> định giá sự thật bằng cách sử dụng các hàm ý trong đầu vào. Kết quả sau đó được kiểm tra để đảm bảo rằng mọi đặc điểm có thể được gán hợp lệ cho cả Đúng và Sai (thất bại ở đây là trường hợp exodso quodlibet cũ ). Cuối cùng, nó tìm kiếm các định giá phù hợp với thực tế của lợn, kiểm tra giá trị cho "có thể bay" trong mỗi định giá.

Khá nhiều byte bị mất ở trạng thái luồng xung quanh: tập hợp các đặc điểm được thấy cho đến nay, hàm chọn lợn-fact-selector và hàm lọc được xác định bởi hàm ý. Có lẽ cùng một ý tưởng sẽ ngắn hơn nhiều trong một ngôn ngữ không trong sạch.

Chỉnh sửa: Đã lưu một vài byte bằng đề xuất của haskeller tự hào, sau đó thêm một vài bằng cách thay thế ràng buộc của z và "u% drop 2 z" bằng một liên kết thành "_: _: z" và "u% z", lưu 3.

Chỉnh sửa 2: Lưu thêm một số. Đã sử dụng thủ thuật (#) = (,) để lưu 2 byte và tìm hiểu về các từ đồng nghĩa mẫu ( https://ghc.haskell.org/trac/ghc/wiki/PotypeSynonymouss ), nhưng ký hiệu quá dài để có được một khoản tiết kiệm từ loại bỏ phần còn lại của các cặp trong chương trình này. Ép ra một số khoản tiết kiệm hơn bằng cách thay đổi các mẫu mà trình phân tích cú pháp tìm kiếm. Ví dụ: nếu một câu không bắt đầu bằng Lợn và chúng tôi còn bất cứ điều gì trong trạng thái trình phân tích cú pháp, chúng tôi sẽ phân tích một câu "Mọi thứ là ..". Điều này đã lưu rất nhiều ký tự trong các mẫu cho X và%.

Trăn, 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

Đối với mỗi a -> bđầu vào, chúng ta thêm mệnh đề đã cho và phủ định của nó not b -> not a vào tập các mệnh đề và sau đó tính toán các mệnh đề có thể ->truy cập được từ bất kỳ mệnh đề nào bằng vòng lặp fixpoint. Bất cứ khi nào chúng tôi gặp phải một mâu thuẫn, chúng tôi ném (và sau đó bắt) a ZeroDivisionErrorvà in Yes.

Cuối cùng, chúng tôi kiểm tra xem 'có thể bay' (và / hoặc phủ định của nó) có thể truy cập được từ đề xuất 'là lợn' ''hay không và in phản hồi thích hợp.

EDIT : Đây là lỗi, sửa nó. Đã sửa.

Ruby 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'}

Sử dụng

Đoạn mã trên định nghĩa một hàm f, trong đó có một tham số đại diện cho đầu vào văn bản và lợi nhuận Yes, Nohoặc Maybe.

Ví dụ:

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

Kiểm tra trực tuyến: http://ideone.com/fxLemg

Mã không mã hóa (bao gồm các bài kiểm tra đơn vị) có sẵn ở đây .