Calcular la suma de una matriz 2D en JavaScript

Estoy tratando de resolver un problema simple: dada una matriz 2D de números enteros (una matriz hecha de matrices hechas de números enteros), calcule la suma de los números enteros. Por ejemplo, dada esta matriz 2D:

[
[1, 0, 0],
[1, 1, 0],
[1, 1, 1]
]

la salida sería 6.

Esto es lo que probé:

const array = [
[1, 0, 0],
[1, 1, 0],
[1, 1, 1]
]

const twoDsum = a => a.reduce( (r,x) => r + x.reduce( (s,y) => s + y) );

console.log(twoDsum(array));

Como puedes ver obtengo tres números enteros, lo cual para mí es una tontería.

También probé el siguiente código para descubrir qué estaba pasando, pero no lo entiendo

const array = [
[1, 0, 0],
[1, 1, 0],
[1, 1, 1]
]

// this function works as you can see from the logs
const sum = a => a.reduce( (r,x) => r + x );

for(let i = 0; i < array.length; i++) {

    console.log(sum(array[i]));
}

// I don't get why this doesn't
const twoDsum = a => a.reduce( (r,x) => r + sum(x) );

console.log(twoDsum(array));

1

a.reduce( (r,x) => r + sum(x) ) carece de su inivalor inicial 0, por lo tanto se utiliza [1, 0, 0]. Por lo tanto, la primera iteración realiza [1, 0, 0] + suma([1, 1, 0]), produciendo una cadena. Lea la documentación. Sugeriría proporcionar siempre un valor inicial.

- Sebastián Simón

27/03/2021 a las 23:15

------------------------------------

Asegúrese de proporcionar el valor inicial (el segundo argumento posicional) explícitamente como 0 para que la suma funcione. En caso contrario se utilizará el primer elemento que es [1,0,0], que se convertirá en una cadena 1,0,0:

Un valor para usar como primer argumento en la primera llamada de tél devuelve la llamada. Si no se proporciona un valor inicial, el primer elemento de la matriz se utilizará como valor acumulador inicial

Vea el ejemplo de trabajo aquí:

const array = [
  [1, 0, 0],
  [1, 1, 0],
  [1, 1, 1]
]

const twoDsum = a => a.reduce((r, x) => r + x.reduce((s, y) => s + y, 0), 0);

console.log(twoDsum(array));

1

1

Oh, supuse que el valor inicial habría sido 0, gracias por la explicación.

- otro

27/03/2021 a las 23:22

------------------------------------

Si solo estás intentando obtener la suma, ¿por qué no aplanar la matriz primero?

const arr = [
  [1, 0, 0],
  [1, 1, 0],
  [1, 1, 1]
]

const flatArr = arr.flat()

FlatArr ahora debería ser [1, 0, 0, 1, 1, 0, 1, 1, 1]

ahora deberías poder usar la reducción normal que esperarías usar

const sum = flatArr.reduce((acc, value) =>  acc += value, 0); 

la suma ahora debería ser 6

------------------------------------

Soy de la vieja escuela, así que solo escribiría un par de bucles. Súper fácil de codificar, funciona la primera vez sin depuración y creo que es la solución más fácil de entender:

const twoDsum = matrix => {
    let sum = 0;
    for( const row of matrix ) {
        for( const cell of row ) {
            sum += cell;
        }
    }
    return sum;
};

console.log(
    twoDsum(
        [
            [ 1, 0, 0 ],
            [ 1, 1, 0 ],
            [ 1, 1, 1 ]
        ]
    )
);

------------------------------------

En su lugar, puedes usar .flat() y usar la ecuación original.

const array = [
[1, 0, 0],
[1, 1, 0],
[1, 1, 1]
]

// this function works as you can see from the logs
const sum = a => a.reduce( (r,x) => r + x );

for(let i = 0; i < array.length; i++) {

    console.log(sum(array[i]));
}

// I don't get why this doesn't
const twoDsum = a => a.flat().reduce( (r,x) => r + x );

console.log(twoDsum(array));

------------------------------------

Yo sugeriría que en lugar de hacer la reducción dos veces, utilice primero el método plano:

const array = [
[1, 0, 0],
[1, 1, 0],
[1, 1, 1]
]

const twoDsum = a => a.flat().reduce((acc,val) => acc + val);

console.log(twoDsum(array));

------------------------------------

Puedes adoptar un enfoque recursivo y verificar el elemento si es una matriz.

const
   addArray = (s, v) => s + (Array.isArray(v) ? v.reduce(addArray, 0) : v),
   data = [[1, 0, 0], [1, 1, 0], [1, 1, 1]],
   sum = data.reduce(addArray, 0);

console.log(sum);

------------------------------------

-------------- ------------------

Usando Array.prototype.forEach().

const array = [
  [1, 0, 0],
  [1, 1, 0],
  [1, 1, 1],
];

const twoDsum = (a) => {
  let total = 0;
  a.forEach(arr => {
    arr.forEach(num => {
      total += num;
    });
  });
  return total
};

console.log(twoDsum(array));

Compártelo Seguir Respondido

28 de marzo de 2021 a las 14:22

usuario6386114

usuario6386114