Wyzwanie

Biorąc pod uwagę jedno słowo jako dane wejściowe, określ, czy słowo jest nieparzyste, czy parzyste.

Dziwne i parzyste słowa

Załóż ogólne zasady:

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

W alfabecie litery nieparzyste to:

aeiou

A litery parzyste to:

bcdfghjklmnpqrstvwxyz

To samo dotyczy wielkich liter ( AEIOUsą nieparzyste i BCDFGHJKLMNPQRSTVWXYZsą parzyste).

Następnie „dodajesz” każdą z liter w słowie razem. Na przykład słowo catsto jest równoważne z:

even + odd + even + even

Co upraszcza:

odd + even

Co dodatkowo upraszcza:

odd

Więc słowo catsjest dziwne.

Przykłady

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Zasady

Wszystkie wprowadzone dane będą pojedynczym słowem, które będzie zawierać tylko znaki alfabetyczne.

Jeśli słowo jest nieparzyste, wypisz prawdziwą wartość. Jeśli słowo jest parzyste, wypisz wartość falsey.

Zwycięski

Najkrótszy kod w bajtach wygrywa.

05AB1E , 6 bajtów

lžMÃgÉ

Wyjaśnienie

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

Wypróbuj online!

EXCEL, 79 bajtów:

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

input:
tę funkcję można umieścić w dowolnym miejscu Z WYJĄTKIEM A1
Zadaj swoje pytanie w A1.

Wyjście: 0 jeśli parzyste, 1 jeśli nieparzyste.

JavaScript (ES6), 34 41 33 32 bajty

Zaoszczędzono 1 bajt dzięki Arnauldowi:

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

• Dziwne słowo: zwraca 1
• Nawet słowa: zwraca 0

33 bajty dzięki Arnauldowi:

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

• Dziwne słowo: zwraca 1
• Nawet słowa: zwraca 0

Innym sposobem bez operatorów bitowych:

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

41 bajtów:

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

• Dziwne słowo: zwraca 1
• Parzyste słowa z nieparzystymi literami: zwraca 0
• Parzyste słowa bez nieparzystych liter: zwraca null

42 bajty do zwrotu 0zamiast null:

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

34 bajty, łamanie słów bez nieparzystych liter:

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

Zaoszczędzono 2 bajty dzięki Shaunowi H.

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

Brain-Flak 206 196 192 178 + 3 = 181 bajtów

Wypróbuj online!

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

Wymaga to działania -cflagi w trybie ASCII, dodając dodatkowe 3 bajty do długości programu.

Nie golfił

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

Wyjaśnienie

Najpierw zapisz wysokość stosu do przyszłych celów

([]<...>

Następnie, gdy stos nie jest pusty (zakłada, że ​​żaden ze znaków nie jest równy zero)

{...}

Odejmij dziewięćdziesiąt siedem (i zachowaj 3 do późniejszych optymalizacji)

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

Jeśli nie jest zero (tj. Nie jest)

{...}

Odejmij 4 (i zapisz 4 do późniejszych optymalizacji)

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

Jeśli nie jest zero (tzn. Nie e)

{...}

Odejmij 4 (i zapisz 4 do późniejszych optymalizacji)

({}[({})])

Jeśli nie jest zero (tj. Nie i)

{...}

Odejmij 6 (i zapisz 6 do późniejszych optymalizacji)

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

Jeśli nie jest zero (tzn. Nie o)

{...}

Odejmij 6 (zapisz 6, ponieważ program oczekuje jednego później)

({}[({})])

Jeśli nie jest zero (tj. Nie u)

{...}

Przenieś resztę do drugiego stosu i ustaw zero na aktywnym stosie, aby uciec od wszystkich ifs

({}<>)(<>)

Po ucieczce wszystkich ifów usuń zero i sześć

{}{}

Po przetworzeniu wszystkich znaków odejmij wysokość przesunięcia od pierwotnie zapisanej wysokości.

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

Mod przez dwa

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

C, 42 bajty

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

Działa to z GCC 4.x na procesorze x86-64. Wyniki mogą się różnić w zależności od konfiguracji.

Przetestować go na repl.it .

Kosztem kolejnych 5 bajtów można uniknąć niezdefiniowanego zachowania, więc kod powinien działać, o ile int ma szerokość co najmniej 32 bity.

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

Jak to działa

Modulo 32 , kody wszystkich nieparzystych liter to 1 , 5 , 9 , 15 i 21 . 2130466 jest 32-bitową liczbą całkowitą, która ustawiła bity w tych pozycjach i nie ustawiła bitów we wszystkich innych.

Kiedy f jest wywoływany na łańcuch, najpierw sprawdza, czy pierwszy znak łańcucha jest bajtem zerowym (terminator łańcucha). Jeśli tak, *szwraca 0, a f zwraca 0 . W przeciwnym razie *spodaj kod literowy i &&zostanie wykonany odpowiedni argument logicznego AND ( ).

Ponieważ >>GCC generuje instrukcję zmiany. Na x86-64 CPU odpowiednie wskazówki dla 32-bitowej liczby całkowitej ignoruje wszystkie ale niższe 5 bitów w prawym argumencie, który zapobiega to zmniejszeniu *smodulo 32 . Prawe przesunięcie i następujące po nim bitowe AND z 1 wyodrębnia bit 2130466, który odpowiada literze, która będzie 1, jeśli tylko i tylko jeśli litera jest nieparzysta.

Następnie zwiększamy wskaźnik s (skutecznie odrzucając pierwszą literę), wywołujemy rekurencyjnie f na ściętym łańcuchu i bierzemy bitową XOR wyniku z góry oraz wynik wywołania rekurencyjnego.

sed 44 (42 + 1 dla -n) 43

-1 dzięki Neilowi

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

Drukuje ona nieparzyste i nic na parzyste

Python, 41 bajtów

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

Python, 42 bajty

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

Nie wiele do wyjaśnienia tutaj. Funkcja bez nazwy, która zwraca 0 lub 1.

Brain-Flak , 524, 446 , 422 bajtów

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

Wypróbuj online!

Wersja bez golfa, bardziej czytelna:

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

Galaretka , 13 12 11 bajtów

-1 bajt dzięki @Luis Mendo (użyj, Ḃaby zastąpić %2)
-1 bajt dzięki @Dennis (użyj kompresji ciągu)

Œlf“¡ẎṢɱ»LḂ

Wszystkie przypadki testowe znajdują się w TryItOnline

W jaki sposób?

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

Niekonkurencyjne, 5 bajtów (ponieważ właśnie dodałem funkcję Øc)

fØcLḂ

Przypadki testowe również w TryItOnline

Tak jak powyżej, ale Øcdaje samogłoski alfabetu łacińskiego,'AEIOUaeiou'

Haskell, 38 37 bajtów

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

Dzięki Angs za jeden bajt!

Python 3, 53 bajtów

Można to prawdopodobnie pograć w golfa dalej:

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

widziałem kilka innych odpowiedzi w języku Java, w przeciwnym razie nie podzieliłbym się nimi. Dzięki Phaeze za uratowanie bajtu.

C 52 bajty

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

główny i wynik:

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 bajtów

%l@"aeiou"rQ02

Wypróbuj online!

Wyjaśnienie:

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

Rubinowy, 30 bajtów

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

Vim, 32, 31 , 29 klawiszy

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

Ponieważ interpreter V jest wstecznie kompatybilny, możesz wypróbować go online! tutaj.

Jeden trzy bajty zapisane dzięki 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;}

Nie golfowany:

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

dimwit , 14 bajtów (niekonkurencyjny)

ar[aeiou]}et}T

Pomyślałem, że będzie to zabawne, proste wyzwanie na początek dla nowego języka.

Wyjaśnienie

• a - wypchnij nową macierz do matrycy
• r[aeiou]} - zlicz wystąpienie wszystkich wartości pasujących do wyrażenia regularnego „[aeiou]” w pierwszej tablicy (ponieważ pierwsza tablica zawiera dane wejściowe), ignorując wielkość liter i wypchnij tę wartość na koniec ostatniej tablicy.
• e - jeśli ostatnia liczba w ostatniej tablicy jest parzysta (którą ustawiliśmy na liczbę wystąpień), wykonaj następne operacje aż do nawiasu zamykającego („}”)
• t - zatrzymać wykonywanie, wyczyścić macierz i ustawić pierwszą wartość na false
• }- koniec ebloku kodu
• T - zatrzymać wykonywanie, wyczyścić macierz i ustawić pierwszą wartość na true

Wypróbuj online!

Użyj pola wprowadzania, aby wprowadzić słowo.

Wkrótce dodam dokumentację ...

PowerShell v2 +, 45 42 bajtów

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

Pobiera dane wejściowe $args[0], wysyła je, -replaceaby usunąć wszystkie znaki inne niż samogłoska, bierze wynikowe .lengthi %2sprawdza, czy jest nieparzyste / parzyste.

Przykłady

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 bajtów

2|+/@e.&'aeiouAEOIU'

Proste podejście

Wyjaśnienie

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 bajtów

1&Uè"%v

Przetestuj online! Wyjścia 1 dla nieparzystych, 0 dla parzystych.

Jak to działa

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

Oktawa, 34 bajty

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

Jest to 6 bajtów krócej niż przy użyciu tradycyjnego podejścia ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)oraz dwa bajty krótszy niż podejście regex: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Sprawdź to tutaj .

PHP, 41 bajtów

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

To daje -1 dla prawdy i 0 dla falsey.

Mathematica, 44 bajty

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

Daje wartość True dla nieparzystego ciągu i False dla parzystej.

q, 29 bajtów

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

C # 64 62 56 50 bajtów

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

• Już używamy linq, więc Contains zapisuje 2 bajty nad IndexOf
• Korzystanie z metody przeciążenie Count oszczędza 6 bajtów
• Dzięki @Milk za zaproponowanie zgrabnej metody i oszczędność 6 dodatkowych bajtów

Anonimowa funkcja, która pobiera ciąg znaków i zlicza nieparzyste litery, a następnie zwraca true, jeśli jest ich nieparzysta liczba, lub false, jeśli nie ma.

To nowe rozwiązanie dzieli ciąg na dowolny ze znaków w podanej tablicy znaków. Mechanika tego odwraca znaczenie %2wyniku; 0 jest teraz nieparzyste, a 1 nawet stąd 1>.

Wypróbuj online tutaj!

Retina , 19 bajtów

Mi`[aeiou]
[13579]$

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Pierwszy wiersz zlicza samogłoski na wejściu. Druga linia sprawdza, czy wynik jest nieparzysty.

MATL , 8 , 7 bajtów

13Y2mso

Wypróbuj online!

Wyjaśnienie:

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 bajtów

l1~Vm/s 2%

Wypróbuj tutaj!