Comment additionner les valeurs de toutes les colonnes d'un tableau multidimensionnel ?

Question

Comment puis-je ajouter toutes les valeurs en colonne par clé associative ? Notez que les jeux de clés sont dynamiques.

Tableau d'entrée :

Array
(
    [0] => Array
        (
            [gozhi] => 2
            [uzorong] => 1
            [ngangla] => 4
            [langthel] => 5
        )

    [1] => Array
        (
            [gozhi] => 5
            [uzorong] => 0
            [ngangla] => 3
            [langthel] => 2
        )

    [2] => Array
        (
            [gozhi] => 3
            [uzorong] => 0
            [ngangla] => 1
            [langthel] => 3
        )
)

Résultat souhaité :

Array
(
    [gozhi] => 10
    [uzorong] => 1
    [ngangla] => 8
    [langthel] => 10
)

Answer 1

$sumArray = array();

foreach ($myArray as $k=>$subArray) {
  foreach ($subArray as $id=>$value) {
    $sumArray[$id]+=$value;
  }
}

print_r($sumArray);

Answer 2

Voici une solution similaire aux deux autres :

$acc = array_shift($arr);
foreach ($arr as $val) {
    foreach ($val as $key => $val) {
        $acc[$key] += $val;
    }
}

Mais ceci n'a pas besoin de vérifier si les clés du tableau existent déjà et ne jette pas d'avis non plus.

Answer 3

On peut aussi le faire en utilisant array_map :

$rArray = array(
    0 => array(
        'gozhi' => 2,
        'uzorong' => 1,
        'ngangla' => 4,
        'langthel' => 5
    ),
    1 => array(
        'gozhi' => 5,
        'uzorong' => 0,
        'ngangla' => 3,
        'langthel' => 2
    ),
    2 => array(
        'gozhi' => 3,
        'uzorong' => 0,
        'ngangla' => 1,
        'langthel' => 3
    ),
);

$sumResult = call_user_func_array('array_map', array_merge(['sum'], $rArray));

function sum()
{
    return array_sum(func_get_args());
}

Answer 4

$newarr=array();
foreach($arrs as $value)
{
  foreach($value as $key=>$secondValue)
   {
       if(!isset($newarr[$key]))
        {
           $newarr[$key]=0;
        }
       $newarr[$key]+=$secondValue;
   }
}

Answer 5

Une autre version, avec quelques avantages ci-dessous.

$sum = ArrayHelper::copyKeys($arr[0]);

foreach ($arr as $item) {
    ArrayHelper::addArrays($sum, $item);
}

class ArrayHelper {

    public function addArrays(Array &$to, Array $from) {
        foreach ($from as $key=>$value) {
            $to[$key] += $value;
        }
    }

    public function copyKeys(Array $from, $init=0) {
        return array_fill_keys(array_keys($from), $init);
    }

}

Je voulais combiner le meilleur des réponses de Gumbo, Graviton et Chris J avec les objectifs suivants afin de pouvoir les utiliser dans mon application :

a) Initialiser les clés du tableau 'sum' en dehors de la boucle (Gumbo). Cela devrait améliorer les performances sur les très grands tableaux (pas encore testé !). Élimine les avis.

b) La logique principale est facile à comprendre sans avoir à consulter les manuels. (Graviton, Chris J).

c) Résoudre le problème plus général de l'addition des valeurs de deux tableaux ayant les mêmes clés et le rendre moins dépendant de la structure des sous-réseaux.

Contrairement à la solution de Gumbo, vous pouvez réutiliser cette méthode dans les cas où les valeurs ne sont pas dans des sous-réseaux. Imaginez dans l'exemple ci-dessous que $arr1 y $arr2 ne sont pas codées en dur, mais sont renvoyées comme résultat de l'appel d'une fonction à l'intérieur d'une boucle.

$arr1 = array(
    'gozhi' => 2,
    'uzorong' => 1,
    'ngangla' => 4,
    'langthel' => 5
);

$arr2 = array(
   'gozhi' => 5,
   'uzorong' => 0,
   'ngangla' => 3,
   'langthel' => 2
);

$sum = ArrayHelper::copyKeys($arr1);

ArrayHelper::addArrays($sum, $arr1);
ArrayHelper::addArrays($sum, $arr2);