Reto

Dada una sola palabra como entrada, determine si la palabra es impar o par.

Palabras impares y pares

Asuma las reglas generales:

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

En el alfabeto, las letras impares son:

aeiou

Y las letras pares son:

bcdfghjklmnpqrstvwxyz

Lo mismo se aplica a las letras mayúsculas ( AEIOUson impares y BCDFGHJKLMNPQRSTVWXYZpares).

Luego 'agrega' cada una de las letras de la palabra juntas. Por ejemplo, la palabra catses equivalente a:

even + odd + even + even

Lo que se simplifica a:

odd + even

Lo cual se simplifica aún más para:

odd

Entonces la palabra catses extraña.

Ejemplos

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Reglas

Toda entrada será una sola palabra que solo contendrá caracteres alfabéticos.

Si la palabra es impar, genera un valor verdadero. Si la palabra es par, genera un valor falsey.

Victorioso

El código más corto en bytes gana.

05AB1E , 6 bytes

lžMÃgÉ

Explicación

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

Pruébalo en línea!

EXCEL, 79 bytes:

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

entrada:
esta función se puede colocar en cualquier lugar EXCEPTO A1
Ponga su palabra en cuestión en A1.

Salida: 0 si es par, 1 si es impar.

JavaScript (ES6), 34 41 33 32 bytes

Guardado 1 bytes gracias a Arnauld:

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

• Palabra extraña: vuelve 1
• Palabras pares: retornos 0

33 bytes gracias a Arnauld:

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

• Palabra extraña: vuelve 1
• Palabras pares: retornos 0

Otra forma sin operadores bit a bit:

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

41 bytes:

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

• Palabra extraña: vuelve 1
• Palabras pares con letras impares: retornos 0
• Palabras pares sin letras impares: devuelve null

42 bytes para devolver en 0lugar de null:

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

34 bytes, saltos en palabras sin letras impares:

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

Guardado 2 bytes gracias a Shaun H

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

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

Pruébalo en línea!

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

Esto requiere que la -cbandera se ejecute en modo ASCII agregando 3 bytes adicionales a la longitud del programa.

Sin golf

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

Explicación

Primero almacene la altura de la pila para propósitos futuros

([]<...>

Luego, mientras la pila no está vacía (se supone que ninguno de los caracteres es cero)

{...}

Reste noventa y siete (y almacene 3 para optimizaciones posteriores)

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

Si no es cero (es decir, no es a)

{...}

Resta 4 (y almacena 4 para optimizaciones posteriores)

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

Si no es cero (es decir, no e)

{...}

Resta 4 (y almacena 4 para optimizaciones posteriores)

({}[({})])

Si no es cero (es decir, no i)

{...}

Resta 6 (y almacena 6 para optimizaciones posteriores)

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

Si no es cero (es decir, no o)

{...}

Resta 6 (almacena 6 porque el programa espera uno más tarde)

({}[({})])

Si no es cero (es decir, no u)

{...}

Mueve el resto a la otra pila y pon un cero en la pila activa para escapar de todos los ifs

({}<>)(<>)

Una vez que se hayan escapado todos los if, elimine el cero y el seis

{}{}

Una vez que se hayan procesado todos los caracteres, reste la altura del desplazamiento de la altura almacenada originalmente.

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

Mod por dos

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

C, 42 bytes

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

Esto funciona con GCC 4.x en una CPU x86-64. Los resultados pueden variar con diferentes configuraciones.

Probarlo en repl.it .

Con el costo de 5 bytes más, se puede evitar un comportamiento indefinido, por lo que el código debería funcionar siempre que los int s tengan al menos 32 bits de ancho.

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

Cómo funciona

Módulo 32 , los códigos de caracteres de todas las letras impares son 1 , 5 , 9 , 15 y 21 . 2130466 es el entero de 32 bits que ha establecido bits en estas posiciones y bits no establecidos en todos los demás.

Cuando se llama a f en una cadena, primero verifica si el primer carácter de la cadena es un byte nulo (terminador de cadena). Si lo es, *sproduce 0 y f vuelve 0 . De lo contrario, *sarroje el código de caracteres de una letra y &&se ejecutará el argumento correcto de la lógica AND ( ).

Para >>, GCC genera una instrucción de turno. En una CPU x86-64, la instrucción correspondiente para un entero de 32 bits ignora todos menos los 5 bits inferiores del argumento correcto, lo que evita reducir el *smódulo 32 . El desplazamiento a la derecha y el siguiente bit a bit Y con 1 extrae el bit de 2130466 que corresponde a la letra, que será 1 si y solo si la letra es impar.

Luego, incrementamos el puntero s (descartando efectivamente la primera letra), llamamos a f recursivamente en la cadena decapitada y tomamos el XOR bit a bit del resultado anterior y el resultado de la llamada recursiva.

sed 44 (42 + 1 para -n) 43

-1 gracias a Neil

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

Imprime opara impar y nada para incluso

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

No hay mucho que explicar aquí. Una función sin nombre que devuelve 0 o 1.

Brain-Flak , 524, 446 , 422 bytes

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

Pruébalo en línea!

Versión no legible y más legible:

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

Jalea , 13 12 11 bytes

-1 byte gracias a @Luis Mendo (usar Ḃpara reemplazar %2)
-1 byte gracias a @Dennis (usar una compresión de cadena)

Œlf“¡ẎṢɱ»LḂ

Todos los casos de prueba están en TryItOnline

¿Cómo?

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

No competidores, 5 bytes (ya que acabo de agregar la función Øc)

fØcLḂ

Casos de prueba también en TryItOnline

Igual que el anterior, pero Øcproduce las vocales del alfabeto latino,'AEIOUaeiou'

Haskell, 38 37 bytes

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

¡Gracias a Angs por un byte!

Python 3, 53 bytes

Esto probablemente se pueda jugar más:

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 un par de otras respuestas de Java, de lo contrario no habría compartido. Gracias a Phaeze por guardar un byte.

C 52 bytes

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

El principal y el 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

*/

Pyth, 14 bytes

%l@"aeiou"rQ02

Pruébalo en línea!

Explicación:

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

Rubí, 30 bytes.

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

Vim, 32, 31 , 29 pulsaciones de teclas

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

Como el intérprete de V es compatible con versiones anteriores, ¡puede probarlo en línea! aquí.

Uno Three bytes guardados gracias a 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;}

Sin golf:

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

dimwit , 14 bytes (no competidor)

ar[aeiou]}et}T

Pensé que este sería un desafío divertido y simple para comenzar con un nuevo idioma.

Explicación

• a - empujar una nueva matriz a la matriz
• r[aeiou]} - contar las ocurrencias de todos los valores que coinciden con la expresión regular "[aeiou]" en la primera matriz (ya que la primera matriz contiene la entrada), ignorando mayúsculas y minúsculas, y empujar ese valor al final de la última matriz.
• e - si el último número en la última matriz es par (que establecemos en el número de ocurrencias), realice las siguientes operaciones hasta un paréntesis de cierre ("}")
• t - detener la ejecución, borrar la matriz y establecer el primer valor como falso
• }- fin del ebloque de código
• T - detiene la ejecución, borra la matriz y establece el primer valor como verdadero

Pruébalo en línea!

Use el campo Entrada para ingresar la palabra.

Pronto agregaré documentación ...

PowerShell v2 +, 45 42 bytes

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

Toma entrada $args[0], la envía -replacepara eliminar todos los caracteres que no son vocales, toma la resultante .lengthy%2 comprueba si es impar / par.

Ejemplos

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'

Enfoque directo

Explicación

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 bytes

1&Uè"%v

¡Pruébelo en línea! Salidas 1 para impar, 0 para par.

Cómo 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

Octava, 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

Esto es 6 bytes más corto que el enfoque tradicional usando ismember ,@(s)mod(sum(ismember(s,'aeiouAEIOU')),2) y dos bytes más corto que el enfoque de expresiones regulares: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Pruébalo aquí .

PHP, 41 bytes

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

Esto genera -1 para la verdad y 0 para falsey.

Mathematica, 44 bytes

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

Da True para una cadena impar y False para una pareja.

q, 29 bytes

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

C # 64 62 56 50 bytes

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

• Ya estamos usando linq, por lo que Contains guarda 2 bytes sobre IndexOf
• Usar el método de sobrecarga de Count ahorra 6 bytes
• Gracias a @Milk por sugerir un método ordenado y guardar 6 bytes más.

Una función anónima que toma una cadena y cuenta las letras impares y luego devuelve verdadero si hay un número impar de ellas o falso si no lo hay.

Esta nueva solución divide la cadena en cualquiera de los caracteres en la matriz de caracteres dada. La mecánica de esto cambia el significado del %2resultado; 0 ahora es impar y 1 par, por lo tanto, el 1>.

Pruébelo en línea aquí!

Retina , 19 bytes

Mi`[aeiou]
[13579]$

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

La primera línea cuenta las vocales en la entrada. La segunda línea verifica que el resultado sea impar.

MATL , 8 , 7 bytes

13Y2mso

Pruébalo en línea!

Explicación:

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%

Pruébalo aquí!