<?php
  $array = array(array('07/11' => '134'), array('07/11' => '134'), array('07/12' => '145'));
  $count = array();
  foreach ($array as $val) {
    foreach ($val as $key => $subval) {
      $count[$key]++;
    }
  }
  print_r($count);

$count = 0;
foreach ($array as $type) {
    $count+= count($type);
}

This can be done with a simple array_map function

$array = array_map(function($element){
    return $element['group'];
}, $array1);

$array2 = (array_count_values($array));

print_r($array2);

Merge all the subarray into a single array and apply array_count_values function to get the result

function merageAll($arr) {
  $flatArray = array();
  foreach(element) {
    if (is_array($element)) {
        $flatArray = array_merge($flatArray, merageAll($element));
    } else {
        $flatArray[] = $element;
    }
  }
  return $flatArray;
 }
 $res = array_count_values(merageAll($feetypes));

Result

Array
(
 [30] => 4
 [35] => 2
 [50] => 2
 [34] => 1
)

function merageAll work if there are values and sub arrays in the array.

Working DEMO LINK

use array_column($array, 1) to get position[1] elements as array; Then use your array_count_values() to count them.

<?php
$array = [[1,2,3],[2,3,4]];
var_dump(array_count_values ( array_column($array,1) ));

This should fit your needs:

<?php

$a = array(
    'svote001' => array("006", "006", "007"),
    'svote002' => array("000", "000", "000"),
    'svote003' => array("003", "001", "001"),
);
$resultArray = array();

foreach ($a as $arrayName => $arrayData){
    $resultArray[$arrayName] = array();
    foreach ($arrayData as $value){
        if (empty($resultArray[$arrayName][$value])){
            $resultArray[$arrayName][$value] = 1;
        }else{
            $resultArray[$arrayName][$value]++;
        }
    }
    arsort($resultArray[$arrayName]);
}

var_dump($resultArray);

Edit: AbraCadaver solution is much better, use this one. I will let the answer stay here anyway.

Does this work for what you need?

$dates = array(array(array("2011-11-18 00:00:00" => C), array("2011-11-18 00:00:00" => I),array
("2011-11-18 00:00:00" => S)),
array(array("2011-11-22 00:00:00" => C), array("2011-11-22 00:00:00" => S)));

$date_count = array();  // create an empty array

foreach($dates as $date) {  // go thought the first level
    foreach($date as $d) {  // go through the second level
        $key = array_keys($d);  // get our date
        // here we increment the value at this date
        // php will see it as 0 if it has not yet been initialized
        $date_count[$key[0]]++;
    }
}
    // show what we have
print_r($date_count);

Prints:

Array ( [2011-11-18 00:00:00] => 3 [2011-11-22 00:00:00] => 2 )

Note: this assumes that you will always be getting data as you structured your array and that each date will be formatted the same. If you can't assume each date will be formatted, this would be a simple conversion using the date() function. If you can't assume that you will get data structured exactly like this, the best way to tackle that would probably be through a recursive function.

Try building a new array that keeps count like this:

$newArray = array(
  array("Software Engineer"),
  array("Hampelmann", "Software Engineer")
);

$countArray = array();

foreach($newArray as $tempArray){
  foreach($tempArray as $key => $value){
    if(array_key_exists($value, $countArray)){
      $countArray[$value] = $countArray[$value] + 1;
    } else {
      $countArray[$value] = 1;
    }
  }
}

echo '<pre>'.print_r($countArray, true).'</pre>';

The output comes out like:

Array
(
  [Software Engineer] => 2
  [Hampelmann] => 1
)

Looping is the answer.

<?php
// untested

$counts = Array();
foreach( $array as $subArray ){
    $value = $subArray[0];
    $counts[ $value ] = ( isset($counts[ $value ]) )
        ? $counts[ $value ] + 1
        : 1;
}

var_dump( $counts);

In my opinion this calls for recursion because you'll do the same thing over each flat level of the array: add the points.

so you'll need to

• loop over each array
• add points found
• if we find any children, do it again but with children array

while keeping track of levels and jumping out if you reach your limit

With that in mind I thought of the following solution:

<?php

$values = array();

//first
$values[] = array('name'=>'andrej','points'=>1,'children'=>array());
$values[] = array('name'=>'peter','points'=>2,'children'=>array());
$values[] = array('name'=>'mark','points'=>3,'children'=>array());

//second
$values[0]['children'][] = array('name'=>'Sarah','points'=>4,'children'=>array());
$values[2]['children'][] = array('name'=>'Mike','points'=>5,'children'=>array());

//third 
$values[0]['children'][0]['children'][] = array('name'=>'Ron','points'=>6,'children'=>array());

//fourth
$values[0]['children'][0]['children'][0]['children'][] = array('name'=>'Ronny','points'=>7,'children'=>array());

//fifth
$values[0]['children'][0]['children'][0]['children'][0]['children'][] = array('name'=>'Marina','points'=>10,'children'=>array());

//sixth
$values[0]['children'][0]['children'][0]['children'][0]['children'][0]['children'][] = array('name'=>'Pjotr','points'=>400,'children'=>array());


function collect_elements($base, $maxLevel,$child='children',$gather='points', &$catch = array(), $level = 0) {
/*    I pass $catch by reference so that all recursive calls add to the same array
      obviously you could use it straight away but I return the created array as well
  because I find it to be cleaner in PHP (by reference is rare and can lead to confusion)

  $base = array it works on
  $maxLevel = how deep the recursion goes

  $child = key of the element where you hold your possible childnodes
      $gather = key of the element that has to be collected
*/

  $level++;
  if($level > $maxLevel) return; // we're too deep, bail out

  foreach ($base as $key => $elem) {
    // collect the element if available
    if(isset($elem[$gather])) $catch[] = $elem[$gather];

    /*
    does this element's container have children? 
       [$child] needs to be set, [$child] needs to be an array, [$child] needs to have elements itself
    */
    if (isset($elem[$child]) && is_array($elem[$child]) && count($elem[$child])){
       // if we can find another array 1 level down, recurse that as well  
       collect_elements($elem[$child],$maxLevel,$child,$gather, $catch,$level); 
    }
  }
return $catch;
}

print array_sum(collect_elements($values,5)) . PHP_EOL;

collect_elements will collect the element you're interested in (until maximum depth is reached) and append it to a flat array, so that you can act on it upon return. In this case we do an array_sum to get the total of poins collected

Only the first for parameters are interesting:

collect_elements($base, $maxLevel,$child='children',$gather='points'

not optional: $base is the array to work on $maxLevel is the maximum depth the function needs to descend into the arrays optional: $child defines the key of the element that contains the children of current element (array) $gather defines the key of the element that contains what we want to gather

The remaining parameters are just ones used for recursion