¡Te damos la bienvenida a este reto!

1

Empezando con Python desde 0

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos: Numbers, Strings y Diccionarios

4

Playground - Retorna el tipo

Día 2

5

Operadores

6

Playground - Calcula la propina

Día 3

7

Condicionales

8

Playground - Averigua si un año es bisiesto

9

Ciclos

10

Playground - Dibuja un triangulo usando bucles

Día 4

11

Listas

12

Encuentra a los gatitos más famosos

13

Diccionarios

14

Obtén el promedio de los estudiantes

15

Tuplas

16

Obten la información de los paquetes

Día 5

17

Calcula la cantidad de letras en una oración

18

Encuentra el mayor palíndromo

Día 6

19

Sets

20

Encuentre la intersección de conjuntos

Día 7

21

List comprehension

22

Encuentra palabras con dos vocales

23

Dictionary Comprehension

24

Calcula la longitud de las palabras

Día 8

25

Funciones Lambda

26

Filtra mensajes de un user específico

27

Higher order functions

28

Crea tu propio método map

Día 9

29

Manejo de Errores y excepciones

30

Maneja correctamente los errores

31

Maneja las excepciones

Día 10

32

Playground - Crea un task manager usando closures

Día 11

33

Lectura de archivos de texto y CSV

Día 12

34

Programación orientada a objetos

35

Crea un auto usando clases

Día 13

36

Abstracción en Python

37

Playground - Crea un sistema de carrito de compras

38

Encapsulamiento en Python

39

Playground - Encapsula datos de los usuarios

Día 14

40

Herencia en Python

41

Playground - Jerarquía de animales usando herencia

Día 15

42

Polimorfismo en Python

43

Playground - Implementa un sistema de pagos

Día 16

44

Estructuras de datos en Python

45

Playground - Crea tu propia lista en python

46

Hash tables en Python

47

Playground - Implementación de una HashTable para Contactos

Día 17

48

Maps en Python

49

Playground - Crea un task manager con Maps

Día 18

50

Singly Linked List en Python

51

Playground - Implementación de una singly linked list

Día 19

52

Stacks en Python

53

Playground - Implementación de un stack

Día 20

54

Queues en Python

55

Playground - Implementación de una queue

Día 21

56

¡Lo lograste!

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Encuentra a los gatitos más famosos

12/56

Aportes 63

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Ahora entiendo porque tantos programadores son calvos y canosos 🤣 a temprana a edad. Después de solucionarlo, lo simplifique con list comprehension

.
.
.

Sude pero salió bien todo!!! 😂
.


.
.
.
.

def find_famous_cat(cats):
  name = []
  followers = []
  famous = []
  
  for cat in cats:
    name.append(cat["name"])
    followers.append(sum(cat["followers"]))

  for i, value in enumerate(followers, 0): 
    if value == max(followers):
      famous.append(name[i])

  return famous  

Utilizando solo los métodos mostrados en este reto, sin nada de temas adelantados:

def find_famous_cat(cats):

  record = 0
  winners = []
  for i in cats:
    count = 0
    
    for j in i['followers']:
      count+=j
    
    if winners==[]:
      winners.append(i['name'])
      record = count    
    elif count > record:
      winners.pop()          
      winners.append(i['name'])
      record = count
    elif count == record:
      winners.append(i['name'])
    
  return winners

Estaba procastinando mis deberes cuando decidi descargar un pomodo con pip. Quiero dedidar un pomodoro al día a este reto, lo complete o no, es acerca de hábito y que Python siempre tendrá una librería o un paquete que haga lo que necesite. Por algo es tan importante aprenderlos.

pip install pydoro

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

def find_famous_cat(cats):
  max = 0
  famous = list()
  for cat in cats:
    total = sum(cat['followers'])
    if total >= max:
      if total > max:
        famous = list() 
      famous.append(cat['name'])
      max = total
  return famous

me costo bastante dar con esa solución

def find_famous_cat(cats): 
    return [i['name']for i in cats if max(
    sum(i['followers']) for i in cats) == sum(i['followers'])]


.
.
.
.
.

def find_famous_cat(cats):

    most_followers = []
    total_followers = []

    #se suman los followers en una lista
    for cat in cats:
        total_followers.append( sum(cat["followers"]))

    #se consigue el máximo
    max_followers = max(total_followers)
    
    #se añaden los nombres de quienes tengan el max
    for idx, followers in enumerate(total_followers):
        if followers == max_followers:
            most_followers.append(cats[idx]["name"])
            
    return most_followers

Escudo antispoiler

Resolví el ejercicio creando dos arrays que almacenaran uno la sumatoria de la cantidad de fans y otro el nombre del mishi, en la misma iteración para que el índice de cada sumatoria correspondiera al del nombre
Luego creé otro bucle que iterara comparando el valor mínimo del array con el máximo y luego eliminara el valor de ese índice en ambos arrays.

<def find_famous_cat(cats):
    array= []
    array2 =[]
    for i in range(len(cats)):
        array.append(sum(cats[i]["followers"]))
        array2.append((cats[i]["name"]))

    for j in range(len(cats)):
        if min(array) != max(array):
          array2.pop(array.index(min(array)))
          array.pop(array.index(min(array)))    
    return (array2)> 


def find_famous_cat(cats):
  famousCat = ""
  contador = -1
  for i in cats:
    cat1 = sum(i["followers"])
    if cat1 > contador:
      famousCat = i["name"]
      contador = cat1
    elif cat1 == contador:
      famousCat += " " + (i["name"])
  return famousCat.split(" ")



find_famous_cat([
  {
    "name": "Mimi",
    "followers": [320, 120, 70]
  },
  {
    "name": "Milo",
    "followers": [400, 300, 100, 200]
  },
  {
    "name": "Gizmo",
    "followers": [250, 750]
  }
])


.
.
.
.
.
.

.
.
.
.
.
.
.
ESTE ES MI CODIGO DESPUES DE DARLE VUELTA UN DIA ENTERO

def find_famous_cat(cats):
  gatoMasFamoso = []
  maxSeguidores = sum(cats[0]['followers'])
  for gatos in cats:
    if maxSeguidores == sum(gatos['followers']):
      gatoMasFamoso.append(gatos['name'])
    elif maxSeguidores < sum(gatos['followers']):
      maxSeguidores = sum(gatos['followers'])
      gatoMasFamoso.clear()
      gatoMasFamoso.append(gatos['name'])
  return gatoMasFamoso
  pass
Se logro! Gracias! def find\_famous\_cat(cats):  *# Tu código aquí 👈*  empty\_list = \[]   max\_followers = \[]   for i in range(len(cats)):      cats\[i]\["followers"] = sum(cats\[i]\["followers"])      empty\_list.append(cats\[i]\["followers"])   idx = empty\_list.index(max(empty\_list))   for i in range(len(cats)):      if cats\[i]\["followers"] == cats\[idx]\["followers"]:          max\_followers.append(cats\[i]\["name"])   return max\_followers```python def find_famous_cat(cats): # Tu código aquí 👈 empty_list = [] max_followers = [] for i in range(len(cats)): cats[i]["followers"] = sum(cats[i]["followers"]) empty_list.append(cats[i]["followers"]) idx = empty_list.index(max(empty_list)) for i in range(len(cats)): if cats[i]["followers"] == cats[idx]["followers"]: max_followers.append(cats[i]["name"]) return max_followers ``` ![](https://imgur.com/a/cciKPzM)
```js def find_famous_cat(cats): # Tu código aquí 👈 mayor=0 lista_famosos=[] for gatos in cats: total_seguidores=0 for seguidores in gatos["followers"]: total_seguidores = total_seguidores + seguidores if total_seguidores==mayor: lista_famosos.append(gatos["name"]) if total_seguidores>mayor: mayor=total_seguidores lista_famosos=[] lista_famosos.append(gatos["name"]) return lista_famosos ```
```js def find_famous_cat(cats): # Tu código aquí 👈 gatos = [] followers = [] followersMax = [] i = 0 for prop in cats: gatos.append(cats[prop]["name"]) followers.append(sum(cats[prop]["followers"])) print(followers) followersMax = max(followers) indice_max =[i for i, j in enumerate(followers) if j == followersMax] if len(indice_max) > 1: print("Los gatitos más populares son:") for prop in indice_max: print(gatos[prop], " con ",followers[indice_max[prop]]," seguidores") else: print("El gatito más popular es ", gatos[indice_max[0]], " con ", followers[indice_max[0]], "seguidores") pass ```def find\_famous\_cat(cats):  # Tu código aquí 👈  gatos = \[]  followers = \[]  followersMax = \[]   i = 0  for prop in cats:    gatos.append(cats\[prop]\["name"])    followers.append(sum(cats\[prop]\["followers"]))  print(followers)  followersMax = max(followers)  indice\_max =\[i for i, j in enumerate(followers) if j == followersMax]   if len(indice\_max) > 1:    print("Los gatitos más populares son:")    for prop in indice\_max:      print(gatos\[prop], " con ",followers\[indice\_max\[prop]]," seguidores")  else:    print("El gatito más popular es ", gatos\[indice\_max\[0]], " con ", followers\[indice\_max\[0]], "seguidores")pass
  # Tu código aquí 👈

  lista_followers = []
  lista_name = []
  lista_maximo = [0]
  lista_max_nom = []
  lista_total = []
  cont = 0
  for   n in  cats:
    lista_name.append((n["name"]))
    lista_followers.append(sum(n["followers"]))
  
  lista_total = (list(zip(lista_name,lista_followers)))
  for e,num in enumerate(lista_total):
    if lista_maximo[cont] < lista_total[e][1]:
      print("mayor")
      lista_maximo = []
      lista_max_nom = []
      lista_maximo.append(lista_total[e][1])
      lista_max_nom.append(lista_total[e][0])
      cont = 0
    elif lista_maximo[cont] == lista_total[e][1]:
      print("men")
      lista_maximo.append(lista_total[e][1])
      lista_max_nom.append(lista_total[e][0])
      cont += 1
  print(lista_maximo)
  return lista_max_nom
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202023-09-30%20123245-19c2f8aa-0306-403e-9de5-703e85ef2e5b.jpg)
`def find_famous_cat(cats):  cat_famous = []  total_followers = []` `  for cat in cats:    total_followers.append(sum(cat["followers"]))` `  max_followers = max(total_followers)` `  for cat in cats:    if sum(cat["followers"]) == max_followers:      cat_famous.append(cat["name"])` `  return cat_famous`

Por fin lo logre de verdad me costo mucho… mucho… mucho…!!
def find_famous_cat(cats):
salida = {}
famous_cat = []
for x in cats:
name = x[‘name’]
followers = sum(x[‘followers’])
salida[name] = followers
key_name = max(salida, key=salida.get)
valor_maximo = salida[key_name]

for x in salida:
    if salida[x] == valor_maximo:
      print("nombre con valor maximo  ", x, "con ", salida[x])
      famous_cat.append(x)
      print("famous_cat ", famous_cat)
     
print("Los gatitos con el mayor número de seguidores son : ", famous_cat, " Con ", valor_maximo, " de seguidores" )

v_find_famous_cat = ([
{
“name”: “Luna”,
“followers”: [500, 200, 300]
},
{
“name”: “Michi”,
“followers”: [100, 300]
},
])

find_famous_cat(v_find_famous_cat)

Comparto mi solución:


.
.
.
.
.
.
.

def find_famous_cat(cats):
    mostfollowcats = []
    groupcatnames = {}
    
    for cat in cats:
        groupcatnames[cat['name']] = sum(cat['followers'])

    mostfollowcats = [key for key, value in groupcatnames.items() 
                      if value == max(groupcatnames.values())] # list comprehension
    
    return mostfollowcats


.
.
.
.
.
.
.
.

def find_famous_cat(cats):
    famous_cats = {'names': [], 'max_followers': 0}
    for cat in cats:
        total_followers = sum(cat['followers'])
        if total_followers == famous_cats['max_followers']:
            famous_cats['names'].append(cat['name'])
        elif total_followers > famous_cats['max_followers']:
            famous_cats['names'].clear()
            famous_cats['names'].append(cat['name'])
            famous_cats['max_followers'] = total_followers
    return famous_cats['names']
def find_famous_cat(cats):
    max_followers = 0
    cats_max_followers = []
      
    for i in cats:
       followers =  sum(i["followers"])
       if followers >= max_followers:
            max_followers = followers

    for i in cats:
        if sum(i["followers"]) == max_followers:
            cats_max_followers.append(i["name"])

    return cats_max_followers

Comparto mi solución al ejercicio:

def find_famous_cat(cats):
  max_followers = 0;

  for cat in cats:
    followers_sum = sum(cat["followers"])
    if (followers_sum > max_followers):
      max_followers = followers_sum
    
  
  return [cat["name"] for cat in cats if sum(cat["followers"]) >= max_followers]


.
.
.
.
.
.
.

def find_famous_cat(cats):
  winner = []
  score = 0
  for cat in cats:
    followers = sum(cat["followers"])
    if followers > score:
      score = followers
      winner = [cat["name"]]
    elif followers == score:
      winner.append(cat["name"])
    else:
      score = score
  return winner

def find_famous_cat(cats):
totalFoll = []
top = []
for cat in cats:
totalFoll.append(sum(cat[“followers”]))
#Conseguir el max
maxFoll = max(totalFoll)
#Mostrar el nombre con max seguidore
for cat in cats:
if sum(cat[“followers”]) == maxFoll:
top.append(cat[“name”])
return top
pass

listCat=[{“name”: “Karen”,
“followers”: [1000, 1000, 700]
},
{“name”: “Benito”,
“followers”: [200,50,30]
},
{“name”: “Cucho”,
“followers”: [300, 15,9]
},
{“name”: “Demostenes”,
“followers”: [250, 500, 100]
},
{“name”: “Panza”,
“followers”: [200, 100, 50]
},
{“name”: “Espanto”,
“followers”: [400,500,100]
},
{“name”: “Don_Gato”,
“followers”: [800, 900, 1000]
}
]
print(find_famous_cat(listCat))

Listo!

Gatitos = [{
“name”: “Luna”,
“followers”: [500, 200, 300]
},
{
“name”: “Michi”,
“followers”: [100, 300,10000000000]
},
{
“name”: “Mimi”,
“followers”: [320, 120, 70]
},
{
“name”: “Milo”,
“followers”: [400, 300, 100, 200]
},
{
“name”: “Gizmo”,
“followers”: [250, 750]
}]
def Elfamoso(Gatitos):
name = []
followers = []
famoso = []
for Gato in Gatitos:
name.append(Gato[“name”])
followers.append(sum(Gato[“followers”]))
for i, value in enumerate(followers, 0):
if value == max(followers):
famoso.append(name[i])
print(famoso)
Elfamoso(Gatitos)

Mi respuesta simple pero me costo XD

def find_famous_cat(cats):
  names = []
  big_names = []
  contador = 0

  for cat in cats:
    total = sum(cat['followers'])
    names.append(cat['name'])
    if total > contador:
      contador = total

  for cat in cats:
    total = sum(cat['followers'])
    if total == contador:
      big_names.append(cat['name'])

  return big_names

Solución sin adelantarme a list comprehensions, pero usando enumerate:

def find_famous_cat(cats):
  max_followers = -1
  followers = []
  for i in cats:
    sum_followers = sum(i["followers"])
    if sum_followers > max_followers:
      max_followers = sum_followers
    followers.append(sum_followers)
  famous_cats = []
  for index, n_followers in enumerate(followers):
    if n_followers == max_followers:
      famous_cats.append(cats[index]["name"])
  return famous_cats

enumerate() te da en dos variables el índice y valor correspondiente de cada elemento del la lista.
Sin enumerate se puede simplemente utilizar el valor del índice y acceder a los elementos a través de él, por ejemplo:

for i in range(len(followers))
  if followers[i] == max_followers:
    famous_cats.append(cats[i]["name"])
return famous_cats
def find_famous_cat(cats):
    most_famous_cat = []
    max_followers = 0
    for cat in cats:
        cat["followers"] = sum(cat["followers"])

    sorted_cats = sorted(cats, key=lambda cat: cat["followers"], reverse=True)
    max_followers = sorted_cats[0]["followers"]

    for cat in sorted_cats:
        if cat["followers"] == max_followers:
            most_famous_cat.append(cat["name"])

    return most_famous_cat

Solución 😄…
.

.
.
.
.

def find_famous_cat(cats):
    max_followers = max(
      sum(cat["followers"]) 
      for cat in cats
      )

    famous_kittens = [
      cat["name"] 
      for cat in cats 
      if sum(cat["followers"]) == max_followers
      ]
      
    return famous_kittens
def find_famous_cat(cats):
    most_famous_cats=[]
    for cat in cats:
        cat['total_followers']=sum(cat['followers'])
        
    max_followers=max([cat['total_followers'] for cat in cats])

    for cat in cats:
        if cat['total_followers']==max_followers:
            most_famous_cats.append(cat['name'])
    
    return most_famous_cats

list_cats_famous = [
  {
    "name": "Mimi",
    "followers": [320, 120, 70]
  },
  {
    "name": "Milo",
    "followers": [400, 300, 100, 200]
  },
  {
    "name": "Gizmo",
    "followers": [250, 750]
  },
  {
    "name": "Kali",
    "followers": [250, 50, 20]
  }
]


def find_famous_cat(cats):
  # Tu código aquí 👈
  list_cats = cats
  initial_follow = 0
  new_list_cats = []
  for follow in list_cats:
    total_follow = sum(follow["followers"])

    if total_follow > initial_follow:
      initial_follow = total_follow
      new_list_cats.clear()
      new_list_cats.append(follow["name"])
    elif total_follow == initial_follow:
      new_list_cats.append(follow["name"])

  return new_list_cats

list = find_famous_cat(list_cats_famous)
print(list)

![Gatos_con_maximo_seguidores.PNG]
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
def find_famous_cat(cats):

Tu código aquí 👈

famous=[]
f=[]
for i in cats:
count=0
for j in i[“followers”]:
count+=j
#print(count)
i[“followers”]=count
#cats
for c in cats:
f.append(c[“followers”])
g=0
g=max(f)
#print(max(f))

for m in cats:
if g == m[“followers”]:
famous.append(m[“name”])

return famous

cats =([
{
“name”: “Mimi”,
“followers”: [320, 120, 70]
},
{
“name”: “Milo”,
“followers”: [400, 300, 100, 200]
},
{
“name”: “Gizmo”,
“followers”: [250, 750]
}
])

print(find_famous_cat(cats))

Ya conozco varias formas de mejorar mi código, sin embargo quiero compartir la versión que desarrollé inicialmente.


.
.
.
.
.
.
.
.
.
.

def find_famous_cat(cats):
  list_of_most_famous = []
  list_of_most_famous.append(cats.pop(0))
  for cat in cats:
    if sum(cat["followers"]) > sum(list_of_most_famous[-1]["followers"]):
      list_of_most_famous = [cat]
    elif sum(cat["followers"]) == sum(list_of_most_famous[-1]["followers"]):
      list_of_most_famous.append(cat)

  name_of_most_famous = []
  for cat in list_of_most_famous:
    name_of_most_famous.append(cat["name"])

  return name_of_most_famous
def find_famous_cat(cats):
  list=[]
  names=[]
  for cat in cats:
    list.append(sum(cat["followers"]))
  max_followers= max(list)
  for cat in cats: 
    if max_followers == sum(cat["followers"]):
      names.append(cat["name"])
  return names


.
.
.
.
.
.
.
.
.
.

Mi solución:

def find_famous_cat(cats):

max_followers = 0
famous_cats = []

  for cat in cats:
      total_followers = sum(cat['followers'])
      if max_followers < total_followers :
          max_followers = total_followers
    
  for cat in cats :
      if max_followers == sum(cat['followers']) :
          famous_cats.append(cat['name'])
            
  return famous_cats

Indico mi solución, en base a los conocimientos básicos de Python. No pasa las pruebas pero responde lo correcto:
.
.
.
.
.
.
.
def find_famous_cat(cats):
my_cats = []
max_puntos = 0
for element in cats:
puntos_gato = 0
for puntos in element[‘followers’]:
puntos_gato += puntos
element[‘total’] = puntos_gato
element.pop(‘followers’)
if puntos_gato > max_puntos:
max_puntos = puntos_gato
#print(cats)
#print(max_puntos)
for element in cats:
if element[‘total’] == max_puntos:
my_cats.append(element[‘name’])
print(my_cats)

find_famous_cat([
{
“name”: “Luna”,
“followers”: [500, 200, 300]
},
{
“name”: “Michi”,
“followers”: [100, 300]
},
])

find_famous_cat([
{
“name”: “Mimi”,
“followers”: [320, 120, 70]
},
{
“name”: “Milo”,
“followers”: [400, 300, 100, 200]
},
{
“name”: “Gizmo”,
“followers”: [250, 750]
}
])


.
List comprehensions con todo.

![chrome_byfODE4No8.png](https://static.platzi.com/media/user_upload/chrome_byfODE4No8-2a19ff72-cab5-4c9b-8a34-2dd1dc81e70e.jpg)


Mi solución:

def find_famous_cat(cats):
  followers = []
  famous_cat = []
  for i in cats:
    followers.append(sum(i["followers"]))
    
  greater_number = max(followers)

  for i in cats:
    if greater_number == sum(i["followers"]):
      famous_cat.append(i["name"])
      
  return famous_cat
def find_famous_cat(cats):
  
  famous = []
  fmax = 0
  
  for cat in cats:
    total_followers = 0
    for follower in cat["followers"]:
      total_followers += follower
    if (total_followers > fmax):
      fmax = total_followers
      if (len(famous) != 0):
        famous.pop()
      famous.append(cat["name"])
    elif total_followers == fmax:
      famous.append(cat["name"])
        
  return famous
  pass

Bueno otro reto sin lograr, pero aprendí un poco más sobre las listas, hay que seguir practicando

Aquí mi solución 😃

.
.
.
.
.

def find_famous_cat(cats):
  followers = []
  catsWithMaxFollowers = []
  for cat in cats:
    followers.append(sum(cat['followers']))

  maxFollowers = max(followers)

  for i, followersByCat in enumerate(followers):
    if (followersByCat == maxFollowers):
      catsWithMaxFollowers.append(cats[i]['name'])

  return catsWithMaxFollowers
def find_famous_cat(cats):
  def get_max_followers(cats):
    followers = 0
    for cat in cats:
      followers = max(followers, sum(cat['followers']))
    return followers

  famosos = get_max_followers(cats)

  nombres = []
  for cat in cats:
    if famosos == sum(cat['followers']):
      nombres.append(cat['name'])

  return nombres
def find_famous_cat(cats):
  sol =[]
  max=0
  for i in cats:
    if sum(i['followers'])>max:
        sol.append(i['name'])
        max=sum(i['followers'])
        if len(sol)>1:
            sol.pop(0)
    elif sum(i['followers'])==max:
      sol.append(i['name'])
  return sol

mi aporte
.
.
.
.
.
.
.
.
.

def find_famous_cat(cats):
    gatototales = {}
    listagatos = []
    listagatosfamosos = []
    
    for prop in cats:
        gato = prop['name']
        list_followers = prop['followers'] 
      
        totalseguidores = 0  
      
        for num_seguidores in list_followers:
            totalseguidores +=  num_seguidores      
        
        gatototales = { gato : totalseguidores }
        listagatos.append(gatototales)

        #print(gatototales)
        #print(listagatos)
    
    MaxSeguidores = 0
    
    for elem in listagatos: 
        for gatito, TotSeguidores in elem.items():
            
            
            
            if TotSeguidores > MaxSeguidores:
                
                MaxSeguidores = TotSeguidores
                
                listagatosfamosos = [gatito]
                
            elif TotSeguidores == MaxSeguidores:
                 listagatosfamosos.append(gatito)
            
            print(gatito, TotSeguidores)
      
    return listagatosfamosos
    
    pass

gato = find_famous_cat([{
    "name": "Luna",
    "followers": [500, 200, 300,800]
  },
  {
    "name": "Michi",
    "followers": [100, 300,700,300]
  },
  {
    "name": "Rey",
    "followers": [500, 200, 300,800]
  }])

print(gato)

Mi aporte
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def find_famous_cat(cats):
  # Tu código aquí 👈
  catsFamous = []
  beforeFollows = 0
  for cat in cats:
    follows = 0
    for follow in cat['followers']:
      follows += follow
    if follows > beforeFollows:
      catsFamous = []
      catsFamous.append(cat['name'])
      beforeFollows = follows
    elif follows == beforeFollows:
      catsFamous.append(cat['name'])
  return catsFamous
  pass

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def find_famous_cat(cats):
  cat_famous=[]
  follower_max=0
  for cat in cats:
    max=0
    for follower in cat["followers"]:
      max+=follower
    if max > follower_max:
      follower_max=max
      cat_famous.clear()
      cat_famous.append(cat["name"])
    elif max == follower_max:
      cat_famous.append(cat["name"])
  return (cat_famous)
  

print (find_famous_cat([
  {
    "name": "Mimi",
    "followers": [20, 10]
  }
]))



.
.
.
La buena noticia es que después de un par de días ahora entiendo mejor las listas y diccionarios 🐍👌🏼
.
.
.
.
.
.

def find_famous_cays(cats):
  #defino listas
  seguidores = []
  gatosFamosos = []
  maxSeguidores = 0

  #iterando
  for element in cats:
    #se agregan los seguidores a la lista
    seguidores.append(sum(element["followers"]))
    #si es el gato mas famoso se borra la lista y se agrega el gato
    if maxSeguidores < (sum(element["followers"])): 
      gatosFamosos.clear()      
      gatosFamosos.append(element["name"])  
    #si es un gato igual de famoso se agrega a la lista
    if maxSeguidores == sum(element["followers"]):        gatosFamosos.append(element["name"])
    #se actualiza el número máximo de seguidores
    maxSeguidores = max(seguidores)
  #retornar lista
  return (gatosFamosos)


.
.
.
.
.
.
.
.
.
.
.

from functools import reduce

def find_famous_cat(cats):
  # Obtenemos el total de seguidores y lo guardamos en la misma llave
  for i, cat in enumerate(cats):
    followers_tmp = cat['followers']
    cat['followers'] = reduce(lambda x, y: x + y, followers_tmp)
  
  # Guardamos en una variable el mayor número de seguidores
  max_followers = max(cats, key=lambda followers: followers['followers'])['followers']

  # Hacemos una lista con list comprehensions, añadiendo el nombre, si la cantidad de seguidores coincide con el número mayor de seguidores
  result = [cat['name'] for cat in cats if cat['followers'] == max_followers]
  return result


*
*
*
*

este es mi codigo:

def find_famous_cat(cats):
  lista = []
  maximo = 0
  for i in range(len(cats)):
    suma = 0
    for x in cats[i]["followers"]:
      suma += x
    if suma == maximo:
      lista.append(cats[i]["name"])
    elif suma > maximo:
      maximo = suma
      lista = [] 
      lista.append(cats[i]["name"])     
  return lista

print(find_famous_cat([
  {
    "name": "Luna",
    "followers": [500, 200, 300]
  },
  {
    "name": "Michi",
    "followers": [100, 300]
  },
]))
print(find_famous_cat([
  {
    "name": "Mimi",
    "followers": [320, 120, 70]
  },
  {
    "name": "Milo",
    "followers": [400, 300, 100, 200]
  },
  {
    "name": "Gizmo",
    "followers": [250, 750]
  }
]))


.
.
.
.
.
.
.
.
.
.

SPOILER ALERT
.-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------



def find_famous_cat(cats):
  # Tu código aquí 👈
  max_total_follower = 0
  list_most_famous_cat = []
  for cat in cats:
    total_follower =0;
    for element in cat["followers"]:
      total_follower += element
    #print(total_follower) 
    if total_follower == max_total_follower:
      list_most_famous_cat.append(cat["name"]) 
    elif total_follower > max_total_follower:
      max_total_follower = total_follower
      if list_most_famous_cat != []:
        list_most_famous_cat.pop()
      list_most_famous_cat.append(cat["name"])
      #print(cat["name"])
  return list_most_famous_cat


Dejo mi aporte (dos soluciones), la primera es una version resumida de la segunda, en ambas primero nos enfocamos en hallar el mayor numero de fans por cada gato.
En la primera vamos gato por gato y comparamos cual de ellos tiene el mayor numero de fans y lo almacenamos en la variable mayor (usamos solo un ciclo for).
En la segunda, primero obtenemos una lista de los fans de cada gato y luego de esta lista obtenemos el mayor numero de fans y almacenamos el valor en la variable mayor(usamos dos ciclos for).
Luego en ambas volvemos a iterar gato por gato esta vez usamos una condicional para comparar la suma del numero de fans de cada gata con la variable mayor y asi obtenemos el gato con mas seguidores.

def find_famous_cat(cats):
  mayor = 0  
  for c in cats:
    fans = sum(c['followers'])
    if fans > mayor:
      mayor = fans
  cat = []
  for c in cats:
    if sum(c['followers']) == mayor:
      cat.append(c['name'])
  return cat


def find_famous_cat(cats):
  fans = []
  for d in cats:
    fans.append(sum(d['followers']))
  mayor = fans[0]
  for n in fans:
    if n > mayor:
      mayor = n
  cat = []  
  for c in cats:
    if sum(c['followers']) == mayor:
      cat.append(c['name'])
  return cat


.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

def find_famous_cat(cats):
  # Tu código aquí 👈
    cats_total  = [
            { 
                'name': cat['name'], 
                'total_follow': sum(cat['followers'])
            } 
            for cat in cats
        ]
    cats_total.sort(reverse =True, key = lambda x: x['total_follow'])
    famous_cat = [
            cat['name'] 
            for cat in cats_total 
            if cat['total_follow'] == cats_total[0]['total_follow']
        ]
    return famous_cat

.
.
.
.
.
.
.
.
.
.

def my_sort(e):
  e["followers"] = sum(e["followers"])
  return e["followers"]

def get_names(cats):
  result = []
  max = cats[0]["followers"]
  for c in cats:
    if max == c["followers"]:
      result.append(c["name"])
    else:
      break
  return result


def find_famous_cat(cats):
  cats.sort(reverse=True, key=my_sort)
  return get_names(cats)


.
.
.
.
.

def find_famous_cat(cats):
  # Tu código aquí 👈
  max_followers = 0
  famous_cats = []

  for cat in cats:
      sum_followers = sum(cat['followers'])
      if max_followers < sum_followers :
          max_followers = sum_followers
    
  for cat in cats :
      if max_followers == sum(cat['followers']) :
          famous_cats.append(cat['name'])
            
  return famous_cats


*
*
*
*
*
*
*

def find_famous_cat(cats):
    most_famous_cats_names = []
    bigger_total_follower = 0
    total_followers = []
    for cat in cats:
        total_followers.append(sum(cat['followers']))
    for i in range(len(total_followers)):       
        if total_followers[i] > bigger_total_follower:
            bigger_total_follower = total_followers[i]
            most_famous_cats_names = []
            most_famous_cats_names.append(cats[i]['name'])
        elif total_followers[i] == bigger_total_follower:
            most_famous_cats_names.append(cats[i]['name'])
    return most_famous_cats_names
ni idea :/ cmo hacer esto \o/
def find_famous_cat(cats):
  # Tu código aquí 👈
  new_cat = []
  init = 0

  for i in cats:
    #print(i["name"])
    sum = 0

    for j in i["followers"]:
      sum = sum + j
      #print(j)

    #print("init = " + str(init))
    #print("sum = " + str(sum))

    if init == sum:
      init = sum
      new_cat.append(i["name"])
      #print(new_cat)

    if init < sum:
      init = sum
      new_cat.clear()
      new_cat.append(i["name"])
      #print(new_cat)

  return new_cat

firs = find_famous_cat([
  {
    "name": "Luna",
    "followers": [500, 200, 300]
  },
  {
    "name": "Michi",
    "followers": [100, 300]
  },
])

print(firs)
undefined