前文

整数は常に偶数または奇数です。偶数の整数は2で割り切れ、奇数の整数は割り切れません。

2つの整数を追加すると、被加数が偶数か奇数かに基づいて、結果が偶数か奇数かを推測できます。

• 偶数+偶数=偶数
• 偶数+奇数=奇数
• 奇数+偶数=奇数
• 奇数+奇数=偶数

同様に、2つの整数を乗算すると、因子が偶数か奇数かに基づいて、結果が偶数か奇数かを推測できます。

• 偶数*偶数=偶数
• 偶数*奇数=偶数
• 奇数*偶数=偶数
• 奇数*奇数=奇数

したがって、加算と乗算のみが関係する数式のすべての変数の偶数または奇数がわかっている場合、結果が偶数か奇数かを推測できます。

たとえば(68 + 99) * 37、偶数と奇数（68 + 99）が奇数であり、奇数と別の奇数（odd * 37）が奇数を与えるため、自信を持って奇数になると言うことができます。

チャレンジ

唯一の4つの文字を含む文字列を取り込みプログラムや関数を書きますeo+*。この文字列は、加算（）と乗算（）のみを含むプレフィックス表記で指定された数式を表します。それぞれが任意の偶数を表し、それぞれが任意の奇数を表します。+*eo

あなたの仕事は表現、印刷または単一の復帰簡素化することであるeか、o式の結果が偶数か奇数かに基づいています。

入力は常に有効なプレフィックス表記であると想定できます。具体的には、それぞれ+との*後に、常に2つの対応するオペランドがあります。これらのオペランドは、単一のeor o、またはオペランドを持つ別の+or *式です。

たとえば、入力*+eooはとしてmul(add(e, o), o)、または(e + o) * o通常の挿入記法で読み取ることができます。e第一oに対応するオペランドであり+、そして+eo、最後には、o対応するオペランドです*。

明確にするために、間違ったプレフィックス表記を持ついくつかの無効な入力を次に示します。

eo
ooe
o+e
ee*
+*oe
+e*o

出力の単一の末尾の改行は問題ありませんが、そうでなければ、e偶数またはo奇数のプレーンのみが出力されるはずです。

バイト単位の最短コードが優先されます。

テストケース

^{（空の行は、同様のケースを視覚的に区別するためだけのものです。）}

e -> e
o -> o

+ee -> e
+eo -> o
+oe -> o
+oo -> e
*ee -> e
*eo -> e
*oe -> e
*oo -> o

+e+ee -> e
+e+eo -> o
+e+oe -> o
+e+oo -> e
+e*ee -> e
+e*eo -> e
+e*oe -> e
+e*oo -> o

+o+ee -> o
+o+eo -> e
+o+oe -> e
+o+oo -> o
+o*ee -> o
+o*eo -> o
+o*oe -> o
+o*oo -> e

*e+ee -> e
*e+eo -> e
*e+oe -> e
*e+oo -> e
*e*ee -> e
*e*eo -> e
*e*oe -> e
*e*oo -> e

*o+ee -> e
*o+eo -> o
*o+oe -> o
*o+oo -> e
*o*ee -> e
*o*eo -> e
*o*oe -> e
*o*oo -> o

++eee -> e
++eeo -> o
++eoe -> o
++eoo -> e
++oee -> o
++oeo -> e
++ooe -> e
++ooo -> o

+*eee -> e
+*eeo -> o
+*eoe -> e
+*eoo -> o
+*oee -> e
+*oeo -> o
+*ooe -> o
+*ooo -> e

*+eee -> e
*+eeo -> e
*+eoe -> e
*+eoo -> o
*+oee -> e
*+oeo -> o
*+ooe -> e
*+ooo -> e

**eee -> e
**eeo -> e
**eoe -> e
**eoo -> e
**oee -> e
**oeo -> e
**ooe -> e
**ooo -> o

+e+e+e+ee -> e
+o+o+o+oo -> o
*e*e*e*ee -> e
*o*o*o*oo -> o
+e+o+e+oe -> e
+o+e+o+eo -> o
*e*o*e*oe -> e
*o*e*o*eo -> e
+e*e+e*ee -> e
+o*o+o*oo -> o
*e+e*e+ee -> e
*o+o*o+oo -> o

+**++*+*eeoeeooee -> e
+**++*+***eooeoeooeoe -> e
+**+***+**++**+eooeoeeoeeoeooeo -> o

+e*o*e**eoe -> e
+*e+e+o+e**eeoe -> e
**o++*ee*++eoe*eo+eoo -> o

CJam、18 17 13バイト

4バイトを節約してくれたaditsuに感謝します。

qW:O%eu~"eo"=

こちらからテストスイートをお試しください。（テストスイートはパーマリンクには長すぎます。チャレンジ仕様からコピーしてください。）

説明

q     e# Read the input.
W:O   e# Push a -1 and store it in variable O.
%     e# Use the -1 to reverse the string, because CJam's stack-based nature and the
      e# commutativity of the operators means we can evaluate the code in postfix notation.
eu    e# Convert the string to upper case, turning 'e' into 'E' (a variable with even value
      e# 14) and 'o' into 'O' (which we've stored the odd value -1 in).
~     e# Evaluate the string as CJam code, leaving the result on the stack.
"eo"= e# Use the result as an index into the string "eo". CJam's indexing is cyclic so it
      e# automatically takes inputs modulo 2. Negative indices also work as expected.

Pyth、16 14バイト

@"eo".vjdXzGU9

Pythはそれ自体、Pyth構文の文字列を評価できます。したがって、eand oを4and に置き換え5ます。その後、評価によって偶数または奇数が得られ、結果を簡単に印刷できます。

オンラインで試す：デモンストレーションまたはテストスイート

説明：

@"eo".vjdXzGU9   implicit: z = input string
         XzGU9   replace "e" in z with 4 and "o" with 5
       jd        put a space between each char
     .v          evaluate it (Pyth style)
@"eo"            and print "e" or "o"

置換の追加説明。Gは、アルファベットで初期化される変数ですabc...xyz。U9リスト[0, 1, ..., 8]です。XzGU9アルファベットの文字をリストの値に置き換えます。そうaで置き換えられます0、bと1、...、eと4、...、iと8、jと0、...、とoと5。したがって、私eはo偶数と奇数に置き換えられます。他のすべての置換はまったく効果がありません。

Perl、50 45 40文字

（39文字のコード+ 1文字のコマンドラインオプション。）

1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/

サンプル実行：

bash-4.3$ echo -n '**o++*ee*++eoe*eo+eoo' | perl -pe '1while s/\+oe|\+eo|\*oo/o/||s/\W\w\w/e/'
o

網膜、29バイト

(+`\*oo|\+(eo|oe)
o
\W\w\w
e

便利な1ファイルバージョンでは、-sフラグが使用されます。

私たちは、（奇数の表現を交換*oo、+oe、+eoに）o私たちは、その後に残りのシンボル文字文字式を入れ替えることができるまでe。できるまでこれを繰り返し、最後の1文字が出力になります。

（このソリューションは、manatworkのPerlの回答に似ています。）

オンラインでお試しください！（デニス）

Python 2、90

def f(s):i=iter(s);a=next(i);return(a>'a')*a or'oe'[f(i)==f(i)if'*'<a else'e'in f(i)+f(i)]

このiter関数は、入力文字列をの呼び出し全体で解析された文字列の量を記憶するFIFOキューに入れる良い方法ですf。べき等であるため、入力が既に文字列ではなくイテレータである場合に再度呼び出すことは無害です。or'oe'...で始まる答えの最後の半分は、ゴルフができるはずですが、何も見つかりませんでした。

-1 Sp3000に感謝します。

Mathematica、91 84バイト

#//.s_:>s~StringReplace~{"+ee"|"+oo"|"*ee"|"*eo"|"*oe"->"e","+eo"|"+oe"|"*oo"->"o"}&

これを圧縮する方法を探しています...

Python 2、80バイト

def f(s,e=0,o=1):i=iter(s);a=next(i);return(a>'a')*a or'eo'[eval(f(i)+a+f(i))%2]

これは、feersumの非常に巧妙な回答に基づいて構築されており、iterポーランド記法の操作を実装するために使用されます。新しいアイデアはeval、式+と*with を評価するために使用することです。eval(f(i)+a+f(i))ここで、演算子aは再帰的な結果の間に挿入されます。evalは、e=0,o=1オプションの関数引数のバインディングを使用します。出力はmod 2になります。

C、79バイト

簡単な再帰。許可される4つの入力文字のいくつかの（偶然の？）ビット単位のプロパティに依存します。

f(){int c=getchar();return c&4?c:c&1?f()^f()^'e':f()&f();}main(){putchar(f());}

シェル+ GNUユーティリティ、33

dc -eFo`rev|tr oe OK`2%p|tr 10 oe

入力はSTDINから取得されます。

これは、入力を逆にしてスタックベースの計算機で評価するという同じトリックを行います-この場合dc。eand oを0and 1で置き換えることもできますが、その後、数字が誤った数字に貪欲に解析されないようにスペースを挿入する必要があります。

代わりeに置き換えさKれているdcデフォルトで0であり、スタックへの電流精度をプッシュするためのコマンドoで置換さOれているdcスタックに電流出力ベースをプッシュするコマンド。これは奇数である必要があるためFo、dcで他の操作を行う前に15に設定します。

それからmod 2を取り、印刷するだけ2%pです。可能な値はnow 0とのみな1ので、出力ベースが15であってもかまいません。その後tr、oまたはに変換されeます。

目を細めれば、このソースはほとんどのように見えdc Forever OKます。

真剣に、24バイト

,R'2'e(Æ'1'o(Æ£ƒ'e'o2(%I

より効率的なスタック操作はおそらくこれを短くすることができますが、まあ、私はそれで満足しています。

次のように入力を文字列として受け取ります "+*oee"

オンラインで試す（入力は手動で入力する必要があります）

説明：

,R        get input and reverse it
'2'e(Æ    replace all "e"s with "2"s
'1'o(Æ    replace all "o"s with "1"s
£ƒ        cast as function and call
'e'o2(%I  push "e" if result is even, else "o"

Ruby、61バイト

再帰降下解析とブール代数を使用します。

def f
gets(1)==?+?f^f : ~/\*/?f&f : $_==?o
end
puts f ? ?o:?e

この関数は、一度に標準入力から1文字を読み取ります。a +またはaを読み取る場合*、それ自体を2回呼び出して、奇数または偶数を決定します。この関数はtrue、奇数およびfalseを返しますeven。^ XORと& AND演算子はそれぞれ加算と乗算式の「奇数判定」を決定するために使用されています。

これは、無料版です。

def f
  x = gets(1)
  case x
  when '+'
    f ^ f
  when '*'
    f & f
  else
    x == 'o'
  end
end

puts f ? 'o' : 'e'

_{最初のバージョンのバグを指摘してくれた@Shelに感謝します。}

Minkolang 0.14、40バイト

巧妙なevalメソッドを実行しようとしましたが、元のスペース以外のコードボックスに追加された値には、プログラムカウンターが到達しないことがわかりました。だから私はあまり賢くない評価方法をやった。：P

$o"eo+*"r0I4-[4g1Z2*1F]l*"e"+O.
0f1f+f*f

ここで試してみてください。

説明

$o                                Read in whole input as characters
  "eo+*"                          Push these characters onto the stack (in reverse order)
        r                         Reverse the stack
         I4-                      Push the length of the stack - 4
            [                     For loop; pop n and repeat that many times
             4g                   Get the item at the fourth index and put it on top
               1Z                 Pops n and pushes first index of n in stack
                 2*               Multiply by 2
                   1F             Gosub; goes to codebox(2n,1) to be returned to
                     ]            Close for loop
                      l*          Multiply by 10
                        "e"+      Add 101 ("o" is 111)
                            O.    Output as character and stop.
0f1f+f*f                          Does the appropriate operation then returns to F

JavaScript、110 106 94バイト

while(i.length>2)i=i.replace(/([+*][eo]{2})/,(o,e)=>{return"+oe+eo*oo".indexOf(o)<0?"e":"o"});

確かに最小のソリューションではありませんが、JavaScriptのような冗長言語では可能な限り最小のソリューションです！

O、24 20 19 18バイト

i`2:e;1:o;~2%'o'e?

、入力を受け取り、それを反転させる、割り当てeに2とoを1とスキにそれをポスト Oコードとして評価します。

説明：

Oは後置記法を使用するため、入力を取得し、それを逆にします
2：e; 「e」を2に割り当てます
1：o; 「o」を1に割り当てます
〜2％評価し、結果が偶数かどうかを確認します
'o'e？偶数の場合は「e」、奇数の場合は「o」を出力します

GNU Sed、36

:
s/*oo\|+eo\|+oe/o/
t
s/\W\w\w/e/
t

投稿した後、これは@manatworkのPerlの回答および@randomraのRetinaの回答とまったく同じアプローチを見ました。ですから、私はずっと行き、彼ら\W\w\wも借りることができると思います。

4バイトを削る@Ruudに感謝します。

Haskell、160バイト

を呼び出しfます。

f=until((==1).l)r
r s|l s<3=s|3#s?o=r('o':3%s)|3#s?sequence["+*","oe","oe"]=r('e':3%s)|0<1=1#s++r(1%s)
l=length
(#)=take
(%)=drop
(?)=elem
o=["+eo","+oe","*oo"]

JavaScript、92 71バイト

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,e=>"eo"[eval((e[1]>"e")+"^&"[+(e[0]<"+")]+(e[2]>"e"))]))

少し難読化されていますがeval、ビット演算子を使用して何かをしたかったのです。注釈付き：

f = (i) => // function(i) { return
    i>"0"  // i[0] == "o" || i[0] == "e" :-) - the characters `*` and `+` are both <"0"
      ? i  // finish
      : f(i.replace( // recursively repeat with
          /.[eo]{2}/, // first occurrence of "something" followed by two values
          (e) =>    // replaced by
              "eo"[ // string indexing
                eval(
                    (e[1]>"e")        // e[1] == "o" ? "true" : "false"
                  + "^&"[+(e[0]<"+")] // e[0] == "+" ? "^" : "&"
                  + (e[2]>"e")        // e[2] == "o" ? "true" : "false"
                )
              ]     // like eval(…) ? "o" : "e"
        ))

繰り返しは(e[…]>"e")少し気になりますが、以下の方が良くありません（103バイト）：

f=i=>i>"0"?i:f(i.replace(/e|o/g,x=>+(x>"e")).replace(/.\d\d/,e=>"eo"[eval(e[1]+"^&"[+(e[0]<"+")]+e[2])]))

結局のところ、@ Arkainの単純な部分文字列マッチングのアプローチは優れています。関数を作成し、いくつかの最適化を行います。

f=i=>i>"0"?i:f(i.replace(/.[eo]{2}/,v=>"eo"[+"+oe+eo*oo".includes(v)]))

ダーツ、173バイト

f(i){var l=i.split(''),e='e',o='o';g(p){if(l[p]!=e&&l[p]!=o){var x=p+1,y=p+2;g(x);g(y);l[p]=l[p]=='+'?l[x]!=l[y]?o:e:l[x]==o?l[y]:e;l.removeRange(x,p+3);}}g(0);print(l[0]);}

これは競争ではありませんが、何でもです。ソリューションの要点は、0から開始して、すべての演算子を再帰的にその演算子に続く文字のペアの評価に置き換え、それらの文字をリストから削除することです。

Haskell、231バイト

これは、深刻な言語を使用したアプローチです;）

ゴルフバージョン：

p(s:_)[]=s
p s(x:y)=p(r$x:s)y
r[]=[]
r('e':'e':'+':x)=r$'e':x
r('e':'o':'+':x)=r$'o':x
r('o':'e':'+':x)=r$'o':x
r('o':'o':'+':x)=r$'e':x
r('e':'e':'*':x)=r$'e':x
r('e':'o':'*':x)=r$'e':x
r('o':'e':'*':x)=r$'e':x
r('o':'o':'*':x)=r$'o':x
r x=x

例：

*Main> p [] "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

ゴルフされていない非常に包括的なバージョン：

type Stack = String

parse :: String -> Char
parse = parse' []

parse' :: Stack -> String -> Char
parse' (s:_) []     = s
parse' s     (x:xs) = parse' (reduce $ x:s) xs

reduce :: Stack -> Stack
reduce [] = []
reduce ('e':'e':'+':xs) = reduce $ 'e':xs
reduce ('e':'o':'+':xs) = reduce $ 'o':xs
reduce ('o':'e':'+':xs) = reduce $ 'o':xs
reduce ('o':'o':'+':xs) = reduce $ 'e':xs
reduce ('e':'e':'*':xs) = reduce $ 'e':xs
reduce ('e':'o':'*':xs) = reduce $ 'e':xs
reduce ('o':'e':'*':xs) = reduce $ 'e':xs
reduce ('o':'o':'*':xs) = reduce $ 'o':xs
reduce xs               = xs

例：

*Main> parse "+**+***+**++**+eooeoeeoeeoeooeo"
'o'

機能：パターンマッチングと再帰。

Jolf、11バイト

（言語が質問を後日付けしているため、非競争的です。）ここで試してみてください！

FVyAi"oe"@\x12

（\x12実際の文字に置き換え\x12ます。これは、インタープリターで自動的に行われます。）

説明：

FVyAi"oe"@\x12
    i          input
          \x12 character 12
         @     char code at
   A "oe"      replace all os with 1s and all es with 2s
  y            eval as jolf, returning the answer
 V             return parity "even" or "odd"
F              get first character
               implicit output

Python 3、171 145 135バイト

競争力はありませんが、それを楽しんでいたので、自分でそれを維持できませんでした。feersumによる（非常に巧妙な）recursive-iterator Pythonエントリとは異なり、このエントリは入力を反転し、逆ポーランド記法の古き良きスタックベースの解析を行います。

def p(i):
 s=[]
 for c in i[::-1]:
  s+=[c>'e'if c>'a'else getattr(s.pop(),'__'+('axnodr'[c>'*'::2])+'__')(s.pop())]
 return'eo'[s[0]]

Haskell、98 94バイト

さらに別のHaskellの試みでお邪魔して申し訳ありません。100バイト未満で非常にうまくいくことを証明したかっただけです。

p(c:s)|any(<'a')s=p(c:p s)
p('+':x:y:s)|x/=y='o':s
p('*':'o':s)=s
p(c:_:_:s)|c<'a'='e':s
p s=s

p有効な式をパラメーターとして受け入れ、結果を長さ1のストリングとして返す関数を定義します。

例：

*Main> p "**o++*ee*++eoe*eo+eoo"
"o"

この関数は、演算子がなくなるまで文字列の右端の演算子を繰り返し減らすことにより機能します。

Add ++、46バイト

D,g,@,d"oe"$eA"e"=+o
D,f,@,bR€gbU32CjbV2%"eo":

オンラインでお試しください！

フッターは、すべての入力例とそれに対応する出力を単純に列挙します。

使い方

ここで答えが失われたように、これは置換と評価を使用します。私たちの主な関数はfでありg、ヘルパー関数です。例として"*e*o*e*oe"（e）を使用します。

f入力文字列を取得し、それを逆にして、を生成し"eo*e*o*e*"ます。次にg、各要素をマッピングします。

g引数を複製することから始まり、最後のコマンドまでコピーを保持します。引数が文字列であるしているかどうかを確認"oe"降伏、1文字用と0をため*か+。次に、引数を再度プッシュし、それがに等しいかどうかを確認し"e"ます。この結果は、前のチェックに追加されます。これは、生成0のいずれかのため*か+、1用oおよび2のためにe。次に、この値と引数の間の論理和を取ります。値が0の場合、引数（つまり*または+）に置き換えられます。それ以外の場合は、そのまま（つまり1および2）のままになります。

これにより、入力の逆にあるすべての文字が数値に変換されます。次に、各要素をスペースで結合し、数字が連結されないようにします。この例では、これによりstringが生成されます"2 1 * 2 * 1 * 2 *"。その後、Add ++の接尾辞表記法を使用してこれを評価し、8を生成できます。私たちは、どちらの降伏、この値のパリティを取る0偶数用と1列にインデックスを付ける前に、奇数のために"eo"、対応する文字を返します。