Ahora entiendo porque tantos programadores son calvos y canosos 🤣 a temprana a edad. Después de solucionarlo, lo simplifique con list comprehension
.
.
.
¡Te damos la bienvenida a este reto!
Empezando con Python desde 0
Día 1
Variables, funciones y sintaxis básica
Tipos de datos: Numbers, Strings y Diccionarios
Playground - Retorna el tipo
Día 2
Operadores
Playground - Calcula la propina
Día 3
Condicionales
Playground - Averigua si un año es bisiesto
Ciclos
Playground - Dibuja un triangulo usando bucles
Día 4
Listas
Encuentra a los gatitos más famosos
Diccionarios
Obtén el promedio de los estudiantes
Tuplas
Obten la información de los paquetes
Día 5
Calcula la cantidad de letras en una oración
Encuentra el mayor palíndromo
Día 6
Sets
Encuentre la intersección de conjuntos
Día 7
List comprehension
Encuentra palabras con dos vocales
Dictionary Comprehension
Calcula la longitud de las palabras
Día 8
Funciones Lambda
Filtra mensajes de un user específico
Higher order functions
Crea tu propio método map
Día 9
Manejo de Errores y excepciones
Maneja correctamente los errores
Maneja las excepciones
Día 10
Playground - Crea un task manager usando closures
Día 11
Lectura de archivos de texto y CSV
Día 12
Programación orientada a objetos
Crea un auto usando clases
Día 13
Abstracción en Python
Playground - Crea un sistema de carrito de compras
Encapsulamiento en Python
Playground - Encapsula datos de los usuarios
Día 14
Herencia en Python
Playground - Jerarquía de animales usando herencia
Día 15
Polimorfismo en Python
Playground - Implementa un sistema de pagos
Día 16
Estructuras de datos en Python
Playground - Crea tu propia lista en python
Hash tables en Python
Playground - Implementación de una HashTable para Contactos
Día 17
Maps en Python
Playground - Crea un task manager con Maps
Día 18
Singly Linked List en Python
Playground - Implementación de una singly linked list
Día 19
Stacks en Python
Playground - Implementación de un stack
Día 20
Queues en Python
Playground - Implementación de una queue
Día 21
¡Lo lograste!
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 69
Preguntas 3
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
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
# 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
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)
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):
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.

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]
}
]))
.
.
.
.
.
.
.
.
.
.
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
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)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?