function melangeage ($array, $facteur)
{
 $nbarray = count($array);
 $nbmelanges = floor($nbarray * $facteur);
 for($curseur = 0; $curseur<$nbmelanges;$curseur++)
 {
  $rand_keys = array_rand ($input, 2);
  $ar1 = $array[$rand_keys[0]];
  $ar2 = $array[$rand_keys[2]];
  $array[$rand_keys[0]] = $ar2;
  $array[$rand_keys[2]] = $ar1;
 }
 return ($array);
}

Re,
Oué j'ai refais des tests (avec un tableau à 72 enregistrements), shuffle n'a pas l'air trop mal, le seul avantage que j'avais avec ma fonction c'est que je pouvais spécifier les nombre de permutations en fonction de la longueur du tableau...
Sinon je vais utiliser le array_rand() dans ma fonction faite maison (que je vais garder dans un coin au cas ou...) ça devrait l'alléger encore un peu...
Bon je suppose qu'on a fini et que je peux mettre résolu non?
Merci à tous!

PS voici la dernière version de ma fonction mélangeage pour ceux que ca intéresse
[php]
function melangeage ($array, $facteur)
{
$nbarray = count($array);
$nbmelanges = floor($nbarray * $facteur);
for($curseur = 0; $curseur<$nbmelanges;$curseur++)
{
$rand_keys = array_rand ($input, 2);
$ar1 = $array[$rand_keys[0]];
$ar2 = $array[$rand_keys[2]];
$array[$rand_keys[0]] = $ar2;
$array[$rand_keys[2]] = $ar1;
}
return ($array);
}
[/php]

sinon, avec un autre approche, plutot que de mélanger le tableau, il y a aussi array_rand() qui retourne une clé au hasard d'un tableau.

$hash = array();

$arr = range(1, 12);

$i = 0;
do
{
	++$i;
	shuffle($arr);
	$str = implode(',', $arr);

	if (isset($hash[$str]))
	{
		die("$i iterations");
	}

	$hash[$str] = 1;
}
while (1);

Pour moi, shuffle() semble faire son boulot parfaitement. Tu peux toujours essayer ce script pour vérifier qu'il ne s'agit pas de ton ordinateur, mais je pense que tu es tombé sur une coïncidence, ou tu t'es simplement fait des idées.

[php]$hash = array();

$arr = range(1, 12);

$i = 0;
do
{
++$i;
shuffle($arr);
$str = implode(',', $arr);

if (isset($hash[$str]))
{
die("$i iterations");
}

$hash[$str] = 1;
}
while (1);[/php]
On crée un tableau avec 12 éléments, on shuffle(), on enregistre l'ordre des éléments à chaque itération et on s'arrête au premier doublon. Sur mon ordi ça demande quelques (dizaines de) milliers de permutations pour avoir une seule combinaison en double. Je n'ai pas essayé avec plus d'éléments parce que mon php.ini est limité à 10 MiB et le tableau devient rapidement monstrueux. Si le cœur t'en dit, essaie avec 20 et va te faire un café pendant que ça tourne, je pense que tu auras le temps de moudre les grains :lol:

Re,
J'ai fait un test préliminaire (avant d'avoir fini le script sur lequel je bossais) avec ma fonction maison et shuffle, il se trouve que shuffle mélange beaucoup moins bien que ma fonction maison et cette dernière ne prend pas plus de temps d'éxécution...
Quelqu'un a t il quelque chose de mieux que shuffle?
Merci à tous!

Re,
le 19 sort des ... qui signifiaient une centaine d'exemples que je n'allais pas écrire :wink:
Sinon dans le cas ou le rand serait le même, ma fonciton va fair eun truc un peu inutile mais elle ne va pas écraser les données, elle va sauvegarder les données du tableau en rand, sauvegarder celles du rand2 (les mêmes donc), remplacer les données du tableau en rand par celles du rand2 (remettre les mêmes en définitive) et remplacer les données du tableau en rand2 par celles en rand (donc encore remettre les mêmes)
Au final de toutes ces manipulations inutiles les données n'auront pas bougées normalement, mais dites moi si je me trompe...
Sinon je fini de coder la fonction qui a besoin de ce mélangeage et je teste avec shuffle...
Merci à tous!

Ben si tu prends le chapître sur les tableaux et que tu lis la définition de toutes les fonctions tu devrais tomber sur shuffle() qui correspond plus ou moins à ce que tu cherches.

Si ça ne correspond pas exactement, merci de préciser en quoi la fonction diffère (et comment, par exemple, tu trouves le "19" de ton exemple).

Attention à ta fonction maison, je ne l'ai pas détaillée mais il semblerait qu'elle perde des données en les écrasant si $rand et $rand2 sont identiques.

<?php
//le facteur pour plus ou moins de mélangeage...
function melangeage ($array, $nbarray, $facteur)
{
$nbmelanges = floor($nbarray * $facteur);
for($curseur = 0; $curseur<$nbmelanges;$curseur++)
{
 $rand = rand(0, $nbarray);
 $rand2 = rand(0, $nbarray);
 $ar1 = $array[$rand];
 $ar2 = $array[$rand2];
 $array[$rand] = $ar2;
 $array[$rand2] = $ar1;
}
return ($array);
}
?>

Bonjour à tous,
Pour les besoins de la cause beaucoup d'entre nous ont besoin de trier leurs tableaux, et bien que cela parraisse pardoxal moi j'ai besoin de mélanger mes tableaux (normal hein?^^)
alors voila mes tableaux se présentent comme ceci
$array[1] = un autre tableau A
$array[2] = un autre tableau B
$array[3] = un autre tableau C
...

Et moi pour notre mélangeage (si si c'est comme bravitude :wink: ) j'aurai besoin par exemple que la valeur de $array[3] (le tableau C) passe en $array[1], que le tableau A passe en $array[2] et que le B passe en $array[19] par exemple, le tout complétement au hasard.
Je pourrais le faire via une fonction un peu simple, mais avant de réinventer la roue je me demandais si les gens de chez php ne nous avaient pas fourni cette dernière...
Voila merci à tous de votre aide!
A+ et bon surf!!!!

PS La fonction de mélangeage faite maison
[php]
<?php
//le facteur pour plus ou moins de mélangeage...
function melangeage ($array, $nbarray, $facteur)
{
$nbmelanges = floor($nbarray * $facteur);
for($curseur = 0; $curseur<$nbmelanges;$curseur++)
{
$rand = rand(0, $nbarray);
$rand2 = rand(0, $nbarray);
$ar1 = $array[$rand];
$ar2 = $array[$rand2];
$array[$rand] = $ar2;
$array[$rand2] = $ar1;
}
return ($array);
}
?>
[/php]