Playground - Encuentra al michi mas famoso

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?

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

David Galvan

student•

Dejo mi solución

export function findFamousCats(cats) {
  const totalFollowers = cat => cat.followers.reduce((prev, curr) => prev + curr, 0);
  const maxFollowers = Math.max(...cats.map(totalFollowers));
  return cats.filter(cat => totalFollowers(cat) === maxFollowers).map(cat => cat.name);
}

```export function findFamousCats(cats) {

&#x20; const totalFollowers = cat => cat.followers.reduce((prev, curr) => prev + curr, 0);

&#x20; const maxFollowers = Math.max(...cats.map(totalFollowers));

&#x20; return cats.filter(cat => totalFollowers(cat) === maxFollowers).map(cat => cat.name);

}

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

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

export function findFamousCats(cats) {
  const totalFollowers = cat => cat.followers.reduce((prev, curr) => prev + curr, 0);
  const maxFollowers = Math.max(...cats.map(totalFollowers));
  return cats.filter(cat => totalFollowers(cat) === maxFollowers).map(cat => cat.name);
}

```export function findFamousCats(cats) {

&#x20; const totalFollowers = cat => cat.followers.reduce((prev, curr) => prev + curr, 0);

&#x20; const maxFollowers = Math.max(...cats.map(totalFollowers));

&#x20; return cats.filter(cat => totalFollowers(cat) === maxFollowers).map(cat => cat.name);

}

Playground - Encuentra al michi mas famoso

¡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

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios