Repetir – Hasta que: Estructura de control repetitiva

La estructura de control repetitivaRepetir – Hasta que” o bucle repetir (conocida en inglés como repeat – until), es una estructura de control que contiene un conjunto de instrucciones que se repiten hasta que una condición específica se vuelva verdadera. En otras palabras, el conjunto de instrucciones dentro del bucle se ejecuta una y otra vez hasta que se logra algo específico. Esta estructura funciona de forma inversa que la estructura “Hacer – mientras”.

Sintaxis

La sintaxis suele variar dependiendo de la herramienta o lenguaje de programación específico debido a que cada uno posee sus propias reglas y convenciones. A continuación se muestra una sintaxis general:

Los elementos de la sintaxis:

  • Repetir: Es una palabra clave que da inicio a la estructura.
  • Cuerpo del bucle: Está conformado por uno o más instrucciones. Se le conoce también como bloque repetitivo.
  • Hasta que: Es una palabra clave que va al final de la estructura e indica que se debe evaluar la condición después de haberse ejecutado el cuerpo del bucle.
  • <condicion>: Es la condición que se evalúa después de cada iteración. El resultado de esta evaluación da Verdadero o Falso. Si la condición es verdadera, el bucle se detiene; de lo contrario, se repite el cuerpo del bucle.

Funcionamiento

  1. La primera vez, se ejecutan las instrucciones que conforman el cuerpo del bucle, sin importar la condición. Es decir, itera como mínimo una vez.
  2. Se evalúa la condición. 
  3. Si la condición es falsa, se ejecuta nuevamente (las instrucciones) el cuerpo del bucle.
  4. Al final de cada iteración, se vuelve a evaluar la condición.
  5. Si la condición sigue siendo falsa, el bucle continúa ejecutándose.
  6. Si la condición es verdadera, el bucle finaliza.

Representación

La estructura “Repetir – Hasta que”, al igual que las demás, puede representarse de varias maneras dependiendo del contexto y de la herramienta que se esté utilizando. Entre ellas se encuentran: diagramas de flujo, pseudocódigo, lenguajes de programación, diagrama Nassi-Shneiderman (N-S), etc.

Diagrama de flujo

repetir - hasta que - diagrama de flujo

En la imagen se observa la representación gráfica de una estructura de control repetitiva “Repetir – Hasta que”.

Pseudocódigo

En español

En inglés

Diagrama N-S

Características

  1. Ejecución previa a la evaluación: Este bucle primero ejecuta y luego pregunta, repitiendo este proceso varias veces.
  2. Flexibilidad en el número de iteraciones: Se utiliza comúnmente cuando no se conoce de antemano el número exacto de veces que debe repetirse un conjunto de instrucciones, en otras palabras, cuando la cantidad de iteraciones es desconocida.
  3. Garantía de ejecución mínima: Este bucle se distingue de otros, como el bucle “Mientras”, porque su condición se evalúa al final. Esto asegura que el cuerpo del bucle se ejecute al menos una vez, lo cual es importante en escenarios donde al menos una iteración es requerida.
  4. Posibilidad de bucles infinitos: Para prevenir bucles infinitos, es decir, aquellos que se repiten indefinidamente, es importante incluir instrucciones dentro del cuerpo del bucle que alteren las variables evaluadas en la condición. Esto garantiza que, en algún momento, la condición se vuelva verdadera y el bucle se detenga.

Otros nombres de la estructura Repetir - Hasta que

En la literatura, esta estructura es identificada con varios nombres, dependiendo del contexto y del lenguaje de programación utilizado.

  • Bucle Repetir – Hasta que
  • Ciclo Repetir – Hasta que
  • Bucle de salida condicionada
  • Bucle Post test
  • Bucle con salida controlada
  • Repeatuntil

Usos frecuentes de la estructura "Repetir - Hasta que"

1. Uso para validación de entrada de datos

Se puede utilizar una estructura repetitiva “Repetir – Hasta que” cada vez que se quiera validar que un usuario ingrese un dato que cumpla con ciertas características. Es decir, hasta que el usuario no ingrese un valor válido, el programa se “estancará” y seguirá pidiendo un valor.

El bucle dejará de repetirse y terminará cuando la condición resulte ser verdadera (funciona de forma totalmente opuesta a la estructura repetitiva “Mientras”).

Ejemplo: Validar que un usuario ingrese un número positivo (mayor que cero)

Ejecución del algoritmo en Pseint

Ejemplo: Algoritmo que valide que un usuario ingrese un número positivo de 3 cifras

Ejecución del algoritmo en Pseint

Ejemplo: Algoritmo para validar que un usuario ingrese un número positivo de 5 cifras. 

Ejecución del algoritmo en Pseint

2. Uso en menús de opciones

Es útil en la creación de menús interactivos, manteniendo al usuario en el menú hasta que elija salir.

Ejemplo: Mostrar una lista de opciones con 3 opciones:

1) Sumar

2) Multiplicar

3) Salir

y finalizar el algoritmo sí y solo sí se elija la opción para salir.

Ejecución del algoritmo en Pseint

3. Alternativa a la estructura repetitiva "Mientras"

En teoría, es posible reemplazar una estructura por cualquier otra, claro que va a depender del contexto, de la lógica del problema  y de lo que se desea lograr para elegir cuál usar.

Ejercicios resueltos

En el enlace a continuación, encontrarás la aplicación práctica de la estructura repetitiva “Repetir – Hasta que” mediante ejercicios resueltos.

Ejercicios con estructura repetitiva Repetir_Hasta en Pseint – parte 1

Principios de algoritmos UTP – resolución de examen final Nº 4

Resolución de un examen final de Principios de algoritmos de la UTP. Cada ejercicio se resuelve mediante un algoritmo bajo el paradigma de la programación estructurada aplicando las estructuras de control: secuenciales, selectivas y repetitivas. La representación de los algoritmos es a través de pseudocódigo y diagramas de flujo utilizando Pseint.

PREGUNTA 1

Desarrollar un algoritmo que permita realizar para N empleados:

  • Leer los salarios, validando que sean entre 1000 y 6000.
  • Mostrar un reporte con el porcentaje de empleados que ganan menos de 1800, entre 1800 y 3500, y más de 3500.
  • Mostrar el promedio de salarios.

Pseint

Pseudocódigo

				
					Proceso Pregunta1
	Definir N, contador1, contador2, contador3 Como Entero
	Definir salario, sumaSalario, promedioSalario, porcentaje1, porcentaje2, porcentaje3 como Real
	
	Repetir
		Escribir "Ingrese el numero de empleados: "
		Leer N
	Hasta Que N > 0
	
	sumaSalario <- 0
	contador1 <- 0
	contador2 <- 0
	contador3 <- 0
	Para i <- 1 hasta N Con Paso  1 Hacer
		Repetir
			Escribir "Salario persona ", i, ": "
			Leer salario
		Hasta Que salario >= 1000 y salario <= 6000
		
		sumaSalario <- sumaSalario + salario
		
		Si salario < 1800 Entonces
			contador1 <- contador1 + 1
		SiNo
			Si salario <= 3500 Entonces
				contador2 <- contador2 + 1
			SiNo
				contador3 <- contador3 + 1
			FinSi
			
		FinSi
	FinPara
	
	promedioSalario <- sumaSalario / N
	porcentaje1 <- contador1 * 100 / N
	porcentaje2 <- contador2 * 100 / N
	porcentaje3 <- contador3 * 100 / N
	
	Escribir "Porcentaje de personas que ganan menos de 1800: ", porcentaje1, "%"
	Escribir "Porcentaje de personas que ganan entre 1800 y 3500: ", porcentaje2, "%"
	Escribir "Porcentaje de personas que ganan de 3500: ", porcentaje3, "%"
	Escribir "Promedio de salarios: S/", promedioSalario
	
FinProceso
view raw
				
			

Diagrama de flujo

PREGUNTA 2

Crear un programa en pseudocódigo para un estacionamiento que cumpla con las siguientes condiciones:

  1. Se debe ingresar la placa del vehículo.
  2. Se ingresa el tiempo que el vehículo permaneció parqueado en minutos.
  3. Si el vehículo es una motocicleta se cobra S/ 0.02 el minuto, S/ 0.25 el minuto si es un auto y S/ 0.30 si es una camioneta.
  4. Si el vehículo permanece más de 1 hora se hace un descuento del 10%; si permanece más de 2 horas, un 20%; si son más de 3 horas, un 30%.
  5. Se debe mostrar un cuadro resumen que indique: la placa, el tiempo en horas y minutos, el precio base, el descuento y el importe final.
  6. El algoritmo solo debe permitir ingresar los tipos de vehículos mencionados y una cantidad de minutos mayor a cero, en caso no se ingresen valores correctos debe volver a pedirlos sin finalizar la ejecución.

Se evaluará:

  •  Validar el tipo de vehículo.
  • Validar la cantidad de minutos.
  • Calcular el precio base.
  • Calcular el descuento.
  • Calcular el precio final.
  • Calcular el tiempo en horas y minutos. Por ejemplo, si se ingresa 200 minutos, se debe mostrar 3 horas y 20 minutos.
  • Mostrar el cuadro resumen.

Pseint

Pseducódigo

				
					Proceso Pregunta2
	Definir N, tiempo Como Entero
	Definir placa, tipo Como Caracter
	Definir importeBase, descuento, importeFinal como Real
	Definir horas, minutos como Entero
	
	Repetir
		Escribir "Ingrese el numero de vehiculos: "
		Leer N
	Hasta Que N > 0
	
	Para i <- 1 hasta N Con Paso  1 Hacer
		Escribir "Ingrese Placa del vehiculo #", i
		Leer placa
		
		Repetir
			Escribir "Tiempo de parqueado (minutos): "
			Leer tiempo
		Hasta Que tiempo > 0
		
		Repetir
			Escribir "Ingrese Tipo del vehiculo: (M:motocicleta, A:auto, C:Camioneta): "
			Leer tipo
		Hasta Que tipo = 'M' o tipo = 'A' o tipo = 'C'
		
		Segun tipo Hacer
			'M':
				importeBase <- tiempo * 0.20
			'A':
				importeBase <- tiempo * 0.25
			'C':
				importeBase <- tiempo * 0.30
		Fin Segun
		
		Si tiempo <= 60
			descuento <- 0
		Sino
			Si tiempo <= 120
				descuento <- importeBase * 0.10
			SiNo
				Si tiempo <= 180
					descuento <- importeBase * 0.20
				SiNo
					descuento <- importeBase * 0.30
				FinSi
			FinSi
		FinSi
		
		importeFinal <- importeBase - descuento
		
		horas <- trunc(tiempo / 60)
		minutos <- tiempo - horas * 60
		
		Escribir "REPORTE: "
		Escribir "Placa: ", placa
		Si (tiempo > 60) entonces
			Escribir "Tiempo: ", horas, " horas y ", minutos, " minutos"
		Sino
			Escribir "Tiempo: ", tiempo, " minutos"
		FinSi
		
		Escribir "Precio base: S/ ", importeBase
		Escribir "Descuento: S/ ", descuento
		Escribir "Importe final: S/ ", importeFinal
		
	FinPara
FinProceso
				
			

Diagrama de flujo

PREGUNTA 3

Realizar prueba de escritorio al siguiente algoritmo.

Prueba de escritorio

Pseint

Pseudocódigo

				
					Proceso Pregunta3
	Definir m, n, p Como Entero    
	m<-30
	n<-6
	p<-1
	Mientras n > 2 Hacer
		Escribir "true"
		Escribir "m=", m
		Escribir "n=", n
		Escribir "p=", p
		Escribir "-----------"
		m <- n mod 2
		n <- n - 1
		p <- m - n
	FinMientras
	Escribir "false"
	Escribir "m=", m
	Escribir "n=", n
	Escribir "p=", p
	Escribir "-----------"
FinProceso