您的程序必须在此单词表中找到包含所有元音（a e i o u y）的所有单词。有很简单的方法可以做到这一点，但是我正在寻找最短的答案。我会选择任何语言，但我想看看Bash。

这是一个示例（可能会大大改善）：

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

您的分数就是代码的长度。

-5分，用于计算单词的所有出现次数。

最低分获胜。

GolfScript，20个字符-5 = 15分

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

基于Howard的解决方案，但是使用了较短的测试（\-!节省了一个字符&,6=），较短的附加长度（.,+= 3个字符）和较短的输出格式（没有人说输出必须用换行符分隔，因此`节省了一个字符n*）。

给定小写单词列表作为输入，这是输出（为便于阅读，插入了换行符）：

["abstemiously" "authoritatively" "behaviourally" "consequentially" "counterrevolutionary"
"disadvantageously" "educationally" "encouragingly" "eukaryotic" "evolutionarily"
"evolutionary" "exclusionary" "facetiously" "gregariously" "heterosexuality" "homosexuality"
"importunately" "inconsequentially" "instantaneously" "insurrectionary" "intravenously"
"manoeuvrability" "neurologically" "neurotically" "ostentatiously" "pertinaciously"
"precariously" "precautionary" "questionably" "revolutionary" "simultaneously"
"supersonically" "tenaciously" "uncomplimentary" "uncontroversially" "unconventionally"
"undemocratically" "unemotionally" "unequivocally" "uninformatively" "unintentionally"
"unquestionably" "unrecognisably" 43]

（诗。从技术上讲，鉴于挑战仅表明代码必须针对此特定输入起作用，所以n%{'aeiouy'\-!},`43将要短一个字符。不过，我认为是作弊。）

说明：

• n% 将换行符上的输入拆分为一个数组。
• { }, 是一个“ grep”运算符，在数组的每个元素的花括号之间执行代码，并选择为其返回真值的花括号。
  • 在循环内部，'aeiouy'\-获取文字字符串，aeiouy并从中删除候选单词中找到的每个字符。在!那么在逻辑上否定了得到的字符串，产生1（真）如果字符串是空的0（假），如果它不是。
• .,+ 复制过滤后的数组，计算其中的单词数，然后将结果附加到原始数组。
• 最后，`取消对数组的排序，将其转换为其内容的字符串表示形式。（没有它，数组中的单词将简单地在输出中连接起来，产生难以理解的混乱。）

GolfScript，19个字符

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

用法：

golfscript vowels.gs < wordlist.txt

输出：

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

如果您还想在最后输出计数，则可以使用

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

再长四个字符。

Python-46个字符

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

可读的版本：可读性很强:-)

APL，21-5 = 16

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

期望找到的单词列表为w。返回包含所有元音及其数量的单词列表。经过ngn apl测试。这是一个例子。

说明

         'aeiouy'∘.∊w   # generate a truth table for every vowel ∊ every word
       ∧⌿               # reduce with ∧ along the rows (vowels)
    w/⍨                 # select the words that contain all the vowels
(,≢)                    # hook: append to the list its own tally

红宝石38

编辑34：到目前为止最好（来自@OI）：

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

编辑1：我只是注意到要求在元音中包含“ y”的问题，因此我已经相应地编辑了我的问题。正如@Nik在对他的回答的评论中所指出的，"aeiouy".chars它比少一个字符%w[a e i o u y]，但我将保留后者，以保持多样性，即使我因放弃的机会而面临噩梦。

编辑2：感谢@OI提出改进建议：

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

这比以前节省了11个字符。

编辑3和3a：@OI还提供了其他一些功能：

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

然后

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

并再次（3b）：

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

我只是个抄写员！

这是另外两个没有竞争力的解决方案：

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

最初我有：

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

s是一个包含单词的字符串，以换行符分隔。s返回包含所有五个元音的单词数组。对于不熟悉Ruby的读者来说，%w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]它&是数组的交集。

假设

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

在区块中{...}，最初

w             #=> "abbreviations"
w.chars       #=> ["a", "b", "b", "r", "e", "v", "i", "a", "t", "i", "o", "n", "s"]
w.chars & %w[a e i o u y] #=> ["a", "e", "i", "o"]
(w.chars & %w[a e i o u y]).size == 6 #=> (4 == 6) => false,

因此未选择“缩写”。

如果字符串s可能包含重复项，则s.split.select...可以用替换s.split.uniq.select...以删除重复项。

刚刚注意到我可以通过更换节省1个字符size==6用size>5。

哈斯克尔-67

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

Ruby-28个字符（如果y不包含在元音中，则为27个字符）

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

要运行的完整命令是（48个字符）：

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

编辑：取代puts与p被@CarySwoveland的建议

AWK-29

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

运行：将小写单词列表保存到wordlist.txt。然后做：

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

如果您的系统没有mawk，awk也可以使用。

您也可以通过将程序保存到program.awk并执行mawk或从文件运行它awk -f program.awk。

Python，45个字符

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

k [22-5 = 17个字符]

我已将文件“ corncob_lowercase.txt”重命名为“ w”

数数单词[22个字符]

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

输出量

43

查找所有词[25个字符]

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

总共43个单词，包含所有元音 (a e i o u y)

输出量

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

Javascript / JScript 147（152-5），158（163-5）或184（189-5）字节：

这是我的Javascript和JScript可怕的“ ungolfyfied”版本（164 152 152-5 = 147字节）：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;}

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=6;for(z in c)i-=!!s[k].search(c[z]);i&&(r[r.length]=s[k]);}return r;}

谢谢@GaurangTandon的search()功能，它为我节省了一个字节！

RegExp基于HORRIBLE性能，但同时支持大写和小写（163-5 = 158字节）：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=RegExp(c[z],'i').test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

基于具有更好性能的RegExp ，BUT需要占用更多的字节（189-5 = 184字节）：

function(s,k,z,x,i,c,r,l){l=[];r=[];for(z in c='aeiouy'.split(''))l[z]=RegExp(c[z],'i');for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=l[z].test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

这个（如果只是为了娱乐）（175-5字节），不会算作答案：

function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;}

它基于第一个答案，但有一个“扭曲”：您可以知道一个单词被发现了多少次。

您只需这样做：

var b=(function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r[r.length]=s[k]]=1+(r[s[k]]||0));}return r;})('youaie youaie youaie youaie a word');

b.youaie //should be 4

由于length没有所有的元音，因此不会删除它，仍然可以作为奖金的答案。

你怎么称呼它？

“简单”：将函数包装在里面()，然后添加('string goes here');到末尾。

像这样： (function(s,k,z,x,i,c,r){c='aeiouy'.split('');r=[];for(k in s=(s+'').split(/\b/)){i=0;for(z in c)i+=s[k].indexOf(c[z])>=0;i==6&&(r[r.length]=s[k]);}return r;})('a sentence youyoy iyiuyoui yoiuae oiue oiuea');

此示例将返回仅包含1个字符串的数组：yoiuae

我知道这是最糟糕的解决方案，但是有效！

为什么我要数-5？

好吧，Javascript / JScript数组在数组中有一个属性（length），用于说明其具有的元素数。

在问题中得到确认后，-5的加分是用于告诉单词数。

由于单词的数量在该属性中，因此我的分数自动为-5。

红宝石39 38

当前计算整个程序（包括输入和输出）时最短的Ruby条目。

使用map代替来保存字符each：

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

另一个版本，带有漂亮输出的39个字符：

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

这两个程序都从stdin接受输入，或者将其作为通过命令行参数传递的文件名：
$ ruby wovels.rb wordlist.txt

编织需要花费3个额外的字符y。

Mathematica（65或314）

Belisarius在对我的最初回应的评论中提出了两种截然不同的方法，更好的一种。首先，我的努力工作是通过算法生成与六个元音（包括“ y”）组合在一起的每个可能的正则表达式，然后对照这720个正则表达式中的每一个检查目标单词列表中的每个单词。它可以工作，但是不是很简洁，而且很慢。

b = Permutations[{"a", "e", "i", "o", "u","y"}]; Table[
 Select[StringSplit[
  URLFetch["http://www.mieliestronk.com/corncob_lowercase.txt"]], 
  StringMatchQ[#, (___ ~~ b[[i]][[1]] ~~ ___ ~~ 
      b[[i]][[2]] ~~ ___ ~~ b[[i]][[3]] ~~ ___ ~~ 
      b[[i]][[4]] ~~ ___ ~~ b[[i]][[5]]~~ ___ ~~ b[[i]][[6]] ~~ ___)] &], {i, 1, 
  Length[b]}]

约320个字符。可以通过使用其他表示法来节省一些，而准备字典文件作为字符串列表时，其他字符会丢失（Mathematica中字典的自然格式。其他语言可能不需要此准备，但Mathematica确实需要）。如果我们省略该步骤（假定已为我们处理），则可以用250个字符以内完成相同的方法，如果使用Mathematica的内置词典，则可以节省更多的钱，

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

少于200个字符。计算找到的单词数只需要将结果传递给Length[Flatten[]]，可以将其添加到上面的任一代码块周围，也可以随后使用来完成Length@Flatten@%。为此挑战指定的单词列表给出了43个匹配项，而Mathematica词典给出了64个匹配项（并且速度更快）。每个词典中都没有匹配的单词。例如，Mathematica在共享列表中找不到“非专业”，而在共享列表中找到Mathematica词典中没有的“真核生物”。

贝利撒留提出了一种更好的解决方案。假设已经准备好单词表并将其分配给变量l，他基于Mathematica的StringFreeQ[]功能定义了一个测试 ，然后使用该Pick[]功能将该测试应用于单词表。65个字符，比我的方法快400倍。

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

Perl 6-35个字符

受到@CarySwoveland的Ruby解决方案的启发：

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

这种选择（grepS）各行收益True的<a e i o u y> ⊆ *.comb，这是问的只是一个奇特的方式“是集合('a','e','i','o','u','y')的子集（⊆中集）由输入的字母（的*.comb）？”

实际上，两者<a e i o u y>和*.comb仅创建Lists ：（⊆或者(<=)如果您被困在ASCII中）会Set为您将它们转换为s。

要获得打印的行数，此42个字符-5 = 37点的脚本也将输出：

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

C-96字节

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

由于运算符优先级的巧合，我节省了几个字节的括号。

Javascript-分数= 124-5 = 119 !!!

编辑：14/02/17

function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z}

非常感谢@Ismael Miguel帮助我减少了约12个字符！

我删除了粗箭头表示法功能表单，因为尽管我已经看到它开始使用，但是它不起作用。不知道为什么

要使其起作用：

将所有由换行符分隔的单词作为参数传递给函数，如下所示。

测试：

// string is "facetiously\nabstemiously\nhello\nauthoritatively\nbye"

var answer = (function(l){z=[],l=l.split("\n"),t=0;while(r=l[t++]){o=0;for(i in k="aeiouy")o+=!~r.search(k[i]);if(o==0)z.push(r)}return z})("facetiously\nabstemiously\nhello\nauthoritatively\nbye")

console.log(answer);
console.log(answer.length);

/* output ->    
    ["facetiously", "abstemiously", "authoritatively"]
    3 // count
*/

Bash + coreutils，39岁

eval cat`printf "|grep %s" a e i o u y`

接受来自stdin的输入。

sed 29个字符

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

顺序从维基百科上的字母频率中选择上的以进行速度检查。

在我的主机上：

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

和

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

Bash（grep）-36个字节

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

注意测试的元音顺序，最不频繁的顺序。对于测试用例，此命令的运行速度约为测试顺序的3倍。这样，第一个测试将删除大量单词，因此后续测试的工作量将减少。显然，这对代码的长度没有影响。按此顺序进行测试，这里发布的许多其他解决方案也会类似地受益。

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

未打高尔夫球：

import std.regex, std.stream;

void main( string[] a )
{
    auto f = new File( a[1] );

    while( !f.eof )
        if( !( a[0] = f.readLine.idup ).match( "(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*" ).empty )
            std.stdio.writeln( a[0] );
}

用法：C:\>rdmd vowels.d wordlist.txt

wordlist.txt 必须包含小写列表字。

Rebol（104个字符）

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

未打高尔夫球：

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

d现在包含找到的单词列表。这是Rebol控制台的示例：

>> ; paste in golf line.  This (REMOVE-EACH) returns the numbers of words removed from list

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

>> length? d
== 43

小话（36/57个字符）

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

要获取计数，请将#size发送到结果集合。结果集合包含43个单词（“绝对”，“权威”，“毫无疑问”，“无法识别”）

上面的代码有77个字符，但是我可以将单词列表文件重命名为“ w”，因此我将文件名计为1，这得到了57分。

读取文件是否是问题的一部分？如果不是（请参见其他示例），并且单词列表已经在集合c中，那么代码将简化为：

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

这是36个字符（删除了不可省略的空格）。

更新：删除不必要的空格

速度很慢，但以bash表示（81个字符）：

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

编辑：echo $l|fold -w1替换fold -w1<<<$l为@ nyuszika7h建议

JavaScript-95个字节

这是我的高尔夫球。

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

我还要指出，您的高尔夫似乎并没有发现所有元音的出现。

取消高尔夫：

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

排序+ uniq + sed

这与单词的重复出现不匹配。如果出现在单词的开头，则它也与字母“ y”不匹配。

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' 

重击

不是OP的短，而是Bash中的一行：

while read p; do if [ $(sed 's/[^aeiouy]//g' <<< $p | fold -w1 | sort | uniq | wc -l) -eq 6 ] ; then echo $p; fi; done < wordlist.txt

C＃-170

using System.Linq;class P{static void Main(string[]a){System.Console.Write(string.Join(",",System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)))));}}

格式：

using System.Linq;
class P
{
    static void Main(string[] a) { 
        System.Console.Write(
            string.Join(",", System.IO.File.ReadAllLines(a[0])
                .Where(w => "aeiouy".All(c => w.Contains(c))))); 
    }
}

现在不打算进行计数，但应该很容易。 单词列表（小写版本）的路径应作为第一个参数传递给程序：

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

输出：

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably

我可以自由使用输出和逗号分隔的单词。规则中均未指定两者（状态“必须找到所有单词”，而不是输出方式（和IF））。

包括计数（+输出）：192-5 = 187

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));System.Console.Write(string.Join(",",r)+" "+r.Count());}}

输出：

abstemiously,authoritatively,behaviourally,consequentially,counterrevolutionary,
disadvantageously,educationally,encouragingly,eukaryotic,evolutionarily,evolutio
nary,exclusionary,facetiously,gregariously,heterosexuality,homosexuality,importu
nately,inconsequentially,instantaneously,insurrectionary,intravenously,manoeuvra
bility,neurologically,neurotically,ostentatiously,pertinaciously,precariously,pr
ecautionary,questionably,revolutionary,simultaneously,supersonically,tenaciously
,uncomplimentary,uncontroversially,unconventionally,undemocratically,unemotional
ly,unequivocally,uninformatively,unintentionally,unquestionably,unrecognisably 4
3

（请注意末尾的计数：43）

无输出（“必须找到所有单词”）：137-5 = 132

using System.Linq;class P{static void Main(string[]a){var r=System.IO.File.ReadAllLines(a[0]).Where(w=>"aeiouy".All(c=>w.Contains(c)));}}

（弯曲的规则1位图的处理然后再：不是真的）这出土文物所有单词，并且可以通过执行计数r.Count()。

锋利的C

我以前从未做过此事，也不确定是什么发布程序。但这是我想出的：

185字节

Action<string>x=(s=>s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v)))Console.Write(w);}));using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

wordList =一个 List<string>所有单词中的a。

如果要显示总计：

219-5 = 214字节

Action<string>x=(s=>{var t=0;s.Split('\n').ToList().ForEach(w=>{if("aeiouy".All(v=>w.Contains(v))){Console.Write(w);t++;}});Console.Write(t);});using(var s=new StreamReader(@"C:\corncob_lowercase.txt"))x(s.ReadToEnd());

// init
var words = "";
var vowels = "aeiouy";
var total = 0;

using (var stream = new StreamReader(@"C:\corncob_lowercase.txt"))
{
    // read file
    words = stream.ReadToEnd();

    // convert word to List<string>
    var wordList = words.Split('\n').ToList();

    // loop through each word in the list
    foreach (var word in wordList)

        // check if the current word contains all the vowels
        if(vowels.All (w => word.ToCharArray().Contains(w)))
        {
            // Count total
            total += 1;
            // Output word
            Console.Write(word);
        }

    // Display total
    Console.WriteLine(total);
}

vb.net（分数91 = 96c-5）_{* 0}

_{* 0 + 49c分钟}

这将创建一个包含所有包含所有元音的单词的枚举。

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

缩短的链接转到http://www.mieliestronk.com/corncob_lowercase.txt