बहु-आयामी सरणी में सभी स्तंभ मानों को कैसे योग करें?

Question

मैं सहयोगी कुंजी द्वारा सभी स्तंभ मान कैसे जोड़ सकता हूं? ध्यान दें कि मुख्य सेट गतिशील हैं।

इनपुट सरणी:

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

वांछित परिणाम:

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

Comments

एक सामान्य स्थिति के लिए, दो बहुमूत्रता सरणियों में एक ही कुंजी नहीं होती है। मर्ज / योग मल्टी डाइमेंशनल एरेप php

— क्रिश रूफ

Answer 1

$sumArray = array();

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

print_r($sumArray);

Comments

कुंजी के रूप में अभी तक मौजूद नहीं है कि पहली यात्रा के लिए नोटिस फेंक देंगे।

— गुम्बो

यदि एन सरण हैं?

— मुहम्मद उस्मान

@ रानामुहम्मदउस्मान: यदि कोई ऐरे हैं n, तो इस घोल का उपयोग करें ।

— अमल मुरली

array_reduce मुझे सबसे सुंदर लगता है stackoverflow.com/questions/14195916/…

— Bill'o

नोटिस से बचने के लिए आप मानों को असाइन करने वाली रेखा को $ sumArray में बदल सकते हैं: array_key_exists ($ id, $ sumArray)? $ sumArray [$ id] + = $ मूल्य: $ sumArray [$ id] = $ मूल्य;

— डेव ओ ब्रायन

Answer 2

आप array_walk_recursive()अपनी समस्या के लिए एक सामान्य-केस समाधान प्राप्त करने के लिए उपयोग कर सकते हैं ( एक जब प्रत्येक आंतरिक सरणी में संभवतः अद्वितीय कुंजी हो सकती है )।

$final = array();

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

array_walk_recursive()सामान्य मामले के लिए उदाहरण

इसके अतिरिक्त, क्योंकि पीएचपी 5.5 आप उपयोग कर सकते हैं array_column()परिणाम आप चाहते हैं प्राप्त करने के लिए समारोह सटीक कुंजी के लिए , [gozhi]उदाहरण के लिए:

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

array_column()निर्दिष्ट कुंजी के लिए उदाहरण के साथ

यदि आप सभी आंतरिक सरणियों का कुल योग एक ही कुंजी ( वांछित परिणाम जिसे आपने पोस्ट किया है ) के साथ प्राप्त करना चाहते हैं, तो आप कुछ इस तरह कर सकते हैं ( ध्यान में रखते हुए कि पहले आंतरिक सरणी में दूसरों के समान संरचना होनी चाहिए। ):

$final = array_shift($input);

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

unset($value);

उदाहरण के array_column()मामले में सभी आंतरिक सरणियों में एक ही कुंजी है

यदि आप एक सामान्य केस सॉल्यूशन का उपयोग करना चाहते हैं, array_column()तो सबसे पहले आप सभी विशिष्ट कुंजी प्राप्त करने पर विचार कर सकते हैं, और फिर प्रत्येक कुंजी के लिए योग प्राप्त कर सकते हैं:

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

array_column()सामान्य मामले के लिए उदाहरण

Answer 3

इस स्निपेट का उपयोग करें:

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

Comments

मैंने इस प्रश्न को स्पष्ट करने के लिए संपादित किया है कि यह समाधान ओपी के वांछित आउटपुट देने के संदर्भ में कुछ हद तक समझ में आता है। यदि आपने अपने उत्तर का विस्तार किया है, तो यह बहुत संभावना है कि पहले पोस्ट किए गए उत्तरों की नकल बन जाए।

— मिकमैकुसा

Answer 4

यहाँ दो अन्य लोगों के समान एक समाधान है:

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

लेकिन यह जाँचने की ज़रूरत नहीं है कि सरणी कुंजियाँ पहले से मौजूद हैं और न तो नोटिस फेंकते हैं और न ही।

Comments

इस विशिष्ट सरणी संरचना के लिए +1 बहुत चतुर समाधान। बहुत बुरा यह अंतिम परिणाम की तरह सभी संरचित सरणियों के अधिक सामान्य मामले में काम नहीं करता है।

— टॉड चाफी

Answer 5

इसका उपयोग करके भी किया जा सकता है 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());
}

Comments

सरणी के n संख्याओं के लिए सही

— दुष्यंत जोशी

आप इसे एन संख्याओं के लिए कैसे बदलेंगे?

— पाथ्र्स

Answer 6

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

Comments

ध्यान दें कि यह आपको हर बार आपके असाइनमेंट के दाईं ओर $ newarr [$ key] का उपयोग करने पर PHP नोटिफ़ाइड (अपरिभाषित सूचकांक) देगा, जब ऐसे मान अभी तक मौजूद नहीं हैं।

— एंटी वीराना

मुझे लगता है कि मैं $ newarr [$ key] को शुरू करने के लिए एक चेक जोड़ता हूं

— Graviton

कृपया टिप्पणी छोड़ दें यदि आप किसी को वोट देते हैं ... यदि आप टिप्पणी नहीं छोड़ते हैं तो समाधान में सुधार करने का कोई तरीका नहीं है।

— टॉड चाफी

@ ग्रेविटॉन मैंने डाउनवोट नहीं किया, लेकिन मैं यह बताऊंगा कि हर स्टैकऑवरफ्लो उत्तर में कुछ स्पष्टीकरण शामिल होना चाहिए कि समाधान कैसे काम करता है और / या क्यों यह उचित है। याद रखें कि इस साइट / नेटवर्क पर हर पेज हजारों डेवलपर्स के लिए एक शैक्षिक संसाधन है जिसमें कौशल / ज्ञान की एक विस्तृत श्रृंखला है। (अगर मुझे हर बार एक कोड-ओनली उत्तर मिला, तो मैं

— निरस्त

Answer 7

एक और संस्करण, नीचे कुछ लाभों के साथ।

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

}

मैं गुमबो के सर्वश्रेष्ठ, ग्रेविटन और क्रिस जे के जवाब को निम्न लक्ष्यों के साथ जोड़ना चाहता था ताकि मैं अपने ऐप में इसका उपयोग कर सकूं:

a) लूप (Gumbo) के बाहर 'sum ’एरो कीज़ को इनिशियलाइज़ करें। बहुत बड़े सरणियों (अभी तक परीक्षण नहीं किया गया है) पर प्रदर्शन के साथ मदद करनी चाहिए। नोटिस को समाप्त करता है।

ख) मुख्य तर्क मैनुअल को पकड़े बिना समझना आसान है। (ग्रेविटन, क्रिस जे)।

ग) किसी भी दो सरणियों के मूल्यों को एक ही कुंजी के साथ जोड़ने की अधिक सामान्य समस्या को हल करें और इसे उप-सरणी संरचना पर कम निर्भर करें।

गम्बो के समाधान के विपरीत, आप उन मामलों में इसका पुन: उपयोग कर सकते हैं जहां मान उप-सरणियों में नहीं हैं। नीचे दिए गए उदाहरण में कल्पना करें $arr1और $arr2हार्ड-कोडेड नहीं हैं, लेकिन लूप के अंदर फ़ंक्शन को कॉल करने के परिणामस्वरूप वापस किया जा रहा है।

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

Answer 8

इसका उपयोग करके भी किया जा सकता है 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'));

पिछले समाधानों की तरह इतना पठनीय नहीं है लेकिन यह काम करता है :)

Answer 9

यहाँ एक संस्करण है जहाँ सरणी कुंजियाँ दोनों सरणियों के लिए समान नहीं हो सकती हैं, लेकिन आप उन सभी को अंतिम सरणी में रखना चाहते हैं।

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

Answer 10

अगर सरणी कुंजी मौजूद है, तो हमें पहले जांच करने की आवश्यकता है।

कोड:

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

सरणी कुंजी सत्यापन के साथ परिणाम:

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

सरणी कुंजी सत्यापन के बिना परिणाम:

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
)

यह एक बुरा अभ्यास है, हालांकि यह आउटपुट प्रिंट करता है। हमेशा पहले जांचें कि क्या कुंजी मौजूद है।

Answer 11

उन लोगों के लिए जो यहां उतरे और एक ऐसे समाधान की तलाश कर रहे हैं जो एन सरणियों का विलय करता है और एन सरणियों में पाए जाने वाले समान कुंजी के मूल्यों को भी नामांकित करता है, मैंने यह फ़ंक्शन लिखा है जो पुनरावर्ती रूप से भी काम करता है। (देखें: https://gist.github.com/Nickology/f700e319cbafab5eaedc )

उदाहरण:

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

में परिणाम होगा:

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

)

यहाँ कोड है:

<?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 <[e-mail]>
 * @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;

}

?>

Answer 12

सरणी के प्रत्येक आइटम के माध्यम से जाओ और पिछले मूल्यों के योग मान यदि वे मौजूद हैं, तो बस मूल्य निर्दिष्ट न करें।

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

आउटपुट:

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

या बस प्रत्येक उप सरणी के माध्यम से लूप करें, और प्रत्येक कॉलम के मानों को समूहित करें। आखिरकार उन्हें सम्‍मिलित करें:

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

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

Answer 13

यहां आपके पास है कि मैं आमतौर पर इस तरह के ऑपरेशन कैसे करता हूं।

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

Comments

कृपया आप इस कोड का स्पष्टीकरण दे सकते हैं, और यह प्रश्न का उत्तर क्यों देता है? यह बिना किसी स्पष्टीकरण के सिर्फ एक कोड ब्लॉक को डंप करने से अधिक सहायक होगा।

— त्रिनकोट

बेशक!! क्षमा करें, मैं स्पेनिश हूं और मेरे लिए, एक प्रश्न का उत्तर देने पर कोड को समझा देना सबसे कठिन काम है! आपकी सलाह के लिए धन्यवाद @trincot

— लुइस गोंजालेज

Answer 14

आप यह कोशिश कर सकते हैं:

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

और अंत में:

print_r($c);

Comments

वास्तव में क्या आप के लिए उपयोग कर रहे हैं $aऔर $bजब आप कॉल array_map()? कृपया इस कोड को केवल उत्तर में सुधारें।

— मिकमैकुसा

Answer 15

यह मेरी लार्वा परियोजना पर बहुत अच्छा काम करता है

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

Comments

हालांकि यह आपके लारवेल प्रोजेक्ट के लिए काम कर सकता है, लेकिन यह इस सवाल का अच्छा / कारगर समाधान नहीं है।

— मिकमैकुसा

Answer 16

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

Comments

यह MANY वर्षों पहले के उत्तर का एक डुप्लिकेट है। stackoverflow.com/a/1496697/2943403 अपने स्वयं के पोस्ट करने से पहले कृपया सभी मौजूदा उत्तर पढ़ें ताकि एक ही पृष्ठ पर कोई अतिरेक न हो।

— मिकमैकुसा

Answer 17

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

`

Comments

कृपया समीक्षा करें कि मैं एक अच्छा उत्तर कैसे लिखूं । कोड-केवल उत्तर हतोत्साहित किए जाते हैं क्योंकि वे यह नहीं समझाते हैं कि वे प्रश्न में समस्या का समाधान कैसे करते हैं। आपको यह बताने के लिए अपने उत्तर को अपडेट करना चाहिए कि यह क्या करता है और 8 साल पुराने इस प्रश्न के कई उत्कीर्ण उत्तरों पर यह कैसे सुधार करता है।

— FluffKitten

मूल रूप से पहले के उत्तर की एक डुप्लिकेट: stackoverflow.com/a/20532196/2943403

— मिकमैकुसा

Answer 18

उदाहरण के लिए, आप नीचे दिए गए परिणाम की तरह से सभी फ़ील्ड्स को प्लक कर सकते हैं।

मैं एक सरणी से 'शेष' निकाल रहा हूं और एक चर पर सहेज रहा हूं

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

फिर अगली पंक्ति पर इस तरह से योग कर सकते हैं:

$sum =  $kii->sum(); 

आशा करता हूँ की ये काम करेगा।