Introducción a la programación

Algoritmos
Guía de Conceptos
Unidad II
Introducción a la Programación – Unidad II

Table of Contents
Estructura Secuencial .................................................................................................................................... 2
→ Ejemplos utilizando Estructurados Secuenciales ............................................................................... 2
→ Ejercicios desarrollados utilizando Estructuras Secuenciales ............................................................ 3
→ Ejercicios desarrollados – Uso del Operador Resto (%) ..................................................................... 4
Estructura Condicional .................................................................................................................................. 5
→ Simples .............................................................................................................................................. 5
→ Dobles ............................................................................................................................................... 5
→ Múltiples ........................................................................................................................................... 6
→ Múltiples (En caso de) ....................................................................................................................... 6
¿Qué debemos de considerar para utilizar este tipo de estructuras? .................................................. 7
Ejemplo práctico – utilizando estructuras condicionales .......................................................................... 7
Ejemplo práctico – utilizando estructuras dobles ...................................................................................... 8
Ejemplo práctico – utilizando Estructuras Múltiples ................................................................................. 8
Ejemplo práctico – utilizando Estructuras Múltiples (En Caso De) ............................................................ 9
Ejercicio práctico – utilizando Estructuras Condicionales/Selectivas....................................................... 10
Estructuras Repetitivas o Cíclicas ................................................................................................................ 16
1. Ciclos con un número determinado de iteraciones (Hacer-Para) .................................................... 16
→ Hacer Para – Desde Hasta: .......................................................................................................... 16
2. Ciclos con un número indeterminado de iteraciones (Hacer-Mientras, Repetir-Hasta) .................. 17
→ Hacer-Mientras ........................................................................................................................... 17
→ Funcionamiento – Estructura Mientras ...................................................................................... 18
→ Función Repetir-Hasta................................................................................................................. 18
Diferencia entre la Estructura Repetir y Mientras ................................................................................... 19
Métodos para la terminación de bucles con datos de entrada ............................................................... 19
Definiciones de ........................................................................................................................................ 19
→ Uso del Contador ........................................................................................................................ 20
→ Uso del acumulador .................................................................................................................... 20
Bandera o Señal (Switch) ......................................................................................................................... 21
Ejemplo práctico – utilizando Bandera o señal ........................................................................................ 21
Ejercicio práctico – utilizando Estructuras cíclicas-Hacer Para ................................................................ 22
Ejercicio práctico – utilizando Estructuras cíclicas – Hacer Mientras ...................................................... 24
Ejercicio práctico – utilizando estructuradas cíclicas – Uso de Banderas ................................................ 26
Bibliografía .................................................................................................................................................. 28

Guía de Conceptos – Material Básico 1

Introducción a la Programación – Unidad II

Estructura Secuencial
La estructura algorítmica de control secuencial ejecuta automáticamente una instrucción después
de la otra, en el orden en el cual se han escrito de inicio a fin. Las tareas se suceden de tal modo
que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso.
Se representa de la siguiente forma:

→ Ejemplos utilizando Estructurados Secuenciales

Sumar dos números positivos ingresados por teclado. Mostrar el resultado.

• Análisis: El algoritmo pide que el usuario ingrese dos valores, luego el programa realiza
el proceso de suma e imprime el resultado.
• Datos de Entrada: numero 1 y numero 2 (n1, n2).
• Datos de Salida: Suma.

Paso 1 Inicio Da inicio al algoritmo

Paso 2 entero n1, n2, suma Declaración de variables
Paso 3 imprimir “Ingrese valores” Mensaje para el usuario
Paso 4 sum=n1 + n2 Proceso que suma números ingresados
Paso 5 imprimir “Resultado”, suma Muestra el valor contenido en variable sum
Paso 6 Fin Fin del algoritmo

Guía de Conceptos – Material Básico 2

Introducción a la Programación – Unidad II

→ Ejercicios desarrollados utilizando Estructuras Secuenciales

1. Calcular la edad de una persona, ingresando el año de nacimiento y el año actual.
Paso 1 Inicio
Paso 2 entero año_nacim, año_actual
Paso 3 Imprimir “Ingrese el año de su nacimiento”
Paso 4 Leer año_nacim
Paso 5 Imprimir “Ingrese el año actual”
Paso 6 Leer año_actual
Paso 7 edad=(año_nacim - año_actual)
Paso 8 imprimir “La edad de una persona es:”, edad
Paso 9 Fin

2. Desarrollar un algoritmo que multiplique un número ingresado por un valor

constante tres.

Paso 1 Inicio
Paso 2 entero num, resul
Paso 3 leer num
Paso 4 resul= num*3
Paso 5 imprimir “El resultado es:” resul
Paso 6 Fin

3. Desarrollar un algoritmo que permita conocer el área de un triángulo a partir de la

base y la altura. Exprese el algoritmo usando Pseudocódigo.

Paso 1 Inicio
Paso 2 entero base, altura, área
Paso 3 Imprimir “Ingrese la base”
Paso 4 Leer base
Paso 5 Imprimir “ Ingrese la altura”
Paso 6 Leer altura
Paso 7 área=(base*altura)/2
Paso 8 imprimir “El área del triángulo es:”, área
Paso9 Fin

Guía de Conceptos – Material Básico 3

Introducción a la Programación – Unidad II

4. Dada la deuda de aporte, calcular la cantidad de años y meses que adeuda un

socio en concepto del mismo. Sabiendo que el aporte es de Gs. 10.000 mensual.
Imprimir la cantidad de años y la cantidad de meses. Nota: utilizar para el efecto la
función entera
Paso 1 Inicio
Paso 2 Real deudaaporte, meses, años, auxmes
Paso 3 Leer deudaaporte
Paso 4 auxmes=deudaaporte/10000
Paso 5 año=entera(auxmes/12)
Paso 6 mes=auxmes-(año*12)
Paso 7 imprimir “Cantidad de años”, años
Paso 8 imprimir “Cantidad de meses”, mes
Paso9 Fin

→ Ejercicios desarrollados – Uso del Operador Resto (%)

El operador mod o también denominado resto, se utiliza para hallar el resto entre una
división entera. También puede ser representado por el operador %.

Ejemplo: Determinar la cifra de las unidades de un numero entero positivo.

Inicio
entero num, resto
resto = num mod 10
Imprimir “La unidad del número es:” resto
Fin

Análisis: El problema pide determinar la cifra de las unidades de un número cualquiera.

Si dividimos un número cualquiera entre diez, obtenemos en el resto siempre la unidad de
la cifra.

• 38 % 10 = 8 El operador mod (resto) almacena el resto de una división entera

• 38 / 10 = 3 El operador div (división) almacena el cociente de una división entera

Guía de Conceptos – Material Básico 4

Introducción a la Programación – Unidad II

Estructura Condicional
La estructura algorítmica condicional o también conocida como estructura selectiva, brinda
la posibilidad de elegir distintos caminos en la ejecución de las acciones y donde se puede
establecer caminos alternativos para la ejecución.

Existen tres tipos básicos: las simples, las dobles y las múltiples.

→ Simples
Las estructuras condicionales simples se les conocen como “Tomas de decisión” Se
representa de la siguiente forma:

→ Dobles
Las estructuras condicionales dobles permiten elegir entre dos opciones o alternativas
posibles en función del cumplimiento o no de una determinada condición. Se representa
de la siguiente forma:

• Si: Indica el comando de comparación

• Condición: Indica la condición a evaluar
• Entonces: Precede a las acciones a realizar cuando se cumple la condición
• Instrucción(es): Son las acciones a realizar cuando se cumple o no la
condición
• si no: Precede a las acciones a realizar cuando no se cumple la condición
Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o
más acciones.

Guía de Conceptos – Material Básico 5

Introducción a la Programación – Unidad II

→ Múltiples
Las estructuras de comparación múltiples son tomas de decisión especializadas que
permiten comparar una variable contra distintos posibles resultados, ejecutando para cada
caso una serie de instrucciones específicas. Se representa de la siguiente forma:

→ Múltiples (En caso de)

La estructura alternativa múltiple: Según sea, En caso de; evaluará una expresión
que podrá tomar n valores distintos.

También es posible que a la hora de especificar la ejecución de una acción haya que
escoger entre varias acciones dependiendo del valor de una determinada variable (o
indicador). Se representa de la siguiente forma:

Guía de Conceptos – Material Básico 6

Introducción a la Programación – Unidad II

Otra forma de representar es de la siguiente forma:

Seleccionar Indicador
Caso Valor 1: Acción 1;
Caso Valor 2: Acción 2;
Caso Valor n: Acción n;
EnOtroCaso: Acción X;
FinCaso
En esta construcción Indicador debe tener un determinado valor que en caso de coincidir
con alguno de los n valores provocará la ejecución de la acción asociada a dicho valor.

Si el valor del Indicador no coincidiera con ninguno de los especificados se ejecutará la

Acción X. No tiene por qué haber una Acción X para cuando el Indicador no coincida con
ninguno de los n valores. En ese caso, si el Indicador no coincide con ningún valor no se
ejecutaría ninguna acción.

¿Qué debemos de considerar para utilizar este tipo de estructuras?

• Cuando existen más de dos elecciones posibles, es cuando se presenta el caso
de alternativas múltiples.
• Si el número de alternativas es grande, puede plantear serios problemas de
escritura del algoritmo y naturalmente de legibilidad.
• La estructura de selección múltiple evaluará una expresión que podrá tomar n
valores distintos.
• Según se elija uno de estos valores en la condición, se realizará una de las n
acciones, o lo que es igual, el flujo del algoritmo seguirá un determinado camino
entre los n posibles.
• Existe un camino adicional que, aunque es opcional, siempre es recomendable
que se utilice. Esta es la opción, En otro caso, la cual ejecuta una acción cuando
la expresión arroja otro valor diferente a los esperados.
• Se dice que esta es la opción DEFAULT o POR DEFECTO, es un camino por
defecto en caso de que no se elija ninguno de los otros caminos.

Ejemplo práctico – utilizando estructuras condicionales

Realizar un algoritmo en donde se pide la edad del usuario; si es mayor de edad debe aparecer
un mensaje indicándolo. Expresar el algoritmo en Pseudocódigo.
Paso 1 Inicio
Paso 2 entero edad
Paso 3 Imprimir “¿Cuál es tu edad?
Paso 4 leer edad
Paso 5 Si (edad>18) entonces
Paso 6 imprimir “ES MAYOR DE EDAD”
Paso 7 Fin si

Guía de Conceptos – Material Básico 7

Introducción a la Programación – Unidad II

Paso 8 Fin
En este ejemplo la condición está dada por un valor que ingresa el usuario. Si la condición se
cumple o es verdadera entonces se visualiza por pantalla el mensaje
“Es mayor de edad”

Ejemplo práctico – utilizando estructuras dobles

Se pide leer tres notas del alumno, calcular su nota final en un rango de 1-5 y enviar un mensaje
donde diga si el alumno aprobó o reprobó el curso. Teniendo en cuenta que aprueba si su
promedio es mayor a dos. Expresar el algoritmo en Pseudocódigo.
Paso 1 Inicio
Paso 2 Real Nota1, Nota2, Nota3, Prom
Paso 3 Leer Nota1, Nota2, Nota3
Paso 4 Prom= (Nota1 + Nota2 + Nota3) /3
Paso 5 Si ( Prom >= 2) entonces
Paso 6 Imprimir “Aprobó el curso”
Paso 7 Sino
Paso 8 Imprimir “Reprobó el curso”
Paso 9 Fin Si
Paso 10 Fin

En este ejemplo la condición está dada por el resultado del cálculo previo del promedio el cual
se obtiene de las tres notas que ingresa el usuario. Si la condición se cumple o es verdadera
entonces se visualiza por pantalla el mensaje “Aprobó el curso”, si la condición resultase falsa,
esto es si el promedio es 1 o cero, o dicho de otra manera menor a 2, entonces ingresa al sino
e imprime el resultado “Reprobó el curso”.

Ejemplo práctico – utilizando Estructuras Múltiples

La Universidad Americana lanzo un programa de control de peso y desea saber si un
alumno posee un peso Bajo, Medio o Alto. Exprese el algoritmo usando Pseudocódigo. Se
considera que el peso es bajo si es menor o igual a 60 kl. Si el peso está entre 61 y 80, el
alumno es de peso medio y si el peso es mayor a 81, el alumno es de peso alto.
Paso 1 Inicio
Paso 2 entero Peso
Paso 3 Imprimir “Cuál es su peso?”
Paso 4 Leer Peso
Paso 5 si (Peso <=60) entonces
Paso 6 Imprimir “Alumno de Peso bajo”
Paso 7 sino si ( Peso <=80) entonces
Paso 8 Imprimir “Alumno de Peso medio”
Paso 9 sino si (Peso >81) entonces
Paso 10 Imprimir “Alumno de Peso alto”
Paso 11 fin si
Paso 12 fin si
Paso 13 fin si

Guía de Conceptos – Material Básico 8

Introducción a la Programación – Unidad II

Paso 14 Fin

En este ejemplo se muestra el uso de una condicional múltiple en donde se pueden identificar
tres condiciones. Si la primera condición se cumple (peso <=60) entonces visualiza por pantalla
el mensaje correspondiente, sino se cumple o resulta falsa entonces evalúa la segunda condición
(peso <=80) si es verdadera, visualiza por pantalla el mensaje correspondiente y si esta condición
volviese a evaluar falsa entonces evalúa la última condición e imprime el mensaje
correspondiente.

Ejemplo práctico – utilizando Estructuras Múltiples (En Caso De)

Dado un número entre 1 y 7 Imprimir su correspondiente día de la semana así:
1. Lunes 4. Jueves
2. Martes 5. Viernes
3. Miércoles 6. Sábado
7- Domingo
Exprese el algoritmo usando Pseudocódigo

Paso 1 Inicio
Paso 2 Entero Día
Paso 3 Imprimir “Diga un número para escribir su día”
Paso 4 Leer Día
Paso 5 En-caso-de Día haga
Paso 6 Caso 1: Imprimir “Lunes”
Paso 7 Caso 2: Imprimir “Martes”
Paso 8 Caso 3: Imprimir “Miércoles”
Paso 9 Caso 4: Imprimir “Jueves”
Paso 10 Caso 5: Imprimir “Viernes”
Paso 11 Caso 6: Imprimir “Sábado”
Paso 12 Caso 7: Imprimir “Domingo”
Paso 13 SINO: Imprimir “Escribió un numero fuera del rango 1-7”
Paso 14 Fin-Caso
Paso 15 Fin

El siguiente ejemplo nos muestra el desarrollo de la estructura “En Caso De”, a través de
la estructura múltiple en donde el valor de una variable puede tener varios resultados.
Dependiendo del valor numérico ingresado en la variable día se imprimirá el mensaje
correspondiente.

Guía de Conceptos – Material Básico 9

 Introducción a la Programación – Unidad II

Ejercicio práctico – utilizando Estructuras Condicionales/Selectivas

1) Un hombre desea saber cuánto dinero se genera por concepto de intereses sobre
la cantidad que tiene invertida en una Cooperativa. El decidirá reinvertir los
intereses siempre y cuando estos excedan a $1.000, y en ese caso desea saber
cuánto dinero tendrá finalmente en su caja de ahorro.

Inicio
entero p_int, cap, int, capf
Leer p_int, cap
int = cap * p_int
si (int > 1000) entonces
capf = cap + int
fin-si
Imprimir capf
Fin

2) El Shopping UA esta de promoción por su mes aniversario y hace un 30% de

descuento a los clientes cuya compra supere los $300. ¿Cuál será la cantidad que
pagará un cliente por su compra?

Inicio entero compra

real desc
Leer compra
Si (compra > 300) entonces desc = compra * 0.30 si no
desc = 0
fin-si
tot_pag = compra - desc
imprimir tot_pag
Fin.
3) Un obrero necesita calcular su salario semanal, el cual se obtiene de la sig.
manera: Si trabaja 40 horas o menos se le paga $16 por hora. Si trabaja más de
40 horas se le paga $16 por cada una de las primeras 40 horas y $20 por cada
hora extra.

Inicio
Entero ht, ss, he
Leer ht
Si (ht > 40) entonces
he = ht - 40
ss = he * 20 + 40 * 16
si no
ss = ht * 16
fin-si
Imprimir ss
Fin

Guía de Conceptos – Material Básico 10

 Introducción a la Programación – Unidad II

4) Diseña un algoritmo que lea dos números y los imprima en forma ascendente

Inicio
Leer num1, num2
Si (num1 < num2) entonces
Imprimir num1, num2
si no
Imprimir num2, num1 fin-si
Fin
5) Visualizar el nombre de un artículo, clave, precio original y su precio con
descuento. El descuento lo hace en base a la clave, si la clave es 01 el descuento
es del 10% y si la clave es 02 el descuento es del 20% (solo existen dos claves).

Inicio
Entero clave, prec_orig
Cadena nombre
Leer nombre, clave, prec_orig
Si clave = = 01 entonces
prec_desc = (prec_orig – (prec_orig * 0.10))
si no
prec_desc = (prec_orig – (prec_orig * 0.20))
fin-si
Imprimir nombre, clave, prec_orig, prec_desc
Fin

6) Calcular el total a pagar por la compra de discos externos. Si se compran tres o

más se aplica un descuento del 10% sobre el total de la compra y si son menos de
tres discos externos se aplica un descuento del 5%.

Inicio
entero cant_de, precio real tot_pag, tot_comp
Leer cant_de, precio
tot_comp = cant_de * precio
Si (cant_de > = 3) entonces
tot_pag = tot_comp – (tot_comp * 0.10)
si no
tot_pag = tot_comp – (tot_comp * 0.05)
fin-si
Imprimir tot_pag
Fin
7) Leer 2 números; si son iguales que los multiplique, si el primero es mayor que el
segundo que los reste y si no que los sume.
Inicio
Entero num1, num2, resul
Leer num1, num2
Si (num1 = = num2) entonces
resul = num1 * num2
sino
si (num1 > num2) entonces
resul = num1 - num2
sino
resul = num1 + num2
fin-si
Guía de Conceptos – Material Básico 11
 Introducción a la Programación – Unidad II
fin-si
fin-si
Fin

8) Leer tres números diferentes e imprimir el número mayor de los tres.

Inicio
Leer num1, num2, num3, mayor
Si (num1 > num2) and (num1 > num3) entonces
mayor = num1
sino
Si (num2 > num1) and (num2 > num3) entonces
mayor = num2 si no mayor = num3
fin-si
fin-si
Imprimir mayor
Fin
9) Determinar la cantidad de dinero que recibirá un trabajador por concepto de las
horas extras trabajadas en una empresa, sabiendo que cuando las horas de
trabajo exceden de 40, el resto se consideran horas extras y que estas se pagan
al doble de una hora normal cuando no exceden de 8; si las horas extras exceden
de 8 se pagan las primeras 8 al doble de lo que se pagan las horas normales y el
resto al triple.

Inicio
Entero ht, pph, tp, he, pd, pt, pe
Leer ht, pph
Si (ht < = 40) entonces
tp = ht * pph
si no
he = ht - 40
Si (he < = 8) entonces
pe = he * pph * 2
si no pd = 8 * pph * 2
pt = (he - 8) * pph * 3
pe = pd + pt
fin-si
tp = 40 * pph + pe
fin-si
Imprimir tp
Fin

10) Calcular el excedente que un socio recibe en el reparto anual de utilidades. Se

calcula el porcentaje dependiendo de la antigüedad como socio en la cooperativa,
de acuerdo con la sig. tabla:

Guía de Conceptos – Material Básico 12

 Introducción a la Programación – Unidad II

Tiempo Utilidad

Menos de 1 año 5%
1. año o más y menos de 2 años 7%
2. años o más y menos de 5 años 10%
5 años o más y menos de 10 años 15%
10 años o más 20%

Inicio
Entero sm, antig, util
Leer sm, antig
Si antig < 1 entonces
util = sm * 0.05
si no
Si (antig > = 1) and (antig < 2) entonces
util = sm * 0.07
si no
Si (antig > = 2) and (antig < 5) entonces
util = sm * 0.10
si no
Si (antig > = 5) and (antig < 10) entonces
util = sm * 0.15 si no util = sm * 0.20
fin-si
fin-si
fin-si
fin-si
Imprimir util
Fin

11) El IPS requiere clasificar a las personas que se jubilaran en el año de 2015. Existen tres
tipos de jubilaciones: por edad, por antigüedad joven y por antigüedad adulta. Las
personas vinculadas a la jubilación por edad deben tener 60 años o más y una antigüedad
en su empleo de menos de 25 años. Las personas vinculadas a la jubilación por
antigüedad joven deben tener menos de 60 años y una antigüedad en su empleo de 25
años o más. Las personas vinculadas a la jubilación por antigüedad adulta deben tener
60 años o más y una antigüedad en su empleo de 25 años o más.
Determinar en qué tipo de jubilación, quedara vinculadas una persona.

Guía de Conceptos – Material Básico 13

 Introducción a la Programación – Unidad II

Inicio
Entero edad, ant leer edad, ant,
si (edad >= 60) and (ant < 25) entonces
imprimir “La jubilación es por edad”
sino
si (edad >= 60) and (ant > 25) entonces
imprimir “La jubilación es por edad adulta”
sino
si (edad < 60) and (ant > 25) entonces
imprimir “La jubilación es por antigüedad joven”
si no
imprimir “No tiene por qué jubilarse”
fin-si
fin-si
fin-si
Fin

12) Desarrolle un algoritmo que le permita leer 2 valores A y B e indicar si uno de los
dos divide al otro exactamente
Inicio
Entero A, B
Leer A, B
Si (A residuo B= =0) entonces
Imprimir “B divide exactamente a”
sino
Si (B residuo A= =0) entonces
Imprimir “A divide exactamente a B”
sino
Imprimir “No se dividen exactamente”
fin-si
fin-si

Fin

13) Desarrolle un algoritmo que le permita leer dos valores A y B e indicar si el

resultado de dividir la suma de los dos números entre la resta del primer número
con el segundo es exacta.

Inicio
Entero A, B
Leer A, B
Si (A+B) mod (A-B)= =0 entonces
Imprimir “La división es exacta”
sino
Imprimir “La división es inexacta”
fin-si
Fin

Guía de Conceptos – Material Básico 14

Introducción a la Programación – Unidad II

14) Cree un algoritmo que, basado en la siguiente tabla, lea un número entero e
imprima el nombre de la estación correspondiente.

Valor Estación
1 Invierno
2 Verano
3 Otoño
4 Primavera

Inicio
Entero estación
Leer estación
Según sea (estación)
Caso 1: Imprimir “Invierno”
Caso 2: Imprimir “Verano”
Caso 3: Imprimir “Otoño”
Caso 4: Imprimir “Primavera”
En otro Caso
Imprimir “Estación errónea” Fin

Estructuras Repetitivas o Cíclicas

Se llaman problemas repetitivos o cíclicos a aquellos en cuya solución es necesario utilizar
un mismo conjunto de acciones que se puedan ejecutar una cantidad específica de
veces. Esta cantidad puede ser fija (previamente determinada por el programador) o
puede ser variable (estar en función de algún dato dentro del programa).

Los ciclos se clasifican en:

1.) Ciclos con un Número Determinado de Iteraciones
- Hacer-Para
2.) Ciclos con un Número Indeterminado de Iteraciones
• Hacer-Mientras
• Repetir-Hasta

1. Ciclos con un número determinado de iteraciones (Hacer-Para)

Son aquellos en que el número de iteraciones se conoce antes de ejecutar el ciclo.
→ Hacer Para – Desde Hasta:
Este tipo de estructura se utiliza cuando se sabe ya antes de ejecutar el bucle el número
exacto de veces que hay que ejecutarlo. Para ello el bucle llevara asociado una variable

Guía de Conceptos – Material Básico 15

Introducción a la Programación – Unidad II

que denominamos variable índice o variable de control, a la que se le asigna un valor

inicial y se determina cual va a ser su valor final.

Esta variable se va a incrementar o decrementar en cada iteración de bucle en un valor

constante, pero esto se va a hacer de manera automática o sea que va a ser una
operación implícita (lo hace por defecto).

Por tanto, en cada iteración del bucle, la variable índice o de control se actualiza
automáticamente y cuando alcanza el valor que hemos puesto como final se termina la
ejecución del bucle.

En este ciclo la variable de control toma el valor inicial del ciclo y el ciclo se repite hasta
que la variable de control llegue al límite superior.

Se representa de la siguiente forma:

Dónde:
V.C: Variable de control del ciclo
L.I: Límite inferior
L.S: Límite superior

2. Ciclos con un número indeterminado de iteraciones (Hacer-

Mientras, Repetir-Hasta)
Son aquellos en que el número de iteraciones no se conoce con exactitud, ya que esta dado en
función de un dato dentro del programa.

→ Hacer-Mientras
Esta es una estructura que repetirá un proceso durante “N” veces, donde “N” puede ser
fijo o variable. Para esto, la instrucción se vale de una condición que es la que debe
cumplir para que se siga ejecutando. Cuando la condición ya no se cumple, entonces ya
no se ejecuta el proceso.

Se representa de la siguiente forma:

Guía de Conceptos – Material Básico 16

Introducción a la Programación – Unidad II

→ Funcionamiento – Estructura Mientras

A. La condición del bucle se evalúa al principio, antes de entrar en él ciclo.
B. Si la condición es verdadera, se comienza a ejecutar las acciones del bucle
y después de la última acción volvemos a preguntar por la condición.
C. En el momento en el que la condición sea falsa salimos del bucle y
ejecutamos la siguiente condición al bucle.
D. Al evaluar la condición, antes de entrar en el bucle al principio, si la
condición al ser evaluada la primera vez es falsa, no entraremos nunca en
el bucle, el bucle puede que se ejecute 0 veces, por tanto, usaremos
obligatoriamente este tipo de bucle en el caso de que exista la posibilidad
de que el bucle pueda ejecutarse 0 veces.

→ Función Repetir-Hasta
En esta estructura el bucle se repite hasta que la condición sea verdadera y mientras la condición
sea falsa.
La condición se evalúa siempre al final del bucle, si es falsa volvemos a ejecutar las acciones, si
es verdadera sale del bucle.
Como la condición se evalúa al final, incluso aunque la primera vez ya sea verdadera, habremos
pasado al menos una vez por el bucle.
Es decir que cuando un bucle se tenga que ejecutar como mínimo una vez, se podrá usar una
estructura repetir.
Se representa de la siguiente forma:

Guía de Conceptos – Material Básico 17

Introducción a la Programación – Unidad II

Diferencia entre la Estructura Repetir y Mientras

Repetir Hacer Mientras

• Repite un proceso una cantidad de • Repite un proceso una cantidad de
veces, hasta que la condición se cumpla veces, mientras que la condición se
o sea verdadera cumpla o hasta que sea falsa
• permite realizar el proceso cuando • puede ser que nunca llegue a entrar si la
menos una vez, ya que la condición se condición no se cumple desde un
evalúa al final del proceso principio.

Métodos para la terminación de bucles con datos de entrada

1) Preguntar antes de la iteración
Solicita a través de un mensaje al usuario si existen más entradas.
2) Encabezar la lista de datos con su tamaño
Conocer en la cabecera del bucle el tamaño o el número de iteraciones
3) Finalizar la lista con su valor de entrada
Leer una lista de valores con un centinela
4) Agotar los datos de entrada
Comprobar que no existen más datos de entrada, preguntar si es fin de archivo.

Definiciones de:

• Conjunto de instrucciones que se repiten un número finito de veces

• Todo bucle tiene que llevar asociada una condición, que es la que va a determinar
cuándo se repite el bucle.
• Consta de tres partes: Decisión, Cuerpo del bucle, Salida del bucle.

• Los bucles son anidados cuando están dispuestos de tal modo que unos son interiores a
otros; los bucles son independientes cuando son externos unos a otros.

• Cada repetición del bucle se llama iteración.

Guía de Conceptos – Material Básico 18

Introducción a la Programación – Unidad II

• Es un valor especial usado para indicar el final de una lista de datos.

• Es una variable auxiliar creada por el programador que se incrementa de un modo

constante, un numero finito de veces.
• El valor se incrementa o decrementa en una cantidad constante en cada repetición que se
produzca.
• Puede ser positivo a través del incremento o puede ser negativo a través del decremento.

• Es una variable que acumula valores que a su vez son el producto de un proceso repetitivo
y finito de sumas sucesivas.
• Almacena una cantidad variable resultado de las operaciones sucesivas y repetidas.
• El incremento y el decremento es variable.

→ Uso del Contador

Un contador es un variable que se utiliza para contar cualquier evento que pueda ocurrir
dentro de un programa. En general suelen contar de forma natural desde 0 y de 1 en 1,
aunque se pueden realizar otros tipos de cuenta necesarios en algunos procesos.

Se utilizan realizando sobre ellos dos operaciones básicas:

A. Inicialización.
Todo contador se inicializa a 0 si realiza cuenta natural o a un valor VI (Valor inicial) si se
desea realizar otro tipo de cuenta.
CONTADOR = 0

B. Contabilización o incremento.
Cada vez que aparece el evento a contar se ha de incrementar el contador en 1 si se
realiza cuenta natural o en Incremento si se realiza otro tipo de cuenta.
CONTADOR = CONTADOR + 1
→ Uso del acumulador
Son objetos que se utilizan en un programa para acumular elementos sucesivos con una
misma operación. En general se utilizan para calcular sumas y productos, sin descartar
otros posibles tipos de acumulación.

Se utilizan realizando sobre ellos dos operaciones básicas:

A. Inicialización.
Todo acumulador necesita ser inicializado con el valor neutro de la operación que va a
acumular, que en el caso de la suma es 0 y en el del producto es 1.
SUMA = 0
PRODUCTO =1

Guía de Conceptos – Material Básico 19

Introducción a la Programación – Unidad II

B. Acumulación.
Cuando se debe acumular un elemento o valor como resultado de una lectura o un cálculo,
se efectúa la acumulación del mismo por medio de la asignación: SUMA = SUMA +
elemento
PRODUCTO = PRODUCTO * elemento

Bandera o Señal (Switch)

Es una variable auxiliar creada por el programador, que generalmente adquiere solo dos
estados (0) cero o (1) uno.

Normalmente su valor inicial es cero (0) y cuando cambia de estado a uno (1) es para
indicar que se ha producido una determinada situación que debía ser evaluada En la
mayoría de los casos una bandera que inicialmente está en cero al cambiar de estado a
uno ya permanece con ese valor final durante todo el proceso aunque sin embargo en
algunas ocasiones el valor de una bandera va variando de estado de cero a uno y de uno
a cero y así sucesivamente de acuerdo a las circunstancias.

Ejemplo práctico – utilizando Bandera o señal

1) Ingresar diez números en forma consecutiva. Determinar el menor de la serie y
luego imprimir el resultado.
Análisis: Averiguar cuál es el menor número de la lista de diez valores ingresados,
teniendo en cuenta que el menor valor pueda ubicarse en cualquier posición.
Datos de entrada: Diez valores aleatorios. Variable a utilizar X
Dato de salida: Valor menor. Variable a utilizar ME
En este algoritmo la bandera está representada por la variable B, la cual es inicializada
con el valor cero (0), con el objetivo de almacenar el primer valor ingresado como menor.

Inicio
Entero B=0, ME=0, X, C
Hacer Para C=1 hasta 10
Leer X
Si B=0
B=1
ME=X
Sino
Si X < ME
ME=X
Fin si
Fin si
Fin para
Imprimir Me
Fin

Guía de Conceptos – Material Básico 20

 Introducción a la Programación – Unidad II

Ejercicio práctico – utilizando Estructuras cíclicas-Hacer Para

1. Calcular el promedio de un alumno que tiene 3 calificaciones en la materia de
Introducción a la Programación.

Inicio
entero sum, calif, c, prom cadena nombre sum = 0
Leer nombre
Hacer para c = 1 a 3
Leer calif
sum = sum + calif
Fin-para
prom = sum /3
Imprimir prom
Fin.

2. Leer 10 números e imprimir solamente los números positivos

Inicio
entero n, num
Hacer para n = 1 a 10
Leer num
Si (num > 0) entonces
Imprimir num
Fin-si
Fin para
Fin

3. Leer 15 números negativos y convertirlos a positivos e imprimir dichos números.

Inicio
entero x, num, pos
Hacer para x = 1 a 15
Leer num pos = num * -1
Imprimir num, pos
Fin-para
Fin

Guía de Conceptos – Material Básico 21

 Introducción a la Programación – Unidad II

4. Leer 20 números e imprimir cuantos son positivos, cuantos negativos y cuantos

neutros.
Inicio
entero cn = 0, cp = 0, cneg = 0, x, num
Hacer para x = 1 a 20
Leer num
Si num = 0 entonces
cn = cn + 1
si no
Si num > 0 entonces
cp = cp + 1
si no
cneg = cneg + 1
Fin-si
Fin-si
Fin-para
Imprimir cn, cp, cneg
Fin

5. Suponga que se tiene un conjunto de calificaciones de un grupo de 20 alumnos.

Realizar un algoritmo para calcular la calificación promedio y la calificación más baja de
todo el grupo. Se inicializa la variable baja con 999
Inicio
sum = 0 baja = 999
Hacer para a = 1 a 20
Leer calif
sum = sum + calif
Si calif < baja entonces
baja = calif
fin-si
Fin-para
media = sum / 2
Imprimir media, baja
fin

Guía de Conceptos – Material Básico 22

 Introducción a la Programación – Unidad II

Ejercicio práctico – utilizando Estructuras cíclicas – Hacer Mientras

1. Calcular el valor de la suma de los cien primeros números naturales
Inicio
Entero suma=0, cont=1
Mientras (cont <=100) hacer
suma=suma + cont
cont=cont + 1
Fin Mientras
Imprimir suma
Fin

2. Calcular la suma de los números mayores a 1 y menores a 100

entero
suma=0, num
leer num
Mientras (num>1) and (num<100) hacer
suma = suma + num
leer num
Fin mientras
Fin

3. Calcular y visualizar la suma y el producto de los números pares que se encuentran

entre los valores 10 y 20, incluyendo los limites
Inicio
Entero sumapar, prod, num
Leer num
Mientras (num>=10) and (num<=20) hacer
Si (num%2 == 0) entonces
sumapar = sumapar + num
prod= num * num
Imprimir “ El producto de los pares es:”, prod
Fin si
Leer num
Fin Mientras
Imprimir “La suma de los pares es:”, sumapar
Fin

Guía de Conceptos – Material Básico 23

 Introducción a la Programación – Unidad II

4. Leer 12 números y obtener cuántos de ellos son positivos.

Inicio
Entero contpos, num, cont=0
Mientras (cont<12) hacer
Leer num
Si (num>0) entonces
Contpos=contpos+1
Fin si
cont=cont+1
Fin Mientras
Imprimir “La cantidad de números positivos es:”, contpos
Fin
5. Hallar el máximo común divisor de dos números naturales enteros positivos.
Visualizar el resultado.
Inicio
Entero a, b, res
Imprimir “Ingreso dos números”
Leer a, b
Repetir
res=a mod b
a = b b = res
Hasta res == 0
Imprimir “El MCD es:”, a
Fin

Guía de Conceptos – Material Básico 24

Introducción a la Programación – Unidad II

Ejercicio práctico – utilizando estructuradas cíclicas – Uso de Banderas

1) Ingresar diez números. Determina e imprime el menor número par de la serie

Inicio
Entero B=0, ME=0, C
Real X
Hacer Para C=1 hasta 10
Leer X
Si X/2==ENT (X/2)
Si B=0
B=1
ME=X
Sino
Si X < ME
ME=X
Fin si
Fin si
Fin si
Fin para
Imprimir Me
Fin

En donde:
• X: Variable de entrada
• B: Bandera
• ME: Auxiliar de menor
2) Ingresar diez números de uno en uno. Determinar e imprimir la cantidad de veces que a
un número positivo le sigue un número negativo en la serie.
Inicio
Entero b=0, cv=0, num, c
Hacer Para c=1 hasta 10
Leer x
Si (num >0) entonces
b=1
Fin Si
Si (num == 0) entonces
b=0
Fin si
Si (num< 0) entonces
Si (b == 1) entonces
b=0
cv= cv + 1
Fin si
Fin si
Fin para
Imprimir “La cantidagd de elementos es:”cv
Fin

Guía de Conceptos – Material Básico 25

Introducción a la Programación – Unidad II

• C: Contador
En donde:
• num: Variable de entrada
• B: Bandera
• CV: Contador de veces
• C: Contador que controla que se introduzcan diez números

3) Ingresar diez números de uno en uno. Determinar e imprimir el mayor número múltiplo de
tres en la serie.
Inicio
Entero b=0, may=0, cont, num
Real r
Hacer para cont=1 hasta 10
Leer num
Si (num/3==ent (num/3))
Si (b = = 0) b=1 may=num
sino
Si (num > may)
may = num
Fin si
Fin si
Fin si
Fin para
Imprimir “El valor mayor encontrado es:”, may
Fin

En donde:
• num: Variable de entrada ▪ b: Bandera
• may: Almacena el mayor
• cont: Contador

Guía de Conceptos – Material Básico 26

Introducción a la Programación – Unidad II

Bibliografía
Básica
• Juganaru Mathieu, M. (2015). Introducción a la programación. Grupo Editorial Patria.
• Moreno Pérez, J. C. (2015). Programación. RA-MA Editorial.
• Farrell, J. (2013). Introducción a la programación lógica y diseño (7a. ed.). Cengage Learning
Complementaria
• Brassard, G. y Bratley, P. (1995). Fundamentos de la algoritmia. México: Prentice-Hall
• Byron, G. (2001). Programación en C. México: Prentice Hall.
• Norton, P. (2004). Introducción a la computación. México: Prentice Hall
• Joyanes Aguilar, L. (2002) Fundamentos de la programación. Buenos Aires: Pearson Educativa.
• Joyanes Aguilar, L. (2001). Fundamentos de la programación, algoritmos y estructuras de datos.
Buenos Aires: Pearson Educativa.

Guía de Conceptos – Material Básico 27