Todas as palavras de babab a zyzyz

38

Sua tarefa é escrever um programa que produza uma lista legível de cada cinco letras da letra com a estrutura:

consoante - vogal - consoante - vogal - consoante

A saída deve ser classificada em ordem alfabética com uma palavra por linha e nenhuma palavra repetida duas vezes. Pode ser minúscula ou maiúscula, mas não mista. Portanto, a lista pode começar e terminar assim:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

As vogais são um - e - i - o - u - y , os outros 20 letras Inglês-alfabeto são consoantes.
As palavras não precisam ser palavras de dicionário reais.
O menor código vence.

Nota: Alguns anos atrás, deparei-me com um programa em um site de uma universidade que fazia exatamente isso. Acontece que meu nome e sobrenome se encaixam na restrição de cvcvc, e eu estava pesquisando sozinho.

wilks
fonte
7
Eu vejo duas coisas aqui. Primeiro, há uma quantidade ridícula de palavras como essa. Como você espera testar as entradas? Além disso, existem muitos nomes que se encaixam nessa restrição. O primeiro que vem à mente é Jacob , embora outros, como Lucas também se encaixam
TrojanByAccident
9
@TrojanByAccident Acredito que o desafio exige todas as combinações possíveis de letras correspondentes, independentemente de serem nomes / palavras em inglês. "As palavras não precisam ser palavras reais do dicionário".
Trichoplax
3
@wilks Meta post relevante - Formatos estritos de E / S não são apreciados nesta comunidade SE. Esse desafio está focado na geração de palavras em cvcvc, não na inserção de novas linhas entre as palavras, não?
JungHwan Min
1
@JungHwanMin Obrigado pelo link, primeira vez aqui e eu não sabia disso. Eu o vi como uma lista legível e alfabética de todas as palavras em cvcvc. Portanto, concordo que maiúsculas ou minúsculas realmente não importam, mas também acho que uma sequência muito longa ou, digamos, algumas matrizes aninhadas, embora tecnicamente válida não seria uma ótima resposta.
Wilks
2
Depois de executar algumas das respostas anteriores a esta pergunta, elas obviamente não estão em conformidade com "A saída deve ser incremental com cada palavra em sua própria linha". Esse requisito foi atendido e, em caso afirmativo, você pode editar a pergunta para refletir isso? Acho que poderia perder alguns bytes se minha resposta não fosse restrita pelo formato.
ElPedro

Respostas:

28

Mathematica, 72 65 61 bytes

Print@@@Tuples@{a=##/(b=#5#9#15#21#25#)&@@Alphabet[],b,a,b,a}

Para testar, recomendo substituir Print@@@por ""<>#&/@. O Mathematica exibirá um formulário truncado mostrando as primeiras e as últimas palavras, em vez de levar uma eternidade para imprimir 288.000 linhas.

Explicação

Finalmente encontrei um uso para dividir strings. :)

Fiquei intrigado com a possibilidade de adicionar ou multiplicar seqüências por um tempo, mas os casos de uso reais são bastante limitados. O ponto principal é que algo como "foo"+"bar"ou "foo"*"bar"(e, consequentemente, a forma abreviada "foo""bar") é completamente válido no Mathematica. No entanto, ele realmente não sabe o que fazer com as seqüências de caracteres em expressões aritméticas, portanto, essas coisas permanecem sem avaliação. Mathematica não aplicar simplificações geralmente aplicáveis embora. Em particular, as strings serão classificadas em ordem canônica (que é bastante bagunçada no Mathematica, quando você começar a classificar strings contendo letras de vários casos, dígitos e não letras), que geralmente é um desrespeitador, mas não importa aqui. . Além disso, "abc""abc"será simplificado para"abc"^2(que é um problema quando você repetiu seqüências de caracteres, mas também não o temos), e algo como "abc"/"abc"será cancelado (do qual usaremos até).

Então, o que estamos tentando jogar aqui? Precisamos de uma lista de vogais e uma lista de consoantes, para que possamos alimentá-las Tuplespara gerar todas as combinações possíveis. Minha primeira abordagem foi a solução ingênua:

Characters@{a="bcdfghjklmnpqrstvwxz",b="aeiouy",a,b,a}

Essa lista codificada de consoantes doeu um pouco. O Mathematica tem um Alphabetbuilt-in que me permitiria evitá-lo, se eu fosse capaz de remover as vogais de uma maneira barata. É aqui que fica complicado, porém. A maneira mais simples de remover elementos é Complement, mas ela acaba sendo mais longa, usando uma das seguintes opções:

{a=Complement[Alphabet[],b=Characters@"aeiouy"],b,a,b,a}
{a=Complement[x=Alphabet[],b=x[[{1,5,9,15,21,25}]]],b,a,b,a}

(Observe que não precisamos mais aplicar Charactersa coisa toda, porque Alphabet[]fornece uma lista de letras, não uma string.)

Então, vamos tentar esse negócio aritmético. Se representarmos o alfabeto inteiro como um produto de letras em vez de uma lista, podemos remover as letras por divisão simples, devido à regra de cancelamento. Isso economiza muitos bytes porque não precisamos Complement. Além disso, "a""e""i""o""u""y"é realmente um byte menor que Characters@"aeiouy". Então, fazemos isso com:

a=##/(b="a""e""i""o""u""y")&@@Alphabet[]

Onde estamos armazenando os produtos consoantes e vogais em ae b, respectivamente. Isso funciona escrevendo uma função que multiplica todos os seus argumentos ##e os divide pelo produto das vogais. Esta função é aplicada à lista de alfabeto, que passa cada letra como um argumento separado.

Até aí tudo bem, mas agora temos

{a=##/(b="a""e""i""o""u""y")&@@Alphabet[],b,a,b,a}

como argumento Tuples, e essas coisas ainda são produtos, não listas. Normalmente, a maneira mais curta de corrigir isso é colocar um List@@@na frente, que transforma os produtos em listas novamente. Infelizmente, adicionar esses 7 bytes o torna mais longo que a abordagem ingênua.

No entanto, acontece que Tuplesisso não se importa com os chefes das listas internas. Se você fizer

Tuples[{f[1, 2], f[3, 4]}]

(Sim, para um indefinido f.) Você receberá:

{{1, 3}, {1, 4}, {2, 3}, {2, 4}}

Como se você tivesse usado um em Listvez de f. Para que possamos repassar esses produtos diretamente Tuplese ainda obter o resultado certo. Isso economiza 5 bytes em relação à abordagem ingênua, usando duas seqüências codificadas.

Agora o "a""e""i""o""u""y"ainda é bastante irritante. Mas espere, também podemos salvar alguns bytes aqui! Os argumentos de nossa função são as letras individuais. Portanto, se escolhermos os argumentos certos, podemos reutilizá-los, em vez dos literais de string, que é mais curto para três deles. Queremos argumentos #(abreviação de #1), #5, #9, #15, #21e #25. Se colocarmos #no final, também não precisamos adicionar nenhum *para multiplicá-los, porque (regex) #\d+é um token completo que não pode ter nenhum dígito anexado a ele. Portanto, acabamos #5#9#15#21#25#economizando outros 4 bytes.

Martin Ender
fonte
11
Lê a explicação. Então ... basicamente mágico.
Tally
Estou surpreso e impressionado com o seu Tuplestruque. Isso é totalmente indocumentado, certo? E inesperado, dado que o formulário de duas entradas Tuples[list,n]trata de listnão ter a Listcabeça (pelo menos para mim)!
A Simmons
1
@ngenisis Acho essa redação muito confusa. Porque não está claro que isso se refere à lista externa ao usar várias listas. Na verdade Tuples[f[{1,2}, {3,4}]]{f[1, 3], f[1, 4], f[2, 3], f[2, 4]}seu lugar. Não está documentado que a cabeça interna seja completamente ignorada.
Martin Ender
@ASimmons cc. ^
Martin Ender
16

Perl, 47 bytes

#!perl -l
/((^|[aeiouy])[^aeiouy]){3}/&&print for a..1x5

Contando o shebang como um.

Experimente online!

primo
fonte
2
Isso é bom, muito bem! Alguma razão para você não estar usando say?
Dada
Obrigado. Eu discordo que -M5.01deveria ser 'grátis'.
Primo
1
Eu gosto da sua opinião -M5.010. E a parte interessante no golfe não deve ser substituída printpor say... #
Dada
Não é -E(e subsequentemente say) um brinde?
Zaid
@Zaid See primeiro comentário de
Dada
11

Python 3 - 110 bytes

a,b="bcdfghjklmnpqrstvwxz","aeiouy";print(*(c+d+e+f+g for c in a for d in b for e in a for f in b for g in a))

Diversão simples em loop :)

Carra
fonte
Pense que nossas idéias são as mesmas, mas você me venceu em 10 com Python 3!
ElPedro
Eu estava prestes a postar um equivalente python2 usando essa abordagem. Muito lento, um voto para você.
Chris H
8

Ruby, 72 71 52 bytes

puts (?z..?z*5).grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/

Agradecemos ao Value Ink pela idéia básica, que reduziu isso para 60 bytes.

GB
fonte
1
É mais curto gerar uma lista de palavras de 5 letras e usá-lo grep. Se você gerar um intervalo que usa sequências em minúsculas, obtém uma sequência apenas das palavras em minúsculas. puts ("babab".."zyzyz").grep /#{["[^aeiouy]"]*3*"[aeiouy]"}/para 60 bytes
Value Ink
7

05AB1E , 18 16 bytes

05AB1E usa a codificação CP-1252 .

žP3ãžO3ãâ€øJ€¨ê»

Explicação

žP3ã                # push all combinations of 3 consonants
    žO3ã            # push all combinations of 3 vowels
        â           # cartesian product
         €ø         # zip each pair of [ccc,vvv] (c=consonant,v=vowel)
           J        # join to list of strings ['cvcvcv','cvcvcv' ...]
            ۬      # remove last vowel from each
              ê     # sort and remove duplicates
              »     # join on newlines

Para fins de teste, recomendo substituir žPpor algumas consoantes e žOpor algumas vogais.

Exemplo usando 5 consoantes e 3 vogais

Emigna
fonte
bom uso do produto cartesiano. Não teria pensado nisso.
Magic Octopus Urn
7

Python 2 , 120 102 94 bytes

from itertools import*
lambda:map(''.join,product(*(('AEIOUY','BCDFGHJKLMNPQRSTVWXZ')*3)[1:]))

Experimente online!

Cajado
fonte
7

Pure Bash, 74

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval echo $c$v$c$v$c

Expansão direta da cinta.

Experimente online .


Se cada item deve estar em sua própria linha, temos:

Pure Bash, 84

v={a,e,i,o,u,y}
c={b,c,d,f,g,h,{j..n},{p..t},v,w,x,z}
eval printf '%s\\n' $c$v$c$v$c
Trauma Digital
fonte
7

PHP, 88 86 84 80 bytes

pretty string increment :)
6 bytes salvos por @Christoph

for($s=$v=aeiouy;++$s<zyzza;preg_match("#[^$v]([$v][^$v]){2}#",$s)&&print"$s
");

faz um loop através de todas as strings de bababapara zyzyze testa se elas correspondem ao padrão. Corra com -nr.

Titus
fonte
Lol, jogar golfe com uma especificação de linguagem de buggy, eu gosto
Patrick Roberts
1
@PatrickRoberts Não é um bug. É uma característica. : Estou triste por incorporar uma conversão implícita ao número inteiro em $a="001";$a++;algum dia. Essa foi uma mudança muito inconveniente.
Titus
1
for($s=$v=aeiouy;++$s<zyzza;)preg_match("#[^$v][$v][^$v][$v][^$v]#",$s)&&print"$s\n";economiza 1 caractere. Infelizmente você precisa alterar o eco para imprimir para usar &&. Substituir \npor uma quebra de linha real salva outra.
Christoph
1
você pode salvar alguns caracteres usando, "#([^$v][$v]){2}​[^$v]#"mas eu não testei.
Christoph
1
@Christoph: Idk porque, mas ([^$v][$v]​){2}[^$v]não funciona no circuito, enquanto [^$v]([$v]​[^$v]){2}faz. Ambos funcionam de forma independente (mesmo com a variável).
Titus
6

MATL , 21 bytes

11Y2'y'h2Y2X~6Myyy&Z*

Experimente online! (mas a saída está truncada).

11Y2   % Push 'aeiou' (predefined literal)
'y'    % Push 'y'
h      % Concatenate: gives 'aeiouy'
2Y2    % Push 'abcdefghijklmnopqrstuvwxyz' (predefined literal)
X~     % Set symmetric difference: gives 'bcdfghjklmnpqrstvwxz'
6M     % Push 'aeiouy' again
yyy    % Duplicate the second-top element three times onto the top. The stack now
       % contains 'bcdfghjklmnpqrstvwxz', 'aeiouy', 'bcdfghjklmnpqrstvwxz',
       % 'aeiouy', 'bcdfghjklmnpqrstvwxz'
&Z*    % Cartesian product of all arrays present in the stack. Implicity display
Luis Mendo
fonte
Eu acho que isso deve funcionar, raspando um byte: 11Y2'y'h2Y2yX~yyy&Z*( Experimente online! )
Conor O'Brien
@ ConorO'Brien Infelizmente, isso cria o vcvcvpadrão, não cvcvcconforme necessário. Obrigado embora!
Luis Mendo
6

Python, 92 bytes

f=lambda i=-4,s='':i*[s]or sum([f(i+1,s+c)for c in i%2*'AEIOUY'or'BCDFGHJKLMNPQRSTVWXZ'],[])

Não posso deixar itertoolsvencer. A iterativa tem 1 byte a mais no Python 2.

W='',
for s in(['AEIOUY','BCDFGHJKLMNPQRSTVWXZ']*3)[1:]:W=[w+c for w in W for c in s]
print W
xnor
fonte
Isso é incrível ^ _ ^
ABcDexter 13/01
6

Haskell, 54 51 bytes

l="bcdfghjklmnpqrstvwxz":"aeiouy":l
mapM(l!!)[0..4]

mapM func listconstrói todas as palavras, pegando os caracteres possíveis para o índice i da lista retornada por func (list!!i).

Edit: @xnor encontrado 2 bytes para salvar e olhando para sua solução, eu encontrei outro.

nimi
fonte
mapM id$take 5$cycle["bcdfghjklmnpqrstvwxz","aeiouy"]salva um byte.
Xnor
Melhor ainda, mapM(cycle["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0..4]ou mapM(["bcdfghjklmnpqrstvwxz","aeiouy"]!!)[0,1,0,1,0]. Seria bom não codificar as vogais e consoantes, masmapM(\n->[x|x<-['a'..'z'],elem x"aeiou"==odd n])[0..4] não consegue.
Xnor
@xnor: Obrigado! Substituindocycle da sua primeira variante por recursão explícita economiza um byte adicional.
Ni13
5

Braquilog , 18 bytes

@W:@Dg:2jcb:eac@w\

Experimente online!

Explicação

@W:@D                 The list ["aeiouy", "bcdfghjklmnpqrstvwxz"]
     g:2jcb           The list ["bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz", "aeiouy", "bcdfghjklmnpqrstvwxz"]
           :ea        Take one character of each string
              c       Concatenate into a single string
               @w     Write to STDOUT followed by a newline
                 \    Backtrack: try other characters of the string
Fatalizar
fonte
Fiquei surpreso com a necessidade de , ge b, mas testá-lo, isso ocorre porque jparece se recusar a receber uma lista de seqüências de caracteres como entrada? :eamostra realmente os pontos fortes do Prolog / Brachylog, no entanto, e é um passo que a maioria das outras línguas acha muito mais difícil.
@ ais523 Sim, também fiquei surpreso ao saber que o ge bera necessário. jparece estar com erros e isso se deve mais uma vez à dificuldade de distinguir uma lista de argumentos de apenas uma lista. Eu posso corrigir isso, embora isso volte a complexificar a implementação. Talvez eu não conserte e investi meu tempo na solução do problema principal em uma nova versão do Brachylog.
Fatalize
5

JavaScript (ES6), 91 90 bytes

f=(s='',i=4)=>{for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')i?f(s+c,i-1):console.log(s+c)}

Edições

  • ETHproductions: -1 byte, removendo o grupo estranho ao redor do operador ternário na fordeclaração

Explicação

Isso define uma função recursiva de 5 profundos que usa a paridade de sua profundidade de chamada para determinar se itera vogais ou consoantes. Em cada iteração, ele verifica se deseja recursar ou imprimir verificando a quantidade de recursões restantes e concatena a letra de sua iteração atual até o final da cadeia de 5 caracteres que está sendo construída atualmente em profundidade primeiro.

Solução alternativa de 89 bytes, assumindo a codificação ISO8859-1:

f=(s='',i=4)=>{for(c of i%2?'aeiouy':btoa`mÇ_äi骻-¿s`)i?f(s+c,i-1):console.log(s+c)}

Solução alternativa de 96 bytes que retorna toda a saída como sequência única:

f=(s='',i=4,o='')=>eval("for(c of i%2?'aeiouy':'bcdfghjklmnpqrstvwxz')o+=i?f(s+c,i-1):s+c+`\n`")

Corra por sua conta e risco. Para a solução de 91 bytes, basta usar f()e, para a alternativa de 97 bytes, use console.log(f()).

Patrick Roberts
fonte
Tentei transformar a solução em um gerador de duas maneiras diferentes. Usando a forma abreviada suportado apenas pelo Firefox é o mesmo comprimento: f=(s='',i=2)=>(for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))for(q of i?f(s+c,i-1):[s+c])q)utilizando o formulário padrão é, infelizmente, um byte mais: function*f(s='',i=2){for(c of(i%2?'aeiouy':'bcdfghjklmnpqrstvwxz'))yield*i?f(s+c,i-1):[s+c]}Ainda esperando pelo dia em que um gerador é a opção mais curta ...
ETHproductions
1
btw, você pode remover as parênteses internas na for...ofinstrução para salvar um byte
ETHproductions
5

C, 201 199 186 184 183 169 163 bytes

Fazendo um pouco diferente do que com o método de contagem básico anterior:

f(){for(char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[5]={0},*s[]={c,v,c,v,c},j=0;j<5;puts("")){for(j=5;j--;putchar(s[j][i[j]]));for(;j++<5&&!s[j][++i[j]];i[j]=0);}}

Ungolfed:

f() {
    for(char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[5]={0}, *s[]={c,v,c,v,c}, j=0; j<5; puts("")) {
        for (j=5; j--; putchar(s[j][i[j]])) ;
        for (; j++ < 5 && !s[j][++i[j]]; i[j]=0) ;
    }
}

E escrito de uma maneira um pouco mais convencional:

f() {
    char *c="bcdfghjklmnpqrstvwxz", *v="aeiouy", i[]={0,0,0,0,0}, *s[]={c,v,c,v,c}, j=0;
    while (j>=0) {
        for (j=0; j<5; j++) putchar(s[j][i[j]]); // output the word
        while (--j>=0 && !s[j][++i[j]]) i[j]=0; // increment the counters
        puts("");
    }
}

Basicamente, i são os contadores, e s a matriz de cadeias que contêm todos os caracteres sobre a qual devemos iteração, para cada marcador. O truque é o loop while interno : é usado para incrementar os contadores, começando pelo mais à direita. Se percebermos que o próximo caractere que devemos exibir é o caractere nulo final, reiniciaremos o contador para zero e o "carry" será propagado para o próximo contador.

Obrigado Cristoph!

escuro
fonte
Bem-vindo ao PPCG!
Martin Ender
1
char *cEu acho que o espaço é desnecessário.
Christoph
1
f(){char*c="bcdfghjklmnpqrstvwxz",*v="aeiouy",i[]={0,0,0,0,0},*s[]={c,v,c,v,c},j=0;while(j>=0){for(j=0;j<5;++j)putchar(s[j][i[j]]);for(;--j>=0&&!s[j][++i[j]];)i[j]=0;puts("");}}leva você a 177. Vamos lá, você pode fazer ainda melhor;).
Christoph
2
Usar em i[5]={0}vez de i[]={0,0,0,0,0}salva 7 bytes.
Falken
1
@Christoph Aha, obrigado. Bom trabalho. Mas você parecia gostar, é por isso que eu estava empurrando o desafio (não, estou brincando: fiz isso só porque sou um pé no saco). Sério, obrigado pela iluminação.
dim
4

Perl, 71 bytes

map{push@{1+/[aeiouy]/},$_}a..z;$"=",";say for glob"{@1}{@2}"x2 ."{@1}"

Experimente online!

Explicação

Vou adicionar mais explicações mais tarde.

map{push@{1+/[aeiouy]/},$_}a..z;cria duas matrizes: @1contém as consoantes e @2contém as vogais.
globQuando call com argumentos como {a,b}{c,d}retorna todas as permutações dos elementos entre chaves.

dada
fonte
4

Befunge, 95 bytes

::45*%\45*/:6%\6/:45*%\45*/:6%\6/1g,2g,1g,2g,1g,55+,1+:"}0":**-!#@_
bcdfghjklmnpqrstvwxz
aeiouy

Experimente online! , embora observe que a saída será truncada.

Este é apenas um loop no intervalo de 0 a 287999, exibindo o índice como um número misto baseado 20-6-20-6-20, com os "dígitos" do número recuperados das tabelas nas duas últimas linhas.

James Holderness
fonte
4

Perl 6 , 70 bytes

$_=<a e i o u y>;my \c=[grep .none,"a".."z"];.say for [X~] c,$_,c,$_,c

Explicação da parte interessante:

.say for [X~] c, $_, c, $_, c

              c, $_, c, $_, c  # list of five lists
         [X ]                  # lazily generate their Cartesian product
           ~                   # and string-concatenate each result
.say for                       # iterate to print each result

O código anterior apenas gera a lista de vogais ( $_) e a lista de consoantes ( c), que é lamentavelmente detalhada.

smls
fonte
4

Python 2 , 120 117 bytes

Obrigado a @WheatWizard pela dica de guias.

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
for a in x:
 for e in x:
	for b in y:
		for c in y:
			for d in y:print b+a+c+e+d

Experimente online!

Não tenho certeza de que isso possa ser muito praticado. Experimente online trunca em 128KB, mas mostra o suficiente para dar uma idéia. Uma execução local com código de depuração para contar as palavras deu um total de 288000. Executa em cerca de 45 segundos, se alguém quiser testar.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Versão não compatível e, portanto, não concorrente (imprime matrizes aninhadas em vez do formato especificado) para 110 bytes:

x,y='aeiouy','bcdfghjklmnpqrstvwxz'
print[[[[c+a+d+b+e for e in y]for d in y]for c in y]for b in x]for a in x]
ElPedro
fonte
1
Foi a minha primeira implemenation :)
Carra
Em vez de usar espaços para todo o seu recuo, você pode usar espaços para o recuo único e tabulações para o dobro.
Assistente de trigo
4

Perl 6, 53 bytes

/<-[aeiouy]>**3%<[aeiouy]>/&&.say for [...] <a z>Xx 5

Demora um pouco para obter qualquer saída. Muito ineficiente. Faz o trabalho.

Maniacs Thrift Jewels
fonte
Bem-vindo ao PPCG!
Martin Ender
4

xeger , 49 bytes

([bcdfghj-np-tvwxz][aeiouy]){2}[bcdfghj-np-tvwxz]

Dada uma expressão regular, o xeger simplesmente gera todas as strings correspondentes. Para não matar o navegador, ele pausa a cada 1000 saídas e você precisa clicar para continuar, mas chegará lá eventualmente.


Aqui está uma versão de 23 bytes com um bug ^corrigido:

([:c^y][:v:y]){2}[:c^y]

Estes são classes de personagens "todas as consoantes ASCII minúsculas" [:c]com yexcluída ^y, e "todas as vogais ASCII minúsculas" [:v:]com yacrescentou.

Michael Homer
fonte
Em que sabor de expressão regular isso se baseia? (? Ou se você rolou seu próprio país, o que apresenta ele suporta Existe alguma documentação sobre isso?)
Martin Ender
@MartinEnder É uma experiência do DFA (desenvolvida a partir de um visualizador de DFA / NFA que construí para estudantes , que possui documentação limitada) - sem referências anteriores, nada de regular. É muito lento para cordas mais longas. A única característica interessante das próprias expressões é conjunta com &.
Michael Homer
Adicionei documentação do restante à página e algumas amostras.
Michael Homer
1
Parece que você implementou intervalos nas classes de personagens. Então você poderia fazer [bcdfghj-np-tvwxz].
Martin Ender
4

JavaScript (Firefox 30-57), 82 bytes

f=(i=5)=>i?[for(s of f(i-1))for(c of i%2?'bcdfghjklmnpqrstvwxz':'aeiouy')s+c]:['']

Retorna uma matriz de seqüências de caracteres. Versão muito rápida para 102 101 (1 byte graças a @ETHproductions) bytes:

_=>[for(i of c='bcdfghjklmnpqrstvwxz')for(j of v='aeiouy')for(k of c)for(l of v)for(m of c)i+j+k+l+m]
Neil
fonte
Agradável. Há um espaço estranho na versão rápida que pode ser removido para 101 bytes
ETHproductions
3

CJam , 32 31 29 28 bytes

Economizou 2 bytes graças a Martin Ender e 1 byte graças a kaine

"aeiouy"_'{,97>^\1$1$1$N]:m*

Experimente online! (Observe que a saída é cortada no TIO)

Explicação

"aeiouy"_ e# Push the six vowels and duplicate
'{,97>    e# Push the whole alphabet
^         e# Symmetric set difference of the alphabet with the vowels, yields the consonants only
\         e# Swap top two elements
1$1$1$    e# Copy the second-from-the-top string to the top three times
          e# This results in the array being consonants-vowels-consonants-vowels-consonants
N         e# Add a newline character to the end of the list
]         e# End an array. Puts everything done so far in an array
          e# since there was no explicit start of the array.
:m*       e# Reduce the array using Cartesian products
Gato de negócios
fonte
'{,97>para pegar o alfabeto. E depois "aeiouy"_'{,97>^salvar outro byte 1$.
Martin Ender
você não precisa do primeiro personagem. Supõe-se se começa o início da pilha.
kaine
@kaine Interessante, não sabia disso. Obrigado.
Cat Business
$ "aeiouy" _ '{, 97> ^] 3 * (;: m * N * $ ignorar os sinais $ Idk como colocar código nos comentários..
kaine
@kaine Use backticks, como "` ".
Conor O'Brien
3

Empilhados, não concorrentes, 51 bytes

(consonants:@c vowels:@v c v c)multicartprod$outmap

Bem simples. Experimente aqui!

Conor O'Brien
fonte
3

Perl, 63 59 54 bytes

$a="aeiouy";$b="[^$a][$a]"x2;for("a"x5.."z"x5){say if/$b[^$a]/}
$a="aeiouy";$b="[^$a][$a]"x2;/$b[^$a]/&&say for"a"x5.."z"x5

$a=aeiouy;$b="[^$a][$a]"x2;/$b[^$a]/&&say for a.."z"x5

Tentando Perl golf para variar.
EDIT: Parece que ainda tenho muito a aprender ... :)

smls
fonte
Boa (mesmo que a resposta de Primo seja mais curta). Você pode escrever o final /$b[^$a]/&&say for"a"x5.."z"x5para salvar alguns bytes. Editar: e você pode soltar o $be fazer $a="aeiouy";/([^$a][$a]){2}[^$a]/&&say for"a"x5.."z"x5.
Dada
Além disso, você não precisa de aspas aeiouy. Além disso, como seu regex verifica 5 caracteres, você pode fazê-lo a.."z"x5.
Dada
@ Dadá: Obrigado. Como alguém que usa Perl para programação normal, mas até agora não para jogar golfe, nem pensei em explorar o modo não estrito. É por isso que escolhi $ae $bcomo nomes de variáveis, porque esses não precisam ser declarados mesmo no modo estrito ... :) Eu também uso muito o Perl 6 hoje em dia, que nem sequer possui um modo não estrito.
SMLS
3

Scala, 87 86 bytes

val a="aeiouy"
val b='a'to'z'diff a
for(c<-b;d<-a;e<-b;f<-a;g<-b)println(""+c+d+e+f+g)
jaxad0127
fonte
Você pode substituir f"$c$d$e$f$g"por ""+c+d+e+f+gpara salvar um byte.
corvus_192
3

R, 143 132 bytes

q=letters;v=c(1,5,9,15,21,25);x=list(q[-v],q[v],q[-v],q[v],q[-v]);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(sapply(x,length))))

q=letters;v=c(1,5,9,15,21,25);x=list(a<-q[-v],b<-q[v],a,b,a);Reduce(paste0,mapply(function(a,b)rep(a,e=b/20),x,cumprod(lengths(x))))

Esta é a minha primeira vez no código de golfe, por isso gostaria de receber sugestões para reduzi-lo ainda mais. Até agora, é tudo R padrão; a única coisa possivelmente complicada aqui é que paste0 recicla seus argumentos na extensão da mais longa.

Edit: usado truque de atribuição de rturnbull, substituído sapply(x,length)por lengths.

Patrick B.
fonte
Bem vindo ao site! Isso parece muito bom (eu mesmo programei um pouco no R). Eu recomendaria não incluir o código antigo na sua resposta. O histórico de edições está sempre disponível para que qualquer pessoa que deseje possa sempre visualizá-lo. Isso é mais uma coisa estilística pessoal, então fique à vontade para ignorar minha opinião.
Assistente de trigo
Você pode fazer força bruta com atribuições de função para 114 bytes !
Punintended
3

R, 111 98 bytes

Adicionado ycomo vogal e com 13 bytes de golfe, graças a @Patrick B.

l=letters
v=c(1,5,9,15,21,25)
apply(expand.grid(C<-l[-v],V<-l[v],C,V,C)[,5:1],1,cat,fill=T,sep="")

Usamos expand.gridpara gerar todas as combinações possíveis de Ve Cem uma matriz, que definimos a partir da variável predefinida letters(o alfabeto). Invertemos as combinações (como o padrão é a primeira variável girar mais rapidamente) para garantir a ordem alfabética. Em seguida, percorreremos cada linha da matriz, imprimindo cada letra em stdout. Usamos o fillargumento para catgarantir que cada palavra comece em uma nova linha.

rturnbull
fonte
Agradável! Você pode dividir isso em mais de 98 caracteres (adicionando 'y' como uma vogal ou 95, se não estiver), usando algumas opções em cat e renomeando "letras": l = letras; v = c (1,5,9, 15,21,25); apply (expand.grid (C <-l [-v], V <- l [v], C, V, C) [, 5: 1], 1, ‌ cat , fill = T, set = "")
Patrick B.
@PatrickB. Obrigado! Incorporamos suas sugestões.
precisa saber é o seguinte
86 bytes
J.Doe 17/09/18
2

Clojure, 101 bytes

(print(apply str(for[V["aeiouy"]C["bcdfghjklmnpqrstvwxz"]a C b V c C d V e C](str a b c d e "\n")))))

Não é tão emocionante ...

NikoNyrh
fonte
2

Ruby, 65 61 bytes

Abordagem completamente diferente:

(b=[*?a..?z]-a="aeiouy".chars).product(a,b,a,b){|x|puts x*""}

Coisas novas que aprendi hoje: a função do produto Array #

GB
fonte
2

Bytes C 361

f(){i,j,k,l,m;v[6]={97,101,105,111,117,121};c[25];s=26;for(i=0;i<26;i++)c[i]=97+i;for(i=0;i<26;i++){for(j=0;j<6;j++)if(c[i]==v[j])c[i]+=1;}for(i=0;i<s;i++)for(j=i+1;j<s;){ if(c[i]==c[j]){for(k=j;k<s-1;++k)c[k]=c[k+1];--s;}else ++j;}for(i=0;i<s;i++)for(j=0;j<6;j++)for(k=0;k<s;k++)for(l=0;l<6;l++)for(m=0;m<s;m++)printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);}

Versão não destruída:

void f()
{   
int i,j, k,l,m;
int s=26;
int v[6]={97,101,105,111,117,121};
int c[s];

for(i=0;i<s;i++)
 c[i]=97+i;
for(i=0;i<s;i++)
{     
  for(j=0;j<6;j++)
    if(c[i]==v[j])
      c[i]+=1;
     }
for(i=0;i<s;i++)
 for(j=i+1;j<s;)
 { if(c[i]==c[j])
  {
    for(k=j;k<s-1;++k)
      c[k]=c[k+1];
      --s;  
  }else
   ++j;  
  }
for(i=0;i<s;i++)
  for(j=0;j<6;j++)
       for(k=0;k<s;k++)
        for(l=0;l<6;l++)
         for(m=0;m<s;m++)       
      printf("%c%c%c%c%c\n",c[i],v[j],c[k],v[l],c[m]);
}

Deve haver alguma maneira de reduzir isso definitivamente.

Explicação

  • Armazenados os valores inteiros de a, e, i, o, u, y em uma matriz numérica,
  • Armazenou todos os alfabetos na matriz, se fosse uma vogal, substituiu-a por uma consoante, para que houvesse valores de consoante duplicados na matriz,
  • Removidos valores de consoante duplicados,
  • Impresso todas as combinações de cvcvc.
Abel Tom
fonte
Se você pudesse colocar uma versão não-gasta, isso ajudaria imensamente.
SIGSTACKFAULT