PHP: Counting similar occurrences in multidimensional array

Question

I have a multidimensional array, in which I want to count similar occurrences.

So basically I want this:

[
    [
        'type' => 'frosties',
        'madeby' => 'kelloggs'
    ],
    [
        'type' => 'frosties',
        'madeby' => 'kelloggs'
    ],        
    [
        'type' => 'cornflakes',
        'madeby' => 'kelloggs'
    ]
];

To end out as this:

[
    [
        'type' => 'frosties',
        'madeby' => 'kelloggs',
        'count' => 2
    ],
    [
        'type' => 'cornflakes',
        'madeby' => 'kelloggs',
        'count' => 1
    ]
]

This is what I've come up with so far:

    public function count($array) {
    $newArr = [];

    foreach ($array as $breakfast) {
        if (in_array($breakfast['type'], $newArr) && in_array($breakfast['madeby'], $newArr)) {
            //what goes here?
            //dosomething['count']++;
        } else {
            $newArr[] = [
                'type'   => $breakfast['type'],
                'madeby' => $breakfast['madeby'],
                'count'  => 0
            ];
        }
    }
    return $newArr;
}

I might have been staring at this for too long, but I just can't seem to come up with what goes inside the if().

I'm guessing you want something similar to this: jdl-enterprises.co.uk/sof/25789697.php (in the sense of it having a "count" field) — James Lalor
– James Lalor, Commented Nov 4, 2014 at 12:57
You are not using in_array correctly as you are checking for a string, but inside your main array you have another level of arrays. You should add the type as the key and compare against that if it is possible. — David Jones
– David Jones, Commented Nov 4, 2014 at 13:00

OIS · Accepted Answer · 2014-11-04 13:12:54Z

3

Here you go:

$array = [
    [
        'type' => 'frosties',
        'madeby' => 'kelloggs'
    ],
    [
        'type' => 'frosties',
        'madeby' => 'kelloggs'
    ],
    [
        'type' => 'cornflakes',
        'madeby' => 'kelloggs'
    ]
];

$results = [];

foreach ($array as $pair) {
    //ksort($pair); <- might need ksort here if type and madeby are not in the same order. 
    $key = serialize($pair);
    if (isset($results[$key])) {
        $results[$key]['count']++;
    } else {
        $results[$key] = array_merge($pair, ['count' => 1]);
    }
}

$results = array_values($results);

print_r($results);

edited Nov 4, 2014 at 13:12

OIS

10.1k3 gold badges35 silver badges41 bronze badges

answered Nov 4, 2014 at 13:04

motanelu

4,0251 gold badge16 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

anders Over a year ago

Although this seems to work perfectly fine with a small array like this, how will it perform if the array contains say 2000 elements?

Community · Accepted Answer · 2017-05-23 12:27:17Z

To save some memory and make the look up faster, I'd suggest to use an implementation that makes use of the \ArrayAccess interface. The CerialStack keeps two internal arrays: One to hold the stack where we append and another smaller one that just serves a purpose as look up map.

class CerialStack implements \ArrayAccess
{
    /** @var array Container */
    private $stack = [];

    /** @var array Flat map of `type` for look ups */
    private $map = [];

    // Only look up the map
    public function offsetExists( $type )
    {
        return in_array( $type, $this->map );
    }

    // Only looks up the map
    public function offsetGet( $type )
    {
        return $this->offsetExists( $type )
            ? $this->stack[ array_search( $type, $this->map ) ]
            : false;
    }

    // Sets both the map as well as the stack (if the map look up return false)
    // increases the counter if the value exists
    public function offsetSet( $index, $value )
    {
        $type = $value['type'];
        if ( ! $this->offsetGet( $type ) )
        {
            $this->map[] = $type;
            $this->stack[] = array_merge( [ 'count' => 1, ], $value );
        }
        else
        {
            $key = $this->getKey( $type );
            $key and $this->stack[ $key ]['count']++;
        }
    }

    // reduces both the map and the stack
    public function offsetUnset( $type )
    {
        $key = $this->getKey( $type );
        if ( $key )
            unset(
                $this->stack[ $key ],
                $this->map[ $key ]
            );
    }

    private function getKey( $type )
    {
        return array_search( $type, $this->map );
    }

    public function getStack()
    {
        return $this->stack;
    }
}

The Stack class allows pretty fast look ups as well as handling the array as you are used to. No magic or special function calls involved.

Sort by [...]

To sort the stack, I'd suggest to use a \SplMaxHeap implementation as I've written in another answer. Just alter the class slightly and replace ->rating with ['count'] in the custom heap.

Test

Let's test that:

// Test data
$cerials = [
    [
        'type'   => 'frosties',
        'madeby' => 'kelloggs',
    ],
    [
        'type'   => 'frosties',
        'madeby' => 'kelloggs',
    ],
    [
        'madeby' => 'kelloggs',
        'type'   => 'cornflakes',
    ]
];

$it = new \CerialStack;
// Push into stack
foreach ( $cerials as $cerial )
    $it[] = $cerial;
// Dump the stack
var_dump( $it->getStack() );

// Output
array (size=2)
  0 => 
    array (size=3)
      'count' => int 2
      'type' => string 'frosties' (length=8)
      'madeby' => string 'kelloggs' (length=8)
  1 => 
    array (size=3)
      'count' => int 1
      'madeby' => string 'kelloggs' (length=8)
      'type' => string 'cornflakes' (length=10)

How does this save memory or improve speed? It is also incorrect as it ignores the key "madeby". Unlike the accepted answer this with hardcoded "type" key is also limited to the data, while the accepted answer will work with all sorts of arrays which does not have a count key of their own.
@OIS Iterators retrieve the data element by element, while an array in a foreach loop gets consumed as one. That's why iterators use less memory. About the "incorrect" part: Could you please elaborate?

amit · Accepted Answer · 2014-11-04 13:11:04Z

Try this and change function name to something else:

        <?php
        $array = array(
            array (
            'type' => 'frosties',
            'madeby' => 'kelloggs',
            ),
       array (
            'type' => 'frosties',
            'madeby' => 'kelloggs'
        ),        
        array(
            'type' => 'cornflakes',
            'madeby' => 'kelloggs'
        )
    );
    print_r(counta($array));

    function counta($array) {
        $newArr = [];

        foreach ($array as $breakfast) {
            if(empty($newArr))
            {
                $newArr[] = array (
                  'type' => $breakfast['type'],
                    'madeby' => $breakfast['madeby'],
                    'count' => 1
                );
            }
            else
            {
                foreach($newArr as $k=>$tmp)
                {
                    if($tmp['type']==$breakfast['type'] && $tmp['madeby']==$breakfast['madeby'])
                    {
                        $newArr[$k]['count']=$newArr[$k]['count']+1;
                    }
                    else{
                        $newArr[] = array (
                  'type' => $breakfast['type'],
                    'madeby' => $breakfast['madeby'],
                    'count' => 1
                );
                    }
                }
            }
        }
        return $newArr;
        }
    ?>

This is potentially really really really really really slow.

Collectives™ on Stack Overflow

PHP: Counting similar occurrences in multidimensional array

3 Answers 3

1 Comment

Sort by [...]

Test

2 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

Sort by [...]

Test

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related