Ваша программа должна найти все слова в этом списке слов, которые содержат все гласные ( a e i o u y). Есть простые способы сделать это, но я ищу кратчайший ответ. Я возьму любой язык, но я бы хотел увидеть Баш.

Вот пример (может быть значительно улучшен):

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

Ваша оценка - это длина кода.

-5 баллов за подсчет всех вхождений слова.

Самый низкий балл побеждает.

GolfScript, 20 символов - 5 = 15 баллов

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

Основано на решении Говарда , но с использованием более короткого теста ( \-!экономит один символ &,6=), более короткого добавления длины ( .,+= 3 символа) и более короткого форматирования вывода (никто не говорил, что вывод должен быть разделен символом новой строки, поэтому `сохраняется один символ 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было бы еще на один символ короче. Хотя я считаю, что измена.)

Объяснение:

• n% разбивает ввод на новых строках в массив.
• { }, является оператором "grep", выполняющим код в фигурных скобках для каждого элемента массива и выбирающим те, для которых он возвращает истинное значение.
  • Внутри цикла '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@,

который на четыре символа длиннее.

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это на один символ меньше %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]}

и снова (3б):

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

Я простой писец!

Вот еще два неконкурентных решения:

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это строка, содержащая слова, разделенные символом новой строки sВозвращается массив слов , содержащий все пять гласных. Для читателей , не знакомых с Ruby, %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...чтобы удалить дубликаты.

Просто заметил, что я могу сохранить 1 символ, заменив size==6на size>5.

Haskell - 67

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

Рубин - 28 символов (или 27, если yисключен из гласных)

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

Полная команда для запуска (48 символов):

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

РЕДАКТИРОВАТЬ: заменено putsна, pкак предложено @CarySwoveland

AWK - 29

/ А / && / е / && / я / && / о / && / и / && / у /

Для запуска: сохраните список слов в нижнем регистре в 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)]

к [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 чудовищно "негольфированная" версия (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()функцию, которая спасла мне байт!

RegExp основан на производительности HORRIBLE , но поддерживает прописные и строчные буквы (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;}

RegExp, основанный на ЛУЧШЕЙ производительности, НО занимает намного больше байтов (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;}

Он основан на 1-м ответе, но имеет «поворот»: вы можете знать, сколько раз было найдено слово.

Вы просто делаете это так:

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.

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

Обе программы получают ввод из стандартного ввода или в виде имени файла, передаваемого в качестве аргумента командной строки:
$ ruby wovels.rb wordlist.txt

Стоит добавить 3 дополнительных символа yв качестве ткацкого ореха.

Mathematica (65 или 314)

Два совершенно разных подхода, лучший из которых был предложен Велисарием в комментариях к моему первоначальному ответу. Во-первых, мое грубое усилие, которое алгоритмически генерирует каждое возможное регулярное выражение, которое соответствует комбинации из шести гласных (включая «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 находит, например, «непрофессионально», которого нет в общем списке, а общий список находит «eukaryotic», которого нет в словаре Mathematica.

Велисарий предложил гораздо лучшее решение. Предполагая, что список слов уже подготовлен и назначен переменной l, он определяет один тест на основе StringFreeQ[]функции Mathematica , а затем применяет этот тест к списку слов с помощью Pick[]функции. 65 символов, и это примерно в 400 раз быстрее, чем мой подход.

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

Perl 6 - 35 символов

Вдохновленный решением Ruby @CarySwoveland:

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

Это выбирает ( grepы) каждую строку, Trueдля <a e i o u y> ⊆ *.combкоторой возвращается , что является просто причудливым способом спросить: «Является ли Set ('a','e','i','o','u','y')подмножеством ( ⊆) Set, составленным из букв input ( *.comb)?»

На самом деле, оба <a e i o u y>и *.combтолько создают Lists: ⊆(или (<=)если вы застряли в 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`

Принимает ввод от стандартного ввода.

Сед 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

Bash (grep) - 36 байт

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

Обратите внимание на порядок проверки гласных, в первую очередь наименее часто встречающихся. Для тестового примера это выполняется примерно в 3 раза быстрее, чем тестирование в порядке. Таким образом, первый тест удаляет большее количество слов, поэтому последующим тестам меньше работы. Очевидно, что это не влияет на длину кода. Многие другие решения, опубликованные здесь, также выиграют от выполнения тестов в этом порядке.

Д - 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 должен содержать строчный список слов.

Реболь (104 символа)

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

Un-golfed:

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 слова ( «воздержанно» «авторитетно» ... «несомненно,» «неузнаваемо»)

Приведенный выше код содержит 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

РЕДАКТИРОВАТЬ: echo $l|fold -w1заменено на, fold -w1<<<$lкак предложено @ nyuszika7h

JavaScript - 95 байт

Вот мой гольф.

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

И я также хотел бы отметить, что ваш гольф, кажется, не встречает все случаи появления гласных.

Ungolfed:

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

сортировать + uniq + sed

Этот не соответствует повторным вхождениям слова. Оно также не соответствует букве «у», если оно встречается в начале слова.

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' 

удар

Не такой короткий, как ОП, но одна строка в Bash:

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

Я взял на себя смелость выводить и разделять запятыми слова; ни то, ни другое не указано в правилах (какое состояние «должно найти все слова», а не то, как (и ЕСЛИ) выводить).

Включая счет (+ вывод): 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-Sharp

Я никогда не делал этого раньше, и я не совсем уверен, каковы процедуры размещения. Но вот что я придумал:

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> из всех слов.

если вы хотите отобразить итог:

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 = 96с - 5) _{* 0}

_{* 0 + 49с мин}

Это создает перечисление, содержащее все слова, которые содержат все гласные.

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