前言

整数始终为偶数或奇数。偶数可被二整除，奇数不可。

当您将两个整数相加时，可以根据被加数是偶数还是奇数来推断结果是偶数还是奇数：

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

同样，当您将两个整数相乘时，可以根据因子是偶数还是奇数来推断结果是偶数还是奇数：

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

因此，如果您知道数学表达式中仅涉及加法和乘法的所有变量的偶数或奇数，则可以推断结果是偶数还是奇数。

例如，我们可以确信地说(68 + 99) * 37结果是奇数，因为偶数加上奇数（68 + 99）就是一个奇数，而奇数乘以另一个奇数（odd * 37）就是一个奇数。

挑战

编写一个仅包含四个字符的字符串的程序或函数eo+*。该字符串表示一个以前缀表示法给出的数学表达式，仅涉及加法（+）和乘法（*）。每个e代表任意的偶数，每个o代表任意的奇数。

您的任务是简化表达式，打印或返回单个e或o基于表达式结果是偶数还是奇数。

您可以假设输入将始终使用有效的前缀表示法。具体来说，每个+和*将始终具有两个对应的操作数。这些操作数可以是单个e或o，或另一个+或*表达式，又具有操作数。

例如，输入*+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字节

感谢aditsu节省了4个字节。

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语法的字符串。因此，我代替e和o与4和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

为了方便使用一个文件版本，-s使用了标志。

我们换奇表达式（*oo，+oe，+eo），以o直到我们可以，然后交换剩余的符号字母字母的表达式e。我们重复此过程，直到可以，最后一个字母是我们的输出。

（此解决方案类似于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来计算表达式+，并*用eval(f(i)+a+f(i))中，操作人员a放置递归结果之间的中缀。eval使用e=0,o=1可选函数参数中的绑定。然后将输出设为mod 2。

C，79字节

直接递归。依赖于四个允许的输入字符的某些（巧合？）按位属性。

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

Shell + 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。现在唯一的值是0and 1，因此输出基数为15无关紧要。然后tr转换为oor e。

我喜欢你if着眼睛看，这个来源几乎就像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

该函数一次从stdin读取一个字符。如果读取a +或a *，它将调用两次以确定奇数或偶数。该函数返回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，110106 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和帖子它的tumblr评估它作为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。

感谢@Ruud削减了4个字节。

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)]))

Dart，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的（非常聪明的）递归迭代器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"

该函数的工作方式是反复减少字符串中最右边的运算符，直到没有剩余的运算符为止。

加++，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。然后，我们再次推送该参数，并检查其是否等于。然后将此结果添加到先前的检查中。这产生0为任一或，1对和2对。然后，我们在该值和参数之间进行逻辑或。如果值为0，则将其替换为参数（即或），否则将保持原样（即1和2）。*+"e"*+oe*+

它将所有与输入相反的字母转换为数值。然后，我们用空格将每个元素连接起来，以确保数字没有连接在一起。对于我们的示例，这将产生字符串"2 1 * 2 * 1 * 2 *"。然后，我们可以使用Add ++的后缀表示法对此进行评估，得出8。然后，我们对该值进行奇偶校验，在索引到字符串并返回相应的字母之前，对偶数产生0，对奇数产生1"eo"。