Contenido del curso
Playground - Encuentra al michi mas famoso
Leonardo de los angeles Espinoza Hernandez
Estudiante
Fernando García Guerrero
Estudiante
Santiago Ruiz
Estudiante
Miguel Angel Muñoz Pozos
Estudiante
Joan Soto
Estudiante
Alfonso Jose Romero Perdomo
Estudiante
Santiago Sabogal
Estudiante
Ronaldo Jiménez
Estudiante
Frandel Corporan Rodríguez
Estudiante
Carlos Leandro Miguel Latyn
Estudiante
Cristian Contreras
EstudianteCarlos Leandro Miguel Latyn
Estudiante
Abril Darynka Tapia Sosa
Estudiante
David Alejandro Lopez Sanchez
Estudiante
Eduardo Gutiérrez Contreras
Estudiante
Jhon sebastian Garzon cano
Estudiante
Gustavo Alonso Aguilar Acuña
Estudiante
Zajith Corro Viveros
Estudiante
Federico Guillermo Moreira Tejera
Estudiante
Osvaldo Martinez Guillen
Estudiante
Alexis Corrales
Estudiante
Jose Maldonado
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Cristian Romero
Estudiante
jorge vilchis
Estudiante
Nicolás Plaza
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Dante Mariani
EstudianteDante Mariani
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Cesar Francisco Zendejas Torres
Estudiante
Evelin Lorena Flores García
Estudiante
Andrés Soret Chacin
Estudiante
Sebastian David Exeni Cazón
Estudiante
EDGAR PINTO
Estudiante¡Hola Platzinauta!
🛡️🛡️🛡️Este es un escudo anti spoilers🛡️🛡️🛡️
. Como lo he mencionado en clases anteriores, este comentario tiene como propósito el que no te auto-spoiles con la soluciones de la comunidad (lo cual no tiene absolutamente NADA de malo el compartir tus soluciones) pero queremos que la comunidad tenga la mejor experiencia si es su primera vez en ejercicios de este estilo (sigan compartiendo soluciones alternativas y feedback pls). El otro propósito de este comentario es explicarte a detalle la solución del playground. . Pero antes, un gif random, bajo tu propio riesgo puedes ver la solución a este problema, si no lo deseas simplemente no des click en "Mostrar más" !michi .
Explicación
Ahora sí, vamos a explicarte la solución a este no tan sencillo problema
export function findFamousCats(cats) { // Creamos un objeto en el cual guardaremos los nombres // de los gatitos y el número máximo de seguidores let famousStats = { // El array de nombres empieza vacío catNames: [], // Y el número máximo de seguidores en 0 maxNumOfFollowers: 0, }; for (let i = 0; i < cats.length; i++) { // Iteramos por cada gatito recibido en el array const cat = cats[i]; // Obtenemos la suma total de seguidores con reduce const totalFollowers = cat.followers.reduce( (acum, currentVal) => acum + currentVal, 0 ); // comparamos si el total de followers del actual gatito es IGUAL // al del objeto que declaramos al inicio if (totalFollowers === famousStats.maxNumOfFollowers) { // De ser así, solo agregamos el nombre del gatito famousStats.catNames.push(cat.name); } // Por otro lado, si es MAYOR if (totalFollowers > famousStats.maxNumOfFollowers) { // Reiniciamos el array de nombres famousStats.catNames = []; // Agregamos a nuestro gatito influencer famousStats.catNames.push(cat.name); // Para al final asignar el número máximo de seguidores // a la debida propiedad del objeto famousStats.maxNumOfFollowers = totalFollowers; } } // Al final solo retornamos LOS NOMBRES return famousStats.catNames; }
. Y así es como ayudamos a los michis a no pelearse por ser influencers. . ¿Cómo resolviste tu este problema?
Linea anti spoiler + + + + + + + + + + + + + +
Ahora si en este punto me atore, pude lograr sin problemas el ejercicio del curso de Java Basico pero este no :'(
Mi pequeña solucion
export function findFamousCats(cats) { let maxFollowers = 0; let famousCats = []; cats.forEach(cat => { let followers = cat.followers.reduce((a, b) => a + b); if (maxFollowers < followers) { famousCats = [cat.name]; maxFollowers = followers; } else if (maxFollowers === followers) { famousCats.push(cat.name); } }); return famousCats; }
tengo una duda que espero me puedas despejar, la parte del if, al menos con el segundo objeto no comprendo xq toma los dos ultimos gatos, siendo que al iterar por el primer elemento followers siempre va a ser mayor que maxFollowers, es decir, siempre el primer nombre se va a grabar en el array...esa es mi duda...graias!!
@joan soto si se guarda en al array inicialmente pero en la siguiente iteración se sobrescribe ya que encontró otro mayor
Estuvo bueno, me hizo pensar.
Spoilers:
export function findFamousCats(cats) { let obj = {}; cats.forEach(element => { return obj[element.name] = element.followers.reduce((a,b) => a+b) }); let max = Math.max(...Object.values(obj)); return(Object.keys(obj).filter(key => obj[key] === max)); };
Al punto y sencillo
casi no puedo comprender tu codigo we
Buenasss, aquí les dejo mi solución usando los métodos dados en las clases.
export function findFamousCats(cats) { // Tu código aquí 👈 let gatosFamosos = []; let maximaCantidadSeguidores = 0; for (let cat of cats) { let seguidores = cat.followers.reduce(function (acumulador, seguidores) { return acumulador + seguidores; }); if (seguidores > maximaCantidadSeguidores) { maximaCantidadSeguidores = seguidores; gatosFamosos = []; gatosFamosos.push(cat.name); } else if (seguidores === maximaCantidadSeguidores) { gatosFamosos.push(cat.name); } } return gatosFamosos; }
Hola, Carlos. Me gustó tu solución, pero no entiendo por qué dentro del if, vuelves a inicializar la variable 'gatosFamosos'? Me puedes explicar, por favor?
Buenas Cristian, dentro del if reasigno la variable gatosFamosos para dejarla vacía de elementos. Al cumplirse el if significa que ese mishi tiene más seguidores que todos los anteriores, por lo tanto, si anteriormente metí un mishi o más (en caso de que haya varios mishis con la misma cantidad de seguidores) debo sacarlos del arreglo, podría usar el metodo .pop() para ir sacando mishi por mishi, pero se me hizo que directamente limpiar el arreglo era más sencillo.
Hola, dejo mi solucion Caminito anti spoilers 🚗 . . . . . . . . . . . . . . . . . . . . Llegamos 📍
export function findFamousCats(cats) { // Tu código aquí 👈 let FamousMichis = []; let maxFollowers = 0; cats.forEach((michi) => { const totalFollowores = michi.followers.reduce((acumulador, numero) => acumulador + numero); const isFisrt = maxFollowers === 0; const isMayor = totalFollowores > maxFollowers; maxFollowers = isFisrt ? totalFollowores : (isMayor ? totalFollowores : maxFollowers); }) let catsFilter = cats.filter((michi) => michi.followers.reduce((acumulador, numero) => acumulador + numero) === maxFollowers) catsFilter.forEach((michi) => { FamousMichis.push(michi.name); }) return FamousMichis }
Admiro la manera en la que haces codigo, muy claro
Quise hacer todo con un reduce dentro de un map, pero no era viable sin modificar el objeto original y en eso me acordé que ya vimos el for. Va mi código: . . . . . . . . . .
// Tu código aquí 👈 // inicializo las variables que voy a necesitar let mostFamousCats = []; // Lista de gatos famosos, en array para poder hacer el push let maxFollowers=0; // Número máximo de seguidores encontrado. No puede haber menos que cero followers... ¿o si? //recorremos el objeto cats for (const individualCat of cats) { // Sumamos los followers que tiene este gatito en todas sus redes sociales let currCatFollowers = individualCat.followers.reduce(function(acc,num){ return acc + num; },0); // Comparamos si el gatito tiene más seguidores que el gatito anterior (o más de cero seguidores, si es el primero) // y si es así, entonces borramos el arreglo y agregamos a la lista al nuevo campeón // Pero, si el gatito tiene los mismos seguidores que el anterior campeón (o si es el primero, y tiene cero seguidores), lo agregamos a la lista de campeones if (currCatFollowers > maxFollowers) { mostFamousCats = []; mostFamousCats.push(individualCat.name); maxFollowers=currCatFollowers; // Actualizamos el número de seguidores a vencer } else if (currCatFollowers === maxFollowers) { mostFamousCats.push(individualCat.name); // Si hubo un empate, agregarlo a la list a } } // Listo! Retornamos la lista de campeones en un arreglo return (mostFamousCats);
hola, leyendo tu codigo muy explicado por cierto, me queda la duda de si sirve para solo 2 inputs, que pasa si hay 3 o 5?
Este estuvo un poco menos dificil porque en las lecturas si nos daban la mayoría de herramientas para la resolución; pero si me llevó su buen par de horas xD ... Aquí mi respuesta (con datos extra para facilitar la ejecucion si quieren probarlo fuera de platzi): ... ... . . . . . . .
let cats = [ {name: "Mimi", followers: [320, 120, 70]}, {name: "Milo",followers: [400, 300, 100, 200]}, { name: "Gizmo",followers: [250, 750]} ] function findFamousCats(cats) { let totalFollowers = 0; let totalMayor=0; let onlyNumbers = []; let onlyWinners = []; let mapedCats = cats.map(function (cat) { totalFollowers = cat.followers.reduce(function (a, n) { return a + n; }); onlyNumbers.push(totalFollowers); //Suma de los followers de cada gato return [cat.name, cat.followers = totalFollowers] //retorna un nuevo array con nombre y total }); totalMayor = Math.max(...onlyNumbers); //calcula cual es el numero más grande de followers let filterCats = mapedCats.filter(function(cat){ //filtra los gatos ganadores segun el totalMayor if (cat[1] === totalMayor) { onlyWinners.push(cat[0]) return onlyWinners; } }) return onlyWinners; } findFamousCats(cats)
Existen muchas formas de hacerlo, a mi se me ocurrió esta :thinking:.
export function findFamousCats(cats) { const reducedCats = cats.reduce((prev, current) => { const { name, followers } = current; const currenTotalFollowers = followers. reduce((prev, current) => prev + current, 0); if (currenTotalFollowers === prev.maxFollowers) { return { maxFollowers: prev.maxFollowers, famousCat: [...prev.famousCat, name] } } if (currenTotalFollowers > prev.maxFollowers) { return { maxFollowers: currenTotalFollowers, famousCat: [name] } } return prev; }, { maxFollowers: 0, famousCat: [] }); return reducedCats.famousCat }
Resolvi el ejercicio de la siguiente manera:
export function findFamousCats(cats) { // Tu código aquí 👈 let maxFollowers = 0; let famousCats = []; for (let cat of cats) { const followersSum = cat.followers.reduce((total, followers) => total + followers, 0); if (followersSum > maxFollowers) { maxFollowers = followersSum; famousCats = [cat.name]; } else if (followersSum === maxFollowers) { famousCats.push(cat.name); } }; return famousCats; }
Buena el mio fue mas revuelto pero funciona jaja
export function findFamousCats(cats) { var array = []; var max; for (let i = 0; i < cats.length; i++) { var total = cats[i].followers.reduce((a, follow) => a + follow, 0); cats[i]['total'] = total; array.push(total) } max = Math.max(...array) return (cats.filter(cat => cat['total'] === max)).map(function (a) { return a.name}) }
no se que es peor.. no entender, o ver las explicaciones de todos y ver que no puedo seguir el desafio porque no entiendo.
¡Hola! En este caso que dudas tienes con el ejercicio?
Me costo un monton sacar la logica para recorrer un array de objetos, pero lo logre:
export function findFamousCats(cats) { const data = cats.map(cat => ({ name: cat.name, totalFollowers: cat.followers.reduce((acc, count) => acc + count, 0) })); const maxFollowers = Math.max(...data.map(cat => cat.totalFollowers)); return data .filter(cat => cat.totalFollowers === maxFollowers) .map(cat => cat.name); }
map se transforman los datos; Esto para pasar el array de followers a un totalFollowers.reduce se suma el array de followers para que en totalFollowers solo quede la suma de todos los followers.Math.max se encuentra la mayor cantidad de followers; recorriendo nuevamente con map para extraer el dato de totalFollowers y entonces obtener el maximo.filter se comparan los totalFollowers con el maxFollowers para extraer unicamente los que son equivalentes, y con map solo se extraen los nombres.aqui mi aporte
export function findFamousCats(cats) {
const totals = cats.map(cat => cat.followers.reduce((sum, f) => sum + f, 0));
const maxFollowers = Math.max(...totals);
return cats
.filter((cat, index) => totals[index] === maxFollowers)
.map(cat => cat.name);
}
Lo intente de esta manera pero no me corre, la logica en teoria esta bien pero no se que me falta, agradezco la opinion de quien pueda ayudarme a entenderlo.(
¡Hola @NicolasSPC!
Recuerda que la función de console.log es desplegar solo en consola la información, lo que debes hacer es poner un return gatoNombre para que la función retorne algo y pueda pasar los tests.
¿Ya te encuentras en el Discord oficial de Platzi? Ahí podemos indagar más a fondo sobre este desafío
Un abrazo!
Hola! No entiendo bien desde esta parte:
for (let i = 0; i < cats.length; i++) { // Iteramos por cada gatito recibido en el array const cat = cats[i]; // Obtenemos la suma total de seguidores con reduce const totalFollowers = cat.followers.reduce( (acum, currentVal) => acum + currentVal, 0 );
No entiendo de dónde sale el acum y currentval, alguien me explica bien? Espero no ser el único medio perdido.
Tampoco entiendo de dónde sale ese 0 final de la función reduce en la variable totalFollowers
¡Hola dante!
Básicamente el método reduce() es un método propio de los arrays que al momento de utilizarlo necesita que le pasemos dos nombres (que no deben ser nombres de variables utilizadas) en los cuales almacenará los siguientes valores.
Yo personalmente elegí los nombres de acum y currentVal para hacer más descriptivas las variables pero son nombres arbitrarios que facilmente también pueden ser valorAcumulado y valorActual.
/
De tal manera que el siguiente código
const totalFollowers = cat.followers.reduce( (acum, currentVal) => acum + currentVal, 0 );
Hace exactamente lo mismo que el siguiente
const totalFollowers = cat.followers.reduce( (valorAcumulado, valorActual) => valorAcumulado+ valorActual, 0 );
solamente son nombres arbitrarios
Con todo esto podemos empezar a manipular el resultado según lo requiera el objetivo del ejercicio. En este caso lo que hicimos es que en cada iteración sumar el valor acumulado acum (El cual lo inicializamos en 0, es por eso que al final va ese número) al valor sobre el que se esté iterando currentVal.
¿te sirvió de ayuda? Cualquier cosa estoy al pendiente :D
Un aporte de codigo
/*Spoiler de reto ....................................................... ............................................................. ............................................................... .................................................................. .................................................................... ................................................................ ...........................*/ export function findFamousCats(cats) { let mayorCat = []; let MoreFollower = 0; cats.map((arg) => { let getFollowers = 0; arg.followers.reduce(function (acumulador, numero) { return getFollowers = (acumulador + numero); },0) if (getFollowers == MoreFollower) { mayorCat.push(arg.name); } else if (getFollowers > MoreFollower) { mayorCat = []; mayorCat.push(arg.name); MoreFollower = getFollowers; } }) return mayorCat; }
Mi solución 👇:
function findFamousCats(cats) { let famousCats = []; let numberOfFollowers = cats.map(cat => { return cat.followers.reduce((accumulator, currentValue) => currentValue + accumulator, 0); }); const maxNumOfFollowers = Math.max(...numberOfFollowers); for (let i = 0; i < cats.length; i++) { if (numberOfFollowers[i] === maxNumOfFollowers) { famousCats.push(cats[i]["name"]); } } return famousCats; }
Aquí mi aporte:
export function findFamousCats(cats) { let resultado = []; let totalFollowers = 0; for (let cat of cats) { let seguidores = cat.followers.reduce(function(acumulador, numero) { return acumulador + numero; }, 0); if (seguidores > totalFollowers) { totalFollowers = seguidores; resultado = [cat.name]; } else if (seguidores === totalFollowers) { resultado.push(cat.name) } } return resultado; }
lo hice muy largo por lo que veo
export function findFamousCats(cats) { let followers1 = []; let catFollowers for (let i = 0; i < cats.length; i++) { catFollowers = cats[i].followers.reduce((acumulador, item) => acumulador + item, 0); if (followers1.length == 0) { followers1.push(cats[i]); } else if (catFollowers == followers1[0].followers.reduce((acumulador, item) => acumulador + item, 0)) { followers1.push(cats[i]); } else if (catFollowers > followers1[0].followers.reduce((acumulador, item) => acumulador + item, 0)) { followers1 = [cats[i]]; } } let ganadores = []; for (let i = 0; i < followers1.length; i++) { ganadores.push(followers1[i].name); } return(ganadores); }