Desafío práctico: optimizar el recorrido de un ascensor

Curso de Pensamiento Lógico

Contenido del curso

Fundamentos del pensamiento computacional

Estructuras de datos básicas

Operaciones, comparaciones y lógica

Control del flujo y modularidad

Aplicaciones prácticas

Tomar examen

Desafío práctico: optimizar el recorrido de un ascensor

Resumen

Optimizar el recorrido de un ascensor en un edificio de varios pisos requiere aplicar pensamiento lógico y estructurado. Vas a resolver un desafío práctico creando un diagrama de flujo y el código necesario, en cualquier lenguaje de programación, para lograr que un ascensor transporte eficientemente a varias personas desde diferentes pisos y hasta distintos destinos, reduciendo tanto el tiempo empleado como la cantidad total de paradas.

¿Cómo organizar el recorrido del ascensor para la menor cantidad de paradas?

El ascensor parte siempre desde el primer piso en un edificio de diez pisos. Cuatro personas aguardan en diferentes niveles, listos para dirigirse a distintos destinos:

Vos estás en el piso 2 y tu destino es el piso 10.
Pedro se encuentra en el piso 5 y quiere ir al piso 1.
Juan espera en el piso 8 y necesita llegar al piso 7.
Carla aguarda en el piso 3 y desea ir al piso 4.

Para minimizar paradas y tiempo de desplazamiento, considerá:

Agrupar personas que viajan en la misma dirección, ya sea de subida o de bajada.
Planificar un recorrido que permita al ascensor evitar detenciones innecesarias cuando se traslada vacío.
Organizar las paradas en función de la proximidad entre los niveles donde suben y bajan los pasajeros.

¿Qué pasos seguir para resolver este desafío en código?

Crear una programación lógica implica poner atención en los siguientes pasos fundamentales:

Definir variables: pisos iniciales y destinos de cada persona, posición inicial del ascensor (piso 1).
Establecer reglas: siempre minimizar paradas y tiempo; mover pasajeros en dirección común.
Estructurar secuencia lógica:
- Identificar los pisos donde debe detenerse inicialmente.
- Agrupar movimientos por direccionamiento ascendente o descendente.
- Repetir hasta entregar en el destino final a cada pasajero.
Crear y probar el diagrama de flujo con las condiciones planteadas antes de pasar al código.

¿Qué recomendaciones considerar para elegir un lenguaje de programación?

A la hora de resolver este tipo de desafíos, seleccionar el lenguaje de programación más acorde a tus objetivos futuros es esencial. Puedes explorar:

Python: útil para ciencia de datos, machine learning y automatización.
JavaScript: orientado hacia proyectos web.
Optar por otro lenguaje si las preferencias o necesidades son distintas.

Comprender los fundamentos básicos del pensamiento lógico-algorítmico mejora cualquier aprendizaje y desarrollo futuro, haciendo que la elección concreta del lenguaje sea menos determinante.

¿Estás listo para crear tu diagrama y escribir tu código? Te invito a compartir tu solución en los comentarios.

José Milton Ruiz Murillo

Estudiante

•

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.

Jairo Sánchez Sánchez

Estudiante

Way to go Milton!! 💯

Julian David Chavarro Balanta

Steven Andres Moreno Melendez

david felipe matallana martinez

Mónica Cruz

Maria Magdalena Nava Martinez

Christian Camilo Hermoso Forero

Fernando Lambraño Leon

Miguel Lozano

Fabiola Jessica Huancollo Chambi

Roberto Flores

Santiago Salamanca Rusinque

Valeria Hernández

Claudia Cecilia Ruiz Duque

Sindy Leon

Carlos Alejandro Derobertis

Gizela Delgado Soto

Ivan Andres Suarez Alfonso

MARIA TERESA PANIAGUA RIVERA

Desafío práctico: optimizar el recorrido de un ascensor

Fundamentos del pensamiento computacional

Estructuras condicionales en programación: cómo el software toma decisiones

Algoritmos y diagramas de flujo para resolver problemas paso a paso

Variables y condicionales en algoritmos

Automatiza tus algoritmos con PSeInt

Estructuras de datos básicas

Tipos de datos: texto, números y booleanos en programación

Variables y constantes en programación básica

Declaración y uso de listas y matrices en pseudocódigo

Selección de moneda por índice numérico en conversor de monedas

Operaciones, comparaciones y lógica

Cálculo de cashback y comisiones en billeteras virtuales

Transformaciones de texto con funciones de cadena en pseudocódigo

Validación de datos de usuario con operadores de comparación

Operadores lógicos para combinar condiciones en validaciones

Control del flujo y modularidad

Condicionales

Tipos de bucles en algoritmos: mientras, repetir y para

Modularización de código con funciones en pseudocódigo

Aplicaciones prácticas

Calculadora de edad canina con Python

Algoritmo para detectar palíndromos en JavaScript

Programación de juego adivina el número con PHP

Desafío práctico: optimizar el recorrido de un ascensor

Resumen