I have 6 users and I want to shuffle an array for each user but with a particular logic.
I have array like this:
$a = array(1, 6, 8);
When shuffled it gives me these results:
shuffle($a); //array(8,6,1) or array(8,1,6) or ...
I want to shuffle the array for a specific user and have it be the same every time for that user:
for user that has id equals 1, give array like this array(6,8,1) every time
for user that has id equals 2, give array like this array(1,8,6) every time
In other words, I want to shuffle an array with private key!
If you provide a seed to the random number generator it will randomize the same way for the same seed (see the version differences below). So use the user id as the seed:
srand(1);
shuffle($a);
Output for 7.1.0 - 7.2.4
Array
(
[0] => 1
[1] => 8
[2] => 6
)
Output for 4.3.0 - 5.6.30, 7.0.0 - 7.0.29
Array
(
[0] => 6
[1] => 1
[2] => 8
)
Note: As of PHP 7.1.0, srand() has been made an alias of mt_srand().
This Example should always produce the same result.
Quoting php.net:
This function shuffles (randomizes the order of the elements in) an array. It uses a pseudo random number generator that is not suitable for cryptographic purposes.
Whatever you are trying to get as a result, you cannot use shuffle because it will randomly give you some order.
If you want to randomly do an order to array, based on some criteria use usort:
function cmp($a, $b)
{
if ($a == $b) {
return 0;
}
return ($a < $b) ? -1 : 1;
}
$a = array(3, 2, 5, 6, 1);
usort($a, "cmp");
Now get the logic in the cmp function...
Related
There seems to be an undocumented change to how PHP 7 handles equal results in usort functions.
$myArray = array(1, 2, 3);
usort($myArray, function($a, $b) { return 0; });
print_r($myArray);
// PHP 5:
Array
(
[0] => 3
[1] => 2
[2] => 1
)
// PHP 7
Array
(
[0] => 1
[1] => 2
[2] => 3
)
In other words in PHP 7, usort is adding equal values to the end of the array, whereas PHP 5 adds them to the beginning. I can't find any mention of this behaviour.
Is there a way of forcing the PHP 5 behaviour?
From the PHP docs:
If two members compare as equal, their relative order in the sorted array is undefined.
Relying on undefined behavior is a bad idea. There is no way to change the behavior (apart from making the items not equal).
I am trying to sort an array by the length of characters in each value (and perhaps, if possible, in alphabetical order if two values have the same length of characters). For example:
Array ( [0] => this [1] => is [2] => a [3] => bunch [4] => of [5] => words;
I am trying to sort this array to look like:
Array ( [0] => a [1] => is [2] => of [3] => this [4] => bunch [5] => words;
How?
This should do it:
array_multisort(array_map('strlen', $array), $array);
Get the length of each string in an array by mapping strlen() using array_map()
Sort on the string lengths and sort the original array by the string length sorted array using array_multisort()
Looks like others have already answered but I started writing this so I'm going to post it, dang it! :)
You could take a look at usort
$data = ["this", "is", "a", "bunch", "of", "words"];
usort($data, function($a, $b) {
$difference = strlen($a) - strlen($b);
return $difference ?: strcmp($a, $b);
});
I'm using the Elvis operator ?: to just return the difference based on the string lengths if it's not 0. If it is 0, just return the return value of strcmp
You can use a custom sort function for this.
function mycmp($a, $b) {
$cmp = strlen($a) - strlen($b);
if ($cmp === 0)
$cmp = strcmp($a, $b);
return $cmp;
}
usort($array, 'mycmp');
See this:
$myarray = explode(" ", "this is a bunch of words");
usort($myarray, function($a, $b) { return strlen($a) - strlen($b) });
print_r($array);
Explanation: usort sorts in place (i.e. by reference) an array, given a custom comparator. A comparator must return a negative number if the first item should be before the second item, and a positive otherwise. A value of 0 means they are equal regarding the order.
You can add custom criteria, not related to strlen() when the lengths are the same. That's up to you and involves just an additional if block.
It is important to note that the function must define an order relationship, as in math:
criteria(a, b)>0 and criteria(b, c)>0 implies criteria(a, c)>0.
the same applies to the lower-than sign, lower-than-or-equal, greater-than-or-equal, and equal.
criteria(a, b) should have an opposite sign of criteria(b, a).
Another method:
$f = fn($s1, $s2) => strlen($s1) <=> strlen($s2);
usort($a, $f);
https://php.net/language.operators.comparison
I want to compare every element of array with one another.
$char=array();
for($i=0;$i<=10;$i++)
{
$char[$i]=rand(0,35);
}
I want to compare every element of $char array. If there is any value repeated than it should change value and select another random value which should be unique in array..
In this particular example, where the range of possible values is very small, it would be better to do this another way:
$allPossible = range(0, 35);
shuffle($allPossible);
// Guaranteed exactly 10 unique numbers in the range [0, 35]
$char = array_slice($allPossible, 0, 10);
Or with the equivalent version using array_rand:
$allPossible = range(0, 35);
$char = array_rand(array_flip($allPossible), 10);
If the range of values were larger then this approach would be very wasteful and you should go with checking for uniqueness on each iteration:
$char = array();
for ($i = 0; $i < 10; ++$i) {
$value = null;
// Try random numbers until you find one that does not already exist
while($value === null || in_array($value, $char)) {
$value = rand(0, 35);
}
$char[] = $value;
}
However, this is a probabilistic approach and may take a lot of time to finish depending on what the output of rand happens to be (it's going to be especially bad if the number of values you want is close to the number of all possible values).
Additionally, if the number of values you want to pick is largish (let's say more than 50 or so) then in_array can prove to be a bottleneck. In that case it should be faster to use array keys to check for uniqueness instead of values, since searching for the existence of a key is constant time instead of linear:
$char = array();
for ($i = 0; $i < 100; ++$i) {
$value = null;
// Try random numbers until you find one that does not already exist
while($value === null || array_key_exists($char, $value)) {
$value = rand(0, 1000);
}
$char[$value] = $value;
}
$char = array_values($char); // reindex keys to start from 0
To change any repeated value for a random one, you should loop through the array twice:
$cont= 0;
foreach($char as $c){
foreach($char as $d){
if($c == $d){
//updating the value
$char[$cont] = rand(0,35);
}
}
$cont++;
}
But what I don't know is if the random value can also be repeated. In that case it would not be so simple.
I've taken this code from the PHP Manual page for rand()
<?php
function uniqueRand($n, $min = 0, $max = null)
{
if($max === null)
$max = getrandmax();
$array = range($min, $max);
$return = array();
$keys = array_rand($array, $n);
foreach($keys as $key)
$return[] = $array[$key];
return $return;
}
?>
This function generates an array which has a size of $n and you can set the min and max values like in rand.
So you could make use of it like
uniqueRand(10, 0, 35);
Use array_count_values() first on the $char array.
Afterwards you can just loop all entries with more than 1 and randomize them. You have to keep checking until all counts are 1 tho. As even the random might remake a duplicate again.
I sugggest two option to make random array:
<?php
$questions = array(1, 2, 3, 4, 5, ..., 34, 35);
$questions = shuffle($questions);
?>
after that you choose the top 10 elements.
you can try this code to replace any repeated value.
for ($i = 0; $i < count($char); $i++) {
for ($n = 0; $n < count($char); $n++) {
if($char[$i] == $char[$n]){
$char[$i] = rand(0,35);
}
}
}
The function array_unique() obtains all unique values from an array, keyed by their first occurrence.
The function array_diff() allows to remove values from one array that are inside another array.
Depending on how you need to have (or not have) the result keyed or the order of keys preserved you need to do multiple steps. Generally it works as I outline in the following paragraphs (with PHP code-examples):
In an array you've got N elements of which Nu are unique.
$N = array(...);
$Nu = array_unique($N);
The number of random elements r you need then to replace the duplicates are the count of N minus the count of Nu. As the count of N is generally a useful value, I also assign it to nc:
$nc = count($N);
$r = $nc - count($Nu);
That makes r an integer ranging from 0 to count(N) - 1:
0 : no duplicate values / all values are unique
1 : one duplicate value / all but one value are unique
...
count(N) - 1 : all duplicate values / no unique value
So in case you you need zero random values ($r === 0) the input $N is the result. This boundary condition is the second most simple result (the first simple result is an input array with no members).
For all other cases you need r random unique values. In your question you write from 0 to 35. However this can not be the full story. Imagine your input array has got 36 duplicated values, each number in the range from 0 to 35 is duplicated once. Adding random numbers from the range 0 to 35 again to the array would create duplicates again - guaranteed.
Instead I've read your question that you are just looking for unique values that are not yet part of the input array.
So you not only you need r random values (Nr), but they also must not be part of N or Nu so far.
To achieve that you only need to create count(N) unique values, remove the unique values Nu from these to ensure nothing duplicates values in Nu. As this the theoretical maximum and not the exact number needed, that array is used to obtain the slice of exactly r elements from:
$Nr = array_slice(array_diff(range(0, $nc - 1), $Nu), 0, $r);
If you also want to have these new values to be added shuffled as range(0, $nc - 1) is ordered, you can do the following:
shuffle($Nr);
That should bring the randomness you seem to ask for in your question back into the answer.
That now leaves you with the unique parts of the original array $Nu and r new values in $Nr. Merging both these arrays will give you a result array which ignores key => value relations (the array is re-index):
array_merge($Nu, $Nr);
For example with an exemplary array(3, 4, 2, 1, 4, 0, 5, 0, 3, 5) for $N, the result this gives is:
Array
(
[0] => 3
[1] => 4
[2] => 2
[3] => 1
[4] => 0
[5] => 5
[6] => 7
[7] => 9
[8] => 6
[9] => 8
)
As you can see all the unique values (0-5) are at the beginning followed by the new values (6-9). Original keys are not preserved, e.g. the key of value 5 was 6 originally, now it is 5.
The relation or key => value are not retained because of array_merge(), it does re-index number keys. Also next to unique numbers in Nr keys also need to be unique in an array. So for every new number that is added to the unqique existing numbers, a key needs to be used that was a key of a duplicate number. To obtain all keys of duplicate numbers the set of keys in the original array is reduced by the set of keys of all for matches of the duplicate numbers (keys in the "unique array" $Nu):
$Kr = array_keys(array_diff_assoc($N, $Nu));
The existing result $Nr can now be keyed with with these keys. A function in PHP to set all keys for an array is to use the function array_combine():
$Nr = array_combine($Kr, $Nr);
This allows to obtain the result with key => value relations preserved by using the array union operator (+):
$Nu + $Nr;
For example with the $N from the last example, the result this gives is:
Array
(
[0] => 3
[1] => 4
[2] => 2
[3] => 1
[5] => 0
[6] => 5
[4] => 8
[7] => 6
[8] => 9
[9] => 7
)
As you can now see for the value 5 it's key 6 has been preserved as well as for the value 0 which had the key 5 in the original array and now as well in the output instead of the key 4 as in the previous example.
However as now the keys have been preserved for the first occurrences of the original values, the order is still changed: First all previously unique values and then all new values. However you might want to add the new values in place. To do that, you need to obtain the order of the original keys for the new values. That can be done by mapping the order by key and the using array_multisort() to sort based on that order.
Because this requires passing return values via parameters, this requires additional, temporary variables which I've chosen to introduce starting with the letter V:
// the original array defines the order of keys:
$orderMap = array_flip(array_keys($N));
// define the sort order for the result with keys preserved
$Vt = $Nu + $Nr;
$order = array();
foreach ($Vt as $key => $value) {
$order[] = $orderMap[$key];
}
Then the sorting is done (here with preserving keys):
// sort an array by the defined order, preserve keys
$Vk = array_keys($Vt);
array_multisort($order, $Vt, $Vk);
The result then is:
array_combine($Vk, $Vt);
Again with the example values from above:
Array
(
[0] => 3
[1] => 4
[2] => 2
[3] => 1
[4] => 7
[5] => 0
[6] => 5
[7] => 8
[8] => 6
[9] => 9
)
This example output shows nicely that the keys are ordered from 0 to 9 as they were are well in the input array. Compared with the previous output you can for example see that the first added value 7 (keyed 4) is at the 5th position - same as the value keyed 4 in the original array. The order of the keys have been obtained as well.
If that is the result you strive for you can short-cut the path to this step as well by iterating the original arrays keys and in case each of those keys is not the first value of any duplicate value, you can pop from the new values array instead:
$result = array();
foreach ($N as $key => $value) {
$result[$key] = array_key_exists($key, $Nu) ? $Nu[$key] : array_pop($Nr);
}
Again with the example array values the result (varies from previous because $Nr is shuffled:
Array
(
[0] => 3
[1] => 4
[2] => 2
[3] => 1
[4] => 7
[5] => 0
[6] => 5
[7] => 8
[8] => 9
[9] => 6
)
Which in the end might be the simplest way to answer your question. Hope this helps you answering the question. Keep the following in mind:
divide your problem:
you want to know if a value is unqiue or not - array_unique() helps you here.
you want to create X new unique numbers/values. array_diff() helps you here.
align the flow:
obtain unique numbers first.
obtain new numbers first.
use both to process the original array.
Like in this example:
// original array
$array = array(3, 4, 2, 1, 4, 0, 5, 0, 3, 5);
// obtain unique values (1.)
$unique = array_unique($array);
// obtain new unique values (2.)
$new = range(0, count($array) - 1);
$new = array_diff($new, $unique);
shuffle($new);
// process original array (3.)
foreach ($array as $key => &$value) {
if (array_key_exists($key, $unique)) {
continue;
}
$value = array_pop($new);
}
unset($value, $new);
// result in $array:
print_r($array);
Which then (exemplary because of shuffle($new)) outputs:
Array
(
[0] => 3
[1] => 4
[2] => 2
[3] => 1
[4] => 9
[5] => 0
[6] => 5
[7] => 8
[8] => 7
[9] => 6
)
I have a key => value array:
a => 2
c => 1
b => 3
I tried this:
ksort($result);
arsort($result);
But it doesn't work. I'm trying to sort by key alphabetically a-z and then sort it by value ascending 0-infinity.
so I should get
c => 1
a => 2
b => 3
But those sorts didn't give me what I wanted.
Try using asort() instead of arsort(). arsort() will sort the array in reverse order. Something like this should "work":
$test = array(
'a' => 0,
'b' => 1,
'c' => 2
);
ksort($test);
asort($test);
Mario is correct that this won't work if multiple items contain the same value. Alternatively, you could use uksort() which allows you to define exactly how the array is sorted. For example you could sort two items using their values by default. But if the values are the same sort by their keys.
$test = array(
'a' => 2,
'd' => 1,
'c' => 1,
'b' => 3
);
function cmp($a, $b){
global $test;
$val_a = $test[$a];
$val_b = $test[$b];
if($val_a == $val_b){
return ($a < $b) ? -1 : 1;
}
return ($val_a < $val_b) ? -1 : 1;
}
uksort($test, 'cmp');
I get unexpected results because sorting values that have the same value is unstable.
So what you forgot to mention in your question is that values can occur twice, and you want arrays sorted by values and keys secondarily.
c => 1
a => 2
z => 2
b => 3
There's no function for that in PHP. You could however try to sort by keys first ksort(), and then apply a user-defined function for sorting by value uasort(). In the callback it's important to also implement the $a == $b check and return 0. So the previous key-ordering might not be accidentally altered by +1 or -1 comparison states. (Don't know if that actually works.)
Otherwise you'll have to implement the whole sorting algorithm yourself, possibly separating keys and values in distinct maps.
This is a really esoteric question, but I'm genuinely curious. I'm using usort for the first time today in years, and I'm particularly interested in what exactly is going on. Suppose I've got the following array:
$myArray = array(1, 9, 18, 12, 56);
I could sort this with usort:
usort($myArray, function($a, $b){
if ($a == $b) return 0;
return ($a < $b) ? -1 : 1;
});
I'm not 100% clear about what is going on with the two parameters $a and $b. What are they, and what do they represent. I mean, I could assume that $a represents the current item in the array, but what exactly is this getting compared to? What is $b?
I could increase my array to include strings:
$myArray = array(
array("Apples", 10),
array("Oranges", 12),
array("Strawberries", 3)
);
And run the following:
usort($myArray, function($a, $b){
return strcmp($a[0], $b[0]);
});
And that would sort my child-arrays alphabetically based upon the [0] index value. But this doesn't offer any clarity about what $a and $b are. I only know that the match the pattern that I'm seeking.
Can somebody offer some clarity about what is actually taking place?
The exact definition of $a and $b will depend upon the algorithm used to sort the array. To sort anything you have to have a means to compare two elements, that's what the callback function is used for. Some sorting algorithms can start anywhere in the array, others can start only in a specific part of it so there's no fixed meaning in $a and $b other than they are two elements in the array that have to be compared according to the current algorithm.
This method can be used to shed light upon which algorithm PHP is using.
<?php
$myArray = array(1, 19, 18, 12, 56);
function compare($a, $b) {
echo "Comparing $a to $b\n";
if ($a == $b) return 0;
return ($a < $b) ? -1 : 1;
}
usort($myArray,"compare");
print_r($myArray);
?>
Output
vinko#mithril:~$ php sort.php
Comparing 18 to 19
Comparing 56 to 18
Comparing 12 to 18
Comparing 1 to 18
Comparing 12 to 1
Comparing 56 to 19
Array
(
[0] => 1
[1] => 12
[2] => 18
[3] => 19
[4] => 56
)
From the output and looking at the source we can see the sort used is indeed a quicksort implementation, check for Zend/zend_qsort.c in the PHP source (the linked to version is a bit old, but hasn't changed much).
It picks the pivot in the middle of the array, in this case 18, then it needs to reorder the list so that all elements which are less (according to the comparison function in use) than the pivot come before the pivot and so that all elements greater than the pivot come after it, we can see it doing that when it compares everything to 18 at first.
Some further diagrammatic explanation.
Step 0: (1,19,18,12,56); //Pivot: 18,
Step 1: (1,12,18,19,56); //After the first reordering
Step 2a: (1,12); //Recursively do the same with the lesser, here
//pivot's 12, and that's what it compares next if
//you check the output.
Step 2b: (19,56); //and do the same with the greater
To sort anything you need a means to compare two items and figure out if one comes before the other. This is what you supply to usort. This function will be passed two items from your input array, and returns the order they should be in.
Once you have a means to compare two elements, you can use sort-algorithm-of-your-choice.
If you are unfamiliar, you might like to look at how a simple naive algorithm like bubblesort would use a comparison function.
Behind the scenes, PHP is using a quicksort.
usort() or uasort() have a human-feeling bug on sorted result. See the code segment:
function xxx($a,$b) { if ($a==$b) return 0; else return $a<$b?-1:1; }
$x=array(1=>10,2=>9,3=>9,4=>9,5=>6,6=>38);
uasort($x,'xxx');
print_r($x);
the result is:
Array ( [5] => 6 [4] => 9 [3] => 9 [2] => 9 [1] => 10 [6] => 38 )
Do you see the bug? No? Ok, let me explain it.
The original three '9' elments are in key order: 2,3,4. But in the result, the three '9' elements are now in key order: 4,3,2, i.e. equal-value elements are in reverse key order after sorting.
If the element is only single value, as in above example,it's fine with us. However, if the element is compound value, then it could cause human-feeling bug. See another code segments. We are to sort many points horizontally, i.e. sort them based on ascending x-coordinate value order :
function xxx($a,$b) { if ($a['x']==$b['x']) return 0; else return $a['x']<$b['x']?-1:1; }
$x=array(1=>array('x'=>1, 'v'=>'l'),2=>array('x'=>9, 'v'=>'love'),
3=>array('x'=>9, 'v'=>'Lara'),4=>array('x'=>9, 'v'=>'Croft'),
5=>array('x'=>15, 'v'=>'and'),6=>array('x'=>38, 'v'=>'Tombraider'));
uasort($x,'xxx');
print_r($x);
the result is:
Array ( [1] => Array ( [x] => 1 [v] => l ) [4] => Array ( [x] => 9 [v] => croft )
[3] => Array ( [x] => 9 [v] => Lara ) [2] => Array ( [x] => 9 [v] => love )
[5] => Array ( [x] => 15 [v] => and ) [6] => Array ( [x] => 38 [v] => Tombraider ) )
You see 'I love Lara Croft and Tombraider' becomes 'I Croft Lara love and Tombraider'.
I call it human-feeling bug because it depends on what case you use and how you feel it should be sorted in real world when the compared values are same.