Introducción
En esta sección te mostramos qué tipo de escritura puede contribuir a fijar los conceptos que aparecen tanto en los enunciados como en las soluciones algorítmicas. Cada ejercicio consiste en la presentación de un enunciado con anotaciones alrededor de este, resaltando algunos términos en color, seguido de la solución analizada de manera similar.
Se explicará qué significa cada una de las instrucciones en términos de asignación de datos a variables, operaciones aritméticas, estructuras de control y orden de las instrucciones. En definitiva, se trata de escribir para qué sirve cada paso. Te sugerimos que leas estos ejercicios analizados para luego poder escribir tú mismo tu propio análisis de otros ejercicios.
El primer paso para la escritura de un programa es evitar la página en blanco: generar anotaciones breves que expliquen el enunciado y la solución a medida que se construye. Es preferible realizarlas en papel, para no estar pendiente de todas las funciones operativas, botones y menús que pueden resultar distractores.
Al lado de cada segmento analizado, se escribe lo que significa. Algunas de estas explicaciones pueden seguir formando parte del programa terminado en forma de comentarios, como explicamos en secciones previas.
Es importante señalar que, en este material, no hemos declarado explícitamente las variables al principio de todos los programas. Asumimos que esta acción ya se ha realizado y que las variables han sido creadas. Sin embargo, lo que sí hemos hecho es inicializar estas variables, es decir, asignarles valores iniciales adecuados para su posterior tratamiento en el programa.
Ejercicios resueltos
1. Calcular la suma de 10 números reales ingresados por teclado. Informar el resultado.
Análisis del problema
Análisis del programa
2. Dado un conjunto de cuatro números decidir si el segundo es mayor que los otros tres (se supone que los números están contenidos en variables ya inicializadas).
Análisis del problema
Sólo se desea conocer la relación entre el segundo número y los demás, por lo tanto, sólo habrá una operación de comparación. Los cuatros números no se ingresan, se supone que este paso fue dado en otra parte del programa.
Análisis del programa
Nombre del programa: Comparación entre num2 y los números restantes
3. Leer 35 números y calcular la suma de sus cuadrados. Mostrar el resultado.
Análisis del problema
La secuencia de datos más importante son los 35 números que ingresan. Se desconoce la secuencia (los números) pero se conoce cuántas veces debe permitirse al usuario ingresar un número. Llenar 35 variables es poco eficiente, por lo tanto, en una única variable se guardará el número ingresado, se calculará su cuadrado y se acumulará en otra variable totalizadora.
Análisis del programa
4. Calcular y mostrar en forma ascendente los múltiplos de 4 menores que n.
Análisis del problema
La secuencia de múltiplos de 4 se obtiene multiplicando 4 por cada uno de los números naturales hasta llegar a un múltiplo cercano a 60.
Si bien el programador conoce la secuencia de números, se pide que el programa los calcule de a uno y los vaya mostrando en forma creciente, suponiendo que se desconoce el último. La condición será que el múltiplo obtenido sea menor que 60.
Habrá por lo menos una iteración, y no se necesita validar ese primer dato, por lo tanto, la estructura adecuada es REPETIR.
Análisis del programa
5. Calcular y mostrar en forma ascendente los múltiplos de m menores que n.
Análisis del problema
Como m y n serán ingresados por teclado, deberá validarse su ingreso para evitar valores que produzcan error. En los siguientes casos, no habrá resultados válidos: n = m, n > m, m = 0, n =0
Análisis del programa
6. Mostrar los primeros m términos de la sucesión de Fibonacci.
Análisis del problema
La secuencia de datos principal es la sucesión de Fibonacci, donde cada número se forma por las suma de los dos números que le preceden. Imaginemos otra secuencia de parejas x, y que van conteniendo los sucesivos valores a sumar. En principio, x e y contienen a 1 y 1, la suma es 2. En un segundo ciclo, x e y cambian sus valores por los que siguen, x contendrá el contenido de y, y el próximo número se guarda en y.
Análisis del programa
7. Ingresar dos números e informar los números naturales comprendidos entre ellos en orden ascendente y descendente utilizando un solo ciclo.
Análisis del problema
La secuencia de datos es un intervalo abierto ( ]a;b[ ), es decir, excluyendo de la sucesión a estos valores. Se pide diferenciar entre orden ascendente y descendente, lo cual implica averiguar cuál de los números es menor que el otro. Una segunda solución más simple los muestra en pantalla como dos listas invertidas desconociendo el procesador cuál es la ascendente y cuál la descendente.
Análisis del programa
8. Se cuenta con el listado de notas de un alumno. En un lugar aparte figura la cantidad de aplazos. Se deben informar dos promedios: el promedio con aplazos y el promedio sin aplazos.
Variables sugeridas:
nota: contiene el valor de cada nota de la lista
acumnot: acumula el valor de todas las notas para calcular el promedio.
cantsin: contador de notas sin aplazos
promsin: promedio sin aplazos
promcon: promedio con aplazos
cantap: cantidad de aplazos (ya se conoce)
9. Calcular el factorial de un número (sin recursividad). Validar que el número esté comprendido entre 1 y 40 y calcular la suma de los naturales menores que él.
10. Resolver el problema de las Torres de Hanoi para cinco discos.
Mover una pila completa desde la posición actual a una posición destino significa mover primero los discos superiores de la pila hacia una pila de espera, mover el último a la posición destino y luego mover los discos en espera a la posición destino. Pero mover los discos en espera implica realizar el mismo procedimiento con un disco menos (n-1).[1]
11. Representar el movimiento de un cuenta kilómetros desde 000 a 999.
12. Formar las combinaciones posibles de dos dígitos distintas tomadas de a 3. Mostrar las que tengan los tres dígitos iguales.
13. Informar la cantidad de ganadores del prode y sus números de documentos. Los resultados tienen el formato de la tarjeta: son listas de 13 elementos cada una.
14. Generar todos aquellos números menores que 2032 tal que sus dígitos sumen 16.
15. Una cátedra tiene clasificados 277 ejercicios según aspectos distintos: ejercicios para razonar, para aplicar definiciones, para desarrollar habilidades prácticas, para investigar, para pasar el rato. Cada ejercicio tiene una calificación del 1 al 10 en cada aspecto. Se desea realizar consultas interactivas a dichos datos. Ingresando dos condiciones (razonar y pasar el rato), se pide listar aquellos cinco mejores ejercicios para esas dos condiciones (el criterio para clasificar se obtiene en base al promedio de las notas de cada ejercicio respecto a esas condiciones). Se conoce además que dichos ejercicios no varían como así tampoco sus calificaciones. Indicar una estructura de datos adecuada para resolver el problema teniendo en cuenta que el tiempo se constituye en un factor crítico.
Análisis del problema
La cantidad de ejercicios está prefijada, así como los aspectos a ser evaluados. Cada nota clasificatoria se aplica a la combinación ejercicio+aspecto, por ejemplo, suponiendo que el ejercicio 2 es muy útil para aplicar definiciones y para pasar el rato, mientras que el ejercicio 1, es bueno para razonar, aunque no es necesariamente entretenido como pasatiempo, así que en este último aspecto tendrá una nota más bien baja.
La estructura de datos para contener las calificaciones podría ser un arreglo de arreglos (tabla de dos dimensiones): un arreglo de 277 ejercicios (considerando la fila en verde como subíndice) cada uno de los cuales es un arreglo de 5 notas cada una calificando una habilidad: razonar, definir, practica, investigar, pasatiempo.
Ejercicios para completar
1. Dado un conjunto de números naturales, determinar cuántos de ellos son mayores o iguales a 100. Un número igual a 0 indica fin de datos.
Análisis del problema
2. Se tiene como datos los importes de todas las facturas correspondientes al mes que acaba de finalizar de un comercio (no se sabe cuántas son). Se desea conocer:
a. Cuántas facturas se realizaron.
b. Importe promedio de las mismas
c. Cuántos son los importes que superan los 30 pesos.
Análisis del problema
3. Leer un conjunto de números enteros y determinar el mayor de ellos. Un número negativo indica fin de datos.
4. Un comerciante desea saber cuántos productos ha vendido en un mes, así como el total de las ventas. Para ello, lee los precios de cada producto vendido y, al final, debe mostrar la cantidad de productos vendidos y el total de ventas.
5. Se tiene una lista de edades de varias personas. Se desea saber cuántas personas son mayores de 18 años y cuántas son menores de 18 años.
6. Leer los resultados de los exámenes de un grupo de estudiantes y determinar cuántos han aprobado (nota mayor o igual a 6) y cuántos han suspendido (nota menor a 6).
7. Se tiene un listado con los salarios de los empleados de una empresa. El objetivo es conocer el salario máximo, el salario mínimo y el promedio de salarios.
8. Dado un conjunto de números enteros, calcular el producto de los mismos. El conjunto finaliza cuando se ingresa el número 1.
9. Un sistema necesita contar cuántos días de la semana ha trabajado un empleado. El sistema lee las horas trabajadas cada día y suma el total de días con horas mayores a 0.
10. Se tiene una lista de números enteros. Se requiere identificar cuántos de esos números son múltiplos de 3.
11. Se desea conocer el mayor y el menor número de una lista de números decimales que se ingresan uno a uno hasta que se ingresa el número 0.
12. Un estudiante realiza un examen con preguntas de verdadero o falso. Para cada respuesta, el sistema debe contar cuántas respuestas correctas y cuántas incorrectas tuvo.
13. Una empresa quiere saber el número total de productos vendidos en un mes, así como el ingreso total por ventas. Cada producto tiene un precio que se ingresa junto con la cantidad vendida.
14. Leer una lista de nombres de estudiantes y sus notas finales, e imprimir aquellos que han aprobado (nota >= 6).
15. Dado un conjunto de números enteros, calcular el promedio de todos los números ingresados. El conjunto finaliza cuando se ingresa el número 0.
Comparación de soluciones en pseudocódigo y Python
La siguiente sección presenta ejercicios de un nivel más complejo y los presenta en dos columnas para que realices una comparación analógica entre el código en pseudocódigo y el código en Python.
Ejemplo 1: Simulación de un Torneo de Videojuegos
Enunciado: Un torneo de videojuegos tiene varias rondas. En cada ronda participan varios jugadores, y cada jugador puede ganar o perder una partida. La cantidad de rondas depende del número de jugadores: si el número de jugadores es mayor a 16, habrá 5 rondas, si es menor o igual a 16, habrá 3 rondas.
- Objetivo: Crear un programa que registre los resultados de las partidas en cada ronda, calcule los ganadores y muestre cómo avanza el torneo. Al final, debe mostrar el jugador ganador.
- Detalles adicionales: Utiliza estructuras anidadas para gestionar los jugadores en cada ronda. Puedes usar un arreglo o lista para las rondas y dentro de ellas otro arreglo para los jugadores. Debes usar condicionales para decidir el número de rondas y para registrar los resultados de cada partida.
- Elementos que considerar: Bucles anidados, listas, condicionales.
INICIO // Leer el número de jugadores LEER numeroDeJugadores // Determinar el número de rondas SI numeroDeJugadores > 16 ENTONCES numeroDeRondas = 5 SINO numeroDeRondas = 3 FIN SI // Crear una lista para almacenar las rondas rondas = CrearLista(numeroDeRondas) // Inicializar la lista de jugadores jugadores = CrearLista(numeroDeJugadores) PARA i DESDE 1 HASTA numeroDeJugadores HACER LEER jugadores[i] // Ingresar nombre o identificación del jugador FIN PARA // Llenar las rondas con los jugadores PARA ronda = 1 HASTA numeroDeRondas HACER // Crear una lista para los jugadores de esta ronda rondaJugadores = CrearLista() // Los jugadores participan en la ronda PARA i DESDE 1 HASTA longitud(jugadores) HACER LEER resultadoPartida // Leer si el jugador ganó o perdió SI resultadoPartida = “ganó” ENTONCES // Agregar al jugador como ganador de esta ronda agregarALista(rondaJugadores, jugadores[i]) FIN SI FIN PARA // Al final de la ronda, actualizar la lista de rondas rondas[ronda] = rondaJugadores FIN PARA // Mostrar el avance del torneo PARA ronda = 1 HASTA numeroDeRondas HACER ESCRIBIR “Ronda “, ronda, “:” PARA i DESDE 1 HASTA longitud(rondas[ronda]) HACER ESCRIBIR “Jugador “, rondas[ronda][i] FIN PARA FIN PARA // Mostrar el ganador del torneo SI longitud(rondas[numeroDeRondas]) = 1 ENTONCES ganador = rondas[numeroDeRondas][1] ESCRIBIR “El ganador del torneo es: “, ganador SINO ESCRIBIR “Hubo un empate. No hay un ganador claro.” FIN SI FIN | def torneo_videojuegos(): # Leer el número de jugadores numero_de_jugadores = int(input(“Ingresa el número de jugadores: “)) # Determinar el número de rondas if numero_de_jugadores > 16: numero_de_rondas = 5 else: numero_de_rondas = 3 # Crear una lista para almacenar las rondas rondas = [[] for _ in range(numero_de_rondas)] # Inicializar la lista de jugadores jugadores = [] for i in range(numero_de_jugadores): jugador = input(f”Ingresa el nombre del jugador {i+1}: “) jugadores.append(jugador) # Llenar las rondas con los jugadores for ronda in range(numero_de_rondas): ronda_jugadores = [] # Los jugadores participan en la ronda for jugador in jugadores: resultado_partida = input(f”¿El jugador {jugador} ganó? (Sí/No): “) if resultado_partida.lower() == “sí”: # Agregar al jugador como ganador de esta ronda ronda_jugadores.append(jugador) # Al final de la ronda, actualizar la lista de rondas rondas[ronda] = ronda_jugadores # Mostrar el avance del torneo for ronda in range(numero_de_rondas): print(f”nRonda {ronda + 1}:”) for jugador in rondas[ronda]: print(f”Jugador: {jugador}”) # Mostrar el ganador del torneo if len(rondas[numero_de_rondas – 1]) == 1: ganador = rondas[numero_de_rondas – 1][0] print(f”nEl ganador del torneo es: {ganador}”) else: print(“nHubo un empate. No hay un ganador claro.”) # Llamar a la función para ejecutar el torneo torneo_videojuegos() |
Explicación del Pseudocódigo: Entrada de datos: Se lee el número de jugadores (numeroDeJugadores). Según el número de jugadores, se determina cuántas rondas tendrá el torneo (5 rondas si hay más de 16 jugadores, 3 rondas si hay 16 o menos). Gestión de rondas: Se crea una lista llamada rondas, que tendrá una sublista para cada ronda del torneo. Se inicializa una lista jugadores que contiene la identificación de cada jugador. Simulación de las partidas: En cada ronda, se registra el resultado de cada partida. Si un jugador gana, se agrega a la lista de jugadores ganadores de esa ronda. Se utiliza un bucle para recorrer todas las rondas, y dentro de cada ronda se procesan los jugadores que participarán. Mostrar el avance del torneo: Se imprime el avance del torneo mostrando los jugadores que han ganado en cada ronda. Determinar al ganador del torneo: Si al final de todas las rondas hay solo un jugador en la última ronda, se considera ese jugador como el ganador del torneo. | Explicación del código en Python: Entrada de datos: Se solicita al usuario que ingrese el número de jugadores y sus nombres. Dependiendo del número de jugadores, se determina cuántas rondas tendrá el torneo: 5 si hay más de 16 jugadores y 3 si hay 16 o menos. Gestión de rondas: Se utiliza una lista rondas que contiene sublistas, una por cada ronda, para almacenar los jugadores ganadores de cada ronda. Los jugadores son ingresados por el usuario y luego se les asigna a las rondas según el resultado de las partidas. Simulación de las partidas: En cada ronda, se pregunta si un jugador ganó o no, y si respondió “Sí”, el jugador es agregado a la lista de ganadores de esa ronda. Mostrar el avance del torneo: Se imprime el estado de cada ronda, mostrando qué jugadores han ganado. Determinar el ganador del torneo: Si al final de todas las rondas hay solo un jugador en la última ronda, se considera ese jugador como el ganador del torneo. |
Consideraciones adicionales: Este pseudocódigo hace uso de estructuras de listas anidadas para almacenar los jugadores ganadores de cada ronda. También emplea condicionales para decidir la cantidad de rondas y determinar el ganador del torneo. | Ejemplo de ejecución: Ingresa el número de jugadores: 4 Ingresa el nombre del jugador 1: Juan Ingresa el nombre del jugador 2: Pedro Ingresa el nombre del jugador 3: Luis Ingresa el nombre del jugador 4: Ana ¿El jugador Juan ganó? (Sí/No): Sí ¿El jugador Pedro ganó? (Sí/No): No ¿El jugador Luis ganó? (Sí/No): Sí ¿El jugador Ana ganó? (Sí/No): No … Ronda 1: Jugador: Juan Jugador: Luis Ronda 2: Jugador: Juan El ganador del torneo es: Juan |
Ejemplo 2: Clasificación de Canciones en una Plataforma de Streaming
- Enunciado: En una plataforma de música, los usuarios pueden agregar canciones a sus listas de reproducción. Cada lista tiene un nombre, una lista de canciones, y cada canción tiene un título, autor y género. Los usuarios pueden tener múltiples listas de reproducción.
- Objetivo: Implementar un sistema que permita agregar, eliminar y clasificar canciones en las listas de reproducción. También se debe permitir ver las canciones de un género específico en cada lista.
- Detalles adicionales: Utiliza listas dentro de listas y bucles anidados para recorrer las canciones de cada lista de reproducción. Además, puedes incluir funciones para añadir canciones nuevas, eliminar canciones y mostrar solo las canciones de un género específico.
- Elementos que considerar: Listas de listas, funciones, búsqueda y clasificación.
// Definición de la estructura de una canción Estructura Cancion: Titulo Autor Genero // Definición de la estructura de una lista de reproducción Estructura ListaReproduccion: Nombre Canciones (lista de Cancion) // Lista de listas de reproducción del usuario Lista de ListasReproduccion // Función para agregar una canción a una lista de reproducción Función agregarCancion(listaNombre, cancion): Para cada lista en ListasReproduccion: Si lista.Nombre es igual a listaNombre: Agregar cancion a lista.Canciones Imprimir “Canción agregada exitosamente a la lista”, listaNombre Retornar Imprimir “La lista de reproducción no existe” // Función para eliminar una canción de una lista de reproducción Función eliminarCancion(listaNombre, tituloCancion): Para cada lista en ListasReproduccion: Si lista.Nombre es igual a listaNombre: Para cada cancion en lista.Canciones: Si cancion.Titulo es igual a tituloCancion: Eliminar cancion de lista.Canciones Imprimir “Canción eliminada exitosamente” Retornar Imprimir “La canción no se encuentra en la lista” // Función para clasificar las canciones de una lista por autor o género Función clasificarCanciones(listaNombre, criterio): Para cada lista en ListasReproduccion: Si lista.Nombre es igual a listaNombre: Si criterio es “Autor”: Ordenar lista.Canciones por Autor Sino si criterio es “Genero”: Ordenar lista.Canciones por Genero Imprimir “Canciones clasificadas por”, criterio Retornar Imprimir “La lista de reproducción no existe” // Función para mostrar canciones de un género específico en una lista Función mostrarPorGenero(listaNombre, genero): Para cada lista en ListasReproduccion: Si lista.Nombre es igual a listaNombre: Para cada cancion en lista.Canciones: Si cancion.Genero es igual a genero: Imprimir “Título:”, cancion.Titulo, “Autor:”, cancion.Autor, “Género:”, cancion.Genero Retornar Imprimir “La lista de reproducción no existe” // Función principal para manejar las interacciones del usuario Función principal(): // Crear un par de listas de reproducción y canciones de ejemplo Crear lista1 = ListaReproduccion(“Rock Hits”, []) Crear lista2 = ListaReproduccion(“Pop Favorites”, []) Agregar lista1 a ListasReproduccion Agregar lista2 a ListasReproduccion // Crear canciones de ejemplo Crear cancion1 = Cancion(“Bohemian Rhapsody”, “Queen”, “Rock”) Crear cancion2 = Cancion(“Shake It Off”, “Taylor Swift”, “Pop”) Crear cancion3 = Cancion(“Hotel California”, “Eagles”, “Rock”) // Agregar canciones a las listas Llamar a agregarCancion(“Rock Hits”, cancion1) Llamar a agregarCancion(“Pop Favorites”, cancion2) Llamar a agregarCancion(“Rock Hits”, cancion3) // Mostrar canciones de un género específico Llamar a mostrarPorGenero(“Rock Hits”, “Rock”) // Clasificar canciones por autor Llamar a clasificarCanciones(“Rock Hits”, “Autor”) // Eliminar una canción de la lista Llamar a eliminarCancion(“Pop Favorites”, “Shake It Off”) | # Definición de la clase Canción class Cancion: def __init__(self, titulo, autor, genero): self.titulo = titulo self.autor = autor self.genero = genero # Definición de la clase ListaReproduccion class ListaReproduccion: def __init__(self, nombre): self.nombre = nombre self.canciones = [] # Función para agregar una canción a la lista def agregar_cancion(self, cancion): self.canciones.append(cancion) print(f”Canción ‘{cancion.titulo}’ agregada exitosamente a la lista ‘{self.nombre}'”) # Función para eliminar una canción de la lista def eliminar_cancion(self, titulo_cancion): for cancion in self.canciones: if cancion.titulo == titulo_cancion: self.canciones.remove(cancion) print(f”Canción ‘{titulo_cancion}’ eliminada exitosamente”) return print(f”La canción ‘{titulo_cancion}’ no se encuentra en la lista”) # Función para clasificar las canciones por autor o género def clasificar_canciones(self, criterio): if criterio == “Autor”: self.canciones.sort(key=lambda x: x.autor) elif criterio == “Genero”: self.canciones.sort(key=lambda x: x.genero) print(f”Canciones clasificadas por {criterio}”) # Función para mostrar canciones de un género específico def mostrar_por_genero(self, genero): for cancion in self.canciones: if cancion.genero == genero: print(f”Título: {cancion.titulo}, Autor: {cancion.autor}, Género: {cancion.genero}”) # Función principal para manejar las interacciones del usuario def main(): # Crear listas de reproducción lista1 = ListaReproduccion(“Rock Hits”) lista2 = ListaReproduccion(“Pop Favorites”) # Crear canciones cancion1 = Cancion(“Bohemian Rhapsody”, “Queen”, “Rock”) cancion2 = Cancion(“Shake It Off”, “Taylor Swift”, “Pop”) cancion3 = Cancion(“Hotel California”, “Eagles”, “Rock”) # Agregar canciones a las listas lista1.agregar_cancion(cancion1) lista2.agregar_cancion(cancion2) lista1.agregar_cancion(cancion3) # Mostrar canciones de un género específico lista1.mostrar_por_genero(“Rock”) # Clasificar canciones por autor lista1.clasificar_canciones(“Autor”) # Eliminar una canción de la lista lista2.eliminar_cancion(“Shake It Off”) # Llamar a la función principal if __name__ == “__main__”: main() |
Explicación del pseudocódigo: Estructura de Canción y Lista de Reproducción: Se definen estructuras para almacenar información sobre una canción (título, autor, género) y sobre una lista de reproducción (nombre y lista de canciones). Funciones: agregarCancion: Permite agregar una canción a una lista de reproducción. eliminarCancion: Permite eliminar una canción de una lista de reproducción. clasificarCanciones: Clasifica las canciones de una lista de reproducción según un criterio (por autor o género). mostrarPorGenero: Muestra todas las canciones de un género específico en una lista de reproducción. Función principal: Se crean dos listas de reproducción con canciones de ejemplo. Luego se agregan las canciones a las listas, se muestra las canciones de un género, se clasifican las canciones y se elimina una canción de una lista. | Explicación del código en Python: Clases: Cancion: Clase que almacena los detalles de una canción (título, autor, género). ListaReproduccion: Clase que representa una lista de reproducción. Contiene métodos para agregar, eliminar, clasificar y mostrar canciones. Métodos en ListaReproduccion: agregar_cancion: Agrega una canción a la lista de reproducción. eliminar_cancion: Elimina una canción de la lista si está presente. clasificar_canciones: Clasifica las canciones de la lista por autor o género usando el método sort(). mostrar_por_genero: Muestra las canciones que pertenecen a un género específico. Función principal: Se crean dos listas de reproducción y varias canciones. Se realizan operaciones como agregar canciones a las listas, mostrar canciones de un género específico, clasificar las canciones y eliminar una canción. |
Consideraciones: El pseudocódigo hace uso de listas dentro de listas, ya que las listas de reproducción contienen una lista de canciones. Los bucles anidados permiten recorrer las listas de reproducción y sus canciones. La lógica está diseñada para que se puedan agregar, eliminar, clasificar y filtrar canciones de manera flexible. |
Ejemplo 3: Gestión de Eventos en una Feria de Tecnología
- Enunciado: En una feria de tecnología, hay múltiples pabellones. En cada pabellón, se realizan varias charlas, y cada charla tiene una duración y un ponente. Los asistentes pueden registrarse en las charlas. El objetivo es organizar y gestionar las charlas y los asistentes, así como determinar en qué pabellón se realizarán.
- Objetivo: Crear un sistema que permita agregar charlas, asignarlas a pabellones, registrar asistentes y mostrar la programación por pabellón. Además, debe verificar si hay alguna charla que se solape con otra en el mismo pabellón.
- Detalles adicionales: Utiliza estructuras de datos anidadas para representar los pabellones, las charlas y los asistentes. Implementa un algoritmo que pueda detectar solapamientos en el horario de las charlas.
- Elementos que considerar: Listas dentro de listas, diccionarios, verificación de solapamientos.
Inicio # Definir estructuras de datos Pabellones = Diccionario() # Diccionario para almacenar pabellones Charlas = Lista() # Lista para almacenar las charlas Asistentes = Lista() # Lista para almacenar los asistentes # Función para agregar una charla Función AgregarCharla(titulo, duracion, ponente, pabellon): charla = CrearCharla(titulo, duracion, ponente) # Verificar que no haya solapamiento de horarios en el pabellón Si VerificarSolapamiento(pabellon, charla): AgregarCharla(pabellon, charla) Imprimir(“Charla agregada correctamente.”) Sino: Imprimir(“Error: La charla se solapa con otra en el mismo pabellón.”) FinSi FinFunción # Función para crear una charla Función CrearCharla(titulo, duracion, ponente): charla = Diccionario() charla[“titulo”] = titulo charla[“duracion”] = duracion charla[“ponente”] = ponente charla[“asistentes”] = Lista() # Lista vacía de asistentes retorno charla FinFunción # Función para verificar solapamientos en el pabellón Función VerificarSolapamiento(pabellon, charlaNueva): # Iterar por las charlas del pabellón Para cada charla en Pabellones[pabellon]: # Verificar si el horario de la nueva charla se solapa con las existentes Si charlaNueva[“horaInicio”] < charla[“horaFin”] y charlaNueva[“horaFin”] > charla[“horaInicio”]: retorno Falso # Hay solapamiento FinSi FinPara retorno Verdadero # No hay solapamiento FinFunción # Función para asignar un asistente a una charla Función RegistrarAsistente(charla, asistente): # Agregar el asistente a la lista de la charla Agregar(asistente, charla[“asistentes”]) Imprimir(“Asistente registrado correctamente.”) FinFunción # Función para mostrar la programación de un pabellón Función MostrarProgramacion(pabellon): Si pabellon en Pabellones: Para cada charla en Pabellones[pabellon]: Imprimir(“Título:”, charla[“titulo”], “Ponente:”, charla[“ponente”], “Duración:”, charla[“duracion”]) Sino: Imprimir(“No hay charlas registradas en este pabellón.”) FinSi FinFunción # Ejemplo de uso # Agregar pabellones Pabellones[“Pabellón A”] = Lista() Pabellones[“Pabellón B”] = Lista() # Agregar charlas AgregarCharla(“Charla 1”, 2 horas, “Ponente A”, “Pabellón A”) AgregarCharla(“Charla 2”, 1.5 horas, “Ponente B”, “Pabellón A”) # Registrar asistentes RegistrarAsistente(Charlas[0], “Asistente 1”) RegistrarAsistente(Charlas[1], “Asistente 2”) # Mostrar programación de un pabellón MostrarProgramacion(“Pabellón A”) Fin | # Definir estructuras de datos pabellones = {} # Diccionario para almacenar pabellones charlas = [] # Lista para almacenar las charlas # Función para agregar una charla def agregar_charla(titulo, duracion, ponente, pabellon, hora_inicio, hora_fin): charla = crear_charla(titulo, duracion, ponente, hora_inicio, hora_fin) # Verificar que no haya solapamiento de horarios en el pabellón if verificar_solapamiento(pabellon, charla): if pabellon not in pabellones: pabellones[pabellon] = [] pabellones[pabellon].append(charla) print(“Charla agregada correctamente.”) else: print(“Error: La charla se solapa con otra en el mismo pabellón.”) # Función para crear una charla def crear_charla(titulo, duracion, ponente, hora_inicio, hora_fin): charla = { “titulo”: titulo, “duracion”: duracion, “ponente”: ponente, “hora_inicio”: hora_inicio, “hora_fin”: hora_fin, “asistentes”: [] # Lista vacía de asistentes } return charla # Función para verificar solapamientos en el pabellón def verificar_solapamiento(pabellon, charla_nueva): # Si el pabellón no tiene charlas, no hay solapamiento if pabellon not in pabellones: return True # Iterar por las charlas del pabellón for charla in pabellones[pabellon]: # Verificar si el horario de la nueva charla se solapa con las existentes if charla_nueva[“hora_inicio”] < charla[“hora_fin”] and charla_nueva[“hora_fin”] > charla[“hora_inicio”]: return False # Hay solapamiento return True # No hay solapamiento # Función para asignar un asistente a una charla def registrar_asistente(charla, asistente): # Agregar el asistente a la lista de la charla charla[“asistentes”].append(asistente) print(“Asistente registrado correctamente.”) # Función para mostrar la programación de un pabellón def mostrar_programacion(pabellon): if pabellon in pabellones: for charla in pabellones[pabellon]: print(f”Título: {charla[‘titulo’]}, Ponente: {charla[‘ponente’]}, Duración: {charla[‘duracion’]}”) else: print(“No hay charlas registradas en este pabellón.”) # Ejemplo de uso # Agregar pabellones y charlas pabellones[“Pabellón A”] = [] pabellones[“Pabellón B”] = [] # Agregar charlas agregar_charla(“Charla 1”, “2 horas”, “Ponente A”, “Pabellón A”, “10:00”, “12:00”) agregar_charla(“Charla 2”, “1.5 horas”, “Ponente B”, “Pabellón A”, “12:00”, “13:30”) # Registrar asistentes registrar_asistente(pabellones[“Pabellón A”][0], “Asistente 1”) registrar_asistente(pabellones[“Pabellón A”][1], “Asistente 2”) # Mostrar programación de un pabellón mostrar_programacion(“Pabellón A”) |
Explicación del pseudocódigo: Estructuras de Datos: Pabellones: Un diccionario que contiene los pabellones de la feria como claves, y cada valor es una lista de las charlas programadas en ese pabellón. Charlas: Una lista que almacena todas las charlas que se han agregado a la feria. Asistentes: Una lista que contiene los asistentes registrados. Funciones: AgregarCharla: Permite agregar una charla, pero antes verifica si existe un solapamiento de horarios con otras charlas en el mismo pabellón. Si hay solapamiento, no se agrega la charla. CrearCharla: Crea un diccionario que contiene los datos de una charla, incluyendo una lista vacía de asistentes. VerificarSolapamiento: Recorre las charlas de un pabellón y verifica si las horas de la nueva charla se solapan con las existentes. Retorna Falso si hay un solapamiento, Verdadero si no lo hay. RegistrarAsistente: Registra un asistente a una charla agregando su nombre a la lista de asistentes de la charla. MostrarProgramacion: Muestra la lista de charlas programadas para un pabellón específico. | Explicación del código: Estructuras de Datos: pabellones: Un diccionario que almacena los pabellones de la feria como claves, y cada valor es una lista de las charlas programadas en ese pabellón. charlas: Una lista que almacena todas las charlas que se han agregado a la feria. Funciones: agregar_charla: Esta función agrega una charla a un pabellón si no hay solapamiento de horarios. Si hay solapamiento, no agrega la charla y muestra un mensaje de error. crear_charla: Crea un diccionario con los datos de la charla, como el título, duración, ponente, hora de inicio y fin, y una lista vacía de asistentes. verificar_solapamiento: Verifica si la charla nueva se solapa con alguna charla ya programada en el mismo pabellón. Si las horas de la charla se solapan, retorna False; si no, True. registrar_asistente: Registra un asistente a una charla, agregando el nombre del asistente a la lista de asistentes de esa charla. mostrar_programacion: Muestra la lista de todas las charlas programadas para un pabellón específico. Ejemplo de uso: Se crean dos pabellones: “Pabellón A” y “Pabellón B”. Se agregan dos charlas al “Pabellón A”. Se registran dos asistentes para las charlas. Se muestra la programación de un pabellón (“Pabellón A”). |
Detalles adicionales: Solapamiento de horarios: El algoritmo verifica si el horario de inicio y fin de una charla nueva se solapa con cualquier charla existente en el mismo pabellón. Si no hay solapamiento, se agrega la charla al pabellón. Estructura anidada: Las charlas están representadas por listas dentro de un diccionario de pabellones, lo que permite gestionar varias charlas por pabellón. Este pseudocódigo cubre las funcionalidades clave de gestión de eventos en una feria de tecnología, como agregar y registrar charlas, verificar solapamientos y manejar los asistentes. | Detalles: Solapamiento de horarios: El algoritmo verifica si el horario de inicio y fin de la charla nueva se solapa con las charlas ya registradas en el mismo pabellón. Si hay solapamiento, no se agrega la charla. |
Ejemplo 4. Simulador de Gestión de Equipos de Deportes
- Enunciado: En una liga de fútbol, hay varios equipos. Cada equipo tiene una lista de jugadores, y cada jugador tiene un nombre, posición y número de goles marcados durante la temporada. El objetivo es crear un sistema para agregar jugadores a los equipos, realizar un seguimiento de los goles de cada jugador y determinar el equipo con más goles al final de la temporada.
- Objetivo: Utiliza listas y diccionarios para representar los equipos y jugadores. Implementa una función para agregar jugadores, actualizar los goles de los jugadores después de cada partido y determinar el equipo con más goles.
- Detalles adicionales: Utiliza bucles anidados para acceder a los jugadores dentro de cada equipo y sumando los goles para determinar el equipo ganador.
- Elementos que considerar: Listas anidadas, diccionarios, funciones.
// Crear una lista para almacenar los equipos de fútbol equipos = {} Función agregar_equipo(nombre_equipo): // Crear un diccionario para el equipo con su nombre y una lista vacía de jugadores equipo = {“nombre”: nombre_equipo, “jugadores”: []} equipos[nombre_equipo] = equipo Función agregar_jugador(nombre_equipo, nombre_jugador, posicion, goles): // Verificar si el equipo existe Si nombre_equipo en equipos: // Crear un diccionario para el jugador jugador = {“nombre”: nombre_jugador, “posicion”: posicion, “goles”: goles} // Agregar el jugador a la lista de jugadores del equipo equipos[nombre_equipo][“jugadores”].agregar(jugador) Sino: Imprimir(“Error: El equipo no existe.”) // Función para actualizar los goles de un jugador después de un partido Función actualizar_goles(nombre_equipo, nombre_jugador, goles): Si nombre_equipo en equipos: // Buscar el jugador en la lista de jugadores del equipo Para cada jugador en equipos[nombre_equipo][“jugadores”]: Si jugador[“nombre”] es igual a nombre_jugador: jugador[“goles”] = jugador[“goles”] + goles Imprimir(“Goles actualizados para el jugador ” + nombre_jugador) Salir del bucle Sino: Imprimir(“Error: El jugador no se encuentra en el equipo.”) Sino: Imprimir(“Error: El equipo no existe.”) // Función para determinar el equipo con más goles al final de la temporada Función equipo_con_mas_goles(): equipo_ganador = “” max_goles = 0 // Recorrer todos los equipos Para cada equipo en equipos: goles_totales = 0 // Sumar los goles de todos los jugadores del equipo Para cada jugador en equipos[equipo][“jugadores”]: goles_totales = goles_totales + jugador[“goles”] // Verificar si el equipo tiene más goles que el máximo registrado Si goles_totales > max_goles: max_goles = goles_totales equipo_ganador = equipo Imprimir(“El equipo con más goles es: ” + equipo_ganador + ” con ” + max_goles + ” goles.”) | # Definir estructura de datos equipos = [] # Lista para almacenar los equipos # Función para agregar un jugador a un equipo def agregar_jugador(equipo, nombre_jugador, posicion): nuevo_jugador = { ‘nombre’: nombre_jugador, ‘posicion’: posicion, ‘goles’: 0 # Inicialmente, los goles son 0 } equipo[‘jugadores’].append(nuevo_jugador) # Función para actualizar goles después de un partido def actualizar_goles(equipo, nombre_jugador, goles_anotados): # Buscar el jugador en la lista de jugadores del equipo for jugador in equipo[‘jugadores’]: if jugador[‘nombre’] == nombre_jugador: jugador[‘goles’] += goles_anotados return print(“Jugador no encontrado”) # Función para determinar el equipo con más goles def equipo_con_mas_goles(): equipo_ganador = None max_goles = 0 for equipo in equipos: total_goles = sum(jugador[‘goles’] for jugador in equipo[‘jugadores’]) if total_goles > max_goles: equipo_ganador = equipo max_goles = total_goles return equipo_ganador, max_goles # Ejemplo de uso # Crear equipos equipo_1 = {‘nombre’: ‘Equipo A’, ‘jugadores’: []} equipo_2 = {‘nombre’: ‘Equipo B’, ‘jugadores’: []} equipos.append(equipo_1) equipos.append(equipo_2) # Agregar jugadores a los equipos agregar_jugador(equipo_1, ‘Jugador 1’, ‘Delantero’) agregar_jugador(equipo_1, ‘Jugador 2’, ‘Defensa’) agregar_jugador(equipo_2, ‘Jugador 3’, ‘Mediocampista’) agregar_jugador(equipo_2, ‘Jugador 4’, ‘Portero’) # Actualizar goles después de un partido actualizar_goles(equipo_1, ‘Jugador 1’, 2) actualizar_goles(equipo_1, ‘Jugador 2’, 1) actualizar_goles(equipo_2, ‘Jugador 3’, 3) actualizar_goles(equipo_2, ‘Jugador 4’, 0) # Determinar el equipo con más goles equipo_ganador, max_goles = equipo_con_mas_goles() print(f”El equipo con más goles es {equipo_ganador[‘nombre’]} con {max_goles} goles.”) |
Explicación:
| Explicación del código:
Este código en Python refleja el flujo y la estructura descritos en el pseudocódigo, utilizando diccionarios para representar los equipos y jugadores, y realizando operaciones básicas de manipulación de listas y diccionarios. |
- Solución basada en: Eric Grimson, and John Guttag. 6.00 Introduction to Computer Science and Programming. Fall 2008. Massachusetts Institute of Technology: MIT OpenCourseWare, https://ocw.mit.edu. License: Creative Commons BY-NC-SA.↵
