仕事

あなたの仕事は、いくつかの文を分析し、ブタが飛ぶことができるそれらの文から結論を出すことができるかどうかを決定する、選択した言語で関数またはプログラムを書くことです。

入力

入力は、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. 指定されたステートメントは有効ですが、一貫性がありません（つまり、指定されたステートメントに矛盾があります）。以来EX falso quodlibet、我々は出力に決めYes、その場合には。
5. 指定されたステートメントは無効です。つまり、指定されたEBNFに従ってフォーマットされていません。その場合、あなたは何でもしたいかもしれません。

詳細

• 与えられた属性は互いに独立していると仮定できます。したがって、たとえば、豚は不整合を引き起こすことなく、若くても老いても、緑、赤、青であってもかまいません。ただし、豚は同時に「緑」と「緑ではない」場合があります。これは矛盾であり、（4）で説明されているように処理する必要があります。
• すべての属性について、指定された属性を持つ少なくとも1つのオブジェクト（必ずしも豚であるとは限らない）がユニバースにあり、それを持たないオブジェクトが1つあると仮定します。

入力と出力の例

入力：

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. 

出力：文字列が上記の基準に一致しないため、何でもいいです。

勝者

これはcode-golfなので、最短の正解（バイト単位）が勝ちます。最初の正解が掲載されてから1週間後に勝者が選ばれます。

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

非ゴルフ/説明：

# 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 に対して、P（x）が真でP（y）が偽であるようなxとyが存在しなければならないという前提でこれを書きました。この仮定なしでは、4番目の入力例に矛盾はなく、「いいえ」と答えます。

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

特性のセットを収集し、入力の含意を使用して特性のセット->真理値評価をフィルタリングすることで機能します。次に、結果をテストして、すべての特性をTrueとFalseの両方に有効に割り当てることができることを確認します（ここでの失敗はex falso quodlibetの場合です）。最後に、豚の事実に一致する評価を探し、各評価で「飛行可能」の値をチェックします。

スレッド化状態でかなりの数バイトが失われました：これまでに見られた特性のセット、pig-fact-selector関数、および含意によって決定されたフィルタリング関数。おそらく、まったく同じ考えは、不純な言語ではずっと短くなるでしょう。

編集：誇らしげなhaskellerの提案によって数バイトを保存し、zと「u％drop 2 z」のバインディングを「_：_：z」と「u％z」へのバインディングに置き換えてさらに3を保存し、3を保存します。

編集2：さらに保存しました。（＃）=（、）トリックを使用して2バイトを節約し、パターンの類義語（https://ghc.haskell.org/trac/ghc/wiki/PatternSynonyms）について学びましたが、表記法が冗長すぎて節約できませんこのプログラムの残りのペアを削除します。パーサーが検索するパターンを変更することで、さらに節約を絞り込みました。たとえば、文がPigsで始まらず、パーサー状態に何かが残っている場合、「Everything that is ..」文を解析します。これにより、Xと％のパターンに多くの文字が保存されました。

パイソン、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 を句のセットに追加->し、固定点ループを使用して任意の命題から到達可能な命題のセットを計算します。矛盾が発生するたびに、a ZeroDivisionErrorとprint をスロー（および後でキャッチ）しますYes。

最後に、「is pig」命題から「飛べる」（および/またはその否定）が到達可能かどうかを確認し''、適切な応答を出力します。

編集：これはバグがあり、修正しています。一定。

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

使用法

定義上、コード機能f、テキスト入力と戻りを表す1つのパラメータをとり、Yes、No、またはMaybe。

例えば：

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

オンラインテスト：http : //ideone.com/fxLemg

使用されていないコード（単体テストを含む）は、ここから入手できます。