Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)
(PHP 4, PHP 5)
shuffle — Mischt die Elemente eines Arrays
Diese Funktion mischt die Reihenfolge der Elemente eines Arrays zufällig (shuffle).
Das zu modifizierende Array.
Gibt bei Erfolg TRUE zurück. Im Fehlerfall wird FALSE zurückgegeben.
Beispiel #1 shuffle() Beispiel
<?php
$numbers = range(1, 20);
srand((float)microtime() * 1000000);
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
?>
Hinweis: Diese Funktion weist den Elementen des Arrays array neue Schlüssel zu. Bestehende Schlüssel, die Sie eventuell zugewiesen haben, werden entfernt statt einfach nur die Schlüssel neu anzuordnen
Hinweis: Seit PHP 4.2.0 besteht keine Notwendigkeit mehr, den Zufallsgenerator für Zahlen mit srand() oder mt_srand() zu füttern, das geschieht nun automatisch.
Shuffle associative and non-associative array while preserving key, value pairs. Also returns the shuffled array instead of shuffling it in place.
<?php
function shuffle_assoc($list) {
if (!is_array($list)) return $list;
$keys = array_keys($list);
shuffle($keys);
$random = array();
foreach ($keys as $key)
$random[$key] = $list[$key];
return $random;
}
?>
This is a replica of shuffle() but preserving keys (associative and non-associative)
bool kshuffle ( array &$array )
<?php
function kshuffle(&$array) {
if(!is_array($array) || empty($array)) {
return false;
}
$tmp = array();
foreach($array as $key => $value) {
$tmp[] = array('k' => $key, 'v' => $value);
}
shuffle($tmp);
$array = array();
foreach($tmp as $entry) {
$array[$entry['k']] = $entry['v'];
}
return true;
}
$array = array('first' => 0, 'second' => 1, 'third' => 2);
kshuffle($array);
print_r($array); // [second] => 1 [first] => 0 [third] => 2
$array = array('first', 'second', 'third');
kshuffle($array);
print_r($array); // [1] => second [2] => third [0] => first
?>
This function shuffles an associative array recursive.
<?php
/**
* Shuffles an associative array recursive
* @author Mogria <m0gr14@gmail.com>
* @param array $array
* @return array
*
*/
function rec_assoc_shuffle($array)
{
$ary_keys = array_keys($array);
$ary_values = array_values($array);
shuffle($ary_values);
foreach($ary_keys as $key => $value) {
if (is_array($ary_values[$key]) AND $ary_values[$key] != NULL) {
$ary_values[$key] = rec_assoc_shuffle($ary_values[$key]);
}
$new[$value] = $ary_values[$key];
}
return $new;
}
?>
Example of use:
<?php
$array =
Array(
1,
Array(
1,
2,
3,
4,
Array(
1,
2,
3,
4,
5
)
),
2,
3,
Array(
0,
1,
Array(
1,
2,
3,
4,
Array(
1,
6,
5,
2,
1,
3
)
)
),
4,
5,
6,
7
);
$array = rec_assoc_shuffle($array);
echo '<pre>';
print_r($array);
echo '</pre>';
/*
Returns:
Array
(
[0] => 6
[1] => 5
[2] => Array
(
[0] => 1
[1] => 3
[2] => Array
(
[0] => 3
[1] => 1
[2] => 2
[3] => 4
[4] => 5
)
[3] => 2
[4] => 4
)
[3] => 3
[4] => Array
(
[0] => Array
(
[0] => 3
[1] => 1
[2] => 4
[3] => Array
(
[0] => 5
[1] => 1
[2] => 3
[3] => 6
[4] => 1
[5] => 2
)
[4] => 2
)
[1] => 1
[2] => 0
)
[5] => 2
[6] => 1
[7] => 4
[8] => 7
)
*/
?>
Many people in SEO need to supply an array and shuffle the results and need the same result each time that page is generated. This is my implementation with a working example:
<?php
function seoShuffle(&$items,$string) {
mt_srand(strlen($string));
for ($i = count($items) - 1; $i > 0; $i--){
$j = @mt_rand(0, $i);
$tmp = $items[$i];
$items[$i] = $items[$j];
$items[$j] = $tmp;
}
}
$items = array('one','two','three','four','five','six');
$string = 'whatever';
echo '<pre>';
print_r($items);
echo '</pre>';
seoShuffle($items,$string);
echo '<pre>';
print_r($items);
echo '</pre>';
?>
Here is a quick function I wrote that generates a random password and uses shuffle() to easily shuffle the order.
<?php
public function randPass($upper = 3, $lower = 3, $numeric = 3, $other = 2) {
//we need these vars to create a password string
$passOrder = Array();
$passWord = '';
//generate the contents of the password
for ($i = 0; $i < $upper; $i++) {
$passOrder[] = chr(rand(65, 90));
}
for ($i = 0; $i < $lower; $i++) {
$passOrder[] = chr(rand(97, 122));
}
for ($i = 0; $i < $numeric; $i++) {
$passOrder[] = chr(rand(48, 57));
}
for ($i = 0; $i < $other; $i++) {
$passOrder[] = chr(rand(33, 47));
}
//randomize the order of characters
shuffle($passOrder);
//concatenate into a string
foreach ($passOrder as $char) {
$passWord .= $char;
}
//we're done
return $passWord;
}
?>
shuffle for associative arrays, preserves key=>value pairs.
(Based on (Vladimir Kornea of typetango.com)'s function)
<?php
function shuffle_assoc(&$array) {
$keys = array_keys($array);
shuffle($keys);
foreach($keys as $key) {
$new[$key] = $array[$key];
}
$array = $new;
return true;
}
?>
*note: as of PHP 5.2.10, array_rand's resulting array of keys is no longer shuffled, so we use array_keys + shuffle.
I needed a simple function two shuffle a two dimensional array. Please note the second level arrays must be indexed using integers, for example $myarray[0]["Name"] and not $myarray["One"]["Name"]. Here is the function:
<?php
function twodshuffle($array)
{
// Get array length
$count = count($array);
// Create a range of indicies
$indi = range(0,$count-1);
// Randomize indicies array
shuffle($indi);
// Initialize new array
$newarray = array($count);
// Holds current index
$i = 0;
// Shuffle multidimensional array
foreach ($indi as $index)
{
$newarray[$i] = $array[$index];
$i++;
}
return $newarray;
}
?>
Please note it only works on two dimensional arrays. Here is an example:
<?php
$myarray = array("Google" => array("Name" => "Google", "URL" => "www.google.com", "Usage" => "Googling"), "Yahoo" => array("Name" => "Yahoo", "URL" => "www.yahoo.com", "Usage" => "Yahooing?"), "Ask" => array("Name" => "Ask", "URL" => "www.ask.com", "Usage" => "Asking Jeeves"));
print_r(twodshuffle($myarray));
/* And the result is:
Array ( [0] => Array ( [Name] => Ask [URL] => www.ask.com [Usage] => Asking Jeeves ) [1] => Array ( [Name] => Google [URL] => www.google.com [Usage] => Googling ) [2] => Array ( [Name] => Yahoo [URL] => www.yahoo.com [Usage] => Yahooing? ) )
*/
?>
Hope you find it useful!
I wrote these functions just for the heck of it, but I managed to get them to work even though I'm a PHP amateur. They're just two functions for a deck of 52 cards. newDeck() creates a deck and deal() creates hands for the deck.
<?php
// Two basic playing card functions
// newDeck([$numJokers]) - returns array of 52 cards plus (if supplied) $numJokers jokers
// deal($deck[, $numHands[, $numCards]]) - returns two compact()ed variables--the new $deck and $hand arrays
function newDeck($numJokers = 0)
{
// Returns $deck: array of 52 standard deck of 4-suit cards plus $numJokers jokers, shuffled (key starts at zero)
// in format of e.g. $deck[4] = "A ♠" = ace of spades (fifth card)
$suitCards = array("J", "Q", "K", "A");
$suitCards = array_merge($suitCards, range(2, 10));
$hearts = array();
$spades = array();
$diamonds = array();
$clubs = array();
foreach($suitCards as $card)
{
$hearts[] = "<span style=\"color: #FF0000;\">" . $card . " ♥" . "</span>";
$spades[] = "<span style=\"color: #000000;\">" . $card . " ♠" . "</span>";
$diamonds[] = "<span style=\"color: #FF0000;\">" . $card . " ♦" . "</span>";
$clubs[] = "<span style=\"color: #000000;\">" . $card . " ♣" . "</span>";
}
$jokers = array();
for($i = 0; $i < $numJokers; $i++)
$jokers[] = "<span style=\"color: #8467D7;\">JOKER</span>";
$deck = array_merge($hearts, $spades, $clubs, $diamonds, $jokers);
shuffle($deck);
return $deck;
}
function deal($deck, $numHands = 1, $numCards = 7)
{
// Returns $hand: two-dimensional array, first key being player ID and second being card number (both starting from zero)
// e.g. $hand[2][4] = "6 ♥" = six of hearts (third hand, fifth card)
// To return, use extract, e.g. extract(deal($deck, 2, 13)); (also returns $deck)
$hand = array();
for($i = 0; $i < $numHands; $i++)
{
for($j = 0; $j < $numCards; $j++)
{
$hand[$i][$j] = next($deck);
if($i == 0 && $j == 0)
$hand[0][0] = prev($deck);
}
}
$deck = array_splice($deck, ($numHands * $numCards));
return compact("hand", "deck");
}
$deck = newDeck();
extract(deal($deck, 3, 7));
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<!-- Just an example of test output to demonstrate capability. -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Basic Playing Card Functions</title>
</head>
<body>
<h1>Deck</h1>
<pre>
<?php
print_r($deck);
?>
</pre>
<hr />
<h1>Hands</h1>
<pre>
<?php
print_r($hand);
?>
</pre>
</body>
</html>
If you want to keep array shuffled in one particular way for every user visiting your site, you can use:
<?php
srand($user['id']);
shuffle($some_array);
?>
I've been wondering why shuffle() doesn't provide the shuffled array as a return value instead of a bool. I mean, what could possibly go wrong in shuffling elements from an array?
So I use something like this:
<?php
function array_shuffle($array) {
if (shuffle($array)) {
return $array;
} else {
return FALSE;
}
}
?>
Here i wrote a custom shuffle function which preserves the array index and distributes the array element randomly.
<?php
/*
* return an array whose elements are shuffled in random order.
*/
function custom_shuffle($my_array = array()) {
$copy = array();
while (count($my_array)) {
// takes a rand array elements by its key
$element = array_rand($my_array);
// assign the array and its value to an another array
$copy[$element] = $my_array[$element];
//delete the element from source array
unset($my_array[$element]);
}
return $copy;
}
$array = array(
'a' => 'apple',
'b' => 'ball',
'c' => 'cat',
'd' => 'dog',
'e' => 'egg',
'f' => 'fan',
'g' => 'gun'
);
print_r(custom_shuffle($array));
Array
(
[c] => cat
[e] => egg
[f] => fan
[a] => apple
[b] => ball
[g] => gun
[d] => dog
)
?>
Building on examples by m227 and pineappleclock, here is a function that returns all permutations of each set in the power set of an array of strings (instead of a string). Thanks for the great examples!
<?php
/*
Use: $arr = power_perms($in);
Example:
$in = array("A","B","C");
$power_perms = power_perms($in);
Returns:
Array
(
[0] => Array
(
[0] => A
[1] => B
[2] => C
)
[1] => Array
(
[0] => A
[1] => C
[2] => B
)
[2] => Array
(
[0] => B
[1] => A
[2] => C
)
[3] => Array
(
[0] => B
[1] => C
[2] => A
)
[4] => Array
(
[0] => C
[1] => A
[2] => B
)
[5] => Array
(
[0] => C
[1] => B
[2] => A
)
[6] => Array
(
[0] => A
[1] => B
)
[7] => Array
(
[0] => B
[1] => A
)
[8] => Array
(
[0] => B
[1] => C
)
[9] => Array
(
[0] => C
[1] => B
)
[10] => Array
(
[0] => A
[1] => C
)
[11] => Array
(
[0] => C
[1] => A
)
[12] => Array
(
[0] => A
)
[13] => Array
(
[0] => B
)
[14] => Array
(
[0] => C
)
)
*/
function power_perms($arr) {
$power_set = power_set($arr);
$result = array();
foreach($power_set as $set) {
$perms = perms($set);
$result = array_merge($result,$perms);
}
return $result;
}
function power_set($in,$minLength = 1) {
$count = count($in);
$members = pow(2,$count);
$return = array();
for ($i = 0; $i < $members; $i++) {
$b = sprintf("%0".$count."b",$i);
$out = array();
for ($j = 0; $j < $count; $j++) {
if ($b{$j} == '1') $out[] = $in[$j];
}
if (count($out) >= $minLength) {
$return[] = $out;
}
}
//usort($return,"cmp"); //can sort here by length
return $return;
}
function factorial($int){
if($int < 2) {
return 1;
}
for($f = 2; $int-1 > 1; $f *= $int--);
return $f;
}
function perm($arr, $nth = null) {
if ($nth === null) {
return perms($arr);
}
$result = array();
$length = count($arr);
while ($length--) {
$f = factorial($length);
$p = floor($nth / $f);
$result[] = $arr[$p];
array_delete_by_key($arr, $p);
$nth -= $p * $f;
}
$result = array_merge($result,$arr);
return $result;
}
function perms($arr) {
$p = array();
for ($i=0; $i < factorial(count($arr)); $i++) {
$p[] = perm($arr, $i);
}
return $p;
}
function array_delete_by_key(&$array, $delete_key, $use_old_keys = FALSE) {
unset($array[$delete_key]);
if(!$use_old_keys) {
$array = array_values($array);
}
return TRUE;
}
?>
To shuffle keeping the keys intact, I've used the following:
<?PHP
$shuff=array("a","b","c","d","e","f","g",
"h","i","j","k","l");
uasort( $shuff, 'scmp' );
print_r($shuff);
function scmp( $a, $b ) {
return rand(-1,1);
}
?>
Example output:
Array
(
[7] => h
[6] => g
[2] => c
[0] => a
[5] => f
[4] => e
[10] => k
[3] => d
[8] => i
[11] => l
[1] => b
[9] => j
)
Array
(
[6] => g
[0] => a
[2] => c
[10] => k
[8] => i
[5] => f
[1] => b
[4] => e
[9] => j
[3] => d
[7] => h
[11] => l
)
Works for me...
If you want the Power Set (set of all unique subsets) of an array instead of permutations, you can use this simple algorithm:
<?php
/**
* Returns the power set of a one dimensional array,
* a 2-D array.
* array(a,b,c) ->
* array(array(a),array(b),array(c),array(a,b),array(b,c),array(a,b,c))
*/
function powerSet($in,$minLength = 1) {
$count = count($in);
$members = pow(2,$count);
$return = array();
for ($i = 0; $i < $members; $i++) {
$b = sprintf("%0".$count."b",$i);
$out = array();
for ($j = 0; $j < $count; $j++) {
if ($b{$j} == '1') $out[] = $in[$j];
}
if (count($out) >= $minLength) {
$return[] = $out;
}
}
return $return;
}
?>
The following function, NKnext(), generates combinations sequentially. NKnext's output is a string of 0s and 1s where a "1" at position k represents the kth item being selected. For example, "1001000" represents the 0th and 3rd items being chosen from among 7. Feed NKnext() such a string to generate the next one in the sequence. Note that the sequence is a Gray Code where all adjacent element pairs (including the first and last) differ by a minimal amount (ie. a 0-1 swap), so that one could easily make it circular (Hamiltonian).
<?php
$n = 7;
$k = 3;
enumNK ($n, $k); // show all possibilities
function enumNK ($n, $k) {
// Iteratively generate all strings of $k "1"s and $n-$k "0"s
// so that adjacent strings have exactly one 0-1 swap.
// Final string is a BRR of the original (right barrel rotation)
print // print the initial string
$str = str_repeat("1", $k) . str_repeat("0", $n-$k);
while ($str= NKnext($str)) print "<br> $str"; }
function swap ($str, $pos1, $pos2) {
// Return $str with characters at $pos1 and $pos2 swapped
$chr = $str[$pos1];
$str[$pos1] = $str[$pos2];
$str[$pos2] = $chr;
return $str; }
function mod($num, $base) { // Mathematician's modulus
// compare with http://php.net/fmod
return ($num - $base*floor($num/$base)); }
function NKnext ($str, $pos=0, $dir=1) {
// Assumes there were initially $k=substr_count($str, "1") contiguous 1s
// starting at ($dir==1=>leftmost; $dir==1=>rightmost) position $pos
// to be barrel rotated in the direction $dir (1=>right, -1=>left)
// while going through all possibilities of [$n=strlen($str), $k]
// Returns the resultant next string in the iteration
// by finding the position of the next swap ($pos and $pos2)
NKswap ($str, $pos, $dir, substr_count ($str, "1"), strlen($str), $pos2);
if ($pos==$pos2) return ""; return swap($str, $pos, $pos2); }
function NKswap ($str, &$pos, $dir, $k, $n, &$pos2) {
// Under the assumptions for NKnext, returns the two
// positions ($pos, $pos2) that are to be swapped.
// $pos2 is set to $pos if $str is final (ie. no more swaps)
if (!$k || $k==$n) return $pos2 = $pos; // all 0s or all 1s
$ch1 = ($str[$pos]!="0"); // Is char of interest (fixed char) a "1"?
$sub = substr($str, 0, $pos) . substr($str, $pos + 1); // Rest of string
// Position of next char of interest
$np = mod($pos - ($dir==1) + $ch1 * $dir * ($k-1), $n-1);
NKswap($sub, $np, $ch1 ? -$dir : $dir, $k---$ch1, $n-1, $pos2);
if ($np==$pos2) // If substring is done
return ($pos2 = mod($pos + $ch1 * $dir * ($k - !$k), $n));
if ($pos2>=$pos) ++$pos2; // Adjustment for 'char of interest' posn
$pos = $np + ($np>=$pos); } // Return the "normal" swap position
?>
BR = Barrel rotation
BRR/BRL = Barrel rotation to the right/left by 1
The basic algorithm is recursive, with a fixed "1" position identified ($pos=0, below), all sub-possibilities are iterated, then it is replaced with a 0, and then all those sub-possibilities are iterated.
[5, 3] example with leftmost 1 fixed: 11100 -> 10101 -> 10110 -> 11010 -> 10011 -> 11001
[5, 3] continued with leftmost char swap: 11001 -> 01101
[5, 3] continued with leftmost 0 fixed: 01101 -> 00111 -> 01011 -> 01110
When $dir is 1 in the above functions, it represents a net BRR, and $pos represents the starting position of the leftmost 1.
When $dir is -1 in the above functions, it represents a net BRL, and $pos represents the starting position of the rightmost 1.
$pos is essentially used to determine when all the swaps are done. For example, in rotating 1110 (with $dir=1 and $pos=0) we go through the following: 1101 (and not 0111!), 1011, 0111
Happy New Year,
Csaba Gabor from Vienna
Here is IMO the simplest and extremely fast way to shuffle an associative array AND keep the key=>value relationship. However, it ONLY works if there are NO NUMERIC keys AT ALL. Look into array_merge for the reason why.
<?php
$unshuffled = array('one'=>1,'two'=>2,'three'=>3);
$shuffled = array_merge( array_flip(array_rand($unshuffled,count($unshuffled))),$unshuffled );
?>
peace
Another shuffle() implementation that preserves keys, does not use extra memory and perhaps is a bit easier to grasp.
<?php
if (function_exists('shuffle_with_keys')===false) {
function shuffle_with_keys(&$array) {
/* Auxiliary array to hold the new order */
$aux = array();
/* We work with an array of the keys */
$keys = array_keys($array);
/* We shuffle the keys */
shuffle($keys);
/* We iterate thru' the new order of the keys */
foreach($keys as $key) {
/* We insert the key, value pair in its new order */
$aux[$key] = $array[$key];
/* We remove the element from the old array to save memory */
unset($array[$key]);
}
/* The auxiliary array with the new order overwrites the old variable */
$array = $aux;
}
}
?>
Function that does the same as shuffle(), but preserves key=>values.
(Based on (Vladimir Kornea of typetango.com)'s function)
<?php
function shuffle_assoc(&$array) {
if (count($array)>1) { //$keys needs to be an array, no need to shuffle 1 item anyway
$keys = array_rand($array, count($array));
foreach($keys as $key)
$new[$key] = $array[$key];
$array = $new;
}
return true; //because it's a wannabe shuffle(), which returns true
}
$test = array(1=>'one','two'=>'2',3=>'3');
print_r($test);
shuffle_assoc($test);
print_r($test);
?>
Array
(
[1] => one
[two] => 2
[3] => 3
)
Array
(
[two] => 2
[1] => one
[3] => 3
)
Very fast way to shuffle associative array and keep key=>value
<?php
$tmp=array("one"=>1,"two"=>2,"three"=>3,"four"=>4);
$new=array();
$c=count($tmp);
$k=array_keys($tmp);
$v=array_values($tmp);
while($c>0) {
$i=array_rand($k);
$new[$k[$i]]=$v[$i];
unset($k[$i]); #exlude selected number from list
$c--;
}
print_r($tmp);
print_r($new);
?>
Result:
Array
(
[one] => 1
[two] => 2
[three] => 3
[four] => 4
)
Array
(
[two] => 2
[three] => 3
[four] => 4
[one] => 1
)
And thats all, folks!
my approach to bring some chaos to associative arrays
<?php
define ("SHUFFLEBOTH", 0);
define ("SHUFFLEVALUES", 1);
define ("SHUFFLEKEYS", 2);
function shuffle_assoc(&$array, $mode=SHUFFLEBOTH) {
$keys = array_keys($array);
$values = array_values($array);
if (($mode==SHUFFLEBOTH) || ($mode==SHUFFLEVALUES)) shuffle($values);
if (($mode==SHUFFLEBOTH) || ($mode==SHUFFLEKEYS)) shuffle($keys);
$array = array_combine($keys, $values);
}
?>
Permutation using recursion
<?php
function perm($n)
{
if($n <= 1) return 1;
else return $n * perm($n-1);
}
?>
Usage example:
<?php $result = perm(8); ?>
$result will be 40320
here come my three pennies about permutations. I did function below to work with word anagrams, it works flawlessly, however may be seen as a slow one.
<?php
/** (c) on LGPL license 2006.10 michal@glebowski.pl */
function fact($int){
if($int<2)return 1;
for($f=2;$int-1>1;$f*=$int--);
return $f;
}
/** @return string string $s with $n-th character cut */
function del($s, $n) {
return substr($s, 0, $n).substr($s, $n+1);
}
/**
* @param $s string word to permute
* @param $n int n-th permutation
* @return string n-th permutation (out of strlen(string)!)
*/
function perm($s, $n = null) {
if ($n === null) return perms($s);
$r = '';
$l = strlen($s);
while ($l--) {
$f = fact($l);
$p = floor($n/$f);
$r.= $s{$p};
$s = del($s, $p);
$n-= $p*$f;
}
$r.=$s;
return $r;
}
/** @return array array of all permutations */
function perms($s) {
$p = array();
for ($i=0;$i<fact(strlen($s));$i++) $p[] = perm($s, $i);
return $p;
}
?>
Posted below is code that you would expect to work
<?php
$keys = shuffle(array_keys($arr));
foreach ($keys as $key) {
$arr_elem = $arr[$key];
// do what you want with the array element
}
?>
This in fact does not work because shuffle returns a boolean true or false. More accurate code using this method would be:
<?php
$keys = array_keys($arr);
shuffle($keys);
foreach ($keys as $key) {
$arr_elem = $arr[$key];
// do what you want with the array element
}
?>
This is taken from an O'Reilly Book and modified slightly to return all possible permutations of a 1D array:
<?php
# Modified from http://linuxalpha1.eicn.ch/OReilly_books/books/webprog/pcook/ch04_26.htm
# Takes a non-associatuve 1D (vector) array of items
# and returns an array of arrays with each possible permutation
function array_2D_permute($items, $perms = array( )) {
static $permuted_array;
if (empty($items)) {
$permuted_array[]=$perms;
#print_r($new);
#print join(' ', $perms) . "\n";
} else {
for ($i = count($items) - 1; $i >= 0; --$i) {
$newitems = $items;
$newperms = $perms;
list($foo) = array_splice($newitems, $i, 1);
array_unshift($newperms, $foo);
array_2D_permute($newitems, $newperms);
}
return $permuted_array;
}
}
$arr=array("Architecture","Mexico","Periodicals","Test");
$result=array_2D_permute($arr);
print_r($result);
?>
Just a quick note to let people know that shuffle() will work on multidimensional associative arrays provided that the first key is already numeric.
So this array can be shuffled without losing any of the secondary keys or their values:
$array[0]['color'], $array[0]['size'], $array[0]['fabric']
. . .
$array[50]['color'], $array[50]['size'], $array[50]['fabric']
I recently ran up against needing to randomize this array and tried shuffle even though it's not really for associative arrays.
Hope it helps somebody out there.
Here's a pretty little function to shuffle an associative array, taking a bit different approach from the earlier entries.
<?PHP
function ass_array_shuffle ($array) {
while (count($array) > 0) {
$val = array_rand($array);
$new_arr[$val] = $array[$val];
unset($array[$val]);
}
return $new_arr;
}
?>
In the function above, the original array is randomly scavenged upon until nothing is left of it. This removes the need for any temporary variables, or indeed for any superfluous tossing around of stuff.
note that in PHP 5.0.4 (and assumably earlier versions as well), shuffle internally calls rand(), not mt_rand().
This was important because I was trying to use a fixed seed to get repeatable results, by calling mt_srand(). But of course that doesn't work, since shuffle uses rand() not mt_rand(). The solution is either to use srand() for seeding, or to write your own version of shuffle() using mt_rand(). (See examples which others have contributed; or, just have a look at ext/standard/array.c) mt_rand on many platforms gives better results than the builtin library anyway...
N.B. Obviously, the way the shuffle function is implemented may change without notice in future versions, including e.g. changing to use mt_rand instead.
[EDIT by danbrown AT php DOT net: As pointed out on 25 July, 2008, by "Anonymous", this implementation may have some errors or inconsistencies that may cause this function not to achieve the desired result. "Anonymous" provided the following link for more information: http://en.wikipedia.org/wiki/Fisher-Yates_shuffle]
This is an attempt to get the Fisher Yates shuffle right, and as optimized as possible. The array items are stepped through from last to first, each being swapped with another between itself and the beginning of the array (N-1 shuffles required.) Using list() to swap array vars instead of a tmp var proved to be slightly slower. Testing for $i = $j decreases performance as the array size increases, so it was left out (elements are always swapped.)
<?php
function fisherYatesShuffle(&$items)
{
for ($i = count($items) - 1; $i > 0; $i--)
{
$j = @mt_rand(0, $i);
$tmp = $items[$i];
$items[$i] = $items[$j];
$items[$j] = $tmp;
}
}
?>
To shuffle an associated array and remain the association between keys and values, use this function:
<?php
$test_array = array("first" => 1,"second" => 2,"third" => 3,"fourth" => 4);
function shuffle_assoc($input_array){
foreach($input_array as $key => $value){
$temp_array[$value][key] = $key;
}
shuffle($input_array);
foreach($input_array as $key => $value){
$return_array[$temp_array[$value][key]] = $value;
}
return $return_array;
}
echo "<pre>";
print_r(shuffle_assoc($test_array));
echo "</pre><hr />";
// this will output something like this:
/*
Array
(
[fourth] => 4
[second] => 2
[third] => 3
[first] => 1
)
*/
?>
This code is very appealing in its simplicity and speed, but it's not a random shuffle:
<?php
function randomcmp($a, $b)
{
return mt_rand(-1, 1);
}
function swapshuffle(&$array)
{
srand((double) microtime() * 10000000);
uksort($array, "randomcmp");
}
?>
This is because uksort calls the C function zend_qsort and this quicksorts the array using the provided comparision function. The pairs of indices selected are biased by the nature of the quicksort algorithm.
One effect is that an element in the middle of the array is heavily biased toward being "shuffled" to the middle. Elements on the edges are biased towards the edges; they're likely to switch edges, but unlikely to end up in the middle.
Be aware that when shuffling an associative array your associative keys will be lost! example below:
<?php
echo "before shuffle\n";
$numbers = array('first'=>1,'second'=>2,'third'=>3,'fourth'=>4);
foreach($numbers as $key=>$value){
echo "$key => $value\n";
}
echo "\nafter shuffle\n";
srand((float)microtime() * 1000000);
shuffle($numbers);
foreach($numbers as $key=>$value){
echo "$key => $value\n";
}
?>
--output--
before shuffle
first => 1
second => 2
third => 3
fourth => 4
after shuffle
0 => 4
1 => 1
2 => 3
3 => 2
Diese Seite bei php.net