Playground: calcula la suma total de elementos en un array

No suban las soluciones, le quitan la emocion a la vida jeje

Hola les comparto mi código, he sufrido mucho con la sintaxis de lo métodos al utilizar arrow functions. Les agradezco si me pueden recomendar literatura para terminar de entenderlo

function solution(numbers) {
	let suma = numbers.reduce((acumulador, item) => acumulador + item)
	return suma;
}; 
const array1 = [1, 1, 1];
const array2 = [2, 4, 8];
solution(array1);
console.log(suma);
solution(array2);
console.log(suma);

Algo simple y legible

function solution(numbers) {
return numbers.reduce( (a, b)  => a + b)
}; 

el output del ejemplo 2 deberia ser 14, no ? estas pequeñas cosas me confunden.

Mi desafío

function solution(numbers) {
 	return numbers.reduce((sum, i) => sum + i, 0)// Tu código aquí 👈 
}; 

function solution(numbers) {
	return numbers.reduce((prev, curr) => prev + curr, 0); //👈 
};

Me falto el valor inicial, corregido XD

export function calcSum(numbers) {
  return numbers.reduce((a, b) => a + b, 0)
}

Yo para no ver las respuestas pon esta sección en preguntas…
Aquí mi solución:

function solution(array){
 	return array.reduce((sum, item) => sum + item, 0);
};

function calcSum(array) {
  return array.reduce((sum, element) => sum + element, 0)
}

calcSum([1, 1, 1]);
calcSum([2, 4, 8]);
calcSum([]);

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

let valor = numbers.reduce((sum, item) => sum + item, 0)
console.log(valor)

😌

Solucion al reto

export function calcSum(numbers) {
  // Tu código aquí 👈
  if (numbers.length < 1) {
    return 0
  } else {
    return numbers.reduce((a, b) => {
      return a + b
    })
  }
}

Esta es otra manea que clases anteirores habia investigado para entenderel metodo reduce, y que en mi opinion personal, me parece mas intuitiva.

<
function solution(numbers) {
	return numbers.reduce((acc, item) => acc = acc + item);
}; > 

Donde, reduce recibe dos parametros, un valor que se estará acumulando, y el item que estará recibiendo del array;

entonces, el valor acumulador en el primer ciclo es igual a su mismo valor mas el item que se esta iterando en ese ciclo, entonces regresa el valor de acc.

Ahora acc es igual al mismo valor que ya tiene (del ciclo anterior) y es igual a su mismo valor mas el item que esta recibiendo en ese cicilo.

espero les ayude de algo.

Suma de arrays con reduce, dos parametros con arrow function sum + num con 0 que es el estado inicial.

reto

export function calcSum(numbers) {
  // Tu código aquí 👈
  const sum = numbers.reduce((contador, number) => {
    return contador + number
  }, 0)

  return sum
}

Mi solución

export function calcSum(numbers) {
  return numbers.reduce((acc, cur) => acc + cur, 0)
}

export function calcSum(numbers) {
  return numbers.reduce((sum, item) => sum + item, 0
  )}

export function calcSum(numbers) {
  return numbers.reduce((sum, item) => sum += item,0)
}

Me salía error si usaba llaves en el cuerpo de la arrow function:

Mi aporte 😃

return numbers.reduce((sum,element) => sum + element,0);

Esta es mi solución del reto en una sola línea 👍

Acá pueden probar el código:

export function calcSum(numbers) {
  return numbers.reduce((sum, item) => sum + item, 0);
}

Aqui mi solucion

export function calcSum(numbers) {

return numbers.reduce((a, b) => a + b, 0)

}

export function calcSum(numbers) {
const sumNumbers=numbers.reduce((sum,item)=>sum + item, 0);
return console.log(sumNumbers);
}

.
.
.
.
.
.
.
.
.
.

export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((sum,item) =>item +sum,0)
}

Mi solución al reto:

export function calcSum(numbers) {
  return numbers.reduce((acumulator, suma) => acumulator + suma, 0)
};

SOLUCION

export function calcSum(numbers) {
  // Tu código aquí 👈
  const solucion = numbers.reduce((sum, element) => sum + element, 0);
  return solucion;
}

Me doy cuanta que hay muhcas formas simpremente pude aver echo un return sin aver escribido la cost solucion

export function calcSum(numbers) {
// Tu código aquí 👈
return numbers.reduce((sum, item) => sum + item, 0);
}

export function calcSum(numbers) {
  return numbers.reduce((sum, num) => sum + num,0)
}

Aquí una versión sin usar arrow function. Para poder manejar bien los métodos que ofrecen los arrays, hay que comprender qué parametros tienen definidos, por ejemplo, en el caso de array.reduce() (en este ejemplo), recibe una función (a la cual, a su vez, le entrega dos argumentos: el acumulado ‘total’, y el ‘item’ iterado), y recibe el valor inicial del acumulador (‘0’ en este caso).

// Usando una función con nombre 'sumarTodo()'
export function calcSum(numbers) {
  return numbers.reduce(function sumarTodo(total, item) {
    return total += item;
  }, 0)
}

// Usando una función anonima
export function calcSum(numbers) {
  return numbers.reduce(function(total, item) {
    return total += item;
  }, 0)
}

// Usando arrow function en bloque
export function calcSum(numbers) {
  return numbers.reduce((total, item) => {
    return total += item;
  }, 0)
}

// Usando arrow function de una sola linea
export function calcSum(numbers) {
  return numbers.reduce((total, item) => total += item, 0)
}

mi solucion 😁✌

export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((sum, item) => {
    return sum + item
  }, 0);
}

Mi solución:

export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((suma, number) => suma + number, 0);
}

A sigle line:

return numbers.reduce((sum, number) => sum + number, 0)

Mi solución:

export function calcSum(numbers) {
  return numbers.reduce((sum, item) => sum += item,0)
}

Mi solución al reto:

export function calcSum(numbers) {
  if (numbers.length == 0) {
    return 0;
  }
  return numbers.reduce((total, num) => total + num, 0);
}

Resultado

 let numbers = [1,2,3,4]


export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((sum, item) => {
    return sum += item
  }, 0)
}

console.log(calcSum(numbers))

Código JavaScript:

function calcSum(ary) {
  let rslt = 0;
  if( Array.isArray(ary) && ary.length>0 ) {
    rslt = ary.reduce((a, b) => a + b);
  }
  return rslt;
}
console.log('numbers:', '-');
console.log('result1:', calcSum('-'));
console.log('numbers:', []);
console.log('result1:', calcSum([]));
console.log('numbers:', [1,2,3,4,]);
console.log('result1:', calcSum([1,2,3,4,]));

export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((suma,item) => suma+= item,0)
}

Comparto mi solución 😄.

export function calcSum(numbers) {
  if (numbers.length != 0) {
    return numbers.reduce((acc, current, index) => {
      return acc = current + acc;
    }, 0); 
  } else { 
    return 0;
  }
}

.
.
.
.
.
.
.
.
.
.
.
.
.

function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((acum, num) => acum + num, 0);
}

export function calcSum(numbers) {
  return numbers.reduce((acc, number) => acc + number, 0);
}

export function calcSum(numbers) {
  return numbers.reduce((numero, accum) => accum + numero, 0)
}

En el ejemplo 2, el Output debería decir 14, no?

Solución

export function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((sum, elem) => sum + elem, 0);
}

function calcSum(numbers) {
  // Tu código aquí 👈
  return numbers.reduce((acum, item) => acum + item, 0);
}

Como siempre. Solución en una sola línea.

export const calcSum = (numbers) => numbers.reduce((acc, cur) => acc + cur, 0)

mi solucion

export function calcSum(numbers) {
  return numbers.reduce((curr, acc) =>(curr + acc),0)
}

Mi solución:

export function calcSum(numbers) {
  return numbers.reduce((sum, num) => sum + num, 0);
}

export function calcSum(numbers) {
  return numbers.reduce((sum, num) => sum += num, 0)
}

Simple y efectivo

export function calcSum(numbers) {
  if (numbers != 0) return numbers.reduce((sum, num) => sum += num)
 return 0
}

Me fata practica e incluso creó que me falta tener más claro los conceptos del scope que ya habia dado por setandos, estos ejercicio si te ponen a pensar, recordar y relacionar clases e incluso cursos previos.

export function calcSum(numbers) {

    let rta = numbers.reduce((acumulador, number) => {
       return acumulador = acumulador + number;  
    }, 0)
    return rta;
}

<code> 

Esta es mi solución

export function calcSum(numbers) {
  return numbers.reduce((obj, numbers) => {
     return obj + numbers
  }, 0)
}

Mi desafio

export function calcSum(numbers) {
  return numbers.reduce((acumulator, number) => {
    acumulator += number
    return acumulator;
  },0)
}

No se olviden de inicializar el acumulador en 0!!!

export function calcSum(numbers) {
  return numbers.reduce((acc, item) => acc + item, 0)
}

ez

export function calcSum(numbers) {
  return numbers.reduce((a, b) => a + b, 0)
}

export function calcSum(numbers) {
  return numbers.reduce((obj, element) => obj + element, 0);
}

Consejo para los que no quieran ver las soluciones:

• Hagan pruebas en su Editor preferido 😛

<const solution = [1, 1, 1];
const solution1 = [2, 4, 8];

const rta3 = solution.reduce((sum, element) => sum + element, 0);
console.log('rta3', rta3);

const rta4 = solution1.reduce((sum, element) => sum + element, 0);
console.log('rta4', rta4);> 

Mi aporte:

const nums1 = [1, 1, 1];
const nums2 = [2, 4, 8];

const sum1 = nums1.reduce((sum, element) => sum + element, 0);
console.log('Sum 1:', sum1);

const sum2 = nums2.reduce((sum, element) => sum + element, 0);
console.log('Sum 2:', sum2);

Me salió a la primera! No me lo esperaba. jaja

function solution(numbers) {
return numbers.reduce((sumar, elemento) => sumar + elemento,0)
};

Esta fue mi solución del reto, cabe aclarar que ya tenia formulada la solución solo que “a” y “b” los tenia con otros nombres y por esa razón me salía que estaba mal jummm

function solution(numbers) {
 	// Tu código aquí 👈 
	return numbers.reduce((a, b) => a + b, 0);
}; 

Acá esta el reto realizado 😃

function solution(numbers) {
	return numbers.reduce((sum, element) => sum + element, 0);
};

solution([1, 1, 1]);
solution([2, 4, 8]);

const numbers = [1, 2, 3, 4];
function solution(numbers) {
  const respuesta = numbers.reduce((sum, item) => item + sum, 0);
  console.log(respuesta);
  return respuesta;
}
solution(numbers);

Reto Sumar números de un array, hecho.

let numeros = [1, 2, 3, 4, 5, 6, 7];
const resultado = numeros.reduce((suma, item) => suma + item, 0);
console.log("resultado", resultado);

function solution(numbers) {
// Tu código aquí 👈
let result = 0;
for (let i = 0; i > numbers.length; i++){
const ele = numbers[i];
result = result + ele;
}return result
};

Reto

function solution(numbers) {
	return numbers.reduce((sum, item) => sum + item, 0);
}; 

const result = solution([1, 1, 1]);
console.log(result);

<function solution(numbers){
    const sumatoria = numbers.reduce((sum=0, item) => {
        return sum + item;
    });
    return sumatoria();    
}

sumatoria([1, 1, 1]);
sumatoria([2, 4, 8]);> 

function solution(numbers) {
 	// Tu código aquí 👈 
	const result = numbers.reduce((sum, num) => sum + num, 0);
	return result
}; 

const solution = array => array.reduce((acc, item) => acc + item)

solution([-1000, 100, 10])

Comparto mi solución al reto:

function solution(numbers) {
 	return numbers.reduce((acc, cur) => acc + cur, 0)
};

en visual studio, logro optener el serultado con estos dos codigo.

const solution = [1, 1, 1];
const solution2 = [2, 4, 8];

const res = 
solution.reduce((sum,item) => sum+item, 0 );
console.log(res);
let sum = 0;
for (let i = 0; i < solution2.length; i++) {
  const element = solution2[i];
  sum = sum +element; 
}
console.log(sum);