Twój program musi znaleźć wszystkie słowa z tej listy słów, które zawierają wszystkie samogłoski ( a e i o u y). Są na to łatwe sposoby, ale szukam najkrótszej odpowiedzi. Wezmę dowolny język, ale chciałbym zobaczyć Basha.

Oto przykład (można go znacznie poprawić):

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

Twój wynik to długość kodu.

-5 punktów za policzenie wszystkich wystąpień słowa.

Najniższy wynik wygrywa.

GolfScript, 20 znaków - 5 = 15 punktów

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

Oparty na rozwiązaniu Howarda , ale przy użyciu krótszego testu ( \-!zapisuje jeden znak &,6=), krótszego dodawania długości ( .,+= 3 znaki) i krótszego formatowania danych wyjściowych (nikt nie powiedział, że dane wyjściowe muszą być oddzielone znakiem nowej linii, więc `zapisuje się jeden znak n*).

Oto wynik, biorąc pod uwagę listę słów pisaną małymi literami jako dane wejściowe (wstawiono podział wierszy w celu zapewnienia czytelności):

["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. Technicznie, biorąc pod uwagę, że wyzwanie mówi tylko, że kod musi działać dla tego konkretnego wkładu, n%{'aeiouy'\-!},`43byłby jeszcze o jeden znak krótszy. Myślę jednak, że to oszustwo.)

Wyjaśnienie:

• n% dzieli dane wejściowe na nowej linii na tablicę.
• { }, jest operatorem „grep”, który wykonuje kod między nawiasami klamrowymi dla każdego elementu tablicy i wybiera te, dla których zwraca prawdziwą wartość.
  • Wewnątrz pętli 'aeiouy'\-bierze dosłowny ciąg znaków aeiouyi usuwa z niego wszystkie znaki znalezione w kandydującym słowie. !Następnie logicznie neguje wynikowy ciąg, otrzymując 1(prawda), jeśli ciąg jest pusta i 0(fałsz), jeśli tak nie jest.
• .,+ tworzy kopię filtrowanej tablicy, liczy liczbę słów w niej i dołącza wynik do oryginalnej tablicy.
• Na koniec `un-ewaluuje tablicę, przekształcając ją w ciąg znaków reprezentujący jej zawartość. (Bez tego słowa w tablicy byłyby po prostu konkatenowane w danych wyjściowych, powodując nieczytelny bałagan).

GolfScript, 19 znaków

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

Stosowanie:

golfscript vowels.gs < wordlist.txt

Wydajność:

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

Jeśli chcesz również podać liczbę na końcu, możesz użyć

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

który jest o cztery znaki dłuższy.

Python - 46 znaków

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

Wersja do odczytu: Jest już dość czytelna :-)

APL, 21-5 = 16

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

Oczekuje znaleźć listę słów jako w. Zwraca listę słów zawierających wszystkie samogłoski oraz ich liczbę. Testowane przy pomocy ngn apl . Oto przykład .

Wyjaśnienie

         '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

Rubinowy 38

Edycja 34: Najlepsze do tej pory (z @OI):

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

Edycja 1: Właśnie zauważyłem pytanie o włączenie „y” wśród samogłosek, więc odpowiednio zmodyfikowałem swoje pytanie. Jak zauważył @Nik w komentarzu do swojej odpowiedzi, "aeiouy".charsjedna postać jest mniejsza niż %w[a e i o u y], ale zostawiam tę drugą, dla różnorodności, mimo że ryzykuję koszmary z powodu utraconej okazji.

Edycja 2: Podziękowania dla @OI za zasugerowanie ulepszenia:

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

co oszczędza 11 znaków od tego, co miałem wcześniej.

Edytuj 3 i 3a: @OI straciło jeszcze kilka:

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

następnie

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

i ponownie (3b):

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

Jestem zwykłym pisarzem!

Oto dwa kolejne niekonkurencyjne rozwiązania:

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

Początkowo miałem:

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

sjest ciągiem zawierającym słowa oddzielone znakami nowej linii. Zwracana jest tablica słów szawierająca wszystkie pięć samogłosek. Dla czytelników niezaznajomionych z Ruby %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]i &przecięciem tablic.

Przypuszczać

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

{...}Początkowo w bloku

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,

więc „skróty” nie są zaznaczone.

Jeśli ciąg smoże zawierać duplikaty, s.split.select...może zostać zastąpiony przez, s.split.uniq.select...aby usunąć duplikaty.

Właśnie zauważyłem, że mogę uratować 1 znak, zastępując size==6go size>5.

Haskell - 67

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

Rubinowy - 28 znaków (lub 27, jeśli ywykluczono z samogłosek)

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

Pełne polecenie do uruchomienia to (48 znaków):

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

EDYCJA: zastąpiona zgodnie putsz psugestią @CarySwoveland

AWK - 29

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

Aby uruchomić: Zapisz listę słów pisaną małymi literami wordlist.txt. Następnie wykonaj:

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

Jeśli twój system nie ma mawk, awkmożna go również użyć.

Możesz również uruchomić go z pliku, zapisując program program.awki wykonując mawklub awk -f program.awk.

Python, 45 znaków

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

k [22-5 = 17 znaków]

Nazwa pliku „corncob_lowercase.txt” zmieniłem na „w”

Policz słowa [22 znaków]

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

Wydajność

43

Znajdź wszystkie słowa [25 znaków]

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

Ogółem 43 słowa zawierające wszystkie samogłoski (a e i o u y)

Wydajność

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

JavaScript / JScript 147 (152-5), 158 (163-5) lub 184 (189-5) bajtów:

Oto moja wersja JavaScript i JScript strasznie „niefunkcjonalna” (164 152 152-5 = 147 bajtów):

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

Dziękuję @GaurangTandon za search()funkcję, która uratowała mi bajt!

RegExp oparty na wydajności HORRIBLE , ale obsługuje zarówno wielkie, jak i małe litery (163-5 = 158 bajtów):

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 oparty na lepszej wydajności, ALE zajmuje o wiele więcej bajtów (189-5 = 184 bajtów):

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

Ten, jeśli tylko dla zabawy (175-5 bajtów) i nie będzie liczony jako odpowiedź:

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

Opiera się na pierwszej odpowiedzi, ale ma „zwrot akcji”: możesz wiedzieć, ile razy znaleziono słowo.

Po prostu robisz tak:

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

Ponieważ lengthto nie ma wszystkich samogłosek, nie zostanie usunięte i nadal będzie odpowiedzią na bonus.

Jak to nazywasz?

„Prosty”: zawijasz funkcję w środku, ()a następnie dodajesz ('string goes here');do końca.

Lubię to: (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');

Ten przykład zwróci tablicę tylko z 1 ciągiem: yoiuae

Wiem, że to najgorsze rozwiązanie, ale działa!

Dlaczego liczę -5?

Cóż, tablice JavaScript / JScript mają w tablicach właściwość ( length), która określa liczbę elementów, które ma.

Po potwierdzeniu w pytaniu premia -5 oznacza podanie liczby słów.

Ponieważ liczba słów znajduje się w tej właściwości, automatycznie mam wynik -5.

Rubinowy 39 38

Obecnie najkrótszy wpis w języku Ruby podczas liczenia całego programu, w tym wejścia i wyjścia.

Zapisano znak, używając mapzamiast each:

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

Inna wersja, 39 znaków z ładniejszym wyjściem:

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

Oba programy pobierają dane wejściowe ze standardowego wejścia lub jako nazwę pliku przekazywaną jako argument wiersza poleceń:
$ ruby wovels.rb wordlist.txt

Kosztuje 3 dodatkowe postacie, aby wznosić się yjako wowel.

Matematyka (65 lub 314)

Dwa bardzo różne podejścia, lepsze zaproponował Belizariusz w komentarzach do mojej pierwszej odpowiedzi. Po pierwsze, mój brutalny wysiłek, który algorytmicznie generuje każde możliwe wyrażenie regularne pasujące do kombinacji sześciu samogłosek (w tym „y”), a następnie sprawdza każde słowo na docelowej liście słów względem każdego z tych 720 wyrażeń regularnych. Działa, ale nie jest zbyt zwięzły i powolny.

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 znaków. Kilka można zapisać za pomocą alternatywnej notacji, a dodatkowe znaki są tracone przygotowując plik słownika jako listę ciągów (naturalny format słownika w Mathematica. Inne języki mogą nie potrzebować tego prepa, ale Mathematica tak robi). Jeśli pominiemy ten krok, zakładając, że został on wykonany za nas, to samo podejście można wykonać w mniej niż 250 znakach, a jeśli użyjemy wbudowanego słownika Mathematica, uzyskamy jeszcze większe oszczędności,

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

Poniżej 200 znaków. Zliczenie liczby znalezionych słów wymaga jedynie przekazania wyniku Length[Flatten[]], który można dodać do dowolnego bloku kodu powyżej lub można to zrobić na przykład za pomocą Length@Flatten@%. Lista słów określona dla tego wyzwania daje 43 dopasowania, a słownik Mathematica daje 64 (i jest znacznie szybszy). Każdy słownik ma pasujące słowa, których nie ma w drugim. Na przykład Mathematica znajduje „nieprofesjonalnie”, którego nie ma na wspólnej liście, a na wspólnej liście znajduje się „eukariotyczny”, którego nie ma w słowniku Mathematiki.

Belizariusz zaproponował znacznie lepsze rozwiązanie. Zakładając, że lista słów została już przygotowana i przypisana do zmiennej l, definiuje pojedynczy test oparty na StringFreeQ[]funkcji Mathematiki , a następnie stosuje ten test do listy słów za pomocą tej Pick[]funkcji. 65 znaków, a to około 400 razy szybciej niż moje podejście.

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

Perl 6-35 znaków

Zainspirowany Rubinowym rozwiązaniem @CarySwoveland:

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

Wybiera ( grepy), że każda linia powróci Truedo <a e i o u y> ⊆ *.comb, który to sposób fantazyjny pytać „jest zbiorem ('a','e','i','o','u','y')podzbiorem ( ⊆) o Zestaw składa się z liter input ( *.comb)?”

W rzeczywistości oba <a e i o u y>i *.combtylko tworzą Lists: ⊆(lub (<=)jeśli utkniesz w ASCII) zamienia je w Sets dla ciebie.

Aby uzyskać liczbę wydrukowanych wierszy, ten 42-znakowy - 5 = 37 punktowy skrypt również wyświetli:

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

C - 96 bajtów

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

Zaoszczędziłem kilka bajtów nawiasów dzięki szczęśliwemu przypadkowi pierwszeństwa operatorów.

JavaScript - wynik = 124 - 5 = 119 !!!

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

Ogromne podziękowania dla @Ismael Miguel za pomoc w odcięciu ~ 12 znaków !

Usunąłem formularz funkcji zapisywania grubych strzałek, ponieważ chociaż widziałem, że zaczął on być używany, nie działa. Nie mam pojęcia, dlaczego ...

Aby to działało:

Przekaż wszystkie słowa oddzielone znakiem nowej linii jako argument do funkcji, jak pokazano poniżej.

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`

Pobiera dane wejściowe ze standardowego wejścia.

sed 29 znaków

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

Zamów wybrane z Częstotliwości liter na wikipedii, aby sprawdzić szybkość.

Na moim hoście:

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

i

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

Bash (grep) - 36 bajtów

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

Zwróć uwagę na kolejność testowanych samogłosek, od najmniejszej częstotliwości. W przypadku testowym przebiega to około 3 razy szybciej niż testowanie w kolejności aeiou y. W ten sposób pierwszy test usuwa większą liczbę słów, więc kolejne testy mają mniej pracy. Oczywiście nie ma to wpływu na długość kodu. Wiele innych opublikowanych tutaj rozwiązań skorzystałoby podobnie z wykonania testów w tej kolejności.

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

Bez golfa :

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

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

wordlist.txt musi zawierać słowa z małej litery.

Rebol (104 znaki)

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

Bez golfa:

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

dteraz zawiera listę znalezionych słów. Oto przykład z konsoli 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 znaków)

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

aby uzyskać liczbę, wyślij #size do wynikowej kolekcji. Zbiór wyników zawiera 43 słowa („abstemicznie” „autorytatywnie” ... „bezsprzecznie” „nie do poznania”)

Powyższy kod ma 77 znaków, ale mógłbym zmienić nazwę pliku listy słów na „w”, więc liczę nazwę pliku jako 1, co daje wynik 57.

Czy odczytanie pliku jest częścią problemu, czy nie? Jeśli nie (patrz inne przykłady), a lista słów znajduje się już w kolekcji c, kod ogranicza się do:

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

czyli 36 znaków (z usuniętymi do pominięcia spacjami).

zaktualizowano: niepotrzebne spacje zostały usunięte

Bardzo wolno, ale w bash (81 znaków):

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

EDYCJA: echo $l|fold -w1zastąpiona fold -w1<<<$lzgodnie z sugestią @ nyuszika7h

JavaScript - 95 bajtów

Oto mój golf.

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

Chciałbym również zwrócić uwagę, że w twoim golfie wydaje się, że nie występują wszystkie wystąpienia samogłosek.

Nie golfowany:

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

Ten nie pasuje do powtarzających się wystąpień słowa. Nie pasuje również do litery „y”, jeśli występuje na początku słowa.

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' 

Grzmotnąć

Nie tak krótkie jak PO, ale jedna linia w 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)))));}}

Sformatowany:

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

W tej chwili nie masz ochoty na liczenie, ale powinno to być łatwe. Ścieżka do listy słów (mała wersja) powinna zostać przekazana do programu jako pierwszy argument:

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

Wydajność:

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

Pozwoliłem sobie na wypisywanie słów i rozdzielanie ich przecinkami; żadne z nich nie jest określone w regułach (który stan „musi znaleźć wszystkie słowa”, a nie jak (i ​​JEŻELI), aby uzyskać dane wyjściowe.

Łącznie z liczbą (+ wyjście): 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());}}

Wydajność:

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

(Uwaga liczba na końcu: 43)

Brak danych wyjściowych („należy znaleźć wszystkie słowa”): 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)));}}

(Ponownie zginam reguły trochę: nie bardzo) Znajduje to wszystkie słowa, a liczenie jest dostępne po wykonaniu r.Count().

C-Sharp

Nigdy wcześniej tego nie robiłem i nie jestem pewien, jakie są procedury delegowania. Ale oto co wymyśliłem:

185 bajtów

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>wszystkich słów.

jeśli chcesz wyświetlić sumę:

219 - 5 = 214 bajtów

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

_{* 0 + 49c min}

Spowoduje to utworzenie wyliczenia zawierającego wszystkie słowa zawierające wszystkie samogłoski.

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

Matematyka - 136 102

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

Skrócony link prowadzi do strony http://www.mieliestronk.com/corncob_lowercase.txt