Le défi est simple:

générer un mot.

Caractéristiques:

• Le mot doit être prononçable.
  • Ceci est défini comme «alternant entre une consonne et une voyelle».
  • Une consonne est l'une des lettres suivantes: bcdfghjklmnpqrstvwxz
  • Une voyelle est l'une des lettres suivantes: aeiouy
• Le mot doit être généré de manière aléatoire.
• Les mots doivent pouvoir contenir chaque consonne et voyelle. (Vous ne pouvez pas simplement utiliser bcdfpour les consonnes et les aeivoyelles.)
• Le mot doit contenir 10 lettres.
• Le code le plus court (en nombre de caractères) gagne.

GolfScript, 32 caractères

['aeiouy'.123,97>^]5*{.,rand=}%+

Exécutez-le en ligne .

Ruby: 56 caractères

([v=%w(a e i o u y),[*?a..?z]-v]*5).map{|a|$><<a.sample}

Exemples de sorties:

• itopytojog
• umapujojim
• ipagodusas
• yfoqinifyw
• ebylipodiz

Python, 81

from random import*
print''.join(map(choice,["bcdfghjklmnpqrstvwxz","aeiouy"]*5))

Bonne chance pour les prononcer.

COBOL, 255

J'apprends donc COBOL en ce moment. Utilisé cette question comme pratique. J'ai essayé de jouer au golf.

C'est 255 sans le premier espace blanc et 286 octets avec.

Pour ce que ça vaut, cela fonctionne dans Microfocus COBOL pour VS2012, et je n'ai aucune idée si cela fonctionnera ailleurs.

       1 l pic 99 1 s pic x(26) value'aeiouybcdfghjklmnpqrstvwxz' 1 r
       pic 99 1 v pic 9 1 q pic 99. accept q perform test after varying
       l from 1 by 1 until l>9 compute v=function mod(l,2) compute r=1+
       function random(q*l)*5+v*15+v*5 display s(r:1)end-perform exit

APL (34)

,⍉↑(V[5?6])((⎕A~V←'AEIOUY')[5?20])

JavaScript, 74

for(a=b=[];a++-5;)b+="bcdfghjklmnpqrstvwxz"[c=new Date*a%20]+"aeiouy"[c%6]

Ne génère pas toutes les combinaisons, mais je pense que toutes les consonnes et voyelles apparaissent.

JavaScript, 79

for(a=b=[];a--+5;)b+="bcdfghjklmnpqrstvwxz"[c=Math.random()*20^0]+"aeiouy"[c%6]

Version plus "aléatoire".

Ruby: 70 66 caractères

10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}

Exemple d'exécution:

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
izogoreroz

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
onewijolen

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
amilyfilil

R: 105 caractères

a=c(1,5,9,15,21,25)
l=letters
s=sample
cat(apply(cbind(s(l[-a],5),s(l[a],5)),1,paste,collapse=""),sep="")

J (51)

,|:>(<"1[5?6 20){&.>'aeiouy';'bcdfghjklmnpqrstvwxz'

Traitement, 100 99 93 87

int i=10;while(i-->0)"aeiouybcdfghjklmnpqrstvwxz".charAt((int)random(i%2*6,6+i%2*i*2));

En examinant de plus près la question, je vois qu'elle ne nécessite aucune sortie. J'ai ajusté cela en conséquence.

Objectif-C, 129

main(){int i=10;while(i-->0)printf("%c",[(i%2==0)?@"aeiouy":@"bcdfghjklmnpqrstvwxz"characterAtIndex:arc4random()%(6+(i%2)*14)]);}

Avec l'aide de Daniero

(J'adore utiliser l' opérateur de tendance (->)

Java AKA la langue la plus verbeuse jamais créée, 176 avec l'aide de Doorknob, Daniero et Peter Taylor (merci les gars!)

class w{public static void main(String[]a){int i=11;while(--i>0)System.out.print((i%2==0?"aeiouy":"bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6+(i%2)*14)));}}

Non golfé:

    class w {

        public static void main(String[] a) {
            int i = 11;
            while (--i > 0) {
                System.out.print((i % 2 == 0 ? "aeiouy" : "bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6 + (i % 2) * 14)));
            }
     }

}

Javascript, 85

for(r=Math.random,s="",i=5;i--;)s+="bcdfghjklmnpqrstvwxz"[20*r()|0]+"aeiouy"[6*r()|0]

S'il est exécuté à partir de la console, la sortie est affichée. L'affichage explicite ajouterait alert(s)8 caractères, encore plus court que les autres solutions JS.

Merci C5H8NNaO4 et Howard!

Javascript, 135 122 96 86 caractères

s='';c=5;r=Math.random;while(c--)s+='bcdfghjklmnpqrstvwxz'[r()*20|0]+'aeiouy'[r()*6|0]

PHP, 100 caractères

<?while($i<6){echo substr('bcdfghjklmnpqrstvwxz',rand(0,20),1).substr('aeiouy',rand(0,5),1);$i++;}?>

Outils Unix: 73 octets

Et le temps de fonctionnement n'est pas garanti :)

</dev/urandom grep -ao '[aeiouy][bcdfghjklmnpqrstvwxz]'|head -5|paste -sd ''

Le seul problème est que la chaîne générée commencera à chaque fois par une "voyelle".

(edit: changé ' 'en ''dans les args de paste) (un autre edit: supprimé -P des options grep, grâce au manatwork )

Pyth, 26 caractères

J-G"aeiouy"VT=k+kOJ=J-GJ;k

Vous pouvez l'essayer dans le compilateur en ligne ici.

Quelqu'un a posté un défi très similaire, mais il a été clôturé après avoir trouvé une solution. Je ne m'en étais pas rendu compte, mais cette question est antérieure à la création de Pyth. Quoi qu'il en soit, voici la répartition:

J                             Set string J equal to:
  G                            the entire alphabet (lowercase, in order)
 - "aeiouy"                    minus the vowels
           VT                 For n in range(1, 10):
             =k                   Set string k to:
                k                  k (defaults to empty string)
               + OJ                plus a random character from J
                   =J             Set J to:
                      G            the entire alphabet
                     - J           minus J
                        ;     End of loop
                         k    print k

Chaque fois que la boucle est exécutée, J passe d'une liste de consonnes à une liste de voyelles. De cette façon, nous pouvons simplement choisir une lettre aléatoire de J à chaque fois.
Il peut y avoir un moyen d'initialiser J dans la boucle ou de supprimer les affectations explicites de la boucle, mais je n'ai pas encore réussi avec les deux.

APL 30 26

,('EIOUY'∪⎕A)[6(|,+)⍪5?20]

L'explication est très similaire à la version précédente ci-dessous, juste réorganisée un peu pour jouer au golf avec la solution.

Remarque: ⎕IO est défini sur 0

('EIOUY'∪⎕A)[,6(|,(⍪+))5?20]

Explication:

'EIOUY'∪⎕A    puts vowels in front of all letters.
5?20            for the indexes we start choosing 5 random numbers between 0 and 19
6(|,(⍪+))        then we sum 6 and the random numbers, convert to 5x1 matrix (⍪), add a column before this one containing 6 modulo the random numbers. 
                [[[ this one can be rewritten as: (6|n) , ⍪(6+n)  for easier understanding]]]
,6(|,(⍪+))5?20  the leading comma just converts the matrix to a vector, mixing the vowel and consonants indexes.

Tryapl.org

PHP 79 octets

<?for($c=bcdfghjklmnpqrstvwxz,$v=aeiouy;5>$i++;)echo$c[rand()%20],$v[rand()%6];

Assez concis.

C: 101

main(){int x=5;while(x-->0){putchar("bcdfghjklmnpqrstvwxyz"[rand()%21]);putchar("aeiou"[rand()%5]);}}

Javascript, 104 87

a="";for(e=10;e--;)a+=(b=e&1?"bcdfghjklmnpqrstvwxz":"aeiouy")[0|Math.random()*b.length]

golfé beaucoup de choses inutiles simples, toujours pas aussi belles que celles de copys

Oh, et celui-là vient de se produire pendant le golf: "dydudelidu"

_{Maintenant, j'en ai essayé un en utilisant l'approche des 2 caractères à la fois. Il s'avère que c'est presque le même que le deuxième copys, donc je ne peux pas le compter, également à 79. a="";for(e=5;e--;)a+="bcdfghjklmnpqrstvwxz"[m=0|20*Math.random()]+"aeiouy"[m%6]}

Brachylog , 9 octets

Ḍ;Ẉṣᵐzh₅c

Essayez-le en ligne!

Donne la sortie sous forme de liste de lettres via la variable de sortie.

   ṣ         Randomly shuffle
 ;  ᵐ        both
Ḍ            the consonants without y
  Ẉ          and the vowels with y,
     z       zip them into pairs,
      h₅     take the first five pairs,
             and output
        c    their concatenation.

F # , 166 caractères

open System;String.Join("",(Random(),"aeiouybcdfghjklmnpqrstvwxz")|>(fun(r,s)->[0..5]|>List.collect(fun t->[s.Substring(6+r.Next()%20,1);s.Substring(r.Next()%6,1)])))

K, 40 octets

,/+5?/:("bcdfghjklmnpqrstvwxz";"aeiouy")

5?"abc" générera 5 lettres aléatoires à partir de la chaîne donnée.

5?/: générera 5 lettres aléatoires à partir de chacune des chaînes de droite, produisant deux listes.

+ transpose ces deux listes, nous donnant une liste de tuples avec un caractère aléatoire de la première liste, puis un de la deuxième liste.

,/ est "raze" - fusionnez tous ces tuples en séquence.

K5 peut le faire en 33 octets en construisant l'alphabet plus intelligemment puis en utilisant "except" ( ^) pour supprimer les voyelles, mais K5 est beaucoup trop nouveau pour être légal dans cette question:

,/+5?/:((`c$97+!26)^v;v:"aeiouy")

R, 83 octets

cat(outer((l<-letters)[a<-c(1,5,9,15,21,25)],l[-a],paste0)[sample(1:120,5)],sep="")

Générez toutes les séquences de voyelles-consonnes possibles dans une matrice, puis échantillonnez au hasard 5 d'entre elles, ce qui donne un mot de 10 lettres.

05AB1E , 10 octets

5FžPΩ?žOΩ?

Essayez-le en ligne ou sortez$n$quantité de mots aléatoires .

Explication:

Assez simple:

5F      # Loop 5 times:
  žP    #  Push string "bcdfghjklmnpqrstvwxz"
    Ω   #  Pop and push a random character from this string
     ?  #  Output it without newline
  žOΩ?  #  Do the same with string "aeiouy"

Gelée , 13 octets

Øy,ØYẊ€Zs5ḢŒl

Explication:

Øy,ØYẊ€Zs5ḢŒl
Øy,ØY         Makes a list of two lists of characters: [[list-of-vowels-with-y], [list-of-consonants-without-y]]
     Ẋ€       Shuffle €ach.
       Z      Zip those two lists together. [[random-vowel, random-consonant],...]
        s5    Split them into chunks of five (because each pair contains two letters, this splits them into chunks of 10 letters)
          Ḣ   Take the list of 5 pairs.
           Œl Make each of the characters in it lowercase
              Implicit concatenation and print.

Essayez-le en ligne!