Saltar a contenido

Práctica 2.2: Sentencias iterativas y saltos

P2.2 - Sentencias iterativas y de salto

En esta práctica vas a automatizar tareas que se repiten: recorrer rangos y cadenas, acumular resultados, leer datos hasta un centinela y construir patrones con bucles anidados. También analizarás cuándo una sentencia de salto hace el flujo más claro y cuándo es preferible expresar la terminación en la condición del bucle.

La actividad continúa la teoría de sentencias iterativas y de salto. El resultado esperado es una colección de programas pequeños, ejecutables y documentados, con pruebas que demuestren que terminan y respetan sus límites.

1. Objetivos

  • Elegir for para recorridos conocidos y while para condiciones que evolucionan o entradas controladas por un centinela.
  • Inicializar y actualizar correctamente contadores, acumuladores y variables de control.
  • Resolver recorridos de cadenas, bucles anidados, búsquedas y cálculos de dígitos sin delegar el algoritmo en una función que lo haga directamente.
  • Reconocer el efecto de break, continue y pass, priorizando un flujo estructurado sin saltos innecesarios.
  • Probar límites, entradas vacías y condiciones de terminación para evitar bucles infinitos.

2. Relación con RA y criterios de evaluación

Código Descripción literal de la normativa
RA 3 Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
CE 3.b Se han utilizado estructuras de repetición.
CE 3.c Se han reconocido las posibilidades de las sentencias de salto.
CE 3.e Se han creado programas ejecutables utilizando diferentes estructuras de control.

Las evidencias se concretan así:

  • CE 3.b: los ejercicios 2.2.1 a 2.2.25 deben utilizar recorridos, contadores, acumuladores o condiciones de repetición adecuadas.
  • CE 3.c: los ejercicios con centinelas, búsquedas y terminación anticipada permiten reconocer el efecto de break, continue y pass, justificando cuándo se usan o por qué no son necesarios.
  • CE 3.e: se entregan los veinticinco archivos Python ejecutables y el README.md con pruebas, resultados y decisiones de flujo.

3. Requisitos y recursos

En los ejercicios cuyo objetivo es construir un algoritmo, no uses funciones o métodos que resuelvan directamente el cálculo: por ejemplo, len, sum, max, min, count, reversed o split cuando el enunciado pide recorrer los datos. Sí puedes usar range, int, float, print y las operaciones básicas. Si una excepción de conversión no se ha estudiado todavía, trabaja con datos del tipo indicado y deja el control de errores para la práctica de excepciones.

4. Pasos a seguir

4.1. Preparar el trabajo

  1. Crea una carpeta de trabajo llamada practica_u2_2_iterativas y guarda cada ejercicio en ejercicio2.2.1.py, ejercicio2.2.2.py, hasta ejercicio2.2.25.py.
  2. Incluye el enunciado resumido en un comentario o docstring y usa nombres que indiquen si una variable es un contador, un acumulador, un centinela o un dato procesado.
  3. Ejecuta cada archivo desde la terminal y conserva ejemplos de entrada y salida en el README.md de la entrega.

4.2. Diseñar el bucle antes de programarlo

  1. Decide si el número de repeticiones es conocido. Si lo es, empieza por un for con range; si depende de una condición o de una entrada, considera while.
  2. Escribe la inicialización, la condición de continuación, la actualización y el resultado que debe quedar al terminar.
  3. Identifica el centinela cuando el ejercicio lea una cantidad indeterminada de datos y asegúrate de que el centinela no se procese como un dato normal.
  4. No uses break ni continue como primera opción: expresa la terminación o el filtrado mediante una condición visible. Estudia esas sentencias solo para reconocer código existente y documenta su efecto si aparecen.

4.3. Implementar por bloques de dificultad

  1. Resuelve los ejercicios 2.2.1 a 2.2.8 con for, range y bucles anidados. Comprueba especialmente los límites exclusivos de range.
  2. Continúa con los ejercicios 2.2.9 a 2.2.13 para practicar while, centinelas y recorridos de texto.
  3. Resuelve los ejercicios 2.2.14 a 2.2.18 usando acumuladores, máximos y extracción matemática de dígitos.
  4. Termina con los ejercicios 2.2.19 a 2.2.25, que combinan menú, búsqueda, validación, bucles anidados y más de un contador.
  5. Tras cada bloque, revisa el número de iteraciones y prueba también la primera entrada como condición de salida.

4.4. Probar, depurar y documentar

  1. Prueba un caso pequeño que puedas calcular a mano y un caso frontera, como altura 1, edad 0, número primo 2, frase vacía o primer dato igual al centinela.
  2. Si el bucle no termina o repite un valor, comprueba qué variable lo acerca a la condición de salida y dónde se actualiza.
  3. En al menos dos ejercicios, coloca un punto de ruptura y observa la variable de iteración y un contador o acumulador; registra la evidencia en el README.md.
  4. No introduzcas break ni continue si puedes resolver el ejercicio con una condición estructurada. Si aparecen en una variante, explica su efecto; un pass no sustituye una implementación pendiente sin justificarlo.

5. Comprobaciones de finalización

  • Los veinticinco programas se ejecutan con los datos previstos y terminan sin quedar bloqueados en un bucle infinito.
  • Los ejercicios 2.2.1 a 2.2.8 respetan los límites y el orden solicitado de cada recorrido.
  • Los ejercicios controlados por centinela no procesan el centinela: 0, -1, salir, * y / tienen el significado indicado en cada enunciado.
  • Los acumuladores empiezan con el valor neutro adecuado y el máximo se inicializa de forma segura cuando todavía no hay datos.
  • Los ejercicios de dígitos funcionan con números de una cifra y con el valor límite que termina la entrada.
  • Se han probado los casos de entrada vacía o sin datos, siempre que el enunciado los permita, y se muestra un mensaje comprensible.
  • Se ha mantenido un flujo estructurado; break y continue no aparecen salvo que se documente una variante de reconocimiento, y pass solo se usa cuando dejar el bloque vacío es una decisión intencionada.
  • El README.md incluye casos de prueba, resultados esperados, dos evidencias de depuración y una nota sobre las decisiones de diseño.

6. Ejercicios y entregables

  1. Ejercicio 2.2.1 — Repetir una palabra. Pide una palabra y muéstrala diez veces, una por línea.
  2. Ejercicio 2.2.2 — Años cumplidos. Pide una edad y muestra los años desde 1 hasta esa edad. Decide qué salida corresponde a la edad 0.
  3. Ejercicio 2.2.3 — Impares. Pide un entero positivo y muestra los impares desde 1 hasta ese número, separados por comas.
  4. Ejercicio 2.2.4 — Cuenta atrás. Pide un entero positivo y muestra la cuenta desde ese número hasta 0, separados por comas.
  5. Ejercicio 2.2.5 — Inversión. Pide cantidad, interés anual y años, y muestra el capital al terminar cada año. Actualiza con capital *= 1 + interes / 100.
  6. Ejercicio 2.2.6 — Triángulo de asteriscos. Pide la altura y muestra un triángulo rectángulo cuya fila n contiene n asteriscos.
  7. Ejercicio 2.2.7 — Tablas de multiplicar. Muestra las tablas del 1 al 10, con los productos del 1 al 10. Usa dos bucles anidados.
  8. Ejercicio 2.2.8 — Triángulo numérico. Pide la altura y muestra, para cada fila, los impares en orden descendente: 1; 3 1; 5 3 1, y así sucesivamente.
  9. Ejercicio 2.2.9 — Contraseña con reintentos. Guarda una contraseña de ejemplo y pide entradas hasta que coincidan. No cuentes el centinela: aquí la coincidencia es la condición de terminación.
  10. Ejercicio 2.2.10 — Número primo. Pide un entero y decide si es primo. Los valores menores que 2 no son primos y la búsqueda de divisores debe terminar cuando encuentre uno.
  11. Ejercicio 2.2.11 — Palabra al revés. Pide una palabra y muestra sus letras desde la última hasta la primera, una por línea.
  12. Ejercicio 2.2.12 — Contar una letra. Pide una frase y una letra, y cuenta cuántas veces aparece la letra. Recorre la frase y no uses str.count.
  13. Ejercicio 2.2.13 — Eco. Muestra el eco de cada línea introducida hasta recibir salir. El texto salir no se repite.
  14. Ejercicio 2.2.14 — Suma hasta cero. Lee enteros hasta 0 y muestra la suma de todos los valores anteriores.
  15. Ejercicio 2.2.15 — Suma de positivos. Lee enteros hasta 0 y suma solo los positivos; los negativos se leen, pero no se acumulan.
  16. Ejercicio 2.2.16 — Mayor hasta cero. Lee enteros positivos hasta 0 e informa del mayor. Indica qué ocurre si la primera entrada es 0.
  17. Ejercicio 2.2.17 — Suma de dígitos. Pide un entero positivo y suma sus dígitos usando % 10 para extraer el último y // 10 para eliminarlo.
  18. Ejercicio 2.2.18 — Dígitos y pares. Lee enteros positivos hasta -1. Para cada uno muestra la suma de sus dígitos y, al final, cuántos números introducidos eran pares. El -1 no cuenta como dato.
  19. Ejercicio 2.2.19 — Menú. Repite un menú con las opciones 1, comenzar; 2, imprimir listado; y 3, finalizar. Informa de las opciones incorrectas y vuelve a mostrar el menú después de 1 y 2.
  20. Ejercicio 2.2.20 — Primera coincidencia. Pide una frase y una letra, recorre la frase carácter a carácter e informa de las posiciones sin coincidencia. Cuando encuentre la primera coincidencia, indícala y termina el recorrido.
  21. Ejercicio 2.2.21 — Compras y descuento. Lee importes hasta 0. Ignora los negativos y pide otro importe; al terminar, aplica un descuento del 10 % si el total supera 1 000 euros.
  22. Ejercicio 2.2.22 — Dígitos pares e impares. Lee enteros positivos hasta 0, informa de los dígitos pares e impares de cada número y acumula ambos totales para el resumen final.
  23. Ejercicio 2.2.23 — Títulos por líneas. Lee títulos hasta *. Una línea con / cierra la línea actual; informa de cuántos dígitos aparecen en ella y del número total de líneas completas.
  24. Ejercicio 2.2.24 — Contar primos. Lee una cantidad indeterminada de números mayores que 1 hasta 0 y cuenta cuántos son primos.
  25. Ejercicio 2.2.25 — Palabra más larga. Pide una frase, cuenta sus palabras y muestra la primera palabra más larga si hay empate. Considera uno o más espacios como separadores y resuelve el recorrido sin usar str.split.
  26. Entregables. Entrega los veinticinco archivos ejercicio2.2.1.py a ejercicio2.2.25.py, un README.md con tu nombre o identificador, casos de prueba y resultados, dos evidencias de depuración y una explicación breve de las decisiones de flujo. Si has elegido no usar pass, explica que no era necesario para completar estos algoritmos y que conoces su efecto.

7. Solución orientativa

Para contrastar cada solución, escribe primero el patrón del bucle en palabras: qué se procesa, qué variable cambia y qué condición hace que termine. Un for con range expresa un recorrido conocido; un while controlado por un centinela necesita una lectura inicial, un cuerpo que procese el dato y una nueva lectura antes de volver a evaluar la condición.

Ejercicio Orientación para contrastar la solución
2.2.1 Usa diez iteraciones; el cuerpo solo debe mostrar la palabra.
2.2.2 Recorre desde 1 hasta la edad incluida; range debe recibir como límite final edad + 1.
2.2.3 Recorre con paso 2 desde 1 y no añadas una coma después del último valor.
2.2.4 La cuenta atrás necesita paso -1 y un límite final que incluya el 0.
2.2.5 Conserva el capital actualizado y muestra una línea por año; prueba interés 0.
2.2.6 La longitud de la fila coincide con su número de iteración.
2.2.7 El bucle exterior selecciona la tabla y el interior sus multiplicadores.
2.2.8 En cada fila, el mayor impar es 2 * fila - 1 y el menor es 1; recorre hacia atrás.
2.2.9 El while continúa mientras la contraseña introducida sea distinta de la almacenada.
2.2.10 Prueba divisores desde 2 y usa una condición o una bandera para terminar la búsqueda sin break.
2.2.11 Recorre índices desde el último hasta el primero o construye el resultado anteponiendo cada letra.
2.2.12 Inicializa un contador a 0 e increméntalo solo cuando el carácter actual coincida.
2.2.13 Comprueba el centinela antes de imprimir y actualiza la entrada en cada vuelta.
2.2.14 El acumulador comienza en 0 y recibe cada entero distinto del centinela.
2.2.15 Mantén la lectura y separa la condición de finalización de la condición que permite acumular.
2.2.16 Usa None para representar que aún no hay mayor; no confundas el 0 centinela con un dato.
2.2.17 Mientras quede una parte del número, suma numero % 10 y reduce con numero // 10.
2.2.18 Calcula los dígitos de cada número, suma sus valores y comprueba la paridad del número original.
2.2.19 La condición principal continúa mientras la opción sea distinta de 3; una opción inválida no debe terminar.
2.2.20 Usa una bandera o una condición exterior para detener el recorrido al encontrar la primera coincidencia; informa de forma distinta si no se encuentra.
2.2.21 Rechaza los importes negativos sin sumarlos y calcula el descuento solo después de cerrar la entrada.
2.2.22 Usa dos contadores de dígitos y actualízalos mientras extraes cada dígito con operaciones enteras.
2.2.23 Separa el contador de dígitos de la línea del contador de líneas; reinicia el primero al recibir /.
2.2.24 Para cada número, comprueba divisores y aumenta el contador de primos solo cuando no encuentres ninguno.
2.2.25 Recorre la frase con un contador de caracteres, cierra una palabra al detectar un espacio y conserva la primera en caso de empate.

Una solución orientativa no consiste en copiar una implementación única: debe permitir explicar la terminación, el valor de cada acumulador y los casos frontera. En el informe final, contrasta al menos un resultado manual con la salida del programa y explica cómo se ha expresado la terminación sin break ni continue. La sentencia pass se estudia aquí para reconocer un bloque vacío; no es necesario introducirla artificialmente en un ejercicio que ya tiene una implementación completa.

8. Fuentes y referencias