도전

한 단어를 입력으로 받으면 단어가 홀수인지 짝수인지 확인하십시오.

홀수 및 짝수 단어

일반적인 규칙을 가정하십시오.

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

온라인으로 사용해보십시오!

엑셀, 79 바이트 :

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

입력 :
이 기능은 어디든지 놓을 수 있습니다. 예외 A1
문제의 단어를 A1에 넣습니다.

출력 : 짝수이면 0, 홀수이면 1

자바 스크립트 (ES6), 34 41 33 32 바이트

Arnauld 덕분에 1 바이트가 절약되었습니다.

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

• 홀수 단어 : 반환 1
• 짝수 단어 : 반환 0

Arnauld 덕분에 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

0대신 42 바이트를 반환 합니다 null.

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

34 바이트, 홀수 문자가없는 단어 구분 :

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

Shaun H 덕분에 2 바이트 절약

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

뇌 플랙 206 196 192 178 + 3 = 181 바이트

온라인으로 사용해보십시오!

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

이를 위해서는 -c프로그램 길이에 3 바이트를 더 추가하여 ASCII 모드로 플래그를 실행 해야합니다 .

언 골프

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

설명

미래의 목적을 위해 먼저 스택 높이를 저장하십시오

([]<...>

그런 다음 스택이 비어 있지 않은 동안 (문자가 0이 아닌 것으로 가정)

{...}

구십 칠 빼기 (나중에 최적화를 위해 3을 저장하십시오)

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

0이 아닌 경우 (즉, a가 아님)

{...}

4 빼기 (나중에 최적화하기 위해 4 저장)

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

0이 아닌 경우 (즉, e가 아님)

{...}

4 빼기 (나중에 최적화하기 위해 4 저장)

({}[({})])

0이 아닌 경우 (즉, i가 아님)

{...}

6 빼기 (나중에 최적화를 위해 6을 저장)

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

0이 아닌 경우 (즉, o가 아님)

{...}

빼기 6 (프로그램은 나중에 예상하므로 상점 6)

({}[({})])

0이 아닌 경우 (즉, u가 아님)

{...}

나머지를 다른 스택으로 옮기고 활성 스택에 0을 넣어 모든 ifs를 피하십시오.

({}<>)(<>)

모든 ifs가 탈출되면 0과 6을 제거하십시오.

{}{}

모든 문자가 처리되면 원래 저장된 높이에서 오프셋 높이를 뺍니다.

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

두 모드

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

C, 42 바이트

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

이것은 x86-64 CPU에서 GCC 4.x와 작동합니다. 결과는 설정에 따라 다를 수 있습니다.

repl.it에서 테스트하십시오 .

5 바이트 이상의 비용이 발생하면 정의되지 않은 동작을 피할 수 있으므로 int 의 폭이 32 비트 이상 이면 코드가 작동해야합니다 .

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

작동 원리

Modulo 32 에서 모든 홀수 문자의 문자 코드는 1 , 5 , 9 , 15 및 21 입니다. 2130466은이 위치에서 비트를 설정하고 다른 모든 비트에서는 설정 해제 된 32 비트 정수입니다.

하면 F가 문자열에 호출, 최초로 확인 문자열의 첫 번째 문자가 널 바이트 (문자열 종료) 인 경우. 그렇다면 0을*s 산출 하고 f 는 0을 리턴합니다 . 그렇지 않으면 문자의 문자 코드를 산출하고 논리 AND ( ) 의 올바른 인수 가 실행됩니다.*s&&

의 경우 >>GCC는 시프트 명령을 생성합니다. x86-64 CPU에서 32 비트 정수에 해당하는 명령어는 오른쪽 인수의 하위 5 비트를 제외한 모든 비트를 무시하므로 *s모듈로 32 감소를 피할 수 있습니다. 오른쪽 시프트 및 다음의 비트 AND AND 1 은 문자에 해당하는 2130466 의 비트를 추출하며 , 문자가 홀수 인 경우에만 1 입니다.

그런 다음 포인터 s를 효과적으로 증가시키고 (첫 번째 문자를 효과적으로 버림) 참수 된 문자열에서 f를 재귀 적으로 호출 하고 위의 결과와 재귀 호출의 결과에 대한 비트 XOR을 가져옵니다.

sed 44 (-n의 경우 42 + 1) 43

Neil 덕분에 -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을 반환하는 명명되지 않은 함수

Brain-Flak , 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'

하스켈, 38 37 바이트

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

1 바이트의 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;}

몇 가지 다른 자바 답변을 보았습니다. 그렇지 않으면 공유하지 않을 것입니다. 바이트를 저장해 준 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 인터프리터는 이전 버전과 호환 되므로 온라인으로 사용해 볼 수 있습니다! 바로 여기에.

한 3 바이트는 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 -실행을 중지하고 행렬을 지우고 첫 번째 값을 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

apt, 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;

truey이면 -1, falsey이면 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를 사용하고 있기 때문에 IndexOf보다 2 바이트를 절약합니다.
• Count의 메소드 오버로드를 사용하면 6 바이트가 절약됩니다.
• 깔끔한 방법을 제안하고 6 바이트를 더 절약 한 @Milk 덕분에

문자열을 가져 와서 홀수 문자를 계산하는 익명 함수는 홀수 문자가 있으면 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%

여기 사용해보십시오!