Виклик

Давши одне слово як вхідне, визначте, чи слово непарне чи парне.

Непарні і парні слова

Припустимо загальні правила:

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

В алфавіті непарні літери:

aeiou

І парні літери:

bcdfghjklmnpqrstvwxyz

Те саме стосується великих літер ( AEIOUнепарні і BCDFGHJKLMNPQRSTVWXYZпарні).

Потім ви "додаєте" кожну букву в слово разом. Наприклад, слово catsеквівалентно:

even + odd + even + even

Що спрощує:

odd + even

Що додатково спрощує:

odd

Тож слово catsдивне.

Приклади

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Правила

Увесь вхід буде одним словом, яке буде містити лише алфавітні символи.

Якщо слово непарне, виведіть значення truthy. Якщо слово є парним, виведіть значення фальси.

Перемога

Виграє найкоротший код у байтах.

05AB1E , 6 байт

lžMÃgÉ

Пояснення

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

Спробуйте в Інтернеті!

EXCEL, 79 байт:

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

Вхід:
Цю функцію можна розмістити в будь-якому місці. ВИНАХОДІ А1
Поставте своє слово під питання в A1.

Вихід: 0, якщо парне, 1, якщо непарне.

JavaScript (ES6), 34 41 33 32 байт

Збережено 1 байт завдяки Arnauld:

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

• Незвичайне слово: повертається 1
• Навіть слова: повертається 0

33 байти завдяки Арнольду:

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

• Незвичайне слово: повертається 1
• Навіть слова: повертається 0

Ще один спосіб без розрядних операторів:

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

41 байт:

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

• Незвичайне слово: повертається 1
• Чітні слова з непарними літерами: повертає 0
• Навіть слова без непарних літер: повертає null

42 байти для повернення 0замість null:

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

34 байти, перерви на слова без непарних літер:

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

Збережено 2 байти завдяки Shaun H

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

Brain-Flak 206 196 192 178 + 3 = 181 байт

Спробуйте в Інтернеті!

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

Для цього потрібно, щоб -cпрапор запускався в режимі ASCII, додаючи додаткові 3 байти до довжини програми.

Безумовно

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

Пояснення

Спочатку зберігайте висоту стопки для майбутніх цілей

([]<...>

Тоді поки стек не порожній (передбачається, що жоден із символів не дорівнює нулю)

{...}

Віднімаємо дев'яносто сім (і зберігаємо 3 для наступних оптимізацій)

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

Якщо він не дорівнює нулю (тобто не a)

{...}

Віднімаємо 4 (і зберігаємо 4 для подальшої оптимізації)

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

Якщо він не дорівнює нулю (тобто не e)

{...}

Віднімаємо 4 (і зберігаємо 4 для подальшої оптимізації)

({}[({})])

Якщо він не дорівнює нулю (тобто не я)

{...}

Віднімаємо 6 (і зберігаємо 6 для подальшої оптимізації)

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

Якщо він не дорівнює нулю (тобто не о)

{...}

Віднімаємо 6 (зберігаємо 6, оскільки програма очікує пізніше)

({}[({})])

Якщо він не дорівнює нулю (тобто не u)

{...}

Перемістіть решту в інший стек і поставте нуль на активний стек, щоб уникнути всіх ifs

({}<>)(<>)

Після того, як всі ifs були врятовані, видаліть нуль і шість

{}{}

Після обробки всіх символів віднімаємо висоту зміщення від спочатку збереженої висоти.

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

Мод на два

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

C, 42 байти

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

Це працює з GCC 4.x на процесорі x86-64. Результати можуть відрізнятися в різних налаштуваннях.

Перевірте це на repl.it .

Ціною ще 5 байт можна не уникнути невизначеної поведінки, тому код повинен працювати до тих пір, поки int s не менше 32 біт шириною.

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

Як це працює

За модулем 32 , символьні коди всіх непарних літер - 1 , 5 , 9 , 15 та 21 . 2130466 - це 32-розрядне ціле число, яке встановлює біти в цих положеннях і відміняє біти на всіх інших.

Коли в рядку викликається f , він спочатку перевіряє, чи є перший символ рядка нульовим байтом (термінатор рядка). Якщо це так, то *sвиходить 0, а f повертає 0 . В іншому випадку *sвиведіть код символу букви і &&виконаний правильний аргумент логічного AND ( ).

Бо >>GCC формує інструкцію про зміну. У процесорі x86-64 відповідна інструкція для 32-бітного цілого числа ігнорує всі, крім нижчих 5 біт правильного аргументу, що дозволяє уникнути зменшення *sмодуля 32 . Зміна вправо і наступний побіжно І з 1 витягує біт 2130466, що відповідає букві, що буде 1, якщо і лише якщо літера непарна.

Після цього ми збільшуємо вказівник s (ефективно відкидаючи першу букву), викликаємо f рекурсивно на обезголовлену рядок і приймаємо бітовий XOR результату зверху та результату рекурсивного виклику.

sed 44 (42 + 1 для -n) 43

-1 завдяки Нілу

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

Принти oдля непарних і нічого не парних

Пітон, 41 байт

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

Пітон, 42 байти

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

Тут не дуже багато пояснювати. Безіменна функція, яка повертає 0 або 1.

Брейн-Флак , 524, 446 , 422 байти

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

Спробуйте в Інтернеті!

Нечитані, більш читані версії:

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

Желе , 13 12 11 байт

-1 байт завдяки @Luis Mendo (використовуйте Ḃдля заміни %2)
-1 байт завдяки @Dennis (використовуйте стиснення рядка)

Œlf“¡ẎṢɱ»LḂ

Усі тестові приклади - у TryItOnline

Як?

Œ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 байт (оскільки я щойно додав функцію Øc)

fØcLḂ

Тестові приклади також у TryItOnline

Те саме, що вище, але Øcдає голосні латинські алфавіти,'AEIOUaeiou'

Haskell, 38 37 байт

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

Дякуємо Angs за один байт!

Пітон 3, 53 байти

Це, ймовірно, може бути додатково гольф:

lambda n:[x in 'aeiou' for x in n.lower()].count(1)&1

Ява, 73

boolean f(String s){return s.replaceAll("(?i)[^aeiou]","").length()%2>0;}

побачив пару інших відповідей Java, інакше не поділився б. Завдяки Phaeze за збереження байта.

C 52 байти

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

головне та результат:

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

*/

Піт, 14 байт

%l@"aeiou"rQ02

Спробуйте в Інтернеті!

Пояснення:

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

Рубін, 30 байт

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

Vim, 32, 31 , 29 натискань клавіш

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

Оскільки перекладач V назад сумісний, ви можете спробувати його в Інтернеті! саме тут.

Один три байти збережено завдяки m-chrzan!

Ява 7, 88

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

Безголовки:

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

dimwit , 14 байт (неконкурентоспроможний)

ar[aeiou]}et}T

Я подумав, що це буде цікавим, простим завданням для початку з нової мови.

Пояснення

• a - підштовхнути новий масив до матриці
• r[aeiou]} - підраховують події всіх значень, що відповідають регулярному вираженню "[aeiou]" у першому масиві (оскільки перший масив містить вхідні дані), ігноруючи регістр, і натисніть це значення до кінця останнього масиву.
• e - якщо останнє число в останньому масиві парне (яке ми встановлюємо на кількість входів), виконайте наступні операції до закриття дужки ("}")
• t - зупинити виконання, очистити матрицю та встановити перше значення як хибне
• }- кінець eблоку коду
• T - зупинити виконання, очистити матрицю та встановити перше значення як істинне

Спробуйте в Інтернеті!

Використовуйте поле Введення для введення слова.

Я скоро додам документацію ...

PowerShell v2 +, 45 42 байти

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

Бере введення $args[0], пересилає його, -replaceщоб видалити всі неголосні символи, приймає отримані результати .lengthі %2перевіряє, чи це непарно / парно.

Приклади

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 байт

2|+/@e.&'aeiouAEOIU'

Прямий підхід

Пояснення

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 байт

1&Uè"%v

Перевірте це в Інтернеті! Виходи 1 для непарних, 0 для парних.

Як це працює

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

Октава, 34 байти

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

Це 6 байт коротше , ніж при традиційному підході з використанням ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)і два байта коротше , ніж регулярний вираз підходу: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Тестуйте це тут .

PHP, 41 байт

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

Це виходить -1 для триути і 0 для фальси.

Математика, 44 байти

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

Дає значення True для непарного рядка, а False - для парного.

q, 29 байт

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

C # 64 62 56 50 байт

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

• Ми вже використовуємо linq, тому вміст зберігає 2 байти над IndexOf
• Використовуючи метод перевантаження Count, економиться 6 байт
• Завдяки @Milk запропонував акуратний метод та заощадив ще 6 байт

Анонімна функція, яка бере рядок і підраховує непарні літери, потім повертає істинне, якщо їх непарне число або помилкове, якщо його немає.

Це нове рішення розділяє рядок на будь-який із символів даного масиву char. Механіка цього перевертає значення %2результату; 0 зараз є непарним, а 1 парним1> .

Спробуйте його онлайн тут!

Сітківка , 19 байт

Mi`[aeiou]
[13579]$

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Перший рядок підраховує голосні звуки на вході. Другий рядок перевіряє, що результат непарний.

MATL , 8 , 7 байт

13Y2mso

Спробуйте в Інтернеті!

Пояснення:

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

Пайк, 10 байт

l1~Vm/s 2%

Спробуйте тут!