Il tuo programma deve trovare tutte le parole in questo elenco di parole che contengono tutte le vocali ( a e i o u y). Ci sono modi semplici per farlo, ma sto cercando la risposta più breve. Prenderò qualsiasi lingua, ma mi piacerebbe vedere Bash.

Ecco un esempio (potrebbe essere molto migliorato):

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

Il tuo punteggio è la lunghezza del codice.

-5 punti per il conteggio di tutte le occorrenze della parola.

Il punteggio più basso vince.

GolfScript, 20 caratteri - 5 = 15 punti

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

Basato sulla soluzione di Howard , ma usando un test più breve ( \-!salva un carattere &,6=), un accorciamento della lunghezza più breve ( .,+= 3 caratteri) e una formattazione dell'output più breve (nessuno ha detto che l'output debba essere separato da una nuova riga, quindi `risparmia un carattere n*).

Ecco l'output, dato l'elenco di parole minuscole come input (interruzioni di riga inserite per la leggibilità):

["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, dato che la sfida dice solo che il codice deve funzionare per questo input specifico, n%{'aeiouy'\-!},`43sarebbe ancora un carattere più breve. Considero comunque l'inganno).

Spiegazione:

• n% divide l'input su newline in un array.
• { }, è un operatore "grep", che esegue il codice tra le parentesi graffe per ciascun elemento dell'array e seleziona quelli per i quali restituisce un valore vero.
  • All'interno del ciclo, 'aeiouy'\-prende la stringa letterale aeiouye rimuove da essa ogni carattere trovato nella parola candidata. L' !poi nega logicamente la stringa risultante, cedevole 1(true) se la stringa è vuota e 0(false) se non è.
• .,+ crea una copia dell'array filtrato, conta il numero di parole al suo interno e aggiunge il risultato all'array originale.
• Infine, `annulla la valutazione dell'array, convertendolo in una rappresentazione in formato stringa del suo contenuto. (Senza di essa, le parole nell'array sarebbero semplicemente concatenate nell'output, producendo un pasticcio illeggibile.)

GolfScript, 19 caratteri

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

Uso:

golfscript vowels.gs < wordlist.txt

Produzione:

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

Se si desidera anche generare il conteggio alla fine, è possibile utilizzare

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

che è più lungo di quattro caratteri.

Python - 46 caratteri

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

Versione leggibile: è già abbastanza leggibile :-)

APL, 21-5 = 16

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

Si aspetta di trovare l'elenco di parole come w. Restituisce un elenco delle parole che contengono tutte le vocali, più il loro conteggio. Testato con ngn apl . Ecco un esempio .

Spiegazione

         '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

Modifica 34: il migliore finora (da @OI):

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

Modifica 1: ho appena notato la domanda che chiedeva di includere "y" tra le vocali, quindi ho modificato la mia domanda di conseguenza. Come ha sottolineato @Nik in un commento alla sua risposta, "aeiouy".charsè un personaggio in meno di %w[a e i o u y], ma lascerò quest'ultimo, per diversità, anche se sto rischiando incubi sull'opportunità perduta.

Modifica 2: Grazie a @OI per aver suggerito il miglioramento:

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

che salva 11 personaggi da quello che avevo prima.

Modifica 3 e 3a: @OI ne ha eliminati alcuni altri:

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

poi

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

e ancora (3b):

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

Sono un semplice scriba!

Ecco altre due soluzioni non compatte:

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

Inizialmente avevo:

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

sè una stringa contenente le parole, separate da nuove righe. Viene srestituita una matrice di parole che contiene tutte e cinque le vocali. Per i lettori che non hanno familiarità con Ruby %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]ed &è l'intersezione di array.

supporre

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

Nel blocco {...}, inizialmente

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,

quindi "abbreviazioni" non è selezionato.

Se la stringa spuò contenere duplicati, s.split.select...può essere sostituita da s.split.uniq.select...per rimuovere i duplicati.

Ho appena notato che ho potuto salvare 1 carattere sostituendolo size==6con size>5.

Haskell - 67

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

Rubino: 28 caratteri (o 27 se yescluso dalle vocali)

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

Il comando completo da eseguire è (48 caratteri):

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

EDIT: sostituito putscon pcome suggerito da @CarySwoveland

AWK - 29

/ A / && / e / && / i / && / o / && / u / && / y /

Per eseguire: salva l'elenco di parole minuscole in wordlist.txt. Quindi fa:

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

Se il tuo sistema non ha mawk, awkpuò essere utilizzato anche.

Puoi anche eseguirlo da un file salvando il programma program.awke facendo mawko awk -f program.awk.

Python, 45 caratteri

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

k [22-5 = 17 caratteri]

Ho rinominato il file "corncob_lowercase.txt" in "w"

Conta le parole [22 caratteri]

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

Produzione

43

Trova tutte le parole [25 caratteri]

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

Complessivamente 43 parole contenenti tutte le vocali (a e i o u y)

Produzione

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

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

Ecco la mia versione orribilmente "ungolfyfied" di Javascript e JScript (164 152 152-5 = 147 byte):

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

Grazie @GaurangTandon per la search()funzione, che mi ha salvato un byte!

RegExp basato su prestazioni ORRIBILI , ma supporta sia lettere maiuscole che minuscole (163-5 = 158 byte):

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

Basato su RegExp con prestazioni MIGLIORI , MA richiede molti più byte (189-5 = 184 byte):

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

Questo è solo per divertimento (175-5 byte) e non conta come una risposta:

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

Si basa sulla prima risposta, ma ha una "svolta": puoi sapere quante volte è stata trovata una parola.

Semplicemente fai così:

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

Dal momento che lengthnon ha tutte le vocali, non sarà cancellato e sarebbe comunque una risposta per il bonus.

Come lo chiami?

"Semplice": avvolgi la funzione all'interno ()e poi aggiungi ('string goes here');alla fine.

Come questo: (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');

Questo esempio restituirà un array solo con 1 stringa: yoiuae

So che questa è la soluzione peggiore, ma funziona!

Perché sto contando -5?

Bene, le matrici Javascript / JScript hanno una proprietà ( length) nelle matrici che indica il numero di elementi che ha.

Dopo essere stato confermato nella domanda, il bonus di -5 è per dire il numero di parole.

Poiché il numero di parole è in quella proprietà, automaticamente ho il punteggio di -5.

Ruby 39 38

Attualmente la voce Ruby più breve quando si conteggia l' intero programma inclusi input e output.

Hai salvato un carattere usando mapinvece di each:

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

Un'altra versione, 39 caratteri con output più bello:

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

Entrambi i programmi accettano input da stdin o come nome file passato come argomento della riga di comando:
$ ruby wovels.rb wordlist.txt

Costa 3 personaggi in più da incidere ycome una pala.

Mathematica (65 o 314)

Due approcci molto diversi, il migliore è stato proposto da Belisarius nei commenti alla mia risposta iniziale. Innanzitutto, il mio sforzo brutale, che genera algoritmicamente ogni possibile espressione regolare che corrisponde a una combinazione di sei vocali (inclusa "y"), quindi controlla ogni parola nell'elenco di parole di destinazione con ognuna di queste 720 espressioni regolari. Funziona, ma non è molto conciso ed è 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 caratteri. Alcuni potrebbero essere salvati usando la notazione alternativa e si perdono altri caratteri preparando il file del dizionario come un elenco di stringhe (il formato naturale per il dizionario in Mathematica. Altre lingue potrebbero non aver bisogno di questa preparazione, ma Mathematica lo fa). Se omettiamo quel passaggio, presumendo che sia stato gestito per noi, lo stesso approccio può essere fatto in meno di 250 caratteri e se utilizziamo il dizionario integrato di Mathematica, otteniamo risparmi ancora più grandi,

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

Meno di 200 caratteri. Il conteggio del numero di parole trovate richiede solo il passaggio al risultato Length[Flatten[]], che può essere aggiunto attorno a uno dei blocchi di codice sopra o che può essere fatto successivamente con, ad esempio Length@Flatten@%,. L'elenco di parole specificato per questa sfida dà 43 corrispondenze e il dizionario Mathematica ne dà 64 (ed è molto più veloce). Ogni dizionario ha parole corrispondenti non nell'altro. Mathematica trova "non professionale", ad esempio, che non è nell'elenco condiviso, e l'elenco condiviso trova "eucariotico", che non è nel dizionario di Mathematica.

Belisario propose una soluzione di gran lunga migliore. Supponendo che l'elenco di parole sia già stato preparato e assegnato alla variabile l, definisce un singolo test basato sulla StringFreeQ[]funzione di Mathematica , quindi applica questo test all'elenco di parole utilizzando la Pick[]funzione. 65 caratteri ed è circa 400 volte più veloce del mio approccio.

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

Perl 6 - 35 caratteri

Ispirato alla soluzione Ruby di @CarySwoveland:

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

Questo seleziona ( grepi) ogni riga che restituisce Trueper <a e i o u y> ⊆ *.comb, che è solo un modo elegante di chiedere "è il set ('a','e','i','o','u','y')di un sottoinsieme ( ⊆) del Set composto da lettere di input ( *.comb)?"

In realtà, entrambi <a e i o u y>e *.combsolo creano Lists: ⊆(o (<=)se sei bloccato in ASCII) li trasforma in Sets per te.

Per ottenere il numero di righe stampate, questo script di 42 caratteri - 5 = 37 punti genererà anche quello:

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

C - 96 byte

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

Ho salvato diversi byte di parentesi grazie a una fortunata coincidenza di precedenza dell'operatore.

Javascript - Punteggio = 124-5 = 119 !!!

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

Grazie mille a @Ismael Miguel per avermi aiutato a tagliare ~ 12 caratteri !

Ho rimosso il modulo della funzione di notazione con la freccia grassa perché sebbene abbia visto che è stato usato per iniziare, non funziona. Non ho idea del perché ...

Per farlo funzionare:

Passa tutte le parole separate da newline come argomento alla funzione come mostrato di seguito.

Test:

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

Riceve input dallo stdin.

sed 29 caratteri

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

Ordine scelto dalla frequenza delle lettere su Wikipedia per il controllo della velocità.

Sul mio 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 byte

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

Nota l'ordine delle vocali testate, prima meno frequenti. Per il caso di test, questo viene eseguito circa 3 volte più veloce del test per ogni anno. In questo modo il primo test rimuove un numero maggiore di parole, quindi i test successivi hanno meno lavoro da fare. Ovviamente questo non ha alcun effetto sulla lunghezza del codice. Molte delle altre soluzioni pubblicate qui trarrebbero beneficio in modo simile dal fare i test in questo ordine.

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

Non golfato :

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

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

wordlist.txt deve contenere le parole dell'elenco in minuscolo.

Rebol (104 caratteri)

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

Un-giocato a golf:

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

dora contiene un elenco di parole trovate. Ecco un esempio dalla console di 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 caratteri)

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

per ottenere il conteggio, inviare #size alla raccolta risultante. La raccolta dei risultati contiene 43 parole ("in modo misterioso" "autorevolmente" ... "senza dubbio" "irriconoscibile")

Il codice sopra ha 77 caratteri, ma avrei potuto rinominare il file della lista di parole in 'w', quindi conto il nome del file come 1 che dà un punteggio di 57.

La lettura del file fa parte del problema o no? In caso contrario (vedi altri esempi) e l'elenco di parole è già in una raccolta c, il codice si riduce a:

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

che è 36 caratteri (con lo spazio bianco omessoble rimosso).

aggiornato: spazi inutili rimossi

Molto lento ma in bash (81 caratteri):

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

EDIT: echo $l|fold -w1sostituito con fold -w1<<<$lcome suggerito da @ nyuszika7h

JavaScript - 95 byte

Ecco il mio golf.

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

E vorrei anche sottolineare che il tuo golf non sembra trovare tutte le occorrenze di vocali.

Ungolfed:

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

ordina + uniq + sed

Questo non corrisponde a ricorrenze ripetute di una parola. Inoltre non corrisponde alla lettera 'y' se si verifica all'inizio di una parola.

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

Non così breve come gli OP, ma una riga in 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)))));}}

formattato:

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

Non è dell'umore giusto per implementare il conteggio, ma dovrebbe essere facile. Il percorso dell'elenco di parole (in minuscolo dell'elenco di parole) deve essere passato al programma come primo argomento:

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

Produzione:

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

Mi sono preso la libertà di emettere e separare le parole in virgola; nessuno dei quali è specificato nelle regole (quale stato "deve trovare tutte le parole", non come (e IF) produrre).

Incluso conteggio (+ uscita): 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());}}

Produzione:

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

(Nota il conteggio alla fine: 43)

Nessun risultato ("deve trovare tutte le parole"): 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)));}}

(Piegando le regole un po 'di nuovo: non proprio) Questo trova tutte le parole e il conteggio è disponibile eseguendo r.Count().

C-Sharp

Non l'ho mai fatto prima e non sono esattamente sicuro di quali siano le procedure di invio. Ma questo è quello che mi è venuto in mente:

185 byte

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>di tutte le parole.

se si desidera visualizzare un totale:

219 - 5 = 214 byte

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

_{* 0 + 49c min}

Questo crea un'enumerazione che contiene tutte le parole che contengono tutte le vocali.

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

Matematica - 136 102

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

Il collegamento abbreviato va a http://www.mieliestronk.com/corncob_lowercase.txt