Thử thách

Cho một từ duy nhất làm đầu vào, xác định xem từ đó là số lẻ hay số chẵn.

Những từ lẻ và chẵn

Giả sử các quy tắc chung:

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

Trong bảng chữ cái, các chữ cái lẻ là:

aeiou

Và các chữ cái chẵn là:

bcdfghjklmnpqrstvwxyz

Điều tương tự áp dụng cho chữ in hoa ( AEIOUlà số lẻ và số chẵn BCDFGHJKLMNPQRSTVWXYZ).

Sau đó, bạn 'thêm' từng chữ cái trong từ lại với nhau. Ví dụ: từ catsnày tương đương với:

even + odd + even + even

Mà đơn giản hóa để:

odd + even

Mà đơn giản hóa hơn nữa để:

odd

Vì vậy, từ catsnày là số lẻ.

Ví dụ

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Quy tắc

Tất cả đầu vào sẽ là một từ duy nhất chỉ chứa các ký tự chữ cái.

Nếu từ là số lẻ, xuất ra một giá trị trung thực. Nếu từ là chẵn, xuất ra một giá trị falsey.

Chiến thắng

Mã ngắn nhất tính bằng byte thắng.

05AB1E , 6 byte

lžMÃgÉ

Giải trình

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

Hãy thử trực tuyến!

EXCEL, 79 byte:

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

đầu vào:
Chức năng này có thể được đặt ở bất cứ đâu NGOẠI TRỪ A1
Đặt từ của bạn trong câu hỏi vào A1.

Đầu ra: 0 nếu chẵn, 1 nếu lẻ.

JavaScript (ES6), 34 41 33 32 byte

Đã lưu 1 byte nhờ Arnauld:

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

• Từ lẻ: trả về 1
• Ngay cả từ: trả về 0

33 byte nhờ Arnauld:

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

• Từ lẻ: trả về 1
• Ngay cả từ: trả về 0

Một cách khác mà không có toán tử bitwise:

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

41 byte:

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

• Từ lẻ: trả về 1
• Ngay cả các từ có chữ lẻ: trả về 0
• Ngay cả những từ không có chữ cái lẻ: trả về null

42 byte để trả về 0thay vì null:

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

34 byte, ngắt các từ không có chữ cái lẻ:

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

Đã lưu 2 byte nhờ Shaun H

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

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

Hãy thử trực tuyến!

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

Điều này đòi hỏi -ccờ phải chạy trong chế độ ASCII, thêm 3 byte vào chiều dài của chương trình.

Bị đánh cắp

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

Giải trình

Đầu tiên lưu trữ chiều cao ngăn xếp cho các mục đích trong tương lai

([]<...>

Sau đó, trong khi ngăn xếp không trống (giả sử rằng không có ký tự nào bằng 0)

{...}

Trừ chín mươi bảy (và lưu trữ 3 để tối ưu hóa sau này)

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

Nếu nó không bằng 0 (tức là không phải a)

{...}

Trừ 4 (và lưu 4 để tối ưu hóa sau)

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

Nếu nó không bằng 0 (tức là không phải e)

{...}

Trừ 4 (và lưu 4 để tối ưu hóa sau)

({}[({})])

Nếu nó không bằng 0 (tức là không phải i)

{...}

Trừ 6 (và lưu 6 để tối ưu hóa sau)

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

Nếu nó không bằng 0 (tức là không o)

{...}

Trừ 6 (cửa hàng 6 vì chương trình mong đợi một lần sau)

({}[({})])

Nếu nó không bằng 0 (tức là không phải u)

{...}

Di chuyển phần còn lại sang ngăn xếp khác và đặt số 0 vào ngăn xếp hoạt động để thoát khỏi tất cả các if

({}<>)(<>)

Khi tất cả các if đã được thoát, hãy xóa số 0 và số 6

{}{}

Khi tất cả các ký tự đã được xử lý trừ đi chiều cao của phần bù so với chiều cao được lưu trữ ban đầu.

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

Mod bởi hai

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

C, 42 byte

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

Điều này hoạt động với GCC 4.x trên CPU x86-64. Kết quả có thể thay đổi với các thiết lập khác nhau.

Thử nghiệm nó trên repl.it .

Với chi phí thêm 5 byte, hành vi không xác định có thể tránh được, do đó mã phải hoạt động miễn là int s rộng tối thiểu 32 bit.

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

Làm thế nào nó hoạt động

Modulo 32 , mã ký tự của tất cả các chữ cái lẻ là 1 , 5 , 9 , 15 và 21 . 2130466 là số nguyên 32 bit đã đặt bit tại các vị trí này và bỏ đặt bit ở tất cả các vị trí khác.

Khi f được gọi trên một chuỗi, đầu tiên nó sẽ kiểm tra xem ký tự đầu tiên của chuỗi có phải là byte không (bộ kết thúc chuỗi). Nếu có, *smang lại 0 và f trả về 0 . Mặt khác, *smang lại mã ký tự của một chữ cái và đối số đúng của logic AND ( &&) được thực thi.

Đối với >>, GCC tạo ra một hướng dẫn thay đổi. Trên CPU x86-64, hướng dẫn tương ứng cho số nguyên 32 bit bỏ qua tất cả trừ 5 bit thấp hơn của đối số bên phải, giúp tránh giảm *smodulo 32 . Sự dịch chuyển bên phải và theo bit sau VÀ với 1 trích xuất bit 2130466 tương ứng với chữ cái, sẽ là 1 khi và chỉ khi chữ cái đó là số lẻ.

Sau đó, chúng tôi tăng con trỏ s (loại bỏ chữ cái đầu tiên một cách hiệu quả), gọi f đệ quy trên chuỗi bị chặt đầu và lấy XOR bitwise của kết quả từ phía trên và kết quả của lệnh gọi đệ quy.

sed 44 (42 + 1 cho -n) 43

-1 cảm ơn Neil

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

In ocho lẻ và không có gì cho thậm chí

Python, 41 byte

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

Python, 42 byte

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

Không có nhiều để giải thích ở đây. Hàm không tên trả về 0 hoặc 1.

Brain-Flak , 524, 446 , 422 byte

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

Hãy thử trực tuyến!

Ungolfed, phiên bản dễ đọc hơn:

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

Thạch , 13 12 11 byte

-1 byte nhờ @Luis Mendo (sử dụng Ḃđể thay thế %2)
-1 byte nhờ @Dennis (sử dụng nén chuỗi)

Œlf“¡ẎṢɱ»LḂ

Tất cả các trường hợp thử nghiệm đều có tại TryItOnline

Làm sao?

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

Không cạnh tranh, 5 byte (vì tôi vừa thêm chức năng Øc)

fØcLḂ

Các trường hợp thử nghiệm cũng tại TryItOnline

Tương tự như trên, nhưng Øcmang lại các nguyên âm của bảng chữ cái Latinh,'AEIOUaeiou'

Haskell, 38 37 byte

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

Cảm ơn Angs cho một byte!

Python 3, 53 byte

Điều này có thể được đánh gôn hơn nữa:

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

đã thấy một vài câu trả lời java khác, nếu không sẽ không chia sẻ. Cảm ơn Phaeze đã lưu một byte.

C 52 byte

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

chính và kết quả:

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

*/

Bình thường, 14 byte

%l@"aeiou"rQ02

Hãy thử trực tuyến!

Giải trình:

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

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

Vim, 32, 31 , 29 tổ hợp phím

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

Vì trình thông dịch V tương thích ngược, bạn có thể dùng thử trực tuyến! ngay chỗ này.

Một Ba byte được lưu nhờ 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;}

Ung dung:

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

dimwit , 14 byte (không cạnh tranh)

ar[aeiou]}et}T

Tôi nghĩ rằng đây sẽ là một thử thách đơn giản, thú vị để bắt đầu với một ngôn ngữ mới.

Giải trình

• a - đẩy một mảng mới vào ma trận
• r[aeiou]} - số lần xuất hiện của tất cả các giá trị khớp với regex "[aeiou]" trong mảng đầu tiên (vì mảng đầu tiên chứa đầu vào), bỏ qua trường hợp và đẩy giá trị đó đến cuối mảng cuối cùng.
• e - nếu số cuối cùng trong mảng cuối cùng là số chẵn (mà chúng tôi đặt thành số lần xuất hiện), hãy thực hiện các thao tác tiếp theo cho đến khi đóng khung ("}")
• t - dừng thực thi, xóa ma trận và đặt giá trị đầu tiên là false
• }- kết thúc ekhối mã
• T - dừng thực thi, xóa ma trận và đặt giá trị đầu tiên là true

Hãy thử trực tuyến!

Sử dụng trường Nhập liệu để nhập từ.

Tôi sẽ sớm thêm tài liệu ...

PowerShell v2 +, 45 42 byte

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

Đưa đầu vào $args[0], gửi nó đi -replaceđể loại bỏ tất cả các ký tự không nguyên âm, lấy kết quả .lengthvà %2kiểm tra xem nó có lẻ / chẵn hay không.

Ví dụ

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 byte

2|+/@e.&'aeiouAEOIU'

Phương pháp tiếp cận thẳng

Giải trình

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 byte

1&Uè"%v

Kiểm tra nó trực tuyến! Đầu ra 1 cho số lẻ, 0 cho số chẵn.

Làm thế nào nó hoạt động

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

Octave, 34 byte

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

Đây là 6 byte ngắn hơn so với phương pháp truyền thống sử dụng ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)và hai byte ngắn hơn so với phương pháp regex: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Kiểm tra nó ở đây .

PHP, 41 byte

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

Điều này tạo ra -1 cho sự thật và 0 cho falsey.

Toán học, 44 byte

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

Cung cấp True cho một chuỗi lẻ và Sai cho một chuỗi chẵn.

q, 29 byte

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

C # 64 62 56 50 byte

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

• Chúng tôi đã sử dụng linq, vì vậy Chứa tiết kiệm 2 byte so với IndexOf
• Sử dụng phương thức quá tải của Count giúp tiết kiệm 6 byte
• Cảm ơn @Milk đã đề xuất một phương pháp gọn gàng và tiết kiệm thêm 6 byte

Hàm ẩn danh nhận một chuỗi và đếm các chữ cái lẻ sau đó trả về true nếu có số lẻ hoặc sai nếu không có.

Giải pháp mới này phân tách chuỗi trên bất kỳ ký tự nào trong mảng char đã cho. Các cơ chế của điều này lật ý nghĩa của %2kết quả; 0 bây giờ là số lẻ và 1 thậm chí là do đó 1>.

Dùng thử trực tuyến tại đây!

Võng mạc , 19 byte

Mi`[aeiou]
[13579]$

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Dòng đầu tiên đếm các nguyên âm trong đầu vào. Dòng thứ hai kiểm tra kết quả là số lẻ.

MATL , 8 , 7 byte

13Y2mso

Hãy thử trực tuyến!

Giải trình:

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 byte

l1~Vm/s 2%

Hãy thử nó ở đây!