यह एक आसान चुनौती है।

चुनौती

इनपुट nullमें अधिकतम लंबाई 100 की एक स्ट्रिंग ( खाली या खाली) नहीं होगी । स्ट्रिंग द्वारा प्रत्येक शब्द में स्वरों की संख्या को आउटपुट करें, जिसे रिक्त स्थान द्वारा अलग किया गया है।

नियम

स्ट्रिंग की लंबाई 100 वर्णों से अधिक नहीं होगी।
स्ट्रिंग में केवल अक्षर होंगे A-Z, a-zऔर रिक्त स्थान भी हो सकते हैं।
इनपुट का उपयोग stdinकमांड लाइन के तर्कों से किया जाना चाहिए ।
में आउटपुट होना चाहिए stdout।
आप एक पूर्ण कार्यक्रम, या एक फ़ंक्शन लिख सकते हैं stdinजो परिणाम से इनपुट लेता है और परिणाम देता है।
आपके कार्यक्रम / फ़ंक्शन को गिनने के लिए आवश्यक स्वर aeiouऔर हैं AEIOU।

परीक्षण के मामलों

This is the first test case     --> 1 1 1 1 1 2
one plus two equals three       --> 2 1 1 3 2
aeiou AEIOU                     --> 5 5
psst                            --> 0
the quick brown fox jumped over the lazy dog --> 1 2 1 1 2 2 1 1 1

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

code-golf string number

— Spikatrix
स्रोत

6

क्या कोई कारण है कि आप एक बल्कि प्रतिबंधात्मक I / O प्रारूप पर जोर देते हैं? हर भाषा STDIN और STDOUT के साथ (सुगमता से) बातचीत नहीं कर सकती है। इसके लिए हमारे पास डिफॉल्ट हैं (यदि आप चाहें तो ओवरराइड करने के लिए स्वतंत्र हैं), जो कमांड-लाइन तर्क, फ़ंक्शन तर्क, रिटर्न वैल्यू आदि की अनुमति देते हैं (वे भी टैग विकी में पाए जा सकते हैं ।)

— मार्टिन एंडर

@ मार्टिनबटनर, " क्या कोई कारण है कि आप एक बल्कि प्रतिबंधात्मक I / O प्रारूप पर जोर देते हैं? " - नहीं। मुझे पसंद नहीं stdinहै stdout। मैं फ़ंक्शन तर्कों के माध्यम से "इनपुट प्राप्त करना" पसंद नहीं करता। कमांड लाइन तर्क ठीक लगता है। मैंने इसे पोस्ट में जोड़ा है।

— स्पिकैट्रिक्स

4

विकिपीडिया:

The name "vowel" is often used for the symbols that represent vowel sounds in a language's writing system, particularly if the language uses an alphabet. In writing systems based on the Latin alphabet, the letters A, E, I, O, U, and sometimes Y are all used to represent vowels. However, not all of these letters represent vowels in all languages.

स्वरों से आपका क्या तात्पर्य है?

— edc65

क्या सिंगल ट्रेलिंग स्पेस ठीक है?

— एलेक्स ए।

3

प्रस्तावित चुनौतियों के लिए सैंडबॉक्स का उपयोग करें।

— mbomb007

8

पायथ, 17 बाइट्स

jdml@"aeiou"dcrzZ

सीधा समाधान। इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

स्पष्टीकरण:

               z   input
              r Z  convert to lower-case
             c     split at spaces
  m                map each word d to:
    @"aeiou"d         filter d for chars in "aeiou"
   l                  length
jd                 join by spaces and implicitly print

— Jakube
स्रोत

जब लोग पाइथ सॉल्यूशन लिखते हैं और इसे "स्ट्रेटफॉवर्ड" कहते हैं, तो यह हमेशा मुझे बहुत लुभाता है (हालाँकि यह सबसे आसान है कि इसे समझाना आसान है) +1

— क्रिस्टोफर विर्ट

10

सी, 113 108 103 96 बाइट्स

धन्यवाद @ andrea-biondo एक विशेष रूप से अच्छा 5 बाइट की बचत के लिए।

main(a,v,c)char**v;{do{for(a=0;c=*v[1]++%32;2016%(c+27)||a++);printf("%d ",a);}while(v[1][-1]);}

यह अभी भी फूला हुआ की तरह लगता है इसलिए उम्मीद है कि मैं इसे आज रात बाद में कुछ बाइट्स से नीचे पा सकता हूं।

दिलचस्प हिस्सा शायद यही है

!(124701951%((c-65&31)+33))

होगा 1यदि cएक (ऊपरी या निचले मामले) ASCII स्वर है, और 0अन्य पात्रों के लिए a-zA-Z। उपसूचक c-65&31नक्शे 'a'और 'A'करने के लिए 0, 'b'और 'B'करने के लिए 2, आदि हम जोड़ते हैं 33स्वर संख्या के अनुरूप 33, 37, 41, 47, 53क्रमशः, जो सभी कर रहे हैं (आसानी से) प्रधानमंत्री। हमारी सीमा में केवल ऐसी संख्याएँ विभाजित होंगी 124701951 = 33*37*41*47*53, अर्थात केवल स्वरों के लिए शेष 124701951%(...)शून्य होगी।

EDIT: इस तरह से कोई भी अभिव्यक्ति पर विचार कर सकता है !(n%((c-65&31)+s))जहां (n,s) = (124701951, 33)यह निर्धारित करना है कि चरित्र cएक स्वर है। टिप्पणियों में @ andrea-biondo ने बताया कि (n,s) = (2016,28)स्वर का निर्धारण करने के लिए जोड़ी का उपयोग इस अभिव्यक्ति में भी किया जा सकता है। मैं उपरोक्त विवरणों के संदर्भ में वर्तमान व्याख्या छोड़ दूंगा, लेकिन इस छोटी जोड़ी के काम करने का कारण फिर से है क्योंकि रेंज में २ numbers-५३ केवल २०१६ के मुख्य कारकों के सेट में पूरी तरह से प्रमुख कारकों के साथ केवल संख्याएँ २,, ३२ हैं। 36, 42, 48, जो स्वरों के अनुरूप हैं।

EDIT2: एक और 5 बाइट्स बचाए गए (c-65&31)+28जिन्हें छोटा किया जा सकता है c%32+27।

EDIT3: अंत में इसे 100 बाइट से नीचे लाने के लिए एक डू-लूप में परिवर्तित किया गया।

परीक्षण के मामलों:

$ ./vowelc "यह पहला परीक्षण मामला है"
1 1 1 1 1 2 
$ ./vowelc "एक से अधिक दो बराबर तीन"
2 1 1 3 2 
$ ./vowelc "ऐयौ एईआईयूयू"
५ ५ 
$ ./vowelc "psst"                     
0

— Cl-
स्रोत

हे भगवान! यह सिर्फ कमाल है! आप a;बाहर का उपयोग करके अधिक बाइट्स बचा सकते हैं main। इस तरह, आप के रूप में आप की घोषणा करने की जरूरत नहीं है कुछ बाइट्स को कम aमें main(...), और भी प्रारंभ करने की जरूरत नहीं है aपाश से।

— स्पिकैट्रिक्स

1

@CoolGuy: aप्रत्येक लूप पर फिर से आरंभीकृत किया जाता है, इसलिए आप इसे वैश्विक घोषित करके एक बार शून्य पर प्रारंभ नहीं कर सकते। मैंने सबसे छोटी (n, s)जोड़ी को खोजने के लिए एक छोटा सा जानवर लिखा, जो n%((c-65&31)+s)स्वरों के लिए शून्य और व्यंजन (az, AZ) के लिए गैर-शून्य है। मैंने पाया (2016, 28)और यह अच्छी तरह से काम करने लगता है: !(2016%((c-65&31)+28))5 चार्ट छोटा है। वैसे भी, बहुत अच्छा समाधान :)

— एंड्रिया बियोनडो

7

CJam, 21 19 बाइट्स

r{el_"aeiou"--,Sr}h

यह कैसे काम करता है :

r{               }h    e# Read the first word and enter a do-while loop
  el_                  e# Convert the word into lower case and take a copy of it
     "aeiou"           e# All small caps vowels
            -          e# Remove all vowels from the copied word
             -         e# Remove all non-vowels from the original word
              ,        e# At this point, we have a string with all vowels of the word
                       e# Simply take its length
               S       e# Put a space after the number of vowel
                r      e# Read the next word. This serves as the truthy condition for the
                       e# do-while loop for us as if there are no word left, this returns
                       e# null/falsy and the do-while loop is exited

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

— अनुकूलक
स्रोत

6

आर, 44 43 बाइट्स

cat(nchar(gsub("[^aeiou]","",scan(,""),T)))

असंगठित + स्पष्टीकरण:

# Read a string from STDIN. scan() automatically constructs a vector
# from input that contains spaces. The what= argument specifies that
# a string will be read rather than a numeric value. Since it's the
# second specified argument to scan(), we can simply do scan(,"").

s <- scan(what = "")

# For each word of the input, remove all consonants using gsub(),
# which is vectorized over its input argument.

g <- gsub("[^aeiou]", "", s, ignore.case = TRUE)

# Print the number of remaining characters in each word to STDOUT
# using cat(), which automatically separates vector values with a
# single space.

cat(nchar(g))

— एलेक्स ए।
स्रोत

5

पर्ल, 35 34 31

say map{lc=~y/aeiou//.$"}split

30पात्रों +1के लिए -n।

बहुत सारे पर्ल कोड की तरह, यह दाईं से बाईं ओर काम करता है। splitव्हाट्सएप पर इनपुट लाइन को विभाजित करेगा। विभाजित किए गए प्रत्येक शब्द mapके बीच कोड चलाएगा {}। lcशब्द को कमतर बनाता है। =~y/aeiou//हमें स्वरों की गिनती देगा। .$"शब्द के लिए एक स्थान जोड़ देगा। sayफिर सभी शब्दों को प्रिंट करता है!

साथ दौड़ो:

echo 'aeiou AEIOU' | perl -nE'say map{lc=~y/aeiou//.$"}split'

— hmatt1
स्रोत

4

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

print(*[sum(c in'aeiouAEIOU'for c in w)for w in input().split()])

बहुत सीधा, काफी पठनीय। wशब्द cके लिए खड़ा है, चरित्र के लिए खड़ा है।

— randomra
स्रोत

4

पर्ल: 30 अक्षर

(नियमों की ताकतों: आउटपुट संख्या में इनपुट शब्दों के रूप में कई रिक्त स्थान के साथ अलग किए गए हैं।)

s|\w+|@{[$&=~/[aeiou]/gi]}|ge

नमूना रन:

bash-4.3$ while read s; do printf '%-30s --> ' "$s"; perl -pe 's|\w+|@{[$&=~/[aeiou]/gi]}|ge' <<< "$s"; done < test-case.txt
This is the first test case    --> 1 1 1 1 1 2
one plus two equals three      --> 2 1 1 3 2
aeiou AEIOU                    --> 5 5
psst                           --> 0

पर्ल: 27 अक्षर

(बस यह दिखाने के लिए कि अगर मैं y///वापसी के मूल्य के बारे में नहीं भूलता तो कितना कम होगा । अब फिर से जाएं और चिल्लमजिक के उत्तर को बढ़ाएं जिसने मुझे y///वापसी के मूल्य के बारे में याद दिलाया । फिर से।)

s|\w+|lc($&)=~y/aeiou//|ge

— आदमी काम पर है
स्रोत

डांग यह मेरा जवाब धड़कता है। यह बाइट्स के s!\w+!lc($&)=~y/aeiou//!geलिए नीचे जाता है 27(26 वर्ण +1 के लिए -p।

— hmatt1

हाँ धन्यवाद। मैं अपनी उंगलियों पर नहीं गिन सकता कि मैं कितनी बार भूल गया y///। :(

— मैनटवर्क

3

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

$><<$*.map{|x|x.count'AIUEOaiueo'}*' '

उपयोग:

mad_gaksha@madlab /tmp/ $ ruby t.rb This is the first test case
1 1 1 1 1 2

— blutorange
स्रोत

3

जावास्क्रिप्ट ( ईएस 6 ), 68

मैं / ओ पॉपअप के माध्यम से। परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

// As requested by OP

alert(prompt().replace(/\w+/g,w=>w.replace(/[^aeiou]/ig,'').length))

// Testable
f=s=>s.replace(/\w+/g,w=>w.replace(/[^aeiou]/ig,'').length)

test=[
 ['This is the first test case','1 1 1 1 1 2']
,['one plus two equals three','2 1 1 3 2']
,['aeiou AEIOU', '5 5']
]  

out=x=>O.innerHTML+=x+'\n'

test.forEach(t=>{
  r=f(t[0])
  out('Test '+ ['Fail','OK'][0|r==t[1]]
      +'\nInput:  '+ t[0]
      +'\nOutput: '+r
      +'\nCheck:  '+t[1]+'\n')
})

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

3

Rebol - 70

print map-each n split input" "[c: 0 find-all n charset"aeiou"[++ c]c]

— draegtun
स्रोत

3

पॉवरशेल, 35 बाइट्स

%{($_-replace"[^aeiou]",'').length}

Kinda उबाऊ, लेकिन वास्तव में एक बार के लिए प्रतिस्पर्धा? (PowerShell डिफ़ॉल्ट रूप से मामले के प्रति संवेदनशील है, वू)

— नच - बहाल मोनिका
स्रोत

FYI करें, आपको इस तरह से कॉल करना होगा echo <word> | code, जहाँ <word> आपका शब्द या वाक्यांश है

— Pureferret

3

बैश - 85

while read l;do for w in $l;do x=${w//[^aouieAOUIE]};echo -n ${#x}\ ;done;echo;done

व्याख्या

read l इनपुट से एक पंक्ति पढ़ें
for w in l व्हॉट्सएप विभाजक का उपयोग करते हुए शब्दों में लाइन को विभाजित करता है
x=${w//[^aouieAOUIE]/} शब्द से स्वर को छोड़कर सभी हटा देता है
${#x} परिणामी स्ट्रिंग की लंबाई === स्वरों की संख्या है

— xuesheng
स्रोत

किसी तरह ओवरडोन लगता है। आवश्यकता कहती है कि इनपुट में केवल अक्षर और रिक्त स्थान होंगे। तो आपने इसे कई इनपुट लाइनों को संसाधित करने के लिए क्यों तैयार किया? बिना while.. do.. doneकम होगा। इसके अलावा /पैटर्न प्रतिस्थापन में अंतिम जरूरत नहीं है । और एक एकल शाब्दिक स्थान उद्धृत होने से बच जाता है। read l;for w in $l;do x=${w//[^aouieAOUIE]};echo -n ${#x}\ ;done;echo

— मैनेटवर्क

मैं सहमत हूं लेकिन नियम कहता है कि 'आप एक पूर्ण कार्यक्रम, या एक फ़ंक्शन लिख सकते हैं जो स्टड से इनपुट लेता है और परिणाम को आउटपुट करता है।' इसलिए मैंने पूरा कार्यक्रम बनाने का फैसला किया है। मैं दो बाइट्स को बचाने के लिए समाधान संपादित करूंगा)) धन्यवाद!

— xuesheng

3

जूलिया, 76 72 69 65 बाइट्स

for w=split(readline()) print(count(i->i∈"aeiouAEIOU",w)," ")end

असंगठित + स्पष्टीकरण:

# Read a string from STDIN and split it into words
s = split(readline())

# For each word in the string...
for w in s
    # Get the number of vowels of any case in the word
    c = count(i -> i ∈ "aeiouAEIOU", w)

    # Print the number of vowels identified
    print(c, " ")
end

इसमें एक एकल अनुगामी स्थान शामिल होगा, जो मुझे बताया गया है कि यह वैध है।

— एलेक्स ए।
स्रोत

2

गणितज्ञ, 95 बाइट्स

किसी भी कंटेस्टेंट की जीत नहीं, लेकिन ...

Print@StringRiffle[ToString[#~StringCount~Characters@"aeiouAEIOU"]&/@StringSplit@InputString[]]

— LegionMammal978
स्रोत

क्या आप किसी ऑनलाइन कंपाइलर के बारे में जानते हैं जहाँ मैं यह परीक्षण कर सकता हूँ?

— स्पाइकाट्रिक्स

कोई भी नहीं है, लेकिन आप यहां नि: शुल्क परीक्षण प्राप्त कर सकते हैं ।

— लेजियन मम्मल 978

@CoolGuy यदि आप यहां मुफ्त खाता प्राप्त करते हैं, तो आप गणितज्ञ (वुल्फ्राम भाषा) कोड ऑनलाइन चला सकते हैं । (निश्चित नहीं है कि InputStringवेब इंटरफेस में मौजूद है, हालांकि यह मैथमेटिका में एक संवाद है।)

@Calle गणितज्ञ लिपियों में, InputStringइनपुट की अगली पंक्ति लेता है।

— लेजिओनमाला 978

ठीक है मैं समझा। अच्छी तरह से अभी भी यकीन नहीं है कि यह क्लाउड नोटबुक में काम करेगा, लेकिन कम से कम अब मुझे पता है कि इसका उपयोग स्टड के लिए क्यों किया जा रहा है।

2

गोल्फलुआ, 55 बाइट्स

~@W I.r():l():gm("%w+")_,c=W:g("[aeiou]",'')I.w(c,' ')$

बेसिक पैटर्न स्वर के निचले मजबूर के बाद मेल खाती है। एक (असम्बद्ध) लुआ समकक्ष होगा

line=io.read()
for word in line:lower():gmatch("%w+") do
   _,c=word:gsub("[aeiou]",'')
   io.write(c," ")
end

— काइल कानोस
स्रोत

एक तरफ के रूप में, लुआ संस्करण के लिए, यह वास्तव में उपयोग करने gsub('[aeiouAEIOU]','')और छोड़ने के लिए कम से कम 2 वर्ण होगा lower()।

— काइल कानोस

2

आर , 139 बाइट्स

पढ़ना / लिखना stdout () भयानक है

s=function(x,y)strsplit(x,y)[[1]]
write(unlist(Map(function(x)sum(x%in%s("AIUEOaiueo","")),Map(s,s(readLines("stdin")," "),"")),),stdout())

— VLO
स्रोत

आर इतना बुरा नहीं है । ;) आप के cat()बजाय उपयोग कर सकते हैं write(..., stdout())।

— एलेक्स ए

2

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

@Randomra के जवाब से प्रेरित है । यह ~~एक ही लंबाई~~ थोड़ा लंबा है, लेकिन सूची समझ के बजाय regex का उपयोग कर। यह भी कम पठनीय है।

import re
print(*map(len,re.sub("[^aeiou ]","",input(),0,2).split(" ")))

— समुदाय
स्रोत

सहेजें 7 बाइट्स import re;print(*map(len,re.sub("[^aeiou ]","",input()).split())):। ( ;यदि आप चाहें तो इसके बजाय न्यूलाइन का उपयोग करें ।)

— mbomb007

@ mbomb007 इसे असंवेदनशील होने की आवश्यकता है ( 2मामला असंवेदनशील ध्वज है) और इसके द्वारा विभाजित " "होने पर 0 लंबाई सामान हो सकता है

आह, मेरे परीक्षण इतने व्यापक नहीं थे कि नोटिस किया जा सके।

— mbomb007

2

PHP - 94

foreach(explode(' ',$argv[1]) as$d){preg_match_all('/[aeiou]/i',$d,$v);echo count($v[0]).' ';}

अनप्लग्ड संस्करण

$a = explode(' ',$argv[1]);
foreach($a as $d) {
    preg_match_all('/[aeiou]/i', $d, $v);
    echo count($v[0]).' ';
}

— kuldeep.kamboj
स्रोत

2

उद्देश्य-सी, 223 बाइट्स

-(void)p:(NSString*)s{NSArray*a=[s componentsSeparatedByString:@" "];for(NSString*w in a){int c=0;for(int i=0;i<w.length;i++){if([@"aeiouAEIOU"containsString:[w substringWithRange:NSMakeRange(i,1)]]){c++;}}NSLog(@"%d",c);}}

सबसे कॉम्पैक्ट भाषा नहीं है, लेकिन यह काम करता है।

असम्पीडित संस्करण:

- (void)p:(NSString*)s{
    NSArray*a=[s componentsSeparatedByString:@" "];
    for (NSString*w in a) {
        int c=0;
        for (int i=0;i<w.length;i++) {
            if ([@"aeiouAEIOU" containsString:
                 [w substringWithRange:NSMakeRange(i, 1)]]) {
                c++;
            }
        }
        NSLog(@"%d",c);
    }
}

— Fennelouski
स्रोत

2

मतलाब, 73 बाइट्स

आपकी चुनौती बहुत स्पष्ट नहीं है (लेकिन यह दिलचस्प है)। मैं मान रहा हूँ

"स्वर" करके आप मतलब a, e, i, o, u।
स्ट्रिंग में अग्रणी या अनुगामी रिक्त स्थान नहीं होते हैं

कोड:

diff(find(regexprep([' ' input('','s') ' '],'[^aeiouAEIOU ]','')==' '))-1

— लुइस मेंडो
स्रोत

2

आरएस , 50 बाइट्स

यह काफी गिनती नहीं है; यह पोस्ट किए जाने के लगभग 2 सप्ताह बाद rs अपलोड किया गया था। हालाँकि, जाहिर है कि यह कुछ भी नहीं जीतेगा, इसलिए यह अभी भी अच्छा है।

*[aeiou]/_
(^| )[^_\s]+ |$/ 0
[^_\s0]/
(_+)/(^^\1)

लाइव डेमो।

कार्यान्वयन सीधा है:

*[aeiou]/_            Replace all vowels with underscores.
(^| )[^_\s]+ |$/ 0    Replace words that have no vowels with a zero.
[^_\s0]/              Remove all other letters.
(_+)/(^^\1)           Convert the underscore sequences into numbers (e.g. '___' to 3).

— kirbyfan64sos
स्रोत

2

पर्ल, 60 45

$/=" ";while(<>){$n=()=/[aeiou]/gi;print"$n "

मुझे 15 बाइट बचाने के लिए kirbyfan64sos के लिए धन्यवाद - कि वास्तव में मदद की!
नोट आउटपुट के अंत में एक अतिरिक्त स्थान है।

— ASCIIThenANSI
स्रोत

आप splitजोड़कर कॉल हटा सकते हैं $/=" ";, और आप लूप उपसर्ग को छोटा कर सकते हैं while(<>)। उन दो परिवर्तनों के साथ, कोड बन जाता है $/=" ";while(<>){$n=()=/[aeiou]/gi;print"$n "}, जिससे 14 बाइट बचती हैं!

— kirbyfan64sos

2

हास्केल, 76 68 बाइट्स

f=interact$unwords.map(show.length).filter(`elem`"aeiouAEIOU").words

सीधे तौर पर कार्यान्वयन, निश्चित नहीं है कि यहां गोल्फ के लिए कुछ है या नहीं।

— ThreeFx
स्रोत

1

केडीबी (क्यू), 30 बाइट्स

{sum@'lower[" "vs x]in"aeiou"}

व्याख्या

            " "vs x              / split x string by space
      lower[       ]             / lower case
                    in"aeiou"    / check vowel
 sum@'                           / sum each booleans
{                            }   / lambda

परीक्षा

q){sum@'lower[" "vs x]in"aeiou"}"This is the first test case"
1 1 1 1 1 2i

— वूइकेंट ली
स्रोत

1

स्मालटाक - 66 72

यह स्मॉलटाकल / एक्स में है; स्टेक / फ़ैरो के लिए स्टड और स्टडआउट के नाम भिन्न हो सकते हैं।

Stdin nextLine subStrings do:[:w|(w count:[:c|c isVowel])print.' 'print]

स्मॉलटाकल / एक्स (और कई अन्य बोलियों) में, प्रतीक # भाव को समझते हैं :, इसलिए इसे 66 वर्णों तक संक्षिप्त किया जा सकता है:

 Stdin nextLine subStrings do:[:w|(w count:#isVowel)print.' 'print]

यदि एक फ़ंक्शन के रूप में कोडित किया जाता है जो तर्क "s" के रूप में स्ट्रिंग प्राप्त करता है:

[:s|s subStrings do:[:w|(w count:#isVowel)print.' 'print]]

बेशक, वास्तविक कोड में, एक उपयोगिता फ़ंक्शन "एफ" का उपयोग करेगा, जो कि गिनती के एक वेक्टर को लौटाता है, और प्रिंट करता है। हालाँकि, आउटपुट स्वरूप तब ठीक वैसा नहीं है जैसा कि चुनौती ने पूछा था:

f := [:s|s subStrings collect:[:w|(w count:#isVowel)]].
(f value: Stdin nextLine) print.

— blabla999
स्रोत

1

पायथन 2, 76 बाइट्स

मैंने इससे पहले कि मैंने कोई अन्य समाधान देखा, फिर दो पी 3 समाधानों को खोजने के लिए जाँच की जो छोटे हैं :( डैरन पी 2 सीमाएं।

print' '.join(`sum(y in'aeiouAEIOU'for y in x)`for x in raw_input().split())

— Kade
स्रोत

1

पॉवरशेल, 65 बाइट्स

($input-split'\s'|%{($_-split''-match'a|e|i|o|u').count})-join' '

निम्न के रूप में सहेजने के बाद पैटर्न का उपयोग करके परीक्षण करें vowels.ps1

"the quick brown fox" | vowels.ps1

इस तरह यह एक वास्तविक स्क्रिप्ट है और न केवल एक कोड स्निपेट है जिससे संतोषजनक बाधाएं होती हैं:

"स्टड या कमांड लाइन तर्कों से इनपुट का उपभोग किया जाना चाहिए।"

— Bevo
स्रोत

1

जेली , 7 बाइट्स

Ḳf€ØcL€

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

चैट में मिस्टर एक्सकोडर की मदद से मिला

व्याख्या

Ḳf€ØcL€ - Main link. Argument: s (a string)  e.g. "aeiou AEIOU"
Ḳ       - Split the input on spaces               ["aeiou", "AEIOU"]
   Øc   - Generate the string "AEIOUaeiou" 
 f€     - Filter out consonants from €ach         ["aeiou", "AEIOU"]
     L€ - Length of €ach                          [5, 5]

यदि आउटपुट स्पेस-अलग होना चाहिए, तो Kअंत में संलग्न करें

— केर्ड सिक्काहिरिंग
स्रोत

0

एसएएस, 72

data;infile stdin;file stdout;input c$@@;x=countc(c,'aeiou','i');put x@;

इसके लिए प्रतिबंधात्मक I / O प्रारूप वास्तव में इसको चोट पहुँचाता है क्योंकि यह 25 बाइट्स के लिए जिम्मेदार है।

— तला हुआ अंडा
स्रोत

0

सी # 186

public class a{public static void Main(string[] a){Console.Write(string.Join(" ",Console.ReadLine().Split(' ').Select(x=>x.ToCharArray().Count(y=>"aeoui".ToCharArray().Contains(y)))));}}

— DLeh
स्रोत

यह तीसरे परीक्षण के मामले में विफल रहता है। आपका कार्यक्रम गिनती के लिए प्रतीत नहीं होता है AEIOU।

— स्पिकट्रिक्स

एक तार के प्रत्येक शब्द में स्वरों की संख्या गिनें

चुनौती

नियम

परीक्षण के मामलों

स्कोरिंग

पायथ, 17 बाइट्स

स्पष्टीकरण:

सी, 113 108 103 96 बाइट्स

CJam, 21 19 बाइट्स

आर, 44 43 बाइट्स

पर्ल, 35 34 31

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

पर्ल: 30 अक्षर

पर्ल: 27 अक्षर

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

जावास्क्रिप्ट ( ईएस 6 ), 68

Rebol - 70

पॉवरशेल, 35 बाइट्स

बैश - 85

व्याख्या

जूलिया, 76 72 69 65 बाइट्स

गणितज्ञ, 95 बाइट्स

गोल्फलुआ, 55 बाइट्स

आर , 139 बाइट्स

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

PHP - 94

उद्देश्य-सी, 223 बाइट्स

मतलाब, 73 बाइट्स

आरएस , 50 बाइट्स

पर्ल, 60 45

हास्केल, 76 68 बाइट्स

केडीबी (क्यू), 30 बाइट्स

व्याख्या

परीक्षा

स्मालटाक - 66 72

पायथन 2, 76 बाइट्स

पॉवरशेल, 65 बाइट्स

जेली , 7 बाइट्स

व्याख्या

एसएएस, 72

सी # 186