RETO1
Este proyecto demuestra la implementación de algoritmos de movimiento en Python utilizando dos enfoques diferentes: una representación visual vectorial mediante la librería estándar turtle y una simulación lógica basada en texto (ASCII) a través de la consola.
El script combina dos entornos de ejecución en un solo flujo de trabajo:
- Entorno Gráfico (
turtle): Utiliza la geometría de la tortuga para dibujar una línea vectorial de 100 unidades. - Entorno de Consola (ASCII): Simula el desplazamiento lineal calculando la posición y generando un rastro visual con caracteres de texto.
Este código es parte del Reto 1, enfocado en la comprensión de coordenadas, entrada de usuario y manipulación de cadenas en Python.
Para ejecutar este proyecto, necesitas:
- Python 3.x instalado.
- Librería
turtle(generalmente incluida en la instalación estándar de Python).
- Clona este repositorio o descarga el archivo
main.py. - Abre tu terminal o línea de comandos.
- Ejecuta el script con el siguiente comando:
RETO2
Markdown
# 🐢 Reto 2: Simulación de Movimiento Vertical
Este proyecto corresponde al segundo desafío de la serie de simulaciones de tortuga. A diferencia del movimiento horizontal, este script se centra en la representación del **desplazamiento vertical descendente** en la consola, utilizando estructuras de control repetitivas.
## 📋 Descripción
El programa simula una tortuga "bajando" por la pantalla. En lugar de moverse a lo largo del eje X (horizontal), se desplaza en el eje Y (vertical) negativo.
El objetivo técnico es demostrar cómo el flujo de impresión estándar de Python (que incluye un salto de línea automático) puede utilizarse junto con bucles `for` para crear estructuras verticales.
## ⚙️ Cómo Funciona
El script ejecuta los siguientes pasos lógicos:
1. **Inicialización:** Define una cantidad fija de pasos (`pasos = 10`).
2. **Interacción:** Pausa la ejecución hasta que el usuario confirma la acción mediante la tecla `ENTER`.
3. **Bucle de Renderizado:**
* Utiliza un ciclo `for` para iterar `n` veces.
* En cada iteración, imprime el carácter `|`, generando el rastro del recorrido.
4. **Finalización:** Imprime una flecha descendente `↓` para indicar la dirección y posición final.
### Diferencia con el Reto 1
* **Reto 1 (Horizontal):** Usó multiplicación de cadenas (`"-" * pasos`) en una sola línea.
* **Reto 2 (Vertical):** Usa un bucle (`for`) porque cada `print()` en Python genera una nueva línea automáticamente.
## 🚀 Instrucciones de Ejecución
Asegúrate de tener Python instalado y ejecuta el siguiente comando en tu terminal:
```bash
python nombre_del_archivo.py
📄 Ejemplo de Salida
Al ejecutar el programa, verás la siguiente interacción en tu consola:
code
Text
simulación de una tortuga bajando:
presiona ENTER para bajar la tortuga
|
|
|
|
|
|
|
|
|
|
↓
🧩 Conceptos de Python Aplicados
Entrada de usuario: input() para controlar el flujo.
Bucles: for i in range() para repetición controlada.
Salida estándar: Uso del salto de línea implícito en print().
Arte ASCII: Representación gráfica mediante caracteres (| y ↓).
👤 Autor
Código desarrollado como parte del Reto 2 de programación en Python.
code
Code
### Sugerencia para tu repositorio
Como ya tienes dos retos, te sugiero organizar tu repositorio de la siguiente manera para que se vea muy ordenado:
```text
📁 Mi-Proyecto-Tortuga/
│
├── 📄 README.md (Un resumen general de todos los retos)
│
├── 📂 Reto_01_Horizontal/
│ ├── 📄 main.py
│ └── 📄 README.md (El primer manual que te pasé)
│
└── 📂 Reto_02_Vertical/
├── 📄 main.py (Este código nuevo)
└── 📄 README.md (El manual de arriba)
RETO3
# 🐢 Reto 3: Simulación de Trayectoria en "L" (Bidireccional)
Este proyecto representa el tercer nivel de la serie de simulaciones. Aquí combinamos el movimiento horizontal y el vertical para crear una trayectoria compleja en forma de "L", introduciendo el concepto de **alineación espacial** en la consola.
## 📋 Descripción
El programa simula una tortuga que primero avanza hacia la derecha y, al llegar a un punto específico, gira 90 grados para descender.
El desafío técnico principal de este script es **mantener la coherencia visual**: el trazo vertical debe alinearse perfectamente con el final del trazo horizontal, lo cual requiere el cálculo preciso de espacios en blanco (indentación).
## ⚙️ Lógica del Código
El script se divide en dos fases coordinadas:
1. **Fase Horizontal (Eje X):**
* Se dibuja una línea utilizando la multiplicación de cadenas: `"-" * 49`.
* Se añade un puntero al final (`►`) para indicar la posición de giro.
2. **Fase Vertical (Eje Y):**
* Para que la tortuga baje justo desde donde terminó, se utiliza un **padding (relleno) de espacios**.
* Antes de imprimir la tubería vertical (`|`), el código inserta la misma cantidad de espacios que la longitud del camino horizontal:
```python
print(" " * 49 + "|")
```
* Esto crea la ilusión de que la tortuga está bajando por el lado derecho de la pantalla.
## 🚀 Instrucciones de Ejecución
Ejecuta el script desde tu terminal con el siguiente comando:
```bash
python nombre_del_archivo.py
Sigue las instrucciones en pantalla presionando ENTER para activar cada tramo del movimiento.
📄 Ejemplo de Salida
La ejecución genera un gráfico ASCII similar al siguiente:
code
Text
simulación de tortuga :
presiona Enter para avanzar 50 unidades hacia la derecha...
-------------------------------------------------►
presiona ENTER para avanzar 10 unidades hacia abajo...
|
|
|
|
|
|
|
|
|
↓
¡La tortuga ha llegado a su destino!
🧠 Aprendizajes Clave
Este reto refuerza y combina los siguientes conceptos:
Concatenación de strings: Unir espacios y caracteres visibles.
Alineación visual: Uso de espacios en blanco (" " * n) para posicionar elementos en la consola sin usar coordenadas reales (x,y).
Secuenciación: Ejecución ordenada de pasos lógicos (primero derecha, luego abajo
### Un detalle técnico interesante para tu aprendizaje:
Lo que acabas de hacer (usar `" " * 49`) es la forma manual de hacer lo que en interfaces gráficas se llama **posicionamiento absoluto**. Estás diciéndole a la consola: *"No imprimas nada en los primeros 49 espacios, y luego imprime la línea"*. ¡Es un concepto clave para entender cómo se construyen las interfaces!
# 🐢 Reto 4: Simulación de Escalones (Patrones Repetitivos)
Este proyecto representa el cuarto desafío en la serie de simulaciones de tortuga en consola. En esta etapa, el enfoque se centra en la **repetición de patrones de movimiento** para construir una estructura compuesta, simulando el dibujo de una escalera paso a paso.
## 📋 Descripción
El programa simula una tortuga que realiza una maniobra compuesta (derecha + abajo) y la repite tres veces consecutivas. El objetivo es visualizar cómo una secuencia de instrucciones simples puede combinarse para formar una estructura mayor.
A nivel de código, este reto explora la ejecución secuencial de bloques lógicos idénticos, sirviendo como preámbulo conceptual para el uso de bucles (loops) en programación.
## ⚙️ Lógica del Movimiento
El patrón se define por una unidad de "escalón", que consiste en:
1. **Fase Horizontal:** Se dibuja un trazo de 5 unidades hacia la derecha (`----- ►`).
2. **Fase Vertical:** Se dibuja una caída de 2 unidades, alineada con el final del trazo horizontal mediante espacios en blanco (` |`).
Este bloque de código se ejecuta tres veces de manera lineal, pausando entre cada fase para permitir al usuario observar el proceso de construcción.
## 🚀 Instrucciones de Ejecución
1. Asegúrate de tener Python instalado.
2. Ejecuta el script en tu terminal:
```bash
python main.py
python main.py