Compte tenu d' une chaîne d'entrée, la sortie de cette chaîne avec toutes les voyelles a, e, i, oet utroqué au hasard entre eux.

Par exemple, dans la chaîne this is a test, il y a 4 voyelles: [i, i, a, e]. Un brassage valide de ces voyelles pourrait [a, i, e, i]donc donner la sortie thas is e tist.

À propos du mélange

Tous les remaniements seront également probables si nous considérons que les voyelles égales sont distinctes . Pour l'exemple ci-dessus, ces 24 mélanges sont possibles:

[i 1 , i 2 , a, e] [i 1 , i 2 , e, a] [i 1 , a, i 2 , e] [i 1 , a, e, i 2 ]
[i 1 , e, i 2 , a] [i 1 , e, a, i 2 ] [i 2 , i 1 , a, e] [i 2 , i 1 , e, a]
[i 2 , a, i 1 , e] [i 2 , a, e, i 1 ] [i 2 , e, i 1 , a] [i 2 , e, a, i 1 ]
[a, i 1 , i 2 , e] [a, i 1 , e, i 2 ] [a, i 2 , i 1 , e] [a, i 2 , e, i 1 ]
[a, e, i 1 , i 2 ] [a, e, i 2 , i 1 ] [e, i 1 , i 2 , a] [e, i 1 , a, i 2 ]
[e, i 2 , i 1 , a] [e, i 2 , a, i 1 ] [e, a, i 1 , i 2 ] [e, a, i 2 , i 1 ]

Chacun devrait être tout aussi probable.

Vous ne pouvez pas essayer de mélanger au hasard toute la chaîne avant d'en trouver une où toutes les voyelles sont au bon endroit. En bref, le temps d'exécution de votre code doit être constant si l'entrée est constante.

Entrées et sorties

• Vous pouvez supposer que toutes les lettres de l'entrée seront en minuscule ou en majuscule. Vous pouvez également prendre en charge des boîtiers mixtes, bien que cela ne vous donne aucun bonus.

• L'entrée consistera toujours en caractères ASCII imprimables. Tous les caractères qui sont dans l'entrée doivent être dans la sortie, seules les voyelles doivent être mélangées et rien d'autre.

• L'entrée peut être vide. Rien ne garantit que l'entrée contiendra au moins une voyelle ou au moins une non-voyelle.

• Vous pouvez prendre l’entrée from STDIN, en tant que paramètre de fonction ou quelque chose de similaire.

• Vous pouvez imprimer la sortie dans STDOUT, la renvoyer depuis une fonction ou quelque chose de similaire.

Cas de test

La première ligne est l'entrée donnée. La deuxième ligne est l’une des sorties possibles.

<empty string>
<empty string>

a
a

cwm
cwm

the quick brown fox jumps over the lazy dog.
tho qeuck brewn fax jumps ovir the lozy dog.

abcdefghijklmnopqrstuvwxyz
abcdefghujklmnipqrstovwxyz

programming puzzles & code golf
pregromming pezzlos & coda gulf

fatalize
fitaleza

martin ender
mirten ander

Notation

C’est le code-golf , mais il faut que ce soit en un rien de temps .

Gelée , 15 octets

f€“¡ẎṢɱ»ðœpżFẊ¥

Essayez-le en ligne!

Comment ça marche

f€“¡ẎṢɱ»ðœpżFẊ¥  Main link. Argument: s (string)

  “¡ẎṢɱ»         Yield "aeuoi"; concatenate "a" with the dictionary word "euoi".
f€               Filter each character in s by presence in "aeuoi".
                 This yields A, an array of singleton and empty strings.
        ð        Begin a new, dyadic chain. Left argument: A. Right argument: s
         œp      Partition s at truthy values (singleton strings of vowels) in A.
            FẊ¥  Flatten and shuffle A. This yields a permutation of the vowels.
           ż     Zip the partition of consonants with the shuffled vowels.

R, 92 91

Je ne peux pas encore commenter, alors j'ajoute ma propre réponse, bien que très similaire à la réponse de @ Andreï Kostyrka (croyez-le ou non, mais venez de manière indépendante).

s=strsplit(readline(),"")[[1]];v=s%in%c("a","e","i","o","u");s[v]=sample(s[v]);cat(s,sep="")

Ungolfed

s=strsplit(readline(),"")[[1]]    # Read input and store as a vector
v=s%in%c("a","e","i","o","u")     # Return TRUE/FALSE vector if vowel
s[v]=sample(s[v])                 # Replace vector if TRUE with a random permutation of vowels
cat(s,sep="")                     # Print concatenated vector

Un octet enregistré grâce à @Vlo

s=strsplit(readline(),"")[[1]];s[v]=sample(s[v<-s%in%c("a","e","i","o","u")]);cat(s,sep="")

R, 99 98 89 octets

x=el(strsplit(readline(),""))
z=grepl("[aeiou]",x)
x[z]=x[sample(which(z))]
cat(x,sep="")

Semble être la première solution lisible par l'homme! Merci à Giuseppe d’ avoir économisé 9 octets!

Cas de test:

tho qaeck bruwn fux jemps over tho lozy dig.
progremmang pozzlos & cide gulf

On dirait qu'il n'y a aucun moyen de faire une affectation de variable interne (à l'intérieur, comme, cat), et encore une fois, certaines personnes vont prouver que je me trompe ...

CJam, 23 octets

lee_{"aeiou"&},_mrerWf=

Essayez-le en ligne!

Explication

l            e# Read input, e.g. "foobar".
ee           e# Enumerate, e.g. [[0 'f] [1 'o] [2 'o] [3 'b] [4 'a] [5 'r]].
_            e# Duplicate.
{"aeiou"&},  e# Keep those which have a non-empty intersection with this string
             e# of vowels, i.e. those where the enumerated character is a vowel.
             e# E.g. [[1 'o] [2 'o] [4 'a]].
_            e# Duplicate.
mr           e# Shuffle the copy. E.g. [[2 'o] [4 'a] [1 'o]].
er           e# Transliteration. Replaces elements from the sorted copy with
             e# the corresponding element in the shuffled copy in the original list.
             e# [[0 'f] [2 'o] [4 'a] [3 'b] [1 'o] [5 'r]].
Wf=          e# Get the last element of each pair, e.g. "foabor".

05AB1E , 17 octets

žMÃ.r`¹vžMyå_iy}?

Explication

žMÃ                # get all vowels from input
   .r`             # randomize them and place on stack
      ¹v           # for each in input
        žMyå_i }   # if it is not a vowel
              y    # push it on stack
                ?  # print top of stack

Essayez-le en ligne!

Python 3, 109 octets

Ne supporte que les voyelles minuscules.

Merci à @Alissa pour avoir sauvegardé un octet supplémentaire.

import re,random
def f(s):r='[aeiou]';a=re.findall(r,s);random.shuffle(a);return re.sub(r,lambda m:a.pop(),s)

Ideone ça!

TSQL, 275 octets

Golfé:

DECLARE @ VARCHAR(99)='the quick brown fox jumps over the lazy dog.'

;WITH c as(SELECT LEFT(@,0)x,0i UNION ALL SELECT LEFT(substring(@,i+1,1),1),i+1FROM c
WHERE i<LEN(@)),d as(SELECT *,rank()over(order by newid())a,row_number()over(order by 1/0)b
FROM c WHERE x IN('a','e','i','o','u'))SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b PRINT @

Ungolfed:

DECLARE @ VARCHAR(max)='the quick brown fox jumps over the lazy dog.'

;WITH c as
(
  SELECT LEFT(@,0)x,0i
  UNION ALL
  SELECT LEFT(substring(@,i+1,1),1),i+1
  FROM c
  WHERE i<LEN(@)
),d as
(
  SELECT 
    *,
    rank()over(order by newid())a,
    row_number()over(order by 1/0)b
  FROM c
  WHERE x IN('a','e','i','o','u')
)
SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b
-- next row will be necessary in order to handle texts longer than 99 bytes
-- not included in the golfed version, also using varchar(max) instead of varchar(99)
OPTION(MAXRECURSION 0) 

PRINT @

Violon

Perl, 38 octets

Inclut +1 pour -p

Exécuter avec la phrase sur STDIN

vawols.pl <<< "programming puzzles & code golf"

vawols.pl:

#!/usr/bin/perl -p
@Q=/[aeiou]/g;s//splice@Q,rand@Q,1/eg

Java 7, 243 241 octets

import java.util.*;String c(char[]z){List l=new ArrayList();char i,c;for(i=0;i<z.length;i++)if("aeiou".indexOf(c=z[i])>=0){l.add(c);z[i]=0;}Collections.shuffle(l);String r="";for(i=0;i<z.length;i++)r+=z[i]<1?(char)l.remove(0):z[i];return r;}

Oui, cela peut probablement être un peu joué au golf, mais Java n’a pas d’intégration pratique pour cet afaik .. De plus, j’ai un peu oublié la variante codegolfed array-variant pour Collections.shuffle..

Ungolfed & cas de test:

Essayez ici.

import java.util.*;
class M{
  static String c(char[] z){
    List l = new ArrayList();
    char i,
         c;
    for(i = 0; i < z.length; i++){
      if("aeiou".indexOf(c = z[i]) >= 0){
        l.add(c);
        z[i] = 0;
      }
    }
    Collections.shuffle(l);
    String r = "";
    for(i = 0; i < z.length; i++){
      r += z[i] < 1
               ? (char)l.remove(0)
               : z[i];
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("".toCharArray()));
    System.out.println(c("a".toCharArray()));
    System.out.println(c("cwm".toCharArray()));
    System.out.println(c("the quick brown fox jumps over the lazy dog.".toCharArray()));
    System.out.println(c("abcdefghijklmnopqrstuvwxyz".toCharArray()));
    System.out.println(c("programming puzzles & code golf".toCharArray()));
    System.out.println(c("fatalize".toCharArray()));
    System.out.println(c("martin ender".toCharArray()));
  }
}

Sortie possible:

a
cwm
tha queck brown fox jumps evor tho lezy dig.
ebcdifghujklmnopqrstavwxyz
prigrommeng puzzlos & cade golf
fatelazi
mertan inder

Perl 6 , 65 octets

{my \v=m:g/<[aeiou]>/;my @a=.comb;@a[v».from]=v.pick(*);@a.join}

Fonction anonyme. Suppose une entrée en minuscule.

( essayez-le en ligne )

Ruby 45 + 1 = 46 octets

+1 octet pour le -pdrapeau

a=$_.scan(e=/[aeiou]/).shuffle
gsub(e){a.pop}

Brachylog , 39 octets

@eI:1aToS,I:2f@~:LcS,Tc
.'~e@V;
e.~e@V,

Essayez-le en ligne!

Explication

• Prédicat principal:

  @eI        I is the list of chars of the input.
  :1aT       T is I where all vowels are replaced with free variables.
  oS,        S is T sorted (all free variables come first).
  I:2f       Find all vowels in I.
  @~         Shuffle them.
  :LcS,      This shuffle concatenated with L (whatever it may be) results in S.
               This will unify the free variables in S with the shuffled vowels.
  Tc         Output is the concatenation of elements of T.
  

• Prédicat 1:

  .          Input = Output…
  '~e@V      …provided that it is not a vowel.
  ;          Otherwise Output is a free variable.
  

• Prédicat 2:

  e.         Output is an element of the input…
  ~e@V,      … and it is a vowel.
  

Javascript (ES6), 78 76 octets

s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))

2 octets sauvés grâce à apsillers

Version alternative proposée par apsillers (76 octets également)

s=>s.replace(r=/[aeiou]/g,[].pop.bind(s.match(r).sort(_=>Math.random()-.5)))

Tester

let f =
s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))

console.log(f("the quick brown fox jumps over the lazy dog."))

MATL , 15 octets

tt11Y2m)tnZr7M(

Essayez-le en ligne!

Explication

tt      % Take input string implicitly. Duplicate twice
11Y2    % Predefined string: 'aeiou'
m       % Logical index that contains true for chars of the input that are vowels
)       % Get those chars from the input string. Gives a substring formed by the
        % vowels in their input order
tnZr    % Random permutation of that substring. This is done via random sampling
        % of that many elements without replacement
7M      % Push logical index of vowel positions again
(       % Assign the shuffled vowels into the input string. Display implicitly

Japt v2.0a0, 14 à 13 octets

ō²f\v
NÌr\v@o

L'essayer

Explication

           :Implicit input of string U.
ö²         :Generate a random permutation of U.
  f\v      :Get all the vowels as an array.
\n         :Assign that array to U.
NÌ         :Get the last element in the array of inputs (i.e., the original value of U)
  r\v      :Replace each vowel.
     @o    :Pop the last element from the array assigned to U above.

Pyth, 26 octets

J"[aeiou]"s.i:QJ3.Sf}TPtJQ

Un programme qui prend en entrée une chaîne entre guillemets et imprime la chaîne mélangée.

Essayez-le en ligne

Comment ça marche

J"[aeiou]"s.i:QJ3.Sf}TPtJQ  Program. Input: Q
J"[aeiou]"                  J="[aeiou]"
             :QJ3           Split Q on matches of regex J, removing vowels
                      PtJ   J[1:-1], yielding "aeiou"
                   f}T   Q  Filter Q on presence in above, yielding vowels
                 .S         Randomly shuffle vowels
           .i               Interleave non-vowel and vowel parts
          s                 Concatenate and implicitly print

PHP, 144 129 octets

Utilisation de la minuscule

$r=Aaeiou;$v=str_shuffle(preg_replace("#[^$r]+#",'',$a=$argv[1]));for(;$i<strlen($a);)echo strpos($r,$a[$i++])?$v[$j++]:$a[$i-1];

Explication:

$r="aeiou"; // set vowels

preg_replace("#[^$r]+#",'',$argv[1]) // find all vowels in input

$v=str_shuffle() // shuffle them

for(;$i<strlen($a);) // run through the text

strpos($r,$a[$i++])?$v[$j++]:$a[$i-1]; // if it's a vowel print the j-th shuffled vowel else print original text

En fait, 24 octets

;"aeiou";╗@s@`╜íu`░╚@♀+Σ

Essayez-le en ligne!

Explication:

;"aeiou";╗@s@`╜íu`░╚@♀+Σ
;                         dupe input
 "aeiou";╗                push vowels, store a copy in reg0
          @s              split one copy of input on vowels
            @`╜íu`░       take characters from other copy of input where
              ╜íu           the character is a vowel (1-based index of character in vowel string is non-zero)
                   ╚      shuffle the vowels
                    @♀+   interleave and concatenate pairs of strings
                       Σ  concatenate the strings

Bash, 75 octets

paste -d '' <(tr aeoiu \\n<<<$1) <(grep -o \[aeiou]<<<$1|shuf)|paste -sd ''

Prend la chaîne en argument et affiche le résultat sur stdout.

Par exemple

for x in "" "a" "cwm" \
         "the quick brown fox jumps over the lazy dog." \
         "abcdefghijklmnopqrstuvwxyz" \
         "programming puzzles & code golf" \
         "fatalize" "martin ender"; do
  echo "$x";. sheffle.sh "$x"; echo
done

empreintes

<blank line>
<blank line>

a
a

cwm
cwm

the quick brown fox jumps over the lazy dog.
tho quuck brown fix jamps ever the lozy dog.

abcdefghijklmnopqrstuvwxyz
ibcdefghajklmnopqrstuvwxyz

programming puzzles & code golf
progremmong pazzlus & cedo gilf

fatalize
fetilaza

martin ender
mertan endir

Bash, 89

Suppose que toutes les entrées sont en minuscules.

a=`tee z|grep -o [aeiou]`
[ -n "$a" ]&&tr `tr -d \ <<<$a` `shuf -e $a|tr -d '
'`<z||cat z

PowerShell v3 +, 155 99 octets

param([char[]]$n)$a=$n|?{$_-match'[aeiou]'}|sort{random};-join($n|%{if($_-in$a){$a[$i++]}else{$_}})

Gros accessoires à @ Ben Owen pour le golf de 56 octets

Prend les entrées $n, attend toutes les minuscules, les jette immédiatement comme un chartableau.

Nous tuyau dans une Where-Objectclause pour retirer les éléments qui -matchune voyelle, les conduit à Sort-Objectavec {Get-Random}le mécanisme de tri. Appeler Get-Randomsans qualificatifs renverra un entier compris entre 0et [int32]::MaxValue- c'est-à-dire, attribue des pondérations aléatoires à chaque élément à la volée. Nous stockons les voyelles aléatoires dans $a.

Enfin, nous passons en boucle $n. Pour chaque élément, |%{...}si le caractère actuel est quelque part -in $a, nous sortons l'élément suivant $a, en post-incrémentant $ipour la prochaine fois. Sinon, nous sortons le caractère actuel. Tout cela est encapsulé entre parenthèses et -joinédité ensemble dans une chaîne. Cette chaîne est laissée sur le pipeline et la sortie est implicite à la fin du programme.

Cas de test

PS C:\Tools\Scripts\golfing> 'a','cwm','the quick brown fox jumps over the lazy dog.','abcdefghijklmnopqrstuvwxyz','programming puzzles & code golf','fatalize','martin ender'|%{.\vawols.ps1 $_}
a
cwm
thu qaeck brown fix jomps ovor thu lezy deg.
abcdofghejklmnupqrstivwxyz
prugrammong pizzles & code golf
fitaleza
mertin endar

Python 3, 106 octets

Minuscule seulement.

import re,random
def f(s):s=re.split('([aeiou])',s);v=s[1::2];random.shuffle(v);s[1::2]=v;return''.join(s)

PHP> = 5.3 , 139 136 octets (et aucune erreur renvoyée)

array_map(function($a,$b){echo$a.$b;},preg_split("/[aeiou]/",$s=$argv[1]),str_split(str_shuffle(implode(preg_split("/[^aeiou]/",$s)))));

K (oK) , 29 octets

Solution:

{x[a:&x in"aeiou"]:x@(-#a)?a}

Essayez-le en ligne!

Exemples:

"pregrommeng pizzlas & codo gulf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregremmong puzzlos & coda gilf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregrommeng pazzlos & cidu golf"

Explication:

Trouvez les emplacements des voyelles et remplacez-les par les voyelles dessinées dans un ordre aléatoire.

{x[a:&x in"aeiou"]:x@(-#a)?a} / the solution
{                           } / anonymous function with input x
 x[              ]            / index into x at these indices
      x in"aeiou"             / is character a vowel
     &                        / indices where true
   a:                         / assign to add
                  :           / assign
                          ?a  / draw randomly from a
                     (   )    / do this together
                       #a     / count length of a
                      -       / negate (draws from list, no duplication)
                   x@         / apply these indices to input

APL (Dyalog Unicode) , 21 octets

{⍵[?⍨≢⍵]}@{⍵∊'AEIOU'}

Essayez-le en ligne!

Assume en majuscule.

Kotlin , 122 118 octets

x->val v=x.filter{"aeiuo".contains(it)}.toList().shuffled()
x.split(Regex("[aeiou]")).reduceIndexed{i,a,s->a+v[i-1]+s}

Essayez-le en ligne!