Método reduce

robado

Qué buena idea!. Hacer estos cursos para programar y hacer matemáticas a la vez.

Ya que nos pusimos en contexto con las Arrow Functions, aquí está mi solución

const esPar = (lista) => lista.length % 2 ? false : true;

A mi me gusta el método reduce 😃

Hay dias que siento que no aprendo aunque este sentado todo el dia frente al pc, como hay otros dias que siento que aprendo mucho y hoy es uno de los dias que siento que aprendi, se que son cosas sencillas pero todos iniciamos asi.

Comparto mi codigo

Calcular si un numero es par en un array

let numeros = [1,2,3,4,5,6,7,8,9,10];

let calcular = function(numeros){
    for(let i = 0; i < numeros.length; i++){
        if (numeros[i] % 2 == 0){
            alert('El numero ' + numeros[i] + ' es par.');
        }
    }
}
calcular(numeros);

Entender el método reduce me resultó muy confuso, y aunque creo que Juan explica muy bien tuve que recurrir a tutoriales de YT para entender este concepto mejor.

Recomiendo al 100% el video de HolaMundo para entenderlo de otra manera, además ahí puedes ver un par de ejemplos de uso en la vida real.

Programación funcional en JavaScript, parte 3: Array Reduce

Para saber si es par

const isPair = arr => arr.length % 2 ? false : true;
isPair(list); // Llamarlo

Este es mi aporte para hallar el promedio

function average(array){
    console.log('Los datos que ingreso fueron: ',array)
    const suma= array.reduce((sum,item)=>item+sum,0);
    averageResult=suma/(array.length)
    console.log('el promedio es: ',averageResult)
}
average([1,2,3,4,5]);

Aquí dejo mi aporte. Me apoye en la documentación para profundizar.

function calculateAverage(list){
    let initialValue = 0;

    let addInitial = list.reduce((accumulator, currentValue) => accumulator + currentValue, initialValue)

    const average = addInitial / list.length;
    console.log(average);
}

Para saber si el array contiene un numero par de elementos yo lo haría así:

const array1 = [4, 5, 1, 9];
let isPar = true;

if (array1.length % 2 === 0) {
  isPar = true;
} else {
  isPar = false;
}

Calcular si un numero es par en un Array

//si es par retornar true si no retornar false
let Lista = [1,2,3,4];

function esPar (Lista){
    if (Lista.length % 2 === 0){
        return true;
        }else {
            return false;
        }
    }

    console.log(esPar(Lista));

Estoy escribiendo todo en ingles, ya que es el estandar. Por ejemplo para sumarTodosElementos, utilizo elementsSum. Al final coger la costumbre de escribir y leer en ingles se hace costumbre hasta el punto de que hacerlo en espanol se convierte en lo “raro”

function siEsPar(numero) {
if (numero % 2 == 0) {
return true
}else{
return false
}
}

UFF

Si hubiera visto esto en mis primeros días estudiando JS pensaría que es magia negra.

const isEven = array => array.length % 2 == 0 ? true : false
isEven(numbers)

Al final el código quedo recortito:

const numbers = [1, 2, 3, 4, 5]

function average(array) {
    const sum = array.reduce((a, b) => a+ b)
    return sum / array.length
}
average(numbers) // 3

Para los que se pregunta sobre el signo " ? " es que nuestros compañeros están usando algo llamado Operador condicional (ternario)

Operador condicional (ternario)

Interesante como ayuda este método, no nos metas miedo profe…estuvo fácil 😅. Cumpliré el contrato firmado en la primera clase.

Aquí la comparación de las dos formas vistas para hallar el promedio:

RETO CUMPLIDO:

CON OPERADOR TERNARIO:

function TieneCantidadPar(array){
    if(array.length % 2 === 0){
        console.log('El array es par')
    }else{
        console.log('El array no es par')
    }
}

RETO para determinar si un array es PAR o IMPAR

Código para saber si la cantidad de elementos de un array es par o inpar:

function pairOrImpair(list) {
    const isPair = list.length % 2 == 0 ? console.log("is pair") : console.log("is not pair");
};

Mi aporte en reduce

const sumarLista = (...arraysuma)=>{
    const sumar = arraysuma.reduce(reducesuma = (valoracomulado,valornuevo)=>{
        return valoracomulado + valornuevo;
    })
    const promedio = sumar / arraysuma.length;
    console.log(promedio);
    return(promedio);
}
sumarLista(100,200,300);

Mi solución

const promedio = (array) =>{
    let suma= array.reduce((acum, x) => acum + x);

    let prom = suma / array.length;

    return  prom.toFixed(2);
}

Habrán cálculos que nos darán muchos decimales, podemos usar el método de javascript toFixed(), para formatear el número y establecer cuántos decimales queremos.

Me encantó esta clase, me gusta cuando muestran las diferentes formas de hacer alguna función o simplemente escribir algún código de distintas maneras.
Estoy aprendiendo un montón de este curso…

Gracias Juan!! Justo tenia muchas dudas con las arrow functions

Este codigo me ayudo a entender el ejemplo de la clase;

  const arrSum = arr.reduce((a, b) => a + b);
  const promedio = arrSum / arr.length;
  return promedio;
} 

console.log(promedio([5,10,25,36,54]))

Este código verifica si el numero de elementos de un arreglo es par o no

// recibe un arr y verifica que si es par
const esPar = (arr) => {
  return (arr.length % 2 === 0) ? "es par" : "No es par"
}
console.log(esPar([1,2,5,5,6,8]))

Bueno, aquí va mi aporte después de practicar muchas veces jejeje, para nada fue a la primera. Este en mi código javascript

// Preparación clase 14. Calcular lista par/impar

function esListaPar(lista){
  return Boolean(!(lista.length % 2))
};

function esListaImpar(lista){
  return Boolean(lista.length % 2)
};

Wow de verdad me encanto esta clase, que excelente juan

Este es mi codigo para saber si es par o impar

const numeros = [ 80, 60, 40, 20, 100]
//Uso filter (que es un filtro en arreglo) para obtener solo los números que 
// tengan residuo 0.

function parOinpar(arr){
    const impares = arr.filter( x => x%2 === 0).length
    // el operador % muestra el resultado de dividendo cuando es dividio por divisor, en este caso el dividento es el elemento del array que traemos y el divisor podemos pedir que divida la mitad hasta que no se pueda mas, si el residuo es mas que 0, no es un numero par.

    console.log(impares)
    if(impares > 0){
        console.log('Pares. Exactamente son ' + impares)
        return true
    }else if (impares == 0){
        console.log('Todos Impares')
        return false
    }
}

MI solución.

let array2 =[1,2,3,4,5,6,7,8,9,10];

let redondear = Math.round((array2.length / 2)) ;
let cantidadDeArray = array2.length;

console.log(cantidadDeArray/redondear)

parOinpar = () => { 
  if (cantidadDeArray/redondear == 2 ){
   console.log ("par");
  }else{
      console.log("inpar");
  }



};

parOinpar();

Una solución corta al reto de validar si el tamaño del array es par o impar;

function parImpar(array) {
    return (array.length % 2 == 0) ? 'par' : 'impar';
}

function esPar(arr){
  if(arr.length%2==0){
return true;
}else{
return false}
}

ListaN = [4,4,6];
function calcularnumeros(Lista){
    const sumarlista = Lista.reduce((a, b) => a+b);

    let comprobante = sumarlista % 2;

    if(comprobante == 0){
        console.log('es par');
    }else{
        console.log('es impar');
    }
}

calcularnumeros(ListaN);

Aquí mi parte profesor :9 ❤️

function esPar(lista){
    for(let i = 0; i < lista.length; i++){
        reciduo = lista[i] % 2;
        if(reciduo == 0){
            console.log(`El número ${lista[i]} es par`);
        } else {
            console.log(`El número ${lista[i]} es inpar`);
        }
    }
}

esPar([4,1,5,734,35,74,24,52,63]);

Aunque en este caso no haría falta, ya que podemos utilizar de forma sencilla el array.length. El método reduce() también nos permite incluir un tercer parámetro que representaría el índice de nuestro array. Espero que esta peculiaridad no les complique entender este método, pero me ha parecido interesante compartirlo con ustedes.

Aquí les dejo el reto, utilizando esta peculiaridad del tercer parámetro:

const numeros = [50,50,20];
let indiceArray = 0;

function saberSiElArrayEsParOImpar() {
  const resultado = numeros.reduce((valorPrevio,valorActual, indice) => {
    indiceArray = indice;
    return valorPrevio + valorActual;
  });

  const promedio = resultado / indiceArray;

  if(promedio % 2 === 0) {
    console.log('Es PAR!');
  } else {
    console.log('Es IMPAR!')
  }

}

PD: Lo ideal es que escribamos nuestro código en inglés. Pero a efectos prácticos y para ayudar a la comprensión, he compartido el reto en castellano para que pueda ayudar a aquellas personas que aún se les complique entender el método reduce().

Por si les sirve de guía, recibimos los valores desde un input separados por comas, para luego separar los valores a partir de las comas. Luego en el for son transformadas a número y agregadas a un array vacío, que luego va ser usado con el método reduce. Cualquier corrección o recomendación quedo pendiente. Muchas gracias.

const btnCalcReduce = document.querySelector('#btnCalcReduce');
const pResultReduce = document.querySelector('#pResultReduce');

btnCalcReduce.addEventListener('click', () => {            
            
	const inputListNum = document.querySelector('#listNumReduce').value;
	const listArray = inputListNum.split(',');
	const newArrayNumber = [];            
            
	for ( item of listArray ) {
		newArrayNumber.push(Number(item));
	};
            
	const sumaList = newArrayNumber.reduce( (acumulado, nuevoValor) => acumulado + nuevoValor );
	const promedio = sumaList / listArray.length;
	pResultReduce.innerText = `Promedio: ${promedio}`;
});

aca dejo mi solucion, haciendo pruebas note q no es necesario retornar explícitamente True o False, ya que el hecho de hacer una comparación retorna un tipo boleado

function esArrayPar(input) {
    return (input.length % 2 == 0);
}

Aquí dejo mi solucion

function calcularPar(lista){  
    if (lista.length%2 == 0) {
        return 'par';
    }
    return 'impar';
}

😀

//Una solución
function esPar(arr){
    if (arr.length % 2 === 0){return true;}
    else{return false;}
}

//otra solución
const isEven= (arr)=> arr.length%2 === 0 ? true : false;

Logrado!

JS

function esPar(lista) {
	if (lista.length % 2 === 0) {
		return true;
	} else {
		return false;
	}
}

esPar([1,5,6,7]) // true
esPar([1,5,6,7,9]) // false

Una forma reducida de cómo utilizar el reduce():

suma = lista.reduce((a, b) => a + b )

Con el método filter, te filtra los números pares:

let isPar = listaNum.filter(item => item % 2 == 0)

Aqui mi solución al reto…😃

Función para ver si un arreglo tiene cantidad par o impar de elementos:

function esArregloPar(arreglo){
   if(arreglo.length % 2 == 0){
        return ("Es par")
   } else{
        return ("Es impar")
   }
}

Reto 😄

// Función
const esPar = (arr) => (arr.length % 2 == 0) ? true : false;

// Pruebas

// Debe dar true
console.log([1, 15, 5, 5].length);
console.log(esPar([1, 15, 5, 5]));

// Debe dar true
console.log([].length);
console.log(esPar([]));

// Debe dar false
console.log([1, 2, 3].length);
console.log(esPar([1, 2, 3]));

// Debe dar false
console.log([0].length);
console.log(esPar([0]));

pos la hice así

function parInpar(lista) {
    const total = lista.length;

    if (total % 2 == 0) {
        console.log('la cantidad de elementos de la lista es par');
    } else {
        console.log('la cantidad de elementos de la lista es inpar');
    }
}

solucion si una lista es par o impar:

En este LINK de platzi busquen JS HERO ahy ejercicios para practicar Javascript. Esta genial!

Al utilizar el método reduce este recibe una función y esta función a su vez espera recibir unos parámetros:

valorAcumulado (guarda el ultimo valor sumado)
nuevoValor (Es cada elemento nuevo que va a sumarse al valorAcumulado)
.
Reduce busca recorrer el array, elemento por elemento. En orden. Y al final devolver un valor.

const listaPar = [1,2,3,4];
const listaImpar = [1,2,3,3];

function parImpar(lista) {
    const finalNum = lista.reduce((acum, val) => {
        return acum + val;
    });

    if(finalNum % 2 == 0) {
        console.log(`La lista es Par ${finalNum}`);
    } else if(finalNum % 2 != 0) {
        console.log(`La lista es Impar ${finalNum}`);
    } else {
        console.log(`Algo no esta bien`);
    }
}

parImpar(listaPar);
parImpar(listaImpar);

Mi solución al reto

Yo por mi parte no tenía claro si debíamos calcular que la longitud de elementos de una lista fuera par o impar o bien que si la suma de todos los elementos de una lista fuera par o impar, así que hice las dos cosas 🙂
Les dejo tanto enlace al código en mi repo de GitHub: https://github.com/robefernandez22/taller-math-js/tree/master/even-odd como a la página desplegada en GitHub Pages para que puedan probarlo: https://robefernandez22.github.io/taller-math-js/even-odd/

function parImpar(array) {
    if (array.length % 2 === 0) {
        console.log('ES UN NUMERO PAAAR!!')
    } else {
        console.log('ES UN NUMERO IMPAR')
    }
}

Fibonacci?

function calcularSiEsParOImpar(array) {
if (array.length % 2 == 0){
console.log(‘es par’);
} else {
console.log(‘es inpar’);
}
}

Orgulloso de mi mismo de que vi la locución bastante rápido🥺🥺 animo muchachos que si se puede!!

let arrayParImpar = [1,2,3,4,5,6,7,8]

function saberSiEsParOImpar() {
    if (arrayParImpar.length % 2 == 0) {
        console.log("es par")
    } else {
        console.log("es impar")
    }
}

saberSiEsParOImpar(arrayParImpar)

function parEimpar(lista){
  lista = lista.length % 2;
  if(lista == 0){
    console.log('es par')
  }else{
    console.log('no es par')
  }
}

Solución:

Les comparto mi solución del reto 😄 ❤️

Que bueno que hayan explicado las array functions! Es algo importantisimo para los cursos que vienen de aqui en adelante! Estoy haciendo este nuevo curso y me ha gustado mucho que hayan tomado en cuenta nuestros comentarios ya que en el curso antiguo de scopes tuve mucho problema con eso. Estoy muy feliz porque cada clase ha sido oro puro!

Done! Empleando el operador de modulador (%) y arrow functions:

.
.
.

let numberArray = [1, 3, 6, 4, 3, 3, 6, 9, 2, 8, 7, 10];

let isEven = (array) => {
        let even;
        if (array.length % 2) {
            return even = 'Its odd';
        }else {
            return even = 'Its even';
        }
}

isEven(numberArray);

Esta es mi solución al reto, espero a alguien le sirva

function calcularParImpar(lista) {
    const result = lista.length % 2

    if (result == 1) {
        console.log('Array impar');
    } else {
        console.log('Array par');
    }
}

Mi aporte

function arrayEsImpar(miArray){
  return miArray.length % 2;
}

Acá mi solucion.

function parOimpar(lista) {
    if(lista.length % 2 === 0) {
        return true;
    }else {
        return false;
    }
}

reto solucionado

function listIsPar (arr) {
    if (arr.length % 2 == 0) {
        return true
    } else {
        return false
    }
}

Aqui mi aporte de par o impar:

function par(arr){

    let pares =0;
    let impares = 0;
    for(number of arr){
        if (number % 2 === 0) 
            { pares++; console.log('soy par');} 
        else 
            { impares++; console.log('soy impar'); } 
    }

    console.log({
        pares,
        impares
    });
}

Función para saber si una lista es par o impar. 🧑‍💻

<function esParOImpar(lista) {
    if (lista.length % 2 === 0) {
        return "La lista es par";
    } else {
        return "La lista es impar";
    }
}

// Ejemplo de uso:
const miLista = [1, 2, 3, 4, 5];
const resultado = esParOImpar(miLista);
console.log(resultado);> 

Hello!
Para determinar si un nuemero es primo, en programacion,
podemos utilizar el operador de modulo (%) se le conoce como porcentaje, pero este mismo sirve como modulo.
Sucede que si aplicamos n (un numero cualquiera) a modulo 2, si el numero es par, obtendremos un 0, y si el numero es impar, obtendremos un 1.
Aqui el problema resuleto:

function numeroPrimo(n){
    if(n%2==0)
        return 'Par';
    else if(n%2!=0)
        return 'Impar';    
}

let list = [1,5,8,7,9];

console.log(numeroPrimo(list.length));

En mi aporte se ven ambos casos

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

//let sumaArray = 0;

function promedio(datos) {
  //* Con ciclos
  // for (let i = 0; i < datos.length; i++) {
  //   sumaArray += datos[i];
  // }
  //* Con reduce
  const sumaLista = datos.reduce((acumulador, valorNuevo) => {
    return acumulador + valorNuevo;
  });

  const resultado = sumaLista / datos.length;
  console.log(resultado);
}

Una forma corta de determinar si es par. Les explico como se leería, variable isPar es igual al resultado de la pregunta: ¿Si el residuo del tamaño de la lista entre 2 es igual a 0, entonces isPar= “Es par”, si no, isPar= “No es par”.

const isPar = list.length % 2 == 0 ? "Es par" : "No es par";

El signo “?” se le conoce como operador ternario y puede sustituir un '“if”.

podemos acortar el código con un arrow function, les dejo mi código de ejemplo

const list = [3,2,5,8,9,4,5];

const sumaLista = list.reduce((valorAcumulado, nuevoValor) => valorAcumulado + nuevoValor);
console.log(sumaLista/list.length);

Mi función para el reto del final de la clase.

Function verificarArrayPar(array){
    if (Number.isInteger(array.length/2)){
        return "Número de elementos en array par";}
    else {
        return "Número de elementos en array impar"
    }
}

Esta es mi solución para comprobar si una lista es par.

// Comprobar que un la cantidad de elementos de un array es par

let lista = [1, 2, 3, 6, 5, 4, 8, 4];

function compruebaNumeroParImpar(lista) {
    const result = (lista.length % 2) === 0 ? 'El número es PAR' : 'El número es Impar';
    console.log(result);
}

compruebaNumeroParImpar(lista);

function solution(obj) {
  const array = Object.entries(obj).map(([id, name]) => { return { id, name }; });
  return array;
}

para que entiendas un poco mas como funcionan las Arrow Functions …
https://platzi.com/clases/3504-ecmascript-6/51753-let-y-const-y-arrow-functions/

Aquí mi solución con las arrow functions:

let esPar = (array) => array.length % 2 === 0;

Asi quedo mi codigo:

const listaPar = (numberList) => {
  if (numberList.length % 2 == 0) {
    console.log("Esta lista es par");
  } else {
    console.log("Esta lista es impar");
  }
}

console.log(listaPar);

Por acá el ejercicio

const esPar=elem=>elem.length % 2 === 0 ? true : false;

esPar([1,2,3,4])

Asi lo resolvi yo, lo hize con el operador que da el residuo de una division:

const arrayParorImpar = array => {
    let operacion = array.length % 2;
    if (operacion === 0){
        return console.log("El array es par");
    } else {
        return console.log("El array es impar")
    }
};

arrayParorImpar([1,2,3,4])

Determinar par o impar

Usando el .reduce y las arrow functions , aumente solo la división para sacar el promedio.-

Código para saber si el array es par o no ✍🏻

const arrayIsEven = (array) => array.length % 2 === 0;

Yo lo hice de tres maneras,

• Forma mas corta:

1. hacemos uso de Arrowfunctions y operador ternario, donde como parámetro recibimos una lista

2. Creamos una variable que contenga toda la validacion que es, si el residuo de la longitud de la lista es == 0 ( ? ), retonar true de lo contrario ( : ) false

Info de operador ternario
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Conditional_Operator

let  par = (lista) => {
    const par_Impar = ((lista.length % 2) == 0) ? true : false;
    return par_Impar
};

• Haciendo recorrido con bucle for, luego validamos que numeros del recorrido es par y e impar y que los imprima

let calcularNumParesYImpares = (lista) => {
    for(let i=0; i < lista.length; i++){
        if(lista[i] % 2 == 0){
            console.log("el numero " + lista[i] + " es par");
        }else{
            console.log("el numero " + lista[i] + " No es Impar");
        }
    }
}

• Hacemos una validacion, donde el residuo (%) de la longituid de la lista sea igual == 0, que nos retorne true, de lo contrario que nos retorne false

let ParOImpar = (lista) => {
    if((lista.length % 2) == 0){
        return true;
    }else{
        return false;
    }
}

Así lo solucione Yo para mostrar los números impares, en clases anteriores me dio curiosidad los métodos y los investigue y cuando puso el reto sabia que con este método se podía hacer

function MostrarImpares(lista) {


    const impares = lista.filter(lista => lista % 2 == !0);
    return impares
    
}

Lo hice de la siguiente forma

const datos = [425,325,500,675,780,900];

function detectarPar() {
    return datos.length % 2 == 0 ? true : false; 
}

Suena potente el método reduce, pero no me quedó muy claro, tocará investigar más 😛

Mi solucion

function arrPar(arr){
  const SumaArr = arr.reduce((a,b) => a+= b);
  
  const Par = (SumaArr % 2 == 0) ? 'Es par': 'Es impar';
  
  return Par
}

Así he reducido yo el ejercicio de la clase

const list =[5,5,5,522];
sacarPromedio(list);
function sacarPromedio(promedio){
    const suma = promedio.reduce((valorAcumulado, valorNuevo) => valorAcumulado + valorNuevo)
    console.log(suma / list.length);
}

function ArrayParImpar (lista){

    let b = 0;
    for (let i = 0; i < lista.length; i++) {
        b = b + 1;
    }
    b = b % 2;
    if (b == 0) {
        console.log("par");
    } else {
        console.log("impar");
    }
}

Para saber si la longitud del array es par o impar, se me ocurrió lo siguiente:

const isPar = lista.reduce((a, b, i) => (Number(i) % 2 == 1 ? true : false));

Aplicación de método REDUCE( ) para la suma de elementos de un ARREGLO - FORMA 5

__

• Esta declararemos la función dentro de REDUCE
  
  
  
  

Explicación de uso de método REDUCE( ) para la suma de elementos de un ARREGLO - FORMA 4

__

El resultado obtenido es el mimo que en las formas anteriores