I need function like this.

function sum(arr1, arr2) {
  return totalArray
};

sum([1,2,3,4], [5,6,7,8,9]) // [6,8,10,12,9]

I tried it this way:

var array1 = [1, 2, 3, 4];
var array2 = [5, 6, 7, 8, 100];
var sum = array1.map((num, idx) => num + array2[idx]); // [6,8,10,12]

I need function like this.

function sum(arr1, arr2) {
  return totalArray
};

sum([1,2,3,4], [5,6,7,8,9]) // [6,8,10,12,9]

I tried it this way:

var array1 = [1, 2, 3, 4];
var array2 = [5, 6, 7, 8, 100];
var sum = array1.map((num, idx) => num + array2[idx]); // [6,8,10,12]

• javascript

Share Improve this question Follow edited May 4, 2018 at 8:43 T.J. Crowder 1.1m200200 gold badges2k2k silver badges2k2k bronze badges asked May 4, 2018 at 8:35 user9703772user9703772 2

• I try this way. var array1 = [1,2,3,4]; var array2 = [5,6,7,8, 100]; var sum = array1.map( (num, idx) => num + array2[idx]); // [6,8,10,12] – user9703772 Commented May 4, 2018 at 8:38
• 2 @MarineKhloyan you should have put this in your question, along with what didn't work. The point is we want to help you fix your problems if you can't but we don't want to do the job in your place. If you fix your question please tell us so we reopen it. – Denys Séguret Commented May 4, 2018 at 8:39

Add a ment  | 

7 Answers 7

Sorted by: Reset to default 4

First you can get an array out of the function's arguments using Spread syntax (...), then sort it by array's length using Array.prototype.sort() and finally Array.prototype.reduce() to get the result array

Code:

const sum =(...arrays) => arrays
  .sort((a, b) => b.length - a.length)
  .reduce((a, c) => a.map((n, i) => n + (c[i] || 0)) || c)

// two arrays
const resultTwoArrays = sum([1, 2, 3, 4], [5, 6, 7, 8, 9])
console.log(resultTwoArrays) // [6, 8, 10, 12, 9]

// three arrays or more...
const resultThreeArrays = sum([1, 2, 3, 4], [5, 6, 7, 8, 9], [1, 2])
console.log(resultThreeArrays) // [7, 10, 10, 12, 9]

.as-console-wrapper { max-height: 100% !important; top: 0; }

At the risk of being unpopular due to using a loop:

function sum(arr1, arr2) {
    let totalArray = [];
    const totalLength =  Math.max(arr1.length, arr2.length);
    for (let i = 0; i < totalLength; i++) {
        totalArray[i] = (arr1[i] || 0) + (arr2[i] || 0);
    }
    return totalArray;
}

The || 0 handles the possibility the array doesn't have an entry at i, because if it doesn't, the result of arrX[i] is undefined, and undefined || 0 is 0.

I try this way.

 var array1 = [1, 2, 3, 4];
 var array2 = [5, 6, 7, 8, 100];
 var sum = array1.map((num, idx) => num + array2[idx]); // [6,8,10,12]

Very close, but map will stop at the end of array1, so you won't get the subsequent entries from array2. Just pick the longer of the two arrays, then handle the fact that the other array may not have an entry at arrayX[idx]. You can do that with the || 0 idiom:

function sum(array1, array2) {
  var a, b;
  if (array1.length > array2.length) {
    a = array1;
    b = array2;
  } else {
    a = array2;
    b = array1;
  }
  return a.map((num, idx) => num + (b[idx] || 0));
}

console.log(sum([1, 2, 3, 4], [5, 6, 7, 8, 100]));

Alternately, you can use the new (but polyfill-able) Array.from to create the result array and use the callback to build the entries:

function sum(array1, array2) {
  return Array.from(
    {length: Math.max(array1.length, array2.length)},
    (_, i) => (array1[i] || 0) + (array2[i] || 0)
  );
}

console.log(sum([1, 2, 3, 4], [5, 6, 7, 8, 100]));

Mosho's answer is wonderfully simple, though.

Find the long and short array according to length. Iterate the short array with Array.map(), and take the value from the long array. Then add the leftovers from the long array using Array.slice(), and Array.concat():

function sum(arr1, arr2) {
  const [l, s] = arr1.length >= arr2.length ? [arr1, arr2] : [arr2, arr1];
    
  return s.map((n, i) => n + l[i])
        .concat(l.slice(s.length));
};

console.log(sum([1,2,3,4], [5,6,7,8,9]));

Are we code golfing this? Here's a generator solution.

const summer = function*(a, b, i=0) {
  while(i < a.length || i < b.length) yield (a[i] || 0)  + (b[i++] || 0);
};
const sum = (a, b) => [...summer(a,b)];

console.log(sum([1,2,3,4], [5,6,7,8,9])) // [6,8,10,12,9]

You can have a custom logic something like this:

function sum(arr1, arr2) {
  var length, selectedArray, nonSelectedArray;
  if(arr1.length>arr2.length){
   length = arr1.length;
   selectedArray = arr2;
   nonSelectedArray = arr1;
  }else {
   length = arr2.length;
   selectedArray = arr1;
   nonSelectedArray = arr2;
  }
  var totalArray = [];
  for(var i=0; i<length; i++){
    if(selectedArray[i]){
      totalArray.push(selectedArray[i] + nonSelectedArray[i]);
    } else {
      totalArray.push(nonSelectedArray[i]);
    }
  }
  return totalArray
};

var res = sum([1,2,3,4], [5,6,7,8,9]);
console.log(res);

Try with map():

function sum(arr1, arr2) {
  var [a1, a2] = arr1.length > arr2.length ? [arr1, arr2] : [arr2, arr1]
  var totalArray = a1.map(function(i, idx){
    i = (i + a2[idx] || i + 0); 
    return i;
  })
  return totalArray;
};

console.log(sum([1,2,3,4], [5,6,7,8,9])) // [6,8,10,12,9]