Dies ist eine ziemlich einfache Herausforderung.

Herausforderung

Die Eingabe enthält eine Zeichenfolge (nicht nulloder leer) mit einer maximalen Länge von 100. Geben Sie die Anzahl der Vokale in jedem Wort der Zeichenfolge aus, die durch Leerzeichen getrennt sind.

Regeln

• Die Zeichenfolge darf nicht länger als 100 Zeichen sein.
• Die Zeichenfolge wird nur Alphabete enthalten A-Z, a-zund kann auch Leerzeichen enthalten.
• Die Eingabe muss über die stdinBefehlszeilenargumente oder erfolgen.
• Die Ausgabe muss im erfolgen stdout.
• Sie können ein vollständiges Programm oder eine Funktion schreiben, die Eingaben von dem Programm entgegennimmt stdinund das Ergebnis ausgibt.
• Die Vokale, die Ihr Programm / Ihre Funktion zählen muss, sind aeiouund AEIOU.

Testfälle

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

Wertung

Dies ist Code-Golf , also gewinnt die kürzeste Einreichung (in Bytes).

Pyth, 17 Bytes

jdml@"aeiou"dcrzZ

Einfache Lösung. Probieren Sie es online aus: Vorführ- oder Testgeschirr

Erläuterung:

               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

C 113 108 103 96 Bytes

Danke @ andrea-biondo für eine besonders schöne 5-Byte-Speicherung.

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

Das fühlt sich immer noch etwas aufgebläht an, so dass ich es hoffentlich später noch ein paar Bytes runterholen kann.

Der interessante Teil ist vielleicht das

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

wird sein, 1wenn cein (Groß- oder Kleinschreibung) ASCII-Vokal ist, und 0für andere Zeichen a-zA-Z. Die subexpression c-65&31abbildet 'a'und 'A'zu 0, 'b'und 'B'zu 2usw. Wenn wir hinzufügen , 33die Vokale zu den Zahlen entsprechen 33, 37, 41, 47, 53jeweils alle sind (bequem) prime. In unserem Sortiment teilen sich nur solche Zahlen124701951 = 33*37*41*47*53 , dh nur für Vokale wird der Rest von124701951%(...) Null.

BEARBEITEN: Auf diese Weise kann man den Ausdruck !(n%((c-65&31)+s))wo (n,s) = (124701951, 33)als Bestimmung betrachten, ob das Zeichen cein Vokal ist. In den Kommentaren @ andrea-biondo darauf hingewiesen, dass das Paar(n,s) = (2016,28) auch in diesem Ausdruck verwendet werden kann, um die Vokalität zu bestimmen. Ich lasse die aktuelle Erklärung in Bezug auf die obigen Primzahlen, aber der Grund, warum diese kürzere Paarung funktioniert, ist wieder, dass im Bereich von 28 bis 53 die einzigen Zahlen mit Primfaktoren, die vollständig in der Primfaktorsammlung von 2016 enthalten sind, 28, 32 sind. 36, 42, 48, die genau den Vokalen entsprechen.

EDIT2: Weitere 5 Bytes, die seitdem gespeichert wurden, (c-65&31)+28können auf gekürzt werdenc%32+27 .

EDIT3: In eine do-while-Schleife konvertiert, um sie endlich unter 100 Bytes zu bringen.

Testfälle:

$ ./vowelc "Dies ist der erste Testfall"
1 1 1 1 1 2 
$ ./vowelc "eins plus zwei gleich drei"
2 1 1 3 2 
$ ./vowelc "aeiou AEIOU"
5 5 
$ ./vowelc "psst"                     
0

CJam, 21 19 Bytes

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

Wie es funktioniert :

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

Probieren Sie es hier online aus

R, 44 43 Bytes

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

Ungolfed + Erklärung:

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

Perl, 35 34 31

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

30Zeichen +1für -n.

Wie viel Perl-Code funktioniert dies von rechts nach links. splitteilt die eingegebene Zeile auf Leerzeichen. mapFührt den Code zwischen {}jedem Wort aus, das geteilt wurde. lcmacht das Wort klein. =~y/aeiou//wird uns die Anzahl der Vokale geben. .$"wird ein Leerzeichen an das Wort anhängen. saydann druckt alle Wörter!

Laufen mit:

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

Python 3, 65 Bytes

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

Sehr einfach, ziemlich lesbar. wsteht für Wort, csteht für Charakter.

Perl: 30 Zeichen

(Art erzwingt die Regeln: Die Zahlen in der Ausgabe werden mit so vielen Leerzeichen getrennt, wie die Eingabewörter waren.)

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

Probelauf:

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

Perl: 27 Zeichen

(Nur um zu zeigen, wie kurz es wäre, wenn ich den y///Rückgabewert von chilemagic nicht vergessen würde . Nochmals. Jetzt stimme der Antwort von chilemagic zu , die mich an y///den Rückgabewert von chilemagic erinnert . Nochmals.)

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

Ruby, 38 Bytes

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

Verwendung:

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

JavaScript ( ES6 ), 68

I / O über Popup. Führen Sie das Snippet zum Testen in Firefox aus.

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

Rebol - 70

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

PowerShell, 35 Byte

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

Irgendwie langweilig, aber tatsächlich einmal im Wettbewerb? (PowerShell unterscheidet standardmäßig zwischen Groß- und Kleinschreibung.)

Bash - 85

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

Erläuterung

• read l Liest eine Zeile von der Eingabe
• for w in l Teilt die Zeile mit dem Leerzeichen-Trennzeichen in Wörter
• x=${w//[^aouieAOUIE]/} löscht alle außer Vokalen aus dem Wort
• ${#x} ist die Länge der resultierenden Zeichenfolge === Anzahl der Vokale

Julia, 76 72 69 65 Bytes

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

Ungolfed + Erklärung:

# 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

Dazu gehört ein einzelnes Leerzeichen, von dem mir gesagt wird, dass es legitim ist.

Mathematica, 95 Bytes

Ich werde keine Wettbewerbe gewinnen, aber ...

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

Golflua, 55 Bytes

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

Grundmusterabgleich von Vokalen nach erzwungener Kleinschreibung. Ein (ungolfed) Lua-Äquivalent wäre

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

R 139 Bytes

Stdout () lesen / schreiben ist schrecklich

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

Python 3, 72 Bytes

Inspiriert von der Antwort von @randomra . Die Länge ist etwas länger, es wird jedoch Regex anstelle des Listenverständnisses verwendet. Es ist auch weniger lesbar.

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

PHP - 94

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

Ungolfed-Version

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

Objective-C, 223 Bytes

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

Nicht die kompakteste Sprache, aber es funktioniert.

Unkomprimierte Version:

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

Matlab, 73 Bytes

Ihre Herausforderung ist nicht sehr klar (aber es ist interessant). Ich gehe davon aus

• Mit "Vokal" Sie meinen a, e, i, o, u.
• Die Zeichenfolge enthält keine führenden oder nachfolgenden Leerzeichen

Code:

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

rs , 50 bytes

Das zählt nicht ganz; rs wurde ungefähr 2 Wochen nach der Veröffentlichung hochgeladen. Offensichtlich würde dies jedoch sowieso nichts gewinnen, so ist es immer noch cool.

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

Live-Demo.

Die Implementierung ist ziemlich einfach:

*[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).

Perl, 60 45

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

Danke an kirbyfan64sos für das Speichern von 15 Bytes - das hat wirklich geholfen!
Beachten Sie, dass am Ende der Ausgabe ein zusätzliches Leerzeichen steht.

Haskell, 76-68 Bytes

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

Einfache Implementierung, nicht sicher, ob es hier etwas zum Golfen gibt.

KDB (Q), 30 Bytes

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

Erläuterung

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

Prüfung

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

Smalltalk - 66 72

Dies ist in Smalltalk / X; die namen für stdin und stdout können in squeak / pharo unterschiedlich sein.

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

In Smalltalk / X (und vielen anderen Dialekten) verstehen Symbole #value :.

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

Wenn als eine Funktion codiert, die den String als Argument "s" erhält:

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

Natürlich würde man in echtem Code eine Dienstprogrammfunktion "f" verwenden, die einen Vektor der Zählungen zurückgibt, und diese ausgeben. Das Ausgabeformat entspricht dann jedoch nicht genau den Anforderungen:

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

Python 2, 76 Bytes

Ich habe dies gemacht, bevor ich eine andere Lösung sah, und dann überprüft, ob zwei P3-Lösungen kürzer sind :( Verdammte P2-Einschränkungen.

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

PowerShell, 65 Byte

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

Testen Sie nach dem Speichern unter das folgende Muster vowels.ps1

"the quick brown fox" | vowels.ps1

Auf diese Weise handelt es sich um ein tatsächliches Skript und nicht nur um ein Code-Snippet, wodurch die folgenden Bedingungen erfüllt werden:

Msgstr "Die Eingabe muss über die Standard - oder Befehlszeilenargumente erfolgen."

Gelee , 7 Bytes

Ḳf€ØcL€

Probieren Sie es online!

Gefunden mit Hilfe von Mr. Xcoder im Chat

Erläuterung

Ḳ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]

Wenn die Ausgabe muss Raum getrennt sein, hängt dann Kan das Ende

SAS, 72

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

Das restriktive E / A-Format für dieses tut diesem wirklich weh, da es hier für 25 der Bytes verantwortlich ist.

C # 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)))));}}