Herausforderung

Bestimmen Sie anhand eines einzelnen Wortes als Eingabe, ob das Wort gerade oder ungerade ist.

Gerade und ungerade Wörter

Nimm die allgemeinen Regeln an:

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

Im Alphabet sind die ungeraden Buchstaben:

aeiou

Und die geraden Buchstaben sind:

bcdfghjklmnpqrstvwxyz

Gleiches gilt für Großbuchstaben ( AEIOUungerade und BCDFGHJKLMNPQRSTVWXYZgerade).

Dann 'addieren' Sie jeden Buchstaben des Wortes. Zum Beispiel ist das Wort catsäquivalent zu:

even + odd + even + even

Welches vereinfacht zu:

odd + even

Was weiter vereinfacht:

odd

Das Wort catsist also seltsam.

Beispiele

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Regeln

Alle Eingaben sind ein einzelnes Wort, das nur alphabetische Zeichen enthält.

Wenn das Wort ungerade ist, geben Sie einen Wahrheitswert aus. Wenn das Wort gerade ist, geben Sie einen falschen Wert aus.

Gewinnen

Der kürzeste Code in Bytes gewinnt.

05AB1E , 6 Bytes

lžMÃgÉ

Erläuterung

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

Probieren Sie es online!

EXCEL, 79 Bytes:

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

Eingabe:
Diese Funktion kann an einer beliebigen Stelle platziert werden, AUSSER A1. Geben
Sie Ihr Wort in A1 ein.

Ausgabe: 0 wenn gerade, 1 wenn ungerade.

JavaScript (ES6), 34 41 33 32 Byte

Dank Arnauld 1 Byte gespart:

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

• Ungerades Wort: kehrt zurück 1
• Gerade Worte: kehrt zurück 0

33 Bytes dank Arnauld:

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

• Ungerades Wort: kehrt zurück 1
• Gerade Worte: kehrt zurück 0

Ein anderer Weg ohne bitweise Operatoren:

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

41 Bytes:

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

• Ungerades Wort: kehrt zurück 1
• Gerade Wörter mit ungeraden Buchstaben: kehrt zurück 0
• Gerade Wörter ohne ungerade Buchstaben: kehrt zurück null

42 zurückzugebende Bytes 0anstelle von null:

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

34 Bytes, Brüche bei Wörtern ohne ungerade Buchstaben:

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

2 Bytes gespart dank Shaun H.

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

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

Probieren Sie es online!

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

Dies erfordert, dass das -cFlag im ASCII-Modus ausgeführt wird und der Länge des Programms 3 zusätzliche Bytes hinzugefügt werden.

Ungolfed

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

Erläuterung

Speichern Sie zuerst die Stapelhöhe für zukünftige Zwecke

([]<...>

Dann, während der Stapel nicht leer ist (setzt voraus, dass keines der Zeichen Null ist)

{...}

Subtrahiere siebenundneunzig (und speichere drei für spätere Optimierungen)

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

Wenn es nicht Null ist (dh nicht a)

{...}

Subtrahiere 4 (und speichere 4 für spätere Optimierungen)

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

Wenn es nicht Null ist (dh nicht e)

{...}

Subtrahiere 4 (und speichere 4 für spätere Optimierungen)

({}[({})])

Wenn es nicht Null ist (dh nicht i)

{...}

Subtrahiere 6 (und speichere 6 für spätere Optimierungen)

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

Wenn es nicht Null ist (dh nicht o)

{...}

Subtrahiere 6 (speichere 6, da das Programm eine spätere erwartet)

({}[({})])

Wenn es nicht Null ist (dh nicht u)

{...}

Verschieben Sie den Rest auf den anderen Stapel und setzen Sie eine Null auf den aktiven Stapel, um alle ifs zu umgehen

({}<>)(<>)

Sobald alle Wenns entkommen sind, entfernen Sie die Null und die Sechs

{}{}

Nachdem alle Zeichen verarbeitet wurden, subtrahieren Sie die Höhe des Offsets von der ursprünglich gespeicherten Höhe.

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

Mod um zwei

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

C, 42 Bytes

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

Dies funktioniert mit GCC 4.x auf einer x86-64-CPU. Die Ergebnisse können je nach Einrichtung variieren.

Testen Sie es auf repl.it .

Auf Kosten von 5 weiteren Bytes kann undefiniertes Verhalten vermieden werden, sodass der Code funktionieren sollte, solange int s mindestens 32 Bit breit sind.

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

Wie es funktioniert

Modulo 32 , die Zeichencodes aller ungeraden Buchstaben sind 1 , 5 , 9 , 15 und 21 . 2130466 ist die 32-Bit-Ganzzahl, die an diesen Stellen gesetzte und an allen anderen Stellen nicht gesetzte Bits hat.

Wenn f für eine Zeichenfolge aufgerufen wird, wird zuerst überprüft, ob das erste Zeichen der Zeichenfolge ein Nullbyte (Zeichenfolgenabschlusszeichen) ist. Wenn dies der Fall ist, *sergibt sich 0 und f gibt 0 zurück . Ansonsten *sergibt sich der Zeichencode eines Buchstabens und das richtige Argument des logischen AND ( &&) wird ausgeführt.

Für >>generiert GCC eine Schichtanweisung. Auf einer x86-64-CPU ignoriert der entsprechende Befehl für eine 32-Bit-Ganzzahl alle bis auf die unteren 5 Bits des rechten Arguments, wodurch das Reduzieren von *sModulo 32 vermieden wird . Die Rechtsverschiebung und das folgende bitweise UND mit 1 extrahieren das Bit von 2130466 , das dem Buchstaben entspricht. Dies ist genau dann 1, wenn der Buchstabe ungerade ist.

Anschließend inkrementieren wir den Zeiger s (wobei der erste Buchstabe effektiv verworfen wird), rufen f rekursiv für die enthauptete Zeichenfolge auf und nehmen das bitweise XOR des Ergebnisses von oben und das Ergebnis des rekursiven Aufrufs.

sed 44 (42 + 1 für -n) 43

-1 danke an Neil

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

Drucke ofür ungerade und nichts für gerade

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

Hier gibt es nicht viel zu erklären. Eine unbenannte Funktion, die 0 oder 1 zurückgibt.

Brain-Flak , 524, 446 , 422 Bytes

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

Probieren Sie es online!

Ungolfed, besser lesbare Version:

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

Jelly , 13 12 11 Bytes

-1 Byte dank @Luis Mendo ( Ḃzum Ersetzen verwenden %2)
-1 Byte dank @Dennis (String-Komprimierung verwenden)

Œlf“¡ẎṢɱ»LḂ

Alle Testfälle sind bei TryItOnline

Wie?

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

Nicht konkurrierend, 5 Bytes (da ich gerade die Funktion hinzugefügt habe Øc)

fØcLḂ

Testfälle auch bei TryItOnline

Wie oben, Øcliefert jedoch die Vokale des lateinischen Alphabets.'AEIOUaeiou'

Haskell, 38 37 Bytes

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

Danke an Angs für ein Byte!

Python 3, 53 Bytes

Dies kann wahrscheinlich weiter golfen werden:

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

Ich habe ein paar andere Java-Antworten gesehen, die ich sonst nicht geteilt hätte. Danke an Phaeze für das Speichern eines Bytes.

C 52 Bytes

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

das Wesentliche und das Ergebnis:

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

Probieren Sie es online!

Erläuterung:

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

Vim, 32, 31 , 29 Tastenanschläge

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

Da der V-Interpreter abwärtskompatibel ist, können Sie ihn online ausprobieren! genau hier.

Ein Drei Bytes gespart dank 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;
  }

Dummkopf , 14 Bytes (nicht konkurrierend)

ar[aeiou]}et}T

Ich dachte, dies wäre eine lustige und einfache Herausforderung für eine neue Sprache.

Erläuterung

• a - Schieben Sie ein neues Array in die Matrix
• r[aeiou]} - Zählen Sie die Vorkommen aller Werte, die mit dem regulären Ausdruck "[aeiou]" im ersten Array übereinstimmen (da das erste Array die Eingabe enthält), ignorieren Sie die Groß- und Kleinschreibung und verschieben Sie diesen Wert an das Ende des letzten Arrays.
• e - Wenn die letzte Zahl im letzten Array gerade ist (die wir auf die Anzahl der Vorkommen festgelegt haben), führen Sie die nächsten Operationen bis zu einer schließenden Klammer ("}") aus.
• t - Beenden Sie die Ausführung, löschen Sie die Matrix und setzen Sie den ersten Wert auf false
• }- Ende des eCodeblocks
• T - Beenden Sie die Ausführung, löschen Sie die Matrix und setzen Sie den ersten Wert auf true

Probieren Sie es online!

Verwenden Sie das Eingabefeld, um das Wort einzugeben.

Ich werde bald Dokumentation hinzufügen ...

PowerShell v2 +, 45 bis 42 Byte

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

Nimmt Eingaben entgegen $args[0], sendet sie durch -replace, um alle Nicht-Vokal-Zeichen zu entfernen, nimmt das Ergebnis auf .lengthund %2prüft, ob es ungerade / gerade ist.

Beispiele

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'

Unkomplizierter Ansatz

Erläuterung

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

Online testen! Ausgänge 1 für ungerade, 0 für gerade.

Wie es funktioniert

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

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

Dies ist 6 Byte kürzer als der traditionelle Ansatz ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)und zwei Bytes kürzer als der regex Ansatz: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Teste es hier .

PHP, 41 Bytes

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

Dies gibt -1 für wahr und 0 für falsch aus.

Mathematica, 44 Bytes

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

Gibt True für eine ungerade Zeichenfolge und False für eine gerade Zeichenfolge.

q, 29 Bytes

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

C # 64 62 56 50 Bytes

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

• Wir benutzen bereits linq, also spart Contains 2 Bytes über IndexOf
• Durch die Verwendung der Methode Überladung von Count werden 6 Bytes eingespart
• Vielen Dank an @Milk, dass er eine saubere Methode vorgeschlagen und weitere 6 Bytes eingespart hat

Eine anonyme Funktion, die eine Zeichenfolge verwendet und die ungeraden Buchstaben zählt, gibt true zurück, wenn eine ungerade Anzahl vorhanden ist, oder false, wenn dies nicht der Fall ist.

Diese neue Lösung teilt die Zeichenfolge in alle Zeichen des angegebenen Zeichen-Arrays auf. Die Mechanik dieser Umkehrung der Bedeutung des %2Ergebnisses; 0 ist jetzt ungerade und 1 gerade daher die 1>.

Probieren Sie es hier online aus!

Netzhaut , 19 Bytes

Mi`[aeiou]
[13579]$

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Die erste Zeile zählt die Vokale in der Eingabe. Die zweite Zeile prüft, ob das Ergebnis ungerade ist.

MATL , 8 , 7 Bytes

13Y2mso

Probieren Sie es online!

Erläuterung:

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%

Probieren Sie es hier aus!