COLEGIO DEPARTAMENTAL CONCEPCIÓN

“MIRANDO AL FUTURO APOYAMOS LA EDUCACIÓN”

Algorítmica
Resolución de problemas algorítmicos

2° B.T.I

Docente: Lic. Juan Benito Torres Báez.

NOVIEMBRE 2015
 Índice

Resolución de problemas algorítmicos

ESTRUCTURAS SELECTIVAS...................................................................................................2
ESTRUCTURAS REPETITIVAS................................................................................................30
VECTORES EJERCICIOS........................................................................................................68

2
 ESTRUCTURAS SELECTIVAS
EJERCICIOS

01. Leer un número e imprimir un mensaje para indicar si es positivo. (Estructura Selectiva
Simple).
Algoritmo: E1
Var
entero: num
INICIO
num ß Ø;
Leer ("Introduzca un número:",num)
Si num > Ø Entonces
Imprimir ("El número es positivo")
Sino
Imprimir ("Error")
Fin_Si
FIN

02. Leer un Número e imprimir un mensaje para indicar si es Par. (Estructura Selectiva Simple)
Algoritmo: E2
Var
entero: num,
INICIO
num ß Ø;
Leer ("Introduzca un numero:",num)
Si num MOD 2 = Ø entonces
Imprimir ("El número es Par")
Sino
Imprimir ("Error")
Fin_Si
FIN

3
03. Leer un número e imprimir un mensaje para indicar si es par. (Estructura Selectiva Doble).
Algoritmo: E3
Var
entero: a
INICIO
a ß Ø;
Leer ("Introduzca un numero:",num)
Si a MOD 4 = 0 y a MOD 100 <> Ø o a MOD 400 = 0 entonces
Imprimir ("El año es Bisiesto")
Sino
Imprimir ("El año no es bisiesto")
Fin_Si
FIN

04. Leer un Número e imprimir un mensaje para determinar si es positivo, negativo o cero.
(Estructura Selectiva Doble).
Algoritmo: E4
Var
entero: num,
INICIO
num ß Ø;
Leer ("Introduzca un numero:",num)
Si num > Ø Entonces
Imprimir ( "El número es positivo")
Sino
Si num < Ø Entonces
Imprimir ("El número es negativo")
Sino
Imprimir ("El número es cero")
Fin_Si
Fin_Si
FIN

4
05. Leer un Número e imprimir un mensaje para determinar si es Par, Impar o Cero.
Algoritmo: E5
Var
entero: num
INICIO
num ß Ø;
Leer ("Introduzca un numero:", num)
Si num MOD 2 = Ø Entonces
Imprimir ("El número es par")
Sino
Si num MOD 2 Ø entonces
Imprimir ("El número es impar")
Sino
Imprimir ("El número es cero")
Fin_Si
Fin_Si
FIN

06. Leer la calificación de un alumno. Si es 1 imprimir "Aplazado”, si es de 2 a 5 imprimir

"Aprobado", en otro caso imprimir "Calificación no válida”.
Algoritmo: E6
Var
entero: cal
INICIO
cal ß Ø
Leer ("Introduzca la calificación:", cal)
Si cal = 1 Entonces
Imprimir ("Aplazado")
Sino
Si cal >= 2 y cal <= 5 Entonces
Imprimir ("Aprobado")
Sino
Si cal < Ø y cal > 5 Entonces
Imprimir ("Error")
Fin_Si
Fin_Si
Fin_Si
FIN

5
07. Leer dos números, y decir si están en orden ascendente o descendente.
Algoritmo: E7
Var
entero: n1, n2
INICIO
n1, n2 ß Ø
Leer ("Introduzca un número:", n1)
Leer ("Introduzca otro número:", n2)
Si n1 < n2 Entonces
Imprimir ("Está de forma ascendente")
Sino
Si n1 > n2 Entonces
Imprimir ("Esta de forma descendente")
Sino
Imprimir ("Error")
Fin_Si
Fin_Si
FIN

08. Verificar si un número leído es múltiplo de 3 o de 5.

Algoritmo: E8
Var
Entero: num
INICIO
num ß Ø
Leer ("Introduzca un numero:", num)
Si num MOD 3 = Ø y num MOD 5 = Ø Entonces
Imprimir ("El número es múltiplo de 5 y de 3")
Sino
Si num MOD 3 = Ø Entonces
Imprimir ("El número es múltiplo de 3")
Sino
Si num MOD 5 = Ø Entonces
Imprimir ("El número es múltiplo de 5")
Fin_Si
Fin_Si
Fin_Si
FIN

6
09. Encontrar el mayor de 3 números.
Algoritmo: E9
var
entero: n1, n2, n3
INICIO
n1, n2, n3 ß Ø
Leer ("Introduzca el primer número: ", n1)
Leer ("Introduzca el segundo número: ", n2)
Leer ("Introduzca el tercer número: ", n3)
Si n1 > n2 y n1 > n3 Entonces
Imprimir ("El mayor es: ", n1)
Sino
Si n2 > n1 y n2 > n3 Entonces
Imprimir ("El mayor es: ", n2)
Sino
Si n3 > n1 y n3 > n2 Entonces
Imprimir ("El mayor es: ", n3)
Fin_Si
Fin_Si
Fin_Si

FIN

10. Encontrar el menor de 4 números.

Algoritmo: E8
var
entero: n1, n2, n3, n4
INICIO
n1, n2, n3, n4 ß Ø
Leer ("Introduzca el primer número: ", n1)
Leer ("Introduzca el segundo número: ", n2)
Leer ("Introduzca el tercer número: ", n3)
Leer ("Introduzca el cuarto número: ", n4)
Si n1 < n2 y n1 < n3 y n1 < n4 Entonces
Imprimir ("El menor es: ", n1)
Sino
Si n2 < n1 y n2 < n3 y n2 < n4 Entonces
Imprimir ("El menor es: ", n2)
Sino
Si n3 < n1 y n3 < n2 y n3 < n4 Entonces
Imprimir ("El menor es: ", n3)
Sino
Si n4 < n1 y n4 < n2 y n4 < n3 Entonces
Imprimir ("El menor es: ", n4)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

7
11. Encontrar el mayor y el menor de tres números.
Algoritmo: E11
var
entero: n1, n2, n3
INICIO
n1, n2, n3 ß Ø
Leer ("Introduzca el primer número: ", n1)
Leer ("Introduzca el segundo número: ", n2)
Leer ("Introduzca el tercer número: ", n3)
Si n1 > n2 y n1 > n3 Entonces
Imprimir ("El mayor es: ", n1)
Sino
Si n2 > n1 y n2 > n3 Entonces
Imprimir ("El mayor es: ", n2)
Sino
Si n3 > n1 y n3 > n2 Entonces
Imprimir ("El mayor es: ", n3)
Sino
Si n1 < n2 y n1 < n3 Entonces
Imprimir ("El menor es: ", n1)
Sino
Si n2 < n1 y n2 < n3 Entonces
Imprimir ("El menor es: ", n2)
Sino
Si n3 < n1 y n3 < n2 Entonces
Imprimir ("El menor es: ", n3)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

8
12. Leer tres números y hallar la diferencia del mayor menos el menor.
Algoritmo: Ej_12
var
entero: n1, n2, n3, may, men, dif
INICIO
n1, n2, n3, may, men, dif ß Ø
LEER (“Escribir el número: “, n1)
LEER (“Escribir el número: “, n2)
LEER (“Escribir el número: “, n3)
Si n1 > n2 y n1 > n3 Entonces
may ß n1
Sino
Si n2 > n1 y n2 > n3 Entonces
may ß n2
Sino
Si n3 > n1 Y n3 > n2 Entonces
may ß n3
Sino
Si n1 < n2 y n1 < n3 Entonces
men ß n1
Sino
Si n2 < n1 y n2 < n3 Entonces
men ß n2
Sino
Si n3 < n1 Y n3 < n2 Entonces
men ß n3
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
dif ß may – men
Imprimir (“La diferencia es:”, dif)
FIN

9
13. Leer tres números, y decir si están en orden ascendente, descendente, sin orden o si son
todos iguales.
Algoritmo: Ej_13
var
entero: n1, n2, n3
INICIO
n1, n2, n3 ß Ø
LEER (“Escribir el número: “, n1)
LEER (“Escribir el número: “, n2)
LEER (“Escribir el número: “, n3)
Si n1 < n2 y n1 <= n3 Entonces
Imprimir (“Los números están e orden ascendente”)
Sino
Si n1 > n2 y n2 >= n3 Entonces
Imprimir (“Los números están e orden descendente”)
Sino
Si n1 = n2 y n2 = n3 Entonces
Imprimir (“Los números son todos iguales”)
Sino
Imprimir (“Los números no tienen orden”)
Fin_Si
Fin_Si
Fin_Si
FIN

10
14. Introducir tres números positivos a, b y c (DISTINTOS ENTRE SI), luego mostrarlos de tal
manera que el menor de ellos se encuentre entre los mayores (los mayores que se encuentran
en los extremos deben estar ordenados ascendentemente).
Ejemplo:
Si a=2, b=5 y c=12 Entonces se deberá mostrar 5, 2, 12.
Si a=12, b=6 y c=8 Entonces se deberá mostrar 8, 6, 12.
Algoritmo: Ej_14
var
entero: a, b, c, men, may1, may2
INICIO
a, b, c, men, may1, may2 ß Ø
LEER (“Escribir el número: “, a)
LEER (“Escribir el número: “, b)
LEER (“Escribir el número: “, c)
Si a < b y a < c Entonces
men ß a
Si b > c Entonces
may1 ß b
may2 ß c
Sino
may1 ß c
may2 ß b
Fin_Si
Sino
Si b < a y b < c Entonces
men ß b
Si a > c Entonces
may1 ß a
may2 ß c
Sino
may1 ß c
may2 ß a
Fin_Si
Sino
Si c < a y c < b Entonces
men ß c
Si a > b Entonces
may1 ß a
may2 ß b
Sino
may1 ß b
may2 ß a
Fin_Si
Fin_Si
Fin_Si

11
 Fin_Si
Imprimir (may1)
Imprimir (men)
Imprimir (may2)
FIN

12
15. Leer un número e indicar si tiene 1, 2, 3 o más de 3 dígitos. Considerar los negativos.
Algoritmo: Ej_15
var
entero: num
INICIO
num ß Ø
LEER (“Escribir el número:“, num)
Si num >= -9 y num <= 9 Entonces
Imprimir (“El número tiene un dígito”)
Sino
Si num >= -99 y num <= 99 Entonces
Imprimir (“El número tiene dos dígitos”)
Sino
Si num >= -999 y num <= 999 Entonces
Imprimir (“El número tiene tres dígitos”)
Sino
Imprimir (“El número tiene más de tres dígitos”)
Fin_Si
Fin_Si
Fin_Si
FIN

16. Un banco antes de conceder un préstamo, comprueba los ingresos del solicitante. Si los
ingresos son superiores a 3000000 Gs., el crédito se concede. Si los ingresos son inferiores a
3000000 Gs. Pero superiores a 2000000 Gs., y el cliente tiene máximo 2 hijos, el crédito se
concede. También se le concede, si tiene ingresos entre 1400000 y 1900000 Gs. Pero no tiene
hijos. Realizar un algoritmo que pida los ingresos mensuales y el número de hijos del
solicitante, y diga si se le da el crédito o no.
Algoritmo: Ej_16
var
entero: imen,nhijos
INICIO
imen,nhijos ß Ø
LEER(“Ingreso mensual:“,imen)
LEER(“Número de hijos:“,nhijos)
Si imen > 3000000 Entonces
Imprimir(“El crédito se concede”)
Sino
Si imen < 3000000 y imen > 2000000 y nhijos <= 2 Entonces
Imprimir(“El crédito se concede”)
Sino
Si imen >= 1400000 o imen <= 1900000 y nhijos = 0 Entonces
Imprimir(“El crédito se concede”)
Sino
Imprimir(“El crédito no se concede”)
Fin_Si
Fin_Si
Fin_Si
FIN

13
17. Diseñe un algoritmo que lea el importe de la compra y la cantidad recibida y calcule el
cambio a devolver, teniendo en cuenta que el número de monedas que se devuelven debe ser
mínimo.
Suponer que el sistema monetario utilizado consta de monedas de 1000, 500 100, 50 y 10 Gs.,
y que hay capacidad limitada de monedas.
Algoritmo: Ej_17
var
entero: impor, cant, camb, m1, m2, m3, m4, m5
INICIO
impor, cant, camb, m1, m2, m3, m4, m5 ß Ø
LEER (“Importe de la compra: “, impor)
LEER (“Cantidad recibida: “, cant)
Si cant >= impor Entonces
camb ß cant – impor
m1 ß camb / 1000
camb ß camb % 1000
m2 ß camb / 500
camb ß camb % 500
m3 ß camb / 100
camb ß camb % 100
m4 ß camb / 50
camb ß camb % 50
m5 ß camb / 10
camb ß camb % 10
Imprimir (“Monedas de 1000:”,m1)
Imprimir (“Monedas de 500:”,m2)
Imprimir (“Monedas de 100:”,m3)
Imprimir (“Monedas de 50:”,m4)
Imprimir (“Monedas de 10:”,m5)
Sino
Imprimir (“No se puede realizar el cobro”)
Fin_Si
FIN

14
18. Dados dos enteros, día y mes, de una fecha de un año no bisiesto, indicar si es correcta.
Algoritmo: Ej_18
var
entero: dia, mes, cant
INICIO
dia, mes, cant ß Ø
LEER (“Ingrese el día: “, dia)
LEER (“Ingrese el mes: “, mes)
Si mes < 1 y mes > 12 Entonces
Imprimir (“Fecha incorrecta”)
Sino
Caso_De mes Hacer
Caso 1, 3, 5, 7, 8, 10, 12
cant ß 31
Caso 4, 6, 9, 11
cant ß 30
Caso 2
cant ß 28
Fin_Caso
Si dia >= 1 y dia >= cant Entonces
Imprimir (“Fecha correcta”)
Sino
Imprimir (“Fecha incorrecta”)
Fin_Si
Fin_Si
FIN

15
19. Escriba un algoritmo que lea tres números enteros de un supuesto triángulo, determine si
realmente forman un triángulo, y muestre el tipo de triángulo que es (si es un triángulo).
a) triángulo: la suma de dos cualesquiera de los lados debe ser mayor que el otro.
b) equilátero: todos los lados son iguales.
c) isósceles: solo dos lados son iguales.
d) escaleno: no tiene dos lados iguales.
Algoritmo: Ej_19
var
entero: n1, n2, n3
INICIO
n1, n2, n3 ß Ø
LEER (“Ingresar el número: “, n1)
LEER (“Ingresar el número: “, n2)
LEER (“Ingresar el número: “, n3)
Si (n1 + n2) > n3 o (n1 + n3) > n2 o (n2 + n3) > n1 Entonces
Imprimir (“Es un triángulo”)
Sino
Si n1 = n2 y n2 = n3 Entonces
Imprimir (“Es un triángulo equilátero”)
Sino
Si n1 = n2 o n1 = n3 o n2 = n3 Entonces
Imprimir (“Es un triángulo isósceles”)
Sino
Si n1 <> n2 y n1 <> n3 y n2 <> n3 Entonces
Imprimir (“Es un triángulo escaleno”)
Sino
Imprimir (“No es un triángulo”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

16
20. Dos entidades financieras ofrecen las siguientes tasas de interés simple:
Entidad A Entidad B
Dinero Depositado Interés Mensual Dinero Depositado Interés Mensual
10.000 a 5.000.000 Gs. 5% 10.000 a 6.000.000 Gs. 7%
5.000.001 a 9.999.999 Gs. 12% 6.000.001 a 8.999.999 Gs. 10%
10.000.000 Gs., o más 16% 9.000.000 Gs., o más 15%
Desarrollar un algoritmo que realice lo siguiente:
 Solicite al usuario que ingrese el monto de dinero que desea y el tiempo (meses) que lo
mantendrá en el banco.
 Determine cuál de las dos entidades, A o B, es más conveniente para depositar el
dinero y muestre un mensaje indicando en que entidad debería el usuario depositar el
monto ingresado, y cuánto dinero tendrá luego de transcurrido el tiempo que indico al
inicio.
Nota: Para calcular el interés simple se utiliza la siguiente formula: Interés = Capital *
Tasa * Tiempo
Algoritmo: Ej_20
var
entero: mont, tiempo, A, B, interés, conviene
INICIO
mont, temp, A, B, interes, conviene ß Ø
LEER (“Ingresa el monto: “, mont)
LEER (“Ingresa el tiempo: “, tiemp)
Si mont >= 10000 y mont <= 5000000 Entonces
Aß5
interés ß mont * A * tiemp
Sino
Si mont >= 500000 y mont <= 9999999 Entonces
A ß 12
interes ß mont * A * tiempo
Sino
Si mont <= 10000000 Entonces
A ß 16
interes ß mont * A * tiemp
Fin_Si
Fin_Si
Fin_Si
Si mont >= 10000 y mont <= 6000000 Entonces
Bß7
interes ß mont * B * tiempo
Sino
Si mont >= 6000001 y mont <= 8999999 Entonces
B ß 10
interes ß mont * B * tiempo
Sino
Si mont >= 9000000 Entonces
B ß 15

17
 interes ß mont * B * tiempo
Fin_Si
Fin_Si
Fin_Si
Si A > B Entonces
conviene ß A
Sino
conviene ß B
Fin_Si
Si conviene = A Entonces
interés ß mont * A * tiempo
Imprimir (“La entidad A conviene por la tasa:”, interes” %” “de interés”)
Sino
interés ß mont * B * tiempo
Imprimir (“La entidad A conviene por la tasa:”, interes”%” “de interés”)
Fin_Si
FIN

18
21. 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 éstas 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
paga por una hora normal y el resto al triple.
Algoritmo: Ej_21
var
entero: hstra, mhora, extra, sb, extra1, extra2, sn
INICIO
hstra, mhora, extra, sb, extra1, extra2, sn ß Ø
LEER (“Ingrese las horas trabajadas: “, hstra)
LEER (“Ingrese el monto por hora: “, mhora)
Si hstra <= 40 Entonces
sb ß hstra * mhora
Imprimir (“Su sueldo bruto es:”,sb)
Sino
extra ß hstra - 40
sb ß 40 * mhora
Imprimir (“Sus sueldo bruto es:”,extra)
Imprimir (“Su sueldo bruto es:”,sb)
Fin_Si
Si extra >= 8 Entonces
extra1 ß 8 * 2 * mhora
extra2 ß extra - 8
extra2 ß extra2 * 3 * mhora
sn ß sb + extra1 + extra2
Imprimir (“Su sueldo por 8 horas extras es:”, extra1)
Imprimir (“Su sueldo por las horas extras restantes es:”, extra2)
Imprimir (“Su sueldo neto es:”, sn)
Fin_Si
Si extra <= 8 Entonces
Extra1 ß extra * 2 mhora
sn ß sb + extra1
Imprimir (“Su sueldo por horas extras es:”, extra1”)
Imprimir (“Su sueldo neto es:”, sn)
Fin_Si
FIN

19
22. Se desea agregar letras para representar la calificación de los alumnos, las calificaciones
son notas entre 1 y 5; use los siguientes parámetros: E para 5, MB para 4, B para 3, A para 2, I
para 1. La calificación debe ser leída.
Algoritmo: Ej_22
var
entero: nota
INICIO
nota ß Ø
LEER (“Escriba la calificación: “, nota)
Si nota = 1 Entonces
Imprimir (“I”)
Sino
Si nota = 2 Entonces
Imprimir (“A”)
Sino
Si nota = 3 Entonces
Imprimir (“B”)
Sino
Si nota = 4 Entonces
Imprimir (“MB”)
Sino
Si nota = 5 Entonces
Imprimir (“E”)
Sino
Imprimir (“Nota no válida”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

20
23. Leer el número de un día de la semana y a continuación imprimir el nombre del día de la
semana. Los días de la semana son 7; por consiguiente, el rango de valores será de 1 a 7; el uno
corresponderá a domingo, 2 a lunes… Si el número se encuentra fuera de rango se deberá
imprimir un mensaje de error.
Algoritmo: ejer23
Var
Entero: Dia
INICIO
Dia Ø
Leer (“Días:”, Dia)
Si Dia = 1 Entonces
Imprimir (“Es domingo”)
Sino
Si Dia = 2 Entonces
Imprimir (“Es lunes”)
Si no
Si Dia = 3 Entonces
Imprimir (“Es martes”)
Sino
Si Dia = 4 Entonces
Imprimir (“Es miércoles”)
Sino
Si Dia = 5 Entonces
Imprimir (“Es jueves”)
Sino
Si Dia = 6 Entonces
Imprimir (“Es viernes”)
Sino
Si Dia = 7 entonces
Imprimir (“Es sábado”)
Sino
Imprimir (“Error”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

21
24. Leer el número de un mes, y luego imprimir el nombre del mes en letras, si el número del
mes no es válido se debe mostrar un mensaje de error.
Algoritmo: ejer24
Var
Entero: n1
INICIO
n1 Ø
Leer (“Introduzca un mes:”, n1)
Si n1 = 1 Entonces
Imprimir (“Enero”)
Sino
Si n1 = 2 Entonces
Imprimir (“Febrero”)
Sino
Si n1 = 3 Entonces
Imprimir (“Marzo”)
Sino
Si n1 = 4 Entonces
Imprimir (“Abril”)
Sino
Si n1 = 5 Entonces
Imprimir (“Mayo”)
Sino
Si n1 = 6 Entonces
Imprimir (“Junio”)
Sino
Si n1 = 7 Entonces
Imprimir (“Julio”)
Sino
Si n1 = 8 Entonces
Imprimir (“Agosto”)
Sino
Si n1 = 9 Entonces
Imprimir (“Septiembre”)
Sino
Si n1 = 10 Entonces
Imprimir (“Octubre”)
Sino
Si n1 = 11 entonces
Imprimir (“Noviembre”)
Sino
Si n1 = 12 Entonces
Imprimir (“Diciembre”)
Sino
Imprimir (“Fecha no válida”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si

22
 Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

25. Leer un carácter y determinar si es o no una vocal.

Algoritmo: ejer25
Var
Cadena: voc
INICIO
voc “”
Leer (“Escriba la letra: “, voc)
Si voc = “A” Entonces
Imprimir (“Es una vocal”)
Sino
Si voc = “E” Entonces
Imprimir (“Es una vocal”)
Sino
Si voc = “I” Entonces
Imprimir (“Es una vocal”)
Sino
Si voc = “O” Entonces
Imprimir (“Es una vocal”)
Sino
Si voc = “U” Entonces
Imprimir (“Es una vocal”)
Sino
Imprimir (“No es una vocal”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

23
 26. Hacer un algoritmo que convierta un número mayor de 10000 dados en segundos a horas,
minutos y segundos. Ejemplo 12015 segundos es equivalente a 3 horas, 20 minutos, 15
segundos.
Algoritmo: ejer26
Var
Entero: num, hor, min, seg
INICIO
Num, hor, min, seg Ø
Leer (“Ingrese los segundos:”, seg)
hor num DIV 3600
num num MOD 3600
min num DIV 60
num num MOD 60
seg num DIV 1
num num MOD 1
Imprimir (hor, “hora/s”, min, “minute/s”, seg, “sesundo/s”)
FIN

27. Leer una hora en tres variables HH, MM, SS y calcular la nueva hora después de haber
transcurrido un segundo.
Algoritmo: ejer27
Var
Entero: hor, min, seg
INICIO
hor, min, seg Ø
Leer (“Ingrese la hora:”, hor)
Leer (“Ingrese el minuto:”, min)
Leer (“Ingrese el segundo:”, seg)
seg seg + 1
Si seg = 60 Entonces
seg Ø
min min + 1
Si min = 60 Entonces
min Ø
hor hor + 1
Si hor = 24 Entonces
hor Ø
Fin_Si
Fin_Si
Fin_Si
Imprimir (“Hora/s: “, hor)
Imprimir (“Minuto/s: “, min)
Imprimir (“Segundo/s: “, seg)
FIN

24
28. Leída una fecha en tres variables DD, MM, AAAA; indicar si la fecha leída es o no correcta.
Algoritmo: e28
Var
Entero: D, M, A, CAN
INICIO
D, M, A, CAN ß Ø
Leer (“Día:”, D)
Leer (“Mes:”, M)
Leer (“Año:”, A)
Si M < 1 o M > 12 Entonces
Imprimir (“Fecha incorrecta”)
Sino
Caso_De M Hacer
Caso 1, 3, 5, 7, 8, 10, 12
CAN ← 31
Caso 4, 6, 9, 11
CAN ← 30
Caso 2
Si (A MOD 4 = Ø y A MOD 100 < > Ø o A MOD 400 = Ø) Entonces
CAN ← 29
Sino
CAN ← 28
Fin_Si
Fin_Caso
Si (D >= 1 y D <= CAN) entonces
Si (A >= 1 y A <= 9999) entonces
Imprimir (“Fecha correcta”)
Sino
Imprimir (“Fecha incorrecta”)
Fin_Si
Sino
Imprimir (“Fecha incorrecta”)
Fin_Si
Fin_Si
FIN

25
29. Después de leer el número del día de un mes, determinar el día de la semana al cual
corresponde, suponiendo que el día 1 de dicho mes haya sido lunes.
Algoritmo: ej29
Var
Entero: num
INICIO
num ← Ø
Leer (“Introduzca el Numero:”, num)
Si num MOD 7 = Ø Entonces
Imprimir (“Domingo”)
Sino
Si num MOD 7 = 1 Entonces
Imprimir (“Lunes”)
Sino
Si num MOD 7 = 2 Entonces
Imprimir (“Martes”)
Sino
Si num MOD 7 = 3 Entonces
Imprimir (“Miércoles”)
Sino
Si num MOD 7 = 4 Entonces
Imprimir (“Jueves”)
Sino
Si num MOD 7 = 5 Entonces
Imprimir (“Viernes”)
Sino
Si num MOD 7 = 6 Entonces
Imprimir (“Sábado”)
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

26
30. Preguntar qué día de la semana fue el día 1 del mes actual y calcular que dia de la semana
es hoy (el número del día de hoy debe ser leído).
Algoritmo: e30
Var
Entero: num
Cadena: dia
INICIO
num ← Ø
día ← “ “
Leer (“El dia de la semana es:”, dia)
Leer (“Ingrese el numero:”, num)
Caso_De dia Hacer
Caso “Domingo”
num ß num + 6
Caso “Lunes”
num ß num + 0
Caso “Martes”
Num ß num + 1
Caso “Miércoles”
num ß num + 2
Caso “Jueves”
num ß num + 3
Caso “Viernes”
num ß num + 4
Caso “Sábado”
num ß num + 5
Fin_Caso
Caso_De (num MOD 7) Hacer
Caso Ø
Imprimir (“Domingo”)
Caso 1
Imprimir (“Lunes”)
Caso 2
Imprimir (“Martes”)
Caso 3
Imprimir (“Miércoles”)
Caso 4
Imprimir (“Jueves”)
Caso 5
Imprimir (“Viernes”)
Caso 6
Imprimir (“Sábado”)
Fin_Caso
FIN

27
31. Leer el nombre de una persona, la fecha de nacimiento (en tres variables: DD, MM, AAAA) y
la fecha actual (en tres variables: DD, MM, AAAA). Calcular la edad actual en años de la
persona. Se supone que las fechas leídas son correctas.
Algoritmo: e31
Var
Entero: dact, mact, act, dnac, mnac, anac, edad
Cadena: nom
INICIO
dact, mact, act, dnac, mnac, anac, edad ← Ø
nom ← “ “
Leer (“Ingrese el nombre:”, nom)
Leer (“Día actual:”, dact)
Leer (“Mes actual:”, mact)
Leer (“Año actual:”, act)
Leer (“Día de nacimiento:”, dnac)
Leer (“Mes de nacimiento:”, mnac)
Leer (“Año de nacimiento:”, anac)
Si mact > mnac Entonces
edad ← act – anac
Sino
edad ← (act - anac) - 1
Fin_Si
Si mact = mnac Entonces
Si dact >= dnac Entonces
edad ← act - anac
Sino
edad ← (act – anac) - 1
Fin_Si
Fin_Si
Imprimir (nom, ”tiene”, edad, ”años”)
FIN

28
32. Leer una hora inicial y una final (en tres variables). Calcular la diferencia entre ambas horas
en segundos, se supone que los valores leídos son correctos.
Algoritmo: e32
Var
Entero: hh, mm, ss, hf, mf, sf, segundos, s1, s2, suma
INICIO
hh, mm, ss, hf, mf, sf, segundos, s1, s2, suma ← Ø
Leer (“Hora inicial:”, hh)
Leer (“Minuto inicial:”, mm)
Leer (“Segundo inicial:”, ss)
Leer (“Hora final:”, hf)
Leer (“Minuto final:”, mf)
Leer (“Segundo final:”, sf)
segundos ← (hf - hh) * 3600
s1 ← (mf - mm) * 60
s2 ← sf – ss
suma ← segundos + s1 + s2
Imprimir (“La diferencia es de:”,suma ”segundos”)
FIN

29
33. El importe del seguro de un coche depende del modelo del coche, del color y d la edad del
conductor. Sean dos modelos de coche A y B y los precios del seguro según el color:
Modelo Color Precio
Blanco 150.000
A Metalizado
Otros
180.000
200.000
Blanco 210.000
B Metalizado
Otros
250.000
300.000

Algoritmo: e33
Var
Entero: precio, edad, seguro, porcentaje
Cadena: modelo, color
INICIO
precio, edad, seg, porcentaje ← Ø
modelo, color ← “ “
Leer (“Modelo:”, modelo)
Leer (“Color:”, color)
Leer (“Edad:”, edad)
Si edad < 26 Entonces
porcentaje ← 25
Sino
Si edad >= 26 y edad <= 30 Entonces
porcentaje ← 10
Sino
Si edad >= 31 y edad <= 65 Entonces
porcentaje ← Ø
Sino
Si edad > 65 Entonces
porcentaje ← 15
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Si modelo = “A” y color = “Blanco” Entonces
seg ← (150.000 * porcentaje / 100) + 150.000
Sino
Si modelo = “B” y color = “Blanco” Entonces
seg ← (210.000 * porcentaje / 100) + 210.000

30
 Sino

Si modelo = “A” y color = “Metalizado” Entonces

seg ← (180.000 * porcentaje / 100) + 180.000
Sino
Si modelo = “B” y color = “Metalizado” Entonces
seg ← (250.000 * porcentaje / 100) + 250.000
Sino
Si modelo = “A” y color = “Otros” Entonces
seg ← (200.000 * porcentaje / 100) + 200.000
Sino
Si modelo = “B” y color = “Otros” Entonces
seg ← (300.000 * porcentaje / 100) + 300.000
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
FIN

31
 ESTRUCTURAS REPETITIVAS
EJERCICIOS

01. Leer un número positivo.

Algoritmo: ejer1
Var
Entero: num
INICIO
num ß Ø
Mientras num <= Ø Hacer
Leer (“Ingrese un número positivo:”, num)
Fin_Mientras
FIN

02. Leer un número negativo.

Algoritmo: ejer2
Var
Entero: num
INICIO
num ß Ø
Mientras num >= Ø Hacer
Leer (“Ingrese un número negativo:”, num)
Fin_Mientras
FIN

03. Leer un número par.

Algoritmo: ejer3
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD 2 <> Ø o num MOD 2 = Ø Hacer
Leer (“Ingrese un número par:”, num)
Fin_Mientras
FIN

04. Leer un número impar.

Algoritmo: ejer4
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD 2 = Ø Hacer
Leer (“Ingrese un número impar:”, num)
Fin_Mientras
FIN

32
05. Leer un número comprendido entre 10 y 20.
Algoritmo: ejer5
Var
Entero: num
INICIO
num ß Ø
Mientras num < 10 o num > 20 Hacer
Leer (“Ingrese un número:”, num)
Fin_Mientras
FIN

06. Leer un número par positivo.

Algoritmo: ejer6
Var
Entero: num
INICIO
Num ß Ø
Mientras num MOD 2 <> Ø Hacer o num <= Ø Hacer
Leer (“n numero par positivo:”, num)
Fin_Mientras
FIN

07. Leer un número impar positivo.

Algoritmo: ejer7
Var
Entero: num
INICIO
Num ß Ø
Mientras num MOD 2 = Ø Hacer o num <= Ø Hacer
Leer (“Un número impar positivo:”, num)
Fin_Mientras
FIN

08. Leer un número par positivo.

Algoritmo: ejer8
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD 2 <> Ø Hacer o num >= Ø Hacer
Leer (“Un numero par negativo:”, num)
Fin_Mientras
FIN

33
09. Leer un número impar negativo.
Algoritmo: ejer9
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD 2 <> Ø Hacer o num >= Ø Hacer
Leer (“Un número impar negativo:”, num)
Fin_Mientras
FIN

10. Leer un número par comprendido entre 50 y 60.

Algoritmo: ejer10
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD 2 <> Ø Hacer o num < 50 o num >60 Hacer
Leer (“Escriba numero par comprendido entre 50 y 60:”, num)
Fin_Mientras
FIN

11. Leer un número impar comprendido entre 50 y 60

Algoritmo: ejer 11
Var
Entero: num
INICIO
num ß Ø
Mientras num MOD2 = Ø o num < 21 o num < 29 Hacer
Leer (“ Escriba un numero: ”, num)
Fin_Mientras
FIN

12. Leer una cadena “SI” o “NO”.

Algoritmo: ejer 12
Var
Cadena: valor
INICIO
valor ß “ ”
Mientras valor <> ”si” y valor <> “no” Hacer
Leer (“Una palabra:”, valor)
Fin_Mientras
FIN

34
13. Leer una cadena que tenga mínimo 5 caracteres.
Algoritmo: ejer 13
Var
cadena: valor
INICIO
Valor ß “ ”
Mientras valor < 5 Hacer
Leer(“Escriba otra palabra: ”, valor)
Fin_Mientras
FIN

14. Imprimir números del 11 al 30, mediante la estructura Mientras y Para.

Algoritmo: eje14
Var
entero: num
INICIO
Num ß 11
Mientras num <= 30 Hacer
Imprimir (num)
num = num + 1
Fin_Mientras
FIN

Algoritmo: ejer14
INICIO
Para num ß 11 Hasta 30 Hacer
Imprimir (num)
Fin_Para
FIN

15. Imprimir números pares del 20 al 40, mediante la estructura Mientras y Para
Algoritmo: ejer15
Var
Entero: num
INICIO
Num ß 20
Mientras num MOD2 <> 0 o num <= 40 Hacer
Imprimir (num)
num = num+2
Fin_Mientras
FIN

Algoritmo: ejer15
INICIO
Para (var = 20; num<=40; num = num+2) Hacer
Imprimir (num)
Fin_Para
FIN

35
16. Imprimir números impares del 101 al 125, mediante la estructura Mientras y Para.
Algoritmo: e16
Var
Entero: num
INICIO
num ← 101
Mientras num MOD 2 = Ø o num <= 125 Hacer
Imprimir (num)
num ← num + 2
Fin_Mientras
FIN

Algoritmo: e16_para
INICIO
Para num ← 101 Hasta 125 Hacer
Imprimir (num)
Fin_Para
FIN

17. Imprimir números múltiplos de 7, desde 14 hasta 77, mediante la estructura Mientras y
Para.
Algoritmo: e17
Var
Entero: num
INICIO
num ← 14
Mientras num MOD 7 = Ø y num < > Ø y num <= 77 Hacer
Imprimir (num)
num ← num + 7
Fin_Mientras
FIN

Algoritmo: e17_para
INICIO
Para num ← 14 ; num MOD 7 = Ø y num < > Ø y num <= 77; num + 7 Hacer
Imprimir (num)
Fin_Para
FIN

18. Sumar e imprimir los números comprendidos entre 10 y 100, mediante la estructura
Mientras y Para.
Algoritmo: e18
Var
Entero: num, suma
INICIO
num ← 14
suma ← Ø
Mientras num <= 100 Hacer
suma ← suma + num
num ← num + 1
Fin_Mientras
FIN

36
Algoritmo: e18_para
INICIO
Para num ← 10 Hasta 100 Hacer
suma ß suma + num
Imprimir (num)
Fin_Para
FIN

19. Sumar por separado los números pares e impares comprendidos entre 100 y 500, mediante
la estructura Mientras y Para.
Algoritmo: e19
Var
Entero: num, sumapar, sumaimpar
INICIO
num ← 100 ; sumapar, sumaimpar ← Ø
Mientras num <= 500 hacer
Si num MOD 2 = Ø Entonces
sumapar ← sumapar + num
Sino
sumaimpar ← sumaimpar + num
Fin_Si
num ← num + 1
Fin_Mientras
Imprimir (“La suma par es: “, sumapar)
Imprimir (“La suma impar es: “, sumaimpar)
FIN

Algoritmo: e19_para
Var
Entero: sumapar, sumaimpar
INICIO
sumapar, sumaimpar ← Ø
Para num ← 100 Hasta 500 Hacer
Si num MOD 2 = Ø Entonces
sumapar ← sumapar + num
Sino
sumaimpar ← sumaimpar + num
Fin_Si
num ← num + 1
Imprimir (“ La suma par es: “, sumapar)
Imprimir (“ La suma impar es: “, sumaimpar)
Fin_Para
FIN

37
20. Calcular el promedio de los números del 100 al 200, mediante la estructura Mientras y
Para.
Algoritmo: e20
Var
Entero: num, suma, promedio
INICIO
num ← 100 ; suma, promedio ← Ø
Mientras num <= 200 Hacer
suma ← suma + num
num ← num + 1
Fin_Mientras
Promedio ← suma / 100
Imprimir (“El promedio es: “, promedio)
FIN

Algoritmo: e20_para
Var
Entero: suma, promedio
INICIO
suma, promedio ← Ø
Para num ← 100 Hasta 200 Hacer
suma ← suma + num
num ← num + 1
Fin_Para
Imprimir (“El promedio es: “, promedio)
FIN

21. Leer números hasta encontrar CERO y determinar el mayor leído.

Algoritmo: e21
Var
Entero: num, mayor
INICIO
num, mayor ß Ø
Leer(“Introduzca un número:”, num)
mayor ßnum
Mientras num <> Ø Hacer
Si num > mayor Entonces
mayor ß num
Fin_Si
Leer(“Introduzca un número: ”, num)
Fin_Mientras
Si mayor = Ø Entonces
Imprimir (“No existe mayor”)
Sino
Imprimir (“El mayor es :”, mayor)
Fin_Si
FIN

38
22. Leer números hasta encontrar CERO y determinar el menor leído.
Algoritmo: e22
Var entero: num, menor
INICIO
num, menor ß Ø
leer(“Introduzca un número:”, num)
menor ß num
Mientras num <> Ø Hacer
Si num < menor Entonces
menor ß num
Fin_Si
Leer(“Introduzca un número:”, num)
Fin_Mientras
Si menor = Ø Entonces
Imprimir(“No existe mayor”)
Sino
Imprimir(“El mayor es :”,mayor)
Fin_Si
FIN

23. Leer números hasta encontrar CERO y determinar el mayor leído y el menor leído.
Algoritmo: e23
Var Entero: num, mayor, menor
INICIO
num, mayor, menor ß Ø
leer(“Introduzca un número:”,num)
mayorßnum
menorßnum
Mientras num <> Ø Hacer
Si num > mayor Entonces
mayor ß num
Sino
Si num < menor Entonces
menor ß num
Fin_Si
Fin_Si
Leer(“Introduzca un número: ”, num)
Fin_Mientras
Si mayor = Ø o menor = Ø Entonces
Imprimir (“No existe mayor o menor”)
Sino
Imprimir (“El mayor es :”, mayor)
Imprimir (“El menor es :”, menor)
Fin_Si
FIN

39
24. Leer números hasta encontrar CERO, imprimir en tiempo real el mayor y el menor. En el
caso de que el primer número leído sea CERO, mostrar un mensaje de que no se ha leído
ningún número.
Algoritmo: e24
Var Entero: num, mayor, menor
INICIO
num, mayor, menor ß Ø
Leer(“Introduzca un número:”, num)
mayor ß num
menor ß num
Mientras num <> Ø Hacer
Si num > mayor Entonces
mayor ß num
Sino
Si num < menor Entonces
menor ß num
Fin_Si
Fin_Si
Imprimir (“El mayor es :”, mayor)
Imprimir (“El menor es :”, menor)
Leer (“Introduzca un número: ”, num)
Fin_Mientras
Si mayor = Ø o menor = Ø Entonces
Imprimir (“No existe mayor o menor”)
Fin_Si
FIN

25. Escribir un algoritmo para imprimir el número 1, una vez, el número 2, dos veces; el
número 3, tres veces y así sucesivamente hasta llegar al número n ingresado. Este número
ingresado deberá ser positivo.
Algoritmo: e25
Var
Entero: num
INICIO
num ß Ø
Mientras num <> Ø Hacer
Leer (“Introduzca un número:”, num)
Fin_Mientras
Desde conß1 Hasta num Hacer
Desde n ß 1 Hasta con Hacer
Imprimir (con)
Fin_Desde
Fin_Desde
FIN

40
26. Se debe leer la calificación de la materia Algorítmica de 10 alumnos. Realizar un algoritmo
para calcular la calificación media, la calificación más alta y más baja del grupo.
Algoritmo: e26
Var
Entero: suma, mayor, menor, nota
Real: promedio
INICIO
suma, mayor, menor, nota ß Ø
promedio ß Ø
Desde alumß1 Hasta 10 Hacer
nota ßØ
Mientras nota < 1 o nota > 5 Hacer
Leer (“Introduzca una nota:”,nota)
Fin_mientras
suma ß suma + nota
Si alum = 1 Entonces
mayor ßnota
menor ßnota
Sino
Si nota > mayor Entonces
mayorßnota
Sino
menorßnota
Fin_Si
Fin_Si
Fin_Desde
promedio ß suma DIV 10
Imprimir (“El mayor es:”, mayor)
Imprimir (“El menor es:”, menor)
Imprimir (“El promedio es:”, promedio)
FIN

41
27. El factorial de un número se define como el producto de todos los números consecutivos
desde la unidad hasta el número, por ejemplo el factorial de 4 = 1*2*3*4. Teniendo en cuenta
esto, lea un número positivo, calcule e imprima su factorial.
Algoritmo: e27
Var
Entero: num, con, fac
INICIO
Num ß Ø
Fac, con ß1
Mientras num <= Ø Hacer
Leer(“Introduzca un número:”, num)
Fin_Mientras
Mientras con<= num Hacer
fac ß fac *con
conßcon + 1
Fin_Mientras
Imprimir (“El factorial de ”, num, “es ”, fac)
FIN

28. Leer 6 números negativos y convertirlos a positivos e imprimir dichos números.

Algoritmo: e28
Var
Entero: num, lectura, positivo
INICIO
num, positivo ß Ø
Desde lecturaß1 Hasta 6 Hacer
Mientras num >= Ø Hacer
Leer (“Introduzca un número negativo:”, num)
Fin_Mientras
positivo ß num * (-1)
Imprimir (positivo)
Leer (“Introduzca un número negativo:”, num)
Fin_Desde
FIN

42
29. Elaborar un algoritmo que permita ingresar 10 números y muestre aquellos números
menores o iguales que 20.
Algoritmo: e29
Var
Entero: num, lectura
INICIO
num ß Ø
Desde lecturaß1 Hasta 11 Hacer
Leer (“Introduzca un número:”, num)
Si num < 20 Entonces
Imprimir(“El número”, num, “es menor a 20”)
Sino
Si num = 20 Entonces
Imprimir (“El número”, num, “es igual a 20”)
Fin_Si
Fin_Si
Fin_Desde
FIN

30. Leer 10 calificaciones de un alumno. Publicar las 2 peores calificaciones.

Algoritmo: e_30
Var
Entero: num, peor1, peor2, lectura
INICIO
num, peor1, peor2 ß Ø
Desde lecturaß1 Hasta 10 Hacer
num ß Ø
Mientras num < 1 o num > 5 Hacer
Leer (“Introduzca una calificación:”, num)
Fin_Mientras
Si lectura = 1 Entonces
peor1 ßnum
peor2 ßnum
Sino
Si num < peor1 Entonces
peor1 ß num
Sino
Si num < peor2 Entonces
peor2 ß num
Fin_Si
Fin_Si
Fin_Si
Fin_Desde
Imprimir (“La 1era peor calificación:”, peor1)
Imprimir (“La 2da peor calificación:”, peor2)
FIN

43
31. Leer 15 números y determinar cuántos son positivos y negativos.
Algoritmo: Ej_31
Var
Entero: num, peor1, peor2
INICIO
num ß Ø
Desde lectura ß 1 Hasta 10 Hacer
num ß Ø
Mientras num < 1 o num > 5 Hacer
Leer (“Introduzca una calificación:”, num)
Fin_Mientras
Si lectura = 1 Entonces
peor1 ß num
peor 2 ß num
Fin_Si
Si num < peor 1 Entonces
peor1 ß num
Sino
Si num < peor2 Entonces
peor2 ß num
Fin_Si
Fin_Si
Fin_Desde
Imprimir (peor1)
Imprimir (peor2)
FIN

32. Leer 15 números y determinar cuántos son pares e impares.

Algoritmo: Ej_32
Var
Entero: num, par, impar
INICIO
num, par, impar ß Ø
Desde conß 1 Hasta 15 Hacer
num ß Ø
Mientras num = Ø Hacer
Leer (“Introduzca un número:”, num)
Fin_Mientras
Si num MOD 2 = Ø Entonces
par ß par + 1
Sino
impar ß impar + 1
Fin_Si
Fin_Desde
Imprimir (“Números par son:”, par)
Imprimir (“Números impar son:”, impar)
FIN

44
33. Leer 15 números y determinar el porcentaje de los positivos y negativos.
Algoritmo: Ej_33
Var
Entero: num, porpos, porneg, pos, neg
INICIO
num, porpos, porneg, pos, neg ß Ø
Desde con ß 1 Hasta 15 Hacer
num ß Ø
Mientras num = Ø Hacer
Leer (“Introduzca una calificación:”, num)
Fin_Mientras
Si num > Ø Entonces
pos ß pos + 1
Sino
neg ß neg + 1
Fin_Si
Fin_Desde
porpos ß pos * 100
porneg ß neg * 100
Imprimir (“El porcentaje de los positivos son:”, porpos)
Imprimir (“El porcentaje de los negativos son:”, porneg)
FIN

34. Leer 15 números y determinar el porcentaje de los pares e impares.

Algoritmo: Ej_34
Var
Entero: num, par, impar, porpar, porimp
INICIO
num, par, impar, porpar, porimp ß Ø
Desde con ß 1 Hasta 15 Hacer
num ß Ø
Mientras num = Ø Hacer
Leer (“Introduzca un número:”, num)
Fin_Mientras
Si num MOD 2 = 0 Entonces
par ß par + 1
Sino
impar ß impar + 1
Fin_Si
Fin_Desde
porpar ßpar * 100 / 15
porimpar ßimpar * 100 / 15
Imprimir (“El porcentaje de los pares son:”, porpos)
Imprimir (“El porcentaje de los impares son:”, porneg)
FIN

45
35. Preguntar la cantidad de números a ingresar; a continuación se leen los números.
Determinar en tiempo real: la cantidad de números leídos, total de positivos y negativos,
promedio y porcentaje de pares e impares, total de múltiplos de 5, 7 y 9.
Algoritmo: Ej 35
Var Entero: num, c , cantpos, contneg, contpar, can, can5, can7, can9, prompar, promimp,
porcpar, porcimpar, sumimp, sumpar
INICIO
num, c , cantpos, contneg, contpar, can, can5, can7, can9, prompar, promimp, porcpar,
porcimpar, sumimp, sumpar ß Ø
Mientras can <= Ø Hacer
Leer (“Cuantos números desea introducir?:”, can)
Fin_Mientras
Mientras c < can Hacer
Leer (“Introduzca un número:”, num)
Si num > Ø Entonces
Cantpos ß canpos + 1
Sino
Cantneg ß canneg + 1
Si num MOD 2 = Ø y num <> Ø Entonces
cantpar ß cantpar + 1
sumpar ß sumpar + 1
prompar ß sumpar / canpar
porcpar ß cantpar * 100 / can
Sino
cantimpar ß cantimpar + 1
sumimpar ß sumimpar + 1
promimpar ß sumimpar / canimpar
porcimpar ß cantimpar * 100 / can
Fin_Si
Si num MOD 5 = Ø y num <> Ø Entonces
Can5 ß can5 + 1
Fin_Si
Si num MOD 7 = Ø y num <> Ø Entonces
Can7 ß can7 + 1
Fin_Si
Si num MOD 9 = Ø y num <> Ø Entonces
Can9 ß can9 + 1
Fin_Si
cßc+1
Imprimir (“Can N° positivos”, cantpos)
Imprimir (“Can N° negativos”, cantneg)
Imprimir (“Can N° par”, cantpar)
Imprimir (“Can N° impar”, cantimpar)
Imprimir (“promedio de pares”, prompar)
Imprimir (“promedio de impares”, promimpar)
Imprimir (“porcentaje pares”, porpar)
Imprimir (“porcentaje impares”, porimpar)
Imprimir (“Multiplo de 5”, can5)
Imprimir (“Multiplo de 7”, can7)
Imprimir (“Multiplo de 9”, can9)
Fin_Mientras
FIN

46
36. Imprimir la tabla de multiplicar del 1 al 10, mediante la estructura Mientras y Para.
Algoritmo: Ej _36
Var
Entero: mult, i, j
INICIO
Desde i ß1 Hasta 10 Hacer
Desde j ß1 Hasta 10 Hacer
mult ßi * j
Imprimir (i, “x”, j ,”=”, mult)
Fin_Desde
Fin_Desde
FIN

Algoritmo: Ej_36_para
Var
Entero: mult, i, j
INICIO
mult ß0
i, j ß 1
Mientras i <= 10 Hacer
Desde j <= 10 Hacer
mult ßi * j
Imprimir (i, “x”, j,”=”, mult)
j ßj + 1
Fin_Mientras
i ßi + 1
Fin_Desde
FIN

37. Leer dos números positivos: el primero debe ser mayor o igual que el segundo. Calcular su
cociente y su resto mediante restas sucesivas. Ejemplo:
50 |13 50 – 13 = 37 c=1
11 3 37 – 13 = 24 c=2
24 – 13 = 11 c=3
Algoritmo: Ej37
Var
Entero: n1, n2, c
INICIO
n1, n2ß Ø
Mientras n1 <= Ø Hacer
Leer (“Introduzca un número:”, n1)
Fin_Mientras
Mientras n2 <= Ø o n2 < n1 Hacer
Leer (“Introduzca un número:”, n2)
Fin_Mientras
Mientras n1 >= n2 Hacer
c ßc + 1
n1 ß n1 - n2
Fin_Mientras
Imprimir (“El cociente es:”, c, “y el resto es:”, n1)
FIN

47
38. Leer un número positivo y determinar si es o no PRIMO. Recuerda que un número es primo
cuando solamente es divisible por sí mismo y la unidad. El número 1 no es primo.
Algoritmo: Ej_38
Var
Entero: num, con, x
INICIO
num, con ß Ø
Mientras num <> 1 Hacer
Leer (“Introduzca un número:”,num)
Fin_Mientras
Desde x ß Ø Hasta num -1 Hacer
Si num MOD x = Ø Entonces
con ß con + 1
Fin_Si
Fin_Desde
Si con = Ø Entonces
Imprimir(“El número: ”, num “es primo”)
Imprimir(“El número: ”, num “no es primo”)
Fin_Si
FIN

39. Diseñar un algoritmo que permita calcular si un número es perfecto (Un número es
perfecto, cuando la suma de sus divisores, sin incluirlo al número es exactamente el mismo
número). Por ejemplo el 6 es perfecto porque sus divisores son 1, 2 y 3.
Algoritmo: Ej_39
Var
Entero: num, div , suma
INICIO
num, suma ß Ø
Mientras num <= Ø Entonces
Leer (“Ingrese números:”, num)
Fin_Mientras
Para di ß1 Hasta num -1
Si num MOD di = Ø Entonces
suma ß suma + di
Fin_Si
Fin_Para
Si num = suma entonces
Imprimir (“El número:”, num, “es perfecto”)
Sino
Imprimir (“El número:”, num, “no es perfecto”)
Fin_Si
FIN

48
40. Leer un número positivo e imprimirlo en orden inverso. Si el número leído es 125, se debe
imprimir 521.
Algoritmo: Ej_40
Var
Entero: num, residuo, invertido
INICIO
num, residuo, invertido ß Ø
Mientras num <= 0 Hacer
Leer (“Introduzca un número:”, num)
Fin_Mientras
Mientras num <> Ø Hacer
residuo ß num MOD 10
num ß num DIV 10
invertido ß(invertido * 10) + residuo
Fin_Mientras
Imprimir (“El número invertido es:”, invertido)
FIN

41. Un número se dice que es capicúa, cuando al invertir sus cifras da el mismo número. Por
ejemplo 1441 es capicúa porque al invertir sus cifras da el mismo número 1441. Escriba un
algoritmo para leer un número positivo e imprimir si es o no capicúa.
Algoritmo: e41
Var
Entero: num, numin, inv, res
INICIO
num ß Ø
numin ß Ø
inv ß 0 res ß Ø
Mientras num <= Ø Hacer
Leer (“Ingrese un numero:”, numin)
num ß numin
Fin_Mientras
Mientras num <> Ø Hacer
res ß num MOD 10
num ß num DIV 10
inv ß (inv * 10) + res
Fin_Mientras
Si inv = numin Entonces
Imprimir (“El número introducido es capicúa”, inv)
Sino
Imprimir (“No es capicúa”)
Fin_Si
FIN

49
42. En matemáticas, la sucesión de Fibonacci es la siguiente sucesión infinita de números
naturales: 0,1,1,2,3,5,8,13,21,34,55…
La sucesión de Fibonacci inicia con 0 y 1, ya a partir de cada elemento es la suma de los
anteriores. Escriba un algoritmo para leer un número positivo y lego para imprimir los números
de la serie de Fibonacci correspondiente al número leído. Por ejemplo si se lee 6, se deberá
imprimir, 0, 1, 1, 2, 3, 5, 8,13.
Algoritmo: e42
Var
Entero: ant, sig, cont, num, aux
INICIO
ant ß Ø
sig ß 1
num ß Ø
aux ß Ø
Mientras num < 1 Hacer
Leer (“Ingrese un número:”, num)
Fin_Mientras
Imprimir (ant, sig)
Desde cont ß 1 Hasta num Hacer
aux ß sig
sig ß ant + sig
ant ß aux
Imprimir (sig)
Fin_Desde
FIN

43. Leer un número positivo y calcular la suma de sus dígitos. Ejemplo: si el número leído es
123, se tiene que realizar 1+2+3 = 6.
Algoritmo: e43
Var
Entero: num, aux, total
INICIO
num, aux, total ß Ø
Mientras num <= Ø Hacer
Leer (“Ingrese un número positivo:”, num)
Fin_Mientras
aux ß num
total ß 0
Mientras num <> 0 Hacer
total ß total + num MOD 10
num ß num DIV 10
Fin_Mientras
Imprimir (“La suma de las cifras es:”, aux,”es”, total)
FIN

50
44. Imprimir números primos comprendidos desde 1 hasta 150.
Algoritmo: e44
Var
Entero: con, x, n
INICIO
Para x ß 1 Hasta 150 Hacer
con ß Ø
Para n ß 2 Hasta x Hacer
Si x MOD n = 0 Entonces
con ß con + 1
Fin_Si
Fin_Para
Si con = 1 Entonces
Imprimir(x)
Fin_Si
Fin_Para
FIN

45. Leer las notas (1-5) de 6 materias de los alumnos del 2° curso, calcular e imprimir el
promedio de notas por materia. En el curso hay 10 alumnos.
Algoritmo: e45
Var
Entero: nota, suma, alum
Real: promedio
Cadena: materia
INICIO
Desde con ß 1 Hasta 6 Hacer
Leer (“Ingrese materias:”,materia)
Desde alum ß 1 Hasta 10 Hacer
nota ß Ø
Mientras nota <= Ø o nota > 5 Hacer
Leer(“Ingrese nota:”, nota)
Fin_Mientras
suma ß suma + nota
Fin_Desde
promedio ß suma DIV 10
Imprimir (“Promedio de”, materia, ”es”, promedio)
Fin_Desde
FIN

51
46. Leer una hora inicial y final. Ambos deberán leerse en tres variables. HH, MM, SS. Calcular
la diferencia entre ambas horas en segundos.
Algoritmo: e46
Var
Entero: h1, m1, s1, h2, m2, s2, seg2, seg1
INICIO
h1, m1, s1, h2, m2, s2 ß Ø
Mientras h1 < Ø o h1 > 23 Hacer
Leer (“Ingrese hora inicial:”, h1)
Fin_Mientras
Mientras m1 < Ø o m1 > 59 Hacer
Leer (“Ingrese minuto inicial:”,m1)
Fin_Mientras
Mientras s1 < Ø o s1 > 59 Hacer
Leer (“Ingrese segundo inicial:”,s1)
Fin_Mientras
Mientras h2 < Ø o h2 > 23 Hacer
Leer (“Ingrese hora final:”,h2)
Fin_Mientras
Mientras m2 < Ø o m2 > 59 Hacer
Leer (“Ingrese minuto final:”,m2)
Fin_Mientras
Mientras s1 < Ø o s1 > 59 Hacer
Leer (“Ingrese segundo final:”,s1)
Fin_Mientras
Si h2 > h1 Entonces
h2 ß (h2 – h1) * 3600
m2 ß (m2 – m1) * 60
s2 ß s2 – s1
seg2 ß h2 – m2 – s2
Sino
Si h1 > h2 Entonces
h1 ß (h1 – h2) * 3600
m1 ß (m1 – m2) * 60
s1 ß s1 – s2
seg1 ß h1 – m1 – s1
Fin_Si
Fin_Si
dif ß seg1 – seg2
Imprimir (“La diferencia es:”, dif,”segundos”)
FIN

52
47. Escriba un algoritmo para leer la hora actual formada por: hora, minuto y segundo.
Determinada cuántas horas, minutos y segundos faltan para culminar el día. Validar las
lecturas.
Algoritmo: e47
Var
Entero: hora, min, seg
INICIO
hora, min, seg ßØ
Mientras hora < Ø y hora > 23 Hacer
Leer(“hora :”, hora)
Fin_Mientras
Mientras min < Ø y min > 59 Hacer
Leer(“minuto :”, min)
Fin_Mientras
Mientras seg < Ø y seg > 59 Hacer
Leer(“Segundo :”, seg)
Fin_Mientras
Si hora <= 23 Entonces
hora ß 23 – hora
min ß 59 – min
seg ß 59 – seg
Si hora = 1 y min >= 1 y seg >= 1 Entonces
hora ß Ø
Si min = 1 y seg >= 1 Entonces
min ß Ø
Fin_Si
Fin_Si
Fin_Si
Imprimir (“Faltan”, hora,”hora/s”, min,”minuto/s y”, seg,”segundo/s”)
FIN

53
48. Leer una fecha en formato aaaa/mm/dd. Validar las lecturas para que la fecha leída esté
comprendida entre 1 de enero del año 1 hasta 31 de diciembre del año 9999.
Algoritmo: e48
Var
Entero: a,mes,dia,can
INICIO
a,mes,dia,can ßØ
Mintras a < 1 o a > 9999 Hacer
Leer ("Introduzca un año:", a)
Fin_Mientras
Mientras mes < 1 o mes > 12 Hacer
Leer ("Ingrese un mes:", mes)
Fin_Mientras
Caso_de mes Hacer
Caso 1, 3, 5, 7, 8, 10, 12
con ß31
Caso 4, 6, 9, 11
con ß 30
Caso 2
Si a MOD 4 = Ø y a MOD 1000 <> Ø o a MOD 400 = Ø Entonces
con ß 29
Sino
con ß 28
Fin_Si
Fin_Caso
Mientras dia < 1 o dia > con Hacer
Leer ("Ingrese un dia:"dias)
Fin_Mientras
Imprimir ("La Fecha es:", año,"/", mes,"/", dia)
FIN

54
49. Leer dos fechas en formato aaaa/mm/dd. Validar las estructuras para que la fecha leída
esté comprendida entre 1 de enero del año 21 hasta 31 de diciembre del año 9999. Calcular la
diferencia entre ambas fechas en días.
Algoritmo: e49
Var
entero: a1, a2, mes1, mes2, dia1, dia2, can, candias, meses, dias
INICIO
a1, a2, mes1, mes2, dia1, dia2, can, candias, meses, dias ß Ø
Desde can ß 1 Hasta can <= 2 Hacer
a2 ß Ø
mes2 ß Ø
dia2 ß Ø
Mientras a2 < 1 o a2 > 9999 Hacer
Leer ("Introduzca un año:", año)
Fin_Mientras
Mientras mes < 1 o mes > 12 Hacer
Leer ("Ingrese un mes:", mes)
Fin_Mientras
Caso_de mes2 Hacer
Caso 1, 3, 5, 7, 8, 10, 12
con ß 31
Caso 4, 6, 9, 11
con ß 30
Caso 2
Si a2 MOD 4 = Ø y a2 MOD 1000 <> Ø o a2 MOD 400 = Ø Entonces
con ß 29
Sino
con ß 28
Fin_Si
Fin_Caso
Mientras dia2 < 1 o dia > can Hacer
Leer ("Ingrese un día:", dia)
Fin_Mientras
Si con = 1 Entonces
a1 ß a2
mes1 ß mes2
dia1 ß dia2
Fin_Si
Fin_Desde
meses ß ((a2 – a1) * 12) + ((mes2 – mes1) + 1)
Desde m ß 1 Hasta m <= meses Hacer
Caso_de mes1 Hacer
Caso 1, 3, 5, 7, 8, 10, 12
dias ß 31
Caso 4, 6, 9, 11
dias ß 30
Caso 2
Si a1 MOD 4 = Ø y a1 MOD 1000 <> Ø o a1 MOD 400 = Ø Entonces
dias ß 29
Sino
dias ß 28
Fin_Si

55
 Fin_Caso
candias ß candias – dia1 – (dias – dia2)
Imprimir (candias, “días”)
Fin_Desde
FIN

50. Leer una fecha entre tres variables, validando las lecturas, luego se debe leer la cantidad de
días a aumentarle, realizar el cálculo e imprimir la nueva fecha.
Algoritmo: e50
var
entero: dia, mes, a, candias, cant, d, flag
INICIO
dia, mes, a, candias, cant, d, flag ß Ø
Mientras a < 1 o a > 9999 Hacer
Leer (“Ingrese un año:”, a)
Fin_Mientras
Mientras mes < 1 o mes > 12 Hacer
Leer (“Ingrese un mes:”, mes)
Fin_Mientras
Caso_de mes Hacer
Caso 1, 3, 5, 7, 8, 10, 12
cant ß 31
Caso 4, 6, 9, 11
cant ß 30
Caso 2
Si a MOD 4 = Ø y a MOD 100 <> Ø o a MOD 400 = Ø Entonces
cant ß 29
Sino
cant ß 28
Fin_Si
Fin_Caso
Mientras dia < 1 o dia > cant Hacer
Leer (“Ingrese un día:”, dia)
Fin_Mientras
Mientras candias > Ø Hacer
Leer (“Ingrese la cantidad de días a aumentarle:”, candias)
Fin_Mientras
flag ß Ø
Mientras candias > Ø Hacer
flag ß flag + 1
Caso_de mes Hacer
Caso 1, 3, 5, 7, 8, 10, 12
cant ß 31
Caso 4, 6, 9, 11
cant ß 30
Caso 2
Si a MOD 4 = Ø y a MOD 100 <> Ø o a MOD 400 = Ø Entonces
cant ß 29
Sino
cant ß 28
Fin_Si
Fin_Caso

56
 Si flag = 1 Entonces
Si candias >= cant Entonces
d ß cant – dia
mes ß mes + 1
candias ß candias – d
Sino
dia ß dia + candias
Si días > cant Entonces
día ß dia – cant
mes ß mes + 1
Si mes = 13 Entonces
mes ß 1
aßa+1
Fin_Si
Fin_Si
candias ß a
Fin_Si
Si mes MOD 13 = Ø Entonces
aßa+1
mes ß 1
Fin_Si
Sino
Si candias >= cant Entonces
candias ß candias – cant
mes ß 1
Si mes MOD 13 = Ø Entonces
aßa+1
mes ß 1
Fin_Si
Sino
dia ß candias
candias ß Ø
Fin_Si
Fin_Si
Fin_Mientras
Imprimir (“La nueva fecha es: “, dia, “/”, mes, “/”, a)
FIN

57
51. Leer un año (1-9999) e imprimir el calendario de dicho año. Se sabe el 1 de enero del año 1
fue un día lunes.
Algoritmo: e51
Var
entero: a, da SunDias, numDia, numDIAS, avi, mes, dia
cadena: numero, espacios, b
INICIO
a, da SunDias, numDia, numDias ß Ø
numero, espacios, b ß “ ”
Mientras a < 1 o a > 9999 Hacer
Leer ("Introduzca un año entre 1 y 9999:", a)
Fin_Mientras
Para avi ß 1 Hasta a Hacer
Si avi MOD 4 = Ø y avi MOD 100 <> Ø o avi MOD 400 = Ø Entonces
da ß 366
Sino
da ß 365
Fin_Si
SunDias ß SunDias + da
Fin_Para
SunDias ß SunDias + 1
Caso_De SunDias MOD 7 Hacer
Caso 0
numDia ß 1
numero ß “01”
Caso 1
numDia ß 2
numero ß “bbb01”
Caso 2
numDia ß 3
numero ß “bbbbbb01”
Caso 3
numDia ß 4
numero ß “bbbbbbbbb01”
Caso 4
numDia ß 5
numero ß “bbbbbbbbbbbb01”
Caso 5
numDia ß 6
numero ß “bbbbbbbbbbbbbbb01”
Caso 6
numDia ß 7
numero ß “bbbbbbbbbbbbbbbbbb01”
Fin_Caso
Imprimir (“Calendario del año:”, a)
Para mes ß 1 Hasta 12 Hacer
Caso_De mes Hacer
Caso 1
Imprimir (“Enero”)
Caso 2
Imprimir (“Febrero”)
Caso 3

58
 Imprimir (“Marzo”)
Caso 4
Imprimir (“Abril”)
Caso 5
Imprimir (“Mayo”)
Caso 6
Imprimir (“Junio”)
Caso 7
Imprimir (“Julio”)
Caso 8
Imprimir (“Agosto”)
Caso 9
Imprimir (“Septiembre”)
Caso 10
Imprimir (“Octubre”)
Caso 11
Imprimir (“Noviembre”)
Caso 12
Imprimir (“Diciembre”)
Fin_Caso
Caso_De mes Hacer
Caso 4, 6, 9 ,11
numDIAS ß 30
Caso 1, 3, 5, 7, 8, 10, 12
numDIAS ß 31
Caso 2
Si a MOD 4 = Ø y a MOD 100 <> Ø o a MOD 400 = Ø Entonces
numDIAS ß 29
Sino
numDIAS ß 28
Fin_Si
Fin_Caso
Imprimir (“DO LU MA MI JU VI SA”)
Imprimir (“= = = = = = = = = = = = =”)
Para dia ß 2 Hasta numDIAS Hacer
numero ß numero + “b”
Si numDia MOD 7 = Ø Entonces
Imprimir (numero, “\n”)
Si dia <= 9 Entonces
numero ß “0” + dia
Sino
numero ß “ ” + dia
Fin_Si
Sino
Si dia <= 9 Entonces
numero ß + “0”
Fin_Si
numero ß numero + dia
Fin_Si
numDia ß numDia + 1
Fin_Para
Imprimir (numero, “\n”)

59
 Si longitud(numero) < 20 Entonces
Para i ß 1 Hasta longitud(numero) Hacer
espacios ß espacios + “b”
Fin_Para
Sino
espacios ß “ ”
Fin_Si
espacios ß espacios + “01”
numero ß espacios
numDia ß numDia + 1
Si mes MOD 3 = Ø Entonces
Imprimir (“Presione ENTER para visualizar los otros meses”)
Leer (b)
Fin_Si
Fin_Para
FIN

52. Un banco establece que la clave secreta para acceso a sus cajeros automáticos debe ser un
número de cuatro dígitos, tales que ninguno de ellos se repita y que la suma de los dígitos
intermedios sea par. Escribir un algoritmo que permita ingresar un valor positivo y verificar si
se trata de una clave válida, imprimir el dígito menor.
Algoritmo: e52
Var
Entero: N, Num, D1, D2, D3, D4, Suma
INICIO
N, Num, D1, D2, D3, D4, Suma Ø
Mientras Num < 1000 y Num > 9999 Hacer
Leer (“Clave Secreta:”, Num)
Fin_Mientras
D4 Num MOD 10
N Num DIV 10
D3 Num MOD 10
N Num DIV 10
D2 Num MOD 10
N Num DIV 10
D1 N DIV 1
Si D1 <> D2 Y D2 <> D3 Y D3 <> D4 Y D1 <> D3 Y D1 <> D4 Y D2 <> D4 Entonces
Suma D2 + D3
Si Suma MOD 2 = 0 Entonces
Imprimir (“Clave Válida”)
Si D1 < D2 Y D1 < D3 Y D1 < D4 Entonces
Imprimir (“Menor:”, D2)
Sino
Si D3 < D1 Y D3 < D2 Y D1 < D4 Entonces
Imprimir (“Menor:”, D3)
Sino
Si D4 < D1 Y D4 < D2 Y D4 < D3 Entonces
Imprimir (“Menor: ”, D4)
Fin_Si
Fin_Si
Fin_Si
Fin_Si

60
 Sino
Imprimir (“Clave no válida”)
Fin_Si
FIN

53. A una fiesta asistieron personas de diferentes edades y sexos. Construir un algoritmo que
calcule: *Cuántas personas asistieron a la fiesta. *Cuántos hombres y cuántas mujeres.
*Promedio de edades por sexo. *La edad de la persona más joven que asistió. No se permiten
menores de edad a la fiesta. Ingresar los datos hasta que se ingrese una edad igual a CERO.
Algoritmo: e53
Var
Entero: Ed, conper, conmas, conmuj, sumamuj, con, menor, conhom
Cadena: Sexo
INICIO
Sexo “”
conper, conmas, conmuj, sumamuj, con, menor, conhom Ø Ed 1
Mientras Ed <> Ø Hacer
Leer (“Ingrese Edad:”, Ed)
Si edad < 18 Entonces
Imprimir (“No Se Permiten Menores de Edad”)
Sino
con con + 1
Mientras Sexo <> “Hombre” o Sexo <> “Mujer” Hacer
Leer (“Introduzca Sexo: ”, Sexo)
Fin_Mientras
conper conper + 1
Si Sexo = “Hombre” Entonces
conmas conmas + 1
sumamas sumamas + Ed
Sino
conmuj conmuj + 1
sumamuj sumamuj + 1
Fin_ Si
Si con = 1 Entonces
Menor Ed
Sino
Si Ed < menor Entonces
menor Ed
Fin_Si
Fin_Si
Fin_Si
Fin_Mientras
Promas sumamas / conmas
Promuj sumamuj / conmuj
Imprimir (“Asistieron:”, conper)
Imprimir (“Mujeres:”, conmuj)
Imprimir (“Hombres:”, conhom)
Imprimir (“Promedio de Hombres:”, promas)
Imprimir (“Promedio de Mujeres:”, promuj)
Imprimir (“Edad más Joven:”, menor)
FIN

61
Algoritmo: 54
Var
Entero: cantidad, precio, Totalsin, Totaldescuento, Total
Real: Descuento
Cadena: articulo, color
INICIO
cantidad, precio, Totalsin, Totaldescuento, Total Ø
articulo, color “”
Mientras articulo <> “ ” Hacer
articulo “”
precio Ø
cantidad Ø
color “”
Leer(“Introduzca Una Cantidad:”, cantidad)
Mientras Precio <= Ø Hacer
Leer (“Introduzca un Precio:”, precio)
Fin_Mientras
Leer (“Introduzca un Color:”, color)
subtotal cantidad * precio
Si color = Rojo Entonces
Descuento * 20 subtotal DIV 100
Sino
Descuento Ø
Fin_Si
Totalsin Totalsin + subtotal
Totaldescuento Totaldescuento + descuento
Total Total (subtotal – descuento)
Leer (“Introduzca un artículo:”, articulo)
Fin_Mientras
Imprimir (“Total sin descuento:”, Totalsin)
Imprimir (“Total Descuento:”, Totaldescuento)
Imprimir (“Total:”, Total)
FIN

62
55. En una granja se requiere saber alguna información para determinar el precio de venta por
cada kilo de huevo. Es importante determinar el promedio de calidad de las n gallinas que hay
en la granja. La calidad de cada gallina se obtiene según la fórmula:
calidad = (peso de la gallina * altura de la gallina) / número de huevos que pone
Finalmente para fijar el precio del kilo de huevo, se toma como base la siguiente tabla:
CALIDAD PESO POR KILO DE HUEVO
Mayor o igual que 15 5000 * promedio de calidad
Mayor que 8 y menor que 15 4000 * promedio de calidad
Menor o igual que 8 3000 * promedio de calidad
Algoritmo: e55
Var:
Entero: G, N, Num, Hue, Suma,Calidad
Real: Peso, Alt, Cantidad, Promedio
INICIO
N, Num, Hue, Suma, Peso, Alt, Cantidad, Promedio Ø
G Ø
Mientras G <= N Hacer
Mientras Peso <= Ø Hacer
Leer (“Introduzca El Peso de la Gallina:”, Peso)
Fin_Mientras
Mientras Alt <= Ø Hacer
Leer (“Introduzca una altura:”, Alt)
Fin_Mientras
Mientras Numhue <= Ø Hacer
Leer (“Introduzca el número de huevos:”, Numhue)
Fin_Mientras
Calidad Peso * Alt / Numhue
Suma Suma + Calidad
G G+1
Fin_Mientras
Promedio Suma / G
Si Calidad >= 15 Entonces
Precio 5000 * Promedio
Sino
SI Calidad > 8 y Calidad < 15 Entonces
Precio 4000 * Promedio
Sino
Si calidad <= 8 Entonces
Precio 3000 * Promedio
Fin_Si
Fin_Si
Fin_Si
Imprimir (“El Precio de Venta por Kg de Huevos es:”, Precio)
FIN

63
56. Un teatro otorga descuentos según la edad del cliente. Determinar la cantidad de dinero
que el teatro debe percibir por cada una de las categorías. Tomar en cuenta que los niños
menores de 5 años no pueden entrar al teatro y que existe un precio único en los asientos.
Los descuentos se hacen tomando en cuenta el siguiente cuadro:
Edad Descuento
Categoría 1 5 -14 35 %
Categoría 2 15 – 19 25%
Categoría 3 20 – 45 10%
Categoría 4 46 - 65 25%
Categoría 5 66 en adelante 35%
Algoritmo: e56
Var
Entero: cont , edad, descuento, precio, c1, c2, c3, c4, c5, tc1, tc2, tc3, tc4, tc5, dc1, dc2,
dc3, dc4, dc5
Real: total
INICIO
cont, edad, descuento, precio, c1, c2, c3, c4, c5, tc1, tc2, tc3, tc4, tc5, dc1, dc2, dc3,
dc4, dc5 ßØ
Leer (“Introduzca la edad :”, edad)
Mientras edad >= Ø Hacer
Si edad < 5 Entonces
Imprimir (“No se permite el ingreso a menores de 5 años de edad”)
Sino
Si edad >= 5 y edad <= 14 Entonces
descuento ß35
dc1ß descuento * precio /100
tc1ßprecio – dc1
c1ß c1 + tc1
Sino
Si edad >= 15 y edad <= 19 Entonces
descuento ß25
dc2ß descuento * precio /100
tc2ßprecio – dc2
c2ß c2 + tc2
Sino
Si edad >= 20 y edad <= 45 Entonces
descuento ß10
dc3ß descuento * precio /100
tc3ßprecio – dc2
c3ß c3 + tc3
Sino
Si edad >= 46 y edad <= 65 Entonces
descuento ß25
dc4ß descuento * precio /100
tc4ßprecio – dc4
c4ß c4 + tc4
Sino
Si edad >= 66 Entonces
descuento ß35
dc5ßdescuento * precio / 100
tc5 ßprecio – dc5
c5 ß c5 + tc5

64
 Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
cont ß cont + 1
Si cont = 1 Entonces
Mientras precio <= Ø Hacer
Leer (“Introduzca el precio:”, precio)
Fin_Mientras
Imprimir (“Categoría 1:”, tc1)
Imprimir (“Categoría 2:”, tc2)
Imprimir (“Categoría 3:”, tc3)
Imprimir (“Categoría 4:”, tc4)
Imprimir (“Categoría 5:”, tc5)
Fin_Si
Leer (“Introduzca la edad:”, edad)
Fin_Mientras
Si cont > Ø Entonces
Imprimir (“ Total Categoria 1:”,c1)
Imprimir (“Total Categoria 2:”,c2)
Imprimir (“Total Categoria 3:”,c3)
Imprimir (“Total Categoria 4:”,c4)
Imprimir (“Total Categoria 5:”,c5)
Sino
Imprimir (“Fin de la ejecución ”)
Fin si
FIN

65
57. El Departamento de Transito desea saber, de los n autos que entran a la ciudad, cuantos
entran con calcomanía de cada color. Conociendo el último dígito de la placa de cada automóvil
se puede determinar el color de la calcomanía utilizando la sig. Relación:
DÍGITO COLOR
1o2 amarilla
3o4 rosa
5o6 roja
7o8 verde
9o0 azul
Algoritmo: e57
Var
Entero: cont, dig, ama, rosa, verde, azul
INICIO
cont, dig, ama, rosa, verde, azul ß Ø
Mientras cont <= Ø Hacer
Leer (“Ingrese la cantidad de autos:”, cont)
Fin_Mientras
Desde n ß Hasta cont Hacer
Leer (“Ingrese el ultimo digito de la placa:” dig)
Mientras dig > 9 o dig < Ø Hacer
Leer (“Ingrese el ultimo digito de la placa:” dig)
Fin_Mientras
Si dig = 1 o dig = 2 Entonces
ama ß ama +1
Sino
Si dig = 3 o dig = 4 Entonces
rosa ß rosa +1
Sino
Si dig = 5 o dig = 6 Entonces
roja ß roja +1
Sino
Si dig = 7 o dig = 8 Entonces
verde ß verde +1
Sino
Si dig = 9 o dig = 8 Entonces
azul ß azul +1
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_ Desde
Imprimir (“Cantidad de autos ingresados:”, cont)
Imprimir (“Cantidad de calcomanías amarillas:”, ama)
Imprimir (“Cantidad de calcomanías rosas:”, rosa)
Imprimir (“Cantidad de calcomanías rojas:”, roja)
Imprimir (“Cantidad de calcomanías verdes:”, verde)
Imprimir (“Cantidad de calcomanías azules:”, azul)
FIN

66
58. Una tienda se dedica a la venta de computadoras, cuenta con 10 vendedores. Cada uno de
ellos tiene un sueldo mensual pero además de su sueldo ganan una comisión por venta.
 Si el monto de venta es mayor de Gs. 10.000.000 la comisión será del 15%.
 Si el monto de venta es mayor o igual a Gs. 5.000.000 y menor o igual de 10.000.000 la
comisión es del 5%.
 Si el monto de venta es menor que Gs. 5.000.000 no tiene comisión.
Calcular el sueldo neto que debe percibir cada vendedor.
Algoritmo: e58
Var
Entero: comision,venta,sueldo,neto,con
INICIO
comision,venta,sueldo,neto,con ßØ
Desde con ß1 Hasta 10 Hacer
Sueldo, venta, neto, comision ßØ
Mientras sueldo <= Ø Hacer
Leer(“Ingrese su sueldo:”, sueldo)
Fin_Mientras
Mientras venta <= Ø Hacer
Leer (“Ingrese el monto de la venta:”, venta)
Fin_Mientras
Si venta > 10000000 Entonces
comision ß 15
Sino
Si venta > 5000000 y venta < 10000000 Entonces
comision ß 5
Sino
Si venta > 5000000 Entonces
comision ß 0
Fin_Si
Fin_Si
Fin_Si
comisión ß (comisión *venta) DIV 100
neto ß sueldo + comisión
Imprimir (“ Su sueldo mensual es :”, sueldo)
Imprimir(“venta:”,venta)
Imprimir(“Su comisión es :”,comisión)
Imprimir(“Su sueldo neto es:”neto)
Fin_Desde
FIN

67
59. Se desea realizar un muestreo con 20 personas para determinar el promedio de peso de los
niños, jóvenes, adultos y viejos que existen en una zona habitacional. Se determinan las
categorías con base en la siguiente tabla:
CATEGORÍA EDAD
Niños 0 – 12
Jóvenes 13 – 29
Adultos 30 – 59
Viejos 60 en adelante
Algoritmo: e59
Var
Entero: peso, suman, sumaj, sumaa, sumav, pron, proj, proa, prov ,con, conj, cona,
conv
INICIO
peso, suman, sumaj, sumaa, sumav, pron, proj, proa, prov, con, conj, cona, conv ß Ø
Desde con ß 1 Hasta 20 Hacer
PesoßØ
EdadßØ
Mientras peso <= Ø Hacer
Leer (“Introduzca peso:”, peso)
Fin_Mientras
Mientras edad <= Ø Hacer
Leer (“Introduzca la edad:”, edad)
Fin_Mientras
Si edad >= Ø y edad <= 12 Entonces
suman ß suman + peso
conßconn+1
Sino
Si edad >= 13 y edad <= 29 Entonces
sumaj ß sumaj + peso
conj ß conj + 1
Sino
Si edad >= 30 y edad <= 59 Entonces
sumaa ß sumaa + peso
cona ß cona + 1
Sino
sumav ß sumav + peso
conv ß conv + 1
Fin_Si
Fin_Si
Fin_Si
Fin_Desde
pron ß suman DIV conn
proj ß sumaj DIV conj
proa ß sumaa DIV cona
prov ß sumav DIV conv
Imprimir (“Promedio de peso de niños:”, pron)
Imprimir (“Promedio de peso de jóvenes:”, proj)
Imprimir (“Promedio de peso de adultos:”, proa)
Imprimir (“Promedio de peso de viejos:”, prov)
FIN

68
60. Un zoólogo pretende determinar el porcentaje de animales que hay en las siguientes tres
categorías de edades: de 0 a 1 año, de más de 1 año y menos de 2, y de 3 o más años. El
zoólogo todavía no está seguro del animal que va a estudiar. Si se decide por elefantes solo
tomara una muestra de 10 de ellos; si se decide por las jirafas, tomara 15 muestras, y si son
chimpancés tomara 12.
Algoritmo: e60
var entero: edad, muestra, c1, c2, c3, porc1, porc2, porc3
cadena: animal
INICIO edad, muestra, c1, c2, c3, porc1, porc2, porc3 ß Ø animal ß “ ”
Mientras animal = “ ” Hacer
Leer (“Introduzca el tipo de animal:”, animal)
Si animal = “Elefantes” Entonces
muestra ß 10
Sino
Si animal = “Jirafas” Entonces
muestra ß 15
Sino
Si animal = “Chimpancés” Entonces
muestra ß 12
Sino
animal ß “ ”
Fin_Si
Fin_Si
Fin_Si
Fin_Mientras
Desde con <- 1 Hasta muestra Hacer
edad ß Ø
Leer (“Introduzca la edad:”, edad)
Si edad < Ø Entonces
con ß con – 1
Sino
Si edad >= Ø y edad <= 1 Entonces
c1 ß c1 + 1
Sino
Si edad > 1 y edad < 3 Entonces
c2 ß c2 + 1
Sino
Si edad >= 3 Entonces
c3 ß c3 + 1
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Desde
porc1 ß (c1 * 100) DIV muestra
porc2 ß (c2 * 100) DIV muestra
porc3 ß (c3 * 100) DIV muestra
Imprimir (“De”, muestra, “animales de”, animal, “el porcentaje de categorías”)
Imprimir (“Categoría 1:”, porc1)
Imprimir (“Categoría 2:”, porc2)
Imprimir (“Categoría 3:”, porc3)
FIN

69
 VECTORES EJERCICIOS

01. Leer números en un vector de 10 elementos, al final imprimir la suma y el promedio de los
números.
Algoritmo: e01
Tipo
Vector: numeros (10) de entero
Var
Entero: suma, P
Real: prom
INICIO
suma ß Ø
prom ß Ø
Desde P ß 1 Hasta 10 Hacer
Leer (“Ingrese un número:”, numeros(P))
suma ß suma * numeros(P)
Fin_Desde
prom ß suma DIV 10
Imprimir (“Suma:”, suma)
Imprimir (“Promedio:”, prom)
FIN

02. Leer 5 números en dos vectores, sumarlos en un tercer vector, visualizar los números de los
dos vectores y también el de la suma.
Algoritmo: e02
Tipo
Vector: num1 (5) de entero, num2 (5) de entero, sum (5) de entero
Var
Entero: P
INICIO
Desde P ß 1 Hasta 5 Hacer
Leer (“Ingrese un número:”, num1(P))
Leer (“Ingrese otro número:”, num2(P))
sum(P) ß num1(P) + num2(P)
Fin_Desde
Desde P ß 1 Hasta 5 Hacer
Imprimir (num1(P))
Imprimir (num(P))
Imprimir (sum(P))
Fin_Desde
FIN

70
03. Leer 15 números en un vector, calcular e imprimir el promedio de los pares e impares.
Algoritmo: e03
Tipo
Vector: num (15) de entero
Var
Entero: par, impar, P, conp, coni
Real: propar, proimpar
INICIO
par, impar, conp, coni ß Ø
propar, proimpar ß Ø, Ø
Desde P ß 1 Hasta 15 Hacer
Leer (“Introduzca un número:”, num(P))
Si num(P) MOD 2 = Ø Entonces
par ß par + num(P)
conp ß conp + 1
Sino
Si num(P) MOD 2 <> Ø Entonces
impar ß impar + num(P)
coni ß coni + 1
Fin_Si
Fin_Si
Fin_Desde
propar ß par / conp
proimpar ß impar / coni
Imprimir (“Promedio par:”, propar)
Imprimir (“Promedio impar:”, proimpar)
FIN

04. Leer una secuencia de 20 números almacenarlos en un vector y mostrar la posición de

donde se encuentra el mayor valor leído.
Algoritmo: e04
Tipo
Vector: num (20) de entero
Var
Entero: may, pos, P
INICIO
may, pos ß Ø
Desde P ß 1 Hasta 20 Hacer
Leer (“Introduzca un número:”, num(P))
Si P = 1 Entonces
may ß num(P)
pos ß P
Sino
Si num(P) > may Entonces
may ß num(P)
pos ß P
Fin_Si
Fin_Si
Fin_Desde
Imprimir (“La posición del mayor es:”, pos)
FIN

71
05. En un vector se tiene almacenado los nombres de 5 personas, en otro vector sus apellidos,
en otro sus direcciones y en otro sus números de celulares. Leer el número de celular, buscar y
si existe mostrar los datos completos de la persona, y i el número de celular no existe se debe
mostrar un mensaje indicando la inexistencia del número.
Algoritmo: e05
Tipo
Vector: nombre(5) de cadena, apellido(5) de cadena, direccion(5) de cadena,
numero(5) de entero.
Var
Entero: celu, P, con
INICIO
celu, con ß Ø
nombre(1) ß Sofía
nombre(2) ß Eloísa
nombre(3) ß Agustina
nombre(4) ß Sandra
nombre(5) ß Richard
apellido(1) ß Benítez
apellido(2) ß Velázquez
apellido(3) ß Alfonso
apellido(4) ß González
apellido(5) ß Giménez
direccion(1) ß Inmaculada
direccion(2) ß Antonio
direccion(3) ß San Luis
direccion(4) ß Santo Luis
direccion(5) ß Itacurubi
numero(1)ß0971111111
numero(2)ß0972222222
numero(3)ß0981555555
numero(4)ß0984444444
numero(3)ß0985555555
Mientras celu <= Ø Hacer
Leer (“Introduzca un número:”, celu)
Fin_Mientras
Desde P ß 1 Hasta 5 Hacer
Si celu = numero(P) Entonces
Imprimir (“Su nombre:”, nombre(P))
Imprimir (“Su apellido:”, apellido(P))
Imprimir (“Su dirección:”, direccion(P))
Imprimir (“Su número:”, numero(P))
Sino
con ß con + 1
Fin_Si
Fin_Desde
Si con = 5 Entonces
Imprimir (“No existe el número”)
Sino
Imprimir (“Fin de la ejecución”)
Fin_Si
FIN

72
06. Preguntar el número de elementos para un vector (6-15). A continuación leer números en
el vector y determinar el mayor y el menor de los números y la posición que ocupa cada uno de
ellos en el vector.
Algoritmo: Vector_06
Tipo
vector: num (n) de entero
var
entero: may, men, pmay, pmen
INICIO
entero: may, men, pmay, pmen Ø
Mientras n < 6 o n <15 hacer
Leer (“Cuantos números desea ingresar”, n)
Fin_Mientras
Desde P 1 Hasta n Hacer
Leer (“ingrese un número “, num (p))
Si P = 1 entonces
may num(p)
men num(p)
pmay P
pmen P
Fin_Si
Si num(p) > may Entonces
may num(p)
pmay P
Sino
Si num(p) < men Entonces
men num(p)
pmen P
Fin_Si
Fin_Si
Fin_Desde
Imprimir (“El mayor es:”, may)
Imprimir (“El menor es:”, men)
Imprimir (“La posición del mayor es:”, pmay)
Imprimir (“La posición del menor es:”, pmen)
FIN

73
07. Leer 5 números en un vector, ordenarlos en forma ascendente. Imprimir el vector
resultante.
Algoritmo: Vector_07
Tipo
vector: num (5) de entero
var
entero: aux, i, a, b, x
INICIO
aux Ø
Para i 1 Hasta 5 Hacer
Leer (“Ingrese um número”, num(i))
Fin_Para
Para a 1 Hasta 5 Hacer
Para b 1 Hasta 4 Hacer
Si num(b) > num(b+1) Entonces
aux num(b)
num(b) num(b+1)
num(b+1) aux
Fin_Si
Fin_Para
Fin_Para
Para x 1 Hasta 5 Hacer
Imprimir (“Orden ascendente:”, aux)
Fin_Para
FIN

74
08. Realice un algoritmo para leer número en un vector de 10 elementos y determine la suma y
el producto de todos del vector. Además, calcule el promedio de los elementos del vector y
determine cuantos de los elementos del vector están debajo y por encima del promedio.
Imprima la suma, el producto el promedio y la cantidad de elementos que están por debajo y
por encima del promedio.
Algoritmo: Vector 8
Tipo
Vector: num (10) de entero
Var
Entero: suma, producto, debajo, encima, P
Real: promedio
INICIO
Desde P ß 1 Hasta 10 Hacer
Leer (“Ingrese un numero:”, num(P)
suma ß suma + num(P)
producto ß producto * num(P)
Fin_Desde
promedio ß suma / 10
Desde P ß 1 Hasta 10 Hacer
Si num (P) < promedio Entonces
debajo ß debajo + 1
Sino
Si num (P) > promedio Entonces
encima ß encima + 1
Fin_Si
Fin_Si
Fin_Desde
Imprimir (“Suma de números:”, suma)
Imprimir (“Producto de números:”, producto)
Imprimir (“El promedio es:”, promedio)
Imprimir (“Debajo del promedio:”, debajo)
Imprimir (“Encima del promedio:”, debajo)
FIN

75
09. Cargue números un vector de 100 elementos. Determine cuál es el valor más pequeño del
vector. Además, determine si existe algún elemento repetido en el vector, de ser cierto, indique
veces se repite. Imprima el elemento más pequeño del vector, el elemento que se repite y la
cantidad de veces que se repite.
Algoritmo: Vector 9
Tipo
Vector: num (100) de entero, rep(100) de entero, can(100) de entero
Var
Entero: peq, cant, P, n, pos, I, A, N
INICIO
Desde P ß 1 hasta 100 Hacer
Leer (“Ingrese un número:”, num(P))
Si P =1 Entonces
peq ß num(P)
Sino
Si num(P) < peq Entonces
peq ß num(P)
Fin_Si
Fin_Si
Fin_Desde
Desde N ß 1 Hasta 100 Hacer
n ß num(N)
existe ß F
Desde B ß 1 Hasta 100 Hacer
Si n = rep(B) Entonces
existe ß V
Salir_Bucle
Fin_Si
Fin_Desde
Si existe = F Entonces
Desde I ß 1 Hasta 100 Hacer
Si n = num(I) Entonces
cant ß cant + 1
Fin_Si
Fin_Desde
Si cant > 1 Entonces
rep(pos)
can(pos)
pos ß pos + 1
Fin_Si
Fin_Si
Fin_Desde
Desde A ß 1 Hasta 100 Hacer
Si can(n) <> Ø Entonces
Imprimir (“Repetidos:”, rep(A))
Imprimir (“Cantidad:”, can(A))
Si A = Ø Entones
Imprimir (“El elemento más pequeño del vector es:”, peq)
Fin_Si
Sino
Si A = Ø Entonces
Imprimir (“No existen”)

76
 Imprimir (“El elemento más pequeño del vector es:”, peq)
Fin_Si
Fin_Si
Fin_Desde
FIN

10. Generar e imprimir 20 números aleatorios comprendidos entre 1 y 100 en un vector.

Algoritmo: 10
tipo
vector: num(20) de entero
var
entero: P
INICIO
Desde P ß 1 Hasta 20 Hacer
numero(P) ß ENTERO(ALEATORIO() * 100) + 1
Imprimir (num(P))
Fin_Desde
FIN

11. Leer la cantidad de números aleatorios a generar (10-50). Generar números pares
comprendidos entre 300 y 500 y almacenarlos en forma ascendente.
Algoritmo: Vector 11
Tipo
Vector: numeros(n) de entero
Var
Entero: n, num, P
INICIO
n, num Ø
Mientras n < 10 o n > 50 Hacer
Leer (“Introduzca la cantidad de números a generar(10-50):”, n)
Fin_Mientras
Desde P 1 Hasta n Hacer
num 1
Mientras num MOD 2 <> Ø Hacer
numeros (P) ENTERO(ALEATORIO() * 201) + 300
Imprimir (numeros(P))
Fin_Mientras
Fin_Desde
FIN

77
12. Leer la cantidad de números aleatorios a generar (15-60). Generar números impares
comprendidos entre 101 y 999 evitando la repitencia, almacenarlos en un vector.
Algoritmo: Vector12
Tipo
Vector: num(n) de entero
Var
Entero: numi, P, cant, I
Lógico: existe
INICIO
cant ß Ø
Mientras n < 15 o n > 60 Hacer
Leer (“Ingrese la cantidad de números a generar(15-60):”, cant)
Fin_Mientras
Desde P ß 1Hasta cant Hacer
numi ß Ø
Mientras numi MOD 2 = 0 Hacer
numi ß ENTERO(ALEATORIO() * 899) + 101
Fin_Mientras
existe ß F
Desde I ß 1 Hasta P – 1 Hacer
Si numi = num(I) Entonces
existe ß V
P ß P -1
Salir_Bucle
Fin_Si
Fin_Desde
Si existe = F Entonces
num(P) ß numi
Imprimir (num(P))
Fin_Si
Fin_Desde
FIN

13. Generar e imprimir 30 números aleatorios pares comprendidos entre 1000 y 2000 evitando
la repitencia almacenarlos en un vector y ordenarlos en forma descendente.
Algoritmo: Vector13
Tipo
Vector: numi(30) de entero
Var
Entero: numi, P, aux, I, O, M, N
Lógico: existe
INICIO
Aux, numiß Ø
Desde P ß 1 Hasta 30 Hacer
numiß1
Mientras numi MOD 2 <> Ø Hacer
numi ß ENTERO(ALEATORIO() * 1001)+100
Fin_Mientras
existe ß F
Desde I ß 1 hasta P-1 hacer
Si numi = num(I) Entonces
existeß V

78
 P ß P-1
Salir_Bucle
Fin_Si
Si existe = F Entonces
num(P) ß numi
Fin_Si
Fin_Desde
Desde M ß 1 Hasta 30 Hacer
Desde N ß 1 Hasta 29 Hacer
Si num (N) > num (N+1) Entonces
aux ß num(N+1)
num(N) ß num (N +1)
num(N+1) ß aux
Fin_Si
Fin_Desde
Fin_Desde
Desde O ß 1 hasta 30 hacer
Imprimir (num(O))
Fin_Desde
FIN

14. Leer la cantidad de números aleatorios a generar (10-70). Generar números impares
comprendidos entre 101 y 999 evitando la repitencia, almacenarlos en un vector y ordenarlos
en forma ascendente.
Algoritmo: Vector14
Tipo
Vector: num(n) de entero
Var
Entero: n, P, imp, a, x, aux, b, un, i
Lógico: existe
INICIO
n Ø
Mientras n < 10 o n > 70 Hacer
Leer (“¿Cuántos números desea ingresar?:”, n)
Fin_Mientras
Desde P 1 Hasta n Hacer
num Ø
Mientras un MOD 2 = 0 Hacer
n ENTERO(ALEATORIO() * 8999) + 1001
Fin_Mientras
existe F
Desde i 1 Hasta P - 1 Hacer
Si n = num(i) Entonces
existe V
P P-1
Salir_Bucle
Fin_Si
Fin_Desde
Si existe = F Entonces
num(P) n
Fin_Si
Fin_Desde

79
 Desde a 1 Hasta n Hacer
Desde b 1 Hasta n - 1 Hacer
Si num(b) > num(b+1) entonces
aux num(b)
num(b) num(b + 1)
num(b + 1) aux
Fin_Si
Fin_Desde
Fin_Desde
Desde x Hasta n Hacer
Imprimir (num(x))
Fin_Desde
FIN

15. En un vector de 25 elementos se deben generar números aleatorios en el siguiente orden:

a) 5 números entre 1 y 15 b) 5 números entre 16 y 30 c) 5 números entre 31 y 45 d) 5 números
entre 46 y 60 e) 5 números entre 61 y 75. Ningún número puede aparecer repetido. Se deben
imprimir en 5 columnas ordenados de menor a mayor, como en un cartón de bingo.
Algoritmo: Vector15
Tipo
Vector: num (25) de entero
Var
Entero: p, Generar, i, a, b, x, aux
Lógico: Existe
INICIO
Desde p ß 1 Hasta 25 Hacer
Si p >= 1 y p <= 5 Entonces
Generar ß ENTERO(ALEATORIO() * 5) + 1
Sino
Si p >= 6 y p <= 10 Entonces
Generar ß ENTERO(ALEATORIO() * 5) + 6
Sino
Si p >= 11 y p <= 15 Entonces
Generar ß ENTERO(ALEATORIO() * 5) + 11
Sino
Si p >= 16 y p <= 20 Entonces
Generar ß ENTERO(ALEATORIO() * 5) + 16
Sino
Si p >= 21 y p <= 25 Entonces
Generar ßENTERO(ALEATORIO()*5)+21
Fin_Si
Fin_Si
Fin_Si
Fin_Si
Fin_Si
existe ß F
Desde i ß 1 Hasta p – 1 Hacer
Si Generar = num (i) Entonces
Existe ß V
pßp–1
Salir_Bucle
Fin_Si

80
 Fin_Desde
Si Existe = F Entonces
num(p) ß Generar
Fin_si
Fin_Desde
Desde a ß 1 Hasta 25 Hacer
Desde b ß 1 Hasta 24 Hacer
Si num (b) > num (b + 1) Entonces
aux ß num (b)
num (b) ß num (b + 1)
num (b + 1) ß aux
Fin_si
Fin_Desde
Fin_Desde
Desde x ß 1 Hasta 25 Hacer
Imprimir (num(p))
Fin_Desde
FIN

81