Meydan okuma

Giriş olarak tek bir kelime verildiğinde, kelimenin tek mi yoksa çift mi olduğunu belirleyin.

Tek ve Çift kelimeler

Genel kuralları kabul edin:

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

Alfabede, tuhaf harfler:

aeiou

Ve çift harfler:

bcdfghjklmnpqrstvwxyz

Aynısı büyük harfler için de geçerlidir ( AEIOUtek ve BCDFGHJKLMNPQRSTVWXYZçift).

Daha sonra kelimedeki harflerin her birini 'eklersiniz'. Örneğin, kelime catsşuna eşittir:

even + odd + even + even

Hangi basitleştirir:

odd + even

Hangisi daha da kolaylaştırır:

odd

Yani kelime catstuhaf.

Örnekler

Input:  trees
Output: even

Input:  brush
Output: odd

Input:  CAts
Output: odd

Input:  Savoie
Output: even

Input:  rhythm
Output: even

kurallar

Tüm girdiler yalnızca alfabetik karakterler içerecek tek bir kelime olacaktır.

Sözcük tek ise, gerçek bir değer verin. Kelime eşitse, bir falsey değeri verin.

Kazanan

Bayt cinsinden en kısa kod kazanır.

05AB1E , 6 bayt

lžMÃgÉ

açıklama

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

Çevrimiçi deneyin!

EXCEL, 79 bayt:

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

girişi:
Bu fonksiyon herhangi bir yere yerleştirilebilir A1 HARİÇ
A1 içine söz konusu söz koyun.

Çıktı: eğer eşitse 0, tek ise 1.

JavaScript (ES6), 34 41 33 32 bayt

Arnauld sayesinde 1 bayt kurtarıldı:

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

• Tek kelime: döndürür 1
• Hatta kelimeler: döner 0

Arnauld sayesinde 33 bayt:

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

• Tek kelime: döndürür 1
• Hatta kelimeler: döner 0

Bitsel operatörler olmadan başka bir yol:

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

41 bayt:

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

• Tek kelime: döndürür 1
• Tek harfli kelimeler bile: döner 0
• Tek harf içermeyen kelimeler bile: döner null

42 geri dönmek için bayt 0yerine null:

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

34 bayt, tuhaf harflerin olmadığı kelimeleri keser:

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

Shaun H sayesinde 2 bayt kaydedildi

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

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

Çevrimiçi Deneyin!

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

Bu, -cbayrağın programın uzunluğuna 3 bayt ekleyerek ASCII modunda çalışmasını gerektirir .

Ungolfed

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

açıklama

İlk önce yığın yüksekliğini gelecekteki amaçlar için saklayın

([]<...>

Sonra yığın boş değilken (karakterlerden hiçbirinin sıfır olmadığını varsayar)

{...}

Doksan yediyi çıkarın (ve daha sonra iyileştirmeler için 3'ü saklayın)

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

Sıfır değilse (yani a)

{...}

4'ü çıkarın (ve daha sonra iyileştirmeler için 4'ü saklayın)

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

Sıfır değilse (yani e değil)

{...}

4'ü çıkarın (ve daha sonra iyileştirmeler için 4'ü saklayın)

({}[({})])

Sıfır değilse (yani ben değil)

{...}

6'yı çıkarın (ve daha sonra iyileştirmeler için 6'yı saklayın)

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

Sıfır değilse (yani o değil)

{...}

Çıkar 6 (depo 6, çünkü program daha sonra bekler)

({}[({})])

Sıfır değilse (yani u)

{...}

Kalanı diğer yığına taşıyın ve tüm ifs'lerden kaçmak için aktif yığına sıfır koyun.

({}<>)(<>)

Tüm ifs'lerden kaçtıktan sonra sıfır ve altı

{}{}

Tüm karakterler işlendikten sonra, ofsetin yüksekliğini başlangıçta depolanan yükseklikten çıkarın.

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

İki tarafından mod

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

C, 42 bayt

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

Bu bir x86-64 CPU üzerindeki GCC 4.x ile çalışır. Sonuçlar farklı kurulumlara göre değişebilir.

Repl.it üzerinde test edin .

5 bayt pahasına, tanımsız davranıştan kaçınılabilir, bu nedenle int en az 32 bit genişliğinde olduğu sürece kod çalışmalıdır .

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

Nasıl çalışır

Modulo 32 , bütün tuhaf harflerin karakter kodları 1 , 5 , 9 , 15 ve 21'dir . 2130466 , bu konumlarda bit ayarlayan ve diğerlerini de bitmeyen 32 bit tam sayıdır.

Bir dizgede f çağrıldığında, önce dizenin ilk karakterinin boş bayt olup olmadığını kontrol eder (string terminator). Öyleyse, 0*s verir ve f 0 döndürür . Aksi halde, bir harfin karakter kodunu verin ve AND ( ) mantıkının doğru argümanı yürütülür.*s&&

Çünkü >>, GCC bir vardiya talimatı üretir. Bir x86-64 işlemcisinde, 32 bit bir tamsayı için karşılık gelen komut, görmezden gelenin en az 5 bitini görmezden gelir, bu da *smodulo 32'nin azalmasını önler . Sağa kaydırma ve sonraki bit yönünde VE 1 ile , harfin karşılığı olan 2130466'nın bitini çıkarır; bu, yalnızca harf tuhaf ise 1 olur.

Daha sonra, imleci s artırırız (ilk harfi etkin biçimde atarız ), başlı dizgede f tekrarı yaparız ve yukarıdan ve özyinelemeli çağrının sonucunun bitli XOR'unu alırız.

sed 44 (-n için 42 + 1) 43

-1 Neil sayesinde

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

oTek ve tek başına hiçbir şey için yazdırır

Python, 41 bayt

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

Python, 42 bayt

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

Burada açıklanacak pek bir şey yok. 0 veya 1 döndüren adsız bir işlev.

Brain-Flak , 524, 446 , 422 bayt

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

Çevrimiçi deneyin!

Ungolfed, daha okunabilir versiyonu:

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

Jöle , 13 12 11 bayt

@Luis Mendo sayesinde -1 bayt ( Ḃdeğiştirmek için kullanılır %2)
@Dennis sayesinde -1 bayt (string sıkıştırma kullanın)

Œlf“¡ẎṢɱ»LḂ

Tüm test vakaları TryItOnline'da

Nasıl?

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

Rekabet etmeyen 5 bayt (fonksiyonu yeni eklediğimden beri Øc)

fØcLḂ

TryItOnline'da da test vakaları

Yukarıdakiyle aynı, ancak ØcLatin alfabesinin ünlülerini verir,'AEIOUaeiou'

Haskell, 38 37 bayt

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

Bir bayt için Angs'a teşekkürler!

Python 3, 53 Bayt

Bu muhtemelen daha fazla golf oynayabilir:

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

Birkaç diğer Java cevaplarını gördüm, aksi halde paylaşmazdım. Bayt tasarrufu için Phaeze teşekkürler.

C 52 bayt

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

ana ve sonuç:

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 bayt

%l@"aeiou"rQ02

Çevrimiçi Deneyin!

Açıklama:

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

Yakut, 30 bayt

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

Vim, 32, 31 , 29 tuş vuruşları

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

V tercümanı geriye dönük uyumlu olduğundan, çevrimiçi deneyebilirsiniz! tam burada.

Bir Üç bayt m-chrzan sayesinde kurtarıldı!

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

dimwit , 14 bayt (rekabet etmeyen)

ar[aeiou]}et}T

Bunun yeni bir dil için başlamak için eğlenceli, basit bir meydan okuma olacağını düşündüm.

açıklama

• a - matrise yeni bir dizi itmek
• r[aeiou]} - ilk dizideki "[aeiou]" regex ile eşleşen tüm değerlerin sayımlarını sayın (ilk dizi girdi içerdiğinden), dikkate almaz ve bu değeri son dizinin sonuna itin.
• e - son dizideki son sayı eşitse (bu sayı oluşum sayısına göre belirlenirse), bir sonraki işlemleri kapatma braketine kadar ("}") gerçekleştirin
• t - yürütmeyi durdur, matrisi temizle ve ilk değeri false olarak ayarla
• }- ekod bloğunun sonu
• T - yürütmeyi durdur, matrisi temizle ve ilk değeri true olarak ayarla

Çevrimiçi deneyin!

Kelimeyi girmek için Giriş alanını kullanın.

Yakında belge ekleyeceğim ...

PowerShell v2 +, 45 42 bayt

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

Girişi alır $args[0], aracılığıyla gönderir -replaceolmayan tüm sesli harf karakterleri kaldırmak için, ortaya çıkan alır .lengthve %2hatta / garip olmadığını kontrol etmek.

Örnekler

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 bayt

2|+/@e.&'aeiouAEOIU'

Düz ileri yaklaşım

açıklama

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 bayt

1&Uè"%v

Çevrimiçi test edin! Tek için 1, çift için 0 çıkışı.

Nasıl çalışır

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

Oktav, 34 bayt

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

Bu kullanılarak geleneksel yaklaşımından daha 6 bayt kısadır ismember, @(s)mod(sum(ismember(s,'aeiouAEIOU')),2)ve iki normal ifade yaklaşımı daha kısa bayt: @(s)mod(nnz(regexpi(s,'[aeiou]')),2).

Burada test et .

PHP, 41 bayt

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

Bu, truthy için -1 ve falsey için 0 değerini verir.

Mathematica, 44 bayt

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

Tek bir dize için True, çift içinse False verir.

q, 29 bayt

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

C # 64 62 56 50 Bayt

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

• Biz zaten linq kullanıyoruz, bu yüzden Contains, IndexOf'a 2 bayt kazandırıyor
• Count yönteminin aşırı yüklenmesi 6 bayttan tasarruf sağlar
• Düzgün bir yöntem önerdiği ve 6 bayttan daha fazla tasarruf sağladığı için @ Milk'a teşekkürler

Bir dize alan ve tek harfleri sayan anonim bir işlev daha sonra eğer tek bir sayı varsa doğru veya sıfır ise yanlış olur.

Bu yeni çözüm, dizgiyi verilen karakter dizisindeki karakterlerden herhangi birine böler. Bunun mekaniği %2sonucun anlamını çevirir; 0 artık tek ve 1 bile 1>.

Burada çevrimiçi deneyin!

Retina , 19 bayt

Mi`[aeiou]
[13579]$

Çevrimiçi deneyin! (İlk satır, satır besleme ayrılmış bir test takımı sağlar.)

İlk satır giriş içindeki ünlü harfleri sayar. İkinci satır, sonucun tuhaf olduğunu kontrol eder.

MATL , 8 , 7 bayt

13Y2mso

Çevrimiçi deneyin!

Açıklama:

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 bayt

l1~Vm/s 2%

Burada dene!