RUBEN

NAVARRO
CASERO
&
RAUL
MORALES
GARCIA
Correccin e implementacin en PSeInt por Alejandro
Caro y discoduroderoer

2004
2012-2013

1
Ejercicios de Pseudocdigo Parte 1
Nota: Los arreglos son en base 0

1. Leer un nmero y mostrar por la salida estndar si dicho nmero es o no es par.

2. Leer 2 nmeros y mostrar el producto de ellos.
3. Leer 2 nmeros y determinar el mayor de ellos.
4. Leer 3 nmeros y mostrar el mayor de ellos.
5. Leer un nmero y mostrar su tabla de multiplicar.
6. Leer una secuencia de 30 nmeros y mostrar la suma y el producto de ellos.
7. Leer una secuencia de nmeros, hasta que se introduce un nmero negativo y
mostrar la suma de dichos nmeros.
8. Leer dos nmeros y realizar el producto mediante sumas.
9. Leer dos nmeros y realizar la divisin mediante restas mostrando el cociente y
el resto.
10. Leer una secuencia de nmeros y mostrar su producto, el proceso finalizar
cuando el usuario pulse a la tecla F.
11. Lee una secuencia de nmeros y determina cual es el mayor de ellos. anda
12. Dado un nmero mostrar su valor en binario.
13. Generar enteros de 3 en 3 comenzando por 2 hasta el valor mximo menor que
Calculando la suma de los enteros generados que sean divisibles por 5.
14. Calcular la media de una secuencia de nmeros, el proceso finalizar cuando el
usuario pulse F.
15. Generar los N primeros trminos de la serie de Fibonacci y mostrarlos por
pantalla. El valor N (entero y positivo) deber ser ledo por el teclado. En esta
serie los dos primeros nmeros son 1, y el resto se obtiene sumando los dos
anteriores: 1,1,2,3,5,8,13,21
16. Leer una secuencia se nmeros y mostrar cules de ellos es el mayor y el menor,
el proceso finalizar cuando se introduzca un nmero impar.
17. Leer una secuencia de nmeros y sumar solo los pares mostrando el resultado
del proceso.
18. Leer una secuencia de nmeros y mostrar los 30 primeros pares ledos.
19. Leer una secuencia de nmeros y mostrar la suma de los 30 nmeros que ocupan
posiciones de lectura par.
20. Leer un nmero y determinar su factorial.
21. Leer un nmero y determinar si es o no es primo.
22. Leer una secuencia de 30 nmeros y mostrar la suma de los primos.
23. Leer una secuencia de 30 nmeros y mostrar la suma de su factorial.
24. Calcular el valor del nmero E (Euler) =(1/n!) y mostrarlo en pantalla. (ver)
25. Implementar un programa que sea capaz de calcular el resultado de aplicar la
frmula siguiente (n i)=n! / (i! * (n-i)!).

Vase pgina Ejercicios de Pseudocdigo Parte 2 para la segunda parte

2
ALGORITMO ejercicio_1
DEFINIR numero COMO ENTERO;

ESCRIBIR ("Introduce un nmero");

LEER numero;
SI (numero % 2 = 0) ENTONCES
ESCRIBIR ("El numero es par");
SINO
ESCRIBIR ("El numero no es par");
FINSI
FINALGORITMO

ALGORITMO ejercicio_2
DEFINIR numero_a COMO ENTERO;
DEFINIR numero_b COMO ENTERO;

ESCRIBIR ("Introduce un nmero");

LEER numero_a;
ESCRIBIR ("Introduce otro nmero");
LEER numero_b;
ESCRIBIR (numero_a * numero_b);
FINALGORITMO

ALGORITMO ejercicio_3
DEFINIR numero1 COMO ENTERO;
DEFINIR numero2 COMO ENTERO;
ESCRIBIR ("Introduce el nmero1");
LEER numero1;
ESCRIBIR ("Introduce el nmero2");
LEER numero2;
SI (numero1 > numero2) ENTONCES
ESCRIBIR ("El nmero1 es mayor", numero1);
SINO
ESCRIBIR ("El nmero2 es mayor", numero2);
SI (numero1 = numero2) ENTONCES
ESCRIBIR ("Los nmeros son iguales");
FINSI
FINSI
FINALGORITMO

3
ALGORITMO ejercicio_4
DEFINIR numero1 COMO ENTERO;
DEFINIR numero2 COMO ENTERO;
DEFINIR numero3 COMO ENTERO;
ESCRIBIR ("Introduce nmero1");
LEER numero1;
ESCRIBIR ("Introduce nmero2");
LEER numero2;
SI (numero1 > numero2) ENTONCES
ESCRIBIR ("Introduce nmero3");
LEER numero3;
SI (numero1 > numero3) ENTONCES
ESCRIBIR ("El nmero1 es el mayor");
SINO
SI (numero2 > numero3) ENTONCES
ESCRIBIR ("El nmero2 es el mayor");
SINO
ESCRIBIR ("El nmero3 es el mayor");
FINSI
FINSI
FINSI
FINALGORITMO

ALGORITMO ejercicio_5
DEFINIR indice COMO ENTERO;
DEFINIR numero COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DEFINIR cota_inferior COMO ENTERO;
cota_inferior <- 1;
cota_superior <- 10;
indice <- 1;

ESCRIBIR "Ingrese un nmero";

LEER numero;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
ESCRIBIR numero ,(" * "), indice ,(" = "), numero*indice;
FINPARA
FINALGORITMO

4
ALGORITMO ejercicio_6
DEFINIR numero COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR producto COMO ENTERO;
suma <- 0;
producto <- 1;
PARA indice <-1 HASTA 30 CON PASO 1 HACER
LEER numero;
suma <- suma + numero;
producto <- producto * numero;
indice <-indice + 1;
FINPARA
ESCRIBIR ("la suma es: "), suma;
ESCRIBIR ("el producto es: "), producto;
FINALGORITMO

ALGORITMO ejercicio_7
DEFINIR numero COMO ENTERO;
DEFINIR suma COMO ENTERO;
suma <- 0;
LEER numero;
MIENTRAS (numero > 0) HACER
suma <- suma +numero;
LEER numero;
FINMIENTRAS
ESCRIBIR ("la suma es:"), suma;
FINALGORITMO

ALGORITMO ejercicio_8
DEFINIR a COMO ENTERO;
DEFINIR b COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR Multi COMO ENTERO;
ESCRIBIR ("introduce el primer nmero");
LEER a;
ESCRIBIR ("introduce el segundo nmero");
LEER b;
multi <- 0;
PARA indice <-b HASTA 1 CON PASO -1 HACER
multi <- multi + a;
FINPARA
ESCRIBIR (multi), " "; //apretar alt + 01
FINALGORITMO

5
ALGORITMO ejercicio_9
DEFINIR dividendo COMO ENTERO;
DEFINIR divisor COMO ENTERO;
DEFINIR cociente COMO ENTERO;
DEFINIR resto COMO ENTERO;
DEFINIR signo COMO ENTERO;

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;
FINMIENTRAS
FINSI
ESCRIBIR "El cociente es ", cociente;
ESCRIBIR "El resto es ", resto;
FINALGORITMO

ALGORITMO ejercicio_10
DEFINIR numero COMO ENTERO;
DEFINIR producto COMO ENTERO;
DEFINIR ffin COMO CARACTER;
DEFINIR limite COMO CARACTER;

Limite <- "f";

Producto <- 1;
REPETIR
ESCRIBIR ("Introduce el nmero");
LEER numero;
ESCRIBIR ("Seguir? f = no s = si\n");
LEER ffin;
producto <- producto * numero;
HASTA QUE (ffin = limite)
ESCRIBIR ("el producto de los nmeros es: "), producto;
FINALGORITMO

6
ALGORITMO ejercicio_11
DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR final COMO CARACTER;
DEFINIR ffin COMO CARACTER;

ffin <-"F";
mayor <- 0;

REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
ESCRIBIR ("Seguir? f = no s = si\n");
LEER final;
SI (numero > mayor) ENTONCES
mayor <- numero;
FINSI
HASTA QUE (final = ffin)
ESCRIBIR ("El mayor es:"), mayor;
FINALGORITMO

ALGORITMO ejercicio_12
DEFINIR contador COMO ENTERO;
DEFINIR binario COMO CADENA;
DEFINIR digito COMO CADENA;
DEFINIR decimal COMO ENTERO;
DEFINIR cociente COMO ENTERO;
binario<-"";
digito<-"";
Contador <- 0;
REPETIR
ESCRIBIR ("Introduce un decimal");
LEER decimal;
Contador <- contador + 1;
HASTA QUE (decimal >= 0) | (contador = 5)
SI (contador = 5) ENTONCES
ESCRIBIR ("Sobrepasado numero de errores");
SINO
SI (decimal = 0) ENTONCES
ESCRIBIR ("0");
FINSI
Cociente <- decimal;

MIENTRAS (cociente<> 0) HACER

SI cociente % 2 = 0 ENTONCES
digito<-"0"
Sino
digito<-"1"
FinSi
binario<-digito+binario
Cociente <- cociente/2;
FINMIENTRAS
ESCRIBIR binario;
FINSI

7
FINALGORITMO

//(Otra solucin)
ALGORITMO ejercicio_12_ii
DEFINIR num COMO ENTERO;
DEFINIR cad COMO CADENA;
ESCRIBIR ("Ingrese un nmero entero positivo: ");
LEER num;
cad <- "";
SI num > 0 ENTONCES
MIENTRAS num>0 HACER
SI num%2 = 0 ENTONCES
cad <- "0" + cad;
SINO
cad <- "1" + cad;
FINSI
num <- trunc(num/2);
FINMIENTRAS
ESCRIBIR ("Numero en binario: "), cad;
SINO
SI num = 0 Entonces
ESCRIBIR "0";
SINO
Escribir ("Solo nmeros mayores a cero");
FINSI
FINSI
FINALGORITMO

ALGORITMO ejercicio_13
DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
suma <- 0;
PARA indice <-2 HASTA 29 CON PASO 3 HACER
SI (indice % 5 = 0) ENTONCES
suma <- suma + indice;
FINSI
FINPARA
ESCRIBIR ("La suma es: "), suma;
FINALGORITMO

ALGORITMO ejercicio_14
DEFINIR media COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR numero COMO ENTERO;
suma <- 0;
contador <- 0;
media <- 0;
ESCRIBIR ("Introduce un nmero");
LEER numero;
MIENTRAS (numero <> 0) HACER
contador <- contador + 1;
suma <- suma + numero;
ESCRIBIR ("Introduce un nmero");

8
 LEER numero;
FINMIENTRAS
media <- suma/contador;
ESCRIBIR suma, " ";
ESCRIBIR media;
FINALGORITMO

ALGORITMO ejercicio_15
DEFINIR numero COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR intercambio COMO ENTERO;
DEFINIR n_1 COMO ENTERO;
DEFINIR n_2 COMO ENTERO;

REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
HASTA QUE (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");
FINSI
n_1 <- 1; //a1 <- 1
n_2 <- 1; //a2 <- 1
PARA indice <-3 HASTA numero CON PASO 1 HACER
ESCRIBIR ( "a"), indice ,(" = "), n_1 + n_2;
intercambio <- n_1;
n_1 <- n_1 + n_2;
n_2 <- intercambio;
FINPARA
FINSI
FINALGORITMO

ALGORITMO ejercicio_16
DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR menor COMO ENTERO;
ESCRIBIR ("Introduce un nmero");
LEER numero;
MIENTRAS (numero % 2 = 0) HACER
mayor <- numero;
menor <- numero;
MIENTRAS (numero % 2 = 0) HACER
SI (numero > mayor) ENTONCES
mayor <- numero;
SINO
SI (numero < menor) ENTONCES
menor <- numero;

9
 FINSI
FINSI
FINMIENTRAS
FINMIENTRAS
FINALGORITMO

ALGORITMO ejercicio_17
DEFINIR suma COMO ENTERO;
DEFINIR numero COMO ENTERO;
suma <- 0;
ESCRIBIR ("Introduce un nmero");
LEER numero;
MIENTRAS (numero % 2 = 0) HACER
LEER numero;
suma <- suma + numero;
SI (numero % 2 = 0) ENTONCES
suma <- suma + numero;
FINSI
FINMIENTRAS
ESCRIBIR (suma);
FINALGORITMO

ALGORITMO ejercicio_18
DEFINIR numero COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR caracter COMO ENTERO;
contador <- 0;
ESCRIBIR ("Introduce el primer nmero");
REPETIR
LEER numero;
SI (numero % 2 = 0) ENTONCES
ESCRIBIR (numero);
contador <- contador + 1;
FINSI
HASTA QUE (contador = 30)
FINALGORITMO

ALGORITMO ejercicio_19
DEFINIR numero COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR posicion COMO ENTERO;
DEFINIR indice COMO ENTERO;

suma <- 0;
posicion <- 0;
MIENTRAS (indice <= 30) HACER
ESCRIBIR ("introduce un nmero");
LEER numero;
posicion <- posicion + 1;
SI (posicion % 2 = 0 ) ENTONCES
suma <- suma + numero;
FINSI
FINMIENTRAS
ESCRIBIR (suma);

10
FINALGORITMO

ALGORITMO ejercicio_20
DEFINIR factorial COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR numero COMO ENTERO;

ESCRIBIR ("introduce un nmero");

LEER numero;
SI (numero < 0) ENTONCES
ESCRIBIR ();
SINO SI (numero = 0) ENTONCES
ESCRIBIR ("El factorial de 0 es 1");
SINO
factorial <- 1;
PARA indice <-2 HASTA numero CON PASO 1 HACER
factorial <- factorial * numero;
FINPARA
ESCRIBIR ("El resultado es: "), factorial;
FINSI
FINSI
FINALGORITMO

ALGORITMO ejercicio_21
DEFINIR n COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR encontrado COMO LOGICO;

ESCRIBIR ("introduce un nmero");

LEER n;
encontrado <- falso;
contador <- 2;
MIENTRAS (contador <= n-1) & (n % contador <> 0) HACER
contador <- contador + 1;
FINMIENTRAS
SI (contador <= n-1 ) ENTONCES
ESCRIBIR ("el nmero no es primo");
SINO
ESCRIBIR ("el nmero es primo");
FINSI
FINALGORITMO

ALGORITMO ejercicio_22
DEFINIR n COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR indice COMO ENTERO;
suma <- 0;
PARA indice <-0 HASTA 29 CON PASO 1 HACER
ESCRIBIR ("introduce un nmero");
LEER numero;
contador <- 2;
MIENTRAS (contador <= n-1) & (n % contador = 0) HACER
contador <- contador + 1;

11
 FINMIENTRAS
SI (contador = n ) ENTONCES
suma <- suma + numero;
FINSI
FINPARA
FINALGORITMO

ALGORITMO ejercicio_23
DEFINIR n COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR factorial COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR numero COMO ENTERO;

n <- 0;
contador <- 0;
suma <- 0;

REPETIR
REPETIR
ESCRIBIR ("introduce un nmero");
LEER numero;
HASTA QUE (n >= 0)
factorial <- 1;
PARA indice <-2 HASTA numero CON PASO 1 HACER
factorial <- factorial * numero;
FINPARA
suma <- suma + factorial;
contador <- contador + 1;
HASTA QUE (contador = 30)
ESCRIBIR ("la suma es:"), suma;
FINALGORITMO

SUBPROCESO suma <- factorial ( numero )

DEFINIR suma COMO ENTERO;
suma<-numero;
PARA contador<-numero-1 HASTA 1 CON PASO -1 HACER
suma<-suma*contador;
FINPARA
FINSUBPROCESO

ALGORITMO ejercicio_24
DEFINIR e, n, numero COMO REALES;
e<-1;
ESCRIBIR "Ingrese la cantidad de cifras para el lmite del factorial: ";
LEER numero;
//ESCRIBIR (1+1/numero)^numero;
PARA n <-1 HASTA numero CON PASO 1 HACER
e <- e + 1/factorial(n);
FINPARA
ESCRIBIR e;
FINALGORITMO

12
SUBPROCESO suma <- factorial ( numero )
DEFINIR suma, contador COMO ENTERO;
suma<-numero;
PARA contador<-numero-1 HASTA 1 CON PASO -1 HACER
suma<-suma*contador;
FINPARA
FINSUBPROCESO
//http://www.discoduroderoer.es/ejercicios-de-funciones-pseudocodigo/

ALGORITMO ejercicio_25
DEFINIR numero COMO ENTERO;
DEFINIR resultado COMO ENTERO;
DEFINIR i COMO ENTERO;
DEFINIR indice COMO ENTERO;
REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
ESCRIBIR ("Introduce i");
LEER i;
HASTA QUE (numero > i) & (numero >= 0) & (i >= 0)
resultado <-factorial(numero) / (factorial(i) * factorial(numero-i));
ESCRIBIR resultado;
FINALGORITMO

SUBPROCESO suma <- factorial ( numero )

DEFINIR suma, contador COMO ENTERO;
suma<-numero;
PARA contador<-numero-1 HASTA 1 CON PASO -1 HACER
suma<-suma*contador;
FINPARA
FINSUBPROCESO

13
1. Desarrolle un algoritmo (Pseudocdigo-Organigrama) para cada uno de los
siguientes problemas que se plantean:
a. Dado una secuencia de nmeros determinar el mayor ledo y el nmero
de veces que aparece.
b. Dado una secuencia de palabras determinar el mayor y menor
lexicogrficamente.
c. Resolucin de una ecuacin de 2 grado.
d. Dado una secuencia de nmeros obtener la suma de los factoriales de
aquellos que ocupan posicin par.
e. Determina dado una secuencia de enteros obtener los dos ms mayores.
f. Dada un entero extraer cada uno de los dgitos 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 tambin
los que tienen como dgito 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 adems
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
mltiplos positivos y enteros.

14
ALGORITMO ejercicio_a
DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR ffin COMO CARACTER;

ffin <- "F";

contador <- 1;
mayor <- 0;
REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
ESCRIBIR ("Seguir? f = no s = si\n");
LEER fin;
SI (numero > mayor) ENTONCES
contador <- 1;
mayor <- numero;
ESCRIBIR numero ,("es el mayor");
SINO
ESCRIBIR ("El mayor es:"), mayor;
FINSI
HASTA QUE (ffin = limite)
ESCRIBIR ("El mayor es:"), mayor;
ESCRIBIR ("Aparece:"), contador ,("veces");
FINALGORITMO

ALGORITMO ejercicio_b
DEFINIR palabra COMO CARACTER;
DEFINIR mayor COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR ffin COMO ENTERO;

ffin <- "F";

contador <- 1;
mayor <- 0;
REPETIR
ESCRIBIR ("Introduce una palabra");
LEER palabra;
ESCRIBIR ("Seguir? f = no s = si\n");
LEER ffin;
SI (palabra > mayor) ENTONCES
contador <- 1;
mayor <- palabra;
ESCRIBIR palabra ,(" es la mayor");
SINO
ESCRIBIR ("La mayor es:", mayor);
FINSI
HASTA QUE (fin = limite)
ESCRIBIR ("La mayor es:"), mayor;
ESCRIBIR ("Aparece:"), contador ,("veces");
FINALGORITMO

15
ALGORITMO ejercicio_c
DEFINIR a COMO ENTERO;
DEFINIR b COMO ENTERO;
DEFINIR c COMO ENTERO;
DEFINIR det COMO REAL;

ESCRIBIR ("Introduce b");

LEER b;
ESCRIBIR ("Introduce a");
LEER a;
ESCRIBIR ("Introduce c");
LEER c;
det <-b^2 - 4 * a * c;
SI ((det)<0) ENTONCES
ESCRIBIR ("error");
SINO
ESCRIBIR (-b + (det)^0.5) / (2 * a);
ESCRIBIR (-b - (det)^0.5) / (2 * a);
FINSI
FINALGORITMO

ALGORITMO ejercicio_d
DEFINIR numero COMO ENTERO;
DEFINIR factorial COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DEFINIR indice COMO ENTERO;

contador <- 0;
suma <- 0;
ESCRIBIR ("cuantos nmeros quieres leer");
LEER cota_superior;
REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
contador <- contador + 1;
SI (contador % 2 = 0) ENTONCES
factorial <- 1;
PARA indice<-2 HASTA numero CON PASO 1 HACER
factorial <- factorial * indice;
FINPARA
suma <- suma + factorial;
FINSI
HASTA QUE (contador = cota_superior)
FINALGORITMO

ALGORITMO ejercicio_e
DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR contador COMO ENTERO;
DEFINIR ffin COMO CADENA;
DEFINIR limite COMO CADENA;
limite <- "F";

16
 ffin <- limite;
Contador <- 1;
Mayor <- 0;
REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
ESCRIBIR ("Si quieres finalizar pulsa F (solo ingrese F o N)");
LEER ffin;
SI (numero > mayor) ENTONCES
Contador <- 1;
Mayor <- numero;
ESCRIBIR numero ,(" es el mayor");
SINO
ESCRIBIR ("El mayor es: "),mayor;
FINSI
HASTA QUE (ffin = limite)
ESCRIBIR ("El mayor es:"),mayor;
ESCRIBIR ("Aparece: "),contador ,(" veces");
FINALGORITMO

ALGORITMO ejercicio_f
DEFINIR decimal COMO ENTERO;
DEFINIR cociente COMO ENTERO;
DEFINIR contador COMO ENTERO;
contador <- 0;
REPETIR
ESCRIBIR ("Introduce un nmero");
LEER decimal;
contador <- contador + 1;
HASTA QUE (decimal >= 0) | (contador = 5)
SI (contador = 5) ENTONCES
ESCRIBIR ("sobrepasa el nmero de errores");
SINO
cociente <- decimal;
MIENTRAS (cociente <> 0) HACER
ESCRIBIR (cociente % 10);
cociente <- trunc(cociente/10);
FINMIENTRAS
FINSI
FINALGORITMO

ALGORITMO ejercicio_g
DEFINIR numero COMO ENTERO;
DEFINIR indice COMO ENTERO;

REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
HASTA QUE (numero > 0)
PARA indice <-1 HASTA numero CON PASO 1 HACER
SI (numero % indice =0) ENTONCES
ESCRIBIR ("Un divisor es: "), indice;
SINO
ESCRIBIR ("El "), indice ,(" no es un divisor");

17
 FINSI
FINPARA
FINALGORITMO

ALGORITMO ejercicio_h
DEFINIR numero COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR ffin COMO CARACTER;
DEFINIR limite1 COMO CARACTER;
DEFINIR limite2 COMO CARACTER;

Limite1 <- "N";

Limite2 <- "S";

REPETIR
ESCRIBIR ("Introduce un nmero");
LEER numero;
HASTA QUE (numero > 0)
PARA indice <-1 HASTA numero CON PASO 1 HACER
SI (numero % indice <-0) ENTONCES
ESCRIBIR ("Un divisor es: "), indice;
SINO
ESCRIBIR ("El "), indice ,(" no es un divisor");
FINSI
FINPARA
REPETIR
ESCRIBIR ("Quieres seguir? (S/N)");
LEER ffin;
HASTA QUE (ffin = limite1) | (fin = limite2)
MIENTRAS (ffin = limite2) HACER
PARA indice <-1 HASTA numero CON PASO 1 HACER
SI (numero % indice <-0) ENTONCES
ESCRIBIR ("Un divisor es:"), indice;
SINO
ESCRIBIR ("El "), indice ,(" no es un divisor");
FINSI
FINPARA
REPETIR
ESCRIBIR ("Quieres seguir? (S/N)");
LEER ffin;
HASTA QUE (ffin = limite1) | (ffin = limite2)
FINMIENTRAS
FINALGORITMO

18
 Programacin modular (algunos no andan)
i Calcular el mayor de dos valores introducidos mediante el teclado utilizando
programacin modular. (ir al cdigo)
Leer un nmero y mostrar su tabla de multiplicar (ir al cdigo)
Realizar un algoritmo que muestre el siguiente men. No anda (ir al cdigo)
a. Amigos
b. Sociables
c. Vector de productos
d. Vector de sumas
e. Bisiesto
f. Salir
j Define una funcin que reciba un vector y devuelva el mayor de todos. No anda (ir a
cdigo)
k Define una funcin que recibiendo un vector y un entero devuelva la existencia o no
de dicho entero en el vector. No anda
l Algoritmo que lea n enteros que indiquen el factorial de los primos. No anda (ir al
cdigo)
(Ir a cdigos parte 2)

19
Calcular el mayor de dos valores introducidos mediante el teclado utilizando
programacin modular. (hecho sin usar variables globales) (volver al ndice)

ALGORITMO ejercicio_i
DEFINIR valor1 COMO ENTERO;
DEFINIR valor2 COMO ENTERO;
Pantalla_principal;
Leer_valores(valor1, valor2);
SI (mayor(valor1, valor2) = 0) ENTONCES
ESCRIBIR ("Valor 1 es mayor que valor2");
SINO
SI (mayor(valor1, valor2) = 1) ENTONCES
ESCRIBIR ("Valor 2 es mayor que valor1");
SINO
ESCRIBIR ("Son iguales");
FINSI
FINSI
FINALGORITMO

SUBPROCESO Pantalla_principal
Borrar_pantalla();
ESCRIBIR ("__");
ESCRIBIR ("__");
//
FINSUBPROCESO

SUBPROCESO Leer_valores (valor1 Por Referencia, valor2 Por Referencia)

ESCRIBIR ("Introduce valor1");
LEER valor1;
ESCRIBIR ("Introduce valor2");
LEER valor2;
FINSUBPROCESO

SUBPROCESO borrar_pantalla
DEFINIR A1 COMO ENTERO; //A1 es un contador
DEFINIR primera_linea, ultima_linea COMO ENTEROS;
primera_linea <- 1;
ultima_linea <- 24;
PARA A1 <- primera_linea HASTA ultima_linea CON PASO 1 HACER
ESCRIBIR ("__") Sin Saltar;
FINPARA
FINSUBPROCESO

SUBPROCESO retorno <- mayor (valor1, valor2)

DEFINIR retorno COMO ENTERO;
SI (valor1 > valor2) ENTONCES
Retorno <- (0);
SINO
SI (valor1 < valor2) ENTONCES
Retorno <- (1);
SINO
Retorno <- (2);
FINSI
FINSI

20
 FINSUBPROCESO

Leer un nmero y mostrar su tabla de multiplicar (hecho sin usar variables

globales) (volver al ndice)

ALGORITMO principal
DEFINIR numero COMO ENTERO;
DEFINIR cota_inferior COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DEFINIR error COMO ENTERO;
error <- leer_valores(numero, cota_superior, cota_inferior);
SI (error = 1) ENTONCES
ESCRIBIR ("Has introducido mal los datos");
SINO
Tabla_multiplicar(numero, cota_superior, cota_inferior);
FINSI
FINALGORITMO

SUBPROCESO retorno <- leer_valores(numero Por Referencia, cota_superior

Por Referencia, cota_inferior Por Referencia)
DEFINIR retorno COMO ENTERO;
ESCRIBIR "Introduce el nmero de multiplicar, cota_superior,
cota_inferior";
LEER numero;
LEER cota_superior;
LEER cota_inferior;
SI (cota_superior < cota_inferior) ENTONCES
Retorno <- (1);
SINO
Retorno <- (0);
FINSI
FINSUBPROCESO

SUBPROCESO Tabla_multiplicar(numero Por Referencia, cota_superior Por

Referencia, cota_inferior Por Referencia)
DEFINIR indice COMO ENTERO;
indice <- 1;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1
HACER
ESCRIBIR numero ,(" * "), indice ,(" = "), numero*indice;
FINPARA
FINSUBPROCESO

Realizar un algoritmo que muestre el siguiente men. (no anda) (volver al ndice)
(probar en cdigo fuente)
(configurar PSeInt para que permita utilizar variables para dimensionar arreglos)
1. Amigos
2. Sociables
3. Vector de productos
4. Vector de sumas
5. Bisiesto
6. Salir

21
ALGORITMO principal
DEFINIR opcion COMO ENTERO;
REPETIR
pantalla_menu();
Leer_opcion();
SEGUN Leer_opcion HACER
1: procedimiento_amigos();
2: procedimiento_sociables();
3: ESCRIBIR procedimiento_vector_productos(vector,
cota_inferior, cota_superior);
4: ESCRIBIR suma_vector(vector, cota_inferior, cota_superior);
5: bisiesto();
FINSEGUN
HASTA QUE (opcion = 6)
FINALGORITMO

SUBPROCESO pantalla_menu()
ESCRIBIR ("__");
ESCRIBIR ("__");
ESCRIBIR ("__");
FINSUBPROCESO

SUBPROCESO leer_opcion
LEER oopcion;
FINSUBPROCESO

SUBPROCESO procedimiento_amigos()
DEFINIR valor1 COMO ENTERO;
DEFINIR valor2 COMO ENTERO;
DEFINIR tecla COMO CARACTER;
REPETIR
REPETIR
LEER valor1;
LEER valor2;
HASTA QUE ((valor1 > 0) & (valor2 > 0))
SI (amigos(valor1,valor2) = 1) ENTONCES
ESCRIBIR ("Son amigos");
SINO
ESCRIBIR ("No son amigos");
FINSI
REPETIR
ESCRIBIR ("Quieres seguir s/n?");
LEER tecla;
HASTA QUE ((tecla = 's') | (tecla = 'n'))
HASTA QUE (tecla = 'n')
FINSUBPROCESO

funcion retorno <- amigos (v1, v2)

DEFINIR Retorno COMO ENTERO;
SI (suma_divisores(v1) = v2) & (suma_divisores(v2) = v1) ENTONCES
Retorno <- (1);
SINO
Retorno <- (0);

22
 FINSI
FINFUNCION

funcion suma <- suma_divisores (vvalor)

DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
Suma <- 0;
PARA indice <- 1 HASTA (v1 - 1) CON PASO 1 HACER
SI (v1 % divisor = 0) ENTONCES
Suma <- suma + indice;
FINSI
FINPARA
FINFUNCION

SUBPROCESO procedimiento_sociables()
DEFINIR cota_inferior COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DIMENSION vector[cota_inferior, cota_superior];
DEFINIR vector COMO ENTERO;
DEFINIR indice COMO ENTERO;
cota_inferior <- 1;
cota_superior <- 20;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
PARA indice_2 <- cota_inferior HASTA cota_superior CON PASO 1
HACER
LEER vector[indice, indice_2];
FINPARA
FINPARA
SI ((sociables(vector, cota_inferior, cota_superior)) = 1) ENTONCES
ESCRIBIR ("Son sociables");
SINO
ESCRIBIR ("NO son sociables");
FINSI
FINSUBPROCESO

funcion retorno <- sociables (vector, cota_inferior, cota_superior)

DEFINIR indice, retorno COMO ENTERO;
indice <- 1;
MIENTRAS (indice < cota_inferior) & (sociables(vector[indice], vector[indice
+ 1]) = 1) HACER
indice <- indice + 1;
FINMIENTRAS
SI (indice = cota_superior) & ((sociable[cota_inferior], v[cota_superior]) = 1)
ENTONCES
Retorno <- (1);
SINO
Retorno <- (0);
FINSI
FINFUNCION

funcion productos <- procedimiento_vector_productos(vector, cota_inferior,

cota_superior)
Definir indice Como Entero;
Definir producto Como Entero;

23
 Producto <- 1;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
producto <- producto * vector[indice];
FINPARA
FINFUNCION

SUBPROCESO vector_de_sumas
DEFINIR cota_inferior COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DEFINIR indice COMO ENTERO;
DIMENSION vector[cota_inferior, cota_superior];
DEFINIR vector COMO ENTERO;
Leer cota_inferior;
Leer cota_superior;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
LEER vector[indice];
FINPARA
ESCRIBIR (suma_vector(vector, cota_inferior, cota_superior));
FINSUBPROCESO

FUNCION suma <- suma_vector(vector, cota_inferior, cota_superior)

DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
Suma <- 0;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
suma <- suma + vector[indice];
FINPARA
FINFUNCION

SUBPROCESO bisiesto
DEFINIR anio COMO ENTERO;
Borrar pantalla;
ESCRIBIR ("Dame un ao");
LEER anio;
ESCRIBIR ("Dame un ao");
LEER anio;
SI (anio <= 0) ENTONCES
ESCRIBIR ("El ao no es bisiesto");
SINO
SI (anio % 400 = 0) ENTONCES
ESCRIBIR ("Es bisiesto");
SINO
SI (anio % 100 = 0) ENTONCES
ESCRIBIR ("No es bisiesto");
SINO
ESCRIBIR ("Es bisiesto");
FINSI
FINSI
FINSI
FINSUBPROCESO

FUNCION retorno <- funcion_Bisiesto(anio)

DEFINIR retorno COMO ENTERO;
SI (anio % 4 <> 0) ENTONCES

24
 Retorno <- (0);
SINO SI (anio % 400 = 0) ENTONCES
Retorno <- (1);
SINO SI (anio % 100 <> 0) ENTONCES
Retorno <- (1);
SINO
Retorno <- (0);
FINSI
FINSI
FINSI
FINFUNCION

Define una funcin que reciba un vector y devuelva el mayor de todos. (probar)

FUNCION Mayor <- mayor_vector (a, cota_inferior, cota_superior)

DEFINIR indice COMO ENTERO;
DEFINIR mayor COMO ENTERO;
mayor <- a[cota_inferior];
PARA (indice <- cota_inferior HASTA cota_superior) CON PASO 1 HACER
SI (a[indice] > mayor) ENTONCES
Mayor <- a[indice];
FINSI
FINPARA
FINFUNCION

Define una funcin que recibiendo un vector y un entero devuelva la existencia o

no de dicho entero en el vector. (probar)

SUBPROCESO retorno <- numero_vector (numero, vector, cota_inferior, cota_superior)

DEFINIR indice, retorno COMO ENTERO;
indice <- cota_inferior;
MIENTRAS (indice <= cota_superior) & (vector(indice <> numero) HACER
indice <- indice + 1;
FINMIENTRAS
SI (indice <- cota_inferior + 1) ENTONCES
Retorno <- (0);
SINO
Retorno <- (1);
FINSI
FINSUBPROCESO

Algoritmo que lea n enteros que indiquen el factorial de los primos. (no anda) (ir al
principio)

ALGORITMO vector_de_factoriales_primos
DIMENSION vector[cota_inferior, cota_superior];
DIMENSION vector_factorial[cota_inferior, cota_superior];
DEFINIR cota_superior COMO ENTERO;
DEFINIR cota_inferior COMO ENTERO;
DEFINIR indice COMO ENTERO;
Leer_valores(valor1, valor2);
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
SI (numeros_primos(vector[indice]) = 1) ENTONCES
vector_factorial[indice] <- factorial_de_un_numero (vector[indice]);

25
 FINSI
ESCRIBIR vector_factorial[indice];
FINPARA
FINALGORITMO

SUBPROCESO Leer_valores (valor1 Por Referencia, valor2 Por Referencia)

ESCRIBIR ("Introduce valor1");
LEER valor1;
ESCRIBIR ("Introduce valor2");
LEER valor2;
FINSUBPROCESO

FUNCION retorno <- numeros_primos (numero)

DEFINIR indice COMO ENTERO;
indice <- 2;
MIENTRAS (indice < numero) & (numero % indice <> 0) HACER
indice <- indice + 1;
FINMIENTRAS
SI (indice = numero) ENTONCES
Retorno <- 1;
SINO
Retorno <- 0;
FINSI
FINFUNCION

SUBPROCESO retorno <- factorial_de_un_numero (numero)

DEFINIR factorial COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR retorno COMO ENTERO;
SI (numero < 0) ENTONCES
Retorno <- -1;
SINO
SI (numero = 1) ENTONCES
Retorno <- (1);
SINO
Factorial <- 1;
FINSI
PARA indice <- 2 HASTA numero CON PASO 1 HACER
factorial <- factorial + indice;
FINPARA
Retorno <- factorial;
FINSI
FINSUBPROCESO

Algoritmo que lea n enteros almacenados en un vector sus factoriales. (no anda)
(configurar PSeInt para que permita utilizar variables para dimensionar arreglos)

ALGORITMO calcular_factorial
DIMENSION vector_entero[cota_inferior, cota_superior];
DIMENSION vector_factorial[cota_inferior, cota_superior];
DEFINIR cota_inferior COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
Borrar pantalla;
Leer_valores;

26
 PARA indice <- cota_inf HASTA cota_sup CON PASO 1 HACER
vector_factorial[indice] <- factorial_de_un_numero(vector_entero[indice]);
ESCRIBIR (vector_factorial[indice]);
FINPARA
FINALGORITMO

SUBPROCESO leer_valores
DEFINIR cota_inferior, cota_superior COMO ENTEROS;
ESCRIBIR ("introduce cotas");
LEER cota_inferior;
LEER cota_superior;
ESCRIBIR ("Rellena el vector");
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
LEER vector_entero[indice];
FINPARA
FINSUBPROCESO

SUBPROCESO retorno <- factorial_de_un_numero (numero)

DEFINIR factorial COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR retorno COMO ENTERO;
SI (numero < 0) ENTONCES
Retorno <- -1;
SINO
SI (numero = 1) ENTONCES
Retorno <- (1);
SINO
Factorial <- 1;
FINSI
PARA indice <- 2 HASTA numero CON PASO 1 HACER
factorial <- factorial + indice;
FINPARA
Retorno <- factorial;
FINSI
FINSUBPROCESO

Leer una secuencia y determinar la longitud de la palabra (no anda)

SUBPROCESO contador_palabra <- palabra_mas_larga (parrafo)

DEFINIR indice COMO ENTERO;
DEFINIR contador_palabra COMO ENTERO;
DEFINIR mayor_palabra COMO ENTERO;
indice <- 0;
contador_palabra <- 0;
mayor_palabra <- 0;
MIENTRAS (parrafo[indice] <> "\o") HACER
SI (parrafo[indice] <> "\o") ENTONCES
Contador_palabra <- contador_palabra + 1;
FINSI
SI (parrafo[indice] <> "\o") & (parrafo[indice + 1] = " " | (parrafo[indice + 1] =
"\o") ENTONCES
SI(contador_palabra > mayor_palabra) ENTONCES
Mayor_palabra <- contador_palabra;
FINSI

27
 Contador_palabra <- 0;
FINSI
Indice <- indice + 1;
FINMIENTRAS
FINSUBPROCESO

Leer una secuencia y determinar la longitud de la misma. (no anda)

SUBPROCESO indice <- longitud_cadena

DEFINIR indice COMO ENTERO;
indice <- \o;
MIENTRAS (texto[indice] <> "\o") HACER
indice <- indice -1;
FINMIENTRAS
FINSUBPROCESO

Realizar una funcin que recibiendo una secuencia devuelva dicha secuencia en maysculas.
(no anda)

SUBPROCESO parrafo <- touppercase_java (parrafo)

DEFINIR indice COMO ENTERO;
DEFINIR resultado COMO SECUENCIA;
indice <- 0;
MIENTRAS (parrafo[indice] <> "\o") HACER
SI (parrafo[indice] >= "a") & (parrafo[indice] <= "z") ENTONCES
Parrafo[indice] <- convertiratexto(convertiranumero[indice] -32);
FINSI
FINMIENTRAS
FINSUBPROCESO

Definir una funcin recibiendo una secuencia cuyo fin ser el carcter "\o" que devuelva el
entero que representa. (no anda) (ningn compilador de pseudocdigo al momento puede
hacer esto)

SUBPROCESO retorno <- simula_autoi (texto)

DEFINIR V_a[1.longitud(texto) + 1] COMO CARACTER;
DEFINIR indice COMO ENTERO;
DEFINIR acumulador COMO ENTERO;
DEFINIR indice2 COMO ENTERO;
DEFINIR retorno COMO ENTERO;
indice <- 0;
MIENTRAS (texto[indice] <> "\o") & (texto[indice] >= "\o") & (texto[indice] <= "9")
V_a[indice + 1] <- texto[indice];
indice <- indice + 1;
FINMIENTRAS
V_a[indice] <- "\o";
acumulador <- 0;
PARA indice2 <- 0 HASTA indice-1 CON PASO 1 HACER
Acumulador <- acumulador + (convertiranumero(v_a[indice2]) 45) * (10^(indice
indice2));
FINPARA
retorno <- acumulador;
FINSUBPROCESO

28
Dada una secuencia mostrar por pantalla el numero de apariciones del codigo ascii. (no anda)
(probar en cdigo fuente)

SUBPROCESO apariciones (texto)

DEFINIR ascii[255] COMO ENTERO;
DEFINIR indice COMO ENTERO;
PARA indice <- 0 HASTA 254 CON PASO 1 HACER
ascii[indice] <- 0;
FINPARA
PARA indice = 0 HASTA longitud(texto) CON PASO 1 HACER
ascii (convertiranumero(texto[indice])) <- (ascii[convertiranumero(texto[indice])) +1
FINPARA
PARA indice <- 0 HASTA 255 CON PASO 1 HACER
ESCRIBIR ("El codigo ascii"), indice, (", ascii[indice]);
FINPARA
FINSUBPROCESO

29
Ejercicios de Pseudocdigo Parte 2
27. Leer una secuencia de nmeros y mostrar la suma de los pares y el producto de
los que son mltiplo de 5.
28. Leer una secuencia de nmeros y determinar el mayor de los pares ledos. anda
29. Leer una secuencia de nmeros y mostrar el mayor de los mltiplos de 5 ledos y
el menor de los mltiplos de 3 ledos.
30. Leer una secuencia de letras y mostrar la suma de sus cdigos ASCII.
Suponemos que tenemos la funcin convertiranumero(caracter)=entero. PSeInt
no puede hacer eso (no anda)
31. Dado un vector de 5 enteros actualizar cada posicin de dicho vector con un
nmero ledo y mostrarla en pantalla.
32. Leer una secuencia de 20 nmeros almacenarlos en un vector y mostrar la
posicin donde se encuentra el mayor valor ledo.
33. Dado dos vectores A y B de 15 elementos cada uno, obtener un vector C donde
la posicin i se almacene la suma de A[i]+B[i].
34. Dado dos vectores A y B de 15 elementos cada uno, obtener un vector C donde
la posicin i se almacene la suma de A[i]+B[i] y mostrar el mayor de los C[i].
35. Dado una secuencia de nmero ledos y almacenados en un vector A mostrar
dichos nmeros en orden.
36. Dado una secuencia de nmero ledos y almacenados en un vector A y un
nmero ledo determinar si dicho nmero se encuentra o no en el vector.
37. Leer una secuencia de 20 nmeros y almacenar en un vector sus factoriales y
mostrarlos en pantalla.
38. Leer 20 nmeros y almacenarlos de manera ordenada en un vector y mostrar
dicho vector en pantalla.
39. Dado dos matrices A y B obtener la suma y mostrarla en pantalla.
40. Dado una matriz determinar la posicin (i,j) del mayor y mostrarla en pantalla.
41. Dado una matriz determinar la posicin (i,j) del mayor y menor y mostrarla en
pantalla.
42. Leer un nmero y una letra si la letra es B mostrar el valor en binario, si es O en
octal y si es H en hexadecimal. Resultado muchas veces incorrecto, problema
de cdigo (ir al cdigo)
43. Leer una secuencia de 20 nmeros almacenarlos en un vector A[20] y mostrar la
suma de los elementos que ocupan posiciones pares y el mayor de los que
ocupan posiciones impares.
44. Dada una matriz A[4,5] realiza la ordenacin de la misma (y mostrarla ordenada
por pantalla).
45. Dada una matriz A[4,5] realiza el proceso de ordenar solo por filas.
46. Dado un vector de nmeros determina aquellos que sea primos.

Ir a Ejercicios de Pseudocdigo Parte 1

Para programacin modular siga este enlace

30
ALGORITMO ejercicio_27
DEFINIR numero COMO ENTERO;
DEFINIR producto COMO ENTERO;
DEFINIR sumapares COMO ENTERO;
numero <- 0;
producto <- 1;
sumapares <- 0;
MIENTRAS numero <> -1 HACER
LEER numero;
SI (numero % 2 = 0) ENTONCES //preguntar si es par
sumapares <- sumapares + numero; // sumar numero a numero de pares
SINO SI (numero % 5 = 0) ENTONCES
producto<-producto*numero;
LEER numero;
FINSI
FINSI
FINMIENTRAS

ESCRIBIR (sumapares);
ESCRIBIR (producto);
FINALGORITMO

ALGORITMO ejercicio_28
DEFINIR MAX COMO ENTERO;
MAX<-5;

DEFINIR indice COMO ENTERO;

DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;

indice<-0;
numero<-0;
mayor<-0;

MIENTRAS (indice <MAX) HACER

indice<-indice+1;
ESCRIBIR ("Introduzca NUMERO");
LEER numero;
SI ((indice%2)=0) ENTONCES
SI (numero>mayor) ENTONCES
mayor<-numero;
FINSI
FINSI
FINMIENTRAS
ESCRIBIR (mayor);
FINALGORITMO

//Adaptado a PSeInt desde cdigo que se encuentra en

http://dis.um.es/~lopezquesada/documentos/FP0405/Proyecto/web4/webalgo/page22b.h
tm

ALGORITMO ejercicio_29
DEFINIR MAX COMO ENTERO;
DEFINIR indice COMO ENTERO;

31
 DEFINIR numero COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR menor COMO ENTERO;
MAX<-10;
indice<-0; //inicializar ndice en 0
numero<-0;
mayor<-0;
menor<-0;
MIENTRAS (indice <MAX) HACER
indice<-indice+1;
ESCRIBIR ("Introduzca NUMERO");
LEER numero;
SI (indice%5=0) ENTONCES //Si numero del ndice es mltiplo de 5
SI (numero>mayor) ENTONCES //si nuevo mayor que ingresa es
todava mayor al mayor actual
mayor<-numero; //numero ingresado es nuevo mayor
FINSI
FINSI

SI (indice%3=0) ENTONCES //Si numero del ndice es mltiplo de 3

SI (numero<menor) ENTONCES //si nuevo menor que ingresa es
todava menor al menor actual
menor<-numero; //numero ingresado es nuevo menor
FINSI //cerrar si
FINSI //cerrar si

FINMIENTRAS
ESCRIBIR (mayor);
ESCRIBIR (menor);

FINALGORITMO
//Corregido y adaptado a PSeInt desde cdigo que se encuentra en
http://dis.um.es/~lopezquesada/documentos/FP0405/Proyecto/web4/webalgo/page32.ht
m

ALGORITMO ejercicio_30

PSeInt no puede hacer eso.

ALGORITMO ejercicio_31
DIMENSION n[5];
DEFINIR n COMO ENTERO;
DEFINIR indice COMO ENTERO;
PARA indice <- 0 HASTA 4 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER indice;
FINPARA
ESCRIBIR indice;
FINALGORITMO

ALGORITMO ejercicio_32
DEFINIR n COMO ENTERO;
DIMENSION n[20];

32
 DEFINIR mayor_indice COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR mayor COMO ENTERO;
PARA indice <-0 HASTA 19 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER indice;
FINPARA
Mayor <- n[1];
PARA indice <-0 HASTA 19 CON PASO 1 HACER
SI (n[indice] > mayor) ENTONCES
mayor_indice <-indice;
FINSI
FINPARA
ESCRIBIR (mayor_indice);
FINALGORITMO

ALGORITMO ejercicio_33
DIMENSION A[16] ;
DIMENSION B[16];
DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
DIMENSION C[16];
DEFINIR A, B, C COMO ENTEROS;

PARA indice <- 1 HASTA 15 CON PASO 1 HACER

ESCRIBIR ("Introduce un nmero para el vector A");
LEER A[indice];
ESCRIBIR ("Introduce un nmero para el vector B");
LEER B[indice];
FINPARA
PARA indice <- 1 HASTA 15 CON PASO 1 HACER
Suma <- A[indice] + B[indice];
C[indice] <- suma;
FINPARA
PARA indice <- 1 HASTA 15 CON PASO 1 HACER
ESCRIBIR C[indice];
FINPARA
FINALGORITMO

ALGORITMO ejercicio_34
DIMENSION A[16];
DIMENSION B[16];
DIMENSION C[16];
DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR mayor_indice COMO ENTERO;
DEFINIR A, B, C COMO ENTEROS;

PARA indice <- 1 HASTA 15 CON PASO 1 HACER

ESCRIBIR ("Introduce un nmero para el vector A");
LEER A[indice];
FINPARA
PARA indice <-1 HASTA 15 CON PASO 1 HACER

33
 ESCRIBIR ("Introduce un nmero para el vector B");
LEER B[indice];
FINPARA
PARA indice <-1 HASTA 15 CON PASO 1 HACER
suma <- A[indice] + B[indice];
C[indice] <- suma;
FINPARA
mayor <- C[1];
mayor_indice <- 1;
PARA indice <-1 HASTA 15 CON PASO 1 HACER
SI (C[indice] > mayor) ENTONCES
mayor_indice <- indice;
mayor <- C[indice];
FINSI
FINPARA
ESCRIBIR (mayor);
ESCRIBIR (mayor_indice);
FINALGORITMO

ALGORITMO ejercicio_35
DEFINIR intercambio COMO ENTERO;
DIMENSION n[15];
DEFINIR intermedio COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR n COMO ENTERO;
PARA indice <-0 HASTA 14 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER n[indice];
FINPARA
REPETIR
intercambio <- 0;
PARA indice <-0 HASTA 14 CON PASO 1 HACER
SI (n[indice] > n[indice + 1]) ENTONCES
intermedio <- n[indice];
n[indice] <- n[indice + 1];
n[indice + 1] <- intermedio;
intercambio <- 1;
FINSI
FINPARA
HASTA QUE (intercambio = 0)
FINALGORITMO

ALGORITMO ejercicio_36
DIMENSION A[10];
DEFINIR numero COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR A COMO ENTERO;

PARA indice <-0 HASTA 9 CON PASO 1 HACER

ESCRIBIR ("Introduce un nmero");
LEER A[indice];
FINPARA
indice <-1;
MIENTRAS (indice < 11) & (numero <> A[indice]) HACER

34
 indice <-indice + 1;
FINMIENTRAS
SI (indice <-11) ENTONCES
ESCRIBIR ("No est");
SINO
ESCRIBIR ("Existe");
FINSI
FINALGORITMO

ALGORITMO ejercicio_37
DIMENSION n[10];
DEFINIR indice COMO ENTERO;
DEFINIR factorial COMO ENTERO;
DEFINIR indice1 COMO ENTERO;
DEFINIR n COMO ENTERO;
PARA indice <- 0 HASTA 9 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER n[indice];
FINPARA
PARA indice <- 0 HASTA 9 CON PASO 1 HACER
factorial <- 1;
PARA indice1 <- 3 HASTA n[indice] CON PASO 1 HACER
factorial <- factorial * indice1;
FINPARA
N[indice] <- factorial;
FINPARA
PARA indice <-0 HASTA 9 CON PASO 1 HACER
ESCRIBIR n[indice];
FINPARA
FINALGORITMO

ALGORITMO ejercicio_38
DIMENSION vector[20];
DIMENSION ordenado[20];
DEFINIR vector COMO ENTERO;
DEFINIR ordenado COMO ENTERO;
DEFINIR aux COMO ENTERO;
DEFINIR i COMO ENTERO;
DEFINIR j COMO ENTERO;
PARA i <-0 HASTA 19 CON PASO 1 HACER
LEER vector[i];
FINPARA

PARA i <- 0 HASTA 19 CON PASO 1 HACER

PARA i <- 0 HASTA 19 CON PASO 1 HACER
SI vector[i]>vector[j] ENTONCES
aux<-vector[i];
vector[i]<-vector[j];
vector[j]<-aux;
FINSI
FINPARA
FINPARA

PARA i <-0 HASTA 19 CON PASO 1 HACER

35
 ordenado[i]<-vector[i];
ESCRIBIR ordenado[i];
FINPARA
FINALGORITMO

//http://programadoraplicaciones.bichotoblog.com/programacion/continuando-con-
pseudocodigo.html

ALGORITMO ejercicio_39
// Habilitar permitir usar variables paras dimensionar arreglos en opciones de lenguaje
//Nota: Las dimensiones variables tienen que ir despus de la lectura de la cantidad de
sus elementos

DIMENSION A[5,10];
DIMENSION B[5,10];
DEFINIR A, B COMO ENTEROS;
DEFINIR suma COMO ENTERO;
DEFINIR fila COMO ENTERO;
DEFINIR columna COMO ENTERO;

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA columna <- 0 HASTA 9 CON PASO 1 HACER
LEER A[fila,columna];
FINPARA
FINPARA
PARA fila <- 0 HASTA 4 CON PASO 1 HACER
PARA columna <- 0 HASTA 9 CON PASO 1 HACER
LEER B[fila,columna];
FINPARA
FINPARA
DIMENSION suma[fila,columna];

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA columna <- 0 HASTA 9 CON PASO 1 HACER
suma[fila,columna] <- A[fila,columna] + B[fila,columna];
FINPARA
FINPARA
ESCRIBIR (suma[fila,columna]);
FINALGORITMO

//http://programador-apli.blogspot.com/2012/04/sumar-las-filas-y-columnas-de-
una.html

36
ALGORITMO ejercicio_40
DIMENSION A[5,4];
DEFINIR A COMO ENTERO;
DEFINIR fila COMO ENTERO;
DEFINIR columna COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR posicion_fila COMO ENTERO;
DEFINIR posicion_columna COMO ENTERO;

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA columna <- 0 HASTA 3 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER A[fila,columna];
FINPARA
FINPARA
Mayor <- A[1,1];
posicion_fila <- 1;
posicion_columna <- 1;
PARA fila <- 0 HASTA 4 CON PASO 1 HACER
PARA columna <- 0 HASTA 3 CON PASO 1 HACER
SI (A[fila,columna] > mayor) ENTONCES
Mayor <- A[fila,columna];
posicion_fila <- [fila];
posicion_columna <- [columna];
FINSI
FINPARA
ESCRIBIR ("El mayor es: "), mayor;
ESCRIBIR ("La posicin es: "), posicion_fila, posicion_columna;
FINPARA
FINALGORITMO

37
ALGORITMO ejercicio_41
DIMENSION A[4,3];
DEFINIR A COMO ENTERO;
DEFINIR fila COMO ENTERO;
DEFINIR columna COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR menor COMO ENTERO;
DEFINIR posicion_fila COMO ENTERO;
DEFINIR posicion_columna COMO ENTERO;
DEFINIR posicion_fila1 COMO ENTERO;
DEFINIR posicion_columna1 COMO ENTERO;

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA columna <- 0 HASTA 2 CON PASO 1 HACER
ESCRIBIR ("Introduce un numero");
LEER A[fila,columna];
FINPARA
FINPARA
Mayor <- A[1,1];
Posicion_fila <- 1;
Posicion_columna <- 1;
PARA fila <- 0 HASTA 3 CON PASO 1 HACER
PARA columna <- 0 HASTA 2 CON PASO 1 HACER
SI (A[fila,columna] > mayor) ENTONCES
Mayor <- A[fila,columna];
Posicion_fila <- [fila];
Posicion_columna <- [columna];
FINSI
FINPARA
ESCRIBIR ("El mayor es: "), mayor;
ESCRIBIR ("La posicin es: "), posicion_fila, posicion_columna;
FINPARA
Menor <- 1;
Posicion_fila1 <- 1;
Posicion_columna1 <- 1;
PARA fila <- 0 HASTA 3 CON PASO 1 HACER
PARA columna <- 0 HASTA 2 CON PASO 1 HACER
SI (A[fila,columna] < menor) ENTONCES
Menor <- A[fila,columna];
Posicion_fila1 <- [fila];
Posicion_columna1 <- [columna];
FINSI
FINPARA
FINPARA
ESCRIBIR ("El menor es: "), menor;
ESCRIBIR ("La posicin es: "), posicion_fila1, posicion_columna1;
FINALGORITMO

38
ALGORITMO ejercicio_42 //resultado muchas veces incorrecto, problema de cdigo
(ir al ndice)
DEFINIR indice COMO ENTERO;
DEFINIR pul COMO ENTERO;
DEFINIR tipo COMO CARACTER;
DEFINIR numero COMO ENTERO;
DEFINIR cociente COMO ENTERO;
DEFINIR divisor COMO ENTERO;
DEFINIR resto COMO ENTERO;
DIMENSION resultado[20];
DEFINIR resultado COMO CADENA;
ESCRIBIR ("Ingrese un nmero");
LEER numero;
ESCRIBIR ("Ingrese el tipo de base");
LEER tipo; // O,H,B
cociente <- numero;
SEGN tipo HACER
'B': divisor <- 2;
'O': divisor <- 8;
'H': divisor <- 16;
FINSEGN
pul <- 0;
REPETIR
pul <- pul + 1;
resto <- cociente % divisor;
SEGN resto HACER
10: resultado[pul] <- 'A';
11: resultado[pul] <- 'B';
12: resultado[pul] <- 'C';
13: resultado[pul] <- 'D';
14: resultado[pul] <- 'E';
15: resultado[pul] <- 'F';
De Otro Modo: resultado[pul] <- convertiratexto(resto);
FINSEGN
cociente <- trunc(cociente/divisor);
HASTA QUE (cociente = 0)
PARA indice <-pul HASTA 1 CON PASO -1 HACER
ESCRIBIR (resultado[pul]);
FINPARA
FINALGORITMO

Cdigo fuente (con errores):

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main(){
int indice;
int pul;
char tipo;
int numero;
int cociente;
int divisor;

39
 int resto;
char resultado[20];

printf ("Ingrese un nmero ");

scanf ("%d", &numero);
fflush(stdin);
printf ("Ingrese el tipo de base ");
fflush(stdin);
scanf ("%c", &tipo); // O,H,B
cociente = numero;
switch (tipo){
case 'B':
divisor = 2;
break;
case 'O':
divisor = 8;
break;
case 'H':
divisor = 16;
break;
}
pul = 0;
do{
pul = pul + 1;
resto = (int)cociente % divisor;
switch(resto){
case 10:
resultado[pul] = 'A';
break;
case 11:
resultado[pul] = 'B';
break;
case 12:
resultado[pul] = 'C';
break;
case 13:
resultado[pul] = 'D';
break;
case 14:
resultado[pul] = 'E';
break;
case 15:
resultado[pul] = 'F';
break;
default:
resultado[pul] = resto;
}
cociente = (int)cociente/divisor;
}while (cociente != 0);
for(indice = pul; indice >= 1; indice--){
printf("%d", resultado[pul]);
}
getch();
return 0;

40
}

41
ALGORITMO ejercicio_43
DIMENSION A[20]; //de 20 elementos
DEFINIR indice COMO ENTERO;
DEFINIR suma COMO ENTERO;
DEFINIR mayor COMO ENTERO;
DEFINIR A COMO ENTERO;
PARA indice <- 0 HASTA 19 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER A[indice];
FINPARA
suma <- 0;
PARA indice <- 2 HASTA 19 CON PASO 2 HACER
suma <- suma + A[indice];
FINPARA
mayor <- A[1];
PARA indice <- 0 HASTA 19 CON PASO 2 HACER
SI (A[indice] > mayor) ENTONCES
mayor <- A[indice];
FINSI
FINPARA
ESCRIBIR ("La suma es: "), suma;
ESCRIBIR ("El mayor es: "), mayor;
FINALGORITMO

42
ALGORITMO ejercicio_44
DIMENSION A[4,5];
DEFINIR A COMO ENTERO;
DEFINIR fila COMO ENTERO;
DEFINIR columna COMO ENTERO;
DIMENSION V[20];
DEFINIR V COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR intercambio COMO ENTERO;
DEFINIR intermedio COMO ENTERO;
DEFINIR saltador COMO ENTERO;

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA columna <- 0 HASTA 4 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER A[fila,columna];
FINPARA
FINPARA

saltador<-0;

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA columna <- 0 HASTA 4 CON PASO 1 HACER
//V[((fila - 1) + 5) + columna] <- A[fila,columna];
V[columna+saltador] <- A[fila,columna];
SI columna % 5 = 0 entonces
saltador<-saltador+5;
FINSi
FINPARA
FINPARA

REPETIR
Intercambio <- 0;
PARA indice <- 0 HASTA 18 CON PASO 1 HACER
SI (V[indice] > V[indice + 1]) ENTONCES
Intermedio <- V[indice];
V[indice] <- V[indice +1];
V[indice +1] <- intermedio;
Intercambio <- 1;
FINSI
FINPARA
HASTA QUE (intercambio = 0)

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA columna <- 0 HASTA 2 CON PASO 1 HACER
A[fila,columna] <- V[((fila - 1) * 5) + columna];
FINPARA
FINPARA

Para fila <- 0 HASTA 19 CON PASO 1 HACER

ESCRIBIR V[fila];
FINPARA
FINALGORITMO

43
ALGORITMO ejercicio_45
DIMENSION A[4,5];
DEFINIR intermedio COMO ENTERO;
DEFINIR intercambio COMO ENTERO;
DEFINIR fila COMO ENTERO;
DEFINIR columna COMO ENTERO;
DEFINIR A COMO ENTERO;
PARA fila <- 0 HASTA 3 CON PASO 1 HACER
PARA columna <- 0 HASTA 4 CON PASO 1 HACER
ESCRIBIR ("Introduce un nmero");
LEER A[fila,columna];
FINPARA
FINPARA
REPETIR
intercambio <- 0;
PARA fila <- 0 HASTA 3 CON PASO 1 HACER
PARA columna <- 0 HASTA 2 CON PASO 1 HACER
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;
FINSI
FINPARA
FINPARA
HASTA QUE (intercambio = 0)
PARA fila <- 0 HASTA 3 CON PASO 1 HACER
ESCRIBIR A[fila,columna];
FINPARA
FINALGORITMO

44
ALGORITMO ejercicio_46
DIMENSION A[20];
DEFINIR A COMO ENTERO;
DEFINIR indice COMO ENTERO;
DEFINIR indice1 COMO ENTERO;

PARA indice <- 0 HASTA 19 CON PASO 1 HACER

ESCRIBIR ("Introduce un nmero");
LEER A[indice];
FINPARA
PARA indice <- 0 HASTA 19 CON PASO 1 HACER
indice1 <- 2;
MIENTRAS (indice1 < A[indice]) & (A[indice] % indice1 <> 0) HACER
indice1 <- indice1 + 1;
FINMIENTRAS
SI (indice1 = A[indice]) ENTONCES
ESCRIBIR A[indice], (" es primo");
FINSI
FINPARA
FINALGORITMO

Otro ejercicio

http://programadoraplicaciones.bichotoblog.com/continu&o-con-pseudocodigo/

45