Ваша програма повинна знайти всі слова в цьому списку слів, які містять усі голосні ( 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]

(Технічно, зважаючи на те, що виклик говорить лише про те, що код повинен працювати на цьому конкретному вкладі, n%{'aeiouy'\-!},`43ще на один символ коротший. Я вважаю, що це обман.)

Пояснення:

• n% розбиває вхід на нові рядки в масив.
• { }, є оператором "grep", виконуючи код між дужками для кожного елемента масиву і вибираючи ті, для яких він повертає справжнє значення.
  • Всередині циклу, 'aeiouy'\-бере буквальний рядок aeiouyі видаляє з нього кожен символ, знайдений у слові-кандидаті. !Потім логічно нівелює отриману рядок, отримуючи 1(істина) , якщо рядок порожня , і 0(брехня) , якщо це не так .
• .,+ робить копію відфільтрованого масиву, підраховує кількість слів у ньому та додає результат до вихідного масиву.
• Нарешті, `unvavals масив, перетворюючи його в рядкове представлення його вмісту. (Без цього слова з масиву просто об'єдналися б у виході, що призведе до нечитабельного безладу.)

GolfScript, 19 символів

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

Використання:

golfscript vowels.gs < wordlist.txt

Вихід:

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

Якщо ви також хочете вивести підрахунок в кінці, ви можете використовувати

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

що на чотири символи довше.

Пітон - 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]}

і знову (3b):

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що містить усі п’ять голосних. Для читачів, незнайомих з Рубі, %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 char, замінивши size==6на size>5.

Хаскелл - 67

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

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

("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.

Пітон, 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 жахливо "не підтвердженої" версії (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;}

Він заснований на першій відповіді, але має "поворот": Ви можете знати, скільки разів було знайдено слово.

Ви просто так робите:

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

Коштує 3 зайвих символи, щоб їх увімкнути yу вигляді плетінки.

Математика (65 або 314)

Два дуже різні підходи, кращий був запропонований Велізарієм у коментарях до моєї первинної відповіді. По-перше, мої зухвалі зусилля, які алгоритмічно генерують кожен можливий регулярний вираз, який відповідає комбінації шести голосних (включаючи "у"), а потім перевіряє кожне слово у списку цільових слів проти кожного з цих 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.

Велізарій запропонував набагато краще рішення. Припускаючи, що список слів вже підготовлений і призначений до змінної 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якого повертається , що є просто фантазійним способом запитати "чи встановити ('a','e','i','o','u','y')підмножину ( ⊆) набору, що складається з літер введення ( *.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`

Бере вхід з stdin.

sed 29 символів

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

Порядок вибраний із частоти літер у wikipedia для перевірки швидкості.

В моєму хості:

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 рази швидше, ніж тестування для порядку aeiou y. Таким чином перший тест видаляє більшу кількість слів, тож наступні тести мають менше роботи. Очевидно, це не впливає на довжину коду. Багато інших розміщених тут рішень отримали б аналогічну користь від проведення тестів у цьому порядку.

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

Без гольфу:

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

Малий розмова (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 знаків (з вилученим пробілом видалено).

оновлено: непотрібні пробіли видалено

Дуже повільно, але в такт (81 символи):

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

EDIT: 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];}

І я також хотів би зазначити, що ваш гольф, здається, не знаходить усіх випадків голосних.

Безголівки:

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-Різкий

Я ніколи цього не робив, і я не зовсім впевнений, що таке процедури розміщення. Але ось що я придумав:

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= a 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 + 49c хв}

Це створює перерахування, що містить усі слова, які містять усі голосні.

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

Математика - 136 102

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

Скорочене посилання переходить до http://www.mieliestronk.com/corncob_lowercase.txt