Votre programme doit trouver tous les mots de cette liste de mots qui contiennent toutes les voyelles ( a e i o u y). Il existe des moyens faciles de le faire, mais je cherche la réponse la plus courte. Je prendrai n'importe quelle langue, mais j'aimerais voir Bash.

Voici un exemple (pourrait être beaucoup amélioré):

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

Votre score est la longueur du code.

-5 points pour compter toutes les occurrences du mot.

Le score le plus bas l'emporte.

GolfScript, 20 caractères - 5 = 15 points

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

Basé sur la solution de Howard , mais en utilisant un test plus court ( \-!enregistre un caractère de plus &,6=), un ajout de longueur plus court ( .,+= 3 caractères) et un formatage de sortie plus court (personne n'a dit que la sortie devait être séparée par des `sauts de ligne, donc enregistre un caractère de plus n*).

Voici la sortie, étant donné la liste de mots en minuscules en entrée (sauts de ligne insérés pour plus de lisibilité):

["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. Techniquement, étant donné que le défi dit seulement que le code doit fonctionner pour cette entrée spécifique, n%{'aeiouy'\-!},`43serait encore un caractère plus court. Je considère que la tricherie, cependant.)

Explication:

• n% divise l'entrée des sauts de ligne en un tableau.
• { }, est un opérateur "grep", exécutant le code entre les accolades pour chaque élément du tableau et sélectionnant ceux pour lesquels il renvoie une valeur vraie.
  • À l'intérieur de la boucle, 'aeiouy'\-prend la chaîne littérale aeiouyet en supprime tous les caractères trouvés dans le mot candidat. le! alors annule logiquement la chaîne résultante, donnant 1(vrai) si la chaîne est vide et 0(faux) si ce n'est pas le cas.
• .,+ crée une copie du tableau filtré, compte le nombre de mots qu'il contient et ajoute le résultat au tableau d'origine.
• Enfin, `annule le tableau, le convertissant en une représentation sous forme de chaîne de son contenu. (Sans cela, les mots du tableau seraient simplement concaténés dans la sortie, ce qui donnerait un gâchis illisible.)

GolfScript, 19 caractères

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

Usage:

golfscript vowels.gs < wordlist.txt

Sortie:

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

Si vous souhaitez également sortir le nombre à la fin, vous pouvez utiliser

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

ce qui fait quatre caractères de plus.

Python - 46 caractères

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

Version lisible: Elle est déjà assez lisible :-)

APL, 21 - 5 = 16

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

Attend de trouver la liste des mots comme w. Renvoie une liste des mots qui contiennent toutes les voyelles, plus leur nombre. Testé avec ngn apl . Voici un exemple .

Explication

         '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

Rubis 38

Edit 34: Meilleur jusqu'ici (de @OI):

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

Edit 1: Je viens de remarquer que la question demandait que «y» soit inclus parmi les voyelles, j'ai donc édité ma question en conséquence. Comme @Nik l'a souligné dans un commentaire à sa réponse, "aeiouy".charsc'est un personnage de moins que %w[a e i o u y], mais je laisse ce dernier, pour la diversité, même si je risque des cauchemars sur l'opportunité manquée.

Edit 2: Merci à @OI d'avoir suggéré l'amélioration:

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

ce qui sauve 11 caractères de ce que j'avais avant.

Edit 3 et 3a: @OI en a supprimé quelques autres:

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

puis

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

et encore (3b):

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

Je suis un simple scribe!

Voici deux autres solutions non compétitives:

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

Au départ, j'avais:

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

sest une chaîne contenant les mots, séparés par des retours à la ligne. Un tableau de mots scontenant les cinq voyelles est renvoyé. Pour les lecteurs peu familiers avec Ruby, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]et &c'est l'intersection des tableaux.

Supposer

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

Dans le bloc {...}, initialement

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,

donc "abréviations" n'est pas sélectionné.

Si la chaîne speut contenir des doublons, s.split.select...peut être remplacée par s.split.uniq.select...pour supprimer les doublons.

Je viens de remarquer que je pouvais enregistrer 1 caractère en remplaçant size==6par size>5.

Haskell - 67

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

Ruby - 28 caractères (ou 27 si yest exclu des voyelles)

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

La commande complète à exécuter est (48 caractères):

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

EDIT: remplacé putspar pcomme suggéré par @CarySwoveland

AWK - 29

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

Pour exécuter: enregistrez la liste des mots en minuscules dans wordlist.txt. Alors fais:

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

Si votre système n'en a pas mawk, awkpeut également être utilisé.

Vous pouvez également l'exécuter à partir d'un fichier en enregistrant le programme dans program.awket en faisant mawkou awk -f program.awk.

Python, 45 caractères

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

k [22-5 = 17 caractères]

J'ai renommé le fichier "corncob_lowercase.txt" en "w"

Comptez les mots [22 caractères]

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

Sortie

43

Trouver tous les mots [25 caractères]

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

Au total 43 mots contenant toutes les voyelles (a e i o u y)

Sortie

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

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

Voici ma version Javascript et JScript horriblement "non golfée" (164 152 152-5 = 147 octets):

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

Merci @GaurangTandon pour la search()fonction qui m'a fait économiser un octet!

RegExp basé sur des performances HORRIBLE , mais prend en charge les majuscules et les minuscules (163-5 = 158 octets):

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 basé sur de MEILLEURES performances, MAIS prend beaucoup plus d'octets (189-5 = 184 octets):

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

Celui-ci est juste pour le plaisir (175-5 octets) et ne comptera pas comme réponse:

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

Il est basé sur la 1ère réponse, mais a un 'twist': vous pouvez savoir combien de fois un mot a été trouvé.

Vous faites simplement ça:

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

Puisque cela lengthn'a pas toutes les voyelles, il ne sera pas supprimé et serait toujours une réponse pour le bonus.

Comment l'appelez-vous?

"Simple": vous encapsulez la fonction à l'intérieur ()puis ajoutez ('string goes here');à la fin.

Comme ça: (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');

Cet exemple retournera un tableau uniquement avec 1 chaîne: yoiuae

Je sais que c'est la pire solution, mais ça marche!

Pourquoi je compte -5?

Eh bien, les tableaux Javascript / JScript ont une propriété ( length) dans les tableaux qui indique le nombre d'éléments qu'il possède.

Après avoir été confirmé dans la question, le bonus de -5 est pour indiquer le nombre de mots.

Puisque le nombre de mots est dans cette propriété, j'ai automatiquement le score de -5.

Rubis 39 38

Actuellement, l'entrée Ruby la plus courte lors du comptage de l' ensemble du programme, y compris les entrées et les sorties.

Enregistré un caractère en utilisant mapau lieu de each:

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

Une autre version, 39 caractères avec une sortie plus jolie:

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

Les deux programmes prennent l'entrée de stdin ou sous la forme d'un nom de fichier transmis comme argument de ligne de commande:
$ ruby wovels.rb wordlist.txt

Il en coûte 3 personnages supplémentaires pour inclyde ycomme une pelle.

Mathematica (65 ou 314)

Deux approches très différentes, la meilleure a été proposée par Bélisaire dans les commentaires de ma réponse initiale. Tout d'abord, mon effort brutal, qui génère de manière algorithmique toutes les expressions régulières possibles qui correspondent à une combinaison de six voyelles (y compris "y"), puis vérifie chaque mot de la liste de mots cible par rapport à chacune de ces 720 expressions régulières. Cela fonctionne, mais ce n'est pas très concis et c'est lent.

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 caractères. Quelques-uns pourraient être enregistrés en utilisant une notation alternative et des caractères supplémentaires sont perdus lors de la préparation du fichier de dictionnaire sous forme de liste de chaînes (le format naturel du dictionnaire dans Mathematica. D'autres langues peuvent ne pas avoir besoin de cette préparation, mais Mathematica en a). Si nous omettons cette étape, en supposant qu'elle a été gérée pour nous, la même approche peut être effectuée en moins de 250 caractères, et si nous utilisons le dictionnaire intégré de Mathematica, nous réalisons des économies encore plus importantes,

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

Moins de 200 caractères. Pour compter le nombre de mots trouvés, il suffit de transmettre le résultat à Length[Flatten[]], qui peut être ajouté autour de l'un des blocs de code ci-dessus, ou peut être effectué ensuite avec, par exemple Length@Flatten@%,. La liste de mots spécifiée pour ce défi donne 43 correspondances, et le dictionnaire Mathematica donne 64 (et est beaucoup plus rapide). Chaque dictionnaire a des mots correspondants pas dans l'autre. Par exemple, Mathematica trouve «non professionnel», qui n'est pas dans la liste partagée, et la liste partagée trouve «eucaryote», qui n'est pas dans le dictionnaire de Mathematica.

Belisarius a proposé une solution bien meilleure. En supposant que la liste de mots a déjà été préparée et affectée à la variable l, il définit un test unique basé sur la StringFreeQ[]fonction de Mathematica , puis applique ce test à la liste de mots à l'aide de la Pick[]fonction. 65 caractères, et c'est environ 400 fois plus rapide que mon approche.

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

Perl 6 - 35 caractères

Inspiré par la solution Ruby de @CarySwoveland:

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

Ceci permet de sélectionner ( greps) chaque ligne que les rendements Truepour <a e i o u y> ⊆ *.comb, qui est juste une façon de fantaisie de demander « est l'ensemble ('a','e','i','o','u','y')un sous - ensemble ( ⊆) de l'ensemble composé des lettres de l'entrée ( *.comb)? »

En fait, les deux <a e i o u y>et *.combseulement créer des Lists: ⊆(ou (<=)si vous êtes coincé en ASCII) les transforme en Sets pour vous.

Pour obtenir le nombre de lignes imprimées, ce 42 caractères - 5 = 37 points script de affichera cela également:

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

C - 96 octets

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

J'ai sauvé plusieurs octets de parenthèses grâce à une heureuse coïncidence de priorité des opérateurs.

Javascript - Score = 124 - 5 = 119 !!!

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

Un grand merci à @Ismael Miguel pour m'avoir aidé à couper ~ 12 caractères !

J'ai supprimé le formulaire de la fonction de notation des flèches grasses parce que même si je l'ai vu commencer à l'utiliser, cela ne fonctionne pas. Je ne sais pas pourquoi ...

Pour le faire fonctionner:

Passez tous les mots séparés par un saut de ligne comme argument à la fonction comme indiqué ci-dessous.

Tester:

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

Prend l'entrée de stdin.

sed 29 caractères

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

Ordre choisi parmi la fréquence des lettres sur wikipedia pour vérifier la vitesse.

Sur mon hôte:

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

et

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

Bash (grep) - 36 octets

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

Notez l'ordre des voyelles testées, les moins fréquentes en premier. Pour le cas de test, cela s'exécute environ 3 fois plus vite que le test dans l'ordre aeiou y. De cette façon, le premier test supprime un plus grand nombre de mots afin que les tests suivants aient moins de travail à faire. Évidemment, cela n'a aucun effet sur la longueur du code. De nombreuses autres solutions publiées ici bénéficieraient de la même manière des tests dans cet ordre.

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

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

wordlist.txt doit contenir les mots de la liste en minuscules.

Rebol (104 caractères)

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

Non-golfé:

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

dcontient maintenant la liste des mots trouvés. Voici un exemple de la 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 caractères)

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

pour obtenir le nombre, envoyez #size à la collection résultante. La collection de résultats contient 43 mots («sans retenue» «avec autorité» ... «sans conteste» «sans reconnaissance»)

Le code ci-dessus a 77 caractères, mais j'aurais pu renommer le fichier de liste de mots en 'w', donc je compte le nom de fichier comme 1, ce qui donne un score de 57.

La lecture du fichier fait-elle partie du problème ou non? Sinon (voir d'autres exemples), et que la liste de mots est déjà dans une collection c, alors le code se réduit à:

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

qui est de 36 caractères (avec les espaces omis supprimés).

mis à jour: espaces inutiles supprimés

Très lent mais en bash (81 caractères):

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

EDIT: echo $l|fold -w1remplacé par fold -w1<<<$lcomme suggéré par @ nyuszika7h

JavaScript - 95 octets

Voici mon golf.

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

Et je voudrais également souligner que votre golf ne semble pas trouver toutes les occurrences de voyelles.

Non golfé:

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

trier + uniq + sed

Celui-ci ne correspond pas aux occurrences répétées d'un mot. Il ne correspond pas non plus à la lettre «y» si elle apparaît au début d'un mot.

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' 

Frapper

Pas aussi court que les PO, mais une ligne dans 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)))));}}

Formaté:

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

Pas d'humeur en ce moment à implémenter le comptage mais devrait être facile. Le chemin d'accès à la (liste en minuscules de la) liste de mots doit être transmis au programme comme premier argument:

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

Sortie:

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

J'ai pris la liberté de sortir et de séparer les mots par des virgules; ni l'un ni l'autre n'est spécifié dans les règles (qui stipulent "doit trouver tous les mots", pas comment (et IF) sortir)

Dont compte (+ sortie): 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());}}

Sortie:

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

(Notez le nombre à la fin: 43)

Aucune sortie ("doit trouver tous les mots"): 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)));}}

(Flexion des règles un bitm puis à nouveau: pas vraiment) Cela trouve tous les mots et le décompte est disponible en exécutant r.Count().

C-Sharp

Je n'ai jamais fait cela auparavant et je ne sais pas exactement quelles sont les procédures d'affichage. Mais c'est ce que j'ai trouvé:

185 octets

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 tous les mots.

si vous souhaitez afficher un total:

219 - 5 = 214 octets

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

_{* 0 + 49c min}

Cela crée une énumération contenant tous les mots qui contiennent toutes les voyelles.

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

Le lien raccourci va à http://www.mieliestronk.com/corncob_lowercase.txt