Sfida

Data una singola parola come input, determinare se la parola è pari o dispari.

Parole pari e dispari

Assumi le regole generali:

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

Nell'alfabeto, le lettere dispari sono:

aeiou

E le lettere pari sono:

bcdfghjklmnpqrstvwxyz

Lo stesso vale per le lettere maiuscole ( AEIOUsono dispari e BCDFGHJKLMNPQRSTVWXYZpari).

Quindi 'aggiungi' ciascuna delle lettere nella parola insieme. Ad esempio, la parola catsequivale a:

even + odd + even + even

Che semplifica a:

odd + even

Che semplifica ulteriormente a:

odd

Quindi la parola catsè strana.

Esempi

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Regole

Tutto l'input sarà una singola parola che conterrà solo caratteri alfabetici.

Se la parola è dispari, genera un valore veritiero. Se la parola è pari, genera un valore false.

vincente

Vince il codice più breve in byte.

05AB1E , 6 byte

lžMÃgÉ

Spiegazione

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

Provalo online!

EXCEL, 79 byte:

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

input:
questa funzione può essere posizionata ovunque TRANNE A1
Metti la tua parola in questione in A1.

Uscita: 0 se pari, 1 se dispari.

JavaScript (ES6), 34 41 33 32 byte

Salvato 1 byte grazie ad Arnauld:

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

• Strana parola: ritorna 1
• Parole pari: ritorna 0

33 byte grazie ad Arnauld:

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

• Strana parola: ritorna 1
• Parole pari: ritorna 0

Un altro modo senza operatori bit a bit:

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

41 byte:

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

• Strana parola: ritorna 1
• Parole pari con lettere dispari: ritorna 0
• Parole pari senza lettere dispari: ritorna null

42 byte da restituire 0anziché null:

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

34 byte, interruzioni di parole senza lettere dispari:

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

Salvato 2 byte grazie a Shaun H

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

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

Provalo online!

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

Ciò richiede che il -cflag venga eseguito in modalità ASCII aggiungendo altri 3 byte alla lunghezza del programma.

Ungolfed

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

Spiegazione

Innanzitutto conservare l'altezza della pila per scopi futuri

([]<...>

Quindi, mentre lo stack non è vuoto (presuppone che nessuno dei caratteri sia zero)

{...}

Sottrai novantasette (e archivia 3 per ottimizzazioni successive)

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

Se non è zero (cioè non a)

{...}

Sottrai 4 (e archivia 4 per ottimizzazioni successive)

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

Se non è zero (cioè non e)

{...}

Sottrai 4 (e archivia 4 per ottimizzazioni successive)

({}[({})])

Se non è zero (cioè non i)

{...}

Sottrai 6 (e archivia 6 per ottimizzazioni successive)

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

Se non è zero (cioè non o)

{...}

Sottrai 6 (store 6 perché il programma si aspetta uno dopo)

({}[({})])

Se non è zero (cioè non u)

{...}

Sposta il resto sull'altro stack e metti uno zero sullo stack attivo per sfuggire a tutti gli if

({}<>)(<>)

Una volta che tutti gli if sono stati evitati, rimuovere lo zero e il sei

{}{}

Una volta elaborati tutti i caratteri, sottrarre l'altezza dell'offset dall'altezza memorizzata originariamente.

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

Mod per due

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

C, 42 byte

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

Funziona con GCC 4.x su una CPU x86-64. I risultati possono variare con impostazioni diverse.

Testarlo su repl.it .

Al costo di altri 5 byte, è possibile evitare comportamenti indefiniti, quindi il codice dovrebbe funzionare fintanto che int s è largo almeno 32 bit.

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

Come funziona

Modulo 32 , i codici carattere di tutte le lettere dispari sono 1 , 5 , 9 , 15 e 21 . 2130466 è il numero intero a 32 bit che ha impostato i bit in queste posizioni e disinserito i bit in tutti gli altri.

Quando f viene chiamato su una stringa, verifica innanzitutto se il primo carattere della stringa è un byte null (terminatore di stringa). In tal caso, *srestituisce 0 e f restituisce 0 . Altrimenti, *srestituisci il codice carattere di una lettera e &&viene eseguito l'argomento giusto dell'AND logico ( ).

Per >>, GCC genera un'istruzione di spostamento. Su una CPU x86-64, l'istruzione corrispondente per un numero intero a 32 bit ignora tutti tranne i 5 bit inferiori dell'argomento corretto, che evita di ridurre il *smodulo 32 . Lo spostamento a destra e il seguente bit bit AND con 1 estrae il bit di 2130466 che corrisponde alla lettera, che sarà 1 se e solo se la lettera è dispari.

Successivamente, incrementiamo il puntatore s (scartando efficacemente la prima lettera), chiamiamo f in modo ricorsivo sulla stringa decapitata e prendiamo l'XOR bit a bit del risultato dall'alto e il risultato della chiamata ricorsiva.

sed 44 (42 + 1 per -n) 43

-1 grazie a Neil

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

Stampa oper pari e niente per pari

Python, 41 byte

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

Python, 42 byte

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

Non c'è molto da spiegare qui. Una funzione senza nome che restituisce 0 o 1.

Brain-Flak , 524, 446 , 422 byte

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

Provalo online!

Versione non golfata, più leggibile:

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

Gelatina , 13 12 11 byte

-1 byte grazie a @Luis Mendo (usare Ḃper sostituire %2)
-1 byte grazie a @Dennis (usare una compressione di stringhe)

Œlf“¡ẎṢɱ»LḂ

Tutti i casi di test sono su TryItOnline

Come?

Œ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 byte non concorrenti (da quando ho appena aggiunto la funzione Øc)

fØcLḂ

Casi di prova anche su TryItOnline

Come sopra, ma Øcproduce le vocali dell'alfabeto latino,'AEIOUaeiou'

Haskell, 38 37 byte

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

Grazie ad Angs per un byte!

Python 3, 53 byte

Questo può probabilmente essere ulteriormente giocato a golf:

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

ho visto un paio di altre risposte java, altrimenti non avrebbero condiviso. Grazie a Phaeze per aver salvato un byte.

C 52 byte

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

il principale e il risultato:

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 byte

%l@"aeiou"rQ02

Provalo online!

Spiegazione:

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

Rubino, 30 byte

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

Tasti Vim, 32, 31 , 29

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

Poiché l'interprete V è retrocompatibile, puoi provarlo online! giusto qui.

Uno Tre byte salvati grazie 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;}

Ungolfed:

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

dimwit , 14 byte (non concorrenti)

ar[aeiou]}et}T

Ho pensato che sarebbe stata una sfida semplice e divertente per iniziare con una nuova lingua.

Spiegazione

• a - invia un nuovo array alla matrice
• r[aeiou]} - conta le occorrenze di tutti i valori corrispondenti alla regex "[aeiou]" nel primo array (poiché il primo array contiene l'input), ignorando il caso e spingi quel valore alla fine dell'ultimo array.
• e - se l'ultimo numero nell'ultimo array è pari (che impostiamo sul numero di occorrenze), esegui le operazioni successive fino a una parentesi chiusa ("}")
• t - interrompe l'esecuzione, cancella la matrice e imposta il primo valore su falso
• }- fine del eblocco di codice
• T - interrompe l'esecuzione, cancella la matrice e imposta il primo valore su true

Provalo online!

Utilizzare il campo di input per inserire la parola.

Presto aggiungerò la documentazione ...

PowerShell v2 +, 45 42 byte

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

Accetta l'input $args[0], lo invia attraverso -replaceper rimuovere tutti i caratteri non vocali, prende il risultato .lengthe %2controlla se è dispari / pari.

Esempi

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 byte

2|+/@e.&'aeiouAEOIU'

Approccio diretto

Spiegazione

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 byte

1&Uè"%v

Provalo online! Uscite 1 per dispari, 0 per pari.

Come funziona

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

Ottava, 34 byte

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

Questo è di 6 byte più breve rispetto all'approccio tradizionale usando ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)e due byte più breve rispetto all'approccio regex: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Provalo qui .

PHP, 41 byte

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

Questo genera -1 per verità e 0 per falsità.

Mathematica, 44 byte

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

Dà True per una stringa dispari e False per una stringa pari.

q, 29 byte

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

C # 64 62 56 50 byte

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

• Stiamo già utilizzando Linq, quindi Contains salva 2 byte su IndexOf
• L'uso del metodo overload di Count consente di risparmiare 6 byte
• Grazie a @Milk per aver suggerito un metodo accurato e risparmiato altri 6 byte

Una funzione anonima che accetta una stringa e conta le lettere dispari quindi restituisce true se ne esiste un numero dispari o false in caso contrario.

Questa nuova soluzione divide la stringa su uno qualsiasi dei caratteri nell'array char specificato. La meccanica di questo capovolge il significato del %2risultato; 0 è ora dispari e 1 anche da qui il 1>.

Provalo online qui!

Retina , 19 byte

Mi`[aeiou]
[13579]$

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

La prima riga conta le vocali nell'input. La seconda riga verifica che il risultato sia dispari.

MATL , 8 , 7 byte

13Y2mso

Provalo online!

Spiegazione:

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 byte

l1~Vm/s 2%

Provalo qui!