How to multiply n arrays of the same length with each other?

I want to multiply arrays of the same length. The total number of arrays (input.length) is known, but it can be everything between 0 and n.

const input = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
];

const output = [1, 16, 81, 256];
// 1*1*1*1, 2*2*2*2, 3*3*3*3, 4*4*4*4

I found solutions on SO for multiplying two arrays by mapping them against each other, but not for n arrays.

I am grateful for any hints.

If you want to multiply arrays, the best solution would be the Array#Reduce function

You here only need to introduce a function as I did with multiplyArray to handle how to compute to arrays together

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const input = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
];

const multiplyArray = (arr1, arr2) => {
  if(arr1.length !== arr2.length) {
    throw new Error('Array have not the same length');
  }
  
  arr1.forEach((elem, index) => {
    arr1[index] = elem * arr2[index]
  })
  
  return arr1
}

const output = input.reduce((acc, curr) => {
  if(acc === null) return curr
  
  return multiplyArray(acc, curr)
}, null)

console.log(output)

<!-- end snippet -->

You can use Array.prototype.map() combined with Array.prototype.reduce() and Array.prototype.every() to create a function multiplyAcrossArrays with validation to check length of sub-arrays

Code:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const input = [[1, 2, 3, 4],[1, 2, 3, 4],[1, 2, 3, 4],[1, 2, 3, 4]]

const multiplyAcrossArrays = (input) => {
  if (!input.every(subArray => subArray.length === input[0].length)) {
    throw new Error('All sub-arrays must have the same length')
  }

  return input[0].map((_, i) => input.reduce((a, c) => a * c[i], 1))
}

console.log(multiplyAcrossArrays(input))

<!-- end snippet -->

const input = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
]

const result = input.reduce((filtered, current) => {
  filtered.push(current.reduce((accumulator, currNum) => {
    accumulator.push(Math.pow(currNum, input.length))
    return accumulator
  }, []))

  return filtered
}, [])
    
console.log(result)

Depending on how often you'll need this type of behaviour, it might be worth the trouble to implement a general purpose transpose function. This switches rows and columns in the provided matrix. See the Wikipedia link for additional details.

function transpose(array) {
  if (!array.length) return [];

  const length = array[0].length;
  if (!array.every(item => Array.isArray(item) && item.length === length)) {
    throw new Error("not all elements are arrays or have the same length");
  }

  return array[0].map((_, index) => array.map(row => row[index]));
}

With this helper defined a solution would be as simple as transposing the matrix, then reducing each row to a single value by multiplying the values.

const output = transpose(input).map((row) => row.reduce((a, b) => a * b));
//=> [1, 16, 81, 256]

<!-- begin snippet: js hide: true console: true babel: false -->

<!-- language: lang-js -->

const input = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
];

const output = transpose(input).map((row) => row.reduce((a, b) => a * b));
console.log(output);

// helpers
function transpose(array) {
  if (!array.length) return [];

  const length = array[0].length;
  if (!array.every(item => Array.isArray(item) && item.length === length)) {
    throw new Error("not all elements are arrays or have the same length");
  }

  return array[0].map((_, index) => array.map(row => row[index]));
}

<!-- end snippet -->

If you don't feel like introducing the helper, I would probably still use a similar solution.

const output = input[0].map((_, index) => (
  input.map(row => row[index]).reduce((a, b) => a * b)
));
//=> [1, 16, 81, 256]

<!-- begin snippet: js hide: true console: true babel: false -->

<!-- language: lang-js -->

const input = [
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4],
  [1, 2, 3, 4]
];

const output = input[0].map((_, index) => (
  input.map(row => row[index]).reduce((a, b) => a * b)
));
console.log(output);

<!-- end snippet -->

Note that this answer assumes at least 1 row in input and assumes the correct data structure. If this is not always the case you might want to add additional data structure validation.