चुनौती

एकल शब्द को इनपुट के रूप में देखते हुए, निर्धारित करें कि शब्द विषम है या सम।

अजीब और भी शब्द

सामान्य नियम मानें:

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

नियम

सभी इनपुट एक एकल शब्द होगा जिसमें केवल वर्णमाला वर्ण होंगे।

यदि शब्द विषम है, तो एक सत्य मान का उत्पादन करें। यदि शब्द समान है, तो एक गलत मूल्य का उत्पादन करें।

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf string decision-problem

— बीटा डिके
स्रोत

1

क्या आप बिना किसी विषम अक्षरों के किसी शब्द का उदाहरण जोड़ सकते हैं।

— हेडी

@ हेदी मैंने एक जोड़ा है, लय

— बीटा डिके

7

पूर्व cuse आप। अजीब वर्ड ™ को पहले से ही JLee द्वारा ट्रेडमार्क किया गया है। यह शब्द का अनधिकृत उपयोग है। : पी

— देउसोवी २०'१६ को

2

यह शुद्ध रेगेक्स प्रस्तुत करने के लिए भीख माँग रहा है

— रोहन झुनझुनवाला

2

क्या इनपुट में केवल वर्णमाला वर्णों की गारंटी है?

— DJMcMayhem

7

05AB1E , 6 बाइट्स

lžMÃgÉ

व्याख्या

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

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

18

EXCEL, 79 बाइट्स:

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

इनपुट:
इस फ़ंक्शन को EXCEPT A1 में कहीं भी रखा जा सकता है।
अपने शब्द को A1 में रखें।

आउटपुट: 0 यदि भी, 1 यदि विषम हो।

— बीटा डिके
स्रोत

13

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स बचाए

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

— Hedi
स्रोत

1

यह विधि तब टूटती है जब शब्द में कोई स्वर नहीं होता है। उस ने कहा: f=जरूरत नहीं है, और regex ऑब्जेक्ट पर कॉलिंग निष्पादन छोटा है। s=>/[aeiou]/ig.exec(s).length%2

— शॉन एच।

मेरे पास ध्वज के execसाथ समान परिणाम नहीं है g।

— हेदी

लानत मस्तिष्क हाँ की उपेक्षा करते हैं, च = अभी भी जरूरत नहीं है कि

— शॉन एच।

क्या आप कर सकते हैं s=>s.split(/[aeiou]/i).length&1^1?

— अरनौल्ड

1

s=>~s.split(/[aeiou]/i).length&1वास्तव में एक बाइट कम है।

— अरनुलद

8

ब्रेन-फ्लैक 206 196 192 178 + 3 = 181 बाइट्स

इसे ऑनलाइन आज़माएं!

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

इसके लिए -cध्वज को ASCII मोड में चलाने के लिए प्रोग्राम की लंबाई में अतिरिक्त 3 बाइट्स जोड़ने की आवश्यकता होती है ।

Ungolfed

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

व्याख्या

भविष्य के प्रयोजनों के लिए पहले स्टैक ऊंचाई को स्टोर करें

([]<...>

तब जबकि स्टैक खाली नहीं है (मानता है कि कोई भी वर्ण शून्य नहीं है)

{...}

नब्बे सात (और बाद में अनुकूलन के लिए स्टोर 3) घटाना

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

यदि यह शून्य नहीं है (अर्थात नहीं)

{...}

4 घटाएँ (और बाद में अनुकूलन के लिए 4 स्टोर)

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

यदि यह शून्य नहीं है (यानी ई नहीं)

{...}

4 घटाएँ (और बाद में अनुकूलन के लिए 4 स्टोर)

({}[({})])

यदि यह शून्य नहीं है (अर्थात मैं नहीं)

{...}

6 घटाएँ (और बाद में अनुकूलन के लिए 6 स्टोर)

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

यदि यह शून्य नहीं है (यानी ओ नहीं)

{...}

घटाना 6 (स्टोर 6 क्योंकि कार्यक्रम एक बाद की उम्मीद है)

({}[({})])

यदि यह शून्य नहीं है (यानी यू नहीं)

{...}

शेष को अन्य स्टैक पर ले जाएं और सभी स्टैक से बचने के लिए सक्रिय स्टैक पर एक शून्य डालें

({}<>)(<>)

एक बार यदि सभी के सभी शून्य और छह को हटा दिया गया है

{}{}

एक बार सभी वर्णों को संसाधित करने के बाद मूल रूप से संग्रहित ऊंचाई से ऑफसेट की ऊंचाई घटाएं।

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

दो से मोद

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

— गेहूं का जादूगर
स्रोत

मुझे लगता -cहै कि केवल +1 बाइट है क्योंकि कभी पर्ल उत्तर भी केवल 1 बाइट / ध्वज जोड़ता है।

— थ्री एफएक्स

1

@ThreeFx ऐसा इसलिए perl -pe'code'है क्योंकि इससे केवल एक बाइट लंबी है perl -e'code'।

— डेनिस

8

सी, 42 बाइट्स

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

यह GCC 4.x के साथ x86-64 CPU पर काम करता है। परिणाम अलग-अलग सेटअप के साथ भिन्न हो सकते हैं।

यह repl.it पर परीक्षण करें ।

5 और बाइट्स की कीमत पर, अपरिभाषित व्यवहार से बचा जा सकता है, इसलिए कोड को तब तक काम करना चाहिए जब तक इंट एस कम से कम 32 बिट्स चौड़ा न हो जाए।

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

यह काम किस प्रकार करता है

मोडुलो 32 , सभी विषम अक्षरों के वर्ण कोड 1 , 5 , 9 , 15 और 21 हैं । 2130466 32-बिट पूर्णांक है जो इन पदों पर बिट्स सेट करता है और अन्य सभी पर बिट्स को अनसेट करता है।

जब f को एक स्ट्रिंग पर बुलाया जाता है, तो यह पहले जांचता है कि क्या स्ट्रिंग का पहला वर्ण एक नल बाइट (स्ट्रिंग टर्मिनेटर) है। यदि यह है, *sतो 0 और च रिटर्न 0 देता है । अन्यथा, *sएक अक्षर के वर्ण कोड का उत्पादन करें और तार्किक AND ( &&) के सही तर्क को निष्पादित किया जाता है।

के लिए >>, GCC एक शिफ्ट निर्देश उत्पन्न करता है। एक x86-64 सीपीयू पर, 32-बिट पूर्णांक के लिए संबंधित निर्देश सभी को अनदेखा करता है, लेकिन सही तर्क के निचले 5 बिट्स, जो *sमोडुलो 32 को कम करने से बचता है । सही शिफ्ट और निम्न बिटवाइंड और 1 के साथ 2130466 के बिट को निकालता है जो पत्र से मेल खाता है, जो कि 1 होगा यदि और केवल यदि पत्र विषम है।

बाद में, हम पॉइंटर एस (प्रभावी रूप से पहले अक्षर को छोड़ने वाले) को बढ़ाते हैं , बी हेडेड स्ट्रिंग पर पुनरावर्ती कॉल करते हैं, और ऊपर से परिणाम के बिटवाइड XOR और पुनरावर्ती कॉल का परिणाम लेते हैं।

— डेनिस
स्रोत

महान बिट बुद्धिमान काम!

— कीउ गण

Ideone में ेरेस रिटर्न 0, क्या यह सही है?

— RosLuP

@RosLuP नहीं, यह सही नहीं है। यह मेरे कंप्यूटर पर और repl.it पर काम करता है, हालांकि (संभवतः क्योंकि जीसीसी का संस्करण काफी अलग है)।

— डेनिस

हाँ, यह निश्चित रूप से संकलक है। क्लैंग 3.7 के साथ, यह आइडोन पर भी काम करता है ।

— डेनिस

7

sed 44 (42 + 1 for -n) 43

-1 नील को धन्यवाद

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

oविषम के लिए प्रिंट और कुछ के लिए भी नहीं

— रिले
स्रोत

s/[aeiou][^aeiou]*[aeiou]//giअगर मैं सही ढंग से गिना जाता हूं, तो आपको एक बाइट बचा सकता है।

— नील

@ नील यप! मेरी इच्छा है कि सेड गैर-लालची खोज कर सकता है।

— रिले

7

पायथन, 41 बाइट्स

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

— XNOR
स्रोत

6

पायथन, 42 बाइट्स

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

यहाँ समझाने के लिए बहुत कुछ नहीं। एक अनाम फ़ंक्शन जो 0 या 1 देता है।

— DJMcMayhem
स्रोत

6

ब्रेन-फ्लैक , 524, 446 , 422 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अधूरा, अधिक पठनीय संस्करण:

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

— DJMcMayhem
स्रोत

Ungolfed संस्करण काम नहीं करता है (टिप्पणी में TIO लिंक फिट नहीं कर सकता; _;)

— गेहूं जादूगर

6

"अधिक पठनीय" 'नाउ ने कहा

— रोहन झुनझुनवाला

6

जेली , 13 12 11 बाइट्स

-1 बाइट के लिए धन्यवाद @Lendo मेंडोज़ ( Ḃप्रतिस्थापित करने के लिए उपयोग %2)
-1 बाइट के लिए धन्यवाद @ डेनिस (एक स्ट्रिंग संपीड़न का उपयोग करें)

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

— जोनाथन एलन
स्रोत

1

मुझे लगता है कि आप की जगह ले सकता %2द्वाराḂ

— लुइस Mendo

7

ईओयू प्राचीन बेसिक रिवील्स में अगोचर उत्साह का रोना है , इसलिए आप शब्दकोश का उपयोग कर सकते हैं और स्वरों को प्राप्त कर सकते हैं “¡ẎṢɱ»।

— डेनिस

@ डेनिस - बेशक!

— जोनाथन एलन

2

@ डेनिस वास्तव में यह कैसे काम करता है? क्या किसी विशाल शब्दकोष में किसी शब्द का सूचकांक प्राप्त करना सिर्फ आधार-संपीड़न है? 'क' कहाँ से आता है?

— DJMcMayhem

2

@DJMcMayhem यह डिक्शनरी का उपयोग कर एक बेस 250 कंप्रेशन है (जो मेरा मानना है कि डेनिस के कंप्यूटर से लिया गया था) शॉर्ट (6 से कम चार) और लंबे शब्दों के बीच अलगाव के साथ। कुछ कोड संपीड़ित तार बनाने की प्रक्रिया को स्वचालित करने के लिए लिन द्वारा लिखे गए थे। अप्रयुक्त 6 बाइट्स जेली के स्ट्रिंग की पहचान करने वाले वर्ण हैं “”«»‘’(इसमें ⁾दो-चार स्ट्रिंग के लिए भी है, लेकिन इसका उपयोग संपीड़ित तारों के भीतर किया जाता है)।

— जोनाथन एलन

6

हास्केल, 38 37 बाइट्स

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

एक बाइट के लिए एंग्स के लिए धन्यवाद!

— BlackCap
स्रोत

विषम के लिए सत्य, इसलिए आपको oddइसके बजाय उपयोग करना होगा even। एक-एक बाइट बचाता है!

— Angs

@Angs चालाक :)

— BlackCap

4

पायथन 3, 53 बाइट्स

इसे संभवतः आगे बढ़ाया जा सकता है:

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

— एल। स्टीयर
स्रोत

के बीच रिक्त स्थान निकालें inऔर 'aeiou'और for, और उपयोग sum8 बाइट्स को बचाने के लिए: lambda n:sum(x in'aeiou'for x in n.lower())&1(हालांकि के रूप में आप DJMcMayhem पद सभी दस स्वरों का उपयोग करने से देख सकते हैं भी छोटा हो)

— जोनाथन एलन

1

सुझावों के लिए धन्यवाद! मैंने पोस्ट करने के बाद अतिरिक्त स्थानों पर थोड़ा ध्यान दिया, लेकिन सभी ईमानदारी में, @DJMcMayhem और मेरे पास समान दृष्टिकोण था जिसमें सबसे अच्छा संस्करण था जिसे मैं पायथन समाधान के लिए कल्पना कर सकता हूं। मैं sum()इस गोल्फ से पहले कमांड के बारे में नहीं जानता था इसलिए एक बार फिर से मैंने कुछ सीखा! आपका दिन शुभ हो :)

— L. Steer

4

जावा, 73

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

एक दूसरे जावा जवाब देखा, अन्यथा साझा नहीं होता। एक बाइट को बचाने के लिए फेज को धन्यवाद।

— dpa97
स्रोत

1

मुझे लगता है कि आप के साथ एक बाइट बचा सकता है%2>0

— जस्टिनएम -

4

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

*/

— RosLuP
स्रोत

मैं संकेत के रूप में int का उपयोग करने की कोशिश करता हूं, लेकिन यह संकलित नहीं करता है कि इनडायरेक्शन का उपयोग * ... यहां पहले जो समाधान छपा था वह गलत था ...

— RosLuP

h(o){return~-o?1^h(1+strpbrk(o,"aeiouAEIOU")):1;}3 बाइट्स बचाता है।

— डेनिस

s; h; (o) {s = ~ -o; 1 ^ h (1 + strpbrk (o, "aeiouAEIOU")): 1;} परिणाम वैश्विक परिवर्तनशील s में है ...

— RosLuP

दुर्भाग्य से, यह अनुमति नहीं है। कार्यों को पुन: प्रयोज्य करना होगा, और यदि आप इसे एक से अधिक बार उपयोग करते हैं तो यह टूट जाएगा। इसके अलावा, आउटपुट को एक चर में सहेजने की अनुमति नहीं है, जब तक कि आप उपयोगकर्ता इनपुट के रूप में स्थान नहीं लेते हैं।

— डेनिस

मुझे लगता है कि इस मामले में पुन: उपयोग संभव है क्योंकि s का प्रारंभ मूल्य अब महत्वपूर्ण नहीं है ... ठीक है अब मुझे लगता है कि कुछ गलत हो सकता है ... धन्यवाद

— RosLuP

3

अजगर, 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

— स्टीवन एच।
स्रोत

3

रूबी, 30 बाइट्स

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

— एम-Chrzan
स्रोत

3

विम, 32, 31 , 29 कीस्ट्रोक्स

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

चूंकि वी दुभाषिया पीछे की ओर संगत है, आप इसे ऑनलाइन आज़मा सकते हैं ! यहीं।

एक तीन बाइट्स ने m-chrzan के लिए धन्यवाद बचाया!

— DJMcMayhem
स्रोत

1

क्या आप इसके s/.../giबजाय कर सकते हैं s/\c.../g?

— m-chrzan

@ m-chrzan Woah, कमाल की टिप। धन्यवाद!

— DJMcMayhem

इसके अलावा, '<C-r>"'-> @"।

— m-chrzan

1

मुझे लगभग @"15 मिनट पहले पता चला । मेरे पास सबसे अच्छा विम टिप है :help fooऔर /प्रलेखन: पी।

— m-chrzan

2

खैर, जब से हम गोल्फ के बारे में बात कर रहे हैं, :h fooकम है। : पी

— DJMcMayhem

3

जावा 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;
  }

3

डिमविट , 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ar[aeiou]}et}T

मुझे लगा कि यह एक नई भाषा के लिए शुरू करने के लिए एक मजेदार, सरल चुनौती होगी।

व्याख्या

a - मैट्रिक्स के लिए एक नया सरणी धक्का
r[aeiou]} - प्रथम एरे में रेगेक्स "[aeiou]" से मेल खाने वाले सभी मानों की गणना करें (क्योंकि पहले एरे में इनपुट होता है), मामले को अनदेखा करते हुए, और अंतिम मान के अंत में उस मान को पुश करें।
e - यदि अंतिम सरणी में अंतिम संख्या सम है (जिसे हम घटनाओं की संख्या पर सेट करते हैं), एक क्लोजिंग ब्रैकेट ("}") तक अगले ऑपरेशन करें।
t - निष्पादन रोकें, मैट्रिक्स को साफ़ करें, और पहला मूल्य निर्धारित करें कि वह गलत है
}- eकोड ब्लॉक का अंत
T - निष्पादन रोकें, मैट्रिक्स को साफ़ करें, और सत्य होने के लिए पहला मान सेट करें

इसे ऑनलाइन आज़माएं!

शब्द दर्ज करने के लिए इनपुट फ़ील्ड का उपयोग करें।

मैं जल्द ही दस्तावेज जोड़ूंगा ...

— MCMastery
स्रोत

2

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

— AdmBorkBork
स्रोत

2

जे, 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

— मील की दूरी पर
स्रोत

हाहा, मैंने अभी एक J उत्तर दिया (अब हटा दिया गया) 1 बाइट इससे अधिक लंबी है। अच्छी नौकरी!

— कॉनर ओ'ब्रायन ने

"ले इनपुट" के लिए कमांड कहाँ है?

— रोजलूप

@RosLuP यह एक क्रिया (फ़ंक्शन) है जो इनपुट के रूप में एकल तर्क लेता है। J टैसिट प्रोग्रामिंग का उपयोग करता है, इसलिए कमांड एक साथ जंजीर हैं और मानों को स्पष्ट रूप से पास करते हैं

— मील

2

जाप, 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

— ETHproductions
स्रोत

2

ऑक्टेव, 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)और दो regex दृष्टिकोण की तुलना में कम बाइट्स: @(s)mod(nnz(regexpi(s,'[aeiou]')),2)।

इसका परीक्षण यहां करें ।

— स्टीवी ग्रिफिन
स्रोत

2

PHP, 41 बाइट्स

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

यह सत्य के लिए -1 और झूठी के लिए 0 आउटपुट देता है।

— user59178
स्रोत

2

मैथेमेटिका, 44 बाइट्स

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

एक अजीब स्ट्रिंग के लिए सच देता है और एक के लिए भी गलत है।

— जूलियन क्लूज
स्रोत

1

गणित सीखने वाले किसी भी पुरुष या महिला के लिए +1

— मैजिक ऑक्टोपस Urn

2

क्यू, 29 बाइट्स

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

— लियाम बैरन
स्रोत

2

सी # 64 62 56 50 बाइट्स

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

~~हम पहले से ही linq का उपयोग कर रहे हैं, इसलिए Contains IndexOf पर 2 बाइट्स बचाता है~~
~~गणना की विधि अधिभार का उपयोग करके 6 बाइट्स बचाता है~~
एक साफ-सुथरा तरीका सुझाने और 6 और बाइट्स बचाने के लिए @Milk को धन्यवाद

एक अनाम फ़ंक्शन जो एक स्ट्रिंग लेता है और विषम अक्षरों को गिना जाता है, तब सच हो जाता है अगर उनमें से एक विषम संख्या है या गलत है अगर नहीं है।

यह नया समाधान दिए गए वर्ण सरणी में किसी भी वर्ण पर स्ट्रिंग को विभाजित करता है। इस के यांत्रिकी %2परिणाम का अर्थ फ्लिप करते हैं ; 0 अब विषम है और 1 भी इसलिए 1>।

इसे यहाँ ऑनलाइन आज़माएं!

— जस्टिनएम - मोनिका को बहाल करें
स्रोत

string.Split()स्वरों की गिनती के लिए इसका उपयोग केवल 50 बाइट्स के लिए किया जाता है और आपको LINQ की आवश्यकता नहीं है। s=>1>s.Split("aeiouAEIOU".ToCharArray()).Length%2;

— दूध

@milk इसके लिए धन्यवाद, बहुत साफ समाधान।

— जस्टिनएम -

1

रेटिना , 19 बाइट्स

Mi`[aeiou]
[13579]$

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

पहली पंक्ति इनपुट में स्वरों को गिनती है। दूसरी पंक्ति जांचती है कि परिणाम विषम है।

— मार्टिन एंडर
स्रोत

1

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

— DJMcMayhem
स्रोत

1

पाइके, 10 बाइट्स

l1~Vm/s 2%

यहाँ यह कोशिश करो!

— नीला
स्रोत

क्या यह एक अजीब शब्द है?

चुनौती

अजीब और भी शब्द

उदाहरण

नियम

जीतना

05AB1E , 6 बाइट्स

EXCEL, 79 बाइट्स:

जावास्क्रिप्ट (ईएस 6), 34 41 33 32 बाइट्स

ब्रेन-फ्लैक 206 196 192 178 + 3 = 181 बाइट्स

Ungolfed

व्याख्या

सी, 42 बाइट्स

यह काम किस प्रकार करता है

sed 44 (42 + 1 for -n) 43

पायथन, 41 बाइट्स

पायथन, 42 बाइट्स

ब्रेन-फ्लैक , 524, 446 , 422 बाइट्स

जेली , 13 12 11 बाइट्स

हास्केल, 38 37 बाइट्स

पायथन 3, 53 बाइट्स

अजगर, 14 बाइट्स

रूबी, 30 बाइट्स

विम, 32, 31 , 29 कीस्ट्रोक्स

जावा 7, 88

डिमविट , 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

व्याख्या

इसे ऑनलाइन आज़माएं!

PowerShell v2 +, 45 42 बाइट्स

उदाहरण

जे, 20 बाइट्स

व्याख्या

जाप, 7 बाइट्स

यह काम किस प्रकार करता है

ऑक्टेव, 34 बाइट्स

PHP, 41 बाइट्स

मैथेमेटिका, 44 बाइट्स

क्यू, 29 बाइट्स

सी # 64 62 56 50 बाइट्स

रेटिना , 19 बाइट्स

MATL , 8 , 7 बाइट्स

पाइके, 10 बाइट्स