Ihr Programm muss alle Wörter in dieser Wortliste finden , die alle Vokale enthalten ( a e i o u y). Es gibt einfache Möglichkeiten, dies zu tun, aber ich suche nach der kürzesten Antwort. Ich werde jede Sprache nehmen, aber ich würde gerne Bash sehen.

Hier ist ein Beispiel (könnte stark verbessert werden):

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

Ihre Punktzahl ist die Länge des Codes.

-5 Punkte zum Zählen aller Vorkommen des Wortes.

Die niedrigste Punktzahl gewinnt.

GolfScript, 20 Zeichen - 5 = 15 Punkte

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

Basierend auf Howards Lösung , aber mit einem kürzeren Test ( \-!spart ein Zeichen mehr &,6=), kürzerer Länge ( .,+= 3 Zeichen) und kürzerer Ausgabeformatierung (niemand sagte, die Ausgabe müsse durch Zeilenumbrüche getrennt werden, `spart also ein Zeichen mehr n*).

Hier ist die Ausgabe, wenn die Wortliste in Kleinbuchstaben als Eingabe angegeben wird (aus Gründen der Lesbarkeit werden Zeilenumbrüche eingefügt):

["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. Technisch gesehen wäre die Herausforderung, die besagt, dass der Code für diese spezielle Eingabe funktionieren muss, n%{'aeiouy'\-!},`43noch ein Zeichen kürzer. Ich halte das jedoch für Betrug.)

Erläuterung:

• n% Teilt die Eingabe in Zeilenumbrüchen in ein Array auf.
• { }, ist ein "grep" -Operator, der den Code zwischen den geschweiften Klammern für jedes Element des Arrays ausführt und diejenigen auswählt, für die er einen wahren Wert zurückgibt.
  • Nimmt in der Schleife 'aeiouy'\-die Literalzeichenfolge aeiouyund entfernt alle im Kandidatenwort gefundenen Zeichen daraus. Das !negiert dann logischerweise die resultierende Zeichenfolge, wodurch man 1(true) , wenn die Zeichenfolge leer ist, und 0(false) , wenn es nicht.
• .,+ Erstellt eine Kopie des gefilterten Arrays, zählt die Anzahl der darin enthaltenen Wörter und hängt das Ergebnis an das ursprüngliche Array an.
• Zum `Schluss wird die Auswertung des Arrays aufgehoben und in eine Zeichenfolgendarstellung seines Inhalts umgewandelt. (Ohne sie würden die Wörter im Array einfach in der Ausgabe verkettet, was zu einem unlesbaren Durcheinander führen würde.)

GolfScript, 19 Zeichen

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

Verwendung:

golfscript vowels.gs < wordlist.txt

Ausgabe:

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

Wenn Sie die Zählung auch am Ende ausgeben möchten, können Sie verwenden

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

Das ist vier Zeichen länger.

Python - 46 Zeichen

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

Lesbare Version: Es ist schon ziemlich lesbar :-)

APL, 21 - 5 = 16

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

Erwartet, die Liste der Wörter als zu finden w. Gibt eine Liste der Wörter zurück, die alle Vokale enthalten, plus deren Anzahl. Getestet mit ngn apl . Hier ist ein Beispiel .

Erläuterung

         '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

Rubin 38

Edit 34: Best so weit (von @OI):

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

Bearbeiten 1: Ich habe gerade bemerkt, dass die Frage 'y' in den Vokalen enthalten sein soll. Deshalb habe ich meine Frage entsprechend bearbeitet. Wie @Nik in einem Kommentar zu seiner Antwort hervorhob, "aeiouy".charsist ein Charakter weniger als %w[a e i o u y], aber ich lasse Letzteres für die Vielfalt, obwohl ich Albträume riskiere, weil ich auf die Gelegenheit verzichte.

Edit 2: Danke an @OI für den Verbesserungsvorschlag:

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

Das spart 11 Zeichen von dem, was ich vorher hatte.

Edit 3 und 3a: @OI hat ein paar mehr abgeschlagen:

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

dann

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

und nochmal (3b):

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

Ich bin nur ein Schreiber!

Hier sind zwei weitere nicht wettbewerbsfähige Lösungen:

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

Anfangs hatte ich:

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

sist eine Zeichenfolge, die die durch Zeilenumbrüche getrennten Wörter enthält. Ein Array von Wörtern s, das alle fünf Vokale enthält, wird zurückgegeben. Für Leser, die mit Ruby nicht vertraut sind, %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]und &Array-Schnittmenge.

Annehmen

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

{...}Anfangs im Block

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,

"Abkürzungen" ist also nicht ausgewählt.

Wenn die Zeichenfolge smöglicherweise Duplikate enthält, s.split.select...können Sie diese durch s.split.uniq.select...Ersetzen ersetzen , um Duplikate zu entfernen.

Nur bemerkte ich durch Ersatz von 1 char retten könnte size==6mit size>5.

Haskell - 67

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

Ruby - 28 Zeichen (oder 27, wenn yaus Vokalen ausgeschlossen)

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

Der vollständige auszuführende Befehl lautet (48 Zeichen):

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

BEARBEITEN: ersetzt putsdurch pwie von @CarySwoveland vorgeschlagen

AWK - 29

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

Ausführen: Speichern Sie die Wortliste in Kleinbuchstaben unter wordlist.txt. Dann mach:

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

Wenn Ihr System nicht hat mawk, awkkann auch verwendet werden.

Sie können auch aus einer Datei ausführen , indem Sie das Programm zur Rettung program.awkund tun mawkoder awk -f program.awk.

Python, 45 Zeichen

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

k [22-5 = 17 Zeichen]

Ich habe die Datei "corncob_lowercase.txt" in "w" umbenannt

Zähle die Wörter [22 Zeichen]

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

Ausgabe

43

Alle Wörter finden [25 Zeichen]

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

Insgesamt 43 Wörter mit allen Vokalen (a e i o u y)

Ausgabe

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

Javascript / JScript 147 (152-5), 158 (163-5) oder 184 (189-5) Bytes:

Hier ist meine Javascript und JScript schrecklich "ungolfyfied" Version (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;}

Vielen Dank an @GaurangTandon für die search()Funktion, die mir ein Byte erspart hat !

RegExp basiert auf der HORRIBLE- Leistung, unterstützt jedoch sowohl Groß- als auch Kleinbuchstaben (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 basiert auf BESSERER Leistung, ABER benötigt viel mehr 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;}

Dies ist nur zum Spaß (175-5 Bytes) und wird nicht als Antwort gewertet:

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

Es basiert auf der ersten Antwort, hat aber eine Wendung: Sie können wissen, wie oft ein Wort gefunden wurde.

Das macht man einfach so:

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

Da das lengthnicht alle Vokale hat, wird es nicht gelöscht und wäre trotzdem eine Antwort für den Bonus.

Wie nennst du das?

"Einfach": Sie binden die Funktion ein ()und fügen ('string goes here');sie am Ende hinzu.

So was: (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');

In diesem Beispiel wird nur ein Array mit 1 Zeichenfolge zurückgegeben: yoiuae

Ich weiß, dass dies die schlechteste Lösung ist, aber es funktioniert!

Warum zähle ich -5?

Nun, Javascript / JScript-Arrays haben eine Eigenschaft ( length) in Arrays, die die Anzahl der Elemente angibt, die sie haben.

Nachdem die Frage bestätigt wurde, gibt der Bonus von -5 die Anzahl der Wörter an.

Da die Anzahl der Wörter in dieser Eigenschaft ist, habe ich automatisch die Punktzahl von -5.

Ruby 39 38

Derzeit der kürzeste Ruby-Eintrag, wenn das gesamte Programm einschließlich Ein- und Ausgabe gezählt wird.

Ein Zeichen gespeichert durch Verwenden von mapanstelle von each:

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

Eine andere Version, 39 Zeichen mit schönerer Ausgabe:

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

Beide Programme erhalten Eingaben von stdin oder als Dateinamen, der als Befehlszeilenargument übergeben wird:
$ ruby wovels.rb wordlist.txt

Es kostet 3 zusätzliche Charaktere, um sich yals Wovel einzuschalten.

Mathematica (65 oder 314)

Zwei sehr unterschiedliche Ansätze, der bessere wurde von Belisarius in den Kommentaren zu meiner ersten Antwort vorgeschlagen. Zuerst meine brutale Anstrengung, die algorithmisch jeden möglichen regulären Ausdruck generiert, der mit einer Kombination von sechs Vokalen (einschließlich "y") übereinstimmt, und dann jedes Wort in der Zielwortliste mit jedem dieser 720 regulären Ausdrücke vergleicht. Es funktioniert, aber es ist nicht sehr präzise und es ist langsam.

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 Zeichen. Einige können durch Verwendung einer alternativen Notation gespeichert werden, und zusätzliche Zeichen gehen verloren, wenn die Wörterbuchdatei als Liste von Zeichenfolgen vorbereitet wird (das natürliche Format für das Wörterbuch in Mathematica. Andere Sprachen benötigen diese Vorbereitung möglicherweise nicht, Mathematica jedoch). Wenn wir diesen Schritt weglassen und davon ausgehen, dass er für uns erledigt wurde, kann derselbe Ansatz in weniger als 250 Zeichen ausgeführt werden, und wenn wir das in Mathematica integrierte Wörterbuch verwenden, erzielen wir noch größere Einsparungen.

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

Unter 200 Zeichen. Das Zählen der Anzahl der gefundenen Wörter erfordert nur das Übergeben des Ergebnisses an Length[Flatten[]], das entweder um einen der obigen Codeblöcke herum oder anschließend mit beispielsweise hinzugefügt werden kann Length@Flatten@%. Die für diese Herausforderung angegebene Wortliste enthält 43 Übereinstimmungen, und das Mathematica-Wörterbuch enthält 64 (und ist viel schneller). Jedes Wörterbuch enthält übereinstimmende Wörter, die nicht im anderen enthalten sind. Mathematica findet beispielsweise "unprofessionell", was nicht in der freigegebenen Liste enthalten ist, und die freigegebene Liste findet "eukaryotisch", was nicht in Mathematics Wörterbuch enthalten ist.

Belisarius schlug eine weitaus bessere Lösung vor. Unter der Annahme, dass die Wortliste bereits erstellt und der Variablen zugewiesen wurde l, definiert er einen einzelnen Test basierend auf der StringFreeQ[]Funktion von Mathematica und wendet diesen Test dann mit der Pick[]Funktion auf die Wortliste an . 65 Zeichen, und es ist etwa 400-mal schneller als mein Ansatz.

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

Perl 6 - 35 Zeichen

Inspiriert von der Ruby-Lösung von @CarySwoveland:

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

Dies wählt grepjede Zeile aus, Truefür <a e i o u y> ⊆ *.combdie ein Wert zurückgegeben wird. Dies ist nur eine ungewöhnliche Art zu fragen: "Ist das Set ('a','e','i','o','u','y')eine Teilmenge ( ⊆) des Sets, die sich aus den Buchstaben der Eingabe ( *.comb) zusammensetzt?"

Eigentlich machen beide <a e i o u y>und *.combnur Lists: ⊆(oder (<=)wenn Sie in ASCII stecken bleiben) sie zu Sets für Sie.

Um die Anzahl der gedruckten Zeilen zu erhalten, gibt dieses Skript mit 42 Zeichen und 5 = 37 Punkten Folgendes aus:

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

Ich habe dank eines glücklichen Zufalls der Operator-Priorität mehrere Bytes Klammern gespart.

Javascript - Ergebnis = 124 - 5 = 119 !!!

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

Vielen Dank an @Ismael Miguel, der mir geholfen hat, ~ 12 Zeichen abzuschneiden !

Ich habe das Formular für die Fettpfeilnotation entfernt, da es, obwohl ich gesehen habe, nicht funktioniert. Keine Ahnung warum ...

Damit es funktioniert:

Übergeben Sie alle durch Newline getrennten Wörter als Argument an die unten gezeigte Funktion.

Prüfung:

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

Übernimmt die Eingabe von stdin.

sed 29 Zeichen

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

Reihenfolge von Buchstabenhäufigkeit auf Wikipedia zur Geschwindigkeitskontrolle gewählt.

Auf meinem Gastgeber:

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

und

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

Beachten Sie die Reihenfolge der getesteten Vokale, am seltensten zuerst. Für den Testfall läuft dies etwa dreimal so schnell wie das Testen, um dies zu erreichen. Auf diese Weise werden beim ersten Test mehr Wörter entfernt, sodass nachfolgende Tests weniger Arbeit erfordern. Offensichtlich hat dies keine Auswirkung auf die Länge des Codes. Viele der anderen hier aufgeführten Lösungen würden in ähnlicher Weise von der Durchführung der Tests in dieser Reihenfolge profitieren.

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

Nicht golfen :

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

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

wordlist.txt muss die Wörter der Kleinbuchstabenliste enthalten.

Rebol (104 Zeichen)

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

Nicht golfen:

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

dEnthält jetzt eine Liste der gefundenen Wörter. Hier ist ein Beispiel von der Rebol-Konsole:

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

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

Um die Anzahl zu ermitteln, senden Sie #size an die resultierende Sammlung. Die Ergebnissammlung enthält 43 Wörter ("enthaltsam", "maßgeblich", "fraglos", "nicht erkennbar").

Der obige Code hat 77 Zeichen, aber ich hätte die Wortlistendatei in 'w' umbenennen können, also zähle ich den Dateinamen als 1, was eine Punktzahl von 57 ergibt.

Gehört das Lesen der Datei zum Problem oder nicht? Ist dies nicht der Fall (siehe andere Beispiele) und befindet sich die Wortliste bereits in einer Sammlung c, reduziert sich der Code auf:

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

Das sind 36 Zeichen (wobei das Leerzeichen weggelassen wird).

aktualisiert: unnötige Leerzeichen entfernt

Sehr langsam, aber in Bash (81 Zeichen):

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

EDIT: echo $l|fold -w1ersetzt durch fold -w1<<<$lwie von @ nyuszika7h vorgeschlagen

JavaScript - 95 Byte

Hier ist mein Golf.

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

Und ich möchte auch darauf hinweisen, dass Ihr Golf nicht alle Vorkommen von Vokalen zu finden scheint.

Ungolfed:

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

sort + uniq + sed

Dieser stimmt nicht mit wiederholten Vorkommen eines Wortes überein. Es stimmt auch nicht mit dem Buchstaben 'y' überein, wenn es am Anfang eines Wortes steht.

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

Nicht so kurz wie die OPs, aber eine Zeile 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)))));}}

Formatiert:

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

Derzeit nicht in der Stimmung, das Zählen zu implementieren , sollte aber einfach sein. Der Pfad zur (Kleinbuchstaben-) Wortliste sollte als erstes Argument an das Programm übergeben werden:

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

Ausgabe:

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

Ich ließ mir die Freiheit, die Wörter auszugeben und durch Kommas zu trennen. Keiner von beiden ist in den Regeln festgelegt (welcher Status "muss alle Wörter finden", nicht wie (und WENN) auszugeben ist).

Einschließlich Anzahl (+ Ausgabe): 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());}}

Ausgabe:

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

(Beachten Sie die Zählung am Ende: 43)

Keine Ausgabe ( „must finden alle Worte“): 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)));}}

(Biege die Regeln dann nochmal ein Bitm: nicht wirklich) Dies findet alle Wörter und die Zählung ist durch Ausführen verfügbar r.Count().

C-Sharp

Ich habe das noch nie zuvor gemacht und bin mir nicht ganz sicher, wie die Postings ablaufen. Aber das habe ich mir ausgedacht:

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> von allen Wörtern.

Wenn Sie eine Gesamtsumme anzeigen möchten:

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

_{* 0 + 49 c min}

Dadurch wird eine Aufzählung erstellt, die alle Wörter enthält, die alle Vokale enthalten.

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

Der verkürzte Link geht zu http://www.mieliestronk.com/corncob_lowercase.txt