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.

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.

Perl, 47 bytes

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

Contando o shebang como um.

Experimente online!

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 :)

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.

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

Python 2 , 120 102 94 bytes

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

Experimente online!

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

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.

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

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

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.

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

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

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!

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.

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.

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.

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]

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.

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.

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]

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

Empilhados, não concorrentes, 51 bytes

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

Bem simples. Experimente aqui!

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 ... :)

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)

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.

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.

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 ...

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 #

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.