Encontre palavras que contenham todas as vogais

28

Seu programa deve encontrar todas as palavras nesta lista de palavras que contenham todas as vogais ( a e i o u y). Existem maneiras fáceis de fazer isso, mas estou procurando a resposta mais curta. Vou usar qualquer idioma, mas gostaria de ver o Bash.

Aqui está um exemplo (poderia ser muito melhorado):

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

Sua pontuação é o comprimento do código.

-5 pontos para contar todas as ocorrências da palavra.

Menor pontuação ganha.

O médico
fonte
11
esse perfil. muitas fotos. muito doge. Uau.
Maçaneta
2
17 respostas e contando! Gostaria de ver mais perguntas como a sua em cg, doc. Muitas vezes eu vou ver algo interessante aqui, mas não têm as várias horas de tempo necessário para produzir uma solução decente ...
Cary Swoveland
2
Sim, mas não pode ser um idioma dedicado à busca de vogais.
TheDoctor 15/02
1
@TheDoctor Shakes fist
Jason C
2
se tiver um bônus, não será um código de golfe. Use o desafio do código.
Tim Seguine

Respostas:

7

GolfScript, 20 caracteres - 5 = 15 pontos

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

Com base na solução de Howard , mas usando um teste mais curto ( \-!economiza um caractere mais &,6=), anexos de comprimento mais curtos ( .,+= 3 caracteres) e formatação de saída mais curta (ninguém disse que a saída tinha que ser separada por nova linha, portanto, `economiza um caractere n*).

Aqui está a saída, considerando a lista de palavras em minúsculas como entrada (quebras de linha inseridas para facilitar a leitura):

["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. Tecnicamente, dado que o desafio diz apenas que o código precisa trabalhar para essa entrada específica, n%{'aeiouy'\-!},`43seria um caractere mais curto ainda. Porém, considero que trapaça.)


Explicação:

  • n% divide a entrada em novas linhas em uma matriz.
  • { }, é um operador "grep", executando o código entre chaves entre cada elemento da matriz e selecionando aqueles para os quais ele retorna um valor verdadeiro.
    • Dentro do loop, 'aeiouy'\-pega a string literal aeiouye remove todos os caracteres encontrados na palavra candidata. Em !seguida, nega logicamente a string resultante, produzindo 1(true) se a string está vazia e 0(false) se não estiver.
  • .,+ faz uma cópia da matriz filtrada, conta o número de palavras e anexa o resultado à matriz original.
  • Por fim, `desvaloriza a matriz, convertendo-a em uma representação de string de seu conteúdo. (Sem ele, as palavras na matriz seriam simplesmente concatenadas na saída, produzindo uma confusão ilegível.)
Ilmari Karonen
fonte
Parabéns!! menor resposta !!!!
TheDoctor
abstenciona e facetariamente são a única palavra com todas as 6 vogais em ordem. Só pensei em compartilhar isso com você. Eu achei legal.
precisa saber é o seguinte
15

GolfScript, 19 caracteres

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

Uso:

golfscript vowels.gs < wordlist.txt

Saída:

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

Se você também quiser exibir a contagem no final, poderá usar

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

que tem mais quatro caracteres.

Howard
fonte
1
Eu gosto disso! Pode ser 4 caracteres a mais, mas você recebe um bônus de -5 pt
TheDoctor
11

Python - 46 caracteres

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

Versão legível: já é bastante legível :-)

yegle
fonte
8

APL, 21-5 = 16

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

Espera encontrar a lista de palavras como w. Retorna uma lista das palavras que contêm todas as vogais, além de sua contagem. Testado com ngn apl . Aqui está um exemplo .

Explicação

         '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
Tobia
fonte
8

Ruby 38

Edição 34: Melhor até agora (da @OI):

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

Edit 1: Acabei de notar que a pergunta solicitada para 'y' ser incluída entre as vogais, por isso editei minha pergunta de acordo. Como @Nik apontou em um comentário para sua resposta, "aeiouy".charsum caractere é menor que%w[a e i o u y] , mas deixarei o último por diversidade, mesmo que eu esteja arriscando pesadelos com a oportunidade perdida.

Edição 2: Agradecemos à @OI por sugerir a melhoria:

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

que salva 11 caracteres do que eu tinha antes.

Edite 3 e 3a: a @OI interrompe mais algumas:

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

then

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

e novamente (3b):

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

Eu sou um mero escriba!

Aqui estão mais duas soluções pouco complexas:

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

Inicialmente tive:

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

sé uma sequência que contém as palavras, separadas por novas linhas. Uma matriz de palavras scontendo as cinco vogais é retornada. Para leitores não familiarizados com Ruby %w[a e i o u y] #=> ["a", "e", "i", "o", "u", "y"]e com &interseção de matriz.

Suponha

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

No bloco {...}, inicialmente

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,

então "abreviações" não está selecionada.

Se a sequência spode conter duplicatas, s.split.select...pode ser substituída por s.split.uniq.select...para remover duplicatas.

Só notei que eu poderia salvar 1 caractere substituindo size==6por size>5.

Cary Swoveland
fonte
1
...size=5é um bug - deve ser...size==5
Uri Agassi
Obrigado, @Uri, por apontar o erro de digitação na primeira linha, que corrigi (não é um bug - veja a linha acima 'para que "abreviações" não sejam selecionadas').
Cary Swoveland
@CarySwoveland Você pode salvar 11 caracteres fazendo o seguinte:s.split.select{|w|'aeiouy'.delete(w)==''}
OI
Isso é ótimo, @OI. Eu fiz uma edição e encontrei um lugar que nas células cinzentas.
Cary Swoveland
@CarySwoveland Isto vai poupar mais 1 caráter: s.split.select{|w|'aeiouy'.tr(w,'')==''}. Tenho certeza de que você pode obter isso com menos de 40 caracteres se usar a lógica nil e o método String 'certo'. Ainda está procurando ... #
03 de OI
6

Haskell - 67

main=interact$unlines.filter(and.flip map "aeiouy".flip elem).lines
polandeer
fonte
2
Este é o código-golf , você deve tentar tornar o código mais curto, por exemplo, através da remoção de espaços em branco ...
mniip
6

Ruby - 28 caracteres (ou 27 se yfor excluído das vogais)

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

O comando completo a ser executado é (48 caracteres):

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

EDIT: substituído putspor pconforme sugerido por @CarySwoveland

Nik O'Lai
fonte
Bom, @Nik. %w[a e i o u]economizaria 1 caractere ppor putsmais 3.
Cary Swoveland
Obrigado, @CarySwoveland! Eu esqueci p, eu raramente uso. Quanto a% w [], se y estiver incluído no conjunto de vogais, a versão com caracteres será ainda mais curta.
Nik O'Lai
@ NikO'Lai "aeiouy".delete(s)==''pode economizar alguns caracteres.
OI
Muito agradável! Publique como sua própria solução, @OI. Vou votá-lo #
584 Nik O'Lai
4

AWK - 29

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

Para executar: salve a lista de palavras em minúsculas em wordlist.txt. Então faça:

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

Se o seu sistema não possuir mawk, também awkpode ser usado.

Você também pode executá-lo a partir de um arquivo, salvando o programa em program.awke executando mawkor awk -f program.awk.

cocolover76
fonte
Escolher a ordem certa acelera o trabalho: '/y/&&/u/&&/i/&&/o/&&/a/&&/e/'!!
F. Hauri 27/03
4

Python, 45 caracteres

[w for w in open(f) if set('aeiouy')<=set(w)]
Justin Fay
fonte
3

k [22-5 = 17 caracteres]

Renomeei o arquivo "corncob_lowercase.txt" para "w"

Conte as palavras [22 caracteres]

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

Saída

43

Encontre todas as palavras [25 caracteres]

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

No geral 43 palavras contendo todas as vogais (a e i o u y)

Saída

"abstemiously"
"authoritatively"
"behaviourally"
..
..
"unintentionally"
"unquestionably"
"unrecognisably"
Nyi
fonte
3

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

Aqui está minha versão Javascript e JScript horrivelmente "não-golfizada" (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;}

Obrigado @GaurangTandon pela search()função, que me salvou um byte!

RegExp baseado em desempenho HORRÍVEL , mas suporta letras maiúsculas e minúsculas (163-5 = 158 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+=RegExp(c[z],'i').test(s[k]);i==6&&(r[r.length]=s[k]);}return r;}

RegExp com melhor desempenho, MAS leva muito mais 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;}


Este é apenas por diversão (175-5 bytes) e não conta como resposta:

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

Baseia-se na 1ª resposta, mas tem uma "reviravolta": você pode saber quantas vezes uma palavra foi encontrada.

Você simplesmente faz assim:

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

Desde que length não tem todas as vogais, não será excluído e ainda seria uma resposta para o bônus.


Como você chama isso?

"Simples": você quebra a função por dentro ()e depois adiciona('string goes here'); ao final.

Como isso: (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');

Este exemplo retornará uma matriz apenas com 1 string: yoiuae

Eu sei que esta é a pior solução, mas funciona!


Por que estou contando -5?

Bem, matrizes Javascript / JScript têm uma propriedade ( length) em matrizes que informa o número de elementos que ela possui.

Depois de confirmado na pergunta, o bônus de -5 é para dizer o número de palavras.

Como o número de palavras está nessa propriedade, automaticamente tenho a pontuação de -5.

Ismael Miguel
fonte
Pode estar interessado em search()vez de indexOf()salvar 1 caractere.
Gaurang Tandon
Além disso, tanto quanto eu posso ver, na sua versão mais curta, você não precisa do .split()on "aeiouy". JS faz um loop sobre uma matriz e uma string da mesma maneira. (Removendo o conserva ~ 10 caracteres)
Gaurang Tandon
2

Ruby 39 38

Atualmente, a menor entrada Ruby ao contar todo o programa, incluindo entrada e saída.

Salve um char usando em mapvez de each:

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

Outra versão, 39 caracteres com saída mais bonita:

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

Ambos os programas recebem entrada de stdin ou como um nome de arquivo passado como argumento de linha de comando:
$ ruby wovels.rb wordlist.txt

Custa 3 caracteres extras para inclyde ycomo um wovel.

daniero
fonte
De qualquer maneira usar Enumerable#greppara encurtar isso? por exemplo, s.split.grep /a*e*i*o*u*y/supondo que sseja uma sequência de palavras separadas por novas linhas.
OI
@OI Uma idéia interessante, mas precisaria de algumas brincadeiras, porque o regex tem as vigas em uma ordem fixa. É por isso que repito a corda 5 vezes antes de .*combiná- la, entre as varetas.
Daniero
Você poderia esclarecer? Suponha s = "aeiouy\neiouay\nyuaioe\n". Então s.split.grep /a*e*i*o*u*y/retorna ["aeiouy", "eiouay", "yuaioe"]para mim. Testando no pryRuby 2.0.0. Ótima solução, a propósito.
OI
@ Oi Oh, ui, eu assumi que grepusava o =~operador, mas aparentemente ele usa ===. Minha suspeita era que ele também corresponderia a strings que não contêm todos os manivelas, porque, por exemplo, /e*a*i*o*u*y/=~"eioy"funciona. Realmente não entendo o que realmente faz ===entre um regex e um operador. Ótima descoberta; Sugiro que você a publique como resposta. edit Eu estava certo: tente por exemplo "heya".
Daniero
Eu acho que você está certo que o regex precisa de ajustes, no entanto. Estou encontrando casos extremos que não contêm todas as vogais que estão vazando. Talvez bom demais para ser verdade.
OI
2

Mathematica (65 ou 314)

Duas abordagens muito diferentes, a melhor foi proposta por Belisarius nos comentários à minha resposta inicial. Primeiro, meu esforço brutal, que gera algoritmicamente todas as expressões regulares possíveis que correspondem a uma combinação de seis vogais (incluindo "y") e, em seguida, verifica cada palavra na lista de palavras de destino em relação a cada uma dessas 720 expressões regulares. Funciona, mas não é muito conciso e é lento.

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 caracteres. Alguns podem ser salvos usando notação alternativa, e caracteres adicionais são perdidos ao preparar o arquivo de dicionário como uma lista de strings (o formato natural do dicionário no Mathematica. Outros idiomas podem não precisar dessa preparação, mas o Mathematica precisa). Se omitirmos essa etapa, presumindo que ela tenha sido tratada por nós, a mesma abordagem pode ser feita com menos de 250 caracteres e, se usarmos o dicionário interno do Mathematica, obteremos economias ainda maiores,

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

Menos de 200 caracteres. Contar o número de palavras encontradas requer apenas passar o resultado para Length[Flatten[]], que pode ser adicionado ao redor de qualquer bloco de código acima ou pode ser feito posteriormente com, por exemplo,Length@Flatten@% ,. A lista de palavras especificada para esse desafio fornece 43 correspondências e o dicionário Mathematica fornece 64 (e é muito mais rápido). Cada dicionário possui palavras correspondentes que não estão no outro. O Mathematica localiza "profissionalmente", por exemplo, que não está na lista compartilhada, e a lista compartilhada encontra "eucariótico", que não está no dicionário do Mathematica.

Belisarius propôs uma solução muito melhor. Supondo que a lista de palavras já tenha sido preparada e atribuída à variável l, ele define um único teste com base na StringFreeQ[]função do Mathematica e aplica esse teste à lista de palavras usando oPick[] função 65 caracteres, e é cerca de 400 vezes mais rápido que a minha abordagem.

f@u_ := And @@ (! StringFreeQ[u, #] & /@ Characters@"aeiouy"); Pick[l,f /@ l]
Michael Stern
fonte
Em 65 caracteres: f@u_:=And@@(!StringFreeQ[u,#]&/@Characters@"aeiouy");Pick[l,f/@l]Onde lestá a lista de palavras
Dr. belisarius
Isso é porque você se esqueceu de considerar o y(! Conforme as exigências OP) como uma vogal
Dr. belisarius
@belisarius sim, percebo que depois de fazer meu comentário. Estou verificando meus resultados com isso corrigido.
Michael Stern
@belisarius confirmou - sua solução é muito mais concisa e mais rápida que a minha. Por que você não o publica como sua própria solução? Eu vou votar.
Michael Stern
Obrigado! Se você gosta, edite sua resposta, incluindo-a. Para mim, é toda sobre encontrar soluções a curto com a linguagem, não acumulando rep :)
Dr. belisarius
2

Perl 6 - 35 caracteres

Inspirado na solução Ruby de @CarySwoveland:

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

Isso seleciona ( greps) cada linha que retorna Truepara <a e i o u y> ⊆ *.comb, que é apenas uma maneira elegante de pedir "é o conjunto('a','e','i','o','u','y') um subconjunto ( ) do conjunto constituído pelas letras do input ( *.comb)?"

Na verdade, ambos <a e i o u y>e *.combapenas criam Lists: (ou (<=)se você estiver preso em ASCII) os transforma em Sets para você.

Para obter o número de linhas impressas, esse script de 42 caracteres - 5 = 37 pontos também produzirá isso:

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

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

Salvei vários bytes de parênteses graças a uma feliz coincidência de precedência do operador.

Nate Eldredge
fonte
2

Javascript - Pontuação = 124 - 5 = 119 !!!

Edição: 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}

Muito obrigado a @Ismael Miguel por me ajudar a cortar ~ 12 caracteres !

Eu removi o formulário da função de notação de seta gorda porque, embora eu tenha visto o uso inicial, ele não funciona. Não faço ideia porque ...


Para fazer funcionar:

Passe todas as palavras separadas por nova linha como argumento para a função, como mostrado abaixo.


Teste:

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

Gaurang Tandon
fonte
Erro de sintaxe na linha 1: expressão esperada, obteve '>' c = (s, j) => {k = "aeiouy" .split ("
Ismael Miguel
1
Você pode reduzir se movendo k="aeiouy".split("")para ficar dentro do for(i in k)loop. Usar em ;vez de novas linhas salva alguns bytes no Windows. E, no entanto, não vejo como ele irá lidar com uma lista de palavras. E como fazê-lo funcionar.
Ismael Miguel
@IsmaelMiguel Eu sei (notação de seta gorda) não funciona. Mas como eu o vi sendo usado aqui, usei porque ele salva caracteres. Mas eu o removi. E eu não entendo sua dica, obrigado por examinar o código. Incorporou sua dica de bytes. E meu novo programa deve esclarecer suas duas dúvidas. Obrigado pela leitura. :)
Gaurang Tandon
Em vez de k="aeiouy";o=0;for(i in k), tente o=0;for(i in k='aeiouy'). e usando o bytes salva, você pode usá-los para mudar o+=RegExp(k[i]).test(s)para o+=RegExp(k[i],'i').test(s), ocupando mais de um byte, mas trabalhar com ambas maiúsculas e minúsculas.
Ismael Miguel
Atualizado com melhor algoritmo. Embora agora eu entenda sua ideia, mas não entendo por que ela funciona aqui e não aqui . Por favor ajude! Obrigado :)
Gaurang Tandon
2

Bash + coreutils, 39

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

Recebe entrada de stdin.

Trauma Digital
fonte
Parece elegível para o bônus de 5 pontos.
Glenn Randers-Pehrson 27/03
@ GlennRanders-Pehrson Esse bônus não faz sentido para mim em tudo ;-)
Digital Trauma
Quer faça sentido ou não, você emite corretamente 86 linhas ao processar um arquivo contendo duas cópias da lista de palavras. Soluções que classificam e relatam apenas 43 não receberiam o bônus, pelo que entendi.
Glenn Randers-Pehrson 27/03
2

sed 29 chars

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

Ordem escolhida entre Frequência de letras na wikipedia para acelerar a verificação.

No meu host:

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

e

time sed -ne '/y/{/u/{/i/{/o/{/a/{/e/p}}}}}'</usr/share/dict/american-english >/dev/null 
real    0m0.030s
F. Hauri
fonte
1
Bom (+1), mas acho que você precisa incluir "sed -n" no script, para uma contagem de 36 bytes.
Glenn Randers-Pehrson
2

Bash (grep) - 36 bytes

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

Observe a ordem das vogais testadas, menos frequentes primeiro. Para o caso de teste, isso é executado cerca de três vezes mais rápido que o teste, na ordem seguinte. Dessa forma, o primeiro teste remove um número maior de palavras, para que os testes subsequentes tenham menos trabalho a fazer. Obviamente, isso não afeta o comprimento do código. Muitas das outras soluções postadas aqui se beneficiariam de maneira semelhante ao realizar os testes nesta ordem.

Glenn Randers-Pehrson
fonte
Por que wc, não estamos descobrindo, não contando? Além disso, contamos o código de entrada na contagem de caracteres?
orion
Eu realmente não entendo o bônus ", -5 pontos por contar todas as ocorrências da palavra". Se realmente significa "reportar todas as ocorrências da palavra", é isso que meus scripts fazem, sem o "| wc". Eu não estou usando nenhum "código de entrada" porque grep lê a entrada padrão, então "grep" é o "código de entrada" e contei-o. Vou remover o "| wc" agora.
Glenn Randers-Pehrson
Recusei o bônus.
Glenn Randers-Pehrson
1

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

Sem golfe :

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

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

wordlist.txt deve conter as palavras da lista em minúsculas.

Tony Ellis
fonte
1

Rebol (104 caracteres)

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

Sem golfe:

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

dagora contém lista de palavras encontradas. Aqui está um exemplo do 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
draegtun
fonte
1

Smalltalk (36/57 caracteres)

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

para obter a contagem, envie #size para a coleção resultante. A coleção de resultados contém 43 palavras ('abstemiously' 'com autoridade' ... 'inquestionavelmente' 'irreconhecivelmente')

O código acima tem 77 caracteres, mas eu poderia ter renomeado o arquivo da lista de palavras para 'w', então conto o nome do arquivo como 1, o que resulta em uma pontuação de 57.

A leitura do arquivo faz parte do problema ou não? Caso contrário (veja outros exemplos), e a lista de palavras já está em uma coleção c, o código será reduzido para:

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

que é de 36 caracteres (com espaço em branco omitível removido).

blabla999
fonte
1

atualizado: espaços desnecessários removidos

Muito lento, mas no bash (81 caracteres):

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

EDIT: echo $l|fold -w1substituído por fold -w1<<<$lconforme sugerido por @ nyuszika7h

Nik O'Lai
fonte
Este é um código de golfe. Você pode reduzir um pouco mais o seu código. Comece removendo espaços em branco desnecessários. ;)
nyuszika7h
Você pode minificar ainda mais o código usando em fold -w1<<<$lvez de echo $l|fold -w1. Nota: o código atual é de 84 caracteres, você não deve contar a nova linha à direita.
nyuszika7h
Até hoje eu não sabia nada sobre <<<. Obrigado novamente, @ nyuszika7h. Você pode me dizer onde é explicado.
Nik O'Lai
Você está aqui
Página Inicial
1

JavaScript - 95 bytes

Aqui está o meu golfe.

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

E também gostaria de salientar que seu golfe não parece encontrar todas as ocorrências de vogais.

Ungolfed:

function countVowels(string) {
  var regex   = /^(?=.*a)(?=.*e)(?=.*i)(?=.*o)(?=.*u)(?=.*y).*/;
  var matches = string.match(regex);
  var length  = matches.length;
  return [matches, length];
Isiah Meadows
fonte
1
Leia as especificações com mais cuidado. Ele está procurando palavras que - como facetas - contêm todas as vogais em uma única palavra. Embora ele não insista que eles estejam contidos em ordem, como faceta.
dmckee
1
Seu regex está errado. Todo o olhar à frente está efetivamente verificando se o primeiro caractere é uma vogal. Você precisa (?=.*a)verificar se aestá em algum lugar na string.
N
@dmckee É por isso que eu usei lookaheads . Eles não exigem nenhuma ordem específica.
Isiah Meadows
Graças @nhahtdh para a captura
Isiah Meadows
1

ordenar + uniq + sed

Este não corresponde a ocorrências repetidas de uma palavra. Também não corresponde à letra 'y' se ocorrer no início de uma palavra.

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' 
Kevin
fonte
Como em sua outra resposta, substitua "classificar wordlist.txt | uniq" por "sort -u wordlist.txt" para salvar 4 bytes.
Glenn Randers-Pehrson
1

Bater

Não tão curto quanto o OP, mas uma linha no 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
Kevin
fonte
Você poderia salvar quatro bytes, substituindo "sort | uniq" com "sort -u"
Glenn Randers-Pehrson
Além disso, você pode remover os espaços de "|" e ";" para salvar mais alguns bytes
Glenn Randers-Pehrson
1

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

Formatado:

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

Agora não está com disposição para implementar a contagem, puhmas deve ser fácil. O caminho para a (versão em minúscula da) lista de palavras deve ser passado ao programa como primeiro argumento:

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

Saída:

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

Tomei a liberdade de produzir e separar vírgulas; nenhum dos quais está especificado nas regras (qual estado "deve encontrar todas as palavras", não como (e SE) como saída).

Incluindo contagem (+ saída): 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());}}

Saída:

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

(Observe a contagem no final: 43)

Nenhuma saída ("deve encontrar todas as palavras"): 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)));}}

(Dobra as regras um bit e depois novamente: não realmente) Isso localiza todas as palavras e a contagem está disponível executando r.Count().

RobIII
fonte
1

C-Sharp

Eu nunca fiz isso antes e não sei exatamente quais são os procedimentos de postagem. Mas é isso que eu vim com:

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>de todas as palavras.

se você deseja exibir um total:

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


Expandido

// 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);
}
jzm
fonte
Geralmente, se a pergunta solicitar um "programa", você deve publicar seu programa completo, incluindo carregamento / inicialização, etc. Bom trabalho de outra forma!
ProgrammerDan
Ah ok. Então, na versão minificada, devo incluir tudo, não apenas a linha que atinge o requisito? Eu pensei que era o último a julgar por outras respostas, porque eles não tinham o código para carregar / ler o arquivo txt.
JZM
Você verá uma variedade de abordagens e, dada a idade da curadoria de respostas, provavelmente não será tão forte em novas respostas, mas, em geral, se a pergunta solicitar um "programa", ela deverá ser compilável e executável conforme publicado. Tomemos o exemplo da pergunta em si - que é uma solução executável completa, independente.
ProgrammerDan
ahh certo. Bem, nesse caso, atualizei as duas versões reduzidas para serem independentes.
JZM
Ótimo! Atualize o texto da sua resposta (você menciona "sem carregar / ler") e calcule sua pontuação.
ProgrammerDan
1

vb.net (pontuação 91 = 96c - 5) * 0

* 0 + 49c min

Isso cria uma enumeração que contém todas as palavras que contêm todas as vogais.

Dim r=IO.File.ReadLines(a(0)).Where(Function(w)"aeiou".Intersect(w).Count=5)
Dim c=r.Count
Adam Speight
fonte
Your program must find all the words in this wordlist. Este é a) não um programa, mas um trecho de um programa eb) não lê / usa a lista de palavras.
RobIII 29/03
@RobIII vb.net tem um mínimo de 49c para um programa básico de console. Os argumentos para o programa (neste caso, a lista de palavras) são a matriz a . Além disso, como alguns outros salientaram, é um programa válido no LinqPad.
Adam Speight
1

Mathematica - 136 102

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

O link abreviado vai para http://www.mieliestronk.com/corncob_lowercase.txt

swish
fonte
Salve 28 caracteres com http://bit.ly/1iZE9kY.
wchargin
Salve dois caracteres com Characters["aeiou"]ou mais, se você incluir y.
wchargin