Simple math using arrays
I’m messing around with JavaScript and am trying out objects, functions & arrays. I’d like to know if someone has tips about making it better, shorter, or has a better solution for what I have thought about for now. What I’ve tried to do is just do simple math (+ and -) using arrays as input for numbers. It all works, but I’m just wondering if it could be even better and/or cleaner.
//Write the result function ap(n) < $(".value").append(n); >// Make sure the input is a number function isNumber(n) < return !isNaN(parseFloat(n)) && isFinite(n); >function doMath(options) < var defaults = < method: 'add' >; var options = $.extend(<>, defaults, options); // Add if(options.method == 'add') < var n = 0; for(var i=0; iif(i===options.numbers.length-1) < ap(n); >> > // Subtract if(options.method == 'subtract' ) < for (var i=0; ielse < if(isNumber(options.numbers[i])) < n = n - options.numbers[i]; >> if(i===options.numbers.length-1) < ap(n); >> > > //Print the result doMath(); 3 Answers 3
You should avoid mixing calculations with input/output. It would be better if your doMath() would not call the output function ap() directly, but instead would just return the result of its calculations:
Of course the ap itself is a lousy name for a function, but it’s more of a helper in here I guess.
I see no reason why you would use and options object instead of passing in just two parameters, but even when you use an options object, it would be simpler to extract its values into local variables and work with these. One can also easily drop the use of $.extend in favor of simple || operator, which is the canonical way of implementing default values for parameters:
var method = options.method || "add"; var numbers = options.numbers; Another step to simplify code is to filter out the invalid numbers before doing any calculations on them. Array.filter helps us here:
var validNumbers = numbers.filter(isNumber); The actual calculation can be easily implemented with Array.reduce . First we can define functions add and subtract
var methods = < add: function(a, b) < return a + b; >, subtract: function(a, b) < return a - b; >>; And then using Array.reduce we can apply them for the whole array:
validNumbers.reduce(methods.add); // or validNumbers.reduce(methods.subtract); function doMath(options) < var method = options.method || "add"; var numbers = options.numbers; var validNumbers = numbers.filter(isNumber); var methods = < add: function(a, b) < return a + b; >, subtract: function(a, b) < return a - b; >>; return validNumbers.reduce(methods[method]); > JavaScript Arrays and loops math
I need to find the sum of the elements in the array ends. Also I need to find the middle number of the array elements, if the list of elements is odd display the middle number. If the list of elements is even I need the average of the two middle numbers. I’ve been at it for a long time and I just can’t think anymore.
Array list: 10, 20, 30, 40, 50
Click the compute function button to return the sum of the first and last values in the array list.
It will also return the average of the two middle elements of the array list.
Sum two arrays in single iteration
I want to sum each value of an array of numbers with its corresponding value in a different array of numbers, and I want to do this without looping through each individual value. So:
var array1 = [1,2,3,4]; var array2 = [5,6,7,8]; var sum = [6,8,10,12]; There are no array math operations built into the language that will do this for you. Write yourself a little function to do it and just call that function whenever you need it.
17 Answers 17
I know this is an old question but I was just discussing this with someone and we came up with another solution. You still need a loop but you can accomplish this with the Array.prototype.map().
var array1 = [1,2,3,4]; var array2 = [5,6,7,8]; var sum = array1.map(function (num, idx) < return num + array2[idx]; >); // [6,8,10,12] @VladMiller That’s a good point. I didn’t realize at the time that JavaScript’s map() method actually gives you access to the index as well to get around that issue. I updated the code to reflect that.
if i have var array1 = [1,2,3,4,5] & array2 = [5,6,7,8] .. then the last integer 5 is not print. what should i do for that
Here is a generic solution for N arrays of possibly different lengths.
function sumArrays(. arrays) < const n = arrays.reduce((max, xs) =>Math.max(max, xs.length), 0); const result = Array.from(< length: n >); return result.map((_, i) => arrays.map(xs => xs[i] || 0).reduce((sum, x) => sum + x, 0)); > console.log(. sumArrays([0, 1, 2], [1, 2, 3, 4], [1, 2])); // 2 5 5 4To pass an array of arrays into sumArrays function, this is how I called this var arr = [[1,2,3,4],[1,2,3,4]]; console.log(. sumArrays(. arr)); // 2 4 6 8
var arr = [1,2,3,4]; var arr2 = [1,1,1,2]; var squares = arr.map((a, i) => a + arr2[i]); console.log(squares); How would you go about having two arrays nested as indices of another? like so . [[5, 2, 3], [2, 2, 3, 10, 6] ]
Below example will work even with length variation and few more use cases. check out. you can do prototyping as well if you needed.
function sumArray(a, b) < var c = []; for (var i = 0; i < Math.max(a.length, b.length); i++) < c.push((a[i] || 0) + (b[i] || 0)); >return c; > // First Use Case. var a = [1, 2, 3, 4]; var b = [1, 2, 3, 4]; console.log( sumArray(a, b) ); // Second Use Case with different Length. var a = [1, 2, 3, 4]; var b = [1, 2, 3, 4, 5]; console.log( sumArray(a, b) ); // Third Use Case with undefined values and invalid length. var a = [1, 2, 3, 4]; var b = []; b[1] = 2; b[3] = 4; b[9] = 9; console.log( sumArray(a, b) );your second use case is not working properly.. Giving me this result <1: 1, 10: 2, 11: 3, 20: 25: 30: 2>1: 1 10: 2 11: 3 20: 1 25: 3 30: 2
Just merge Popovich and twalters’s answer.
Array.prototype.SumArray = function (arr) < var sum = this.map(function (num, idx) < return num + arr[idx]; >); return sum; > var array1 = [1,2,3,4]; var array2 = [5,6,7,8]; var sum = array1.SumArray(array2); console.log(sum); // [6,8,10,12] For all of the beginners coming across this question who may not be at the level to use map / reduce or ternary operators..
let sum = 0; let nums = [] for (let i = 0; i < array1.length; i++)< sum = array1[i] + array2[i]; nums.push(sum) >return nums Welcome to Stack Overflow! Nice answer! You should consider registering an account to get access to more of Stack Overflow’s features.
You can’t avoid the loop, but you can do this once and add a function to all Array objects using Array.prototype .
// Add a SumArray method to all arrays by expanding the Array prototype(do this once in a general place) Array.prototype.SumArray = function (arr) < var sum = []; if (arr != null && this.length == arr.length) < for (var i = 0; i < arr.length; i++) < sum.push(this[i] + arr[i]); >> return sum; > // here's your code var array1 = [1, 2, 3, 4]; var array2 = [5, 6, 7, 8]; var sum = array1.SumArray(array2); console.log(sum); // [6,8,10,12] Another way to do it could be like that
var array1 = [1,2,3,4]; var array2 = [5,6,7,8]; var sum = [. array1].map((e,i)=> e+array2[i]); //[6,8,10,12] In this case [. array1] is the same to [1,2,3,4]
You can use the _.unzipWith method from the Lodash library.
var array1 = [1, 2, 3, 4]; var array2 = [5, 6, 7, 8]; var array = [array1, array2]; console.log(_.unzipWith(array, _.add));In ES6+, you can use arrow function to make the code clear:
var x = [1,2,3]; var y = [2,3,4]; var sum = x.map( (val, i) => val + y[i] ); console.log(sum); //Array [3, 5, 7] var z = [3,4,5]; var add3 = x.map( (val, i) => val + y[i] + z[i] ); console.log(add3); //Array [6, 9, 12] All the above mentioned answer is correct,
Using reduce. I just want to add my answer might be simple and useful.
var array1 = [1,2,3,4]; var array2 = [5,6,7,8]; const reducer = (accumulator, currentValue, index, array) => < let val = currentValue + array2[index]; accumulator.push(val); return accumulator; >console.log(array1.reduce(reducer, []));You can do it using some functional style:
const a = [1,2,3] const b = [4,5,6] const f= a.concat(b).map((v,i,arr)=>< if ( i).filter(n=>!isNaN(n)) console.log(f) This example will work with different length variation:
let getSum = (arr1, arr2) => < let main = arr1.length >= arr2.length ? arr1 : arr2; let sec = arr1.length < arr2.length ? arr1 : arr2; return main.map((elem, i) =>sec[i] ? elem + sec[i] : elem) > Generic solution for N arrays of possibly different lengths using functional programming in one line 😉
const sumArrays = as => as.filter(a => a.length).length ? [as.filter(a => a.length).reduce((r, a) => r + a.shift(), 0), . sumArrays(as)] : [] console.log(sumArrays([[1, 2, 3], [100], [11, 22, 33, 44], []]))
let array1=[]; let array2=[]; let array3=[]; let sum=0; // Take elements from the user for 1st Array for(let i=0; i console.log(array1); // Take elements from the user for 2nd Array for(let j=0; j console.log(array2); // add sum of two arrays in 3rd Array for(k=0; k console.log(array3);Your answer could be improved with additional supporting information. Please edit to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.
Note: This answer does NOT solve the issue in a single iteration.
Base Case Solution
You can split this issue into two separate issues.
- First we need to combine the elements of elements of the different arrays that are present on the same index. This is commonly called «zipping arrays». You’ll find a zip() methods in a lot of libraries, but can easily create your own.
const array1 = [1,2,3,4]; const array2 = [5,6,7,8]; zip(array1, array2) //=> [ [1,5], [2,6], [3,7], [4,7] ] If you aren’t using a library that has this included, you must define your own. A simple variant looks like this:
function zip(. arrays) < const length = Math.max(. arrays.map(array =>array.length)); return Array.from(< length >, (_, i) => arrays.map(array => array[i])); > numbers.reduce((sum, number) => sum + number, 0); It’s probably a good idea to store this in a new function definition. sum(numbers) is far more descriptive than the numbers.reduce(. ) line.
function sum(numbers) < return numbers.reduce((sum, number) =>sum + number, 0); > We now have all the building blocks to produce the desired result.
const result = zip(array1, array2).map(numbers => sum(numbers)); //=> [6, 8, 10, 12] // simplified const result = zip(array1, array2).map(sum); //=> [6, 8, 10, 12] The above combines array1 and array2 like shown in 1. Then we map() each of the resulting pairs to their sum.
const array1 = [1,2,3,4]; const array2 = [5,6,7,8]; const result = zip(array1, array2).map(sum); console.log(result); // helpers function zip(. arrays) < const length = Math.max(. arrays.map(array =>array.length)); return Array.from(< length >, (_, i) => arrays.map(array => array[i])); > function sum(numbers) < return numbers.reduce((sum, number) =>sum + number, 0); >More Arrays
This solution allows you to easily change the number of arrays.
const result = zip(array1, array2, array3, array4).map(sum); Non-Matching Array Lengths
Do note that it’s expected that all the arrays do have the same length. If the length doesn’t match the sum will result in NaN , since number + undefined = NaN
zip([1,2,3], [4,5], [6]) //=> [ [1,4,6], [2,5,undefined], [3,undefined,undefined] ] To solve this you could add another helper to remove «empty» values. For this we can introduce the compact() helper, which removes null and undefined values from the array.
function compact(array) < return array.filter(item =>item != null); // removes both `null` and `undefined` > zip([1,2,3], [4,5], [6]) // [ [1,4,6], [2,5, undefined], [3,undefined,undefined] ] .map(compact) // [ [1,4,6], [2,5], [3] ] .map(sum) // [ 11, 7, 3 ] const array1 = [1,2,3]; const array2 = [4,5]; const array3 = [6]; const result = zip(array1, array2, array3).map(compact).map(sum); console.log(result); // helpers function zip(. arrays) < const length = Math.max(. arrays.map(array =>array.length)); return Array.from(< length >, (_, i) => arrays.map(array => array[i])); > function sum(numbers) < return numbers.reduce((sum, number) =>sum + number, 0); > function compact(array) < return array.filter(item =>item != null); >