Reto 1: Área de un triángulo

El área de un triángulo puede ser calculada cuando se conoce la longitud de sus lados.
Teniendo en cuenta que s1, s2 y s3 son las longitudes de los lados del triángulo, se puede
calcular el subperímetro s = (s1+s2+s3)/2, y, con este valor, se puede calcular el área del
triángulo de la siguiente manera: area = √( s * (s-s1) * (s-s2) * (s-s3) ).
Cree una función que recibe la medida de los lados del triángulo y retorna el área de este,
redondeada a una cifra decimal.
El módulo math puede serle de ayuda para calcular la raíz cuadrada.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: area_triangulo
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

s1 float Longitud de uno de los lados del triángulo.

s2 float Longitud de uno de los lados del triángulo.

s3 float Longitud de uno de los lados del triángulo.

Descripción del retorno:

Tipo Descripción

float El área del triángulo redondeado a una cifra decimal.

Codigo:
import math

def calcular_subperimetro(s1, s2, s3):

return (s1 + s2 + s3) / 2

def calcular_area(s1, s2, s3, s):

return math.sqrt(s * (s - s1) * (s - s2) * (s - s3))

def area_triangulo(s1, s2, s3):

# Calcular el subperímetro
s = calcular_subperimetro(s1, s2, s3)

# Calcular el área
area = calcular_area(s1, s2, s3, s)

# Redondear el área a una cifra decimal

area_redondeada = round(area, 1)

return area_redondeada
# Ejemplo de uso
lado1 = 5
lado2 = 7
lado3 = 8

# Calcular el área del triángulo

area_del_triangulo = area_triangulo(lado1, lado2, lado3)
print("El área del triángulo es:", area_del_triangulo)

Reto 2: Índice de masa corporal

Cree una función que pueda calcular el índice de masa corporal (BMI) de una persona.
La fórmula para calcular el BMI es la siguiente:
BMI = peso/(altura^2)
En esta fórmula el peso está en kilogramos y la altura en metros. Tenga en cuenta que el peso y
altura que reciban su función, van a estar en libras y pulgadas respectivamente, ya que su
función será usada en los Estados Unidos.
Recuerde que:
● 1 libra corresponde a 0.45kg.
● 1 pulgada corresponde a 0.025 metros.
El valor de retorno debe estar redondeado a dos decimales.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_BMI
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

peso_lb float Peso en libras de la persona.

 altura_inch float Altura en pulgadas de la persona.

Descripción del retorno:

Tipo Descripción

float Índice de masa corporal de la persona, el valor de retorno debe estar redondeado a
dos decimales.
Codigo:
def calcular_BMI(peso_lb, altura_inch):
# Convertir peso de libras a kilogramos
peso_kg = peso_lb * 0.45

# Convertir altura de pulgadas a metros

altura_m = altura_inch * 0.025

# Calcular el BMI
bmi = peso_kg / (altura_m ** 2)

# Redondear el resultado a dos decimales

bmi_redondeado = round(bmi, 2)

return bmi_redondeado

# Ejemplo de uso:
peso_en_libras = 150.0
altura_en_pulgadas = 70.0
resultado_BMI = calcular_BMI(peso_en_libras, altura_en_pulgadas)
print("El BMI es:", resultado_BMI)

Reto 3: Cambio a retornar

Considere el software que se ejecuta en una máquina expendedora. Una de las tareas que debe
realizar es determinar cuánto cambio debe entregarle al cliente luego de que paga. Escriba una
función que recibe la cantidad de dinero (en pesos) a dar como cambio al cliente y retorne un
mensaje con la cantidad de monedas de cada denominación que deben ser entregadas,
teniendo en cuenta que el cambio se debe otorgar con la menor cantidad de monedas posible.
La máquina cuenta con monedas de 500, 200, 100 y 50 pesos, y el cambio total se entregará
con monedas de estas denominaciones. El mensaje retornado DEBE seguir el siguiente
formato: “A,B,C,D” (sin espacios intermedios) donde A, B, C y D son la cantidad de monedas de
500, 200, 100 y 50, respectivamente.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_cambio
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

cambio int Valor a entregarle al comprador.

Descripción del retorno:

Tipo Descripción

str Cadena de caracteres que indica cuántas monedas de cada denominación se deben
entregarle al comprador (usando la menor cantidad de monedas posible).

Codigo:
def calcular_cambio(cambio):
monedas_500 = cambio // 500
cambio %= 500

monedas_200 = cambio // 200

cambio %= 200

monedas_100 = cambio // 100

cambio %= 100

monedas_50 = cambio // 50

return "{},{},{},{}".format(monedas_500, monedas_200, monedas_100, monedas_50)

# Ejemplo de uso
cambio_a_entregar = 1175 # Cambio a entregar al cliente
mensaje_cambio = calcular_cambio(cambio_a_entregar)
print("Cantidad de monedas a entregar:", mensaje_cambio)
Una agencia de viajes necesita informar a sus clientes la hora de llegada de sus vuelos. Se
conoce la hora de partida del vuelo (en horas, minutos y segundos) y la duración del vuelo
(en horas, minutos y segundos).
Cree una función que retorne la hora de llegada del vuelo en una cadena con el formato
“HH:mm:ss” donde HH es la hora, mm los minutos y ss los segundos de la hora de llegada
del vuelo.
La hora está dada en formato de 24 horas. Si alguno de los 3 números de la respuesta es
menor a 10, sólo se necesita un dígito ('7' en lugar de '07').
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_horario_llegada
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

hora_salida int Hora de salida del vuelo (valor entre 0 y 23).

minuto_salida int Minuto de salida del vuelo (valor entre 0 y 59).

segundo_salida int Segundo de salida del vuelo (valor entre 0 y 59).

duracion_horas int Número de horas que dura el vuelo.

duracion_minutos int Número de minutos (adicionales al número de horas) que dura

el vuelo.

duracion_segundos int Número de segundos (adicionales al número de horas y

minutos) que dura el vuelo.
Descripción del retorno:
Tipo Descripción
 str Cadena que indica la hora de llegada del vuelo a su destino, la cadena debe estar en
el formato “HH:mm:ss”.
Codigo:
def calcular_horario_llegada(hora_salida, minuto_salida, segundo_salida, duracion_horas,
duracion_minutos, duracion_segundos):
# Convertir la duración total a segundos
duracion_total_segundos = duracion_horas * 3600 + duracion_minutos * 60 +
duracion_segundos

# Calcular la hora de llegada en segundos desde la medianoche

hora_llegada_segundos = (hora_salida * 3600 + minuto_salida * 60 + segundo_salida) +
duracion_total_segundos

# Calcular las horas, minutos y segundos de la hora de llegada

hora_llegada = hora_llegada_segundos // 3600
minutos_llegada = (hora_llegada_segundos % 3600) // 60
segundos_llegada = hora_llegada_segundos % 60

# Formatear la hora de llegada en el formato HH:mm:ss

hora_llegada_str = str(hora_llegada).rjust(2, '0')
minutos_llegada_str = str(minutos_llegada).rjust(2, '0')
segundos_llegada_str = str(segundos_llegada).rjust(2, '0')

return f"{hora_llegada_str}:{minutos_llegada_str}:{segundos_llegada_str}"

# Ejemplo de uso
hora_salida = 12
minuto_salida = 30
segundo_salida = 0
duracion_horas = 3
duracion_minutos = 45
duracion_segundos = 30

hora_llegada = calcular_horario_llegada(hora_salida, minuto_salida, segundo_salida,

duracion_horas, duracion_minutos, duracion_segundos)
print("Hora de llegada:", hora_llegada) # Ejemplo de salida: Hora de llegada: 16:15:30

Examen 1:
MÓDULO 2:

Reto 1: Modularidad
Escriba una función que reciba dos números enteros n y d y determine si n es divisible por 2d, si
n es divisible por d, o si n no es divisible ni por d ni por 2d.
Recuerde que ningún número es divisible por 0.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: es_divisible
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

n int Un número entero.

d int Un número entero.

Descripción del retorno:
Tipo Descripción

int Si el número n es divisible por 2d, retorna 2. Si el número n es divisible entre d pero no
entre 2d, retorna 1. De lo contrario, retorna 0.
Codigo:
def es_divisible(n: int, d: int) -> int:
if d == 0:
return 0 # Ningún número es divisible por 0

if n % (2 * d) == 0:
return 2 # n es divisible por 2d
elif n % d == 0:
return 1 # n es divisible por d
else:
return 0 # n no es divisible ni por d ni por 2d

# Ejemplo de uso
numero = 15
divisor = 5
resultado = es_divisible(numero, divisor)

if resultado == 2:
print(f"{numero} es divisible por 2*{divisor}")
elif resultado == 1:
print(f"{numero} es divisible por {divisor} pero no por
2*{divisor}")
else:
print(f"{numero} no es divisible ni por {divisor} ni por
2*{divisor}")
Reto 2: Regalo de santa
En el taller de regalos de Santa Claus, el CTE (Chief Technology Elf) ha decidido implementar
un nuevo sistema de clasificación de regalos, para facilitar su organización. Cada paquete tiene
ahora un identificador numérico único. El identificador es un número entero entre 100 y 999 y
sirve para clasificar los regalos de la siguiente manera.
● Si el número es palíndromo e impar, el regalo corresponde a una niña.
● Si el número es palíndromo y par, el regalo corresponde a un niño.
● Si el número es par pero no es palíndromo, el regalo corresponde a un hombre.
● Si el número es impar pero no es palíndromo, el regalo corresponde a una mujer.
Escriba una función que ayude al CTE a calcular, dado un identificador único de regalo, a qué
tipo de persona corresponde dicho regalo.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: clasificar_regalo
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

id int El identificador del regalo cuyo tipo de persona se quiere calcular.

Descripción del retorno:

Tipo Descripción

str Si el número es palíndromo e impar, el regalo corresponde a una niña, y se retorna

"girl". Si el número es palíndromo y par, el regalo corresponde a un niño, y se retorna
"boy". Si el número es par, pero no palíndromo, el regalo corresponde a un hombre, y
se retorna "man". Si el número es impar, pero no palíndromo, el regalo corresponde a
una mujer, y se retorna "woman"
Codigo:
def clasificar_regalo(identificador: int) -> str:
# Verificar si el número es palíndromo
 es_palindromo = str(identificador) == str(identificador)[::-1]

# Determinar si es par o impar

es_par = identificador % 2 == 0

if es_palindromo and es_par:

return "boy"
elif es_palindromo and not es_par:
return "girl"
elif not es_palindromo and es_par:
return "man"
else:
return "woman"

# Ejemplo de uso
identificador_regalo = 131
tipo_persona = clasificar_regalo(identificador_regalo)
print(f"El regalo con identificador {identificador_regalo} corresponde a: {tipo_persona}")

Reto 3: Movimiento robótico

Usted quiere anticipar el movimiento del nuevo robot que recibió como regalo de cumpleaños. El
robot tiene una brújula interna que le permite saber hacia qué punto cardinal está mirando
actualmente: Norte, Sur, Este, u Oeste. Además, el robot tiene un control remoto que permite
girarlo hacia la izquierda o la derecha, y también pedirle que dé media vuelta. Usted debe
escribir una función que, dados 3 comandos que se envíen usando el control remoto, calcule la
orientación final del robot.
Nota: La representación de los puntos cardinales que llegan por parámetro es la siguiente:
● "N", para Norte.
● "S", para Sur.
● "E", para Este.
● "W", para Oeste.
Las representaciones de los comandos del control remoto que llegan por parámetro son las
siguientes:
● "L", para girar a la izquierda.
● "R", para girar a la derecha.
● "H", para dar media vuelta.
● ".", para mantener la orientación actual.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: movimiento_robot
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

orientacion_actual str La orientación actual del robot.

giro_1 str La acción por ejecutar a partir de la orientación inicial del robot.
Debe ser un valor de los siguientes: {"L","H","R","."}.

giro_2 str La acción por ejecutar a partir de la orientación posterior al giro_1

del robot. Debe ser un valor de los siguientes: {"L","H","R","."}.

giro_3 str La acción por ejecutar a partir de la orientación posterior al giro_2

del robot. Debe ser un valor de los siguientes: {"L","H","R","."}.

Descripción del retorno:

Tipo Descripción

str La orientación final del robot. Debe ser uno de los siguientes valores: {"W","N","S","E"}.

Codigo:
def movimiento_robot(orientacion_actual: str, giro_1: str, giro_2: str, giro_3: str) -> str:
# Definir reglas de giro
reglas_giro = {
"L": {"N": "W", "W": "S", "S": "E", "E": "N"},
"R": {"N": "E", "E": "S", "S": "W", "W": "N"},
"H": {"N": "S", "S": "N", "E": "W", "W": "E"},
".": {}
}

# Aplicar los giros en secuencia

orientacion_final = orientacion_actual
for giro in [giro_1, giro_2, giro_3]:
if orientacion_final in reglas_giro[giro]:
orientacion_final = reglas_giro[giro][orientacion_final]

return orientacion_final

# Ejemplo de uso
orientacion_inicial = "N"
giro_1 = "R"
giro_2 = "H"
giro_3 = "L"

orientacion_final = movimiento_robot(orientacion_inicial, giro_1, giro_2, giro_3)

print("La orientación final del robot es:", orientacion_final)

Reto 4: Materias favoritas

Pedro es un estudiante inteligente pero desinteresado por algunas de sus materias. A Pedro le
gustan las clases en las que aprende programación, matemática, filosofía y literatura. Por lo
anterior, cualquier materia que lleve en su título alguna de estas palabras, será de su agrado.
Pedro está planeando su horario, pero ha puesto a su asistente digital a que le dé posibles
conjuntos de tres materias para inscribir en su semestre. Él quiere saber, dados los títulos de las
tres materias, cuántas de estas son de su agrado. Se sabe que los nombres de las materias irán
sin acentos y en minúsculas cuando sean recibidos por parámetro en la función.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: conteo_de_materias
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

nombre_materia_1 str El nombre de la primera materia.

nombre_materia_2 str El nombre de la segunda materia.

nombre_materia_3 str El nombre de la tercera materia.

Descripción del retorno:

Tipo Descripción
int Retorna el número de materias que cumplen los criterios para gustarle a Pedro.

Codigo:
def conteo_de_materias(nombre_materia_1: str, nombre_materia_2: str, nombre_materia_3:
str) -> int:
# Palabras clave que indican que a Pedro le gustan las materias
palabras_clave = ['programación', 'matemática', 'filosofía', 'literatura']

# Convertimos los nombres de las materias a minúsculas para hacer la comparación

nombre_materia_1 = nombre_materia_1.lower()
nombre_materia_2 = nombre_materia_2.lower()
nombre_materia_3 = nombre_materia_3.lower()

# Contador para el número de materias que gustan a Pedro

contador = 0

# Verificamos si cada materia contiene alguna palabra clave

if any(palabra in nombre_materia_1 for palabra in palabras_clave):
contador += 1
if any(palabra in nombre_materia_2 for palabra in palabras_clave):
contador += 1
if any(palabra in nombre_materia_3 for palabra in palabras_clave):
contador += 1

return contador

# Ejemplo de uso
nombre_materia_1 = "Introducción a la programación"
nombre_materia_2 = "Álgebra lineal"
nombre_materia_3 = "Filosofía contemporánea"

# Contamos cuántas materias son de agrado para Pedro

num_materias_agradables = conteo_de_materias(nombre_materia_1, nombre_materia_2,
nombre_materia_3)
print("Número de materias que gustan a Pedro:", num_materias_agradables)
Reto 5: Picas y fijas
El juego de las Picas y Fijas es un juego matemático muy sencillo, consiste en adivinar un
número de 4 cifras y de todos los dígitos diferentes. Para esto, el jugador que intenta adivinar
deberá decir el número que cree está escondiendo el otro, y este deberá responder el número
de picas y fijas que tiene ahora el jugador.
Una pica es un dígito que se encuentra en el número a adivinar, pero no está en el lugar
correcto; y una fija es un dígito correctamente colocado.
Por ejemplo, si el número secreto es 1234 y el otro jugador dice 1325, tendrá dos picas y una
fija.
Debes crear una función que devuelva un diccionario con las llaves "PICAS" y "FIJAS" que
represente el resultado de la jugada si un jugador trata de adivinar el numero_secreto con el
número intento.
Tu solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: picas_y_fijas
Si lo requieres, puedes agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

numero_secreto int Número por adivinar.

intento int Número con el cual se intenta adivinar.

Descripción del retorno:

Tipo Descripción

dict Diccionario con las llaves "PICAS" y "FIJAS" que describen el resultado del intento.

Codigo:
def picas_y_fijas(numero_secreto: int, intento: int) -> dict:
# Convertir el número adivinado y el intento en listas de dígitos
 num_secreto_lista = [int(d) for d in str(numero_secreto)]
intento_lista = [int(d) for d in str(intento)]

# Inicializar contadores para picas y fijas

picas = 0
fijas = 0

# Verificar picas y fijas

for i in range(len(num_secreto_lista)):
if num_secreto_lista[i] == intento_lista[i]:
fijas += 1
elif num_secreto_lista[i] in intento_lista:
picas += 1

# Crear y retornar el diccionario con los resultados

resultado = {"PICAS": picas, "FIJAS": fijas}
return resultado

# Ejemplo de uso
numero_secreto = 1234
intento = 1325

# Calcular picas y fijas

resultado_jugada = picas_y_fijas(numero_secreto, intento)
print("Resultado de la jugada:", resultado_jugada) # Debería imprimir {"PICAS": 1, "FIJAS":
2}

Los estudiantes de un cierto colegio tienen que ver 5 cursos:

Matemáticas, Español, Ciencias, Literatura y Arte. Usted debe construir una función que
reciba la información de 5 estudiantes y calcule quién es el mejor estudiante (el que tenga el
mejor promedio). La información de cada estudiante se representará usando un diccionario
con 6 llaves: "nombre", que tendrá asociado el nombre del estudiante; "matematicas", que
tendrá asociada la nota del estudiante en el curso Matemáticas; "español", que tendrá
asociada la nota del estudiante en el curso Español; "ciencias", que tendrá asociada la nota
del estudiante en el curso Ciencias; "literatura", que tendrá asociada la nota del estudiante
en el curso Literatura; y "arte", que tendrá asociada la nota del estudiante en el curso Arte.
Las notas son números decimales entre 0 y 5.
Su función debe retornar el nombre del estudiante que tenga el mejor promedio. Si hay
varios con el mejor promedio, debe aparecer el estudiante que tenga el nombre
alfabéticamente menor (independientemente de mayúsculas o minúsculas).
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: mejor_del_salon
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

estudiante1 dict Diccionario con las notas y el nombre del primer estudiante.

estudiante2 dict Diccionario con las notas y el nombre del segundo estudiante.

estudiante3 dict Diccionario con las notas y el nombre del tercer estudiante.

estudiante4 dict Diccionario con las notas y el nombre del cuarto estudiante.

estudiante5 dict Diccionario con las notas y el nombre del quinto estudiante.

Descripción del retorno:

Tipo Descripción

str Nombre del mejor estudiante del salón.

Codigo:
def calcular_promedio(notas):
return sum(notas.values()) / len(notas)

def mejor_del_salon(estudiante1, estudiante2, estudiante3, estudiante4, estudiante5):

estudiantes = [estudiante1, estudiante2, estudiante3, estudiante4, estudiante5]

mejor_promedio = float('-inf')
mejor_estudiante = None

for estudiante in estudiantes:

nombre = estudiante['nombre']
promedio = calcular_promedio({k: v for k, v in estudiante.items() if k != 'nombre'})
if promedio > mejor_promedio or (promedio == mejor_promedio and nombre.lower() <
mejor_estudiante.lower()):
mejor_promedio = promedio
mejor_estudiante = nombre
 return mejor_estudiante

# Ejemplo de uso
estudiante1 = {'nombre': 'Juan', 'matematicas': 4.5, 'español': 3.8, 'ciencias': 4.2, 'literatura':
4.7, 'arte': 3.9}
estudiante2 = {'nombre': 'María', 'matematicas': 3.9, 'español': 4.2, 'ciencias': 4.8, 'literatura':
4.5, 'arte': 4.1}
estudiante3 = {'nombre': 'Pedro', 'matematicas': 4.7, 'español': 4.3, 'ciencias': 4.6, 'literatura':
4.9, 'arte': 4.0}
estudiante4 = {'nombre': 'Ana', 'matematicas': 4.8, 'español': 4.1, 'ciencias': 4.4, 'literatura':
4.8, 'arte': 4.2}
estudiante5 = {'nombre': 'Luis', 'matematicas': 4.4, 'español': 4.4, 'ciencias': 4.7, 'literatura':
4.5, 'arte': 4.3}

mejor_estudiante = mejor_del_salon(estudiante1, estudiante2, estudiante3, estudiante4,

estudiante5)
print("El mejor estudiante del salón es:", mejor_estudiante)

EXAMEN 2:
MODULO 3

Reto 1: Calcular sucesión de Fibonacci

En matemáticas, la sucesión o serie de Fibonacci es la siguiente sucesión infinita de números
naturales: 0,1,1,2,3,5,8,13,...
La sucesión comienza con los números 0 y 1, y a partir de estos, cada término es la suma de
los dos anteriores.
Cree una función que reciba un número que indica la cantidad de números de la sucesión que
se quieren encontrar y retorne una cadena con los números separados por coma.
Por ejemplo, el resultado de la función, si se pasa como parámetro el número 18 es el siguiente:
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: sucesion_fibonacci
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

cantidad_numeros int Cantidad de números de la sucesión que se quieren encontrar.

Descripción del retorno:

 Tipo Descripción

str Cadena que contiene los números de la sucesión de Fibonacci hasta la cantidad que
indica el parámetro, separados por coma y sin espacios intermedios.

Codigo:
def sucesion_fibonacci(cantidad_numeros):
if cantidad_numeros <= 0:
return "Cantidad de números debe ser un entero positivo"

# Caso especial para la primera entrada

if cantidad_numeros == 1:
return "0"

# Inicializamos la sucesión con los primeros dos números

fibonacci = [0, 1]

# Generamos la sucesión de Fibonacci

for i in range(2, cantidad_numeros):
fibonacci.append(fibonacci[i - 1] + fibonacci[i - 2])

# Convertimos los números a cadena y los unimos separados por coma

fibonacci_str = ",".join(map(str, fibonacci))

return fibonacci_str

# Ejemplo de uso
cantidad_numeros_1 = 1
resultado_1 = sucesion_fibonacci(cantidad_numeros_1)
print(f"Caso 1: {resultado_1}") # Salida: "0"

cantidad_numeros_2 = 18
resultado_2 = sucesion_fibonacci(cantidad_numeros_2)
print(f"Caso 2: {resultado_2}") # Salida:
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597"
Reto 2: Mismos dígitos
Escriba una función que determine si en dos números enteros aparecen los mismos dígitos. No
tenga en cuenta ni la frecuencia ni el orden de aparición de los dígitos en los números.
Los números no tienen necesariamente la misma cantidad de dígitos. Por ejemplo, si los
números son 998 y 89 la función debería retornar True.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: mismos_digitos
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

a int El primer número. Es un entero positivo.

b int El segundo número. Es un entero positivo.

Descripción del retorno:

Tipo Descripción

bool True si los dígitos que aparecen en ambos números son los mismos, False de lo
contrario.
Codigo:
def mismos_digitos(a, b):
# Convierte los números a conjuntos de dígitos
set_a = set(str(a))
set_b = set(str(b))

# Compara los conjuntos de dígitos

return set_a == set_b

# Ejemplos de uso
numero_1 = 998
numero_2 = 89
print(mismos_digitos(numero_1, numero_2)) # Salida: True

numero_3 = 123
numero_4 = 789
print(mismos_digitos(numero_3, numero_4)) # Salida: False

Reto 3: Caracteres repetidos

Escriba una función que cuente la cantidad de caracteres diferentes que aparecen más de una
vez en una cadena.
Suponga que todas las cadenas se componen únicamente de letras minúsculas del alfabeto en
inglés.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: contar_caracteres_repetidos
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

cadena str La cadena por revisar.

Descripción del retorno:

Tipo Descripción

int La cantidad de caracteres diferentes que aparecen repetidos en la cadena.

Codigo:
def contar_caracteres_repetidos(cadena):
# Diccionario para contar la frecuencia de cada caracter
frecuencia_caracteres = {}

# Contador para caracteres repetidos

 caracteres_repetidos_count = 0

# Calcular la frecuencia de cada caracter

for caracter in cadena:
frecuencia_caracteres[caracter] = frecuencia_caracteres.get(caracter, 0) + 1

# Contar los caracteres que aparecen más de una vez

for frecuencia in frecuencia_caracteres.values():
if frecuencia > 1:
caracteres_repetidos_count += 1

return caracteres_repetidos_count

# Ejemplo de uso
cadena_ejemplo = "abcaabbccd"
resultado = contar_caracteres_repetidos(cadena_ejemplo)
print("Cantidad de caracteres diferentes que aparecen más de una vez:", resultado) #
Salida: 3

Reto 4: Ordenar cadena de caracteres

Escriba una función que reciba una cadena de caracteres (str) por parámetro y retorne dicha
cadena ordenada alfabéticamente.
Por ejemplo, si se recibe la palabra "bca", el retorno correcto sería "abc".
Suponga que las palabras que su función deberá ordenar están compuestas únicamente del
alfabeto inglés en minúsculas. La cadena no tiene espacios.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: ordenar_cadena
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción
 cadena str La cadena de texto por ordenar

Descripción de retorno:
Tipo Descripción

str La cadena que se recibió por parámetro ordenada alfabéticamente

Codigo:
def ordenar_cadena(cadena):
# Convierte la cadena a una lista de caracteres, ordena y luego une nuevamente
cadena_ordenada = ''.join(sorted(cadena))
return cadena_ordenada

# Ejemplo de uso
cadena_ejemplo = "bca"
resultado = ordenar_cadena(cadena_ejemplo)
print("Cadena ordenada alfabéticamente:", resultado) # Salida: "abc"

Reto 5: Buscar el índice de un elemento en

una lista
Escriba una función que reciba una lista y un número entero a buscar, y que retorne un entero
que indique el índice en que se encuentra este elemento.
En caso de que el elemento se encuentre más de una vez dentro de la lista, debe retornar la
primera posición en que lo encuentre.
En caso de no encontrar el número, retorne -1.
Nombre de la función: buscar_elemento
Descripción de parámetros:
 Nombre Tipo Descripción

entrada list Lista en la que se buscará el número

buscado int Número entero a buscar

Descripción de retorno:
Tipo Descripción

int Número que indica el índice en el que se encuentra el elemento buscado, si no lo

encuentra retorna -1.
def buscar_elemento(entrada, buscado):
for i, elemento in enumerate(entrada):
if elemento == buscado:
return i
return -1

# Ejemplo de uso
lista_ejemplo = [4, 2, 7, 1, 5, 2]
elemento_buscado = 2
resultado = buscar_elemento(lista_ejemplo, elemento_buscado)
print("Índice del elemento buscado:", resultado) # Salida: 1

Reto 6: Encontrar el elemento mayor

Escriba una función que encuentre el mayor número en una lista de enteros positivos.
En caso de que la lista esté vacía, se debe retornar-1.
Nombre de la función: encontrar_mayor
Descripción de parámetros:
Nombre Tipo Descripción
 entrada list Lista en la que se buscará.

Descripción de retorno:
Tipo Descripción

int El número mayor en la lista. Si la lista está vacía retorna -1.

def encontrar_mayor(entrada):
if not entrada:
return -1

mayor = float('-inf') # Inicializar con un valor muy pequeño

for num in entrada:

if num > mayor:
mayor = num

return mayor

# Ejemplo de uso
lista_ejemplo = [10, 5, 20, 15, 25]
resultado = encontrar_mayor(lista_ejemplo)
print("El mayor número en la lista es:", resultado) # Salida: 25

Reto 7: Aproximación de notas

Una clase de la Universidad de los Andes tiene las siguientes reglas con respecto a las
aproximaciones de las notas finales.
● Si la nota es mayor o igual a 4.5, la nota se aproxima a 5.0.
● Si la nota es mayor o igual a 3.5 y menor a 4.5, la nota se aproxima a 4.0.
● Si la nota es mayor o igual a 2.5 y menor a 3.5, la nota se aproxima a 3.0.
● De lo contrario, la nota asignada será 1.5.
Teniendo una lista de diccionarios en donde cada uno corresponde a un estudiante y que tiene
como llaves "nombre" y "nota" (sin aproximar), retorne una lista con todos los diccionarios
actualizados con sus notas después de aproximación.
Cada uno de los diccionarios retornados tiene las llaves "nombre" y "nota"(aproximada).
Se garantiza que la lista tiene al menos un diccionario.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_definitivas
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

estudiantes list Lista de diccionarios que representan a los estudiantes que han
finalizado el curso con su nota final sin aproximar. Cada diccionario tiene
las siguientes llaves: "nombre": (str) el nombre del estudiante. "nota":
(float), un float que representa la nota sin aproximar del estudiante

Descripción de retorno:
Tipo Descripción

list Lista de diccionarios, con la misma cantidad que en la lista inicial, pero con sus notas
aproximadas. El orden de los diccionarios debe ser el mismo que en la lista de entrada.
Cada uno de los diccionarios retornados debe tener las llaves: "nombre" (str) y "nota"
(float).
def calcular_definitivas(estudiantes):
# Función para aproximar la nota según las reglas
def aproximar_nota(nota):
if nota >= 4.5:
return 5.0
elif nota >= 3.5:
return 4.0
elif nota >= 2.5:
return 3.0
else:
return 1.5

# Lista para almacenar los resultados

notas_aproximadas = []

# Calcular las notas aproximadas para cada estudiante

for estudiante in estudiantes:
nombre = estudiante["nombre"]
nota_original = estudiante["nota"]
nota_aproximada = aproximar_nota(nota_original)

# Crear un nuevo diccionario con el nombre y la nota aproximada

estudiante_aproximado = {"nombre": nombre, "nota": nota_aproximada}
notas_aproximadas.append(estudiante_aproximado)
 return notas_aproximadas

# Ejemplo de uso
estudiantes_ejemplo = [
{"nombre": "Alice", "nota": 4.7},
{"nombre": "Bob", "nota": 3.2},
{"nombre": "Charlie", "nota": 2.9}
]

notas_aproximadas_ejemplo = calcular_definitivas(estudiantes_ejemplo)
print(notas_aproximadas_ejemplo)

Reto 8: Ash y la liga Kalos

Ash Ketchum, el personaje principal del anime Pokémon, está a punto de luchar en la final de la
liga Kalos. En estos eventos compiten los mejores entrenadores del mundo en batallas donde
cada entrenador puede tener 3, 4, 5 o 6 criaturas. Ash quiere saber, para una cantidad de
criaturas específica, si él podrá formar un equipo únicamente con Pokémon seudolegendarios
para competir en la final. Un pokemon seudolegendario es aquel que en la suma de sus
estadísticas de combate tiene 600 puntos o más.
Las estadísticas de combate de cada pokemon son 6:
● "ataque"
● "defensa"
● "ataque_especial"
● "defensa_especial"
● "velocidad"
● "vida"
Escriba una función que, dada una lista de diccionarios (cada uno representando un pokémon)
con las anteriores estadísticas, determine si Ash podrá formar un equipo de pokémon
seudolegendarios para afrontar la final de la liga. En caso que Ash pueda formar un equipo,
retorne una lista con los nombres de las criaturas que Ash utilizaría en la batalla. Si es imposible
generar un equipo que cumpla con las condiciones, retorne None.
Se garantiza que en caso de poder formar un equipo válido, solamente habrá una configuración
posible.
La lista de retorno debe componerse únicamente de cadenas de caracteres y debe tener el
mismo orden de la lista que llega por parámetro.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: construir_equipo_pokemon
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

Cantidad int La cantidad de pokémones que usará cada entrenador en la batalla final.
Es un entero entre 3 y 6.

Lista_pkmn list Una lista compuesta de diccionarios. Los diccionarios representan cada
uno de los pokémon elegibles por Ash. Cada diccionario tiene las
siguientes llaves: "nombre": (str) el nombre del pokemon, se garantiza
que no hay nombres repetidos en los diccionarios de la lista; "vida": (int),
"ataque":(int), "defensa": (int),"ataque_especial":
(int),"defensa_especial": (int),"velocidad": (int). Cada uno de estos
valores enteros representa la estadística de combate respectiva del
pokémon.
Descripción de retorno:
Tipo Descripción

list None si es imposible generar un equipo de pokémon seudolegendarios para la batalla.

De lo contrario, retorna una lista con los nombres de los pokémon a utilizar en la
batalla.
from itertools import combinations

def calcular_puntaje(pokemon):
"""Calcula el puntaje total de un Pokémon."""
return sum(pokemon[stat] for stat in ["vida", "ataque", "defensa", "ataque_especial",
"defensa_especial", "velocidad"])

def construir_equipo_pokemon(cantidad, lista_pkmn):

# Filtrar los Pokémon que son seudolegendarios
seudolegendarios = [pokemon for pokemon in lista_pkmn if calcular_puntaje(pokemon)
>= 600]

# Verificar si es posible formar un equipo con la cantidad especificada

if len(seudolegendarios) < cantidad:
return None

# Generar combinaciones de Pokémon para formar el equipo

for equipo in combinations(seudolegendarios, cantidad):
 # Verificar si la suma de las estadísticas de combate es al menos 600
if all(calcular_puntaje(pokemon) >= 600 for pokemon in equipo):
# Si es válido, retornar los nombres de los Pokémon en el equipo
return [pokemon["nombre"] for pokemon in equipo]

# Si no se encontró un equipo válido, retornar None

return None

# Ejemplo de uso
pokemones = [
{"nombre": "Charizard", "vida": 78, "ataque": 84, "defensa": 78, "ataque_especial": 109,
"defensa_especial": 85, "velocidad": 100},
{"nombre": "Mewtwo", "vida": 106, "ataque": 110, "defensa": 90, "ataque_especial": 154,
"defensa_especial": 90, "velocidad": 130},
{"nombre": "Rayquaza", "vida": 105, "ataque": 150, "defensa": 90, "ataque_especial": 150,
"defensa_especial": 90, "velocidad": 95}
]

# Intentamos formar un equipo de 3 Pokémon seudolegendarios

equipo_resultante = construir_equipo_pokemon(3, pokemones)
print("Equipo resultante:", equipo_resultante) # Salida: ["Charizard", "Mewtwo", "Rayquaza"]

Reto 9: El novio tacaño

Nicolás es un novio muy amoroso, pero tiene fama de ser tacaño. Para el cumpleaños de su
novia ha pedido un catálogo de artículos para escoger el regalo más barato disponible. El
catálogo es un diccionario que tiene varias llaves que corresponden al nombre de los productos.
El valor asociado a cada llave es el precio del producto.
Cree una función que retorne el nombre del artículo más barato en el catálogo.
Si Nicolás encuentra dos artículos igual de baratos, comprará el que tenga el nombre
alfabéticamente menor (el que aparecería antes en el diccionario ignorando las mayúsculas y
minúsculas).
Si el artículo más barato vale más de 10.000 pesos, Nicolás no comprará nada e invitará a su
novia a ver una película en su casa.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: producto_mas_barato
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

catalogo dict Diccionario que contiene los nombres de los productos como llaves y sus
respectivos precios como valores.
Descripción de retorno:
Tipo Descripción

str El nombre del artículo más barato en el catálogo. Si no hay ningún artículo que valga
menos de 10.000, retornará None. Si el catálogo está vacío, retornará la cadena "No
hay productos para escoger".
def producto_mas_barato(catalogo):
if not catalogo:
return "No hay productos para escoger"

min_price = float('inf')
cheapest_products = []

for product, price in catalogo.items():

# Convertimos a minúsculas para comparar alfabéticamente
product_lower = product.lower()

if price < min_price:

min_price = price
cheapest_products = [product_lower]
elif price == min_price:
# Si hay un empate en precio, agregamos el producto a la lista
cheapest_products.append(product_lower)

if min_price > 10000:

return None

# Ordenamos alfabéticamente y retornamos el nombre del producto más barato

return sorted(cheapest_products)[0].capitalize()

# Ejemplo de uso
print(producto_mas_barato({})) # No hay productos para escoger
print(producto_mas_barato({'pantuflas': 20000, 'chicle': 2000, 'coca cola': 2500, 'lenceria':
7000})) # Chicle
print(producto_mas_barato({'pantuflas': 2000, 'chicle': 2000, 'coca cola': 2500, 'lenceria':
7000})) # Chicle
print(producto_mas_barato({'pantuflas': 12000, 'chicle': 2000, 'coca cola': 2500, 'lenceria':
7000})) # None

Reto 10: Producto más caro de un carro de

compras
Catalina necesita llevar un mejor control de sus gastos cuando hace mercado. Para esto, ha
decidido construir una aplicación para registrar cada producto que agregue en su carrito de
compras. Estos datos son guardados en un diccionario cuyas llaves corresponden a los
nombres de los productos. El valor asociado a cada llave es el precio del producto
correspondiente.
Cree una función que retorne el nombre del producto más costoso del carrito de compras. Si se
encuentran dos productos igual de costosos (siendo los más costosos del carro), la función
retorna el menor alfabéticamente. Por ejemplo, si los 'bananos' que compra Catalina costaran
los mismo que las 'chocolatinas', la función retornaría 'bananos'
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: producto_mas_costoso
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

carrito_compras dict Diccionario que contiene los nombres de los productos del carrito
de compras como llaves y sus respectivos precios como valores.
Todas las llaves están escritas únicamente con letras minúsculas.

Descripción de retorno:
Tipo Descripción

str El nombre del artículo más costoso en el carrito de compras. Si el carrito de compras
está vacío, retornará la cadena "No hay productos en el carrito".
def producto_mas_costoso(carrito_compras):
 if not carrito_compras:
return "No hay productos en el carrito"

max_price = float('-inf')
most_expensive_products = []

for product, price in carrito_compras.items():

# Convertimos a minúsculas para comparar alfabéticamente
product_lower = product.lower()

if price > max_price:

max_price = price
most_expensive_products = [product_lower]
elif price == max_price:
# Si hay un empate en precio, agregamos el producto a la lista
most_expensive_products.append(product_lower)

# Ordenamos alfabéticamente y retornamos el nombre del producto más costoso

return sorted(most_expensive_products)[0]

# Ejemplo de uso
carrito = {'manzanas': 12000, 'bananos': 15000, 'chocolatinas': 12000, 'uvas': 15000}
print(producto_mas_costoso(carrito)) # Salida: "bananos"

Reto 11: Costo total de un carro de compras

Catalina necesita llevar un mejor control de sus gastos cuando hace mercado. Para esto, ha
decidido construir una aplicación para registrar cada producto que agregue en su carrito de
compras. Estos datos son guardados en un diccionario cuyas llaves corresponden a los
nombres de los productos. El valor asociado a cada llave es el precio del producto
correspondiente.
Cree una función que retorne el valor total del carrito de compras. Esto es, la suma de los
precios individuales de todos los productos que están en el carrito.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: valor_carrito_compras
Si lo requiere, puede agregar funciones adicionales
Descripción de parámetros:
Nombre Tipo Descripción

carrito_compras dict Diccionario que contiene los nombres de los productos del carro de
compras como llaves y sus respectivos precios como valores.

Descripción de retorno:
Tipo Descripción

float Valor total del carro de compras. Si el carro de compras está vacío, retornará el valor
cero.
def valor_carrito_compras(carrito_compras):
total = 0.0

for price in carrito_compras.values():

total += price

return total

# Ejemplo de uso
carrito = {'manzanas': 12000, 'bananos': 15000, 'chocolatinas': 5000, 'uvas': 8000}
print("Valor total del carrito de compras:", valor_carrito_compras(carrito)) # Salida: 40000.0

Reto 12: La mejor aerolínea

Recopilamos los registros de los vuelos que ocurrieron durante un día entre aeropuertos
ubicados en Estados Unidos y los organizamos en un diccionario de diccionarios. Ahora
queremos que usted nos ayude a averiguar cuál es la mejor aerolínea con base en la
puntualidad. Es decir, queremos saber cuál es la aerolínea que acumuló el menor retraso
promedio en los vuelos que recopilamos.
El parámetro vuelos de la función, es un diccionario de diccionarios con la información de los
vuelos.
Las llaves en este diccionario son el código de cada vuelo.
Los valores en este diccionario son diccionarios con la información de un vuelo organizado de
acuerdo con las siguientes llaves:
● aerolinea, corresponde al nombre de la aerolínea.
● origen, corresponde al código de aeropuerto de origen.
● destino, corresponde al código de aeropuerto destino del vuelo.
● distancia, corresponde a la distancia entre el origen y el destino.
● retraso, corresponde a la cantidad de minutos de retraso que tuvo el vuelo.
● duracion, corresponde a la duración planeada del vuelo en minutos.
● salida, corresponde a un entero que representa la hora de salida.
La hora de salida, se representa usando la hora en formato 24 horas multiplicada por 100 más la
cantidad de minutos (por ejemplo, las 2007 indica que el vuelo salió a las 8:07 pm).
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: mejor_aerolinea
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

vuelos dict Diccionario de diccionarios con la información de los vuelos.

Descripción de retorno:
Tipo Descripción

str El nombre de la mejor aerolínea (la que tenga menor retraso promedio).

from collections import defaultdict

def mejor_aerolinea(vuelos):
# Creamos un diccionario para almacenar el retraso acumulado y la cantidad de vuelos
por aerolínea
retrasos_acumulados = defaultdict(int)
cantidad_vuelos = defaultdict(int)

# Iteramos sobre los vuelos para acumular los retrasos por aerolínea
for vuelo_info in vuelos.values():
aerolinea = vuelo_info['aerolinea']
retraso = vuelo_info['retraso']
retrasos_acumulados[aerolinea] += retraso
cantidad_vuelos[aerolinea] += 1

# Calculamos el retraso promedio para cada aerolínea

retrasos_promedio = {aerolinea: retrasos_acumulados[aerolinea] /
cantidad_vuelos[aerolinea] for aerolinea in cantidad_vuelos}

# Encontramos la aerolínea con el menor retraso promedio

 mejor_aerolinea = min(retrasos_promedio, key=retrasos_promedio.get)

return mejor_aerolinea

# Ejemplo de uso
vuelos = {
'V1': {'aerolinea': 'Delta', 'retraso': 10},
'V2': {'aerolinea': 'American Airlines', 'retraso': 20},
'V3': {'aerolinea': 'Delta', 'retraso': 5},
'V4': {'aerolinea': 'United Airlines', 'retraso': 15}
}

print(mejor_aerolinea(vuelos)) # Salida: 'Delta'

Reto 13: Estadísticas de las tareas

Como parte de una iniciativa de analítica sobre el desempeño de los estudiantes para identificar
las dificultades que tienen en un curso, se recopilaron las notas que obtuvieron en diferentes
tareas. Ahora, queremos analizarlas con un pequeño programa que usted tendrá que construir.
La información obtenida está organizada en un diccionario donde las llaves son los nombres de
los estudiantes (cadenas de caracteres) y los valores son diccionarios.
En estos diccionarios "internos", las llaves son los nombres de las tareas y los valores son las
notas obtenidas por el estudiante para esa tarea (un número entero entre 0 y 100).
Es decir, si el único estudiante en la muestra se llama "Roberto" y ha realizado dos tareas
("Tarea 1" y "Tarea 2" con notas de 80 y 90 respectivamente), el diccionario de diccionarios con
esta información se vería en Python de la siguiente forma: {"Roberto": {"Tarea 1": 80, "Tarea 2" :
90}}.
Tenga cuidado: no todos los estudiantes resolvieron todas las tareas.
Usted debe construir una función que, dados los resultados de los estudiantes, calcule las
siguientes estadísticas para una tarea dada su nombre: la mayor nota obtenida, el nombre del
estudiante que obtuvo la mejor nota, la menor nota obtenida, el nombre del estudiante que
obtuvo la peor nota, el promedio de las notas de los estudiantes, la cantidad de estudiantes que
recibieron una nota y la suma de las notas obtenidas por los estudiantes.
La función debe retornar un diccionario con las siguientes llaves: "mayor", "mejor", "menor",
"peor", "promedio", "cantidad" y "total".
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_estadisticas_tarea
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

estudiantes_tareas dict Un diccionario de diccionarios con la información de los

estudiantes y sus tareas.

nombre_tarea str El nombre de la tarea para la que se quiere calcular las

estadísticas
Descripción de retorno:
Tipo Descripción

dict Un diccionario con las llaves "mayor", "mejor", "menor", "peor", "promedio", "cantidad" y
"total" que representan: la mayor nota, el nombre del estudiante con la mejor nota, la
peor nota, el nombre del estudiante con la peor nota, el promedio, la cantidad de
estudiantes que hicieron la tarea y el valor total que resulta de sumar todas las notas
obtenidas en esa tarea.
def calcular_estadisticas_tarea(estudiantes_tareas, nombre_tarea):
# Inicializar variables para el cálculo de estadísticas
mayor_nota = float('-inf')
mejor_estudiante = ""
menor_nota = float('inf')
peor_estudiante = ""
suma_notas = 0
cantidad_estudiantes = 0

# Iterar sobre los estudiantes y sus tareas

for estudiante, tareas in estudiantes_tareas.items():
if nombre_tarea in tareas:
nota = tareas[nombre_tarea]
# Calcular mayor y mejor estudiante
if nota > mayor_nota:
mayor_nota = nota
mejor_estudiante = estudiante

# Calcular menor y peor estudiante

if nota < menor_nota:
menor_nota = nota
peor_estudiante = estudiante

# Sumar notas y contar estudiantes

suma_notas += nota
cantidad_estudiantes += 1
 # Calcular promedio
promedio = suma_notas / cantidad_estudiantes if cantidad_estudiantes > 0 else 0

# Crear diccionario con las estadísticas

estadisticas = {
"mayor": mayor_nota,
"mejor": mejor_estudiante,
"menor": menor_nota,
"peor": peor_estudiante,
"promedio": promedio,
"cantidad": cantidad_estudiantes,
"total": suma_notas
}

return estadisticas

# Ejemplo de uso
estudiantes_tareas = {
"Roberto": {"Tarea 1": 80, "Tarea 2": 90},
"Laura": {"Tarea 1": 70},
"Carlos": {"Tarea 2": 85}
}

nombre_tarea = "Tarea 1"

print(calcular_estadisticas_tarea(estudiantes_tareas, nombre_tarea))

Reto 14: La vaca de cumpleaños

Una clase de estudiantes ejemplares ha decidido hacer una vaca para el cumpleaños de su
profesor favorito. Para esto, un estudiante recorrerá todo el salón recogiendo el dinero que cada
estudiante va a aportar. Tienen dos opciones de regalo: una botella de licor que cuesta 120.000
o un pastel que cuesta 35.000. Además, el estudiante que más dinero ponga, será el que tenga
el honor de darle el regalo al profesor. Recree este caso en una función que reciba una matriz
que representa al salón y una cadena que indica el regalo. Debe retornar una lista cuya primera
posición es un mensaje que indica si el dinero alcanzó para la vaca y las siguientes dos
posiciones son las coordenadas del puesto del estudiante que más aportó.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: hacer_la_vaca
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

salon list Matriz que representa el salón de estudiantes, los valores son enteros que
representan cuánto dinero aportarán.

vaca str Cadena que indica qué vaca se está realizando, esta puede ser 'botella' o
'pastel .
Descripción de retorno:
Tipo Descripción

list Lista cuya primera posición es un str de la forma 'Hay Vaca' si se alcanzó la vaca, y
'No Alcanza' de lo contrario. Las siguientes dos posiciones, son las coordenadas del
estudiante qué más dinero aportó.
def hacer_la_vaca(salon, vaca):
total_dinero = sum(sum(row) for row in salon)

# Determinar el costo del regalo elegido

costo_regalo = 120000 if vaca == 'botella' else 35000

if total_dinero >= costo_regalo:

# Encontrar las coordenadas del estudiante que más aportó
max_dinero = 0
max_coords = None
for i, row in enumerate(salon):
for j, dinero in enumerate(row):
if dinero > max_dinero:
max_dinero = dinero
max_coords = (i, j)

if max_coords is not None:

return ['Hay Vaca', max_coords]
else:
return ['No Alcanza', None]
else:
return ['No Alcanza', None]

# Ejemplo de uso
salon_ejemplo = [
[50000, 60000, 70000],
 [80000, 100000, 90000],
[120000, 95000, 110000]
]

print(hacer_la_vaca(salon_ejemplo, 'botella')) # Salida: ['Hay Vaca', (2, 0)]

Reto 15: La fila juiciosa

Andrés es un profesor que tiene la teoría de que hay filas del salón que tienen mejor promedio
que otras.
Para comprobarlo, ha decidido crear una función que calcule el promedio de la nota de una fila.
La función recibe como parámetros una matriz, un número de fila y retorna el promedio de la fila
redondeado a dos decimales.
Cuidado: un 0 en la matriz no significa que el estudiante haya sacado 0, sino que no hay ningún
estudiante en dicha silla.
Tenga muy en cuenta que para Andrés la primera fila es la número 1. Si se pide un número de
fila que no tenga sentido, su función debe retornar -1. Si la fila no tiene estudiantes, su función
debe retornar 0.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: promedio_fila
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

matriz list Matriz que representa el salón de clases.

fila int Fila a la cual se le va a calcular el promedio.

Descripción de retorno:
Tipo Descripción

float Promedio de la fila que el profesor solicitó.

def promedio_fila(matriz, fila):
# Validar que la fila sea válida
if fila < 1 or fila > len(matriz):
return -1

fila -= 1 # Ajustar el número de fila al índice de la matriz

# Obtener la fila correspondiente

estudiantes = matriz[fila]

# Validar si la fila no tiene estudiantes

if all(est == 0 for est in estudiantes):
return 0

# Calcular el promedio de la fila

total_notas = sum(est for est in estudiantes if est != 0)
cantidad_estudiantes = sum(1 for est in estudiantes if est != 0)
promedio = total_notas / cantidad_estudiantes

return round(promedio, 2)

# Ejemplo de uso
salon_ejemplo = [
[85, 90, 0, 75],
[0, 0, 0, 0],
[70, 80, 85, 90]
]

print(promedio_fila(salon_ejemplo, 1)) # Salida: 83.33

Reto 16: Repintar la x

Un matemático ha diseñado un juego muy sencillo para que sus hijos practiquen operaciones
aritméticas básicas. En este juego, él les da una matriz cuadrada de más de 3x3 y les pide que
"repinten la X" usando una operación determinada. Es decir, ellos tienen que devolver la matriz
aplicando la operación sobre todas las casillas que hacen parte de las diagonales de la matriz.
Las operaciones posibles son sumar, restar, multiplicar y dividir el valor de cada casilla por él
mismo. Por ejemplo, si en una casilla de la X el número original era 5 y la operación que se debe
aplicar es la suma, el valor 5 deberá reemplazarse por 10.
Construya una función que le sirva a los hijos del matemático para verificar sus respuestas. La
función recibe una matriz cuadrada, una operación y retorna la matriz modificada según las
reglas del juego.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: pintar_x
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

matriz list Matriz cuadrada con números positivos.

operacion str Cadena con el símbolo de la operación a realizar. El símbolo puede ser '+',
'-', '*' o '/'.
Descripción de retorno:
Tipo Descripción

list La matriz modificada según la operación indicada.

def pintar_x(matriz, operacion):

n = len(matriz)

# Validar que la matriz sea cuadrada

if n != len(matriz[0]):
raise ValueError("La matriz debe ser cuadrada")

# Realizar la operación en las diagonales

for i in range(n):
for j in range(n):
if i == j or i + j == n - 1:
if operacion == '+':
matriz[i][j] += matriz[i][j]
elif operacion == '-':
matriz[i][j] -= matriz[i][j]
elif operacion == '*':
matriz[i][j] *= matriz[i][j]
elif operacion == '/':
# Evitar división por 0
if matriz[i][j] != 0:
matriz[i][j] /= matriz[i][j]

return matriz
# Ejemplo de uso
matriz_ejemplo = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

print(pintar_x(matriz_ejemplo, '+')) # Sumar en las diagonales

print(pintar_x(matriz_ejemplo, '-')) # Restar en las diagonales
print(pintar_x(matriz_ejemplo, '*')) # Multiplicar en las diagonales
print(pintar_x(matriz_ejemplo, '/')) # Dividir en las diagonales

Examen 3
Modulo 4

Reto 1: Sumar dos vectores (3d)

Construya una función que reciba dos vectores (con 3 componentes cada uno) y retorne un
nuevo vector que sea la suma de los dos vectores recibidos. Cada vector debe recibirse como
una tupla con tres valores flotantes.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: suma_vectorial
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

vector_1 tuple Vector a sumar.

vector_2 tuple Vector a sumar.

Descripción del retorno:

 Tipo Descripción

tuple Vector resultado de la suma como una tupla.

def suma_vectorial(vector_1, vector_2):

"""
Calcula la suma de dos vectores tridimensionales.

Parámetros:
vector_1 (tuple): Primer vector tridimensional representado como una tupla (x1, y1, z1).
vector_2 (tuple): Segundo vector tridimensional representado como una tupla (x2, y2, z2).

Retorna:
tuple: El vector resultante de la suma como una tupla (x1 + x2, y1 + y2, z1 + z2).
"""
resultado = (vector_1[0] + vector_2[0], vector_1[1] + vector_2[1], vector_1[2] +
vector_2[2])
return resultado

# Ejemplo de uso
vector_1 = (1.0, 2.0, 3.0)
vector_2 = (4.0, 5.0, 6.0)

resultado_suma = suma_vectorial(vector_1, vector_2)

print("Resultado de la suma:", resultado_suma) # Salida: (5.0, 7.0, 9.0)

Reto 3: Binarizar
Este ejercicio consiste en llevar los valores de una matriz que representa una imagen a dos
colores: negro y blanco. En cada posición de la matriz que representa la imagen, hay una tupla
de 3 flotantes entre 0 y 1 que representan los valores R, G y B del píxel.
Para ello, se establece un umbral (valor entre 0 y 1) y los píxeles con promedio de color que son
iguales o mayores al umbral se cambian a blanco (todos los valores de la tupla en 1) y los que
están por debajo se cambian a negro (todos los valores de la tupla en 0).
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: binarizar_imagen
Si lo requiere, puede agregar funciones adicionales.
Descripción de argumentos:
Nombre Tipo Descripción

imagen list Matriz que representa la imagen

umbral float Umbral de binarización

Descripción del retorno:

Tipo Descripción

list Matriz que representa la imagen binarizada

def binarizar_imagen(imagen, umbral):

imagen_binarizada = []

for fila in imagen:

fila_binarizada = []
for pixel in fila:
# Calcula el promedio de los valores R, G y B del píxel
promedio_color = sum(pixel) / len(pixel)

# Compara el promedio con el umbral

if promedio_color >= umbral:
fila_binarizada.append([1, 1, 1]) # Blanco
else:
fila_binarizada.append([0, 0, 0]) # Negro

imagen_binarizada.append(fila_binarizada)

return imagen_binarizada

# Ejemplo de uso
imagen_original = [
[[0.2, 0.4, 0.6], [0.7, 0.8, 0.1], [0.5, 0.5, 0.5]],
[[0.9, 0.2, 0.3], [0.1, 0.5, 0.9], [0.8, 0.7, 0.4]],
[[0.3, 0.3, 0.3], [0.6, 0.6, 0.6], [0.2, 0.2, 0.2]]
]

umbral = 0.5

imagen_binarizada = binarizar_imagen(imagen_original, umbral)

print(imagen_binarizada)

Reto 4: Reflejar Verticalmente

En este ejercicio se debe reflejar la imagen verticalmente sobre una línea imaginaria en el centro
de la figura, creando una imagen espejo de la figura original. En cada posición de la matriz que
representa la imagen hay una tupla de 3 flotantes entre 0 y 1 que representan los valores R, G y
B del píxel.
Después de reflejar una figura, la distancia entre la línea de reflexión y cada punto en la figura
original es la misma que la distancia entre la línea de reflexión y el punto correspondiente en la
imagen de espejo. Para hacer esta transformación, se intercambian las columnas de píxeles de
la imagen: La primera con la última, la segunda con penúltima, etc.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: reflejar_imagen
Si lo requiere, puede agregar funciones adicionales.
Descripción de argumentos:
Nombre Tipo Descripción

imagen list Matriz que representa la imagen.

Descripción del retorno:

Tipo Descripción

list Matriz que representa la imagen reflejada.

def reflejar_imagen(imagen):

imagen_reflejada = []

# Itera sobre cada fila de la imagen

for fila in imagen:
fila_reflejada = fila[::-1] # Invierte la fila para reflejarla verticalmente
imagen_reflejada.append(fila_reflejada)
 return imagen_reflejada

# Ejemplo de uso
imagen_original = [
[[0.2, 0.4, 0.6], [0.7, 0.8, 0.1], [0.5, 0.5, 0.5]],
[[0.9, 0.2, 0.3], [0.1, 0.5, 0.9], [0.8, 0.7, 0.4]],
[[0.3, 0.3, 0.3], [0.6, 0.6, 0.6], [0.2, 0.2, 0.2]]
]

imagen_reflejada = reflejar_imagen(imagen_original)
print(imagen_reflejada)

Reto 5: Buscar los mejores estudiantes

Construya una función que reciba un DataFrame con información sobre el desempeño de un
conjunto de estudiantes en 5 materias y retorne un DataFrame con información sobre los
mejores estudiantes.
El DataFrame que recibe la función tiene 6 columnas: 'nombre', donde aparecen los nombres de
los estudiantes, 'matematicas', 'ingles', 'ciencias', 'literatura' y 'arte', en las cuales aparecen las
calificaciones de los estudiantes en cada una de esas materias. Las calificaciones son números
decimales entre 0 y 5.0.
La función debe retornar un DataFrame con dos columnas: 'nombre', donde aparecen los
nombres de los estudiantes; y 'promedio', donde aparecen los promedios de sus calificaciones
redondeados a dos decimales. El DataFrame resultante, debe estar ordenado de mayor a menor
promedio y solo deben aparecer los estudiantes cuyo promedio haga parte del mejor 25%.
Nota: para ordenar los resultados y seleccionar el mejor 25%, no tenga en cuenta las
aproximaciones.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: mejores_estudiantes
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
 Nombre Tipo Descripción

estudiantes DataFrame DataFrame con las columnas 'nombre', 'matematicas', 'ingles',

'ciencias', 'literatura' y 'arte'.
Descripción del retorno:
Tipo Descripción

DataFrame DataFrame con las columnas 'nombre' y 'promedio', ordenado de forma

descendente con respecto al promedio. En este DataFrame, aparecerá el 25%
de los estudiantes del DataFrame original. Por ejemplo, si el DataFrame tenía
las calificaciones de 19 estudiantes, en el resultado aparecerán los 4 mejores
estudiantes.
import pandas as pd

def mejores_estudiantes(estudiantes):
# Calcula el promedio de cada estudiante y redondea a 2 decimales
estudiantes['promedio'] = estudiantes.mean(axis=1).round(2)

# Ordena los estudiantes por promedio en orden descendente

estudiantes_ordenados = estudiantes.sort_values(by='promedio', ascending=False)

# Calcula el número de estudiantes a incluir en el resultado (el 25% de los estudiantes)

num_mejores = int(len(estudiantes) * 0.25)

# Selecciona solo el 25% de los mejores estudiantes

mejores_estudiantes = estudiantes_ordenados.head(num_mejores)

# Filtra y selecciona solo las columnas 'nombre' y 'promedio'

mejores_estudiantes = mejores_estudiantes[['nombre', 'promedio']]

return mejores_estudiantes

# Ejemplo de uso
datos = {
'nombre': ['Estudiante1', 'Estudiante2', 'Estudiante3', 'Estudiante4', 'Estudiante5'],
'matematicas': [4.5, 3.7, 4.9, 4.8, 3.2],
'ingles': [3.9, 4.2, 4.5, 3.8, 4.7],
'ciencias': [4.8, 4.6, 4.9, 4.7, 4.5],
'literatura': [4.2, 4.1, 4.7, 3.9, 4.3],
'arte': [4.5, 4.6, 4.9, 4.7, 4.5]
}

# Crear un DataFrame a partir de los datos

df_estudiantes = pd.DataFrame(datos)

# Obtener los mejores estudiantes

mejores_estudiantes_df = mejores_estudiantes(df_estudiantes)
# Mostrar el DataFrame con los mejores estudiantes
print(mejores_estudiantes_df)

Reto 6: Depurar partidos de fútbol

Un hacker alteró los resultados de los partidos de un torneo suramericano de fútbol y ahora la
CONMEBOL tiene que hacer algo para corregir la información averiada. Escriba una función que
reciba la información con problemas en un DataFrame y retornará otro DataFrame con la
información corregida.
El DataFrame que se recibe tiene siguientes columnas:
1. 'local': el nombre del equipo local en cada partido.
2. 'visitante': el nombre del equipo visitante en cada partido.
3. 'goles_local': la cantidad de goles que anotó el equipo local en cada partido.
4. 'goles_visitante': la cantidad de goles que anotó el equipo visitante en cada partido.
5. 'resultado': el resultado del partido, es decir el nombre del equipo ganador o la cadena
'empate' en caso de que hayan anotado la misma cantidad de goles.
Durante el análisis del ataque informático, la CONMEBOL descubrió que el hacker sólo realizó 3
tipos de daños:
● Alteró la columna 'resultado' de forma aleatoria.
● Introdujo valores nulos en la cantidad de goles, tanto de los equipos locales como de los
visitantes.
● Alteró los nombres de los equipos.
Según lo que decidió la CONMEBOL, la función debe corregir estos errores de la siguiente
manera:
● En la columna 'resultado' debe quedar el resultado correcto del partido (el nombre del
equipo ganador o la cadena 'empate').
● Debe remplazar las cantidades de goles por 0 cuando se encuentren valores nulos.
● Debe eliminar los partidos en los cuales aparezca que un equipo jugó contra él mismo.
Los valores del DataFrame resultante deben tener el mismo orden en el que se recibieron
originalmente.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: depurar_partidos
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción

partidos DataFrame DataFrame con las columnas 'local', 'visitante', 'goles_local',

'goles_visitante' y 'resultado'. En las columnas 'goles_local' y
'goles_visitante' puede aparecer el valor nulo de numpy (np.NaN).

Descripción del retorno:

Tipo Descripción

DataFrame DataFrame con las columnas 'local', 'visitante', 'goles_local', 'goles_visitante' y

'resultado' en el que se corrigen todos los problemas del DataFrame original.

import numpy as np
import pandas as pd

def depurar_partidos(partidos):
# Elimina los partidos en los que un equipo juega contra sí mismo
partidos = partidos[partidos['local'] != partidos['visitante']]

# Remplaza los valores nulos en 'goles_local' y 'goles_visitante' con 0

partidos['goles_local'].fillna(0, inplace=True)
partidos['goles_visitante'].fillna(0, inplace=True)

# Corrige la columna 'resultado' según los goles

partidos['resultado'] = np.where(partidos['goles_local'] > partidos['goles_visitante'],
partidos['local'],
np.where(partidos['goles_local'] < partidos['goles_visitante'],
partidos['visitante'],
'empate'))

return partidos

# Ejemplo de uso
datos = {
'local': ['Equipo1', 'Equipo2', 'Equipo3', 'Equipo4'],
'visitante': ['Equipo2', 'Equipo3', 'Equipo1', 'Equipo3'],
'goles_local': [3, np.nan, 1, 2],
'goles_visitante': [np.nan, 2, 2, 1],
'resultado': ['Equipo1', np.nan, np.nan, np.nan]
}

# Crear un DataFrame a partir de los datos

df_partidos = pd.DataFrame(datos)

# Obtener el DataFrame corregido

df_partidos_corregido = depurar_partidos(df_partidos)

# Mostrar el DataFrame corregido

print(df_partidos_corregido)

Reto 7: Calcular capacidad en universidades

Construya la función calcular_habitantes_por_puesto que calcule la cantidad de habitantes que
hay en un país, por cada estudiante inscrito en una universidad de ese país y clasificada en el
ranking TIMES.
La función recibe dos DataFrames. El primero tiene la información sobre la población de cada
país organizada en tres columnas: 'Pais', 'Poblacion' y 'Edad_mediana'. El segundo tiene la
información sobre universidades organizada en tres columnas: 'country', con el nombre del país;
'university_name', con el nombre de una universidad del ranking; y 'num_students', con el
número de estudiantes inscritos en esa universidad.
Su función debe retornar un DataFrame con las siguientes condiciones:
● Una columna llamada 'Pais' con el nombre de los países.
● Una columna llamada 'habitantes_por_puesto'.
En esta última columna aparecerá la cantidad de habitantes de cada país, dividida por la
cantidad total de estudiantes que hay en las universidades del país que aparecen en el ranking
TIMES. Por ejemplo, si la población de Australia es de 25 millones de personas y hay 31
universidades que en total atienden a 740.000 estudiantes, entonces la cantidad de
'habitantes_por_puesto' será 33.8 (el número debe redondearse a 1 cifra decimal). Además, el
DataFrame resultante debe estar ordenado de menor a mayor de acuerdo con la cantidad de
'habitantes_por_puesto'.
Nota: para ordenar los resultados no tenga en cuenta las aproximaciones.
Su solución debe tener una función de acuerdo con la siguiente especificación:
● Nombre de la función: calcular_habitantes_por_puesto
Si lo requiere, puede agregar funciones adicionales.
Descripción de parámetros:
Nombre Tipo Descripción
 poblacion DataFrame DataFrame con las columnas 'Pais', 'Poblacion' y
'Edad_mediana'. Este DataFrame está desordenado.

universidades DataFrame DataFrame con las columnas 'country', 'num_students' y

'university_name'. Este DataFrame está desordenado.
Descripción del retorno:
Tipo Descripción

DataFrame DataFrame con las columnas 'Pais' y 'habitantes_por_puesto', ordenado de

menor a mayor de acuerdo con la columna 'habitantes_por_puesto'.

import pandas as pd

def calcular_habitantes_por_puesto(poblacion, universidades):

# Agrupa las universidades por país y calcula la suma de estudiantes por país
estudiantes_por_pais = universidades.groupby('country')
['num_students'].sum().reset_index()

# Une los DataFrames de población y estudiantes por país

datos_completos = pd.merge(poblacion, estudiantes_por_pais, left_on='Pais',
right_on='country', how='inner')

# Calcula la cantidad de habitantes por puesto en universidades

datos_completos['habitantes_por_puesto'] = datos_completos['Poblacion'] /
datos_completos['num_students']

# Selecciona las columnas necesarias y ordena por 'habitantes_por_puesto' de menor a

mayor
resultado = datos_completos[['Pais',
'habitantes_por_puesto']].sort_values(by='habitantes_por_puesto')

return resultado

# Ejemplo de uso
datos_poblacion = {
'Pais': ['Australia', 'USA', 'UK'],
'Poblacion': [25000000, 330000000, 66000000],
'Edad_mediana': [37, 38, 40]
}

datos_universidades = {
'country': ['Australia', 'USA', 'UK', 'USA', 'Australia', 'UK'],
'university_name': ['Uni1', 'Uni2', 'Uni3', 'Uni4', 'Uni5', 'Uni6'],
'num_students': [200000, 300000, 400000, 100000, 240000, 300000]
}

df_poblacion = pd.DataFrame(datos_poblacion)
df_universidades = pd.DataFrame(datos_universidades)

resultado = calcular_habitantes_por_puesto(df_poblacion, df_universidades)

print(resultado)