PHP Sorting Multidimensional array by number of occurrences of values in a key

Question

I'm trying to first sort by quantity in Rank and if the quantity is equal then sort numerically by Rank.

It might sound complicated but here is the pseudo-code I envision

1. First sort arrays by the number of repeated values in Rank.
2. If number of repeated values is equal sort numerically by the value in Rank.

I guess its kinda recursive seeing as the 2nd part is performed on all sub-arrays.

I've been trying usort but I can't get it so see the count of repeated rank values in the array. Multisort doesn't seem to fit either.

Example:

Array
(
    [0] => Array
        (
            [Rank] => 7
            [Suit] => Hearts
        )

    [1] => Array
        (
            [Rank] => 3
            [Suit] => Hearts
        )

    [2] => Array
        (
            [Rank] => 6
            [Suit] => Spades
        )

    [3] => Array
        (
            [Rank] => 10
            [Suit] => Spades
        )

    [4] => Array
        (
            [Rank] => 3
            [Suit] => Spades
        )

    [5] => Array
        (
            [Rank] => 6
            [Suit] => Hearts
        )

    [6] => Array
        (
            [Rank] => 2
            [Suit] => Clubs
        )

)

According to my algorithm

Array
(

    [0] => Array
        (
            [Rank] => 6
            [Suit] => Hearts
        )

    [1] => Array
        (
            [Rank] => 6
            [Suit] => Spades
        )

    [2] => Array
        (
            [Rank] => 3
            [Suit] => Spades
        )


    [3] => Array
        (
            [Rank] => 3
            [Suit] => Hearts
        )

    [4] => Array
        (
            [Rank] => 10
            [Suit] => Spades
        )

    [5] => Array
        (
            [Rank] => 7
            [Suit] => Hearts
        )

    [6] => Array
        (
            [Rank] => 2
            [Suit] => Clubs
        )

)

Answer 1

To avoid performing the counting operation multiple times, you should populate the lookup array of ranks and their counts and cache it as a variable ($rankCounts). Using native functions is a concise way of directly generating the lookup array.

Pass the lookup array into the scope of the usort() call with use().

The spaceship operator makes the comparison logic very clean and readable. Write corresponding values into the array on either side of the operator to declare the order of the sorting conditions. Write $b values on the left and $a values on the right to achieve DESC order.

Code: (Demo)

$rankCounts = array_count_values(array_column($array, 'Rank'));

usort(
    $array,
    function($a, $b) use ($rankCounts) {
        return [$rankCounts[$b['Rank']], $b['Rank']] <=> [$rankCounts[$a['Rank']], $a['Rank']];
    }
);

var_export($array);

If you want to add another sorting rule, just add it as element [2] to both arrays inside of usort and you are finished. The spaceship operator is very handy and powerful.

Answer 2

The easiest solution I could come up with, is to use a second array in which we'll store the card count for each rank. We can then pass this array to the sorting function in order to get the result we want.

Here's an example of how this would look:

$cards = [...];

$ranks = [];

// Count the cards for each rank
foreach ($cards as $card) {
    if (!isset($ranks[$card['Rank']])) {
        $ranks[$card['Rank']] = 0;
    }

    $ranks[$card['Rank']]++;
}

// Sort the cards array
usort($cards, function ($a, $b) use ($ranks) {
    // If the cards count is the same for the rank, compare rank
    if ($ranks[$a['Rank']] == $ranks[$b['Rank']]) {
        return $a['Rank'] - $b['Rank'];
    }

    // Compare the card count for the rank
    return $ranks[$a['Rank']] - $ranks[$b['Rank']];
});