プログラムは、この単語リストですべての母音（a e i o u y）を含むすべての単語を見つける必要があります。これを行う簡単な方法はありますが、最短の答えを探しています。私はどんな言語でも取りますが、Bashを見たいです。

次に例を示します（大幅に改善される可能性があります）。

cat wordlist.txt | grep "a" | grep "e" | grep "i" | grep "o" | grep "u" | grep "y"

あなたのスコアはコードの長さです。

単語のすべての出現をカウントするための-5ポイント。

最低スコアが勝ちます。

GolfScript、20文字-5 = 15ポイント

n%{'aeiouy'\-!},.,+`

ハワードのソリューションに基づきますが、短いテスト（\-!1文字を節約&,6=）、短い長さの追加（.,+= 3文字）、および短い出力フォーマットを使用します（出力を改行で区切る必要があると述べたため、`1文字を節約しますn*）。

入力として小文字の単語リストを指定した場合の出力を次に示します（読みやすくするために改行が挿入されています）。

["abstemiously" "authoritatively" "behaviourally" "consequentially" "counterrevolutionary"
"disadvantageously" "educationally" "encouragingly" "eukaryotic" "evolutionarily"
"evolutionary" "exclusionary" "facetiously" "gregariously" "heterosexuality" "homosexuality"
"importunately" "inconsequentially" "instantaneously" "insurrectionary" "intravenously"
"manoeuvrability" "neurologically" "neurotically" "ostentatiously" "pertinaciously"
"precariously" "precautionary" "questionably" "revolutionary" "simultaneously"
"supersonically" "tenaciously" "uncomplimentary" "uncontroversially" "unconventionally"
"undemocratically" "unemotionally" "unequivocally" "uninformatively" "unintentionally"
"unquestionably" "unrecognisably" 43]

（Ps。技術的には、この特定の入力に対してコードが機能しなければならないというチャレンジn%{'aeiouy'\-!},`43を考えると、まだ1文字短くなります。

説明：

• n% 改行の入力を配列に分割します。
• { }, 「grep」演算子は、配列の各要素の波括弧の間のコードを実行し、true値を返す要素を選択します。
  • ループ内で、'aeiouy'\-リテラル文字列aeiouyを取得し、候補単語で見つかったすべての文字を削除します。!その後、論理的に得、結果の文字列を否定する1文字列が空である場合（真）0そうでない場合（偽）。
• .,+ フィルターされた配列のコピーを作成し、その配列内の単語数をカウントし、元の配列に結果を追加します。
• 最後に、`配列を無効にし、その内容の文字列表現に変換します。（それなしでは、配列内の単語は出力内で単純に連結され、読み取り不能な混乱が生じます。）

GolfScript、19文字

n%{'aeiouy'&,6=},n*

使用法：

golfscript vowels.gs < wordlist.txt

出力：

abstemiously
authoritatively
behaviourally
[...]
uninformatively
unintentionally
unquestionably
unrecognisably

最後にカウントも出力したい場合は、使用できます

n%{'aeiouy'&,6=},.n*n@,

これは4文字長くなります。

Python-46文字

filter(lambda x:set(x)>=set("AEIOUY"),open(f))

読み取り可能なバージョン：すでにかなり読みやすいです:-)

APL、21-5 = 16

(,≢)w/⍨∧⌿'aeiouy'∘.∊w

として単語のリストを見つけることを期待しますw。すべての母音とそのカウントを含む単語のリストを返します。ngn aplでテスト済み。以下に例を示します。

説明

         'aeiouy'∘.∊w   # generate a truth table for every vowel ∊ every word
       ∧⌿               # reduce with ∧ along the rows (vowels)
    w/⍨                 # select the words that contain all the vowels
(,≢)                    # hook: append to the list its own tally

ルビー38

編集34：これまでのベスト（@OIから）：

a.split.select{|w|'aeiouy'.count(w)>5} 

編集1：「y」を母音に含めるように求められる質問に気付いたので、それに応じて質問を編集しました。@Nikが彼の答えへのコメントで指摘したように、私は機会よりも悪夢を危険にさらしているにもかかわらず、多様性のために、後者"aeiouy".charsよりも1文字少ない%w[a e i o u y]です。

編集2：改善を提案してくれた@OIに感謝：

s.split.select{|w|'aeiouy'.delete(w)==''}

これにより、以前の11文字を節約できます。

編集3および3a：@OIはさらにいくつかの成果を上げました。

s.split.select{|w|'aeiouy'.tr(w,'')==''}

それから

s.split.reject{|w|'aeiouy'.tr(w,'')[1]}

そして再び（3b）：

a.split.select{|w|'aeiouy'.count(w)>5} 

私は単なる筆記者です！

以下に、2つの非競合的なソリューションを示します。

s.split.group_by{|w|'aeiouy'.delete(w)}['']       (43)
s.gsub(/(.+)\n/){|w|'aeiouy'.delete(w)==''?w:''} (48)

最初に私が持っていた：

s.split.select{|w|(w.chars&%w[a e i o u y]).size==6}

s改行で区切られた単語を含む文字列です。s5つの母音すべてを含む単語の配列が返されます。ルビーに不慣れな読者のために、%w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]及び&配列交点です。

仮に

s = "abbreviations\nabduction\n"
s.split #=> ["abbreviations", "abduction"] 

ブロック{...}では、最初は

w             #=> "abbreviations"
w.chars       #=> ["a", "b", "b", "r", "e", "v", "i", "a", "t", "i", "o", "n", "s"]
w.chars & %w[a e i o u y] #=> ["a", "e", "i", "o"]
(w.chars & %w[a e i o u y]).size == 6 #=> (4 == 6) => false,

そのため、「略語」は選択されません。

文字列sに重複が含まれている可能性がある場合は、s.split.select...置換しs.split.uniq.select...て重複を削除できます。

に置き換えることsize==6で1文字節約できることに気付きましたsize>5。

ハスケル-67

main=interact$unlines.filter(and.flip map "aeiouy".flip elem).lines

Ruby-28文字（またはy母音から除外されている場合は27文字）

("ieaouy".chars-s.chars)==[]

実行する完全なコマンドは（48文字）です。

ruby -nle 'p $_ if ("ieaouy".chars-$_.chars)==[]'

EDIT：置き換えputsてp@CarySwovelandによって示唆されているように

AWK-29

/ a / && / e / && / i / && / o / && / u / && / y /

実行するには：小文字の単語リストをに保存しますwordlist.txt。次に、以下を実行します。

mawk "/ a / && / e / && / i / && / o / && / u / && / y /" wordlist.txt

お使いのシステムが持っていない場合はmawk、awk同様に使用することができます。

プログラムを保存しprogram.awkてmawkまたはを実行することにより、ファイルから実行することもできますawk -f program.awk。

Python、45文字

[w for w in open(f) if set('aeiouy')<=set(w)]

k [22-5 = 17文字]

ファイル「corncob_lowercase.txt」の名前を「w」に変更しました

単語を数える[22文字]

+/min'"aeiouy"in/:0:`w

出力

43

すべての単語を検索[25文字]

x@&min'"aeiouy"in/:x:0:`w

すべての母音を含む全体で43の単語 (a e i o u y)

出力

"abstemiously"
"authoritatively"
"behaviourally"
..
..
"unintentionally"
"unquestionably"
"unrecognisably"

Javascript / JScript 147（152-5）、158（163-5）、または184（189-5）バイト：

これが私のJavascriptとJScriptの恐ろしい「ungolfyfied」バージョン（164 152 152-5 = 147バイト）：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;}

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=6;for(z in c)i-=!!s[k].search(c[z]);i&&(r[r.length]=s[k]);}return r;}

@GaurangTandonのsearch()機能に感謝します。

HORRIBLEパフォーマンスに基づくRegExp が、大文字と小文字の両方をサポート（163-5 = 158バイト）：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=RegExp(c[z],'i').test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

正規表現はしてベースBETTERのパフォーマンス、BUT（189から5 = 184バイト）以上のバイトがかかります。

function(s,k,z,x,i,c,r,l){l=[];r=[];for(z in c='aeiouy'.split(''))l[z]=RegExp(c[z],'i');for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=l[z].test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

これは楽しみのためだけの場合（175-5バイト）であり、答えとしてカウントされません：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;}

最初の回答に基づいていますが、「ねじれ」があります。単語が何回見つかったかを知ることができます。

次のようにします。

var b=(function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;})('youaie youaie youaie youaie a word');

b.youaie //should be 4

それlengthはすべての母音を持っているわけではないので、それは削除されず、それでもボーナスの答えになります。

どうやって呼ぶの？

「シンプル」：関数を内側にラップし、最後に()追加('string goes here');します。

このような： (function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;})('a sentence youyoy iyiuyoui yoiuae oiue oiuea');

この例では、1文字列のみの配列を返します：yoiuae

私はこれが最悪の解決策であることを知っていますが、うまくいきます！

-5をカウントするのはなぜですか？

さて、Javascript / JScript配列の配列には、所有するlength要素の数を示すプロパティ（）があります。

質問で確認された後、-5のボーナスは単語数を伝えることです。

単語の数がそのプロパティにあるため、自動的に-5のスコアがあります。

ルビー39 38

現在、入力と出力を含むプログラム全体を数えるときの最短のRubyエントリ。

のmap代わりに使用して文字を保存しましたeach：

$<.map{|w|w*5=~/a.*e.*i.*o.*u/m&&p(w)}

別のバージョン、よりきれいな出力の39文字：

puts$<.select{|w|w*5=~/a.*e.*i.*o.*u/m}

どちらのプログラムも、stdinからの入力、またはコマンドライン引数として渡されるファイル名としての入力を受け取ります。
$ ruby wovels.rb wordlist.txt

yとして含めるには、追加の3文字が必要です。

Mathematica（65または314）

ベリサリウスは、2つの非常に異なるアプローチを提案しました。最初に、6つの母音（「y」を含む）の組み合わせに一致するすべての可能な正規表現をアルゴリズムで生成し、ターゲットワードリスト内のすべての単語をこれらの720の正規表現のすべてに対してチェックする残忍な努力。それは機能しますが、あまり簡潔ではなく、遅いです。

b = Permutations[{"a", "e", "i", "o", "u","y"}]; Table[
 Select[StringSplit[
  URLFetch["http://www.mieliestronk.com/corncob_lowercase.txt"]], 
  StringMatchQ[#, (___ ~~ b[[i]][[1]] ~~ ___ ~~ 
      b[[i]][[2]] ~~ ___ ~~ b[[i]][[3]] ~~ ___ ~~ 
      b[[i]][[4]] ~~ ___ ~~ b[[i]][[5]]~~ ___ ~~ b[[i]][[6]] ~~ ___)] &], {i, 1, 
  Length[b]}]

〜320文字。いくつかは代替表記を使用して保存でき、追加の文字は辞書ファイルを文字列のリストとして準備する際に失われます（Mathematicaの辞書の自然な形式。他の言語はこの準備を必要としないかもしれませんが、Mathematicaは必要です）。そのステップを省略し、処理済みであると仮定すると、250文字未満で同じアプローチを実行できます。Mathematicaの組み込み辞書を使用すると、さらに大きな節約が得られます。

Map[DictionaryLookup[(___ ~~ #[[1]] ~~ ___ ~~ #[[2]] ~~ ___ ~~ #[[3]] 
~~ ___ ~~ #[[4]] ~~ ___ ~~ #[[5]]~~ ___ ~~ #[[6]] ~~ ___) .., IgnoreCase -> True] &, 
 Permutations[{"a", "e", "i", "o", "u","y"}]]

200文字未満。見つかった単語の数をカウントするには、結果をLength[Flatten[]]に渡すだけで済みます。これは、上記のコードブロックの周りに追加するか、またはで後で実行できますLength@Flatten@%。このチャレンジに指定されたワードリストは43個の一致を提供し、Mathematica辞書は64個の一致を提供します（より高速です）。各辞書には、他の辞書にない一致する単語があります。例えば、Mathematicaは「非専門的に」、共有リストにないものを見つけ、共有リストは「真核生物」を見つけますが、これはMathematicaの辞書にありません。

Belisariusは、非常に優れたソリューションを提案しました。ワードリストがすでに準備され、変数lに割り当てられていると仮定すると、彼はMathematicaのStringFreeQ[]関数に基づいて単一のテストを定義 し、Pick[]関数を使用してこのテストをワードリストに適用します。65文字で、私のアプローチよりも約400倍高速です。

f@u_ := And @@ (! StringFreeQ[u, #] & /@ Characters@"aeiouy"); Pick[l,f /@ l]

Perl 6-35文字

@CarySwovelandのRubyソリューションに触発された：

say grep <a e i o u y>⊆*.comb,lines

これは、をgrep返す各行を選択します。これは、「セットは入力の文字で構成されたセットのサブセット（）ですか？」True<a e i o u y> ⊆ *.comb('a','e','i','o','u','y')⊆*.comb

実際には、両方<a e i o u y>を*.comb作成するだけですList：（⊆または(<=)ASCIIでスタックしている場合）は、それらをSetsに変換します。

印刷された行数を取得するには、この42文字-5 = 37ポイントスクリプトも同様に出力します。

say +lines.grep(<a e i o u y>⊆*.comb)».say

C-96バイト

 char*gets(),*i,j[42];main(p){while(p=0,i=gets(j)){while(*i)p|=1<<*i++-96;~p&35684898||puts(j);}}

演算子の優先順位が偶然一致したおかげで、数バイトの括弧を節約できました。

Javascript-スコア= 124-5 = 119 !!!

編集：17/02/14

function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z}

〜Ismael Miguel、12文字までのカットを手伝ってくれてありがとう！

太い矢印表記関数フォームを削除したのは、使用を開始したのを見たものの、機能しないためです。理由はわかりません...

動作させるには：

以下に示すように、改行で区切られたすべての単語を引数として関数に渡します。

テスト：

// string is "facetiously\nabstemiously\nhello\nauthoritatively\nbye"

var answer = (function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z})("facetiously\nabstemiously\nhello\nauthoritatively\nbye")

console.log(answer);
console.log(answer.length);

/* output ->    
    ["facetiously", "abstemiously", "authoritatively"]
    3 // count
*/

Bash + coreutils、39

eval cat`printf "|grep %s" a e i o u y`

stdinから入力を受け取ります。

sed 29文字

/y/{/u/{/o/{/i/{/a/{/e/p}}}}}

ウィキペディア上の文字の頻度から選択した順序で、チェックを高速化します。

私のホストで：

time sed -ne '/a/{/e/{/i/{/o/{/u/{/y/p}}}}}' </usr/share/dict/american-english >/dev/null 
real    0m0.046s

そして

time sed -ne '/y/{/u/{/i/{/o/{/a/{/e/p}}}}}'</usr/share/dict/american-english >/dev/null 
real    0m0.030s

バッシュ（grep）-36バイト

g=grep;$g y|$g u|$g o|$g i|$g a|$g e

テストされた母音の順序に注意してください。テストケースの場合、これはaeiou yの順序でのテストの約3倍の速度で実行されます。この方法では、最初のテストで多数の単語が削除されるため、後続のテストで実行する作業が少なくなります。明らかに、これはコードの長さに影響しません。ここに掲載されている他のソリューションの多くは、この順序でテストを行うことで同様に恩恵を受けます。

D-196

import std.regex,std.stream;void main(string[]a){auto f=new File(a[1]);while(!f.eof)if(!(a[0]=f.readLine.idup).match("(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*").empty)std.stdio.writeln(a[0]);}

ゴルフをしていない：

import std.regex, std.stream;

void main( string[] a )
{
    auto f = new File( a[1] );

    while( !f.eof )
        if( !( a[0] = f.readLine.idup ).match( "(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*" ).empty )
            std.stdio.writeln( a[0] );
}

使用法：C:\>rdmd vowels.d wordlist.txt

wordlist.txt 小文字のリスト単語を含める必要があります。

Rebol（104文字）

remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]

ゴルフをしていない：

remove-each w d: read/lines %wordlist.txt [
    6 != length? collect [foreach n "aeiouy" [if find w n [keep n]]]
]

d見つかった単語のリストが含まれるようになりました。Rebolコンソールの例を次に示します。

>> ; paste in golf line.  This (REMOVE-EACH) returns the numbers of words removed from list

>> remove-each w d: read/lines %wordlist.txt[6 != length? collect[foreach n"aeiouy"[if find w n[keep n]]]]
== 58067

>> length? d
== 43

Smalltalk（36/57文字）

'corncob_lowercase.txt' asFilename contents select:[:w | w includesAll:'aeiouy']

カウントを取得するには、結果のコレクションに#sizeを送信します。結果のコレクションには43の単語が含まれます（ 'abstemiously' 'authoritatively' ... 'unquestionably' 'unrecognisably'）

上記のコードには77文字が含まれていますが、ワードリストファイルの名前を「w」に変更できたので、ファイル名を1としてカウントし、スコア57を得ました。

ファイルの読み取りは問題の一部ですか？そうでない場合（他の例を参照）、単語のリストが既にコレクションcにある場合、コードは次のようになります。

c select:[:w | w includesAll:'aeiouy']

36文字です（省略可能な空白が削除されています）。

更新：不要なスペースが削除されました

非常に遅いが、bash（81文字）で：

while read l;do [ `fold -w1<<<$l|sort -u|tr -dc ieaouy|wc -m` = 6 ]&&echo $l;done

編集：@ nyuszika7hが示唆するようにecho $l|fold -w1置き換えられfold -w1<<<$lます

JavaScript-95バイト

これが私のゴルフです。

function f(s){return[var a=s.match(/^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/),a.length];}

また、あなたのゴルフは母音のすべての出現を見つけるようには見えないことを指摘したいと思います。

ゴルフをしていない：

function countVowels(string) {
  var regex   = /^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/;
  var matches = string.match(regex);
  var length  = matches.length;
  return [matches, length];

sort + uniq + sed

これは、単語の繰り返し出現と一致しません。また、単語の先頭にある場合、文字「y」とは一致しません。

sort wordlist.txt | uniq | sed -n '/a/p' | sed -n '/e/p' | sed -n '/i/p' | sed -n '/o/p' | sed -n '/u/p' | sed -nr '/^[^y]+y/p' 

バッシュ

OPほど短くはありませんが、Bashの1行：

while read p; do if [ $(sed 's/[^aeiouy]//g' <<< $p | fold -w1 | sort | uniq | wc -l) -eq 6 ] ; then echo $p; fi; done < wordlist.txt

C＃-170

using System.Linq;class P{static void Main(string[]a){System.Console.Write(string.Join(",",System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)))));}}

フォーマット済み：

using System.Linq;
class P
{
    static void Main(string[] a) { 
        System.Console.Write(
            string.Join(",", System.IO.File.ReadAllLines(a[0])
                .Where(w => "aeiouy".All(c => w.Contains(c))))); 
    }
}

カウントを実装する気分ではありませんが、簡単なはずです。 （小文字バージョンの）ワードリストへのパスは、最初の引数としてプログラムに渡す必要があります。

program.exe D:\foo\bar\corncob_lowercase.txt

出力：

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably

単語を出力し、コンマで区切る自由を取りました。どちらもルールに指定されていません（出力方法（およびIF）ではなく、「すべての単語を見つける必要があります」）。

カウントを含む（+出力）：192-5 = 187

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));System.Console.Write(string.Join(",",r)+" "+r.Count());}}

出力：

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably 4
3

（最後のカウントに注意してください：43）

出力なし（「すべての単語を見つける必要がある」）：137-5 = 132

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));}}

（ルールを少しずつ曲げます：実際にはそうではありません）これはすべての単語を見つけ、を実行することでカウントが利用可能になりますr.Count()。

Cシャープ

私はこれをこれまで一度もやったことがなく、投稿手順が正確にわからない。しかし、これは私が思いついたものです：

185バイト

Action<string>x=(s=>s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v)))Console.Write(w);}));using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

wordList= List<string>すべての単語のa 。

合計を表示する場合：

219-5 = 214バイト

Action<string>x=(s=>{var t=0;s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v))){Console.Write(w);t++;}});Console.Write(t);});using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

// init
var words = "";
var vowels = "aeiouy";
var total = 0;

using (var stream = new StreamReader(@"C:\corncob_lowercase.txt"))
{
    // read file
    words = stream.ReadToEnd();

    // convert word to List<string>
    var wordList = words.Split('\n').ToList();

    // loop through each word in the list
    foreach (var word in wordList)

        // check if the current word contains all the vowels
        if(vowels.All (w => word.ToCharArray().Contains(w)))
        {
            // Count total
            total += 1;
            // Output word
            Console.Write(word);
        }

    // Display total
    Console.WriteLine(total);
}

vb.net（スコア91 = 96c-5）_{* 0}

_{* 0 + 49c分}

これにより、すべての母音を含むすべての単語を含む列挙が作成されます。

Dim r=IO.File.ReadLines(a(0)).Where(Function(w)"aeiou".Intersect(w).Count=5)
Dim c=r.Count

Mathematica- 136 102

Fold[Flatten@StringCases@## &, 
Flatten@Import@"http://bit.ly/1iZE9kY",
___ ~~ # ~~ ___ & /@ Characters@"aeiouy"]

短縮リンクはhttp://www.mieliestronk.com/corncob_lowercase.txtに移動します