Su tarea es escribir un programa que genere una lista legible de cada palabra de cinco letras con la estructura:

consonante - vocal - consonante - vocal - consonante

La salida se debe ordenar alfabéticamente con una palabra por línea y ninguna palabra repetida dos veces. Puede ser minúscula o mayúscula pero no mezclada. Entonces la lista podría comenzar y terminar así:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Las vocales son a - e - i - o - u - y , las otras 20 letras del alfabeto inglés son consonantes.
Las palabras no tienen que ser palabras reales del diccionario.
El código más corto gana.

Nota: Hace unos años me topé con un programa en el sitio web de una universidad que hacía exactamente eso. Resulta que mi nombre y apellido se ajustan a la restricción de cvcvc, y yo mismo había estado buscando en Google.

Mathematica, 72 65 61 bytes

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

Para las pruebas, recomiendo reemplazarlas Print@@@por ""<>#&/@. Luego, Mathematica mostrará un formulario truncado que muestra las primeras y últimas palabras, en lugar de tomar una eternidad para imprimir 288,000 líneas.

Explicación

Finalmente encontré un uso para dividir cadenas. :)

Me ha intrigado la posibilidad de agregar o multiplicar cadenas por un tiempo, pero los casos de uso reales son bastante limitados. El punto principal es que algo como "foo"+"bar"o "foo"*"bar"(y, en consecuencia, la forma abreviada "foo""bar") es completamente válido en Mathematica. Sin embargo, realmente no sabe qué hacer con las cadenas en las expresiones aritméticas, por lo que estas cosas permanecen sin evaluar. Sin embargo, Mathematica aplica simplificaciones generalmente aplicables. En particular, las cadenas se ordenarán en orden canónico (que está bastante desordenado en Mathematica, una vez que comience a ordenar cadenas que contienen letras de varios casos, dígitos y no letras), que a menudo es un factor decisivo, pero no importa aquí . Además, "abc""abc"se simplificará a"abc"^2(lo cual es un problema cuando tiene cadenas repetidas, pero tampoco tenemos eso), y algo así "abc"/"abc"se cancelará (que incluso haremos uso de).

Entonces, ¿qué estamos tratando de jugar golf aquí? Necesitamos una lista de vocales y una lista de consonantes, de modo que podamos alimentarlas Tuplespara generar todas las combinaciones posibles. Mi primer enfoque fue la solución ingenua:

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

Esa lista codificada de consonantes duele un poco. Mathematica tiene una función Alphabetincorporada que me permitiría evitarlo, si pudiera eliminar las vocales de una manera barata. Sin embargo, aquí es donde se pone difícil. La forma más sencilla de eliminar elementos es Complement, pero eso termina siendo más largo, utilizando una de las siguientes opciones:

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

(Tenga en cuenta que ya no necesitamos aplicar Charactersa todo el asunto, porque Alphabet[]da una lista de letras, no una cadena).

Así que intentemos ese negocio aritmético. Si representamos el alfabeto completo como un producto de letras en lugar de una lista, entonces podemos eliminar letras por división simple, debido a la regla de cancelación. Eso ahorra muchos bytes porque no los necesitaremos Complement. Además, en "a""e""i""o""u""y"realidad es un byte más corto que Characters@"aeiouy". Entonces hacemos esto con:

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

Donde estamos almacenando los productos de consonantes y vocales en ay b, respectivamente. Esto funciona escribiendo una función que multiplica todos sus argumentos ##y los divide por el producto de las vocales. Esta función se aplica a la lista del alfabeto, que pasa cada letra como un argumento separado.

Hasta ahora todo bien, pero ahora tenemos

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

como argumento para Tuples, y esas cosas siguen siendo productos, no listas. Normalmente, la forma más rápida de arreglar eso es poner un List@@@al frente, lo que convierte los productos en listas nuevamente. Desafortunadamente, agregar esos 7 bytes lo hace más largo que el enfoque ingenuo.

Sin embargo, resulta que Tuplesno le importan en absoluto los encabezados de las listas internas. Si lo haces

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

(Sí, para un indefinido f). Obtendrá:

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

Como si hubieras usado un en Listlugar de f. Por lo tanto, podemos pasar esos productos directamente Tuplesy aún así obtener el resultado correcto. Esto ahorra 5 bytes sobre el enfoque ingenuo utilizando dos cadenas codificadas.

Ahora el "a""e""i""o""u""y"sigue siendo bastante molesto. Pero espera, ¡también podemos guardar algunos bytes aquí! Los argumentos de nuestra función son las letras individuales. Entonces, si solo seleccionamos los argumentos correctos, podemos reutilizarlos en lugar de los literales de cadena, que es más corto para tres de ellos. Queremos argumentos# (abreviatura de #1), #5, #9, #15, #21y #25. Si lo ponemos #al final, tampoco necesitamos agregar ninguno *para multiplicarlos, porque (regex) #\d+es un token completo que no puede tener ningún dígito agregado. Por lo tanto, terminamos #5#9#15#21#25#ahorrando otros 4 bytes.

Perl, 47 bytes

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

Contando el shebang como uno.

Pruébalo en línea!

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

Sencilla diversión en bucle :)

Ruby, 72 71 52 bytes

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

Gracias a Value Ink por la idea básica, que la redujo a 60 bytes.

05AB1E , 18 16 bytes

05AB1E utiliza la codificación CP-1252 .

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

Explicación

ž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 fines de prueba, recomiendo reemplazar žPcon algunas consonantes y žOcon algunas vocales.

Ejemplo usando 5 consonantes y 3 vocales

Python 2 , 120 102 94 bytes

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

Pruébalo en línea!

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

Expansión directa de la llave.

Pruébalo en línea .

Si cada artículo debe estar en su propia línea, entonces tenemos:

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

incremento de cadena bonita :)
6 bytes guardados por @Christoph

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

recorre todas las cadenas de bababaa zyzyzy prueba si coinciden con el patrón. Corre con -nr.

MATL , 21 bytes

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

Pruébalo en línea! (pero la salida 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'],[])

No puedo dejar itertoolsganar. Iterative es 1 byte más largo en 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 listconstruye todas las palabras tomando los posibles caracteres para el índice i de la lista devuelta por func (list!!i).

Editar: @xnor encontró 2 bytes para guardar y mirando su solución, encontré otra.

Brachylog , 18 bytes

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

Pruébalo en línea!

Explicación

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

Ediciones

• ETHproductions: -1 byte eliminando un grupo extraño alrededor del operador ternario en la fordeclaración

Explicación

Esto define una función recursiva de 5 profundidades que usa la paridad de su profundidad de llamada para determinar si iterar vocales o consonantes. En cada iteración, verifica si debe repetirse o imprimirse verificando la cantidad de recursiones restantes, y concatena la letra de su iteración actual al final de la cadena de 5 caracteres que se está construyendo actualmente en profundidad.

Solución alternativa de 89 bytes asumiendo la codificación 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)}

Solución alternativa de 96 bytes que devuelve la salida completa como una sola cadena:

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

Corre bajo tu propio riesgo. Para la solución de 91 bytes, simplemente use f()y para la alternativa de 97 bytes, use console.log(f()).

C, 201 199 186 184 183 169 163 bytes

Haciéndolo un poco diferente que con el método de conteo 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);}}

Sin golf:

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

Y escrito de una manera un poco más 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("");
    }
}

Básicamente, yo soy los contadores, y s la matriz de cadenas que contiene todos los caracteres sobre los que debemos iterar, para cada contador. El truco es el bucle while interno : se usa para incrementar los contadores, comenzando por el más a la derecha. Si vemos que el siguiente carácter que deberíamos mostrar es el carácter nulo final, reiniciaremos el contador a cero y el "carry" se propagará al siguiente contador.

Gracias cristoph!

Perl, 71 bytes

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

Pruébalo en línea!

Explicación

Agregaré más explicaciones más tarde.

map{push@{1+/[aeiouy]/},$_}a..z;crea dos matrices: @1contiene las consonantes y @2contiene las vocales.
globCuando llame con argumentos como, {a,b}{c,d}devuelve todas las permutaciones de los elementos entre llaves.

Befunge, 95 bytes

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

Pruébalo en línea! , aunque tenga en cuenta que la salida se truncará.

Esto es solo un bucle en el rango de 0 a 287999, generando el índice como un número mixto 20-6-20-6-20, con los "dígitos" del número recuperado de las tablas en las últimas dos líneas.

Perl 6 , 70 bytes

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

Explicación de la parte interesante:

.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

El código anterior solo genera la lista de vocales ( $_) y la lista de consonantes ( c), que lamentablemente es detallada.

Python 2 , 120 117 bytes

Gracias a @WheatWizard por la sugerencia de pestañas.

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

Pruébalo en línea!

No estoy seguro de que se pueda jugar mucho al golf. Pruébelo en línea se trunca a 128 KB pero muestra lo suficiente como para dar una idea. Una ejecución local con código de depuración para contar las palabras dio un total de 288000. Se ejecuta en aproximadamente 45 segundos si alguien quiere probar.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Versión no compatible y, por lo tanto, no competitiva (imprime matrices anidadas en lugar del 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

Toma un poco de tiempo tener alguna salida. Muy ineficiente Hace el trabajo.

xeger , 49 bytes

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

Dada una expresión regular, xeger simplemente genera todas las cadenas coincidentes. Para no matar el navegador, se detiene cada 1000 salidas y debe hacer clic para continuar, pero eventualmente llegará allí.

Aquí hay una versión de 23 bytes con un error ^corregido:

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

Estas son clases de caracteres "todas las consonantes ASCII en minúsculas" [:c]con yexcluido ^y, y "todas las vocales ASCII en minúscula" [:v:]con yagregado.

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]:['']

Devuelve una matriz de cadenas. Versión muy rápido para 102 101 (1 byte gracias 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

Ahorró 2 bytes gracias a Martin Ender y 1 byte gracias a kaine

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

Pruébalo en línea! (Tenga en cuenta que la salida se corta en TIO)

Explicación

"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

Apilado, no competitivo, 51 bytes

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

Bastante simple. Pruébalo aquí!

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

Probar Perl golf para variar.
EDITAR: Parece que todavía tengo mucho que 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 es mi primera vez en Code Golf, así que agradecería cualquier sugerencia para reducirlo aún más. Hasta ahora todo es bastante estándar R; Lo único posiblemente complicado aquí es que paste0 recicla sus argumentos a la longitud del más largo.

Editar: truco de asignación usado de rturnbull, reemplazado sapply(x,length)por lengths.

R, 111 98 bytes

Agregado ycomo vocal y con 13 bytes de golf, gracias 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 generar todas las combinaciones posibles de Vy Cen una matriz, que definimos a partir de la variable preestablecida letters(el alfabeto). Revertimos las combinaciones (ya que el valor predeterminado es que la primera variable gire más rápido) para garantizar el orden alfabético. Luego iteramos a través de cada fila de la matriz, imprimiendo cada letra en stdout. Usamos el fillargumento para catasegurarnos de que cada palabra comience en una nueva línea.

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

No es tan emocionante ...

Rubí, 65 61 bytes

Enfoque completamente diferente:

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

Cosas nuevas que aprendí hoy: la función de producto Array #

C 361 bytes

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

Versión sin golf:

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

Debe haber alguna forma de acortar esto definitivamente.

Explicación

• Almacenamos los valores enteros de a, e, i, o, u, y en una matriz numérica,
• Almacenaba todos los alfabetos en la matriz, si era una vocal, la reemplazaba por una consonante, por lo que había valores de consonantes duplicados en la matriz,
• Se eliminaron valores de consonantes duplicados,
• Impreso todas las combinaciones de cvcvc.