Desafio

Dada uma única palavra como entrada, determine se a palavra é ímpar ou par.

Palavras ímpares e pares

Suponha as regras gerais:

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

No alfabeto, as letras ímpares são:

aeiou

E as letras pares são:

bcdfghjklmnpqrstvwxyz

O mesmo se aplica às letras maiúsculas ( AEIOUsão ímpares e BCDFGHJKLMNPQRSTVWXYZpares).

Você 'adiciona' cada uma das letras da palavra. Por exemplo, a palavra catsé equivalente a:

even + odd + even + even

O que simplifica para:

odd + even

O que simplifica ainda mais:

odd

Então a palavra catsé estranha.

Exemplos

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Regras

Toda entrada será uma única palavra que conterá apenas caracteres alfabéticos.

Se a palavra for ímpar, insira um valor de verdade. Se a palavra for par, imprima um valor falsey.

Ganhando

O código mais curto em bytes vence.

05AB1E , 6 bytes

lžMÃgÉ

Explicação

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

Experimente online!

EXCEL, 79 bytes:

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

entrada:
Esta função pode ser colocada em qualquer lugar, EXCETO A1
Coloque sua palavra em questão em A1.

Saída: 0 se for par, 1 se for ímpar.

JavaScript (ES6), 34 41 33 32 bytes

Economizou 1 bytes graças a Arnauld:

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

• Palavra estranha: retorna 1
• Palavras pares: retorna 0

33 bytes graças a Arnauld:

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

• Palavra estranha: retorna 1
• Palavras pares: retorna 0

Outra maneira sem operadores bit a bit:

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

41 bytes:

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

• Palavra estranha: retorna 1
• Palavras pares com letras ímpares: retorna 0
• Palavras pares sem letras ímpares: retorna null

42 bytes para retornar em 0vez de null:

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

34 bytes, quebras de palavras sem letras ímpares:

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

Economizou 2 bytes graças a Shaun H

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

Brain-Flak 206 196 192 178 + 3 = 181 bytes

Experimente Online!

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

Isso requer que o -csinalizador seja executado no modo ASCII, adicionando 3 bytes extras ao comprimento do programa.

Ungolfed

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

Explicação

Primeiro armazene a altura da pilha para fins futuros

([]<...>

Enquanto a pilha não estiver vazia (assume que nenhum dos caracteres é zero)

{...}

Subtraia noventa e sete (e armazene 3 para otimizações posteriores)

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

Se não for zero (ou seja, não a)

{...}

Subtraia 4 (e armazene 4 para otimizações posteriores)

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

Se não for zero (ou seja, não e)

{...}

Subtraia 4 (e armazene 4 para otimizações posteriores)

({}[({})])

Se não for zero (ou seja, não i)

{...}

Subtraia 6 (e armazene 6 para otimizações posteriores)

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

Se não for zero (ou seja, não o)

{...}

Subtraia 6 (armazene 6 porque o programa espera um depois)

({}[({})])

Se não for zero (ou seja, não u)

{...}

Mova o restante para a outra pilha e coloque um zero na pilha ativa para escapar de todos os ifs

({}<>)(<>)

Depois que todos os ifs tiverem escapado, remova o zero e os seis

{}{}

Depois que todos os caracteres tiverem sido processados, subtraia a altura do deslocamento da altura armazenada originalmente.

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

Mod por dois

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

C, 42 bytes

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

Isso funciona com o GCC 4.x em uma CPU x86-64. Os resultados podem variar de acordo com as diferentes configurações.

Testá-lo em repl.it .

Ao custo de mais 5 bytes, é possível evitar um comportamento indefinido, portanto o código deve funcionar desde que os int tenham pelo menos 32 bits de largura.

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

Como funciona

Módulo 32 , os códigos de caracteres de todas as letras ímpares são 1 , 5 , 9 , 15 e 21 . 2130466 é o número inteiro de 32 bits que definiu bits nessas posições e não definiu bits em todas as outras.

Quando f é chamado em uma sequência, ele primeiro verifica se o primeiro caractere é um byte nulo (terminador de sequência). Se for, *sproduz 0 e f retorna 0 . Caso contrário, *sforneça o código de caractere de uma letra e o argumento correto do AND lógico ( &&) será executado.

Pois >>, o GCC gera uma instrução de turno. Em uma CPU x86-64, a instrução correspondente para um número inteiro de 32 bits ignora todos, exceto os 5 bits inferiores do argumento correto, o que evita a redução do *smódulo 32 . O deslocamento para a direita e o seguinte bit a bit E com 1 extratos do bit de 2.130.466 que corresponde à carta, que será 1 se e somente se a letra é estranho.

Depois, incrementar o ponteiro s (descartando efetivamente a primeira letra), chamada f recursivamente na corda decapitado, e tomar o XOR bit a bit do resultado de cima e o resultado da chamada recursiva.

sed 44 (42 + 1 para -n) 43

-1 graças a Neil

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

Imprime opara ímpar e nada para par

Python, 41 bytes

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

Python, 42 bytes

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

Não há muito o que explicar aqui. Uma função sem nome que retorna 0 ou 1.

Brain-Flak , 524, 446 , 422 bytes

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

Experimente online!

Versão não-gasta e mais legível:

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

Geléia , 13 12 11 bytes

-1 byte graças a @Luis Mendo (use Ḃpara substituir %2)
-1 byte graças a @Dennis (use uma compactação de string)

Œlf“¡ẎṢɱ»LḂ

Todos os casos de teste estão em TryItOnline

Quão?

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

Não concorrente, 5 bytes (desde que acabei de adicionar a funçãoØc )

fØcLḂ

Casos de teste também em TryItOnline

O mesmo que acima, mas Øcproduz as vogais do alfabeto latino,'AEIOUaeiou'

Haskell, 38 37 bytes

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

Graças a Angs por um byte!

Python 3, 53 bytes

Provavelmente isso pode ser ainda mais importante:

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

Java, 73

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

vi algumas respostas java, caso contrário não teria compartilhado. Agradecemos a Phaeze por salvar um byte.

C 52 bytes

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

o principal e o resultado:

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

*/

Pitão, 14 bytes

%l@"aeiou"rQ02

Experimente Online!

Explicação:

  @"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 bytes

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

Teclas Vim, 32, 31 , 29

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

Como o intérprete V é compatível com versões anteriores, você pode experimentá-lo online! bem aqui.

Um Três bytes salvos graças ao 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;}

Ungolfed:

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

dimwit , 14 bytes (não concorrente)

ar[aeiou]}et}T

Eu pensei que este seria um desafio divertido e simples para um novo idioma.

Explicação

• a - empurre uma nova matriz para a matriz
• r[aeiou]} - conte ocorrências de todos os valores correspondentes ao regex "[aeiou]" na primeira matriz (uma vez que a primeira matriz contém a entrada), ignorando maiúsculas e minúsculas e envie esse valor até o final da última matriz.
• e - se o último número da última matriz for par (que definimos como o número de ocorrências), execute as próximas operações até um colchete de fechamento ("}")
• t - interrompa a execução, limpe a matriz e defina o primeiro valor como falso
• } - fim do e bloco código
• T - interrompa a execução, limpe a matriz e defina o primeiro valor como verdadeiro

Experimente online!

Use o campo Entrada para inserir a palavra.

Em breve adicionarei documentação ...

PowerShell v2 +, 45 42 bytes

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

Recebe entrada $args[0], envia-a -replacepara remover todos os caracteres que não são vogais, pega o resultado .lengthe %2verifica se é ímpar / par.

Exemplos

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 bytes

2|+/@e.&'aeiouAEOIU'

Abordagem direta

Explicação

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

Japonês, 7 bytes

1&Uè"%v

Teste online! Saídas 1 para ímpar, 0 para par.

Como funciona

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

Oitava, 34 bytes

@(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

Este é 6 bytes mais curto do que a abordagem tradicional utilizando ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)e dois bytes mais curto do que a abordagem regex:@(s)mod(nnz(regexpi(s,'[aeiou]')),2) .

Teste aqui .

PHP, 41 bytes

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

Isso gera -1 para verdade e 0 para falsey.

Mathematica, 44 bytes

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

Dá Verdadeiro para uma sequência ímpar e Falso para uma sequência par.

q, 29 bytes

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

C # 64 62 56 50 bytes

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

• Já estamos usando linq, portanto Contém economiza 2 bytes sobre IndexOf
• Usar a sobrecarga de método de Count economiza 6 bytes
• Obrigado ao @Milk por sugerir um método elegante e salvar mais 6 bytes

Uma função anônima que pega uma string e conta as letras ímpares retorna true se houver um número ímpar delas ou false se não houver.

Esta nova solução divide a cadeia de caracteres em qualquer um dos caracteres na matriz de caracteres especificada. A mecânica disso muda o significado do %2resultado; 0 agora é ímpar e 1, portanto, o 1>.

Experimente online aqui!

Retina , 19 bytes

Mi`[aeiou]
[13579]$

Experimente online!(A primeira linha ativa um conjunto de testes separado por avanço de linha.)

A primeira linha conta as vogais na entrada. A segunda linha verifica se o resultado é ímpar.

MATL , 8 , 7 bytes

13Y2mso

Experimente online!

Explicação:

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 bytes

l1~Vm/s 2%

Experimente aqui!