Jak zsumować wszystkie wartości kolumn w tablicy wielowymiarowej?

Jak mogę dodać wszystkie wartości kolumnowe według klucza asocjacyjnego? Zwróć uwagę, że zestawy kluczy są dynamiczne.

Tablica wejściowa:

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
        )
)

Pożądany rezultat:

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

$sumArray = array();

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

print_r($sumArray);

Możesz użyć, array_walk_recursive()aby uzyskać ogólne rozwiązanie problemu ( takie, w którym każda wewnętrzna tablica może mieć unikalne klucze ).

$final = array();

array_walk_recursive($input, function($item, $key) use (&$final){
    $final[$key] = isset($final[$key]) ?  $item + $final[$key] : $item;
});

Przykład z array_walk_recursive()dla przypadku ogólnego

Ponadto, ponieważ PHP 5.5 można użyć array_column()funkcji do osiągnięcia rezultatu, który ma na dokładnym klucza , [gozhi]na przykład:

array_sum(array_column($input, 'gozhi')); 

Przykład z array_column()dla określonego klucza

Jeśli chcesz uzyskać całkowitą sumę wszystkich wewnętrznych tablic z tymi samymi kluczami ( pożądany wynik, który opublikowałeś ), możesz zrobić coś takiego ( pamiętając, że pierwsza wewnętrzna tablica musi mieć taką samą strukturę jak pozostałe ):

$final = array_shift($input);

foreach ($final as $key => &$value){
   $value += array_sum(array_column($input, $key));
}    

unset($value);

Przykład z array_column()case wszystkie tablice wewnętrzne mają te same klucze

Jeśli chcesz zastosować rozwiązanie dla przypadków ogólnych, array_column()na początku możesz rozważyć uzyskanie wszystkich unikalnych kluczy, a następnie uzyskać sumę za każdy klucz:

$final = array();

foreach($input as $value)
    $final = array_merge($final, $value);

foreach($final as $key => &$value)
    $value = array_sum(array_column($input, $key));

unset($value);

Przykład z array_column()dla przypadku ogólnego

Użyj tego fragmentu:

$key = 'gozhi';
$sum = array_sum(array_column($array,$key));

Oto rozwiązanie podobne do dwóch pozostałych:

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

Ale to nie musi sprawdzać, czy klucze tablic już istnieją i nie generują powiadomień.

Można to również zrobić za pomocą 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());
}

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

Inna wersja, z kilkoma zaletami poniżej.

$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);
    }

}

Chciałem połączyć najlepsze odpowiedzi Gumbo, Graviton i Chrisa J z następującymi celami, aby móc użyć tego w mojej aplikacji:

a) Zainicjuj klucze tablicy „sum” poza pętlą (Gumbo). Powinno pomóc w wydajności na bardzo dużych tablicach (jeszcze nie testowane!). Eliminuje powiadomienia.

b) Główna logika jest łatwa do zrozumienia bez sięgania po instrukcje. (Graviton, Chris J).

c) Rozwiąż bardziej ogólny problem polegający na dodaniu wartości dowolnych dwóch tablic z tymi samymi kluczami i uczynienie go mniej zależnym od struktury podtablicy.

W przeciwieństwie do rozwiązania Gumbo, możesz użyć tego ponownie w przypadkach, gdy wartości nie znajdują się w tablicach podrzędnych. Wyobraź sobie na przykład, że poniżej $arr1i $arr2nie są zakodowane, ale są zwracane w wyniku wywołania funkcji wewnątrz pętli.

$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);

Można to również zrobić za pomocą array_walk:

function array_sum_values(array $input, $key) {
   $sum = 0;
   array_walk($input, function($item, $index, $params) {
         if (!empty($item[$params[1]]))
            $params[0] += $item[$params[1]];
      }, array(&$sum, $key)
   );
   return $sum;
}

var_dump(array_sum_values($arr, 'gozhi'));

Nie tak czytelne jak poprzednie rozwiązania, ale działa :)

Oto wersja, w której klucze tablic mogą nie być takie same dla obu tablic, ale chcesz, aby wszystkie znajdowały się w ostatecznej tablicy.

function array_add_by_key( $array1, $array2 ) {
    foreach ( $array2 as $k => $a ) {
        if ( array_key_exists( $k, $array1 ) ) {
            $array1[$k] += $a;
        } else {
            $array1[$k] = $a;
        }
    }
    return $array1;
}

Musimy najpierw sprawdzić, czy klucz tablicy istnieje.

KOD:

$sum = array();
foreach ($array as $key => $sub_array) {
    foreach ($sub_array as $sub_key => $value) {

        //If array key doesn't exists then create and initize first before we add a value.
        //Without this we will have an Undefined index error.
        if( ! array_key_exists($sub_key, $sum)) $sum[$sub_key] = 0;

        //Add Value
        $sum[$sub_key]+=$value;
    }
}
print_r($sum);

WYJŚCIE z walidacją klucza tablicy:

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

WYJŚCIE bez weryfikacji klucza tablicy:

Notice: Undefined index: gozhi in F:\web\index.php on line 37

Notice: Undefined index: uzorong in F:\web\index.php on line 37

Notice: Undefined index: ngangla in F:\web\index.php on line 37

Notice: Undefined index: langthel in F:\web\index.php on line 37

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

Jest to zła praktyka, chociaż drukuje dane wyjściowe. Zawsze najpierw sprawdź, czy klucz istnieje.

Dla tych, którzy wylądowali tutaj i szukają rozwiązania, które łączy N tablic ORAZ również sumuje wartości identycznych kluczy znalezionych w N tablicach, napisałem tę funkcję, która działa również rekurencyjnie. (Zobacz: https://gist.github.com/Nickology/f700e319cbafab5eaedc )

Przykład:

$a = array( "A" => "bob", "sum" => 10, "C" => array("x","y","z" => 50) );
$b = array( "A" => "max", "sum" => 12, "C" => array("x","y","z" => 45) );
$c = array( "A" => "tom", "sum" =>  8, "C" => array("x","y","z" => 50, "w" => 1) );

print_r(array_merge_recursive_numeric($a,$b,$c));

Spowoduje:

Array
(
    [A] => tom
    [sum] => 30
    [C] => Array
        (
            [0] => x
            [1] => y
            [z] => 145
            [w] => 1
        )

)

Oto kod:

<?php 
/**
 * array_merge_recursive_numeric function.  Merges N arrays into one array AND sums the values of identical keys.
 * WARNING: If keys have values of different types, the latter values replace the previous ones.
 * 
 * Source: https://gist.github.com/Nickology/f700e319cbafab5eaedc
 * @params N arrays (all parameters must be arrays)
 * @author Nick Jouannem <nick@nickology.com>
 * @access public
 * @return void
 */
function array_merge_recursive_numeric() {

    // Gather all arrays
    $arrays = func_get_args();

    // If there's only one array, it's already merged
    if (count($arrays)==1) {
        return $arrays[0];
    }

    // Remove any items in $arrays that are NOT arrays
    foreach($arrays as $key => $array) {
        if (!is_array($array)) {
            unset($arrays[$key]);
        }
    }

    // We start by setting the first array as our final array.
    // We will merge all other arrays with this one.
    $final = array_shift($arrays);

    foreach($arrays as $b) {

        foreach($final as $key => $value) {

            // If $key does not exist in $b, then it is unique and can be safely merged
            if (!isset($b[$key])) {

                $final[$key] = $value;

            } else {

                // If $key is present in $b, then we need to merge and sum numeric values in both
                if ( is_numeric($value) && is_numeric($b[$key]) ) {
                    // If both values for these keys are numeric, we sum them
                    $final[$key] = $value + $b[$key];
                } else if (is_array($value) && is_array($b[$key])) {
                    // If both values are arrays, we recursively call ourself
                    $final[$key] = array_merge_recursive_numeric($value, $b[$key]);
                } else {
                    // If both keys exist but differ in type, then we cannot merge them.
                    // In this scenario, we will $b's value for $key is used
                    $final[$key] = $b[$key];
                }

            }

        }

        // Finally, we need to merge any keys that exist only in $b
        foreach($b as $key => $value) {
            if (!isset($final[$key])) {
                $final[$key] = $value;
            }
        }

    }

    return $final;

}

?>

Przejrzyj każdy element tablicy i zsumuj wartości z poprzednimi wartościami, jeśli istnieją, jeśli nie tylko przypisz wartość.

<?php
$array = 
[
    [
        'a'=>1,
        'b'=>1,
        'c'=>1,
    ],
    [
        'a'=>2,
        'b'=>2,
    ],
    [
        'a'=>3,
        'd'=>3,
    ]
];

$result = array_reduce($array, function($carry, $item) {
    foreach($item as $k => $v)
        $carry[$k] = $v + ($carry[$k] ?? 0);

    return $carry;
}, []);

print_r($result);

Wynik:

Array
(
    [a] => 6
    [b] => 3
    [c] => 1
    [d] => 3
)

Lub po prostu przejrzyj każdą pod tablicę i pogrupuj wartości dla każdej kolumny. Ostatecznie je podsumowując:

foreach($array as $subarray)
    foreach($subarray as $key => $value)
        $grouped[$key][] = $value;

$sums = array_map('array_sum', $grouped);

Oto, jak zwykle wykonuję tego rodzaju operacje.

// We declare an empty array in wich we will store the results
$sumArray = array();

// We loop through all the key-value pairs in $myArray
foreach ($myArray as $k=>$subArray) {

   // Each value is an array, we loop through it
   foreach ($subArray as $id=>$value) {

       // If $sumArray has not $id as key we initialize it to zero  
       if(!isset($sumArray[$id])){
           $sumArray[$id] = 0;
       }

       // If the array already has a key named $id, we increment its value
       $sumArray[$id]+=$value;
    }
 }

 print_r($sumArray);

Możesz spróbować tego:

$c = array_map(function () {
      return array_sum(func_get_args());
     },$a, $b);

i w końcu:

print_r($c);

działa to świetnie w moim projekcie laravel

print_r($Array); // your original array

$_SUM = [];

// count($Array[0]) => if the number of keys are equall in all arrays then do a count of index 0 etc.
for ($i=0; $i < count($Array[0]); $i++) {
    $_SUM[] = $Array[0][$i] + $Array[1][$i]; // do a for loop on the count 
}

print_r($_SUM); // get a sumed up array

$sumArray = array();
foreach ($myArray as $k => $subArray) {
    foreach ($subArray as $id => $value) {
        if (!isset($sumArray[$id])) {
            $sumArray[$id] = 0;
        }
        $sumArray[$id]+=$value;
    }
}

$sumArray = array();

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

print_r($sumArray);

`

Na przykład możesz usunąć wszystkie pola z wyniku takiego jak ten poniżej.

Wybieram „saldo” z tablicy i zapisuję do zmiennej

$kii =   $user->pluck('balance');

następnie w następnym wierszu możesz podsumować w ten sposób:

$sum =  $kii->sum(); 

Mam nadzieję, że to pomoże.