Su programa debe encontrar todas las palabras en esta lista de palabras que contienen todas las vocales ( a e i o u y). Hay formas fáciles de hacer esto, pero estoy buscando la respuesta más corta. Tomaré cualquier idioma, pero me gustaría ver a Bash.

Aquí hay un ejemplo (podría mejorarse mucho):

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

Tu puntaje es la longitud del código.

-5 puntos por contar todas las ocurrencias de la palabra.

La puntuación más baja gana.

GolfScript, 20 caracteres - 5 = 15 puntos

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

Basado en la solución de Howard , pero usando una prueba más corta ( \-!ahorra un carácter más &,6=), un agregado de longitud más corto ( .,+= 3 caracteres) y un formato de salida más corto (nadie dijo que la salida tuviera que separarse de la nueva línea, por lo que `ahorra un carácter más n*).

Aquí está la salida, dada la lista de palabras en minúsculas como entrada (saltos de línea insertados para facilitar la lectura):

["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. Técnicamente, dado que el desafío solo dice que el código tiene que funcionar para esta entrada específica, n%{'aeiouy'\-!},`43sería un carácter más corto todavía. Sin embargo, considero que hacer trampa).

Explicación:

• n% divide la entrada en las nuevas líneas en una matriz.
• { }, es un operador "grep", que ejecuta el código entre llaves para cada elemento de la matriz y selecciona aquellos para los que devuelve un valor verdadero.
  • Dentro del bucle, 'aeiouy'\-toma la cadena literal aeiouyy elimina de ella todos los caracteres encontrados en la palabra candidata. El !anula entonces lógicamente la cadena resultante, produciendo 1(verdadero) si la cadena está vacía y el 0(falso) si no lo es.
• .,+ realiza una copia de la matriz filtrada, cuenta el número de palabras que contiene y agrega el resultado a la matriz original.
• Finalmente, `anula la evaluación de la matriz y la convierte en una representación de cadena de su contenido. (Sin ella, las palabras en la matriz simplemente se concatenarían en la salida, produciendo un lío ilegible).

GolfScript, 19 caracteres

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

Uso:

golfscript vowels.gs < wordlist.txt

Salida:

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

Si también desea generar el recuento al final, puede usar

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

que es cuatro caracteres más largo.

Python - 46 caracteres

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

Versión legible: ya es bastante legible :-)

APL, 21 - 5 = 16

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

Espera encontrar la lista de palabras como w. Devuelve una lista de las palabras que contienen todas las vocales, más su recuento. Probado con ngn apl . Aquí hay un ejemplo .

Explicación

         '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

Rubí 38

Edición 34: Mejor hasta ahora (desde @OI):

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

Edición 1: Acabo de notar que la pregunta pedía que se incluyera 'y' entre las vocales, así que he editado mi pregunta en consecuencia. Como señaló @Nik en un comentario a su respuesta, "aeiouy".charses un personaje menor que %w[a e i o u y], pero dejaré el último, por diversidad, a pesar de que estoy arriesgando pesadillas por la oportunidad desaprovechada.

Edición 2: Gracias a @OI por sugerir la mejora:

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

que salva 11 caracteres de lo que tenía antes.

Edición 3 y 3a: @OI ha eliminado algunos más:

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

luego

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

y nuevamente (3b):

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

Soy un simple escriba!

Aquí hay dos soluciones menos competitivas:

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

Inicialmente tuve:

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

ses una cadena que contiene las palabras, separadas por nuevas líneas. Se sdevuelve una matriz de palabras que contiene las cinco vocales. Para los lectores no familiarizados con Ruby, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]y &es la intersección de la matriz.

Suponer

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

En el bloque {...}, 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,

entonces "abreviaturas" no está seleccionado.

Si la cadena spuede contener duplicados, s.split.select...puede ser reemplazada por s.split.uniq.select...para eliminar duplicados.

Sólo se dio cuenta de que podía ahorrar 1 carácter mediante la sustitución size==6con size>5.

Haskell - 67

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

Rubí: 28 caracteres (o 27 si yestá excluido de las vocales)

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

El comando completo para ejecutar es (48 caracteres):

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

EDITAR: reemplazado putspor plo sugerido por @CarySwoveland

AWK - 29

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

Para ejecutar: Guarde la lista de palabras en minúsculas en wordlist.txt. Entonces hazlo:

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

Si su sistema no tiene mawk, awkpuede usarse también.

También puede ejecutarlo desde un archivo guardando el programa program.awky haciendo mawko awk -f program.awk.

Python, 45 caracteres

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

k [22-5 = 17 caracteres]

Cambié el nombre del archivo "corncob_lowercase.txt" a "w"

Cuenta las palabras [22 caracteres]

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

Salida

43

Encuentra todas las palabras [25 caracteres]

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

En general 43 palabras que contienen todas las vocales (a e i o u y)

Salida

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

Javascript / JScript 147 (152-5), 158 (163-5) o 184 (189-5) bytes:

Aquí está mi versión de JavaScript y JScript horriblemente "no 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;}

¡Gracias @GaurangTandon por la search()función, que me ahorró un byte!

RegExp basado en un rendimiento HORRIBLE , pero admite mayúsculas y 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 basado en MEJOR rendimiento, PERO toma muchos más 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 es solo por diversión (175-5 bytes) y no contará como respuesta:

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

Se basa en la primera respuesta, pero tiene un 'giro': puede saber cuántas veces se ha encontrado una palabra.

Simplemente haces así:

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

Como eso lengthno tiene todas las vocales, no se eliminará y aún sería una respuesta para el bono.

¿Como lo llamas?

"Simple": ajusta la función dentro ()y luego la agrega ('string goes here');al final.

Me gusta esto: (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 ejemplo devolverá una matriz solo con 1 cadena: yoiuae

Sé que esta es la peor solución, ¡pero funciona!

¿Por qué estoy contando -5?

Bueno, las matrices Javascript / JScript tienen una propiedad ( length) en las matrices que indica la cantidad de elementos que tiene.

Después de ser confirmado en la pregunta, la bonificación de -5 es para decir la cantidad de palabras.

Como el número de palabras está en esa propiedad, automáticamente tengo la puntuación de -5.

Rubí 39 38

Actualmente, la entrada de Ruby más corta al contar todo el programa, incluidas las entradas y salidas.

Guardado un char usando en maplugar de each:

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

Otra versión, 39 caracteres con salida más bonita:

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

Ambos programas toman la entrada de stdin o como un nombre de archivo pasado como argumento de línea de comando:
$ ruby wovels.rb wordlist.txt

Cuesta 3 personajes adicionales para inclyde ycomo una pala.

Mathematica (65 o 314)

Dos enfoques muy diferentes, el mejor fue propuesto por Belisario en los comentarios a mi respuesta inicial. Primero, mi esfuerzo brutal, que genera algorítmicamente todas las expresiones regulares posibles que coinciden con una combinación de seis vocales (incluida "y"), y luego comprueba cada palabra en la lista de palabras objetivo con cada una de estas 720 expresiones regulares. Funciona, pero no es muy conciso y es 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. Se podrían guardar algunos mediante la notación alternativa, y se perderán caracteres adicionales al preparar el archivo del diccionario como una lista de cadenas (el formato natural para el diccionario en Mathematica. Otros idiomas pueden no necesitar esta preparación, pero Mathematica sí). Si omitimos ese paso, suponiendo que se haya manejado para nosotros, se puede hacer el mismo enfoque en menos de 250 caracteres, y si usamos el diccionario incorporado de Mathematica, obtendremos ahorros aún mayores,

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

Menos de 200 caracteres. Para contar la cantidad de palabras encontradas solo se requiere pasar el resultado a Length[Flatten[]], que se puede agregar alrededor de cualquier bloque de código anterior, o se puede hacer después con, por ejemplo Length@Flatten@%,. La lista de palabras especificada para este desafío da 43 coincidencias, y el diccionario de Mathematica da 64 (y es mucho más rápido). Cada diccionario tiene palabras coincidentes que no están en el otro. Mathematica encuentra "no profesionalmente", por ejemplo, que no está en la lista compartida, y la lista compartida encuentra "eucariota", que no está en el diccionario de Mathematica.

Belisario propuso una solución mucho mejor. Suponiendo que la lista de palabras ya ha sido preparada y asignada a la variable l, define una sola prueba basada en la StringFreeQ[]función de Mathematica , luego aplica esta prueba a la lista de palabras usando la Pick[]función. 65 caracteres, y es aproximadamente 400 veces más rápido que mi enfoque.

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

Perl 6 - 35 caracteres

Inspirado por la solución Ruby de @CarySwoveland:

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

Esto selecciona ( greps) cada línea que regresa Truepara <a e i o u y> ⊆ *.comb, que es sólo una forma elegante de pedir "es el conjunto de ('a','e','i','o','u','y')un subconjunto ( ⊆) del conjunto componen de las letras de la entrada ( *.comb)?"

En realidad, ambos <a e i o u y>y *.combsolo crean Lists: ⊆(o (<=)si estás atrapado en ASCII) los convierte en Sets para ti.

Para obtener el número de líneas impresas, este guión de 42 caracteres - 5 = 37 puntos también generará eso:

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

Ahorré varios bytes de paréntesis gracias a una afortunada coincidencia de precedencia de operadores.

Javascript - Puntuación = 124 - 5 = 119 !!!

Editar: 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}

¡Muchas gracias a @Ismael Miguel por ayudarme a cortar ~ 12 caracteres !

Eliminé el formulario de función de notación de flecha gruesa porque, aunque he visto que comienza a usarse, no funciona. No tengo idea de por qué ...

Para que funcione:

Pase todas las palabras separadas por nueva línea como argumento a la función como se muestra a continuación.

Prueba:

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

Toma información de stdin.

sed 29 caracteres

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

Orden elegida de Frecuencia de letra en wikipedia para verificar la velocidad.

En mi anfitrión:

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

y

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

Tenga en cuenta el orden de las vocales probadas, menos frecuentes primero. Para el caso de prueba, esto se ejecuta aproximadamente 3 veces más rápido que la prueba en orden aeiou y. De esa manera, la primera prueba elimina una mayor cantidad de palabras, por lo que las pruebas posteriores tienen menos trabajo por hacer. Obviamente, esto no tiene ningún efecto sobre la longitud del código. Muchas de las otras soluciones publicadas aquí se beneficiarían de manera similar al hacer las pruebas en este orden.

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

Sin golf :

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 debe contener las palabras de la lista en 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]]]]

Sin golf:

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

dahora contiene una lista de palabras encontradas. Aquí hay un ejemplo de la consola 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 obtener el recuento, envíe #size a la colección resultante. La colección de resultados contiene 43 palabras ('abstemiamente' 'autoritativamente' ... 'incuestionablemente' 'irreconocible')

El código anterior tiene 77 caracteres, pero podría haber cambiado el nombre del archivo de la lista de palabras a 'w', así que cuento el nombre de archivo como 1, lo que da una puntuación de 57.

¿Leer el archivo es parte del problema o no? Si no (vea otros ejemplos), y la lista de palabras ya está en una colección c, entonces el código se reduce a:

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

que son 36 caracteres (sin espacios en blanco omitibles).

actualizado: espacios innecesarios eliminados

Muy lento pero en bash (81 caracteres):

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

EDITAR: echo $l|fold -w1reemplazado por fold -w1<<<$llo sugerido por @ nyuszika7h

JavaScript: 95 bytes

Aquí está mi golf.

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

Y también me gustaría señalar que su golf no parece encontrar todas las apariciones de vocales.

Sin golf:

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 no coincide con las repeticiones de una palabra. Tampoco coincide con la letra 'y' si aparece al comienzo de una palabra.

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' 

Golpetazo

No tan corto como el OP, pero una línea en 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)))));}}

Formateado:

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

En este momento no está de humor para implementar el conteo, pero debería ser fácil. La ruta a la (versión en minúsculas de la) lista de palabras se debe pasar al programa como primer argumento:

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

Salida:

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

Me tomé la libertad de mostrar y separar las palabras por comas; ninguno de los cuales se especifica en las reglas (qué estado "debe encontrar todas las palabras", no cómo (e IF) para la salida).

Recuento incluido (+ salida): 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());}}

Salida:

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

(Tenga en cuenta el recuento al final: 43)

Sin salida ("debe encontrar todas las palabras"): 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)));}}

(Doblar las reglas un poco, nuevamente: no realmente) Esto encuentra todas las palabras y el conteo está disponible al ejecutar r.Count().

C-Sharp

Nunca he hecho esto antes y no estoy exactamente seguro de cuáles son los procedimientos de publicación. Pero esto es lo que se me ocurrió:

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 las palabras.

si quieres mostrar un 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 (Puntuación 91 = 96c - 5) _{* 0}

_{* 0 + 49c min}

Esto crea una enumeración que contiene todas las palabras que contienen todas las vocales.

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

El enlace acortado va a http://www.mieliestronk.com/corncob_lowercase.txt