Votre tâche consiste à écrire un programme qui produira une liste lisible de tous les mots de cinq lettres avec la structure suivante:

consonne - voyelle - consonne - voyelle - consonne

La sortie doit être triée alphabétiquement avec un mot par ligne et aucun mot ne doit être répété deux fois. Il peut être en minuscule ou en majuscule mais pas mélangé. Donc, la liste pourrait commencer et se terminer comme ceci:

babab  
babac  
babad  
...  
zyzyw  
zyzyx  
zyzyz 

Les voyelles sont a - e - i - o - u - y , les 20 autres lettres de l 'alphabet anglais sont des consonnes.
Les mots ne doivent pas nécessairement être des mots du dictionnaire.
Le code le plus court gagne.

Remarque: Il y a quelques années, je suis tombé sur un programme sur un site Web universitaire qui faisait exactement cela. Il s'avère que mon prénom et mon nom de famille correspondent à la contrainte cvcvc, et que je me cherchais moi-même.

Mathematica, 72 65 61 octets

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

Pour les tests, je recommande de remplacer Print@@@par""<>#&/@ . Mathematica affichera ensuite une forme tronquée indiquant les premiers et derniers mots au lieu de prendre indéfiniment 288 000 lignes.

Explication

J'ai finalement trouvé un usage pour diviser des chaînes. :)

J'ai été intrigué par la possibilité d'ajouter ou de multiplier des chaînes pendant un moment, mais les cas d'utilisation réels sont assez limités. Le point principal est que quelque chose comme "foo"+"bar"ou "foo"*"bar"(et par conséquent la forme abrégée "foo""bar") est tout à fait valable dans Mathematica. Cependant, il ne sait pas vraiment quoi faire avec les chaînes dans les expressions arithmétiques, donc ces choses ne sont pas évaluées. Mathematica ne s'applique généralement applicables si simplifications. En particulier, les chaînes seront triées dans l'ordre canonique (ce qui est assez compliqué dans Mathematica, une fois que vous commencez à trier des chaînes contenant des lettres de casse différente, des chiffres et des non-lettres), ce qui est souvent un dealbreaker, mais cela n'a pas d'importance ici. . En outre, "abc""abc"sera simplifié pour"abc"^2(ce qui pose un problème lorsque vous avez répété des chaînes, mais nous ne l’avons pas non plus), et quelque chose comme "abc"/"abc"va réellement annuler (que nous utiliserons même).

Alors, qu'essayons-nous de jouer au golf ici. Nous avons besoin d'une liste de voyelles et d'une liste de consonnes pour pouvoir les alimenter Tupleset générer toutes les combinaisons possibles. Ma première approche a été la solution naïve:

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

Cette liste de consonnes codée en dur fait un peu mal. Mathematica possède une fonction Alphabetintégrée qui me permettrait de l'éviter si je pouvais supprimer les voyelles de manière économique. C'est là que ça devient difficile. Le moyen le plus simple de supprimer des éléments est Complement, mais cela finit par être plus long, en utilisant l'une des options suivantes:

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

(Notez que nous n'avons plus besoin d'appliquer Charactersà l'ensemble, car Alphabet[]donne une liste de lettres, pas une chaîne.)

Essayons donc cette affaire d'arithmétique. Si nous représentons tout l'alphabet comme un produit de lettres au lieu d'une liste, nous pouvons supprimer les lettres par simple division, en raison de la règle d'annulation. Cela économise beaucoup d'octets car nous n'en aurons pas besoin Complement. En outre, "a""e""i""o""u""y"est en fait un octet plus court que Characters@"aeiouy". Nous faisons donc cela avec:

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

Où nous stockons les produits de consonnes et de voyelles dans aet b, respectivement. Cela fonctionne en écrivant une fonction qui multiplie tous ses arguments avec ##et les divise par le produit des voyelles. Cette fonction est appliquée à la liste alphabétique, qui transmet chaque lettre en tant qu'argument séparé.

Jusqu'ici tout va bien, mais maintenant nous avons

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

comme argument à Tuples, et ces choses sont toujours des produits, pas des listes. Normalement, le moyen le plus rapide de remédier à ce problème consiste à mettre un List@@@à l'avant, ce qui transforme à nouveau les produits en listes. Malheureusement, l'ajout de ces 7 octets le rend plus long que l'approche naïve.

Cependant, il s'avère que Tuplespeu importe la tête des listes intérieures. Si tu fais

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

(Oui, pour un indéfini f.) Vous obtiendrez:

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

Juste comme si vous aviez utilisé un Listau lieu de f. Nous pouvons donc passer ces produits directement Tupleset obtenir le bon résultat. Cela permet d'économiser 5 octets sur l'approche naïve en utilisant deux chaînes codées en dur.

Maintenant, "a""e""i""o""u""y"c'est toujours assez ennuyant. Mais attendez, nous pouvons économiser quelques octets ici aussi! Les arguments de notre fonction sont les lettres individuelles. Donc, si nous choisissons juste les bons arguments, nous pouvons les réutiliser au lieu des littéraux de chaîne, ce qui est plus court pour trois d'entre eux. Nous voulons des arguments #(court pour #1), #5, #9, #15, #21et #25. Si nous plaçons #à la fin, nous n’avons pas non plus besoin d’ajouter d’autres *pour les multiplier, car (regex) #\d+est un jeton complet auquel aucun non-chiffre ne peut être ajouté. Par conséquent, nous nous retrouvons avec #5#9#15#21#25#, économisant encore 4 octets.

Perl, 47 octets

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

Compter le shebang comme un.

Essayez-le en ligne!

Python 3 - 110 octets

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

Amusement en boucle simple :)

Ruby, 72 71 52 octets

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

Merci à Value Ink pour l’idée de base, qui a ramené cela à 60 octets.

05AB1E , 18 16 octets

05AB1E utilise le codage CP-1252 .

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

Explication

ž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

À des fins de test, je recommande de remplacer žPpar quelques consonnes et žOquelques voyelles.

Exemple utilisant 5 consonnes et 3 voyelles

Python 2 , 120 102 94 octets

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

Essayez-le en ligne!

Pure Bash, 74 ans

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

Expansion d'accolade simple.

Essayez-le en ligne .

Si chaque article doit être sur sa propre ligne, alors nous avons:

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 octets

joli incrément de chaîne :)
6 octets enregistrés par @Christoph

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

boucles à travers toutes les chaînes de bababala zyzyzet des tests si elles correspondent au modèle. Courez avec -nr.

MATL , 21 octets

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

Essayez-le en ligne! (mais la sortie est tronquée).

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 octets

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

Ne peut pas laisser itertoolsgagner. Itératif est 1 octet plus long dans 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 octets

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

mapM func listconstruit tous les mots en prenant les caractères possibles pour l’index i dans la liste renvoyée par func (list!!i).

Edit: @xnor a trouvé 2 octets à sauvegarder et en regardant sa solution, j'ai trouvé un autre.

Brachylog , 18 octets

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

Essayez-le en ligne!

Explication

@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 octets

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

Édite

• ETHproductions: -1 octet en supprimant le groupe superposé autour de l'opérateur ternaire dans l' forinstruction

Explication

This defines a 5-deep recursive function that uses the parity of its depth of call to determine whether to iterate vowels or consonants. On each iteration, it checks to see whether to recurse or print by checking the amount of recursions left, and concatenates the letter of its current iteration to the end of the 5 character string that is currently being built depth-first.

Solution alternative à 89 octets utilisant le codage 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)}

Solution alternative à 96 octets qui renvoie la sortie entière en tant que chaîne unique:

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

Courez à vos risques et périls. Pour la solution à 91 octets, utilisez simplement f()et pour l'option à 97 octets, utilisez console.log(f()).

C, 201 199 186 184 183 169 163 bytes

Doing it a bit differently than with the previous basic counting method:

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

And written in a bit more conventional way:

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

Basically, i are the counters, and s the array of strings containing all the chars over which we should iterate, for each counter. The trick is the inner while loop: it is used to increment the counters, starting from the rightmost one. If we see that the next character we should display is the ending null char, we restart the counter to zero and the "carry" will be propagated to the next counter.

Thanks Cristoph!

Perl, 71 bytes

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

Try it online!

Explanation

I'll add more explanations later.

map{push@{1+/[aeiouy]/},$_}a..z; creates two arrays: @1 contains the consonants, and @2 contains the vowels.
glob when call with arguments like {a,b}{c,d} returns all permutations of the elements in the braces.

Befunge, 95 bytes

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

Try it online!, although note that the output will be truncated.

This is just a loop over the range 0 to 287999, outputting the index as a mixed based number 20-6-20-6-20, with the "digits" of the number retrieved from the tables on the last two lines.

Perl 6, 70 bytes

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

Explanation of the interesting part:

.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

The code before that just generates the list of vowels ($_) and the list of consonants (c), which is regrettably verbose.

Python 2, 120 117 bytes

Thanks to @WheatWizard for the tabs tip.

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

Try it online!

Not sure that this can be golfed much. Try it online truncates at 128KB but shows enough to give an idea. A local run with debug code to count the words gave a total of 288000. Runs in about 45 seconds if anyone wants to test.

zyzyv
zyzyw
zyzyx
zyzyz
Total word count: 288000

Non-compliant and therefore non-competing version (prints out nested arrays instead of the specified format) for 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

Takes a little time to have any output. Very inefficient. Does the job.

xeger, 49 bytes

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

Given a regular expression, xeger simply generates all matching strings. In order not to kill the browser, it pauses every 1000 outputs and you need to click to continue, but it'll get there eventually.

Here's a 23-byte version with a bug in ^ fixed:

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

These are character classes "all lower-case ASCII consonants" [:c] with y excluded ^y, and "all lower-case ASCII vowels" [:v:] with y added.

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

Returns an array of strings. Very fast version for 102 101 (1 byte thanks to @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

Saved 2 bytes thanks to Martin Ender and 1 byte thanks to kaine

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

Try it online! (Note that the output gets cut off on TIO)

Explanation

"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

Stacked, noncompeting, 51 bytes

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

Pretty simple. Try it here!

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

Trying Perl golf for a change.
EDIT: Looks like I've still got much to learn... :)

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

This is my first go at code golf so I'd welcome any suggestions to chop it down further. So far it's all pretty standard R; the only possibly tricky thing here is that paste0 recycles its arguments to the length of the longest one.

Edit: used assignment trick from rturnbull, replaced sapply(x,length) with lengths.

R, 111 98 bytes

Added y as a vowel, and golfed off 13 bytes, thanks to @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="")

We use expand.grid to generate all possible combinations of V and C in a matrix, which we define from the preset variable letters (the alphabet). We reverse the combinations (as the default is for the first variable to rotate the fastest) to ensure alphabetical order. Then we iterate through each row of the matrix, printing each letter to stdout. We use the fill argument to cat to ensure that each word begins on a new line.

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

Not that exciting...

Ruby, 65 61 bytes

Completely different approach:

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

New things I learned today: the Array#product function

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

Ungolfed version:

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

There must be some way to shorten this definitely.

Explanation

• Stored the integer values of a,e,i,o,u,y in a numerical array,
• Stored all alphabets in array, if it was a vowel, replaced it with a consonant, so there were duplicate consonant values in the array,
• Removed duplicate consonant values,
• Printed all combinations c-v-c-v-c.