Défi

Étant donné un seul mot en entrée, déterminez si le mot est impair ou pair.

Mots pairs et impairs

Supposons les règles générales:

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

Dans l'alphabet, les lettres impaires sont:

aeiou

Et les lettres paires sont:

bcdfghjklmnpqrstvwxyz

Il en va de même pour les majuscules ( AEIOUsont impairs et BCDFGHJKLMNPQRSTVWXYZpairs).

Vous «ajoutez» ensuite chacune des lettres du mot ensemble. Par exemple, le mot catséquivaut à:

even + odd + even + even

Ce qui simplifie:

odd + even

Ce qui simplifie encore plus:

odd

Donc, le mot catsest étrange.

Exemples

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Règles

Toutes les entrées seront un seul mot qui ne contiendra que des caractères alphabétiques.

Si le mot est impair, sortez une valeur véridique. Si le mot est pair, sortez une valeur de falsey.

Gagnant

Le code le plus court en octets gagne.

05AB1E , 6 octets

lžMÃgÉ

Explication

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

Essayez-le en ligne!

EXCEL, 79 octets:

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

entrée:
Cette fonction peut être placée n'importe où SAUF A1
Mettez votre mot en question dans A1.

Sortie: 0 si pair, 1 si impair.

JavaScript (ES6), 34 41 33 32 octets

1 octets enregistrés grâce à Arnauld:

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

• Mot étrange: retourne 1
• Mots pairs: retourne 0

33 octets grâce à Arnauld:

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

• Mot étrange: retourne 1
• Mots pairs: retourne 0

Une autre façon sans opérateurs au niveau du bit:

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

41 octets:

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

• Mot étrange: retourne 1
• Mots pairs avec des lettres impaires: retourne 0
• Mots pairs sans lettres impaires: retourne null

42 octets à renvoyer 0au lieu de null:

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

34 octets, pause sur les mots sans lettres impaires:

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

Enregistré 2 octets grâce à Shaun H

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

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

Essayez-le en ligne!

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

Cela nécessite que l' -cindicateur s'exécute en mode ASCII en ajoutant 3 octets supplémentaires à la longueur du programme.

Non golfé

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

Explication

Stockez d'abord la hauteur de la pile pour de futures utilisations

([]<...>

Ensuite, alors que la pile n'est pas vide (suppose qu'aucun des caractères n'est nul)

{...}

Soustrayez quatre-vingt-dix-sept (et stockez 3 pour des optimisations ultérieures)

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

S'il n'est pas nul (c'est-à-dire pas a)

{...}

Soustrayez 4 (et stockez 4 pour des optimisations ultérieures)

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

Si ce n'est pas zéro (c'est-à-dire pas e)

{...}

Soustrayez 4 (et stockez 4 pour des optimisations ultérieures)

({}[({})])

Si ce n'est pas zéro (c'est-à-dire pas i)

{...}

Soustrayez 6 (et stockez 6 pour des optimisations ultérieures)

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

Si ce n'est pas zéro (c'est-à-dire pas o)

{...}

Soustrayez 6 (stockez 6 car le programme en attend un plus tard)

({}[({})])

Si ce n'est pas zéro (c'est-à-dire pas u)

{...}

Déplacez le reste dans l'autre pile et mettez un zéro sur la pile active pour échapper à tous les ifs

({}<>)(<>)

Une fois tous les ifs échappés, supprimez le zéro et les six

{}{}

Une fois que tous les caractères ont été traités, soustrayez la hauteur du décalage de la hauteur initialement stockée.

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

Mod par deux

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

C, 42 octets

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

Cela fonctionne avec GCC 4.x sur un processeur x86-64. Les résultats peuvent varier selon les différentes configurations.

Testez - le sur repl.it .

Au prix de 5 octets supplémentaires, un comportement indéfini peut être évité, donc le code devrait fonctionner tant que les int s ont une largeur d'au moins 32 bits.

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

Comment ça marche

Modulo 32 , les codes de caractères de toutes les lettres impaires sont 1 , 5 , 9 , 15 et 21 . 2130466 est l'entier 32 bits qui a défini des bits à ces positions et des bits non définis à tous les autres.

Lorsque f est appelé sur une chaîne, il vérifie d'abord si le premier caractère de la chaîne est un octet nul (terminateur de chaîne). Si c'est le cas, *sdonne 0 et f renvoie 0 . Sinon, *sdonnez le code de caractère d'une lettre et l'argument de droite du AND logique ( &&) est exécuté.

Pour >>, GCC génère une instruction de décalage. Sur un processeur x86-64, l'instruction correspondante pour un entier 32 bits ignore tout sauf les 5 bits inférieurs de l'argument de droite, ce qui évite de réduire le *smodulo 32 . Le décalage à droite et le ET suivant au niveau du bit avec 1 extrait le bit de 2130466 qui correspond à la lettre, qui sera 1 si et seulement si la lettre est impaire.

Ensuite, nous incrémentons le pointeur s (en supprimant effectivement la première lettre), appelons f récursivement sur la chaîne décapitée et prenons le XOR au niveau du bit du résultat d'en haut et le résultat de l'appel récursif.

sed 44 (42 + 1 pour -n) 43

-1 merci à Neil

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

Imprime opour impair et rien pour pair

Python, 41 octets

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

Python, 42 octets

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

Pas grand chose à expliquer ici. Une fonction sans nom qui renvoie 0 ou 1.

Brain-Flak , 524, 446 , 422 octets

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

Essayez-le en ligne!

Version non lue, plus lisible:

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

Gelée , 13 12 11 octets

-1 octet grâce à @Luis Mendo (utilisé Ḃpour remplacer %2)
-1 octet grâce à @Dennis (utiliser une compression de chaîne)

Œlf“¡ẎṢɱ»LḂ

Tous les cas de test sont sur TryItOnline

Comment?

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

Non concurrent, 5 octets (puisque je viens d'ajouter la fonction Øc)

fØcLḂ

Cas de test également à TryItOnline

Comme ci-dessus, mais Øcdonne les voyelles de l'alphabet latin,'AEIOUaeiou'

Haskell, 38 37 octets

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

Merci à Angs pour un octet!

Python 3, 53 octets

Cela peut probablement être joué plus loin:

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;}

vu quelques autres réponses java, sinon n'aurait pas partagé. Merci à Phaeze d'avoir enregistré un octet.

C 52 octets

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

le principal et le résultat:

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 octets

%l@"aeiou"rQ02

Essayez-le en ligne!

Explication:

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

Rubis, 30 octets

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

Vim, 32, 31 , 29 touches

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

L'interpréteur V étant rétrocompatible, vous pouvez l' essayer en ligne! ici.

Un Trois octets économisés grâce à 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;}

Non golfé:

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

dimwit , 14 octets (non concurrent)

ar[aeiou]}et}T

Je pensais que ce serait un défi amusant et simple pour commencer avec une nouvelle langue.

Explication

• a - pousser un nouveau tableau vers la matrice
• r[aeiou]} - compter les occurrences de toutes les valeurs correspondant à l'expression régulière "[aeiou]" dans le premier tableau (puisque le premier tableau contient l'entrée), en ignorant la casse, et pousser cette valeur à la fin du dernier tableau.
• e - si le dernier nombre du dernier tableau est pair (que nous fixons au nombre d'occurrences), effectuez les opérations suivantes jusqu'à une parenthèse fermante ("}")
• t - arrêtez l'exécution, effacez la matrice et définissez la première valeur sur false
• }- fin du ebloc de code
• T - arrêtez l'exécution, effacez la matrice et définissez la première valeur sur true

Essayez-le en ligne!

Utilisez le champ de saisie pour saisir le mot.

Je vais bientôt ajouter de la documentation ...

PowerShell v2 +, 45 42 octets

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

Prend l'entrée $args[0], l'envoie à travers -replacepour supprimer tous les caractères non voyelle, prend le résultat .length, et%2 vérifie s'il est impair / pair.

Exemples

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 octets

2|+/@e.&'aeiouAEOIU'

Approche directe

Explication

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 octets

1&Uè"%v

Testez-le en ligne! Sorties 1 pour impair, 0 pour pair.

Comment ça marche

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

Octave, 34 octets

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

Ceci est 6 octets plus court que l'approche traditionnelle utilisant ismember , @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)et deux octets plus courte que l'approche regex: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Testez-le ici .

PHP, 41 octets

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

Cela donne -1 pour true et 0 pour falsey.

Mathematica, 44 octets

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

Donne True pour une chaîne impaire et False pour une chaîne paire.

q, 29 octets

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

C # 64 62 56 50 octets

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

• Nous utilisons déjà linq, donc Contains enregistre 2 octets sur IndexOf
• L'utilisation de la surcharge de méthode de Count économise 6 octets
• Merci à @Milk d'avoir suggéré une méthode soignée et d'avoir économisé 6 octets supplémentaires

Une fonction anonyme qui prend une chaîne et compte les lettres impaires renvoie ensuite true s'il y en a un nombre impair ou false s'il n'y en a pas.

Cette nouvelle solution divise la chaîne sur l'un des caractères du tableau de caractères donné. La mécanique de cette inversion du sens du %2résultat; 0 est maintenant impair et 1 même d'où le 1>.

Essayez-le en ligne ici!

Rétine , 19 octets

Mi`[aeiou]
[13579]$

Essayez-le en ligne!(La première ligne active une suite de tests séparés par un saut de ligne.)

La première ligne compte les voyelles dans l'entrée. La deuxième ligne vérifie que le résultat est impair.

MATL , 8 , 7 octets

13Y2mso

Essayez-le en ligne!

Explication:

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 octets

l1~Vm/s 2%

Essayez-le ici!