70

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

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

# 挑战

``````eo
ooe
o+e
ee*
+*oe
+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``````

8

ghosts_in_the_code

8
@ghosts_in_the_code不，对不起。

2

xnor 2015年

1
@xnor当然。无论如何。

2

WGroleau

43

## CJam，18 17 13字节

``````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.
``````

27

# 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"
``````

xnor 2015年

@xnor以模包装方式完成对字符串中元素的访问。因此，没有必要对模2
Jakube

@xnor但是，感谢相反的事情。当然这不是必须的。（我今天有点累了。）
Jakube 2015年

16

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

primo

h 我真笨 在尝试其`sed`版本时实际上使用了该条件…谢谢@primo。
manatwork

primo

manatwork

Digital Trauma 2015年

13

# 视网膜，29字节

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

（此解决方案类似于manatwork的Perl回答。）

12

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

xnor 2015年

3

xnor

1
@xnor您最好将其发布为答案。与该解决方案有很大不同。
feersum

9

## Mathematica，91 84字节

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

3
`//.`比短`FixedPoint`
alephalpha

8

## 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]``

karhell 2015年

@karhell它计算像的表达式`e+o`，因此它需要变量来引用数字。
xnor

8

## C，79字节

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

8

# Shell + GNU实用程序，33

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

5

## 严重的是，24个字节

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

``````,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"
``````

5

# Ruby，61个字节

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

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

puts f ? 'o' : 'e'``````

1

-Shelvacu 2015年

Shelvacu 2015年

1

daniero 2015年

@谢尔阿哈..！我改回去`f^f``f&f`然后翻转`\$_==?e``?e:?o`相反:)
daniero

1

Shelvacu 2015年

4

## Minkolang 0.14，40字节

``````\$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
``````

1
hoo！好的 ol'shell击败了（半）打高尔夫球的语言；-P
Digital Trauma

4

# JavaScript，110106 94字节

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

manatwork 2015年

Arkain 2015年

manatwork

1

Alex A.

1
@Arkain，您无需在正则表达式中捕获一个组，因为无论如何您将整个匹配的子字符串作为一个部分使用。出于相同的原因，无需将参数e传递给回调。
manatwork 2015年

4

# O，24 20 19 18字节

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

```我`获取输入并反转输入，因为O使用后缀表示法
2：e; 将e分配给2
1：o; 将o分配给1
〜2％评估并检查结果是否均匀
'o'e？如果为偶数则输出“ e”，如果为奇数则输出“ o”
```

4

# GNU Sed，36岁

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

Ruud Helderman 2015年

@Ruud是的。我以前尝试过，但是没有意识到不使用`|`时需要逃脱的需求`-r`。不过，比分还差2个字节-谢谢！
Digital Trauma 2015年

2

``````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"]``````

2

## JavaScript，92 71字节

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

``````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"
))``````

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

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

1

# 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]);}
``````

1

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

1

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

1

# Python 3中，171个145 135字节

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

`callable()`很优雅，但是很长。（反转条件并除去条件`not`会更短。）相反，检查m是否为整数`m in[0,1]`会更短，但检查c是否为value `c in'eo'`会更短。稍后与`c>'a'`此情况相同。
manatwork 2015年

manatwork 2015年

@manatwork：谢谢！我认为我无法逆转这种情况，因为我认为这意味着`s.pop()`每个循环都要调用（两次）。直到现在我才开始打扰。但是，现在要解决这个问题了。

manatwork 2015年

@manatwork：因为我没有想到。我只考虑了infix运算符（`^``&`）及其`operator`对等运算符，而忽略了实际实现它们的方法。哦，`reversed()`由于另一个Python高尔夫技巧，现在已被删除。

1

``````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
``````

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

0

# 加++，46字节

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

## 这个怎么运作

`f`首先采用输入字符串并将其反转，从而产生`"eo*e*o*e*"`。然后，我们映射`g`每个元素：

`g`首先复制参数，直到最后一条命令之前都保留一个副本。然后，我们检查参数是否在字符串中`"oe"`，字母是否为1，或则为0。然后，我们再次推送该参数，并检查其是否等于。然后将此结果添加到先前的检查中。这产生0为任一或，1对和2对。然后，我们在该值和参数之间进行逻辑或。如果值为0，则将其替换为参数（即或），否则将保持原样（即12）。`*``+``"e"``*``+``o``e``*``+`

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.