Вызов

Учитывая одно слово в качестве входных данных, определить, является ли слово нечетным или четным.

Нечетные и четные слова

Предположим, общие правила:

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

правила

Весь ввод будет одним словом, которое будет содержать только алфавитные символы.

Если слово нечетное, выведите истинное значение. Если слово четное, выведите значение фальси.

выигрыш

Самый короткий код в байтах побеждает.

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.
Поместите слово в вопрос А1.

Выход: 0, если четный, 1, если нечетный.

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

Сохранено 1 байт благодаря Арно:

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 байта к длине программы.

Ungolfed

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

объяснение

Сначала сохраните высоту стека для будущих целей

([]<...>

Тогда пока стек не пустой (предполагается, что ни один из символов не равен нулю)

{...}

Вычтите девяносто семь (и сохраните 3 для последующих оптимизаций)

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

Если это не ноль (то есть не а)

{...}

Вычтите 4 (и сохраните 4 для дальнейшей оптимизации)

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

Если это не ноль (т.е. не е)

{...}

Вычтите 4 (и сохраните 4 для дальнейшей оптимизации)

({}[({})])

Если это не ноль (то есть не я)

{...}

Вычтите 6 (и сохраните 6 для дальнейшей оптимизации)

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

Если это не ноль (т.е. не о)

{...}

Вычтите 6 (сохраните 6, потому что программа ожидает один позже)

({}[({})])

Если это не ноль (то есть не вы)

{...}

Переместите остаток в другой стек и положите ноль в активный стек, чтобы избежать всех if

({}<>)(<>)

После того, как все ifs были удалены, удалите ноль и шесть

{}{}

Как только все символы были обработаны, вычтите высоту смещения из первоначально сохраненной высоты.

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

Мод на двоих

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

C, 42 байта

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

Это работает с GCC 4.x на процессоре x86-64. Результаты могут отличаться в зависимости от настроек.

Проверьте это на repl.it .

За счет дополнительных 5 байтов можно избежать неопределенного поведения, поэтому код должен работать до тех пор, пока int имеет ширину не менее 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 результата сверху и результата рекурсивного вызова.

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

-1 спасибо Нейлу

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

Принты oдля нечетных и ничего для четных

Python, 41 байт

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

Python, 42 байта

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

Не так много, чтобы объяснить здесь. Безымянная функция, которая возвращает 0 или 1.

Brain-Flak , 524, 446 , 422 байта

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

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

Ungolfed, более читаемая версия:

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

Желе , 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 за один байт!

Python 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

*/

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

Ungolfed:

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

тусклый , 14 байтов (не конкурирующий)

ar[aeiou]}et}T

Я думал, что это будет весело, простая задача для нового языка.

объяснение

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

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

Используйте поле ввода для ввода слова.

Я скоро добавлю документацию ...

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 для фальси.

Mathematica, 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, поэтому Contains сохраняет 2 байта над IndexOf
• Использование метода перегрузки Count сохраняет 6 байтов
• Спасибо @Milk за предложенный аккуратный метод и сохранение еще 6 байтов

Анонимная функция, которая берет строку и считает нечетные буквы, затем возвращает true, если их нечетное число, или false, если их нет.

Это новое решение разбивает строку на любой из символов в данном массиве символов. Механика этого переворачивает значение %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%

Попробуй это здесь!