Contenido del curso
Julian David Chavarro Balanta
student•
hace un año
Julian David Chavarro Balanta
student•
hace un año
Contenido del curso
Julian David Chavarro Balanta
Julian David Chavarro Balanta
david felipe matallana martinez
Steven Andres Moreno Melendez
José Milton Ruiz Murillo
Jairo Sánchez Sánchez
Mónica Cruz
Maria Magdalena Nava Martinez
Christian Camilo Hermoso Forero
Fernando Lambraño Leon
Miguel Lozano
Fabiola Jessica Huancollo Chambi
Valeria Hernández
Claudia Cecilia Ruiz Duque
Fernando Lambraño Leon
Sindy Leon
Carlos Alejandro Derobertis
Gizela Delgado Soto
Ivan Andres Suarez Alfonso
MARIA TERESA PANIAGUA RIVERA
santiago sanchez correa
Santiago Heredia
Pienso qué el desafío no está en las paradas, porque todos están en paradas diferentes y van a pisos diferentes, lo único a tener en cuenta es no repetir el mismo piso
Diría que el desafío está en el tiempo, basado en eso daré 2 segundos a cada parada sea para subirse o bajarse del ascensor y 1 segundo a cambiar de piso.
tiempo\_parada = 2 tiempo\_cambio\_piso = 1 tiempo\_total = 0 def calcularTiempo(inicio, fin):   return tiempo\_cambio\_piso\*abs(fin - inicio) + tiempo\_parada \# Recogere Piso2 tiempo\_total += calcularTiempo(1, 2) \# Recoger a Carla Piso3 tiempo\_total += calcularTiempo(2, 3) \# Dejar a Carla Piso4 tiempo\_total += calcularTiempo(3, 4) \# Recoger a Pedro Piso5 tiempo\_total += calcularTiempo(4, 5) \# Recoger a Juana Piso 8 tiempo\_total += calcularTiempo(5, 8) \# Dejarme Piso10 tiempo\_total += calcularTiempo(8, 10) \# Dejar a Juana piso7 tiempo\_total += calcularTiempo(10, 7) \# Dejar a Pedro piso1 tiempo\_total += calcularTiempo(7, 1) print(f"El tiempo total es de {tiempo\_total} segundos")
El tiempo total es de 34 segundos
tiempo_parada = 2 tiempo_cambio_piso = 1 tiempo_total = 0 def calcularTiempo(inicio, fin): return tiempo_cambio_piso*abs(fin - inicio) + tiempo_parada # Recogere Piso2 tiempo_total += calcularTiempo(1, 2) # Recoger a Carla Piso3 tiempo_total += calcularTiempo(2, 3) # Dejar a Carla Piso4 tiempo_total += calcularTiempo(3, 4) # Recoger a Pedro Piso5 tiempo_total += calcularTiempo(4, 5) # Recoger a Juana Piso 8 tiempo_total += calcularTiempo(5, 8) # Dejarme Piso10 tiempo_total += calcularTiempo(8, 10) # Dejar a Juana piso7 tiempo_total += calcularTiempo(10, 7) # Dejar a Pedro piso1 tiempo_total += calcularTiempo(7, 1) print(f"El tiempo total es de {tiempo_total} segundos") ```tiempo\_parada = 2tiempo\_cambio\_piso = 1tiempo\_total = 0 def calcularTiempo(inicio, fin): return tiempo\_cambio\_piso\*abs(fin - inicio) + tiempo\_parada \# Recogere Piso2tiempo\_total += calcularTiempo(1, 2)# Recoger a Carla Piso3tiempo\_total += calcularTiempo(2, 3)# Dejar a Carla Piso4tiempo\_total += calcularTiempo(3, 4)# Recoger a Pedro Piso5tiempo\_total += calcularTiempo(4, 5)# Recoger a Juana Piso 8tiempo\_total += calcularTiempo(5, 8)# Dejarme Piso10tiempo\_total += calcularTiempo(8, 10)# Dejar a Juana piso7tiempo\_total += calcularTiempo(10, 7)# Dejar a Pedro piso1tiempo\_total += calcularTiempo(7, 1) print(f"El tiempo total es de {tiempo\_total} segundos")
que curso tan bueno, 100000/10
Realmente este reto me hizo llorar no pude hacerlo solo, me toco pedir ayuda y tutoria de gemini para hacerlo paso a paso lo primero que me dijo fue que hay que optimizar el reccorido en 2 paras 1 para la subida otro para la bajada dentro es estos paras nesecitabamos una condicion Si entonces anidada y tambien me enseño a que podia dimensionar varias partes en una sola dimension para no estarlo haciendo una a una tambien me recomendo hacer un gimnasio de pensamiento logico para estar puliendo y practicando con el esto
Algoritmo Elevador_Final_Pro
// 1. Datos del edificio y gente
Dimensionar nombres(4), origen(4), destino(4)
nombres[0] <- 'Steven'
origen[0] <- 2
destino[0] <- 10
nombres[1] <- 'Pedro'
origen[1] <- 5
destino[1] <- 1
nombres[2] <- 'Juan'
origen[2] <- 8
destino[2] <- 7
nombres[3] <- 'Carla'
origen[3] <- 3
destino[3] <- 4
// 2. VIAJE DE SUBIDA (Del 1 al 10)
Escribir '--- ASCENSOR SUBIENDO ---'
Para p<-1 Hasta 10 Hacer
Para i<-0 Hasta 3 Hacer
// Si el origen es este piso y va hacia ARRIBA
Si origen[i]==p Y destino[i]>origen[i] Entonces
Escribir 'Piso ', p, ': Sube ', nombres[i]
FinSi
// Si el destino es este piso y venía desde ABAJO
Si destino[i]==p Y destino[i]>origen[i] Entonces
Escribir 'Piso ', p, ': Baja ', nombres[i]
FinSi
FinPara
FinPara
// 3. VIAJE DE BAJADA (Del 10 al 1)
Escribir '--- ASCENSOR BAJANDO ---'
Para p<-10 Hasta 1 Con Paso -1 Hacer
Para i<-0 Hasta 3 Hacer
// Si el origen es este piso y va hacia ABAJO
Si origen[i]==p Y destino[i]<origen[i] Entonces
Escribir 'Piso ', p, ': Sube ', nombres[i]
FinSi
// Si el destino es este piso y venía desde ARRIBA
Si destino[i]==p Y destino[i]<origen[i] Entonces
Escribir 'Piso ', p, ': Baja ', nombres[i]
FinSi
FinPara
FinPara
FinAlgoritmo
Implementación del Motor de Decisiones: Lógica de Paradas Concurrentes
1. Explicación: La Estrategia de Eficiencia
Para este proyecto, el objetivo no es solo mover un ascensor, sino optimizar el recurso energético y el tiempo. He aplicado el Algoritmo SCAN (o Algoritmo del Elevador).
• Agrupación Direccional: El sistema no atiende llamadas por orden de llegada, sino por dirección. Si el ascensor sube, termina todas las tareas de subida antes de cambiar de sentido.
• Recogida en Ruta: El ascensor es capaz de recoger pasajeros nuevos siempre que su destino coincida con la dirección actual de la cabina.
• Impacto: Esto reduce el recorrido total de la cabina de 30 pisos (en un sistema simple) a solo 18 pisos, logrando un ahorro del 40%.
2. Pensamiento Lógico: El Diagrama de Flujo
Antes de programar, diseñé la lógica de decisión. Este diagrama muestra cómo el sistema filtra las solicitudes y decide cuándo detenerse.
Puntos clave del diagrama:
1. Entrada de datos: Registro de todos los pasajeros.
2. Clasificación: División entre grupos "Subida" y "Bajada".
3. Bucle de Movimiento: Verificación constante de origen/destino en cada piso.
3. Implementación: El Código en Python
Aquí el pensamiento lógico se convierte en instrucciones reales. El código es interactivo y permite ingresar cualquier número de pasajeros.
# =================================================================
# SISTEMA DE ASCENSOR OPTIMIZADO CON REPORTE DETALLADO
# Autor: José Milton Ruiz Murillo
# =================================================================
def simular_ascensor_final():
piso_actual = 1
pasos_totales_globales = 0
solicitudes = []
print("=== CONTROLADOR DE ASCENSOR: PENSAMIENTO LÓGICO ===")
try:
n = int(input("¿Cuántas personas usarán el ascensor?: "))
except ValueError:
print("Error: Por favor, ingresa un número entero.")
return
# 1. CAPTURA DE DATOS (Interactivo uno por uno)
for i in range(n):
print(f"\n--- Pasajero {i+1} ---")
nombre = input("Nombre: ")
origen = int(input(f"¿En qué piso está {nombre}?: "))
destino = int(input(f"¿A qué piso va {nombre}?: "))
# Guardamos la información con estados de control
solicitudes.append({
"nombre": nombre,
"origen": origen,
"destino": destino,
"pasos_viaje": 0,
"en_viaje": False,
"completado": False
})
# 2. LÓGICA DE DIRECCIÓN (Clasificación para eficiencia)
subiendo = [s for s in solicitudes if s["destino"] > s["origen"]]
bajando = [s for s in solicitudes if s["destino"] < s["origen"]]
print("\n" + "="*50)
print("INICIANDO RECORRIDO DE ALTA EFICIENCIA")
print("="*50)
# --- FASE 1: RECORRIDO DE SUBIDA ---
if subiendo:
print("\n>>> MODO: SUBIENDO")
# Determinamos el punto más alto necesario
piso_max_subida = max([s["destino"] for s in subiendo] + [s["origen"] for s in subiendo])
for piso in range(piso_actual, piso_max_subida + 1):
piso_actual = piso
print(f"Piso {piso_actual}...")
# REGLA: Dejar pasajeros y reportar su viaje individual
for s in subiendo:
if s["en_viaje"]:
s["pasos_viaje"] += 1
if s["destino"] == piso_actual and not s["completado"]:
s["completado"] = True
s["en_viaje"] = False
print(f" [OK] Bajando a {s['nombre']}. (Viaje individual: {s['pasos_viaje']} pisos)")
# REGLA: Recoger pasajeros en el camino
for s in subiendo:
if s["origen"] == piso_actual and not s["completado"]:
s["en_viaje"] = True
print(f" [!] Subiendo a {s['nombre']} (Hacia piso {s['destino']})")
if piso_actual < piso_max_subida:
pasos_totales_globales += 1
# --- FASE 2: RECORRIDO DE BAJADA ---
if bajando:
print("\n>>> MODO: BAJANDO")
# Si el ascensor quedó abajo de donde alguien quiere bajar, debe subir vacío
inicio_bajada = max([b["origen"] for b in bajando])
while piso_actual < inicio_bajada:
piso_actual += 1
pasos_totales_globales += 1
print(f"Piso {piso_actual}... (Subiendo vacío para recoger)")
# Iniciamos el descenso
piso_min_bajada = min([b["destino"] for b in bajando])
for piso in range(piso_actual, piso_min_bajada - 1, -1):
piso_actual = piso
print(f"Piso {piso_actual}...")
# REGLA: Dejar pasajeros
for b in bajando:
if b["en_viaje"]:
b["pasos_viaje"] += 1
if b["destino"] == piso_actual and not b["completado"]:
b["completado"] = True
b["en_viaje"] = False
print(f" [OK] Bajando a {b['nombre']}. (Viaje individual: {b['pasos_viaje']} pisos)")
# REGLA: Recoger pasajeros
for b in bajando:
if b["origen"] == piso_actual and not b["completado"]:
b["en_viaje"] = True
print(f" [!] Subiendo a {b['nombre']} (Hacia piso {b['destino']})")
if piso_actual > piso_min_bajada:
pasos_totales_globales += 1
# 3. REPORTE FINAL DE RESULTADOS
print("\n" + "="*50)
print("REPORTE DE EFICIENCIA FINAL")
print("-" * 50)
for s in solicitudes:
estado = "Completado" if s["completado"] else "No realizado"
print(f"Pasajero: {s['nombre']:<10} | Viaje: {s['pasos_viaje']:2} pisos | {estado}")
print("-" * 50)
print(f"MOVIMIENTOS TOTALES DE LA CABINA: {pasos_totales_globales} pisos")
print(f"Estado Final: ESPERA en piso {piso_actual}")
print(f"Autor: José Milton Ruiz Murillo")
print("="*50)
# Iniciar el programa
if __name__ == "__main__":
simular_ascensor_final()
4. Resultados y Validación: Un Sistema Interactivo y Transparente
Para validar que el pensamiento lógico se aplicó correctamente, el programa genera un flujo de salida dividido en tres hitos fundamentales:
A. Entrada Dinámica (El valor agregado)
A diferencia de un código estático, este proyecto incluye una interfaz de consola interactiva.
• Qué hace: El sistema inicia solicitando la cantidad de usuarios y, acto seguido, pide individualmente el nombre, origen y destino de cada pasajero.
• Por qué importa: Esto permite probar el algoritmo bajo cualquier escenario de estrés o cantidad de personas sin modificar el código.
B. Trazabilidad en Tiempo Real (Proceso de Movimiento)
Mientras el ascensor opera, el sistema no salta directamente al final; va narrando su recorrido.
• Visualización: Verás en pantalla cómo el contador de pisos avanza uno a uno (Piso 1..., Piso 2...).
• Eventos: El programa señaliza con etiquetas claras ([!] para subir y [OK] para bajar) el momento exacto en que interactúa con un pasajero, permitiendo verificar que se cumple la Regla de Coincidencia (recoger a alguien mientras ya hay otro pasajero a bordo).
C. Reporte de Eficiencia Final (Métricas de Éxito)
Al finalizar todas las tareas, el sistema entrega un desglose detallado:
• Conteo por Pasajero: Indica cuántos pisos se movió cada persona (comprobando que su viaje fue directo).
• Conteo Global: Muestra la cantidad total de pisos que se desplazó la cabina.
• Validación Lógica: Aquí se confirma el éxito del proyecto: el total de pisos recorridos es menor a la suma de los viajes individuales, demostrando una optimización real de recursos.
Conclusión
Lo que hace único a este controlador es su capacidad interactiva. He diseñado el código para que, al ejecutarse, solicite dinámicamente el número de usuarios y sus rutas (Origen/Destino).
Durante la ejecución, el sistema ofrece una bitácora en tiempo real de cada piso recorrido, diferenciando visualmente cuándo está en 'Modo Subida' o 'Modo Bajada'. Finalmente, el programa entrega un reporte de métricas que desglosa los movimientos individuales frente al movimiento global, validando matemáticamente la eficiencia del algoritmo.
Way to go Milton!! 💯
Hola, al problema le agregue tiempo porque siempre se harán 8 paradas, así que le agregue 1 segundo por piso y 4 segundos por subida o bajada.
Este curso no cumple mis expectativas. Pésimo. Su examen va dirigido a programadores. Muy lejos de las habilidades que requiero fortalecer. Esto es una habilidad dura
Buen curso, sin embargo, creo que las preguntas deberían mejorarse para evaluar conceptos generales y lógica.
Comparto el diagrama que hice:
Primera versión del código (no respectaba si subia o bajaba, es decir, no estaba optimizado):
piso_actual = 1 direccion = "subir" recogida = [2,5,8,3] destinos = [4,10,7,1] while len(recogida) != 0 and len(destinos) != 0: print("Piso actual:", piso_actual) if piso_actual in recogida: print("[PARAR Y RECOGER]") recogida.remove(piso_actual) print("Recogida", recogida) if piso_actual in destinos: print("[PARAR Y DEJAR]") destinos.remove(piso_actual) #logica movimiento if direccion == "subir": piso_actual+=1 if piso_actual == 10: direccion = "bajar" else: piso_actual-=1 if piso_actual == 1: direccion = "subir" print("TODOS HAN LLEGADO A SU DESTINO!")
Versión optimizada teniendo en cuenta los siguientes puntos:
# Estado inicial piso_actual = 1 direccion = "subir" # Diccionario de solicitudes {piso_origen: piso_destino} solicitudes = { 2: 10, # Vos 5: 1, # Pedro 8: 7, # Juan 3: 4 # Carla } # Lista para saber quién está dentro del ascensor (guardamos sus destinos) pasajeros_dentro = [] # El ciclo continúa mientras haya gente esperando O gente dentro del ascensor while solicitudes or pasajeros_dentro: print(f"\n--- Piso actual: {piso_actual} (Dirección: {direccion}) ---") # 1. Lógica para DEJAR personas (Descenso) if piso_actual in pasajeros_dentro: # Quitamos todas las instancias de este piso (por si varias personas bajan aquí) while piso_actual in pasajeros_dentro: pasajeros_dentro.remove(piso_actual) print(f"[PARAR Y DEJAR] Pasajero llegó a su destino.") # 2. Lógica para RECOGER personas (Ascenso) if piso_actual in solicitudes: destino_persona = solicitudes[piso_actual] # Determinamos hacia dónde va la persona direccion_persona = "subir" if destino_persona > piso_actual else "bajar" # REGLA DE OPTIMIZACIÓN: Solo recogemos si va en nuestra misma dirección if direccion_persona == direccion: pasajeros_dentro.append(destino_persona) del solicitudes[piso_actual] # Ya no está esperando en el piso print(f"[PARAR Y RECOGER] Pasajero sube. Destino: Piso {destino_persona}") else: print(f"[PASAR DE LARGO] Hay alguien esperando para {direccion_persona}, pero yo voy {direccion}.") # 3. Lógica de MOVIMIENTO if direccion == "subir": if piso_actual < 10: piso_actual += 1 else: direccion = "bajar" piso_actual -= 1 else: # direccion == "bajar" if piso_actual > 1: piso_actual -= 1 else: direccion = "subir" piso_actual += 1 print("\n========================================") print("¡TODOS HAN LLEGADO A SU DESTINO!") print("========================================")
Bueno, aquí yo lo hice en pseudocódigo 😅:
Algoritmo ascensor Dimension viajes[4,3] //Fabiola viajes[0,0] = 2//punto de partida viajes[0,1] = 10//punto de destino viajes[0,2] = 1//#persona //Carla viajes[1,0] = 3//punto de partida viajes[1,1] = 4//punto de destino viajes[1,2] = 2//#persona //Pedro viajes[2,0] = 5//punto de partida viajes[2,1] = 1//punto de destino viajes[2,2] = 3//#persona //Juana viajes[3,0] = 8//punto de partida viajes[3,1] = 7//punto de destino viajes[3,2] = 4//#persona nro_parada = 0 nro_subida = 0 nro_bajada = 0 nro_personas_ascensor = 0 nro_trayecto = 1 Mientras nro_trayecto <= 2 Hacer Si nro_trayecto MOD 2 = 0 Entonces //el ascensor baja punto_inicial = 10 punto_termino = 1 nro_bajada_x_trayecto = 0 Para j desde punto_inicial hasta punto_termino Hacer Si nro_personas_ascensor > 0 Entonces Para i desde 0 hasta 3 Hacer Si viajes[i, 0] > viajes[i, 1] Y viajes[i, 1] == j Entonces nro_bajada = nro_bajada + 1 nro_bajada_x_trayecto = nro_bajada_x_trayecto + 1 nro_parada = nro_parada + 1 nro_personas_ascensor = nro_personas_ascensor - 1 FinSi FinPara FinSi FinPara Escribir "Trayecto #: ", nro_trayecto Escribir "En este trayecto bajan: " , nro_bajada_x_trayecto, " personas" Escribir "Con el trayecto de bajada ya van bajando del ascensor un total de: " , nro_bajada Escribir "Con el trayecto de bajada el ascensor ya va parando un total de: ", nro_parada Escribir "La cantidad de personas en el ascensor ahora es de: ", nro_personas_ascensor SiNo //el ascensor sube punto_inicial = 1 punto_termino = 10 nro_subida_x_trayecto = 0 nro_bajada_x_trayecto = 0 Para j desde punto_inicial hasta punto_termino Hacer Si viajes[0, 0] == j O viajes[1, 0] == j O viajes[2, 0] == j O viajes[3, 0] == j Entonces nro_subida = nro_subida + 1 nro_subida_x_trayecto = nro_subida_x_trayecto + 1 Si nro_subida > 1 Entonces Para i desde 0 hasta 3 Hacer Si viajes[i, 0] < viajes[i, 1] Y viajes[i, 1] == j Entonces nro_bajada = nro_bajada + 1 nro_bajada_x_trayecto = nro_bajada_x_trayecto + 1 nro_parada = nro_parada + 0 FinSi FinPara FinSi nro_parada = nro_parada + 1 nro_personas_ascensor = nro_subida - nro_bajada SiNo Si nro_personas_ascensor > 0 Entonces Para i desde 0 hasta 3 Hacer Si viajes[i, 0] < viajes[i, 1] Y viajes[i, 1] == j Entonces nro_bajada = nro_bajada + 1 nro_bajada_x_trayecto = nro_bajada_x_trayecto + 1 nro_parada = nro_parada + 1 FinSi FinPara nro_personas_ascensor = nro_subida - nro_bajada FinSi FinSi FinPara Escribir "Trayecto #: ", nro_trayecto Escribir "En este trayecto suben: " , nro_subida_x_trayecto, " personas" Escribir "Con el trayecto de subida ya van subiendo un total de personas: " , nro_subida Escribir "En este trayecto bajan: " , nro_bajada_x_trayecto, " personas" Escribir "Con el trayecto de subida ya van bajando un total de personas: " , nro_bajada Escribir "La cantidad de paradas que está teniendo el ascensor hasta el momento: ", nro_parada Escribir "La cantidad de personas en el ascensor hasta el momento: ", nro_personas_ascensor FinSi nro_trayecto = nro_trayecto + 1 FinMientras FinAlgoritmo
Desafio del elevador resuelto
Algoritmo desafio_elevador piso_inicial = 1 piso_final = 10 tiempo_paradas_subida = 0 tiempo_paradas_bajada = 0 tiempo_movimiento_por_piso = 1 respuesta_usuario = '' // 1. TRAYECTO DE SUBIDA Mientras piso_inicial < 10 Hacer Escribir "El ascensor está en el piso ", piso_inicial, " y va a subir." Escribir "¿Alguien se sube/baja en este piso? (0 para No, 1 para Si):" Leer respuesta_usuario Si respuesta_usuario == '1' Entonces tiempo_paradas_subida = tiempo_paradas_subida + 2 FinSi piso_inicial = piso_inicial + 1 FinMientras tiempo_total_subida = (10 * tiempo_movimiento_por_piso) + tiempo_paradas_subida Escribir "--- El ascensor llegó al tope. Tiempo de subida: ", tiempo_total_subida, " segundos. ---" Escribir "" // 2. TRAYECTO DE BAJADA Mientras piso_final > 0 Hacer Escribir "El ascensor está en el piso ", piso_final, " y va a descender." Escribir "¿Alguien se sube/baja en este piso? (0 para No, 1 para Si):" Leer respuesta_usuario Si respuesta_usuario == '1' Entonces tiempo_paradas_bajada = tiempo_paradas_bajada + 2 FinSi piso_final = piso_final - 1 FinMientras // El tiempo de bajada tiempo_total_bajada = (10 * tiempo_movimiento_por_piso) + tiempo_paradas_bajada Escribir "--- El ascensor regresó a la planta baja. Tiempo de bajada: ", tiempo_total_bajada, " segundos. ---" Escribir "" // RESULTADO FINAL tiempo_total_recorrido = tiempo_total_subida + tiempo_total_bajada Escribir 'El tiempo total de todo el recorrido del ascensor es de: ', tiempo_total_recorrido, ' segundos.' FinAlgoritmo
# -----------------------------
# Datos del problema
# -----------------------------
pasajeros = [
{"nombre": "Vos", "origen": 2, "destino": 10},
{"nombre": "Pedro", "origen": 5, "destino": 1},
{"nombre": "Juan", "origen": 8, "destino": 7},
{"nombre": "Carla", "origen": 3, "destino": 4}
]
ascensor_pos = 1
paradas = []
# -----------------------------
# Clasificación por dirección
# -----------------------------
ascendentes = [p for p in pasajeros if p["origen"] < p["destino"]]
descendentes = [p for p in pasajeros if p["origen"] > p["destino"]]
# Ordenar por cercanía
ascendentes.sort(key=lambda p: p["origen"]) # origen ascendente
descendentes.sort(key=lambda p: p["origen"], reverse=True) # origen descendente
# -----------------------------
# Función para mover el ascensor
# -----------------------------
def mover_a(piso):
global ascensor_pos
if ascensor_pos != piso:
paradas.append(piso)
ascensor_pos = piso
# -----------------------------
# Recorrido ascendente
# -----------------------------
for p in ascendentes:
mover_a(p["origen"]) # recoger
for p in ascendentes:
mover_a(p["destino"]) # dejar
# -----------------------------
# Recorrido descendente
# -----------------------------
for p in descendentes:
mover_a(p["origen"]) # recoger
for p in descendentes:
mover_a(p["destino"]) # dejar
# -----------------------------
# Resultado final
# -----------------------------
print("Secuencia de paradas del ascensor:")
print(paradas)
from dataclasses import dataclass from typing import List, Dict, Tuple @dataclass(frozen=True) class Request: name: str origin: int destination: int def plan_scan_route( requests: List[Request], start_floor: int = 1, building_floors: int = 10, ) -> Tuple[List[int], List[str]]: """ Planifica una ruta tipo SCAN: 1) SUBIR: parar en floors de ORIGEN para recoger. (Opcionalmente podrías permitir dropoffs 'hacia arriba' aquí.) 2) Ir al máximo destino/origen relevante hacia arriba. 3) BAJAR: parar en destinos en orden descendente, terminar en start_floor. Devuelve: - lista de paradas (floors) - log de eventos (strings) """ # Validaciones básicas for r in requests: if not (1 <= r.origin <= building_floors and 1 <= r.destination <= building_floors): raise ValueError(f"Request fuera de rango: {r}") if r.origin == r.destination: raise ValueError(f"Origen y destino iguales no tiene sentido: {r}") waiting_by_floor: Dict[int, List[Request]] = {} for r in requests: waiting_by_floor.setdefault(r.origin, []).append(r) onboard: List[Request] = [] stops: List[int] = [start_floor] events: List[str] = [f"Inicio en piso {start_floor}"] # Pisos de pickup por encima del start pickup_floors_up = sorted([f for f in waiting_by_floor.keys() if f >= start_floor]) # Para asegurar que sí o sí alcanzamos el máximo que necesitamos hacia arriba: # (máximo entre pickups y destinos) max_needed = max([start_floor] + [r.origin for r in requests] + [r.destination for r in requests]) # SUBIR: recoger en pisos de origen current = start_floor for f in pickup_floors_up: if f < current: continue if f != current: current = f stops.append(current) # recoger if current in waiting_by_floor: for r in waiting_by_floor[current]: onboard.append(r) events.append(f"Pickup: {r.name} en piso {r.origin} -> destino {r.destination}") del waiting_by_floor[current] # Subir hasta max_needed si no estamos ahí (ej: destino 10) if current != max_needed: current = max_needed stops.append(current) # En este punto, hacemos dropoffs SOLO en bajada (orden descendente) events.append(f"Cambio a BAJAR desde piso {current}") # Construir lista de destinos pendientes (de los que llevamos) pending_dropoffs = sorted({r.destination for r in onboard}, reverse=True) # Bajar parando en destinos for d in pending_dropoffs: if d == current: # dropoff inmediato leaving = [r for r in onboard if r.destination == d] onboard = [r for r in onboard if r.destination != d] for r in leaving: events.append(f"Dropoff: {r.name} en piso {d}") continue # bajar a d current = d stops.append(current) leaving = [r for r in onboard if r.destination == d] onboard = [r for r in onboard if r.destination != d] for r in leaving: events.append(f"Dropoff: {r.name} en piso {d}") # Finalmente volver a start_floor (si no quedó allí) if current != start_floor: current = start_floor stops.append(current) events.append("Fin: todos llegaron a su destino") return stops, events if __name__ == "__main__": # Tu caso requests = [ Request("Vos", origin=2, destination=10), Request("Pedro", origin=5, destination=1), Request("Juana", origin=8, destination=7), Request("Carla", origin=3, destination=4), ] stops, events = plan_scan_route(requests, start_floor=1, building_floors=10) print("Paradas:", stops) print("\nEventos:") for e in events: print("-", e)
Listo, plantee el siguiente codigo: teniendo en cuenta que se prioriza la dirección, asi que priorice los que suben y luego los que bajan:
# Ascensor - versión simplificada para principiantes
piso = 1
print("El ascensor inicia en el piso", piso)
# SUBIDA
print("\n--- SUBIDA ---")
subida = [
(2, "SL", "recoge"),
(3, "Carla", "recoge"),
(4, "Carla", "baja"),
(10, "SL", "baja")
]
for parada in subida:
piso = parada[0]
nombre = parada[1]
accion = parada[2]
if accion == "recoge":
print("Sube al piso", piso, "y recoge a", nombre)
else:
print(nombre, "baja en el piso", piso)
# BAJADA
print("\n--- BAJADA ---")
bajada = [
(8, "Juan", "recoge"),
(7, "Juan", "baja"),
(5, "Pedro", "recoge"),
(1, "Pedro", "baja")
]
for parada in bajada:
piso = parada[0]
nombre = parada[1]
accion = parada[2]
if accion == "recoge":
print("Baja al piso", piso, "y recoge a", nombre)
else:
print(nombre, "baja en el piso", piso)
print("\nFin del recorrido")
-----------------------------------------
El ascensor inicia en el piso 1
--- SUBIDA ---
Sube al piso 2 y recoge a SL
Sube al piso 3 y recoge a Carla
Carla baja en el piso 4
SL baja en el piso 10
--- BAJADA ---
Baja al piso 8 y recoge a Juan
Juan baja en el piso 7
Baja al piso 5 y recoge a Pedro
Pedro baja en el piso 1
Fin del recorrido
Muy bueno
"Programar no se trata de memorizar sintaxis, sino de pensar de forma lógica" 🙌
En mi caso decidí explorar el uso de Python. Una de las cosas que me costo fue entender toda la lógica del asunto. Para priorizar la velocidad agrupe las subidas primero y luego realizar las solicitudes de bajadas.
#=============================== #Ascensor subidas y bajadas #=============================== import time # 1.Leer numero de pisos pisos= int(input("Ingrese el numero total de pisos del edificio ")) #2. Solicitudes solicitudes= [ {"nombre":"Ivan","origen" : 2, "destino": 10}, {"nombre":"Pedro","origen" : 5, "destino": 1}, {"nombre":"Juan","origen" : 8, "destino": 7}, {"nombre":"Carla","origen" : 3, "destino": 4}, ] #3: Clasificar solicitudes subidas = [] bajadas = [] for s in solicitudes: if s["destino"] > s["origen"]: subidas.append(s) else: bajadas.append(s) #4. Ordenar por recorrido subidas.sort(key=lambda x: x["origen"]) bajadas.sort(key=lambda x: x["origen"], reverse=True) print("solicitudes de subida:", subidas) print("solicitudes de bajada:", bajadas) #5. Lista de pasajeros dentro del ascensor personas_en_ascensor = [] #6. Simulación de subida print("\n--- Ascendiendo---") for piso in range(1, pisos + 1): print(f"\n Ascensor en piso {piso}") time.sleep(0.5) #suben personas en este piso for s in subidas: if s["origen"]== piso : print(f"🟩 {s['nombre']} entra al ascensor (va al piso {s['destino']})") personas_en_ascensor.append(s) # Bajan personas cuyo destino es este piso for p in personas_en_ascensor[:]: if p["destino"]== piso : print(f"🟥 {p['nombre']} sale del ascensor (llegó a su destino)") personas_en_ascensor.remove(p) # 7. Simulación de bajada print("\n--- ASCENSOR BAJANDO ---") for piso in range(pisos, 0, -1): print(f"\n🚪 Ascensor en piso {piso}") time.sleep(0.5) # Suben personas en este piso que van hacia abajo for s in bajadas: if s["origen"] == piso: print(f"🟩 {s['nombre']} entra al ascensor (va al piso {s['destino']})") personas_en_ascensor.append(s) # Bajan personas cuyo destino es este piso for p in personas_en_ascensor[:]: if p["destino"] == piso: print(f"🟥 {p['nombre']} sale del ascensor (llegó a su destino)") personas_en_ascensor.remove(p) print("\n✅ Recorrido completado.")
gracias
const tiempo_parada = 2; const tiempo_cambiando_piso = 5; function calcular_tiempo_tomado(destino, origen) { const pisos = Math.abs(destino - origen); const tiempo = pisos * tiempo_cambiando_piso + tiempo_parada; return tiempo; } let personas = []; let personas_bajando = []; let personas_subiendo = []; const cantidad_personas = parseInt(prompt('¿Cuantas Personas usarán el Ascensor?'), 10); for (let i = 0; i < cantidad_personas; i++) { const nombre = prompt('Nombre de la persona'); const origen = parseInt(prompt(`Piso origen ${nombre}`), 10); const destino = parseInt(prompt(`Piso destino ${nombre}`), 10); const direccion = origen > destino ? 'Baja' : 'Sube'; const persona = { nombre, origen, destino, direccion }; personas.push(persona); if (direccion === 'Sube') { personas_subiendo.push(persona); } else { personas_bajando.push(persona); } } personas_subiendo.sort((a, b) => a.origen - b.origen); personas_bajando.sort((a, b) => b.origen - a.origen); let tiempo_total = 0; for (let persona of personas_subiendo) { const tiempo = calcular_tiempo_tomado(persona.destino, persona.origen); console.log(`${persona.nombre}: tarda ${tiempo} segundos en el recorrido`); tiempo_total += tiempo; } for (let persona of personas_bajando) { const tiempo = calcular_tiempo_tomado(persona.destino, persona.origen); console.log(`${persona.nombre}: tarda ${tiempo} segundos en el recorrido`); tiempo_total += tiempo; } console.log(`\nEl tiempo total del ascensor es: ${tiempo_total} segundos.`);
Dejo mi aporte:
peticiones = [ { 'nombre': 'el programador', 'origen': 2, 'destino': 10 }, { 'nombre': 'Carla', 'origen': 3, 'destino': 4 }, { 'nombre': 'Juan', 'origen': 8, 'destino': 7 }, { 'nombre': 'Pedro', 'origen': 5, 'destino': 1 } ] peticiones_subida = [] peticiones_bajada = [] for peticion in peticiones: if peticion['destino'] > peticion['origen']: peticiones_subida.append(peticion) else: peticiones_bajada.append(peticion) peticiones_subida.sort(key=lambda p: p['origen']) peticiones_bajada.sort(key=lambda p: p['origen'], reverse=True) paradas_subida = [] for p in peticiones_subida: paradas_subida.append(p['origen']) paradas_subida.append(p['destino']) paradas_subida = sorted(list(set(paradas_subida))) paradas_bajada = [] for p in peticiones_bajada: paradas_bajada.append(p['origen']) paradas_bajada.append(p['destino']) paradas_bajada = sorted(list(set(paradas_bajada)), reverse=True) # --- Simulación --- piso_actual = 1 print(f"---- El ascensor se encuentra en el piso {piso_actual} ----\n") for piso_parada in paradas_subida: if piso_parada > piso_actual: verbo = "sube" else: verbo = "baja" print(f"El ascensor {verbo} del piso {piso_actual} al {piso_parada}") piso_actual = piso_parada for peticion in peticiones_subida: if peticion['origen'] == piso_actual: print(f"» Recoge a {peticion['nombre']}.") if peticion['destino'] == piso_actual: print(f"« Deja a {peticion['nombre']}.") for piso_parada in paradas_bajada: if piso_parada > piso_actual: verbo = "sube" else: verbo = "baja" print(f"El ascensor {verbo} del piso {piso_actual} al {piso_parada}") piso_actual = piso_parada for peticion in peticiones_bajada: if peticion['origen'] == piso_actual: print(f"» Recoge a {peticion['nombre']}.") if peticion['destino'] == piso_actual: print(f"« Deja a {peticion['nombre']}.") print("\n--- Fin del recorrido. ---")
---- El ascensor se encuentra en el piso 1 ----
El ascensor sube del piso 1 al 2
» Recoge a el programador.
El ascensor sube del piso 2 al 3
» Recoge a Carla.
El ascensor sube del piso 3 al 4
« Deja a Carla.
El ascensor sube del piso 4 al 10
« Deja a el programador.
El ascensor baja del piso 10 al 8
» Recoge a Juan.
El ascensor baja del piso 8 al 7
« Deja a Juan.
El ascensor baja del piso 7 al 5
» Recoge a Pedro.
El ascensor baja del piso 5 al 1
« Deja a Pedro.
--- Fin del recorrido. ---