Chương trình của bạn phải tìm tất cả các từ trong danh sách từ này có chứa tất cả các nguyên âm ( a e i o u y). Có nhiều cách dễ dàng để làm điều này, nhưng tôi đang tìm kiếm câu trả lời ngắn nhất. Tôi sẽ lấy bất kỳ ngôn ngữ nào, nhưng tôi muốn gặp Bash.

Đây là một ví dụ (có thể được cải thiện nhiều):

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

Điểm của bạn là độ dài của mã.

-5 điểm để đếm tất cả các lần xuất hiện của từ này.

Điểm số thấp nhất chiến thắng.

GolfScript, 20 ký tự - 5 = 15 điểm

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

Dựa trên giải pháp của Howard , nhưng sử dụng thử nghiệm ngắn hơn ( \-!tiết kiệm được một char&,6= ), nối dài hơn ( .,+= 3 ký tự) và định dạng đầu ra ngắn hơn (không ai nói đầu ra phải được phân tách bằng dòng mới, vì vậy sẽ `tiết kiệm được một char n*).

Đây là đầu ra, được đưa ra danh sách từ viết thường làm đầu vào (ngắt dòng được chèn để dễ đọc):

["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. Về mặt kỹ thuật, cho rằng thách thức chỉ nói rằng mã phải hoạt động cho đầu vào cụ thể này, n%{'aeiouy'\-!},`43 sẽ ngắn hơn một ký tự. Tuy nhiên, tôi cho rằng gian lận đó.)

Giải trình:

• n% chia đầu vào trên dòng mới thành một mảng.
• { }, là một toán tử "grep", thực thi mã giữa các dấu ngoặc cho từng phần tử của mảng và chọn những phần tử mà nó trả về một giá trị thực.
  • Trong vòng lặp, 'aeiouy'\-lấy chuỗi ký tự aeiouyvà xóa khỏi nó mọi ký tự được tìm thấy trong từ ứng cử viên. Sau !đó, phủ nhận một cách hợp lý chuỗi kết quả, mang lại 1(true) nếu chuỗi trống và 0(false) nếu không.
• .,+ tạo một bản sao của mảng được lọc, đếm số lượng từ trong đó và nối kết quả vào mảng ban đầu.
• Cuối cùng, `hủy bỏ mảng, chuyển đổi nó thành một chuỗi đại diện cho nội dung của nó. (Không có nó, các từ trong mảng sẽ chỉ được ghép vào đầu ra, mang lại một mớ hỗn độn không thể đọc được.)

GolfScript, 19 ký tự

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

Sử dụng:

golfscript vowels.gs < wordlist.txt

Đầu ra:

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

Nếu bạn cũng muốn xuất số đếm ở cuối, bạn có thể sử dụng

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

đó là bốn ký tự dài hơn.

Con trăn - 46 ký tự

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

Phiên bản có thể đọc được: Nó đã khá dễ đọc :-)

APL, 21 - 5 = 16

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

Mong đợi để tìm danh sách các từ như w. Trả về một danh sách các từ có chứa tất cả các nguyên âm, cộng với số lượng của chúng. Đã thử với ngn apl . Đây là một ví dụ .

Giải trình

         '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

Chỉnh sửa 34: Tốt nhất cho đến nay (từ @OI):

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

Chỉnh sửa 1: Tôi chỉ nhận thấy câu hỏi yêu cầu 'y' được bao gồm trong các nguyên âm, vì vậy tôi đã chỉnh sửa câu hỏi của mình cho phù hợp. Như @Nik đã chỉ ra trong một bình luận cho câu trả lời của anh ấy, "aeiouy".charslà một ký tự ít hơn%w[a e i o u y] , nhưng tôi sẽ rời bỏ cái sau, vì sự đa dạng, mặc dù tôi đang mạo hiểm những cơn ác mộng về cơ hội bị bỏ qua.

Chỉnh sửa 2: Cảm ơn @OI đã đề xuất cải tiến:

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

lưu 11 ký tự từ những gì tôi có trước đây.

Chỉnh sửa 3 và 3a: @OI đã loại bỏ một vài thứ nữa:

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

sau đó

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

và một lần nữa (3b):

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

Tôi chỉ là một người ghi chép!

Đây là hai giải pháp khó chịu hơn:

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

Ban đầu tôi có:

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

slà một chuỗi chứa các từ, được phân tách bằng dòng mới. Một mảng các từ từ sđó chứa tất cả năm nguyên âm được trả về. Đối với độc giả không quen thuộc với Ruby, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]và &là giao điểm mảng.

Giả sử

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

Trong khối {...}, ban đầu

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,

vì vậy "chữ viết tắt" không được chọn.

Nếu chuỗi scó thể chứa trùng lặp, s.split.select...có thể được thay thế bằng cách s.split.uniq.select...loại bỏ trùng lặp.

Chỉ cần lưu ý tôi có thể tiết kiệm 1 char bằng cách thay thế size==6bằng size>5.

Haskell - 67

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

Ruby - 28 ký tự (hoặc 27 nếu yđược loại trừ khỏi nguyên âm)

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

Lệnh hoàn thành để chạy là (48 ký tự):

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

EDIT: được thay thế putsbằng pnhư được đề xuất bởi @CarySwoveland

AWK - 29

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

Để chạy: Lưu danh sách từ viết thường vào wordlist.txt . Sau đó, làm:

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

Nếu hệ thống của bạn không có mawk,awk cũng có thể được sử dụng.

Bạn cũng có thể chạy nó từ một tệp bằng cách lưu chương trình program.awkvà thực hiện mawkhoặc awk -f program.awk.

Con trăn, 45 ký tự

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

k [22-5 = 17 ký tự]

Tôi đã đổi tên tập tin "corncob_lowercase.txt" thành "w"

Đếm các từ [22 ký tự]

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

Đầu ra

43

Tìm tất cả các từ [25 ký tự]

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

Tổng cộng 43 từ có chứa tất cả các nguyên âm (a e i o u y)

Đầu ra

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

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

Đây là phiên bản "ungolfyfied" Javascript và JScript của tôi164 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;}

Cảm ơn bạn @GaurangTandon cho search()chức năng này, đã tiết kiệm cho tôi một byte!

RegExp dựa trên hiệu suất HORRIBLE , nhưng hỗ trợ cả chữ hoa và chữ thường (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;}

RegExp dựa trên hiệu suất BETTER , BUT cần nhiều byte hơn (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;}

Cái này nếu chỉ để giải trí (175-5 byte) và sẽ không được tính là một câu trả lời:

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

Nó dựa trên câu trả lời đầu tiên, nhưng có một 'twist': Bạn có thể biết bao nhiêu lần một từ đã được tìm thấy.

Bạn chỉ cần làm như thế này:

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

Vì lengthnó không có tất cả các nguyên âm, nó sẽ không bị xóa và vẫn sẽ là một câu trả lời cho phần thưởng.

Bạn gọi cái đó như thế nào?

"Đơn giản": Bạn bọc chức năng bên trong ()và sau đó thêm ('string goes here');vào cuối.

Như thế này: (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');

Ví dụ này sẽ trả về một mảng chỉ với 1 chuỗi: yoiua

Tôi biết rằng đây là giải pháp tồi tệ nhất, nhưng hoạt động!

Tại sao tôi đếm -5?

Chà, mảng Javascript / JScript có thuộc tính ( length) trong mảng cho biết số lượng phần tử mà nó có.

Sau khi được xác nhận trong câu hỏi, phần thưởng của -5 là để nói số lượng từ.

Vì số lượng từ trong tài sản đó, tự động tôi có điểm -5.

Ruby 39 38

Hiện tại mục Ruby ngắn nhất khi đếm toàn bộ chương trình bao gồm đầu vào và đầu ra.

Đã lưu char bằng cách sử dụng mapthay vì each:

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

Một phiên bản khác, 39 ký tự với đầu ra đẹp hơn:

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

Cả hai chương trình đều nhận đầu vào từ stdin hoặc làm tên tệp được truyền dưới dạng đối số dòng lệnh:
$ ruby wovels.rb wordlist.txt

Nó có giá 3 nhân vật phụ để inclyde ynhư một cái xẻng.

Toán học (65 hoặc 314)

Hai cách tiếp cận rất khác nhau, cách tiếp cận tốt hơn đã được Belisarius đề xuất trong các bình luận cho phản ứng ban đầu của tôi. Đầu tiên, nỗ lực tàn bạo của tôi, thuật toán tạo ra mọi biểu thức chính quy có thể phù hợp với sự kết hợp của sáu nguyên âm (bao gồm cả "y"), và sau đó kiểm tra từng từ trong danh sách từ đối với mỗi một trong số 720 biểu thức chính quy này. Nó hoạt động, nhưng nó không ngắn gọn và chậm.

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 ký tự. Một số có thể được lưu thông qua việc sử dụng ký hiệu thay thế và các ký tự bổ sung bị mất khi chuẩn bị tệp từ điển dưới dạng danh sách các chuỗi (định dạng tự nhiên cho từ điển trong Mathicala. Các ngôn ngữ khác có thể không cần chuẩn bị này, nhưng Mathicala thì có). Nếu chúng tôi bỏ qua bước đó, giả sử nó đã được xử lý cho chúng tôi, cách tiếp cận tương tự có thể được thực hiện dưới 250 ký tự và nếu chúng tôi sử dụng từ điển tích hợp của Mathicala, chúng tôi còn nhận được khoản tiết kiệm lớn hơn,

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

Dưới 200 ký tự. Đếm số lượng từ tìm thấy chỉ yêu cầu chuyển kết quả đếnLength[Flatten[]] , có thể được thêm vào xung quanh một trong hai khối mã ở trên hoặc có thể được thực hiện sau đó, ví dụ,Length@Flatten@% . Danh sách từ được chỉ định cho thử thách này cho 43 kết quả phù hợp và từ điển Mathicala cho 64 (và nhanh hơn nhiều). Mỗi từ điển có từ phù hợp không phải trong từ khác. Mathicala tìm thấy "không có lợi", ví dụ, không có trong danh sách được chia sẻ và danh sách được chia sẻ tìm thấy "eukaryotic", không có trong từ điển của Mathicala.

Belisarius đề xuất một giải pháp tốt hơn rất nhiều. Giả sử danh sách từ đã được chuẩn bị và gán cho biến l, anh ta xác định một thử nghiệm duy nhất dựa trên StringFreeQ[]chức năng của Mathicala, sau đó áp dụng thử nghiệm này cho danh sách từ bằng cách sử dụng Pick[]hàm. 65 ký tự và nhanh hơn khoảng 400 lần so với cách tiếp cận của tôi.

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

Perl 6 - 35 ký tự

Lấy cảm hứng từ giải pháp Ruby của @CarySwoveland:

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

Lựa chọn này ( greps) mỗi dòng mà lợi nhuận Truecho <a e i o u y> ⊆ *.comb, mà chỉ là một cách ưa thích của yêu cầu "là Set ('a','e','i','o','u','y')một tập hợp con ( ⊆) của lệnh Set tạo thành từ các chữ cái của đầu vào ( *.comb)?"

Trên thực tế, cả hai <a e i o u y>và *.combchỉ tạo Lists: ⊆(hoặc (<=)nếu bạn bị kẹt trong ASCII) biến chúng thành Sets cho bạn.

Để có được số lượng dòng được in, tập lệnh 42 ký tự - 5 = 37 điểm này cũng sẽ xuất ra:

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

Tôi đã lưu một vài byte dấu ngoặc đơn nhờ vào sự trùng hợp may mắn của ưu tiên toán tử.

Javascript - Điểm = 124 - 5 = 119 !!!

Chỉnh sửa: 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}

Xin chân thành cảm ơn @Ismael Miguel đã giúp tôi cắt đứt ~ 12 ký tự !

Tôi đã loại bỏ biểu mẫu chức năng ký hiệu chất béo bởi vì mặc dù tôi đã thấy nó bắt đầu được sử dụng, nhưng nó không hoạt động. Không biết tại sao ...

Để làm cho nó hoạt động:

Truyền tất cả các từ được phân tách bằng dòng mới dưới dạng đối số cho hàm như dưới đây.

Kiểm tra:

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

Lấy đầu vào từ stdin.

sed 29 ký tự

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

Thứ tự được chọn từ tần số Thư trên wikipedia để kiểm tra tốc độ.

Trên máy chủ của tôi:

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

và

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

Lưu ý thứ tự các nguyên âm được thử nghiệm, ít thường xuyên nhất trước tiên. Đối với trường hợp thử nghiệm, việc này chạy nhanh gấp khoảng 3 lần so với thử nghiệm theo thứ tự aeiou y. Bằng cách đó, bài kiểm tra đầu tiên sẽ loại bỏ số lượng từ lớn hơn để các bài kiểm tra tiếp theo có ít việc phải làm hơn. Rõ ràng điều này không ảnh hưởng đến độ dài của mã. Nhiều giải pháp khác được đăng ở đây sẽ có lợi tương tự từ việc thực hiện các bài kiểm tra theo thứ tự này.

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

Chưa chơi gôn :

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ách sử dụng :C:\>rdmd vowels.d wordlist.txt

wordlist.txt phải chứa các từ danh sách chữ thường.

Rebol (104 ký tự)

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

Chưa chơi gôn:

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

dbây giờ chứa danh sách các từ tìm thấy. Dưới đây là một ví dụ từ bảng điều khiển 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 ký tự)

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

để lấy số đếm, hãy gửi #size đến bộ sưu tập kết quả. Bộ sưu tập kết quả chứa 43 từ ('tiết kiệm' 'có thẩm quyền' ... 'không nghi ngờ gì nữa' 'không thể nhận ra')

Mã ở trên có 77 ký tự, nhưng tôi có thể đã đổi tên tệp danh sách từ thành 'w', vì vậy tôi đếm tên tệp là 1 cho điểm 57.

Là đọc một phần của vấn đề hay không? Nếu không (xem các ví dụ khác) và danh sách các từ đã có trong bộ sưu tập c, thì mã giảm xuống:

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

đó là 36 ký tự (với khoảng trắng bỏ qua được loại bỏ).

đã cập nhật: không gian không cần thiết bị xóa

Rất chậm nhưng trong bash (81 ký tự):

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

EDIT: được echo $l|fold -w1thay thế bằng fold -w1<<<$lnhư được đề xuất bởi @ nyuszika7h

JavaScript - 95 byte

Đây là golf của tôi.

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

Và tôi cũng muốn chỉ ra rằng golf của bạn dường như không tìm thấy tất cả các lần xuất hiện của nguyên âm.

Ung dung:

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

sắp xếp + uniq + sed

Điều này không phù hợp với sự xuất hiện lặp đi lặp lại của một từ. Nó cũng không khớp với chữ 'y' nếu xảy ra ở đầu từ.

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

Không ngắn như OP, nhưng một dòng trong 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)))));}}

Định dạng:

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

Không có tâm trạng ngay bây giờ để thực hiện đếm nhưng nên dễ dàng. Đường dẫn đến danh sách từ (phiên bản chữ thường của) nên được chuyển đến chương trình dưới dạng đối số đầu tiên:

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

Đầu ra:

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

Tôi đã tự do xuất ra và phân tách các dấu phẩy; không được quy định nào trong các quy tắc (trạng thái "phải tìm tất cả các từ", không phải cách (và IF) để xuất).

Bao gồm số đếm (+ đầu ra): 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());}}

Đầu ra:

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

(Lưu ý số đếm ở cuối: 43)

Không có đầu ra ("phải tìm tất cả các từ"): 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)));}}

(Uốn các quy tắc một bitm một lần nữa: không thực sự) Điều này tìm thấy tất cả các từ và số lượng có sẵn bằng cách thực hiện r.Count().

C-sắc nét

Tôi chưa bao giờ làm điều này trước đây và tôi không chắc chắn chính xác các thủ tục đăng bài là gì. Nhưng đây là những gì tôi nghĩ ra:

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>trong tất cả các từ.

nếu bạn muốn hiển thị tổng cộng:

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

_{* 0 + 49c phút}

Điều này tạo ra một bảng liệt kê chứa tất cả các từ có chứa tất cả các nguyên âm.

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

Toán học - 136 102

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

Liên kết rút gọn đi đến http://www.mieliestronk.com/corncob_lowercase.txt