Tantangan

Diberi kata tunggal sebagai input, tentukan apakah kata itu ganjil atau genap.

Kata-kata ganjil dan genap

Asumsikan aturan umum:

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

Dalam alfabet, huruf anehnya adalah:

aeiou

Dan huruf genapnya adalah:

bcdfghjklmnpqrstvwxyz

Hal yang sama berlaku untuk huruf kapital ( AEIOUganjil dan BCDFGHJKLMNPQRSTVWXYZgenap).

Anda kemudian 'menambahkan' masing-masing huruf dalam kata bersama. Misalnya, kata catstersebut setara dengan:

even + odd + even + even

Yang disederhanakan menjadi:

odd + even

Yang menyederhanakan lebih lanjut ke:

odd

Jadi kata catsitu aneh.

Contohnya

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

Aturan

Semua input akan menjadi satu kata yang hanya akan berisi karakter alfabet.

Jika kata tersebut ganjil, berikan nilai yang benar. Jika kata tersebut genap, berikan nilai falsey.

Kemenangan

Kode terpendek dalam byte menang.

05AB1E , 6 byte

lžMÃgÉ

Penjelasan

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

Cobalah online!

EXCEL, 79 byte:

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

input:
Fungsi ini dapat ditempatkan di mana saja KECUALI A1
Masukkan kata Anda ke dalam A1.

Output: 0 jika genap, 1 jika ganjil.

JavaScript (ES6), 34 41 33 32 byte

Disimpan 1 byte berkat Arnauld:

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

• Kata ganjil: kembali 1
• Bahkan kata-kata: kembali 0

33 byte berkat Arnauld:

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

• Kata ganjil: kembali 1
• Bahkan kata-kata: kembali 0

Cara lain tanpa operator bitwise:

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

41 byte:

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

• Kata ganjil: kembali 1
• Bahkan kata-kata dengan huruf aneh: kembali 0
• Bahkan kata-kata tanpa huruf aneh: kembali null

42 byte untuk dikembalikan, 0bukan null:

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

34 byte, istirahat kata-kata tanpa huruf aneh:

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

Disimpan 2 byte berkat Shaun H

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

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

Cobalah secara Online!

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

Ini membutuhkan -cbendera untuk berjalan dalam mode ASCII menambahkan 3 byte tambahan ke panjang program.

Tidak disatukan

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

Penjelasan

Pertama-tama simpan tinggi tumpukan untuk tujuan di masa mendatang

([]<...>

Kemudian sementara tumpukan tidak kosong (mengasumsikan bahwa tidak ada karakter yang nol)

{...}

Kurangi sembilan puluh tujuh (dan simpan 3 untuk optimasi nanti)

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

Jika bukan nol (yaitu bukan a)

{...}

Kurangi 4 (dan simpan 4 untuk optimisasi nanti)

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

Jika bukan nol (yaitu bukan e)

{...}

Kurangi 4 (dan simpan 4 untuk optimisasi nanti)

({}[({})])

Jika bukan nol (yaitu bukan saya)

{...}

Kurangi 6 (dan simpan 6 untuk optimisasi nanti)

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

Jika bukan nol (yaitu bukan o)

{...}

Kurangi 6 (simpan 6 karena program mengharapkannya nanti)

({}[({})])

Jika bukan nol (yaitu bukan u)

{...}

Pindahkan sisanya ke tumpukan lain dan beri angka nol pada tumpukan aktif untuk menghindari semua seandainya

({}<>)(<>)

Setelah semua ifs telah lolos, lepaskan nol dan enam

{}{}

Setelah semua karakter diproses, kurangi tinggi offset dari ketinggian yang disimpan sebelumnya.

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

Mod oleh dua

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

C, 42 byte

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

Ini bekerja dengan GCC 4.x pada CPU x86-64. Hasil dapat bervariasi dengan pengaturan berbeda.

Mengujinya pada repl.it .

Dengan biaya 5 byte lebih, perilaku yang tidak terdefinisi dapat dihindari, sehingga kode harus bekerja selama int setidaknya 32 bit.

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

Bagaimana itu bekerja

Modulo 32 , kode karakter dari semua huruf aneh adalah 1 , 5 , 9 , 15 , dan 21 . 2130466 adalah integer 32-bit yang telah menetapkan bit pada posisi ini dan menghapus bit pada yang lainnya.

Ketika f dipanggil pada sebuah string, ia pertama-tama memeriksa apakah karakter pertama dari string tersebut adalah byte nol (string terminator). Jika ya, *shasilkan 0 dan f mengembalikan 0 . Kalau tidak, *shasilkan kode karakter huruf dan argumen yang benar dari logika AND ( &&) dieksekusi.

Sebab >>, GCC menghasilkan instruksi shift. Pada CPU x86-64, instruksi yang sesuai untuk integer 32-bit mengabaikan semua kecuali 5 bit yang lebih rendah dari argumen yang benar, yang menghindari pengurangan *smodulo 32 . Pergeseran kanan dan bitwise berikut DAN dengan 1 mengekstrak bit 2130466 yang sesuai dengan huruf, yang akan menjadi 1 jika dan hanya jika hurufnya ganjil.

Setelah itu, kami kenaikan pointer s (efektif membuang huruf pertama), panggilan f rekursif pada string dipenggal, dan mengambil XOR bitwise hasil dari atas dan hasil dari panggilan rekursif.

sed 44 (42 +1 untuk -n) 43

-1 Terima kasih kepada Neil

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

Mencetak ountuk yang aneh dan tidak ada yang genap

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

Tidak banyak yang bisa dijelaskan di sini. Fungsi tanpa nama yang mengembalikan 0 atau 1.

Brain-Flak , 524, 446 , 422 byte

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

Cobalah online!

Versi tidak disatukan dan lebih mudah dibaca:

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

Jelly , 13 12 11 byte

-1 byte terima kasih kepada @Luis Mendo (gunakan Ḃuntuk mengganti %2)
-1 byte terima kasih kepada @Dennis (gunakan kompresi string)

Œlf“¡ẎṢɱ»LḂ

Semua test case ada di TryItOnline

Bagaimana?

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

Non-bersaing, 5 byte (karena saya baru saja menambahkan fungsi Øc)

fØcLḂ

Uji kasus juga di TryItOnline

Sama seperti di atas, tetapi Øcmenghasilkan vokal alfabet Latin,'AEIOUaeiou'

Haskell, 38 37 byte

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

Terima kasih kepada Angs untuk satu byte!

Python 3, 53 Bytes

Ini mungkin bisa di-golf lebih lanjut:

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

Jawa, 73

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

melihat beberapa jawaban java lainnya, jika tidak tidak akan dibagikan. Terima kasih kepada Phaeze karena telah menghemat satu byte.

C 52 byte

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

utama dan hasilnya:

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 byte

%l@"aeiou"rQ02

Cobalah secara Online!

Penjelasan:

  @"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 penekanan tombol

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

Karena penerjemah V kompatibel dari belakang, Anda dapat mencobanya secara online! disini.

Satu Tiga byte disimpan berkat 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;}

Tidak Terkumpul:

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

dimwit , 14 byte (tidak bersaing)

ar[aeiou]}et}T

Saya pikir ini akan menjadi tantangan yang menyenangkan dan sederhana untuk memulai dengan bahasa baru.

Penjelasan

• a - dorong array baru ke matriks
• r[aeiou]} - hitung kemunculan semua nilai yang cocok dengan regex "[aeiou]" dalam array pertama (karena array pertama berisi input), abaikan case, dan dorong nilai itu ke akhir array terakhir.
• e - jika angka terakhir dalam array terakhir adalah genap (yang kami atur ke jumlah kemunculan), lakukan operasi berikutnya hingga braket penutup ("}")
• t - hentikan eksekusi, kosongkan matriks, dan atur nilai pertama menjadi false
• }- akhir eblok kode
• T - hentikan eksekusi, hapus matriks, dan tetapkan nilai pertama menjadi benar

Cobalah online!

Gunakan bidang Input untuk memasukkan kata.

Saya akan segera menambahkan dokumentasi ...

PowerShell v2 +, 45 42 byte

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

Mengambil input $args[0], mengirimkannya -replaceuntuk menghapus semua karakter non-vokal, mengambil hasilnya .length, dan%2 untuk memeriksa apakah itu aneh / genap.

Contohnya

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'

Pendekatan lurus ke depan

Penjelasan

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

Uji secara online! Output 1 untuk ganjil, 0 untuk genap.

Bagaimana itu bekerja

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

Oktaf, 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

Ini adalah 6 byte lebih pendek dibandingkan dengan pendekatan tradisional yang menggunakan ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)dan dua byte lebih pendek dibandingkan dengan pendekatan regex: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Uji di sini .

PHP, 41 byte

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

Ini menghasilkan -1 untuk kebenaran dan 0 untuk falsey.

Mathematica, 44 byte

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

Memberikan True untuk string aneh dan False untuk string genap.

q, 29 byte

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

C # 64 62 56 50 Bytes

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

• Kami sudah menggunakan LINQ, jadi Berisi menyimpan 2 byte lebih dari IndexOf
• Menggunakan metode overload Count menghemat 6 byte
• Terima kasih kepada @Milk untuk menyarankan metode yang rapi dan menghemat 6 byte lebih

Fungsi anonim yang mengambil string dan menghitung huruf ganjil kemudian mengembalikan true jika ada angka ganjil atau salah jika tidak ada.

Solusi baru ini membagi string pada salah satu karakter dalam array char yang diberikan. Mekanisme ini membalikkan makna %2hasilnya; 0 sekarang aneh dan 1 bahkan karenanya 1>.

Coba online di sini!

Retina , 19 byte

Mi`[aeiou]
[13579]$

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Baris pertama menghitung vokal dalam input. Baris kedua memeriksa apakah hasilnya aneh.

MATL , 8 , 7 byte

13Y2mso

Cobalah online!

Penjelasan:

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%

Coba di sini!