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.