Playground - Encuentra al michi mas famoso

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

1
¡Bienvenido al mundo de JavaScript!
01:33 min

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

77
Playground - Crea un task manager con patrones de diseño

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - Encuentra al michi mas famoso

Comentarios

Leonardo de los angeles Espinoza Hernandez

student

¡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?

Fernando García Guerrero

student

Linea anti spoiler + + + + + + + + + + + + + +

Santiago Ruiz

student

Ahora si en este punto me atore, pude lograr sin problemas el ejercicio del curso de Java Basico pero este no :'(

Miguel Angel Muñoz Pozos

student

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;

}

Joan Soto

student

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!!

Alfonso Jose Romero Perdomo

student

@joan soto si se guarda en al array inicialmente pero en la siguiente iteración se sobrescribe ya que encontró otro mayor

Santiago Sabogal

student

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

Ronaldo Jiménez

student

Al punto y sencillo

Frandel Corporan Rodríguez

student

casi no puedo comprender tu codigo we

Carlos Leandro Miguel Latyn

student

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

Cristian Contreras

student

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?

Carlos Leandro Miguel Latyn

student

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.

Abril Darynka Tapia Sosa

student

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
}

David Alejandro Lopez Sanchez

student

Admiro la manera en la que haces codigo, muy claro

Eduardo Gutiérrez Contreras

student

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

Jhon sebastian Garzon cano

student

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?

Gustavo Alonso Aguilar Acuña

student

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)

Zajith Corro Viveros

student

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
}

Federico Guillermo Moreira Tejera

student

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

Osvaldo Martinez Guillen

student

Buena el mio fue mas revuelto pero funciona jaja

Alexis Corrales

student

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

Jose Maldonado

student

no se que es peor.. no entender, o ver las explicaciones de todos y ver que no puedo seguir el desafio porque no entiendo.

Leonardo de los angeles Espinoza Hernandez

student

¡Hola! En este caso que dudas tienes con el ejercicio?

Cristian Romero

student

•

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

Con map se transforman los datos; Esto para pasar el array de followers a un totalFollowers.
Con reduce se suma el array de followers para que en totalFollowers solo quede la suma de todos los followers.
Con Math.max se encuentra la mayor cantidad de followers; recorriendo nuevamente con map para extraer el dato de totalFollowers y entonces obtener el maximo.
Con filter se comparan los totalFollowers con el maxFollowers para extraer unicamente los que son equivalentes, y con map solo se extraen los nombres.

jorge vilchis

student

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

}

Nicolás Plaza

student

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.(

Leonardo de los angeles Espinoza Hernandez

student

¡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!

Dante Mariani

student

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.

Dante Mariani

student

Tampoco entiendo de dónde sale ese 0 final de la función reduce en la variable totalFollowers

Leonardo de los angeles Espinoza Hernandez

student

¡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.

El valor acumulador
El valor actual

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

Cesar Francisco Zendejas Torres

student

Un aporte de codigo

Evelin Lorena Flores García

student

/*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;
}

Andrés Soret Chacin

student

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

Sebastian David Exeni Cazón

student

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

EDGAR PINTO

student

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

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

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;

}

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

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

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
}

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

  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)

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
}

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

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

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

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

/*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;
}

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

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

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

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays