挑战

给定一个单词作为输入，请确定该单词是奇数还是偶数。

奇偶字

假设一般规则：

odd + odd = even
even + odd = odd
odd + even = odd
even + even = even

在字母表中，奇数字母为：

aeiou

偶数字母是：

bcdfghjklmnpqrstvwxyz

大写字母也是如此（AEIOU奇数和BCDFGHJKLMNPQRSTVWXYZ偶数）。

然后，您将单词中的每个字母一起“添加”。例如，该词cats等于：

even + odd + even + even

简化为：

odd + even

这进一步简化为：

odd

所以这个词cats很奇怪。

例子

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

规则

所有输入将是一个仅包含字母字符的单词。

如果单词是奇数，则输出真值。如果单词是偶数，则输出假值。

获奖

以字节为单位的最短代码获胜。

05AB1E，6个字节

lžMÃgÉ

说明

l       # convert to lower case
 žMÃg   # count odd letters
     É  # true if odd else false

在线尝试！

EXCEL，79个字节：

=MOD(SUMPRODUCT(LEN(A1)-LEN(SUBSTITUTE(LOWER(A1),{"a","e","i","o","u"},""))),2)

输入：
此功能可以放置在A1以外的任何位置
。

输出：偶数为0，奇数为1。

JavaScript（ES6），34 41 33 32字节

感谢Arnauld，节省了1个字节：

s=>~s.split(/[aeiou]/i).length&1

• 奇数词：返回 1
• 偶数字：回报 0

33字节归功于Arnauld：

s=>s.split(/[aeiou]/i).length&1^1

• 奇数词：返回 1
• 偶数字：回报 0

没有按位运算符的另一种方式：

s=>++s.split(/[aeiou]/i).length%2

41个字节：

(s,a=s.match(/[aeiou]/ig))=>a&&a.length%2

• 奇数词：返回 1
• 带有奇数字母的偶数单词：返回 0
• 没有奇数字母的偶数单词：返回 null

返回42个字节，0而不是null：

(s,a=s.match(/[aeiou]/ig))=>a?a.length%2:0

34个字节，不包含奇数字母的单词：

f=s=>s.match(/[aeiou]/ig).length%2

感谢Shaun H，节省了2个字节

s=>s.match(/[aeiou]/ig).length%2

脑高射炮 206 196 192 178 + 3 = 181字节

在线尝试！

([]<{({}[((((((()()())){}){}){}){}){}()]){({}[({}())]){({}[({})]){({}[({}()())]){({}[({})]){({}<>)(<>)}}}}}{}{}}><>[[]]<>()()){(({}[<>(())<>()()])){{}({}())((<>)<>)}{}}{}<>({}<>)  

这要求该-c标志以ASCII模式运行，从而在程序长度上增加了3个字节。

不打高尔夫球

([]<
{({}[(((((()()()){}){}){}){}){}()])
 {
  ({}[()()()()])
  {
   ({}[()()()()])
   {
    ({}[(()()()){}])
    {
     ({}[(()()()){}])
     {
      ({}<>)
      (<>)
     }
    }
   }
  }
 }
 {}
}
><>[[]]<>)
(<(()()<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)

说明

首先存储堆栈高度以备将来使用

([]<...>

然后，当堆栈不为空时（假设所有字符都不为零）

{...}

减去97（并存储3以便以后进行优化）

({}[((((((()()())){}){}){}){}){}()])

如果它不为零（即不是a）

{...}

减去4（并存储4以便以后进行优化）

({}[({}())])

如果它不为零（即不是e）

{...}

减去4（并存储4以便以后进行优化）

({}[({})])

如果不为零（即不是i）

{...}

减去6（并存储6以便以后进行优化）

({}[({}()())])

如果不是零（即不是o）

{...}

减去6（存储6，因为程序希望以后再存储）

({}[({})])

如果它不为零（即不是u）

{...}

将其余的移动到另一个堆栈，并在活动堆栈上放置零，以逃避所有ifs

({}<>)(<>)

一旦所有if都逃脱了，请删除零和六

{}{}

处理完所有字符后，请从原始存储的高度中减去偏移量的高度。

...<>[[]]<>)

模二

{(({}[<>(())<>()()])){{}({}())((<>)<>)}{}}{}<>({}<>) 

C，42个字节

f(char*s){return*s&&2130466>>*s&1^f(s+1);}

这适用于x86-64 CPU上的GCC4.x。结果可能因不同的设置而异。

在repl.it上对其进行测试。

以另外5个字节为代价，可以避免未定义的行为，因此只要int至少为32位宽，代码就应该可以工作。

f(char*s){return*s&&2130466>>(*s&31)&1^f(s+1);}

怎么运行的

模32，所有奇数字母的字符代码是1，5，9，15，和21。2130466是32位整数，在这些位置具有置位，而在所有其他位置具有未置位。

当在字符串上调用f时，它将首先检查字符串的第一个字符是否为空字节（字符串终止符）。如果是，则*s产生0，并且f返回0。否则，*s产生字母的字符代码，并&&执行逻辑AND（）的右参数。

对于>>，GCC生成移位指令。在x86-64 CPU上，用于32位整数的相应指令将忽略右参数的除低5位以外的所有指令，这避免了对32取*s模。右移以及随后的按位与1提取与字母相对应的2130466位，当且仅当字母为奇数时，该位才为1。

然后，我们增加指针s（有效地丢弃第一个字母），对斩首的字符串进行递归调用f，并从上方对结果和递归调用的结果进行按位XOR运算。

sed 44（-n为42 +1）43

-1感谢Neil

s/[aeiou][^aeiou]*[aeiou]//gi
/[aeiou]/Ico

打印o为奇数而不打印为偶数

Python，41个字节

lambda s:sum(map(s.count,"aeiouAEIOU"))%2

Python，42个字节

lambda s:sum(c in"aeiouAEIOU"for c in s)%2

这里没有太多要解释的。返回0或1的未命名函数。

Brain-Flak，524，446，422字节

{(<((((()()()()){}){}){}<>)>)<>{({}[()])<>(({}[({})]())){{}(<({}({}))>)}{}<>}{}<>([(((({}<{}<>>))))]()){(<{}>)<>({}[()])<>}<>({}())<>{}([{}]()()()()()){(<{}>)<>({}[()])<>}<>({}())<>{}(((()()())){}{}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}(((()()()()())){}{}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}((((()()()){}())){}{}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}}(<(()())>)<>{({}[()])<>(({}[({})]())){{}(<({}({}))>)}{}<>}{}<>({}<{}<>>)

在线尝试！

非高尔夫的，更具可读性的版本：

{((((()()()()){}){}){})(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>)((((({})))))
(())
({}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}
(()()()()())
({}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}
(()()()()()()()()())
({}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}
(()()()()()()()()()()()()()()())
({}[{}]){(<{}>)<>({}[()])<>}<>({}())<>{}
(()()()()()()()()()()()()()()()()()()()()())
({}[{}])
{(<{}>)<>({}[()])<>}<>({}())<>{}}<>(()())(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}><>){{}([()])
(<><>)}({}{}())

果冻，13 12 11 字节

-1个字节感谢@Luis Mendo（用于Ḃ替换%2）
-1个字节感谢@Dennis（使用字符串压缩）

Œlf“¡ẎṢɱ»LḂ

所有测试用例都在TryItOnline上

怎么样？

Œlf“¡ẎṢɱ»LḂ - Main link takes an argument - s
Œl          - lowercase(s)
   “¡ẎṢɱ»   - string of lowercase vowels (compression using the words a and eoui)
  f         - filter - keep only the vowels
         L  - length - the number of vowels
          Ḃ - Bit (modulo 2)

不竞争，5个字节（因为我刚刚添加了该函数Øc）

fØcLḂ

在TryItOnline上也有测试用例

与上述相同，但会Øc产生拉丁字母的元音，'AEIOUaeiou'

Haskell，38 37字节

odd.length.filter(`elem`"aeiouAEIOU")

感谢Angs提供一个字节！

Python 3，53字节

这可能可以进一步打高尔夫球：

lambda n:[x in 'aeiou' for x in n.lower()].count(1)&1

爪哇，73

boolean f(String s){return s.replaceAll("(?i)[^aeiou]","").length()%2>0;}

看到其他几个Java答案，否则就不会共享。感谢Phaeze节省了一个字节。

C 52字节

h(o){o=strpbrk(o,"aeiouAEIOU");return o?1^h(o+1):0;}

主要和结果：

main()
{int   k;
 char *a[]={"trees","brush","CAts","Savoie","rhythm", 0};

 for(k=0;a[k];++k)
     printf("[%s]=%s\n", a[k], h(a[k])?"odd":"even");
}

/*
91
[trees]=even
[brush]=odd
[CAts]=odd
[Savoie]=even
[rhythm]=even

*/

Pyth，14个字节

%l@"aeiou"rQ02

在线尝试！

说明：

  @"aeiou"       Grab only the vowels
          rQ0      From lowercased input
 l                 Get the length of this
%            2     And mod 2 to check for oddness

Ruby，30个字节

->w{w.scan(/[aeiou]/i).size%2}

VIM，32，31，29次的击键

:s/[^aeiou]//gi
C<C-r>=len(@")%2<cr>

由于V解释器向后兼容，因此您可以在线尝试！就在这儿。

一节省了三字节，这要归功于m-chrzan！

Java 7、88

boolean f(char[]s){int x=0;for(char c:s)if("aeiouAEIOU".indexOf(c)>=0)++x;return x%2>0;}

取消高尔夫：

  boolean f(char[] s) {
    int x = 0;
    for (char c : s) {
      if ("aeiouAEIOU".indexOf(c) >= 0) {
        ++x;
      }
    }
    return x % 2 > 0;
  }

dimwit，14个字节（非竞争）

ar[aeiou]}et}T

我认为这对于一门新语言来说是一个有趣，简单的挑战。

说明

• a -将新数组推入矩阵
• r[aeiou]} -计算第一个数组中与正则表达式“ [aeiou]”匹配的所有值的出现（因为第一个数组包含输入），忽略大小写，并将该值推到最后一个数组的末尾。
• e -如果最后一个数组中的最后一个数字是偶数（我们将其设置为出现次数），请执行下一个操作，直到右括号（“}”）
• t -停止执行，清除矩阵，并将第一个值设置为false
• }- e代码块结尾
• T -停止执行，清除矩阵，并将第一个值设置为true

在线尝试！

使用输入字段输入单词。

我很快会添加文档...

PowerShell v2 +，45个 42字节

($args[0]-replace'[^aeiouAEIOU]').Length%2

接受输入$args[0]，将其发送-replace以删除所有非元音字符，接受结果.length，并%2检查其是否为奇/偶。

例子

PS C:\Tools\Scripts\golfing> 'trees','brush','CAts','Savoie','rhythm'|%{"$_ --> "+(.\is-it-an-odd-word.ps1 $_)}
trees --> 0
brush --> 1
CAts --> 1
Savoie --> 0
rhythm --> 0

J，20个字节

2|+/@e.&'aeiouAEOIU'

直截了当的方法

说明

2|+/@e.&'aeiouAEOIU'  Input: string S
     e.&'aeiouAEOIU'  Test each char in S for membership in 'aeiouAEOIU'
  +/@                 Sum those values
2|                    Take it modulo 2 and return

Japt，7个字节

1&Uè"%v

在线测试！输出1表示奇数，0表示偶数。

怎么运行的

         // Implicit: U = input string
  Uè     // Count the number of matches of the following regex in the input:
    "%v  //   /[AEIOUaeiou]/g
1&       // Take only the first bit (convert 1, 3, 5, etc. to 1, and others to 0)
         // Implicit output

八度，34字节

@(s)mod(nnz(~(s'-'aeiouAEIOU')),2)


s'-'aeiouAEIOU'    % Creates a 2D-matrix where each of the odd letters are 
                   % subtracted from the string s
~(s'-'aeiouAEIOU') % Negates that array, so the all zero elements become 1
nnz( .... )        % Counts all the non-zero elements (the odd letters)
mod(nnz( ....),2   % Takes this sum modulus 2

这比传统方法更短的6个字节利用ismember，@(s)mod(sum(ismember(s,'aeiouAEIOU')),2)和两字节比所述正则表达式的方法更短的：@(s)mod(nnz(regexpi(s,'[aeiou]')),2)。

在这里测试。

PHP，41字节

<?=count(spliti("[aeiou]",$argv[1]))%2-1;

这将为真输出-1，为假输出0。

Mathematica，44个字节

OddQ@StringCount[#,Characters@"aeiouAEIOU"]&

为奇数字符串提供True，为偶数字符串提供False。

q，29个字节

{mod[sum x in "aeiouAEIOU";2]}

C＃64 62 56 50字节

s=>1>s.Split("aeiouAEIOU".ToCharArray()).Length%2;

• 我们已经在使用linq，所以Contains在IndexOf上节省了2个字节
• 使用Count的方法重载可节省6个字节
• 感谢@Milk提出了一种整洁的方法并节省了6个字节

一个匿名函数，它接收字符串并计算奇数字母，如果奇数个字母为奇数，则返回true；否则为false。

此新解决方案将字符串拆分给定char数组中的任何字符。这种机制使%2结果的含义发生变化。现在0是奇数，而1甚至是1 1>。

在这里在线尝试！

视网膜，19字节

Mi`[aeiou]
[13579]$

在线尝试！（第一行启用换行分隔的测试套件。）

第一行计算输入中的元音。第二行检查结果是否为奇数。

MATL，8，7个字节

13Y2mso

在线尝试！

说明：

13Y2    % Push the string 'aeiouAEIOU', a predefined literal. 
    m   % For each char of the input that is in that string, push a one. For every other element, push a zero.
     s  % Sum this array
      o % Mod 2

Pyke，10个字节

l1~Vm/s 2%

在这里尝试！