El Laberinto del Robot
Ya sabés instanciar objetos, llamar sus métodos, repetir con bucles y decidir con condicionales. Ahora vas a usar todo eso junto para algo distinto: en vez de escribir código que imprime texto, vas a escribir código que mueve a alguien de verdad. Cada laberinto de esta guía se resuelve programando un objeto Robot — sin bloques arrastrables, con Python real corriendo en tu navegador.
Bienvenido
Esta guía funciona distinto a las anteriores: no hay preguntas de opción múltiple ni ejercicios que revise un docente. Cada nivel es un laberinto con un objetivo (📍) y tu código se auto-verifica solo — si el robot llega a la meta, el nivel queda resuelto de verdad, al instante.
Escribís Python en el editor de cada nivel y presionás ▶ Ejecutar. Tu código corre de verdad (Pyodide, un Python real compilado a WebAssembly) y cada vez que llamás a un método del robot, lo ves moverse en el laberinto, paso a paso, en vivo. Si el robot choca contra una pared, tu programa termina con un error — igual que cualquier otro error de Python — y podés corregir el código y reintentar las veces que quieras.
La progresión de los 8 niveles no enseña ningún concepto nuevo de programación orientada a objetos: es un repaso, cada vez más exigente, de instanciar objetos, llamar métodos, y combinarlos con for, while e if.
🧍 Instanciar
Crear el robot con Robot() lo hace aparecer parado en la casilla de inicio.
🕹️ Llamar métodos
avanzar(), girar_izquierda() y girar_derecha() lo mueven de verdad.
🔁 Combinar
for, while e if junto con dos sensores para resolver laberintos más grandes.
La clase Robot
Todos los niveles usan la misma clase, ya definida — no hace falta escribirla ni importarla, ya está disponible en cada editor. Solo se instancia una vez por nivel.
| Miembro | Qué hace |
|---|---|
robot = Robot() | Crea el robot. Recién en este momento aparece parado en la casilla de inicio del laberinto. |
robot.avanzar() | Avanza una casilla en la dirección a la que está mirando. Si adelante hay una pared, el programa termina con un error. |
robot.girar_izquierda() | Gira 90° hacia la izquierda, sin cambiar de casilla. |
robot.girar_derecha() | Gira 90° hacia la derecha, sin cambiar de casilla. |
robot.hay_pared_adelante() | Devuelve True o False: ¿la casilla de adelante es una pared? |
robot.en_la_meta() | Devuelve True o False: ¿el robot ya está parado sobre la meta (📍)? |
robot = Robot()
robot.avanzar()
robot.avanzar()
robot.girar_derecha()
robot.avanzar()Cada laberinto tiene un único robot. No hace falta (ni tiene sentido) instanciar más de uno en el mismo nivel.
Nivel 1 — Instanciar y avanzar
PendienteEl camino es una línea recta. Creá el robot y hacelo avanzar hasta la meta.
Instanciar el robot con Robot() y llamar avanzar() las veces que hagan falta para llegar a la casilla amarilla.
Nivel 2 — Un giro
PendienteEsta vez el camino dobla una vez. Necesitás girar en el momento justo, ni antes ni después.
Usar girar_derecha() cuando el robot llegue a la esquina, y seguir avanzando hacia la meta.
Nivel 3 — Varios giros
PendienteAhora el camino dobla dos veces: primero hacia un lado, después hacia el otro. Todavía sin bucles — solo encadenar las llamadas en el orden correcto.
Vas a necesitar tanto girar_derecha() como girar_izquierda() en algún momento del recorrido.
Nivel 4 — Bucle for: pasillo largo
Pendiente
El pasillo es mucho más largo que los anteriores. Escribir robot.avanzar() nueve veces seguidas funciona, pero ya sabés una forma mejor de repetir una instrucción.
Resolvé el nivel usando un for en vez de repetir la línea a mano: for _ in range(9): robot.avanzar().
Nivel 5 — Bucle for con varios pasos
Pendiente
El camino tiene forma de escalera: el mismo patrón de movimientos se repite tres veces seguidas.
El cuerpo del for no tiene por qué ser una sola línea — podés repetir un bloque de varias instrucciones juntas (avanzar, avanzar, girar, avanzar, girar) tantas veces como se repita el patrón.
Nivel 6 — Sensor y decisión: if / else
Pendiente
El robot camina recto hasta encontrarse con una pared — pero en vez de contar a mano cuántas casillas hay antes de doblar, esta vez usá el sensor para que el propio robot lo detecte.
Avanzá hasta la pared y, con if robot.hay_pared_adelante():, decidí hacia qué lado girar. Para este laberinto en particular también podrías resolverlo contando pasos a mano — la idea es practicar el patrón del sensor, que sí hace falta cuando el laberinto no lo conocés de antemano (niveles 7 y 8).
Nivel 7 — Bucle while: avanzar hasta la meta
Pendiente
Otro pasillo recto — pero esta vez ni siquiera hace falta saber cuántas casillas mide.
Usá while not robot.en_la_meta(): robot.avanzar() en vez de contar casillas. Esta idea — "repetí hasta que se cumpla la condición", sin saber de antemano cuántas veces — es exactamente lo que hace un while.
Nivel 8 — Reto final: recorrido con decisiones
PendienteEl último laberinto combina todo lo anterior: hay que caminar, doblar dos veces, y el robot tiene que descubrir solo cuándo doblar.
Una sola regla, repetida con while, alcanza para resolver este laberinto (y cualquier otro parecido, sin importar cuántos giros tenga): "si hay pared adelante, girar a la derecha; si no, avanzar" — hasta llegar a la meta.
🗒️ Cheat Sheet
| Necesitás... | Escribís |
|---|---|
| Crear el robot | robot = Robot() |
| Moverse una casilla | robot.avanzar() |
| Girar sin moverse | robot.girar_izquierda() / robot.girar_derecha() |
| Preguntar si hay pared adelante | robot.hay_pared_adelante() |
| Preguntar si ya llegó | robot.en_la_meta() |
| Repetir N veces | for _ in range(N): ... |
| Repetir hasta cumplir una condición | while not robot.en_la_meta(): ... |
| Decidir según el sensor | if robot.hay_pared_adelante(): ... else: ... |
¿Sabías que...?
🐢 El ancestro real de este ejercicio
En 1967, el matemático Seymour Papert (MIT) creó LOGO, un lenguaje donde se programaba una "tortuga" (al principio un robot físico con ruedas, después un cursor en pantalla) con instrucciones como avanza y gira. La idea de "programar un personaje para que se mueva" que acabás de usar tiene más de 55 años.
🧩 Blockly Games
Google publicó Blockly Games: Maze, un laberinto casi idéntico a este pero resuelto arrastrando bloques en vez de escribir código — pensado para introducir la programación a quienes todavía no escriben texto. Vos ya sabés Python de verdad, así que esta guía te lo hizo resolver escribiéndolo.
🤖 Programar robots de verdad
El patrón if robot.hay_pared_adelante(): girar() else: avanzar() que usaste en el Reto Final se llama seguimiento de pared (wall following) y es un algoritmo real que usan robots físicos simples para explorar laberintos sin tener un mapa previo.