No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Playground: calcula la suma total de elementos en un array

12/28

Aportes 80

Preguntas 3

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Algo simple y legible


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

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);

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); //馃憟 
};

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.

```js export function calcSum(numbers) { return numbers.reduce((acc, number) => acc + number, 0) } ```
Mi soluci贸n: ```js export function calcSum(numbers) { return numbers.reduce((suma,elem)=>{ return suma += elem},0); } ``` Aunque vi que se puede simplificar m谩s.
**Mi soluci贸n** ```js export function calcSum(numbers) { return numbers.reduce((acc, item) =>acc + item,0 ) } ```
Mi soluci贸n usando ciclo for 馃捇 馃懆鈥嶐煉: ```js export function calcSum(numbers) { let result = 0 for (let i = 0; i < numbers.length; i++){ result = result + numbers[i] } return result } ```
mi aporte: export function calcSum(numbers) {聽 // Tu c贸digo aqu铆 馃憟聽 return numbers.reduce((index, acum)=> index + acum, 0)} ```js export function calcSum(numbers) { // Tu c贸digo aqu铆 馃憟 return numbers.reduce((index, acum)=> index + acum, 0) } ```
aqui esta mi solucion sin el uso de reduce () `<````js let result = 0; let valueIteracion = false ; [...numbers].forEach((number) => { if (valueIteracion == false) { valueIteracion = true; result = number; } else { result += number } }); return result; ```` let result = 0;` ` let valueIteracion = false ;` ` [...numbers].forEach((number) => {` ` if (valueIteracion == false) {` ` valueIteracion = true;` ` result = number;` ` } else {` ` result += number ` ` }` ` });` ` return result;>`
decidi solucionarlo sin el uso de reduce () , y esta es mi solucion , que les parece ? ` let result = 0;` ` let valueIteracion = false ;` ` [...numbers].forEach((number) => {` ` if (valueIteracion == false) {` ` valueIteracion = true;` ` result = number;` ` } else {` ` result += number ` ` }` ` });` ` return result;`
Spoilers . . . . . . . . . . . . . . . . . . . . . . . . . . . ```js export function calcSum(numbers) { return numbers.reduce((a, b) => a + b, 0) } ```export function calcSum(numbers) {聽 return numbers.reduce((a, b) => a + b, 0)}

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)
}

Hola aqui una version con una arrow function ```js const calcSum = (numbers) => numbers.reduce((prev, increment) => prev + increment, 0); export { calcSum } ```
```js //COMPARTO MI SOLUCI脫N export function calcSum(numbers) { const rta = numbers.reduce((sum, element) => sum + element, 0); return rta // Tu c贸digo aqu铆 馃憟 } ```

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 鈥榯otal鈥, y el 鈥榠tem鈥 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 鈥渁鈥 y 鈥渂鈥 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);
undefined