Diferencias

Muestra las diferencias entre dos versiones de la página.

--- indice:uba:ingenieria:uba-xxi:pensamiento-computacional:guias-y-resueltos:guia-5 [2025/04/29 14:28] – upadmin
+++ indice:uba:ingenieria:uba-xxi:pensamiento-computacional:guias-y-resueltos:guia-5 [2025/04/29 17:02] (actual) – upadmin
@@ Línea 1: / Línea 1: @@
 ====== Guía 5 ======
- * {{ :indice:uba:ingenieria:uba-xxi:pensamiento-computacional:guias-y-resueltos:guia_de_ejercicios_n_5.docx.pdf |}}
+  * {{ :indice:uba:ingenieria:uba-xxi:pensamiento-computacional:guias-y-resueltos:guia_de_ejercicios_n_5.docx.pdf |Guía de Ejercicios Nro 5}}
 ===== Resueltos =====
+<file python resueltos_guia_5.py>
+#ejercicio 1
+""" En una escuela se quiere tener un sistema para guardar la información de sus estudiantes para tener
+mejor organizado sus datos.
+a. Crear un diccionario que sirve para representar a una persona en este contexto, pensar en las
+características que se consideren más relevantes para identificar a una persona (su nombre,
+DNI, edad, etc).
+b. Agregar al diccionario creado, un campo que sea otro diccionario y sirva para guardar el curso
+del estudiante y sus características (año, división, orientación, etc).
+c. Teniendo una lista de diccionarios de estudiantes, buscar en la lista la persona con mayor edad
+e imprimirla por pantalla. """
+#a)
+persona = {"nombre":"Juan", "edad":47, "dni":22175698}
+#b)
+persona["curso"] = {"año":5, "division":"a", "orientacion":"humanidades"}
+print(persona)
+persona1 = {"nombre":"pablo", "edad":56, "dni":17823033, "curso":{"año":6, "division":"d", "orientacion":"musica"}}
+persona2 = {"nombre":"Juan", "edad":47, "dni":22175698, "curso":{"año":5, "division":"a", "orientacion":"humanidades"}}
+persona3 = {"nombre":"Sebastian", "edad":20, "dni":40123987, "curso":{"año":3, "division":"b", "orientacion":"tecnica"}}
+persona4 = {"nombre":"lucrecia", "edad":23, "dni":38693012, "curso":{"año":4, "division":"c", "orientacion":"economicas"}}
+lista_personas = [persona1, persona2, persona3, persona4]
+#c)
+edad = 0
+for i in lista_personas:
+        if i["edad"] >= edad:
+            edad = i["edad"]
+            persona_mayor_edad = i
+print(persona_mayor_edad)
+print(persona_mayor_edad["nombre"])
+#ejercicio 2
+""" En un vivero se guardan las plantas en una lista de diccionario con la siguiente información: especie, si
+necesita luz solar o no, y el precio. (OBSERVACIÓN: ¿Qué tipo de dato nos permitía guardar si algo es
+verdad o no?). Ahora se necesita un sistema que guarde las plantas a medida que van llegando. Se pide
+hacer una función que reciba la lista de diccionarios de plantas, y los datos de la planta nueva y agregue
+esa planta a la lista de diccionarios. """
+def guardar_plantas(lista_plantas, especie_nueva, necesita_luz_solar, precio_nueva_planta):
+    planta_nueva = {
+        "especie": especie_nueva,
+        "necesita_luz": necesita_luz_solar,
+        "precio": precio_nueva_planta
+        }
+    lista_plantas.append(planta_nueva)
+plantas = []
+print(plantas)
+guardar_plantas(plantas, "Rosa" , True, 5000)
+guardar_plantas(plantas, "Jazmin", False, 4000)
+print(plantas)
+#ejercicio 3
+""" Se representa un ticket de supermercado como una lista de diccionarios, donde cada diccionario tiene
+la siguiente información:
+    ● Nombre del producto
+    ● Precio por unidad
+    ● Cantidad
+Se pide hacer una función que reciba el ticket y devuelva el monto total a pagar. """
+productos = []
+def agregar_producto(lista, nombre_producto, precio_unidad, cantidad):
+     producto_nuevo = {"nombre":nombre_producto, "precio":precio_unidad, "cantidad":cantidad}
+     lista.append(producto_nuevo)
+print(productos)
+agregar_producto(productos, "fideos", 10, 2)
+agregar_producto(productos, "cocas", 100, 4)
+print(productos)
+def calculando_ticket(lista):
+  monto_ticket = 0
+  for i in lista:
+      monto_ticket += i["precio"] * i["cantidad"]
+  return(monto_ticket)
+monto = calculando_ticket(productos)
+print(monto)
+#ejercicio 4
+""" Sol tiene una lista de diccionarios donde guarda todas las películas que vió. La información que tiene
+para cada una es: el nombre de la serie, año en que salió, y la puntuación que le puso del 1 al 10. Hace
+mucho que quiere que Tomás empiece a ver las películas que ella considera que son las mejores que vio.
+Hacer una función que reciba el diccionario de las películas que vió Sol, y que devuelva una nueva lista
+de diccionarios donde sólo estén las películas que tienen puntaje mayor a 7. """
+peliculas = [{"nombre":"tiburon", "año_estreno":1984, "puntuacion":5},
+             {"nombre":"casablanca", "año_estreno":1924, "puntuacion":10},
+             {"nombre":"kramer vs kramer", "año_estreno":1970, "puntuacion":2},
+             {"nombre":"el padrino 2", "año_estreno":1980, "puntuacion":9}]
+lista_refinada = []
+def recomendar_peliculas(lista):
+    for i in lista:
+      if i["puntuacion"] > 7:
+          lista_refinada.append(i)
+recomendar_peliculas(peliculas)
+print(lista_refinada)
+#ejercicio 5
+""" Un profesor guarda las notas del primer parcial de sus alumnos en una lista de diccionarios que guarda
+la siguiente información:
+    ● Nombre
+    ● Apellido
+    ● Intento
+    ● Nota
+Donde "intento" es la instancia que está rindiendo, 1 si es la primera vez que rinde el parcial, 2 si es el
+primer recuperatorio y 3 si es el segundo recuperatorio.
+Se pide hacer una función que, dado esta lista de diccionarios, devuelva el promedio de las notas en la
+primera oportunidad que rindieron los alumnos.
+¿Cómo harían para generalizar la función y que el intento sea parametrizable? Es decir, que no
+solamente sirve para el intento 1, sino que también pueda servir para los demás. """
+def promedio(notas, intento_numero):
+    total = 0
+    cantidad_notas = 0
+    for i in notas:
+        if(i["intento"] == intento_numero):
+            cantidad_notas += 1
+            total += i["nota"]
+    return total / cantidad_notas
+lista_notas = [
+    {"nombre": "Juan",
+     "apellido":"Perez",
+      "intento": 2,
+      "nota": 7,
+    },
+    {"nombre": "Pamela",
+     "apellido":"Fernandez",
+      "intento": 2,
+      "nota": 10,
+    },
+    {"nombre": "Romina",
+     "apellido":"Sanchez",
+      "intento": 1,
+      "nota": 9,
+    },
+    {"nombre": "Brenda",
+     "apellido":"Lopez",
+      "intento": 1,
+      "nota": 7,
+    },
+    {"nombre": "Florencia",
+     "apellido":"Martinez",
+      "intento": 3,
+      "nota": 5,
+    }
+]
+print(promedio(lista_notas,2))
+#ejercicio 6
+""" En una fábrica, se hace un chequeo de calidad a los productos antes de cada entrega. El resultado del
+chequeo de la entrega se guarda en una lista de diccionarios, donde cada diccionario tiene la siguiente
+información de cada producto:
+    ● Código del producto
+    ● Fecha de vencimiento
+    ● Si pasó el chequeo de calidad o no
+Se pide hacer una función que reciba esta lista de diccionarios y elimine todos los productos que no
+pasaron el chequeo de calidad. Devolver en una tupla el diccionario con los elementos eliminados y la
+cantidad de elementos que quedaron en el diccionario.
+Dado que la tupla es inmutable y nosotros no podemos ir agregando elementos a una tupla, ¿En qué
+momento deberíamos crear la tupla? """
+entrega_programada = [{"codigo":1, "fecha_vencimiento":"03-04-2024", "calidad":True},
+                      {"codigo":2, "fecha_vencimiento":"07-04-2024", "calidad":False},
+                      {"codigo":3, "fecha_vencimiento":"11-04-2024", "calidad":True},
+                      {"codigo":4, "fecha_vencimiento":"15-04-2024", "calidad":False},
+                      {"codigo":5, "fecha_vencimiento":"16-04-2024", "calidad":False},
+                      {"codigo":6, "fecha_vencimiento":"17-04-2024", "calidad":False}]
+def eliminar_defectuosos(lista):
+    productos_defectuosos = []
+    productos_a_entregar = []
+    for i in lista:
+        if i["calidad"] == False:
+            productos_defectuosos.append(i)
+        else:
+            productos_a_entregar.append(i)
+    productos_defectuosos.append(len(productos_defectuosos))
+    productos_a_entregar.append(len(productos_a_entregar))
+    return tuple(productos_defectuosos) , tuple(productos_a_entregar)
+resultados = eliminar_defectuosos(entrega_programada)
+print()
+print(resultados[0])
+print()
+print(resultados[1])
+print()
+#ejercicio 7
+""" Se quiere guardar la información de un grupo de maratonistas. Se necesita guardar su nombre, DNI, y
+todas las maratones que corrió, de la cual a su vez se quiere tener el nombre de cada una, el año, el
+puesto en que salió el maratonista, y el tiempo que tardó en terminarla.
+a. Crear el diccionario que represente esta situación.
+AYUDA: Queremos guardar muchos maratonistas, y a su vez, muchas maratones para cada
+maratonista, entonces ¿Qué tipo de dato debería ser el campo que guarda todas las
+maratones? ¿Y qué tipo de dato es la maratón en sí?
+b. Teniendo una lista de diccionarios de maratonistas, ordenarlos alfabéticamente.
+c. Ordenar las maratones de cada maratonista según el tiempo que tardó en completar cada una
+de forma ascendente. """
+#a)
+maratonistas = [{"nombre":"Marcelo", "dni":"11111111", "maratones":[{"maraton":"buenos aires", "año":2020, "puesto":2, "tiempo":240},{"maraton":"mexico", "año":2021, "puesto":3, "tiempo":241}]},
+                {"nombre":"Alejandro", "dni":"22222222", "maratones":[{"maraton":"buenos aires", "año":2020, "puesto":5, "tiempo":250},{"maraton":"montevideo", "año":2021, "puesto":1, "tiempo":230}]},
+                {"nombre":"Carlos", "dni":"33333333", "maratones":[{"maraton":"lima", "año":2023, "puesto":1, "tiempo":232},{"maraton":"montevideo", "año":2021, "puesto":2, "tiempo":231}]},
+                ]
+#b)
+def nombres(diccionario):
+    return diccionario["nombre"]
+maratonistas.sort(key = nombres)
+print(maratonistas)
+#c)
+def tiempos(diccionario):
+    return diccionario["tiempo"]
+for i in maratonistas:
+    i["maratones"].sort(key = tiempos)
+print(maratonistas)
+</file>