Este documento contiene 20 ejercicios de pseudocódigo con sus respectivas soluciones. Los ejercicios abordan temas como leer y procesar secuencias de números y letras, usar vectores y matrices, y realizar operaciones como suma, producto, ordenamiento y búsqueda. Cada ejercicio viene acompañado de un algoritmo en pseudocódigo que describe los pasos para resolverlo.

1. RUBEN
NAVARRO
CASERO
&
RAUL
MORALES
GARCIA
© 2004
1

2. Ejercicios de Pseudocódigo Parte 2
1. Leer una secuencia de números y mostrar la suma de los pares y el producto de
los que son múltiplo de 5.
2. Leer una secuencia de números y determinar el mayor de los pares leídos.
3. Leer una secuencia de números y mostrar el mayor de los múltiplos de 5 leídos y
el menor de los múltiplos de 3 leídos.
4. Leer una secuencia de letras y mostrar la suma de sus códigos ASCII.
Suponemos que tenemos la función Conv_a_Codigo (char)=int.
5. Dado un vector de 5 enteros actualizar cada posición de dicho vector con un
número leído.
6. Leer una secuencia de 20 números almacenarlos en un vector y mostrar la
posición donde se encuentra el mayor valor leído.
7. Dado dos vectores A y B de 15 elementos cada uno, obtener un vector C donde
la posición i se almacene la suma de A[i]+B[i].
8. Dado dos vectores A y B de 15 elementos cada uno, obtener un vector C donde
la posición i se almacene la suma de A[i]+B[i] y mostrar el mayor de los C[i].
9. Dado una secuencia de número leídos y almacenados en un vector A mostrar
dichos números en orden.
10. Dado una secuencia de número leídos y almacenados en un vector A y un
número leído determinar si dicho número se encuentra o no en el vector.
11. Leer una secuencia de 20 números y almacenar en un vector sus factoriales.
12. Leer 20 números y almacenarlos de manera ordenada en un vector.
13. Dado dos matrices A y B obtener la suma.
14. Dado una matriz determinar la posición (i,j) del mayor.
15. Dado una matriz determinar la posición (i,j) del mayor y menor.
16. Leer un número y una letra si la letra es B mostrar el valor en binario, si es O en
octal y si es H en hexadecimal.
17. Leer una secuencia de 20 números almacenarlos en un vector A[1..20] y mostrar
la suma de los elementos que ocupan posiciones pares y el mayor de los que
ocupan posiciones impares.
18. Dada una matriz A[1..4][1..5] realiza la ordenación de la misma.
19. Dada una matriz A[1..4][1..5] realiza el proceso de ordenar solo por filas.
20. Dado un vector de números determina aquellos que sea primos.
2

3. ALGORITMO ejercicio 5
VARIABLE
ENTERO n[1..5];
ENTERO indice;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 5 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (indice);
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
----------------------------------------------------------------------------------------------------------
ALGORITMO ejercicio 6
VARIABLE
ENTERO n[1..20];
ENTERO mayor_indice;
ENTERO indice;
ENTERO mayor;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 20 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (indice);
FIN_PARA
Mayor = n[1]
PARA indice = 1 HASTA 20 INCREMENTO 1
SI (n[indice] > mayor) ENTONCES
Mayor_indice = indice;
FIN_SI
FIN_PARA
ESCRIBIR (mayor_indice);
FIN_INICIO
FIN_ALGORITMO
3

4. ALGORITMO ejercicio 7
VARIABLE
ENTERO A[1..15];
ENTERO B[1..15];
ENTERO indice;
ENTERO suma;
ENTERO C[1..15];
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 15 INCEMENTO 1
ESCRIBIR (“Introduce un numero para el vector A”);
LEER (A[indice]);
ESCRIBIR (“Introduce un numero para el vector B”);
LEER (B[indice]);
FIN_PARA
PARA indice = 1 HASTA 15 INCREMENTO 1
Suma = A[indice] + B[indice];
C[indice] = suma;
FIN_PARA
PARA indice = 1 HASTA 15 INCREMENTO 1
ESCRIBIR (C[indice]);
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
4

5. ALGORITMO ejercicio 8
VARIABLE
ENTERO A[1..15];
ENTERO B[1..15];
ENTERO C[1..15];
ENTERO indice;
ENTERO suma;
ENTERO mayor;
ENTERO mayor_indice;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 15 INCRMENTO 1
ESCRIBIR (“Introduce un numero para el vector A”);
LEER (A[indice]);
FIN_PARA
PARA indice = 1 HASTA 15 INCRMENTO 1
ESCRIBIR (“Introduce un numero para el vector B”);
LEER (B[indice]);
FIN_PARA
PARA indice = 1 HASTA 15 INCRMENTO 1
Suma = A[indice] + B[indice];
C[indice] = suma;
FIN_PARA
Mayor = C[1];
Mayor_indice = 1;
PARA indice = 1 HASTA 15 INCREMENTO 1
SI (C[indice] > mayor) ENTONCES
Mayor_indice = indice;
Mayor = C[indice];
FIN_SI
FIN_PARA
ESCRIBIR (mayor);
ESCRIBIR (mayor_indice);
FIN_INICIO
FIN_ALGORITMO
5

6. ALGORITMO ejercicio 9
VARIABLE
ENTERO intercambio;
ENTERO n[1..15];
ENTERO intermedio;
ENTRO indice;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 15 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (n[indice]);
FIN_PARA
REPETIR
Intercambio = 0;
PARA indice = 1 HASTA 15 INCREMENTO 1
SI (n[indice] > n[indice + 1]) ENTONCES
Intermedio = n[indice];
N[indice] = n[indice + 1];
N[indice + 1] = Intermedio;
Intercambio = 1;
FIN_SI
FIN_PARA
HASTA (intercambio = 0)
FIN_INICIO
FIN_ALGORITMO
6

7. ALGORITMO ejercicio 10
VARIABLE
ENTERO A[1..10];
ENTERO numero;
ENTERO indice;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 10 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[indice]);
FIN_PARA
Indice = 1;
MIENTRAS (indice < 11) AND (numero <> A[indice]) HACER
Indice = indice + 1;
FIN_MIENTRAS
SI ( indice = 11) ENTONCES
ESCRIBIR (“No esta”);
SINO
ESCRIBIR (“Existe”);
FIN_SI
FIN_INICIO
FIN_ALGORITMO
7

8. ALGORITMO ejercicio 11
VARIABLE
ENTERO n[1..20];
ENTERO indice;
ENTERO factorial;
ENTERO indice1;
ENTERO N[1..20];
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 20 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (n[indice]);
FIN_PARA
PARA indice = 1 HASTA 20 INCREMENTO 1
Factorial = 1;
PARA indice1 = 2 HASTA n[indice] INCREMENTO 1
Factorial = factorial * indice1;
FIN_PARA
N[indice] = factorial;
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
8

9. ALGORITMO ejercicio 13
VARIABLE
ENTERO A[1..5][1..10];
ENTERO B[1..5][1..10];
ENTERO suma[fila][columna];
ENTERO fila;
ENTERO columna;
FIN_VARIABLE
INICIO
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 10 INCREMENTO 1
LEER (A[fila][columna]);
FIN_PARA
FIN_PARA
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 10 INCREMENTO 1
LEER (B[fila][columna]);
FIN_PARA
FIN_PARA
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 10 INCREMENTO 1
Suma[fila][columna] = A[fila][columna] + B[fila][columna];
FIN_PARA
FIN_PARA
ESCRIBIR (suma[fila][columna]);
FIN_INICIO
FIN_ALGORITMO
9

10. ALGORITMO ejercicio 14
VARIABLE
ENTERO A[1..5][1..4];
ENTERO fila;
ENTERO columna;
ENTERO mayor;
ENTERO posicion_fila;
ENTERO posición_columna;
FIN_VARIABLE
INICIO
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 4 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[fila][columna]);
FIN_PARA
FIN_PARA
Mayor = A[1][1];
Posición_fila = 1;
Posición_columna = 1;
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 4 INCREMENTO 1
SI (A[fila][columna] > mayor) ENTONCES
Mayor = A[fila][columna];
Posición_fila = [fila];
Posición_columna = [columna];
FIN_SI
FIN_PARA
ESCRIBIR (“El mayor es:mayor”);
ESCRIBIR (“La posición es:posición_fila, Posición_columna”);
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
10

11. ALGORITMO ejercicio 15
VARIABLE
ENTERO A[1..5][1..4];
ENTERO fila;
ENTERO columna;
ENTERO mayor;
ENTERO posicion_fila;
ENTERO posición_columna;
ENTERO menor
ENTERO posición_fila1;
ENTERO posición_columna1;
FIN_VARIABLE
INICIO
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 4 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[fila][columna]);
FIN_PARA
FIN_PARA
Mayor = A[1][1];
Posición_fila = 1;
Posición_columna = 1;
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 4 INCREMENTO 1
SI (A[fila][columna] > mayor) ENTONCES
Mayor = A[fila][columna];
Posición_fila = [fila];
Posición_columna = [columna];
FIN_SI
FIN_PARA
ESCRIBIR (“El mayor es:mayor”);
ESCRIBIR (“La posición es:posición_fila, Posición_columna”);
FIN_PARA
Menor = 1;
Posición_fila1 = 1;
Posición_columna1 = 1;
PARA fila = 1 HASTA 5 INCREMENTO 1
PARA columna = 1 HASTA 4 INCREMENTO 1
SI (A[fila][columna] < menor) ENTONCES
Menor = A[fila][columna];
Posición_fila1 = [fila];
Posición_columna1 = [columna];
FIN_SI
FIN_PARA
ESCRIBIR (“El mayor es:menor”);
ESCRIBIR (“La posición es:posición_fila1, Posición_columna1”);
FIN_INICIO
FIN_ALGORITMO
11

12. ALGORITMO ejercicio 16
VARIABLE
ENTERO indice;
ENTERO pul;
ENTERO tipo;
ENTERO numero;
ENTERO cociente;
ENTERO divisor;
ENTERO resto;
CARÁCTER resultado[1..20];
FIN_VARIABLE
INICIO
LEER (numero);
LEER (tipo); // O,H,B
Cociente = numero;
SELECTOR tipo
Caso “B”: divisor = 2;
Caso “O”: divisor = 8;
Caso “H”: divisor = 16;
FIN_SELECTOR
Pul = 0;
REPETIR
Pul = pul + 1;
Resto = cociente mod divisor;
SELECTOR resto
Caso 10: resultado[pul] = “A”;
…
…
Caso 15: resultado[pul] = “F”;
Defecto: resultado[pul] = resto;
FIN_SELECTOR
Cociente = cocientedivisor;
HASTA (cociente = 0)
PARA indice = pul HASTA 1 INCREMENTO -1
ESCRIBIR (resultado[pul]);
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
12

13. ALGORITMO ejercicio 17
VARIABLE
ENTERO A[1..20];
ENTERO indice;
ENTERO suma;
ENTERO mayor;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 20 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[indice]);
FIN_PARA
Suma = 0;
PARA indice = 2 HASTA 20 INCREMENTO 2
Suma = suma + A[indice];
FIN_PARA
Mayor = A[1];
PARA indice = 1 HASTA 20 INCREMENTO 2
SI (A[indice] > mayor) ENTONCES
Mayor = A[indice];
FIN_SI
FIN_PARA
ESCRBRIR (“LA suma es:+suma”);
ESCRIBIR (“El mayor es:+mayor”);
FIN_INICIO
FIN_ALGORITMO
13

14. ALGORITMO ejercicio 18
VARIABLE
ENTERO A[1..4][1..5];
ENTERO fila;
ENTERO columna;
ENTERO v[1..20];
ENTERO indice;
ENTERO intercambio;
ENTERO intermedio;
FIN_VARIABLE
INICIO
PARA fila = 1 HASTA 4 INCREMENTO 1
PARA columna = 1 HASTA 5 INCREMENTO 1
ESCRIBIR(“Introduce un numero”);
LEER (A[fila][columna]);
FIN_PARA
FIN_PARA
PARA fila = 1 HASTA 4 INCREMENTO 1
PARA columna = 1 HASTA 5 INCREMENTO 1
V[((fila – 1) + 5) + columna] = A[fila][columna];
FIN_PARA
FIN_PARA
REPETIR
Intercambio = 0;
PARA (indice = 1) HASTA 19 INCREMENTO 1
SI (V[indice] > V[indice + 1]) ENTONCES
Intermedio = V[indice];
V[indice] = V[indice +1];
V[indice +1] = intermedio;
Intercambio = 1;
FIN_SI
FIN_PARA
HASTA (intercambio = 0)
PARA fila = 1 HASTA 4 INCREMENTO 1
PARA columna = 1 HASTA 3 INCREMENTO 1
A[fila][columna] = V[((fila – 1) * 5) + columna];
FIN_PARA
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
14

15. ALGORITMO ejercicio 19
VARIABLE
ENTERO A[1..4][1..5];
ENTERO intermedio;
ENTERO fila;
ENTERO columna;
FIN_VARIABLE
INICIO
PARA fila = 1 HASTA 4 INCREMENTO 1
PARA columna = 1 HASTA 5 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[fila][columna]);
FIN_PARA
FIN_PARA
REPETIR
Intercambio = 0;
PARA fila = 1 HASTA 4 INCREMENTO 1
PARA columna = 1 HASTA 3 INCREMENTO 1
SI (A[fila][columna] > A[fila][columna + 1] ENTONCES
Intermedio = A[fila][columna];
A[fila][columna] = A[fila][columna + 1];
A[fila][columna + 1] = intermedio;
Intercambio = 1;
FIN_SI
FIN_PARA
FIN_PARA
HASTA (intercambio = 0)
FIN_INICIO
FIN_ALGORITMO
15

16. ALGORITMO ejercicio 20
VARIABLE
ENTERO A[1..20];
ENTERO indice;
ENTERO indice1;
FIN_VARIABLE
INICIO
PARA indice = 1 HASTA 20 INCREMENTO 1
ESCRIBIR (“Introduce un numero”);
LEER (A[indice]);
FIN_PARA
PARA indice = 1 HASTA 20 INCEMENTO 1
Indice1 = 2;
MIENTRAS (indice1 < A[indice]) AND (A[indice] mod indice1 <> 0) HACER
Indice1 = indice1 + 1;
FIN_MIENTRAS
SI (indice1 = A[indice]) ENTONCES
ESCRIBIR (“A[indice] es primo”);
FIN_SI
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
16

17. Ejercicios de Pseudocódigo Parte 1
1. Leer un número y mostrar por la salida estándar si dicho número es o no es par.
2. Leer 2 números y mostrar el producto de ellos.
3. Leer 2 números y determinar el mayor de ellos.
4. Leer 3 números y mostrar el mayor de ellos.
5. Leer un número y mostrar su tabla de multiplicar.
6. Leer una secuencia de 30 números y mostrar la suma y el producto de ellos.
7. Leer una secuencia de números, hasta que se introduce un número negativo y
mostrar la suma de dichos números.
8. Leer dos números y realizar el producto median sumas.
9. Leer dos números y realizar la división mediante restas mostrando el cociente y
el resto.
10. Leer una secuencia de números y mostrar su producto, el proceso finalizará
cuando el usuario pulse a la tecla F.
11. Lee una secuencia de números y determina cual es el mayor de ellos.
12. Dado un número mostrar su valor en binario.
13. Generar enteros de 3 en 3 comenzando por 2 hasta el valor máximo menor que
30. Calculando la suma de los enteros generados que sean divisibles por 5.
14. Calcular la media de una secuencia de números, el proceso finalizará cuando
15. Generar los N primeros términos de la serie de Fibonacci. El valor N(entero y
positivo) deberá ser leído por el teclado. En esta serie los dos primeros números
son 1, y el resto se obtiene sumando los dos anteriores: 1,1,2,3,5,8,13,21…
16. Leer una secuencia se números y mostrar cuales de ellos es el mayor y el menor,
el proceso finalizará cuando se introduzca un número impar.
17. Leer una secuencia de números y sumar solo los pares mostrando el resultado
del proceso.
18. Leer una secuencia de números y mostrar los 30 primeros pares leídos.
19. Leer una secuencia de números y mostrar la suma de los 30 números que ocupan
posiciones de lectura par.
20. Leer un número y determinar su factorial.
21. Leer un número y determinar si es o no es primo.
22. Leer una secuencia de 30 números y mostrar la suma de los primos.
23. Leer una secuencia de 30 números y mostrar la suma de su factorial.
24. Dado
25. Calcular el valor del número E=(1/n!).
26. Implementar un programa que sea capaz de calcular el resultado de aplicar la
fórmula siguiente (n i)=n! / (i! * (n-i)!).
17

18. ALGORITMO ejercicio 1
VARIABLE
ENTERO numero;
FIN_VARIABLE
INICIO
ESCRIBIR (“Introduce un numero”);
LEER (numero);
SI (numero mod 2 = 0) ENTONCES
ESCRIBIR (“El numero es par”);
SINO
ESCRIBIR (“El numero no es par”);
FIN_SI
FIN_INICIO
FIN_VARIABLE
ALGORITMO ejercicio 2
VARIABLE
ENTERO numero a;
ENTERO numero b;
FIN_VARIABLE
INICIO
LEER (numero a);
LEER (numero b);
ESCRIBIR (“El numero a * El numero b”);
FIN_INICIO
FIN_ALGORITMO
18

19. ALGORITMO ejercicio 3
VARIABLE
ENTERO numero1;
ENTERO numero2;
FIN_VARIABLE
INICIO
ESCRIBIR (“Introduce el numero1”);
LEER (numero1);
ESCRIBIR (“Introduce el numero2”);
LEER (numero2);
SI (numero1 > numero2) ENTONCES
ESCRIBIR (“El numero1 es mayor”);
SINO
ESCRIBIR (“El numero2 es mayor”);
SI (numero1 = numero2) ENTONCES
ESCRIBIR (“Los numeros son iguales”);
FIN_SI
FIN_INICIO
FIN_ALGORITMO
19

20. ALGORITMO ejercicio 4
VARIABLE
ENTERO numero1;
ENTERO numero2;
ENTERO numero3;
FIN_VARIABLE
INICIO
ESCRIBIR (“Introduce numero1”);
LEER (numero1);
ESCRIBIR (“Introduce numero2”);
LEER (numero2);
SI (numero1 > numero2) ENTONCES
ESCRIBIR (“Introduce numero3”);
LEER (numero3);
SI (numero1 > numero3) ENTONCES
ESCRIBIR (“El numero1 es el mayor”);
SINO
SI (numero2 > numero3) ENTONCES
ESCRIBIR (“El numero2 es el mayor”);
SINO
ESCRIBIR (“El numeo3 es el mayor”);
FIN_SI
FIN_SI
FIN_SI
FIN_INICIO
FIN_ALGORITMO
20

21. ALGORITMO ejercicio 5
VARIABLE
ENTERO numero;
ENTERO indice;
FIN_VARIABLE
CONSTANTE
ENTERO numero = 5;
Conta_superior = 10
Cota_inferior = 1
FIN_CONSTANTE
INICIO
PARA cota_inferior HASTA cota_superior INCREMETO 1
REPETIR
ESCRIBIR (numero5 * indice);
HASTA (indice = 10)
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
21

22. ALGORITMO ejercicio 6
VARIABLE
ENTERO numero;
ENTERO indice;
ENTERO suma;
ENTERO producto;
FIN_VARIABLE
INICIO
Suma = 0;
Producto = 1;
PARA indice = 1 HASTA 30 INCREMETO 1
LEER (numero);
Suma = suma + numero;
Producto = producto * numero;
Indice = indice + 1;
FIN_PARA
ESCRIBIR (“la suma es:”+suma);
ESCRIBIR (“el producto es:”+producto);
FIN_INICIO
FIN_ALGORITMO
22

23. ALGORITMO ejercicio 7
VARIABLE
ENTERO numero;
ENTERO suma;
FIN_VARIABLE
INICIO
Suma = 0;
LEER (numero);
MIENTRAS (numero > 0) HACER
Suma = suma +numero;
LEER (numero);
FIN_MIENTRAS
ESCRIBIR (“la suma es:”+suma);
FIN_INICIO
FIN_ALGORITMO
23

24. ALGORITMO ejercicio 8
VARIABLE
ENTERO a;
ENTERO b;
ENTERO indice;
Multi;
FIN_VARIABLE
INICIO
ESCRIBIR (“introduce el primer numero”);
LEER (a);
ESCRIBIR (“introduce el segundo numero”);
LEER (b);
Multi = 0;
PARA indice = b HASTA 1 INCREMETO -1
Multi = multi + a;
FIN_PARA
ESCRIBIR (multi);
FIN_INICIO
FIN_ALGORITMO
24

25. ALGORITMO ejercicio 9
VARIABLE
ENTERO dividendo;
ENTERO divisor;
ENTERO cociente;
ENTERO resto;
ENTERO signo;
FIN_VARIABLE
INICIO
ESCRIBIR (“introduce el dividendo”);
LEER (dividendo);
ESCRIBIR (“introduce el divisor”);
LEER (divisor);
 idem multiplicar
//casos especiales//
SI (divisor = 0) ENTONCES
ESCRIBIR (“error”);
SINO
Cociente = 0;
Resto = dividendo;
MIENTRAS (resto >= divisor) HACER
Resto = resto – divisor;
Cociente = cociente + 1;
FIN_MIENTRAS
FIN_SI
FIN_INICIO
FIN_ALGORITMO
25

26. ALGORITMO ejercicio 10
VARIABLE
ENTERO numero;
ENTERO producto;
CARÁCTER fin;
FIN_VARIABLE
CONSTANTES
Limite = “f”;
FIN_CONSTANTE
INICIO
Producto = 1;
REPETIR
ESCRIBIR (“Introduce el numero”);
LEER (numero);
ESCRIBIR (“Si quieres finalizar pulsa “f””);
LEER (fin);
Producto = producto * numero;
HASTA (fin = limite)
ESCRIBIR (“el producto de los numeros es:+producto”);
FIN_INICIO
FIN_ALGORITMO
26

27. ALGORITMO ejercicio 11
VARIABLE
ENTERO numero;
ENTERO mayor;
CARÁCTER final;
FIN_VARIABLE
CONSTANTE
Fin = “F”;
FIN_CONSTANTE
INICIO
Mayor = 0;
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
ESCRIBIR (“Si no quieres introducir mas numeros pulsa “F””);
LEER (final);
SI (numero > mayor) ENTONCES
Mayor = numero;
FIN_SI
HASTA (final = fin)
ESCRIBIR (“El mayor es:”+mayor);
FIN_INICIO
FIN_ALGORITMO
27

28. ALGORITMO ejercicio 12
VARIABLE
ENTERO contador;
ENTERO decimal;
ENTERO cociente;
FIN_VARIABLE
INICIO
Contador = 0;
REPETIR
ESCRIBIR (“Introduce un decimal”);
LEER (decimal);
Contador = contador + 1;
HASTA (decimal >= 0) OR (contador = 5)
SI (contador = 5) ENTONCES
ESCRIBIR (“Sobrepasado numero de errores”);
SINO
SI (decimal = 0) ENTONCES
ESCRIBIR (“0”);
FIN_SI
Cociente = decimal
MIENTRAS (cociente<> 0) HACER
ESCRIBIR (cociente mod 2);
Cociente = cociente/2;
FIN_MIENTRAS
FIN_SI
FIN_INICIO
FIN_ALGORITMO
28

29. ALGORITMO ejercicio 13
VARIABLE
ENTERO indice;
ENTERO suma;
FIN_VARIABLE
INICIO
Suma = 0;
PARA indice = 2 HASTA 29 INCREMENTO 3
SI (indice mod 5 = 0) ENTONCES
Suma = suma + indice;
FIN_SI
FIN_PARA
ESCRIBIR (“La suma es:+suma”);
FIN_INICIO
FIN_ALGORITMO
29

30. ALGORITMO ejercicio 14
VARIABLE
ENTERO medio;
ENTERO suma;
ENTERO contador;
ENTERO numero;
FIN_VARIABLE
INICIO
Suma = 0;
Contador = 0;
Media = 0;
ESCRIBIR (“Introduce un numero”);
LEER (numero);
MIENTRAS (numero <> 0) HACER
Contador = contador + 1;
Suma = suma + numero;
ESCRIBIR (“Introduce un numero”);
LEER (numero);
FIN_MIENTRAS
Media = suma/contador;
FIN_INICIO
FIN_ALGORITMO
30

31. ALGORITMO ejercicio 15
VARIABLE
ENTERO numero;
ENTERO indice;
ENTERO intercambio;
ENTERO n-1;
ENTERO n-2;
FIN_VARIABLE
INICIO
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
HASTA (numero > 0)
SI (numero = 1) ENTONCES
ESCRIBIR (“a1 = 1”);
SINO
SI (numero = 2) ENTONCES
ESCRIBIR (“a1 = 1”);
ESCRIBIR (“a2 = 1”);
SINO
ESCRIBIR (“a1 = 1”);
ESCRIBIR (“a2 = 1”);
FIN_SI
n-1 = 1; //a1 = 1
n-2 = 1; //a2 = 1
PARA indice = 3 HASTA numero INCREMENTO 1
ESCRIBIR (“a”+indice+”=”+n-1+n-2);
Intercambio = n-1;
n-1 = n-1 + n-2;
n-2 = intercambio;
FIN_PARA
FIN_SI
FIN_INICIO
FIN_ALGORITMO
31

32. ALGORITMO ejercicio 16
VARIABLE
ENTERO numero;
ENTERO mayor;
ENTERO menor;
FIN_VARIABLE
INICIO
ESCRIBIR (“Introduce un numero”);
LEER (numero);
MIENTRAS (numero mod 2 = 0) HACER
Mayor = numero;
Menor = numero;
MIENTRAS (numero mod 2 = 0) HACER
SI (numero > mayor) ENTONCES
Mayor = numero;
SINO
SI (numero < menor) ENTONCES
Menor = numero;
FIN_SI
FIN_SI
FIN_MIENTRAS
FIN_MIENTRAS
FIN_INICIO
FIN_ALGORITMO
32

33. ALGORITMO ejercicio 17
VARIABLE
ENTERO suma;
ENTERO numero;
FIN_VARIABLE
CONSTANTE
Carácter fin;
FIN_CONSTANTE
INICIO
ESCRIBIR (“Introduce un numero”);
LEER (numero);
Suma = 0;
MIENTRAS (numero mod 2 = 0) HACER
Suma = suma + numero;
ESCRIBIR (“Desea continuar”);
SI (numero mod 2 = 0) ENTONCES
Suma = suma + numero;
SINO
Fin
FIN_SI
FIN_MIENTRAS
FIN_INICIO
FIN_ALGORITMO
33

34. ALGORITMO ejercicio 18
VARIABLE
ENTERO numero;
FIN_VARIABLE
CONSTANTE
Contador carácter;
FIN_CONSTANTE
INICIO
Contador = 0;
ESCRIBIR (“Introduce el primer numero”);
REPETIR
LEER (numero);
SI (numero mod 2 = 0) ENTONCES
ESCRIBIR (nuemro);
Contador = contador + 1;
FIN_SI
HASTA (contador = 30)
FIN_INICIO
FIN_ALGORITMO
34

35. ALGORITMO ejercicio 19
VARIABLE
ENTERO numero;
ENTERO suma;
ENTERO posicion;
ENTERO indice;
FIN_VARIABLE
INICIO
Suma = 0;
Posición = 0;
MIENTRAS (indice <= 30) HACER
ESCRIBIR (“introduce un numero”);
LEER (numero);
Posición = posición + 1;
SI (posicion mod 2 = 0 ) ENTONCES
Suma = suma + numero;
FIN_SI
FIN_MIENTRAS
FIN_INICIO
FIN_ALGORITMO
35

36. ALGORITMO ejercicio 20
VARIABLE
ENTERO factorial;
ENTERO indice;
ENTERO numero;
FIN_VARIABLE
INICIO
ESCRIBIR (“introduce un numero”);
LEER (numero);
SI (numero < 0) ENTONCES
ESCRIBIR ();
SINOSI (numero = 0) ENTONCES
ESCRIBIR (“El factorial de 0 es 1”);
SINO
Factorial = 1;
PARA indice = 2 HASTA numero INC 1 HACER
Factorial = factorial * numero;
FIN_PARA
ESCRIBIR (“el resultado es:”+factorial);
FIN_SI
FIN_INICIO
FIN_ALGORITMO
36

37. ALGORITMO ejercicio 21
VARIABLE
ENTERO n;
ENTERO contador;
BOOLEAN encontrado;
FIN_VARIABLE
INICIO
ESCRIBIR (“introduce un numero”);
LEER (numero);
Encontrado = false;
Contador = 2;
MIENTRAS (contador <= n-1)AND(n mod contador <> 0) HACER
Contador = contador + 1;
FIN_MIENTRAS
SI (contador <= n-1 ) ENTONCES
ESCRIBIR (“el numero no es primo”);
SINO
ESCRIBIR (“el numero es primo”);
FIN_SI
FIN_INICIO
FIN_ALGORITMO
37

38. ALGORITMO ejercicio 22
VARIABLE
ENTERO n;
ENTERO contador;
ENTERO suma;
ENTERO indice;
FIN_VARIABLE
INICIO
Suma = 0;
PARA indice = 1 HASTA 30 INC 1 HACER
ESCRIBIR (“introduce un numero”);
LEER (numero);
Contador = 2;
MIENTRAS (contador <= n-1)AND(n mod contador = 0) HACER
Contador = contador + 1;
FIN_MIENTRAS
SI (contador = n ) ENTONCES
Suma = suma + numero;
FIN_SI
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
38

39. ALGORITMO ejercicio 23
VARIABLE
ENTERO n;
ENTERO contador;
ENTERO factorial
ENTERO suma;
ENTERO indice;
FIN_VARIABLE
INICIO
Contador = 0;
REPETIR
REPETIR
ESCRIBIR (“introduce un numero”);
LEER (numero);
HASTA (n >= 0)
Factorial = 1;
PARA indice = 2 HASTA numero INC 1 HACER
Factorial = factorial * numero;
FIN_PARA
Suma = suma + factorial;
Contador = contador + 1;
HASTA (contador = 30)
ESCRIBIR (“la suma es:”+suma);
FIN_INICIO
FIN_ALGORITMO
39

40. ALGORITMO ejercicio 26
VARIABLE
ENTERO numero;
ENTERO resultado;
ENTERO i;
ENTERO factorial;
ENTERO resta;
ENTERO indice;
FIN_VARIABLE
INICIO
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
ESCRIBIR (“Introduce i”);
LEER (i);
HASTA (n > i) AND (N >= 0) AND (i >= 0)
Factorial = 1
FIN_INICIO
FIN_ALGORITMO
40

41. 1. Desarrollo un algoritmo (Peseudocódigo-Organigrama) para cada uno de los
siguientes problemas que se plantean:
a. Dado una secuencia de números determinar el mayor leído y el número
de veces que aparece.
b. Dado una secuencia de palabras determinar el mayor y menor
lexicográficamente.
c. Resolución de una educación de 2º grado.
d. Dado una secuencia de números obtener la suma de los factoriales de
aquellos que ocupan posición par.
e. Determina dado una secuencia de enteros los dos mayores.
f. Dada un entero extraer cada uno de los dígitos que lo forma.
g. Dada un entero visualizar sus divisores.
h. Dada una secuencia de enteros determinar para cada una los divisores.
i. Dada una secuencia de enteros determinar los que son primos y además
tienen como dígito menos significativo un 7.
j. Dada una secuencia de enteros determinar para cada su factorial y si es o
no primo.
k. Determina de una secuencia de enteros aquel que es mayor pero además
es primo.
l. Determina de una secuencia de enteros aquel factorial que es mayor.
m. Dado una secuencia de enteros de cada uno determina sus 20 primeros
múltiplos positivos y enteros.
41

42. ALGORITMO ejercicio a
VARIABLE
ENTERO numero;
ENTERO mayor;
ENTERO contador;
FIN_VARIABLE
CONSTANTE
Fin = “F”;
FIN_CONSTANTE
INICIO
Contador = 1;
Mayor = 0;
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
ESCRIBIR (“Si quieres finalizar pulsa F”);
LEER (fin);
SI (numero > mayor) ENTONCES
Contador = 1;
Mayor = numero;
ESCRIBIR (numero +“es el mayor”);
SINO
ESCRIBIR (“El mayor es:”+mayor);
FIN_SI
HASTA (fin = limite)
ESCRIBIR (“El mayor es:”+mayor);
ESCRIBIR (“Aparece:”+contador +”veces”);
FIN_INICIO
FIN_ALGORITMO
42

43. ALGORITMO ejercicio b
VARIABLE
SECUENCIA palabra;
ENTERO mayor;
ENTERO contador;
FIN_VARIABLE
CONSTANTE
Fin = “F”;
FIN_CONSTANTE
INICIO
Contador = 1;
Mayor = 0;
REPETIR
ESCRIBIR (“Introduce una palabra”);
LEER (palabra);
ESCRIBIR (“Si quieres finalizar pulsa F”);
LEER (fin);
SI (palabra > mayor) ENTONCES
Contador = 1;
Mayor = palabra;
ESCRIBIR (palabra +“es la mayor”);
SINO
ESCRIBIR (“La mayor es:”+mayor);
FIN_SI
HASTA (fin = limite)
ESCRIBIR (“La mayor es:”+mayor);
ESCRIBIR (“Aparece:”+contador +”veces”);
FIN_INICIO
FIN_ALGORITMO
43

44. ALGORITMO ejercicio c
VARIABLE
ENTERO a;
ENTERO b;
ENTERO c;
FIN_VARIABLE
INICIO
ESCRIBIR (“Introduce b”);
LEER (b);
ESCRIBIR (“Introduce a”);
LEER (a);
ESCRIBIR (“Introduce c”);
LEER (c);
SI ((b^2 – 4 * a * c)<0) ENTONCES
ESCRIBIR (error);
SINO
ESCRIBIR ((-b + (b^2 – 4 * a * c)^0.5 / (2 * a));
ESCRIBIR ((+b +- (b^2 – 4 * a * c)^0.5 / (2 * a));
FIN_SI
FIN INICIO
FIN_ALGORITMO
44

45. ALGORITMO ejercicio d
VARIABLE
ENTERO numero;
ENTERO factorial;
ENTERO contador;
ENTERO suma;
ENTERO c_s;
ENTERO indice;
FIN_VARIABLE
INICIO
Contador = 0;
suma = 0;
ESCRIBIR (“cuantos numeros quieres leer”);
LEER (c_s);
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
Contador = contador + 1;
SI (contador mod 2 = 0) ENTONCES
Factorial = 1;
PARA indice=2 HASTA numero INC 1
Factorial = factorial * indice;
FIN_PARA
Suma = suma + factorial;
FIN_SI
HASTA (contador = c_s)
FIN_INICIO
FIN_ALGORITMO
45

46. ALGORITMO ejercicio e
VARIABLE
ENTERO numero;
ENTERO mayor1;
ENTERO mayor2;
CARÁCTER fin;
FIN_VARIABLE
CONSTANTES
Limite = “f”;
FIN_CONSTANTE
INICIO
ESCRIBIR (“Introduce un numero”);
LEER (numero);
Mayor1 = numero;
Mayor2 = numero;
REPETIR
ESCRIBIR (“Quieres acabar”);
LEER (fin);
HASTA (fin = limite)
MIENTRAS (fin <> limite)
ESCRIBIR (“Introduce un numero”);
LEER (numero);
SI (numero > mayor1) ENTONCES
Mayor2 = mayor1;
Mayor1 = numero;
SINOSI (numero > mayor2) ENTONCES
Mayor2 = numero;
FIN_SI
REPETIR
ESCRIBIR (“Quieres acabar”);
LEER (fin);
HASTA (fin = limite)
FIN_MIENTRAS
ESCRIBIR (“los mayores son:”+mayor1 “y” +mayor2);
FIN_INICIO
FIN_ALGORITMO
46

47. ALGORITMO ejercicio f
VARIABLE
ENTERO decimal;
ENTERO cociente;
ENTERO contador;
INICIO
Contador = 0;
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
Contador = contador + 1;
HASTA (decimal >= 0) OR (contador = 5)
SI (contador = 5) ENTONCES
ESCRIBIR (“sobrepasa el numero de errores”);
SINO
Cociente = decimal;
MIENTRAS (contador <> 0)
ESCRIBIR (cociente mod 10);
Cociente = cociente/10;
FIN_MIENTRAS
FIN_SI
FIN_INICIO
FIN_ALGORITMO
47

48. ALGORITMO ejercicio g
VARIABLE
ENTERO numero;
ENTERO indice;
FIN_VARIABLE
INICIO
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
HASTA (numero > 0)
PARA indice = 1 HASTA numero INCREMENTO 1
SI (numero mod indice = 0) ENTONCES
ESCRIBIR (“Un divisor es:+ndice”);
SINO
ESCRIBIR (“El +indice no es un divisor”);
FIN_SI
FIN_PARA
FIN_INICIO
FIN_ALGORITMO
48

49. ALGORITMO ejercicio h
VARIABLE
ENTERO numero;
ENTERO indice;
CARÁCTER fin;
FIN_VARIABLE
CONSTANTE
Limite1 = “N”;
Limite2 = “S”;
FIN_CONSTANTE
INICIO
REPETIR
ESCRIBIR (“Introduce un numero”);
LEER (numero);
HASTA (numero > 0)
PARA indice = 1 HASTA numero INCREMENTO 1
SI (numero mod indice = 0) ENTONCES
ESCRIBIR (“Un divisor es:+ndice”);
SINO
ESCRIBIR (“El +indice no es un divisor”);
FIN_SI
FIN_PARA
REPETIR
ESCRIBIR (“¿Quieres seguir? (S/N)”);
LEER (fin);
HASTA (fin = limite1) OR (fin = limite2)
MIENTRAS (fin = limite2) HACER
PARA indice = 1 HASTA numero INCREMENTO 1
SI (numero mod indice = 0) ENTONCES
ESCRIBIR (“Un divisor es:+ndice”);
SINO
ESCRIBIR (“El +indice no es un divisor”);
FIN_SI
FIN_PARA
REPETIR
ESCRIBIR (“¿Quieres seguir? (S/N)”);
LEER (fin);
HASTA (fin = limite1) OR (fin = limite2)
FIN_MIENTRAS
FIN_INICIO
FIN_ALGORITMO
49

50. Calcular el mayor de dos valores introducidos mediante el teclado utilizando
programación modular.
ALGORITMO
VARIABLE
ENTERO A1;
ENTERO A2;
FIN_VARIABLE
INICIO
Pantalla_principal ();
Leer_valores ();
SI (mayor (A1,A2) = o) ENTONCES
ESCRIBIR (“A1 es mayor que A2”);
SINO
SI (mayor (A1,A2) = 1) ENTONCES
ESCRIBIR (“A2 es mayor que A1”);
SINO
ESCRIBIR (“Son iguales”);
FIN_SI
FIN_SI
FIN_INICIO
PROCEDIMIENTO pantalla_principal
INICIO
Borrar_pantalla ();
ESCRIBIR (“__”);
ESCRIBIR (“__”);
……
FIN_PROCEDIMIENTO
PROCEDIMIENTO leer_valores
INICIO
ESCRIBIR (“Introduce A1”);
LEER (A1);
ESCIBIR (“Introduce A2”);
LEER (A2);
FIN_PROCEDIMIENTO
PROCEDIMIENTO borrar_pantalla
VARIABLE
ENTERO A1; /*A1 es un contador*/
FIN_VARIABLE
CONSTANTE
ENTERO primera_linea = 1;
ENTERO ultima_linea = 24;
FIN_CONSTANTE
INICIO
PARA A1 = primera_linea HASTA ultima_linea INCREMENTO 1
ESCRIBIR (“__”);
FIN_PARA
FIN_PROCEDIMIENTO
ENTERO funcion mayor(entero valor1, entero valor2)
INICIO
50

51. SI (valor1 > valor2) ENTONCES
Devolver (0)
SINO
SI (valor1 < valor2) ENTONCES
Devolver (1);
SINO
Devolver (2);
FIN_SI
FIN_SI
FIN_FUNCION
FIN_ALGORITMO
Leer un numero y mostrar su tabla de multiplicar
ALGORITMO
VARIABLE
ENTERO numero;
ENTERO error;
ENTERO cota_superior;
ENTERO cota_inferior;
FIN_VARIABLE
INICIO
Pantalla_inicial ();
Borrar_pantalla ();
Error = leer_valores();
SI (error = 1) ENTONCES
ESCRIBIR (“Has introducido mal los datos”);
SINO
Tabla_multiplicar(numero, cota_superior, cota_inferior);
FIN_SI
Pantalla_final();
FIN_INICIO
LIBRERÍA
ENTERO funcion leer_valores()
INICIO
Borrar_pantalla ();
ESCRIBIR (“Introduce el numero de multiplicar, c_s, c_i);
LEER (numero);
LEER (c_s);
LEER (c_i);
SI (c_s < c_i) ENTONCES
Devolver (1);
SINO
Devolver (0);
FIN_SI
FIN_FUNCION
FIN_ALGORITMO
51

52. Realizar un algoritmo que muestre el siguiente menú.
1. Amigos
2. Sociables
3. Vector de productos
4. Vector de sumas
5. Bisiesto
6. Salir
IMPORTAR MATEMATICAS
ALGORITMO
VARIABLE
ENTERO opcion;
FIN_VARIABLE
INICIO
Pantalla_inicial ();
REPETIR
Pantalla_menu ();
Leer_opcion ();
SELECTOR
Caso1: procedimiento amigos ()
Caso2: procedimiento sociables ()
Caso3: procedimiento vector de productos ()
Caso4: procedimiento vector de sumas ()
Caso5: procedimiento bisiesto ()
FIN_SELECTOR
HASTA (opcion = 6)
Pantalla_fin ();
FIN_INICIO
PROCEDIMIENTO pantalla_menu ()
ESCRIBIR (“__”);
……
……
FIN_PROCEDIMIENTO
PRCEDIMIENTO leer_opcion
INICIO
LEER (opcion);
FIN_INICIO
FIN_PROCEDIMIENTO
PROCEDIMIENTO procedimientos_amigos ()
VARIABLE
ENTERO valor1;
ENTERO valor2;
CARÁCTER tecla;
FIN_VARIABLE
INICIO
REPETIR
Pantalla_amigos ();
REPETIR
LEER (valor1);
LEER (valor2);
52

53. HASTA ((valor1 > 0) AND (valor2 > 0))
SI (amigos(valor1,valor2) = 1) ENTONCES
ESCRIBIR (“Son amigos”);
SINO
ESCRIBIR (“No son amigos”);
FIN_SI
REPETIR
ESCRIBIR (“¿Quieres seguir s/n?”);
LEER (tecla);
HASTA ((teca = s) OR (tecla = n))
HASTA (tecla = N)
FIN_INICIO
FIN_PROCEDIMIENTO
ENTERO funcion amigos (entero v1, entero v2)
INICIO
SI (suma_divisores (v1) = v2) AND (suma_divisores(v2) = v1) ENTONCES
Devuelve (1);
SINO
Devuelve (0);
FIN_SI
FIN_FUNCION
ENTERO funcion suma_divisores (Entero valor)
VARIABLE
ENTERO indice;
ENTERO suma;
FIN_VARIABLE
INICIO
Suma = 0;
PARA indice = 1 HASTA (v1 – 1) INCREMENTO 1
SI (v1 mod divisor = 0) ENTONCES
Suma = suma + indice;
FIN_SI
FIN_PARA
Devolver (suma);
FIN_FUNCION
PROCEDIMIENTO procedimiento_sociable ()
CONSTANTE
ENTERO c_i = 1;
ENTERO c_s = 20;
FIN_CONSTANTE
VARIABLE
ENTERO vector[c_i..c_s];
ENTERO indice;
FIN_VARIABLE
Pantalla_sociable
PARA indice = c_i HASTA c_s INCREMENTO 1
LEER (vector[indice]);
FIN_PARA
SI ((sociable(vector, c_i, c_s)) = 1) ENTONCES
ESCRIBIR (“Son sociables”);
53

54. SINO
ESCRIBIR (“NO son sociables”);
FIN_SI
FIN_INICIO
FIN_PROCEDIMIENTO
ENTERO funcion sociables (Entero vector[], Entero c_i, Entero c_s)
VARIABLE
ENTERO indice;
FIN_VARIABLE
INICIO
Indice = 1;
MIENTRAS (indice < c_i) AND (sociables(vector[indice], ventor[indice + 1]) = 1)
Indice = indice + 1;
FIN_MIENTRAS
SI (indice = c_s) AND ((sociable[c_i], v[c_s]) = 1) ENTONCES
Devolver (1);
SINO
Devolver (0);
FIN_SI
FIN_INICIO
FIN_FUNCION
ENTERO funcion vector_producto (Entero vector[], c_i, c_s)
VARIABLE
ENTERO indice;
ENTERO producto;
FIN_VARIABLE
INICIO
Producto = 1;
PARA indice = c_i HASTA c_s INCREMENTO 1
Producto = producto * vector[indice];
FIN_PARA
Devolver (productos);
FIN_FUNCION
PROCEDIMIENTO vector_de_sumas
VARIABLE
ENTERO c_i;
ENTERO c_s;
ENTERO indice;
ENTERO vector [c_i..c_s];
FIN_VARIABLE
INICIO
Borrar_pantalla ();
Pantalla_inicial_vector_de_sumas ();
Leer (c_i);
Leer (c_s);
PARA indice = c_i HASTA c_s INCREMENTO 1
LEER (vector[indice]);
FIN_PARA
ESCRIBIR (“suma_vector(vector[], c_i, c_s);
FIN_INICIO
54

55. FIN_PROCEDIMIENTO
ENTERO funcion suma_vector (Entero vector[], c_i, c_s)
VARIABLE
ENTERO indice;
ENTEOR suma;
FIN_VARIABLE
INICIO
Suma = 0;
PARA indice = c_i HASTA c_s INCREMENTO 1
Suma = suma + vector[indice[;
FIN_PARA
Devolver (suma);
FIN_FUNCION
PROCEDIMIENTO bisiesto
VARIABLE
CARÁCTER año;
FIN_VARIABLE
INICIO
Borrar_pantalla ();
Pantalla_inicial_bisiesto ();
ESCRIBIR (“Dame un año”);
LEER (año);
SI (año =< 0) ENTONCES
ESCRIBIR (“El año no es bisiesto”);
SINO
SI (año mod 400 = 0) ENTONCES
ESCRIBIR (“Es bisiesto”);
SINO
SI (año mod 100 = 0) ENTONCES
ESCRIBIR (“No es bisiesto”);
SINO
ESCRIBIR (“Es bisiesto”);
FIN_SI
FIN_SI
FIN_SI
FIN_INICIO
FIN_PROCEDIMIENTO
ENTERO funcion Bisiesto(Entero año)
INICIO
SI (año mod 4 <> 0) ENTONCES
Devolver (0);
SINO SI (año mod 400 = 0) ENTONCES
Devolver (1);
SINO SI (año mod 100 <> 0) ENTONCES
Devolver (1);
SINO
Devolver (0);
FIN_SI
FIN_FUNCION
FIN_ALGORITMO
55

56. Define una función que reciba un vector y devuelva el mayor de todos.
ENTERO funcion mayor_vector (Entero a[], Entero c_i, Entero c_s)
VARIABLE
ENTERO indice;
ENTERO mayor;
FIN_VARIABLE
INICIO
Mayor = a[c_i];
PARA indice = c_i HASTA c_s INCREMENTO 1
SI (a[indice] > mayor) ENTONCES
Mayor = a[indice];
FIN_SI
FIN_PARA
Devolver (mayor);
FIN_FUNCION
Define una función que recibiendo un vector y un entero devuelva la existencia o no de dicho
entero en el vector.
ENTERO funcion numero_vector (Entero numero, Entero vector[], Entero c-i, c_s)
VARIABLE
ENTERO indice;
FIN_VARIABLE
INICIO
Indice = c_i;
MIENTRAS (indice <= c_s) AND (vector(indice <> numero) HACER
Indice indice + 1;
FIN_MIENTRAS
SI (indice = c_i + 1) ENTONCES
Devolver (0);
SINO
Devolver (1);
FIN_SI
FIN_FUNCION
Algoritmo que lea n enteros que indiquen el factorial de los primos.
ALGORITMO vector_de_factoriales_primos
VARIABLE
ENTERO vector [c_i..c_s];
ENTERO vector_factorial [c_i..c_s];
ENTERO cota_superior;
ENTERO cota_inferior;
ENTERO indice;
FIN_VARIABLE
INICIO
Borrar_pantalla ();
Pantalla:inicial ();
Borrar_pantalla ();
56

57. Leer_valores ();
PARA indice = cota_inf HASTA cota_sup INCREMENTO 1
SI (numeros_primos(vector[indice]) = 1) ENTONCES
Vector_factorial[indice] = factorial_de_un _numero (vector[indice]);
FIN_SI
ESCRIBIR (vector_factorial[indice]);
FIN_PARA
Pantalla_inicial ();
FIN_INICIO
ENTERO funcion numero_primo (Entero numero)
VARIABLE
ENTERO numero;
ENTERO indice;
FIN_VARIABLE
INICIO
Indice = 2;
MIENTRAS (indice < numero) AND (numero mod indice <> 0) HACER
Indice = indice + 1;
FIN_MIENTRAS
SI (indice = numero) ENTONCES
Devolver (1);
SINO
Devolver (0);
FIN_SI
FIN_FUNCION
FIN_ALGORTIMO
57

58. Algoritmo que lea n enteros almacenados en un vector sus factoriales.
ALGORITMO factorial
VARIABLE
ENTERO vector_entero[c_i..c_s];
ENTERO vector_factorial[c_i..c_s];
ENTERO cota_inferior;
ENTERO cota_superior;
FIN_VARIABLE
INICIO
Borrar_pantalla ();
Pantalla:inicial ();
Borrar_pantalla ();
Leer_valores ();
PARA indice = cota_inf HASTA cota_sup INCREMENTO 1
Vector_factorial[indice] = factorial_de_un_numero(vector:etero[indice]);
ESCRIBIR (vector_factorial[indice]);
FIN_PARA
Pantalla_final ();
FIN_INICIO
PROCEDIMIENTO leer_valores ()
INICIO
ESCRIBIR (“introduce cotas”);
LEER (cota_inf);
LEER (cota_sup);
ESCRIBIR (“Rellena el vector”);
PARA indice = cota_inf HASTA cota_sup INCREMENTO 1
LEER (vector_entero [indice]);
FIN_PARA
FIN_PROCEDIMIENTO
ENTERO funcion factorial_de_un _numero (numero)
VARIABLE
ENTERO factorial;
ENTERO indice;
FIN_VARIABLE
INICIO
SI (numero < 0) ENTONCES
Devolver (-1);
SINO
SI (numero = 1) ENTONCES
Devolver (1);
SINO
Factorial = 1;
FIN_SI
PARA indice = 2 HASTA numero INCREMENTO 1
Factorial = factorial + indice;
FIN_PARA
Devolver (factorial);
FIN_SI
FIN_INICIO
58

59. FIN_FUNCION
FIN_ALGORITMO
Leer una secuencia y determinar la longitud de la palabra
ENTERO funcion palabra_mas_larga (secuencia parrafo)
VARIABLE
ENTERO indice;
ENTERO contador_palabra;
ENTERO mayor_palabra;
FIN_VARIABLE
INICIO
Indice = 0;
Contador_palabra = 0;
Mayor_palabra = 0;
MIENTRAS (parrafo[indice] <> “o”) HACER
SI (parrafo[indice] <> “o”) ENTONCES
Contador_palabra = contador_palabra + 1;
FIN_SI
SI (parrafo[indice] <> “o”) AND (parrafo[indice + 1] = “ ” OR (parrafo[indice +
1] = “o”) ENTONCES
SI(contador_palabra > mayor_palabra) ENTONCES
Mayor_palabra = contador_palabra;
FIN_SI
Contador_palabra = 0;
FIN_SI
Indice = indice + 1;
FIN_MIENTRAS
Devolver (contador_palabra);
FIN_FUNCION
Leer una secuencia y determinar la longitud de la misma.
VARIABLE
ENTERO indice;
FIN_VARIABLE
INICIO
Indice = o
MIENTRAS (texto[indice] <> “o”) HACER
Indice = indice -1
FIN_MIENTRAS
Devolver (indice);
FIN_INICIO
Realizar una funcion que recibiendo una secuencia devuelva dicha secuencia en mayusculas.
ENTERO funcion touppercase_java (secuencia parrafo)
VARIABLE
ENTERO indice;
SECUENCIA resultado;
59

60. FIN_VARIABLE
INICIO
Indice = 0;
MIENTRAS (parrafo[indice] <> “o”) HACER
SI (parrafo[indice] >= “a”) AND (parrafo[indice] <= “z”) ENTONCES
Parrafo[indice] = Entero_to_caracter(carácter_to_entero[indice] -32);
FIN_SI
FIN_MIENTRAS
Devolver (parafo);
FIN_INICIO
Definir una funcion recibiendo una secuencia cuyo fin sera el carácter “o” que devuelva el
entero que representa.
ENTERO funcion simula_autoi (secuencia texto)
VARIABLE
CARÁCTER V_a[1.longitud(texto) + 1];
ENTERO indice;
ENTERO acumulador;
ENTERO indice2;
FIN_VARIABLE
INICIO
Indice = 0;
MIENTRAS (texto[indice] <> “o”) AND (texto[indice] >= “o”) AND (texto[indice] <= “9”)
V_a[indice + 1] = texto[indice];
Indice = indice + 1;
FIN_MIENTRAS
V_a[indice] = “o”;
Acumulador = 0;
PARA indice2 = 1 HASTA indice -1 INCREMENTO 1
Acumulador = acumulador + (carácter_to_entero (v_a[indice2]) – 45) * (10^(indice –
indice2));
FIN_PARA
Devolver (acumulador);
FIN_FUNCION
Dada una secuencia mostrar por pantalla el numero de apariciones del codigo ascii.
PROCEDIMIENTO apariciones (secuencia texto)
VARIABLE
ENTERO ascii[0..255];
ENTERO indice;
FIN_VARIABLE
INICIO
PARA indice = 0 HASTA 255 NCREMENTO 1
Ascii[indice] = 0;
FIN_PARA
PARA indice = 0 HASTA longitud(texto) INCREMENTO 1
Ascii (carácter_to_entero(texto[indice])) = (ascii[carácter_to_entero(texto[indice])) +1
FIN_PARA
60

61. PARA indice = 0 HASTA 255 INCREMENTO 1
ESCRIBIR (“EL codigo ascii”+indice”:”+ascii[indice]);
FIN_PARA
FIN_PROCEDIMIENTO
61