Seu programa deve encontrar todas as palavras nesta lista de palavras que contenham todas as vogais ( a e i o u y). Existem maneiras fáceis de fazer isso, mas estou procurando a resposta mais curta. Vou usar qualquer idioma, mas gostaria de ver o Bash.

Aqui está um exemplo (poderia ser muito melhorado):

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

Sua pontuação é o comprimento do código.

-5 pontos para contar todas as ocorrências da palavra.

Menor pontuação ganha.

GolfScript, 20 caracteres - 5 = 15 pontos

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

Com base na solução de Howard , mas usando um teste mais curto ( \-!economiza um caractere mais &,6=), anexos de comprimento mais curtos ( .,+= 3 caracteres) e formatação de saída mais curta (ninguém disse que a saída tinha que ser separada por nova linha, portanto, `economiza um caractere n*).

Aqui está a saída, considerando a lista de palavras em minúsculas como entrada (quebras de linha inseridas para facilitar a leitura):

["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. Tecnicamente, dado que o desafio diz apenas que o código precisa trabalhar para essa entrada específica, n%{'aeiouy'\-!},`43seria um caractere mais curto ainda. Porém, considero que trapaça.)

Explicação:

• n% divide a entrada em novas linhas em uma matriz.
• { }, é um operador "grep", executando o código entre chaves entre cada elemento da matriz e selecionando aqueles para os quais ele retorna um valor verdadeiro.
  • Dentro do loop, 'aeiouy'\-pega a string literal aeiouye remove todos os caracteres encontrados na palavra candidata. Em !seguida, nega logicamente a string resultante, produzindo 1(true) se a string está vazia e 0(false) se não estiver.
• .,+ faz uma cópia da matriz filtrada, conta o número de palavras e anexa o resultado à matriz original.
• Por fim, `desvaloriza a matriz, convertendo-a em uma representação de string de seu conteúdo. (Sem ele, as palavras na matriz seriam simplesmente concatenadas na saída, produzindo uma confusão ilegível.)

GolfScript, 19 caracteres

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

Uso:

golfscript vowels.gs < wordlist.txt

Saída:

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

Se você também quiser exibir a contagem no final, poderá usar

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

que tem mais quatro caracteres.

Python - 46 caracteres

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

Versão legível: já é bastante legível :-)

APL, 21-5 = 16

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

Espera encontrar a lista de palavras como w. Retorna uma lista das palavras que contêm todas as vogais, além de sua contagem. Testado com ngn apl . Aqui está um exemplo .

Explicação

         '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

Ruby 38

Edição 34: Melhor até agora (da @OI):

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

Edit 1: Acabei de notar que a pergunta solicitada para 'y' ser incluída entre as vogais, por isso editei minha pergunta de acordo. Como @Nik apontou em um comentário para sua resposta, "aeiouy".charsum caractere é menor que%w[a e i o u y] , mas deixarei o último por diversidade, mesmo que eu esteja arriscando pesadelos com a oportunidade perdida.

Edição 2: Agradecemos à @OI por sugerir a melhoria:

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

que salva 11 caracteres do que eu tinha antes.

Edite 3 e 3a: a @OI interrompe mais algumas:

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

then

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

e novamente (3b):

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

Eu sou um mero escriba!

Aqui estão mais duas soluções pouco complexas:

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

Inicialmente tive:

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

sé uma sequência que contém as palavras, separadas por novas linhas. Uma matriz de palavras scontendo as cinco vogais é retornada. Para leitores não familiarizados com Ruby %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]e com &interseção de matriz.

Suponha

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

No bloco {...}, inicialmente

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,

então "abreviações" não está selecionada.

Se a sequência spode conter duplicatas, s.split.select...pode ser substituída por s.split.uniq.select...para remover duplicatas.

Só notei que eu poderia salvar 1 caractere substituindo size==6por size>5.

Haskell - 67

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

Ruby - 28 caracteres (ou 27 se yfor excluído das vogais)

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

O comando completo a ser executado é (48 caracteres):

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

EDIT: substituído putspor pconforme sugerido por @CarySwoveland

AWK - 29

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

Para executar: salve a lista de palavras em minúsculas em wordlist.txt. Então faça:

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

Se o seu sistema não possuir mawk, também awkpode ser usado.

Você também pode executá-lo a partir de um arquivo, salvando o programa em program.awke executando mawkor awk -f program.awk.

Python, 45 caracteres

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

k [22-5 = 17 caracteres]

Renomeei o arquivo "corncob_lowercase.txt" para "w"

Conte as palavras [22 caracteres]

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

Saída

43

Encontre todas as palavras [25 caracteres]

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

No geral 43 palavras contendo todas as vogais (a e i o u y)

Saída

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

Bytes Javascript / JScript 147 (152-5), 158 (163-5) ou 184 (189-5):

Aqui está minha versão Javascript e JScript horrivelmente "não-golfizada" (164 152 152-5 = 147 bytes):

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

Obrigado @GaurangTandon pela search()função, que me salvou um byte!

RegExp baseado em desempenho HORRÍVEL , mas suporta letras maiúsculas e minúsculas (163-5 = 158 bytes):

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 com melhor desempenho, MAS leva muito mais bytes (189-5 = 184 bytes):

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

Este é apenas por diversão (175-5 bytes) e não conta como resposta:

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

Baseia-se na 1ª resposta, mas tem uma "reviravolta": você pode saber quantas vezes uma palavra foi encontrada.

Você simplesmente faz assim:

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

Desde que length não tem todas as vogais, não será excluído e ainda seria uma resposta para o bônus.

Como você chama isso?

"Simples": você quebra a função por dentro ()e depois adiciona('string goes here'); ao final.

Como isso: (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');

Este exemplo retornará uma matriz apenas com 1 string: yoiuae

Eu sei que esta é a pior solução, mas funciona!

Por que estou contando -5?

Bem, matrizes Javascript / JScript têm uma propriedade ( length) em matrizes que informa o número de elementos que ela possui.

Depois de confirmado na pergunta, o bônus de -5 é para dizer o número de palavras.

Como o número de palavras está nessa propriedade, automaticamente tenho a pontuação de -5.

Ruby 39 38

Atualmente, a menor entrada Ruby ao contar todo o programa, incluindo entrada e saída.

Salve um char usando em mapvez de each:

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

Outra versão, 39 caracteres com saída mais bonita:

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

Ambos os programas recebem entrada de stdin ou como um nome de arquivo passado como argumento de linha de comando:
$ ruby wovels.rb wordlist.txt

Custa 3 caracteres extras para inclyde ycomo um wovel.

Mathematica (65 ou 314)

Duas abordagens muito diferentes, a melhor foi proposta por Belisarius nos comentários à minha resposta inicial. Primeiro, meu esforço brutal, que gera algoritmicamente todas as expressões regulares possíveis que correspondem a uma combinação de seis vogais (incluindo "y") e, em seguida, verifica cada palavra na lista de palavras de destino em relação a cada uma dessas 720 expressões regulares. Funciona, mas não é muito conciso e é lento.

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 caracteres. Alguns podem ser salvos usando notação alternativa, e caracteres adicionais são perdidos ao preparar o arquivo de dicionário como uma lista de strings (o formato natural do dicionário no Mathematica. Outros idiomas podem não precisar dessa preparação, mas o Mathematica precisa). Se omitirmos essa etapa, presumindo que ela tenha sido tratada por nós, a mesma abordagem pode ser feita com menos de 250 caracteres e, se usarmos o dicionário interno do Mathematica, obteremos economias ainda maiores,

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

Menos de 200 caracteres. Contar o número de palavras encontradas requer apenas passar o resultado para Length[Flatten[]], que pode ser adicionado ao redor de qualquer bloco de código acima ou pode ser feito posteriormente com, por exemplo,Length@Flatten@% ,. A lista de palavras especificada para esse desafio fornece 43 correspondências e o dicionário Mathematica fornece 64 (e é muito mais rápido). Cada dicionário possui palavras correspondentes que não estão no outro. O Mathematica localiza "profissionalmente", por exemplo, que não está na lista compartilhada, e a lista compartilhada encontra "eucariótico", que não está no dicionário do Mathematica.

Belisarius propôs uma solução muito melhor. Supondo que a lista de palavras já tenha sido preparada e atribuída à variável l, ele define um único teste com base na StringFreeQ[]função do Mathematica e aplica esse teste à lista de palavras usando oPick[] função 65 caracteres, e é cerca de 400 vezes mais rápido que a minha abordagem.

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

Perl 6 - 35 caracteres

Inspirado na solução Ruby de @CarySwoveland:

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

Isso seleciona ( greps) cada linha que retorna Truepara <a e i o u y> ⊆ *.comb, que é apenas uma maneira elegante de pedir "é o conjunto('a','e','i','o','u','y') um subconjunto ( ⊆) do conjunto constituído pelas letras do input ( *.comb)?"

Na verdade, ambos <a e i o u y>e *.combapenas criam Lists:⊆ (ou (<=)se você estiver preso em ASCII) os transforma em Sets para você.

Para obter o número de linhas impressas, esse script de 42 caracteres - 5 = 37 pontos também produzirá isso:

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

C - 96 bytes

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

Salvei vários bytes de parênteses graças a uma feliz coincidência de precedência do operador.

Javascript - Pontuação = 124 - 5 = 119 !!!

Edição: 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}

Muito obrigado a @Ismael Miguel por me ajudar a cortar ~ 12 caracteres !

Eu removi o formulário da função de notação de seta gorda porque, embora eu tenha visto o uso inicial, ele não funciona. Não faço ideia porque ...

Para fazer funcionar:

Passe todas as palavras separadas por nova linha como argumento para a função, como mostrado abaixo.

Teste:

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

Recebe entrada de stdin.

sed 29 chars

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

Ordem escolhida entre Frequência de letras na wikipedia para acelerar a verificação.

No meu host:

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

e

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

Bash (grep) - 36 bytes

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

Observe a ordem das vogais testadas, menos frequentes primeiro. Para o caso de teste, isso é executado cerca de três vezes mais rápido que o teste, na ordem seguinte. Dessa forma, o primeiro teste remove um número maior de palavras, para que os testes subsequentes tenham menos trabalho a fazer. Obviamente, isso não afeta o comprimento do código. Muitas das outras soluções postadas aqui se beneficiariam de maneira semelhante ao realizar os testes nesta ordem.

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

Sem golfe :

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

Uso :C:\>rdmd vowels.d wordlist.txt

wordlist.txt deve conter as palavras da lista em minúsculas.

Rebol (104 caracteres)

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

Sem golfe:

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

dagora contém lista de palavras encontradas. Aqui está um exemplo do console 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 caracteres)

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

para obter a contagem, envie #size para a coleção resultante. A coleção de resultados contém 43 palavras ('abstemiously' 'com autoridade' ... 'inquestionavelmente' 'irreconhecivelmente')

O código acima tem 77 caracteres, mas eu poderia ter renomeado o arquivo da lista de palavras para 'w', então conto o nome do arquivo como 1, o que resulta em uma pontuação de 57.

A leitura do arquivo faz parte do problema ou não? Caso contrário (veja outros exemplos), e a lista de palavras já está em uma coleção c, o código será reduzido para:

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

que é de 36 caracteres (com espaço em branco omitível removido).

atualizado: espaços desnecessários removidos

Muito lento, mas no bash (81 caracteres):

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

EDIT: echo $l|fold -w1substituído por fold -w1<<<$lconforme sugerido por @ nyuszika7h

JavaScript - 95 bytes

Aqui está o meu golfe.

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

E também gostaria de salientar que seu golfe não parece encontrar todas as ocorrências de vogais.

Ungolfed:

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

ordenar + uniq + sed

Este não corresponde a ocorrências repetidas de uma palavra. Também não corresponde à letra 'y' se ocorrer no início de uma palavra.

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' 

Bater

Não tão curto quanto o OP, mas uma linha no 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)))));}}

Formatado:

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

Agora não está com disposição para implementar a contagem, mas deve ser fácil. O caminho para a (versão em minúscula da) lista de palavras deve ser passado ao programa como primeiro argumento:

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

Saída:

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

Tomei a liberdade de produzir e separar vírgulas; nenhum dos quais está especificado nas regras (qual estado "deve encontrar todas as palavras", não como (e SE) como saída).

Incluindo contagem (+ saída): 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());}}

Saída:

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

(Observe a contagem no final: 43)

Nenhuma saída ("deve encontrar todas as palavras"): 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)));}}

(Dobra as regras um bit e depois novamente: não realmente) Isso localiza todas as palavras e a contagem está disponível executando r.Count().

C-Sharp

Eu nunca fiz isso antes e não sei exatamente quais são os procedimentos de postagem. Mas é isso que eu vim com:

185 bytes

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>de todas as palavras.

se você deseja exibir um total:

219 - 5 = 214 bytes

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 (pontuação 91 = 96c - 5) _{* 0}

_{* 0 + 49c min}

Isso cria uma enumeração que contém todas as palavras que contêm todas as vogais.

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

O link abreviado vai para http://www.mieliestronk.com/corncob_lowercase.txt