How to assign a rank number to an array

Question

I have an array of numbers, for example myarray = (45,3,56,7,21). What I need is to rank the values ​​in another array, so for the above, I would end up with myarray2 = (4,1,5,2,3).

Many thanks,

Adam

Answer 1

There you go, the full solution:

<?php

$myarray = array(45,3,56,7,21);

//create a copy and sort
$myarray_copy = $myarray;
sort($myarray_copy);

//reverses key and values
$myarray_copy = array_flip($myarray_copy);

//create result by using keys from sorted values + 1
foreach($myarray as $val)
    $myarray2[] = $myarray_copy[$val]+1;

//print final array
print_r($myarray2);

/*
Output:

Array ( [0] => 4 [1] => 1 [2] => 5 [3] => 2 [4] => 3 )
*/
?>

Answer 2

Very interesting.

What I can find in place looks something like this:

Sort the array and put it in another array, then populate myarray2 by searching for an intermediate array for the value, and then populating the values ​​of myarray2 with an index.

$myarraytemp = sort clone $myarray;

foreach ($myarray as $num)
{
    array_push($myarray2, array_search($num,$myarraytemp));
}

Alternatively, you can do this:

foreach ($myarray as $num)
{
    $rank=0;
    foreach ($myarray as $innernum)
    {
        if($innernum<= $num)
            $rank++;             
    }
    array_push($myarray2, $rank);
}

Answer 3

, - :

$b = $a = array(45,3,56,7,21);
sort($b);
$r = array_map(
    function ($number) use ($b) {
        return array_search($number, $b) + 1;
    }, $a);

, . Java, ( weka):

/**
 * Sorts a given array of integers in ascending order and returns an 
 * array of integers with the positions of the elements of the original 
 * array in the sorted array. The sort is stable. (Equal elements remain
 * in their original order.)
 *
 * @param array this array is not changed by the method!
 * @return an array of integers with the positions in the sorted
 * array.
 */
public static int[] sort(int[] array) {

    int[] index = new int[array.length];
    int[] newIndex = new int[array.length];
    int[] helpIndex;
    int numEqual;

    for (int i = 0; i < index.length; i++) {
        index[i] = i;
    }
    quickSort(array, index, 0, array.length - 1);

    // Make sort stable
    int i = 0;
    while (i < index.length) {
        numEqual = 1;
        for (int j = i + 1; ((j < index.length)
                && (array[index[i]] == array[index[j]]));
                j++) {
            numEqual++;
        }
        if (numEqual > 1) {
            helpIndex = new int[numEqual];
            for (int j = 0; j < numEqual; j++) {
                helpIndex[j] = i + j;
            }
            quickSort(index, helpIndex, 0, numEqual - 1);
            for (int j = 0; j < numEqual; j++) {
                newIndex[i + j] = index[helpIndex[j]];
            }
            i += numEqual;
        } else {
            newIndex[i] = index[i];
            i++;
        }
    }
    return newIndex;
}

private static void quickSort(int[] array, int[] index,
        int left, int right) {

    if (left < right) {
        int middle = partition(array, index, left, right);
        quickSort(array, index, left, middle);
        quickSort(array, index, middle + 1, right);
    }
}

Answer 4

Take a few arrays, count how many numbers are less than one, add one and you have a rank.

Answer 5

Here's how to do it:

function get_array_ranking($array){
  $ranking = array();
  foreach ($array as $number) {
    $smaller = 1;
    foreach ($array as $number2) {
      if ($number2 < $number) $smaller++;
    }
    $ranking[] = $smaller;
  }
  return $ranking;
}

Answer 6

Quite simply, if you use a sort function that supports source keys such as asort:

Also, since it uses php internal sorting, the runtime for sorting is n log (n) I suppose

$myArray = (45,3,56,7,21);
$myArrayCopy = $myArray;
//asort will sort an array while preserving the key value
asort($myArrayCopy);

foreach($myArraycopy as $key => $value)
{
    //map the keys of the array to the original index locations
    $sortIndexArray[] =  $key;
}