试试这个，即使一个键只存在于一个数组中，它也会找到和，这会同时找到和和和计数。

<?php

$arr = [
  [0 => 1, 1 => 5, 3 => null],
  [0 => 4, 1 => null, 3 => null],
  [0 => null, 1 => 5, 3 => 5]
];
$out   = [];
$count = [];
foreach ( $arr as $key => $value) {
    # code...
    foreach ( $value as $k => $v) {
      if(NULL != $v) {
         $count[$k] = isset($count[$k]) ? ($count[$k] + 1) : 1;
      }

      $v       = (NULL === $v) ? 0 : $v;
      $out[$k] = isset($out[$k]) ? ($out[$k] + $v) : $v;

   }

}
echo '<pre>';
echo "Sum array is : ";
print_r($out);
echo '</pre>';

echo '<pre>';
echo "Count array is : ";
print_r($count);
echo '</pre>';

Will给出了输出

Sum array is : 
Array
(
    [0] => 5
    [1] => 10
    [3] => 5
)

Count array is : 
Array
(
    [0] => 2
    [1] => 2
    [3] => 1
)

对于下面注解的输入数组

$arr = [ 
    [0 => null, 1 => null, 3 => null], 
    [0 => 4, 1 => null, 3 => null], 
    [0 => null, 1 => 5, 3 => 5] 
];

将给予

Sum array is : 
Array
(
    [0] => 4
    [1] => 5
    [3] => 5
)

Count array is : 
Array
(
    [0] => 1
    [1] => 1
    [3] => 1
)

• • 如果这不是您想要的结果，也请为注解数组提供预期输出。**

步骤：
1)循环数组，你会得到子数组。
2)在子数组上循环，我们将得到实际的数值。
3)在子数组中准备一个以key为数值的数组。
4)每次在内部循环中，如果该值作为键存在于结果数组中，则返回。
5)如果存在，则增加计数。
这可能是您的解决方案：

<?php
$arr = [
  [0 => 1, 1 => 5, 3 => null],
  [0 => 4, 1 => null, 3 => 2],
  [0 => null, 1 => 5, 3 => 5]
];
$out = array();
foreach ($arr as $key => $value){
    foreach ($value as $key2 => $value2){
        $index = $value2;
        if (array_key_exists($index, $out)){
            $out[$index]++;
        } else {
            $out[$index] = 1;
        }
    }
}

echo "Original array:<br/>";
echo '<pre>';print_r($arr);echo '</pre>';

echo "Counted values:<br/>";
echo '<pre>';print_r($out);echo '</pre>';
?>

输出：
原始阵列：

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 5
            [3] => 
        )

    [1] => Array
        (
            [0] => 4
            [1] => 
            [3] => 2
        )

    [2] => Array
        (
            [0] => 
            [1] => 5
            [3] => 5
        )

)

Counted values:

Array
(
    [1] => 1
    [5] => 3
    [] => 3
    [4] => 1
    [2] => 1
)

如果你想要这些值的总和，尽管这确实假设所有的数组都有与第一行相同的列...

$data = '[
  {"0":1, "1":5, "3":null},
  {"0":4, "1":null, "3":2},
  {"0":null, "1":5, "3":5}
]';

$data = json_decode($data, true);
$out = array();
foreach ( array_keys($data[0]) as $key ) {
    $out[$key] = array_sum(array_column($data, $key));
}
print_r(json_encode($out));

它查看数据的第一行并获得列的列表（使用array_keys()），然后从整个数组中提取该列的值（使用array_column()）并将这些值相加（使用array_sum()）。
输出为...

{"0":5,"1":10,"3":7}

**更新：**问题编辑后...

$data = '[
  {"0":1, "1":5, "3":null},
  {"0":4, "1":null, "3":null},
  {"0":null, "1":5, "3":5}
]';

$data = json_decode($data, true);
$out = array();
foreach ( array_keys($data[0]) as $key ) {
    $out[$key] = 0;
    foreach ( array_column($data, $key) as $value ) {
        if ( $value )   {
            $out[$key]++;
        }
    }
}
print_r(json_encode($out));

输出...

{"0":2,"1":2,"3":1}

使用类似的原理，但只是循环遍历每一列，并对包含值的列进行计数。
或者更短的版本...

$data = json_decode($data, true);
$out = array();
foreach ( array_keys($data[0]) as $key ) {
    $out[$key] = count(array_filter(array_column($data, $key)));
}
print_r(json_encode($out));

虽然递归不是严格需要的，但是array_walk_recursive()提供了到第二级关联数据的直接路径。
代码：（Demo）

$result = [];
array_walk_recursive(
    $array,
    function($v, $k) use(&$result) {
        $result[$k] = ($result[$k] ?? 0) + ($v !== null);
    }
);
var_export($result);

否则，可以使用嵌套循环访问行的数据。
代码：（Demo）

$result = [];
foreach ($array as $row) {
    foreach ($row as $k => $v) {
        $result[$k] = ($result[$k] ?? 0) + ($v !== null);
    }
}
var_export($result);