TrabajoPseu en PseInt

RUBEN
NAVARRO
CASERO
&
RAUL
MORALES
GARCIA
Corrección e implementación en PSeInt por Alejandro
Caro y discoduroderoer
© 2004
© 2012-2013
1
Ejercicios de Pseudocódigo Parte 1
Nota: Los arreglos son en base 0
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 mediante 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. anda
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
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 el
usuario pulse F.
15. Generar los N primeros términos de la serie de Fibonacci y mostrarlos por
pantalla. 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 cuáles 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. Calcular el valor del número E (Euler) =(1/n!) y mostrarlo en pantalla. (ver)
25. Implementar un programa que sea capaz de calcular el resultado de aplicar la
fórmula siguiente (n i)=n! / (i! * (n-i)!).
Véase página Ejercicios de Pseudocódigo Parte 2 para la segunda parte
2
ALGORITMO ejercicio_1
DEFINIR numero COMO ENTERO;
ESCRIBIR ("Introduce un número");

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

LEER numero_a;
ESCRIBIR ("Introduce otro número");
LEER numero_b;
ESCRIBIR (numero_a * numero_b);
FINALGORITMO
DEFINIR numero1 COMO ENTERO;
ESCRIBIR ("Introduce el número1");
LEER numero1;
ESCRIBIR ("Introduce el número2");
LEER numero2;
SI (numero1 > numero2) ENTONCES
ESCRIBIR ("El número1 es mayor", numero1);
SINO
ESCRIBIR ("El número2 es mayor", numero2);
SI (numero1 = numero2) ENTONCES
ESCRIBIR ("Los números son iguales");
FINSI
FINSI
FINALGORITMO
3
ESCRIBIR ("Introduce número1");
LEER numero1;
LEER numero2;
LEER numero3;
ESCRIBIR ("El número1 es el mayor");
SINO
SINO
FINSI
FINSI
FINSI
FINALGORITMO
DEFINIR indice COMO ENTERO;
DEFINIR cota_superior COMO ENTERO;
DEFINIR cota_inferior COMO ENTERO;
cota_inferior <- 1;
cota_superior <- 10;
indice <- 1;
ESCRIBIR "Ingrese un número";

LEER numero;
PARA indice <- cota_inferior HASTA cota_superior CON PASO 1 HACER
ESCRIBIR numero ,(" * "), indice ,(" = "), numero*indice;
FINPARA
FINALGORITMO
4
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
suma <- 0;
LEER numero;
MIENTRAS (numero > 0) HACER
suma <- suma +numero;
LEER numero;
FINMIENTRAS
ESCRIBIR ("la suma es:"), suma;
FINALGORITMO
DEFINIR a COMO ENTERO;
DEFINIR b COMO ENTERO;
DEFINIR Multi COMO ENTERO;
ESCRIBIR ("introduce el primer número");
LEER a;
ESCRIBIR ("introduce el segundo número");
LEER b;
multi <- 0;
PARA indice <-b HASTA 1 CON PASO -1 HACER
multi <- multi + a;
FINPARA
ESCRIBIR (multi), " "; //apretar alt + 01
FINALGORITMO
5
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
DEFINIR ffin COMO CARACTER;
DEFINIR limite COMO CARACTER;
Limite <- "f";
Producto <- 1;
REPETIR
ESCRIBIR ("Introduce el número");
LEER numero;
ESCRIBIR ("¿Seguir? f = no s = si\n");
LEER ffin;
producto <- producto * numero;
HASTA QUE (ffin = limite)
ESCRIBIR ("el producto de los números es: "), producto;
FINALGORITMO
6
DEFINIR mayor COMO ENTERO;
DEFINIR final COMO CARACTER;
ffin <-"F";
mayor <- 0;
REPETIR
LEER numero;
LEER final;
SI (numero > mayor) ENTONCES
mayor <- numero;
FINSI
HASTA QUE (final = ffin)
ESCRIBIR ("El mayor es:"), mayor;
FINALGORITMO
DEFINIR contador COMO ENTERO;
DEFINIR binario COMO CADENA;
DEFINIR digito COMO CADENA;
DEFINIR decimal 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 solución)
ALGORITMO ejercicio_12_ii
DEFINIR num COMO ENTERO;
DEFINIR cad COMO CADENA;
ESCRIBIR ("Ingrese un número 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 números mayores a cero");
FINSI
FINSI
FINALGORITMO
suma <- 0;
SI (indice % 5 = 0) ENTONCES
suma <- suma + indice;
FINSI
FINPARA
ESCRIBIR ("La suma es: "), suma;
FINALGORITMO
DEFINIR media COMO ENTERO;
suma <- 0;
contador <- 0;
media <- 0;
LEER numero;
MIENTRAS (numero <> 0) HACER
contador <- contador + 1;
8
LEER numero;
FINMIENTRAS
media <- suma/contador;
ESCRIBIR suma, " ";
ESCRIBIR media;
FINALGORITMO
DEFINIR intercambio COMO ENTERO;
DEFINIR n_1 COMO ENTERO;
DEFINIR n_2 COMO ENTERO;
REPETIR
LEER numero;
HASTA QUE (numero > 0)
SI (numero = 1) ENTONCES
ESCRIBIR ("a1 <- 1");
SINO
SINO
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
DEFINIR menor COMO ENTERO;
LEER numero;
MIENTRAS (numero % 2 = 0) HACER
mayor <- numero;
menor <- numero;
mayor <- numero;
SINO
SI (numero < menor) ENTONCES
menor <- numero;
9
FINSI
FINSI
FINMIENTRAS
FINMIENTRAS
FINALGORITMO
suma <- 0;
LEER numero;
LEER numero;
FINSI
FINMIENTRAS
ESCRIBIR (suma);
FINALGORITMO
DEFINIR caracter COMO ENTERO;
contador <- 0;
ESCRIBIR ("Introduce el primer número");
REPETIR
LEER numero;
ESCRIBIR (numero);
FINSI
HASTA QUE (contador = 30)
FINALGORITMO
DEFINIR posicion COMO ENTERO;
suma <- 0;
posicion <- 0;
MIENTRAS (indice <= 30) HACER
ESCRIBIR ("introduce un número");
LEER numero;
posicion <- posicion + 1;
SI (posicion % 2 = 0 ) ENTONCES
FINSI
FINMIENTRAS
ESCRIBIR (suma);
10
FINALGORITMO
DEFINIR factorial COMO ENTERO;

LEER numero;
SI (numero < 0) ENTONCES
ESCRIBIR ();
SINO SI (numero = 0) ENTONCES
ESCRIBIR ("El factorial de 0 es 1");
SINO
factorial <- 1;
factorial <- factorial * numero;
FINPARA
ESCRIBIR ("El resultado es: "), factorial;
FINSI
FINSI
FINALGORITMO
DEFINIR n COMO ENTERO;
DEFINIR encontrado COMO LOGICO;

LEER n;
encontrado <- falso;
contador <- 2;
MIENTRAS (contador <= n-1) & (n % contador <> 0) HACER
FINMIENTRAS
SI (contador <= n-1 ) ENTONCES
ESCRIBIR ("el número no es primo");
SINO
ESCRIBIR ("el número es primo");
FINSI
FINALGORITMO
suma <- 0;
LEER numero;
contador <- 2;
MIENTRAS (contador <= n-1) & (n % contador = 0) HACER
11
FINMIENTRAS
SI (contador = n ) ENTONCES
FINSI
FINPARA
FINALGORITMO
n <- 0;
contador <- 0;
suma <- 0;
REPETIR
REPETIR
LEER numero;
HASTA QUE (n >= 0)
factorial <- 1;
factorial <- factorial * numero;
FINPARA
suma <- suma + factorial;
HASTA QUE (contador = 30)
ESCRIBIR ("la suma es:"), suma;
FINALGORITMO
SUBPROCESO suma <- factorial ( numero )

suma<-numero;
PARA contador<-numero-1 HASTA 1 CON PASO -1 HACER
suma<-suma*contador;
FINPARA
FINSUBPROCESO
DEFINIR e, n, numero COMO REALES;
e<-1;
ESCRIBIR "Ingrese la cantidad de cifras para el límite 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
DEFINIR suma, contador COMO ENTERO;
suma<-numero;
FINPARA
FINSUBPROCESO
//http://www.discoduroderoer.es/ejercicios-de-funciones-pseudocodigo/
DEFINIR resultado COMO ENTERO;
DEFINIR i COMO ENTERO;
REPETIR
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

DEFINIR suma, contador COMO ENTERO;
suma<-numero;
FINPARA
FINSUBPROCESO
13
1. Desarrolle un algoritmo (Pseudocó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 ecuació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 obtener los dos más 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 también
los que 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.
14
ALGORITMO ejercicio_a
ffin <- "F";
contador <- 1;
mayor <- 0;
REPETIR
LEER numero;
LEER fin;
contador <- 1;
mayor <- numero;
ESCRIBIR numero ,("es el mayor");
SINO
FINSI
ESCRIBIR ("Aparece:"), contador ,("veces");
FINALGORITMO
ALGORITMO ejercicio_b
DEFINIR palabra COMO CARACTER;
DEFINIR ffin COMO ENTERO;
ffin <- "F";
contador <- 1;
mayor <- 0;
REPETIR
ESCRIBIR ("Introduce una palabra");
LEER palabra;
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
contador <- 0;
suma <- 0;
ESCRIBIR ("cuantos números quieres leer");
LEER cota_superior;
REPETIR
LEER numero;
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 ffin COMO CADENA;
DEFINIR limite COMO CADENA;
limite <- "F";
16
ffin <- limite;
Contador <- 1;
Mayor <- 0;
REPETIR
LEER numero;
ESCRIBIR ("Si quieres finalizar pulsa F (solo ingrese F o N)");
LEER ffin;
Contador <- 1;
Mayor <- numero;
ESCRIBIR numero ,(" es el mayor");
SINO
ESCRIBIR ("El mayor es: "),mayor;
FINSI
ESCRIBIR ("El mayor es:"),mayor;
ESCRIBIR ("Aparece: "),contador ,(" veces");
FINALGORITMO
ALGORITMO ejercicio_f
DEFINIR decimal COMO ENTERO;
contador <- 0;
REPETIR
LEER decimal;
HASTA QUE (decimal >= 0) | (contador = 5)
SI (contador = 5) ENTONCES
ESCRIBIR ("sobrepasa el número de errores");
SINO
cociente <- decimal;
MIENTRAS (cociente <> 0) HACER
ESCRIBIR (cociente % 10);
cociente <- trunc(cociente/10);
FINMIENTRAS
FINSI
FINALGORITMO
ALGORITMO ejercicio_g
REPETIR
LEER numero;
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 limite1 COMO CARACTER;
DEFINIR limite2 COMO CARACTER;
Limite1 <- "N";

Limite2 <- "S";
REPETIR
LEER numero;
SI (numero % indice <-0) ENTONCES
ESCRIBIR ("Un divisor es: "), indice;
SINO
FINSI
FINPARA
REPETIR
ESCRIBIR ("¿Quieres seguir? (S/N)");
LEER ffin;
HASTA QUE (ffin = limite1) | (fin = limite2)
MIENTRAS (ffin = limite2) HACER
SI (numero % indice <-0) ENTONCES
ESCRIBIR ("Un divisor es:"), indice;
SINO
FINSI
FINPARA
REPETIR
ESCRIBIR ("¿Quieres seguir? (S/N)");
LEER ffin;
HASTA QUE (ffin = limite1) | (ffin = limite2)
FINMIENTRAS
FINALGORITMO
18
Programación modular (algunos no andan)
i Calcular el mayor de dos valores introducidos mediante el teclado utilizando
programación modular. (ir al código)
Leer un número y mostrar su tabla de multiplicar (ir al código)
Realizar un algoritmo que muestre el siguiente menú. No anda (ir al código)
a. Amigos
b. Sociables
c. Vector de productos
d. Vector de sumas
e. Bisiesto
f. Salir
j Define una función que reciba un vector y devuelva el mayor de todos. No anda (ir a
código)
k Define una función 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
código)
(Ir a códigos parte 2)
19
Calcular el mayor de dos valores introducidos mediante el teclado utilizando
programación modular. (hecho sin usar variables globales) (volver al índice)
ALGORITMO ejercicio_i
DEFINIR valor1 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;
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 número y mostrar su tabla de multiplicar (hecho sin usar variables

globales) (volver al índice)
ALGORITMO principal
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)
ESCRIBIR "Introduce el número 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)
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 código 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 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)

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()
DIMENSION vector[cota_inferior, cota_superior];
DEFINIR vector COMO ENTERO;
cota_inferior <- 1;
cota_superior <- 20;
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;
producto <- producto * vector[indice];
FINPARA
FINFUNCION
SUBPROCESO vector_de_sumas
Leer cota_inferior;
Leer cota_superior;
LEER vector[indice];
FINPARA
ESCRIBIR (suma_vector(vector, cota_inferior, cota_superior));
FINSUBPROCESO
FUNCION suma <- suma_vector(vector, cota_inferior, cota_superior)

Suma <- 0;
suma <- suma + vector[indice];
FINPARA
FINFUNCION
SUBPROCESO bisiesto
DEFINIR anio COMO ENTERO;
Borrar pantalla;
ESCRIBIR ("Dame un año");
LEER anio;
ESCRIBIR ("Dame un año");
LEER anio;
SI (anio <= 0) ENTONCES
ESCRIBIR ("El año 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)

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 función que reciba un vector y devuelva el mayor de todos. (probar)
FUNCION Mayor <- mayor_vector (a, cota_inferior, cota_superior)

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 función 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
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_factorial[cota_inferior, cota_superior];
Leer_valores(valor1, valor2);
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)

LEER valor1;
LEER valor2;
FINSUBPROCESO
FUNCION retorno <- numeros_primos (numero)

indice <- 2;
MIENTRAS (indice < numero) & (numero % indice <> 0) HACER
FINMIENTRAS
SI (indice = numero) ENTONCES
Retorno <- 1;
SINO
Retorno <- 0;
FINSI
FINFUNCION
SUBPROCESO retorno <- factorial_de_un_numero (numero)

Retorno <- -1;
SINO
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];
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");
LEER vector_entero[indice];
FINPARA
FINSUBPROCESO
SUBPROCESO retorno <- factorial_de_un_numero (numero)

Retorno <- -1;
SINO
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 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

indice <- \o;
MIENTRAS (texto[indice] <> "\o") HACER
indice <- indice -1;
FINMIENTRAS
FINSUBPROCESO
Realizar una función que recibiendo una secuencia devuelva dicha secuencia en mayúsculas.
(no anda)
SUBPROCESO parrafo <- touppercase_java (parrafo)

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 función recibiendo una secuencia cuyo fin será el carácter "\o" que devuelva el
entero que representa. (no anda) (ningún compilador de pseudocódigo al momento puede
hacer esto)
SUBPROCESO retorno <- simula_autoi (texto)

DEFINIR V_a[1.longitud(texto) + 1] COMO CARACTER;
DEFINIR acumulador COMO ENTERO;
DEFINIR indice2 COMO ENTERO;
indice <- 0;
MIENTRAS (texto[indice] <> "\o") & (texto[indice] >= "\o") & (texto[indice] <= "9")
V_a[indice + 1] <- texto[indice];
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 código fuente)
SUBPROCESO apariciones (texto)

DEFINIR ascii[255] 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
ESCRIBIR ("El codigo ascii"), indice, (", ascii[indice]);
FINPARA
FINSUBPROCESO
29
Ejercicios de Pseudocódigo Parte 2
27. Leer una secuencia de números y mostrar la suma de los pares y el producto de
los que son múltiplo de 5.
28. Leer una secuencia de números y determinar el mayor de los pares leídos. anda
29. 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.
30. Leer una secuencia de letras y mostrar la suma de sus códigos ASCII.
Suponemos que tenemos la función convertiranumero(caracter)=entero. PSeInt
no puede hacer eso (no anda)
31. Dado un vector de 5 enteros actualizar cada posición de dicho vector con un
número leído y mostrarla en pantalla.
32. Leer una secuencia de 20 números almacenarlos en un vector y mostrar la
posición donde se encuentra el mayor valor leído.
33. 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].
34. 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].
35. Dado una secuencia de número leídos y almacenados en un vector A mostrar
dichos números en orden.
36. 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.
37. Leer una secuencia de 20 números y almacenar en un vector sus factoriales y
mostrarlos en pantalla.
38. Leer 20 números 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 posición (i,j) del mayor y mostrarla en pantalla.
41. Dado una matriz determinar la posición (i,j) del mayor y menor y mostrarla en
pantalla.
42. 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. Resultado muchas veces incorrecto, problema
de código (ir al código)
43. Leer una secuencia de 20 números 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 ordenación 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 números determina aquellos que sea primos.
Ir a Ejercicios de Pseudocódigo Parte 1

Para programación modular siga este enlace
30
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
DEFINIR MAX COMO ENTERO;
MAX<-5;

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 código que se encuentra en

http://dis.um.es/~lopezquesada/documentos/FP0405/Proyecto/web4/webalgo/page22b.h
tm
DEFINIR MAX COMO ENTERO;
31
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 múltiplo de 5
SI (numero>mayor) ENTONCES //si nuevo mayor que ingresa es
todavía mayor al mayor actual
mayor<-numero; //numero ingresado es nuevo mayor
FINSI
FINSI
SI (indice%3=0) ENTONCES //Si numero del índice es múltiplo de 3

SI (numero<menor) ENTONCES //si nuevo menor que ingresa es
todavía 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 código que se encuentra en
http://dis.um.es/~lopezquesada/documentos/FP0405/Proyecto/web4/webalgo/page32.ht
m
PSeInt no puede hacer eso.
DIMENSION n[5];
LEER indice;
FINPARA
ESCRIBIR indice;
FINALGORITMO
DIMENSION n[20];
32
DEFINIR mayor_indice COMO ENTERO;
LEER indice;
FINPARA
Mayor <- n[1];
SI (n[indice] > mayor) ENTONCES
mayor_indice <-indice;
FINSI
FINPARA
ESCRIBIR (mayor_indice);
FINALGORITMO
DIMENSION A[16] ;
DIMENSION B[16];
DIMENSION C[16];
DEFINIR A, B, C COMO ENTEROS;

ESCRIBIR ("Introduce un número para el vector A");
LEER A[indice];
ESCRIBIR ("Introduce un número para el vector B");
LEER B[indice];
FINPARA
Suma <- A[indice] + B[indice];
C[indice] <- suma;
FINPARA
ESCRIBIR C[indice];
FINPARA
FINALGORITMO
DIMENSION A[16];
DIMENSION B[16];
DIMENSION C[16];
DEFINIR mayor_indice COMO ENTERO;
DEFINIR A, B, C COMO ENTEROS;

ESCRIBIR ("Introduce un número para el vector A");
LEER A[indice];
FINPARA
33
ESCRIBIR ("Introduce un número para el vector B");
LEER B[indice];
FINPARA
suma <- A[indice] + B[indice];
C[indice] <- suma;
FINPARA
mayor <- C[1];
mayor_indice <- 1;
SI (C[indice] > mayor) ENTONCES
mayor_indice <- indice;
mayor <- C[indice];
FINSI
FINPARA
ESCRIBIR (mayor);
ESCRIBIR (mayor_indice);
FINALGORITMO
DIMENSION n[15];
DEFINIR intermedio COMO ENTERO;
LEER n[indice];
FINPARA
REPETIR
intercambio <- 0;
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
DIMENSION A[10];
DEFINIR A COMO ENTERO;

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
DIMENSION n[10];
LEER n[indice];
FINPARA
factorial <- 1;
PARA indice1 <- 3 HASTA n[indice] CON PASO 1 HACER
factorial <- factorial * indice1;
FINPARA
N[indice] <- factorial;
FINPARA
ESCRIBIR n[indice];
FINPARA
FINALGORITMO
DIMENSION vector[20];
DIMENSION ordenado[20];
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
// Habilitar permitir usar variables paras dimensionar arreglos en opciones de lenguaje
//Nota: Las dimensiones variables tienen que ir después de la lectura de la cantidad de
sus elementos
DIMENSION A[5,10];
DIMENSION B[5,10];
DEFINIR A, B COMO ENTEROS;
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
LEER B[fila,columna];
FINPARA
FINPARA
DIMENSION suma[fila,columna];

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
DIMENSION A[5,4];
DEFINIR posicion_fila COMO ENTERO;
DEFINIR posicion_columna COMO ENTERO;

FINPARA
FINPARA
Mayor <- A[1,1];
posicion_fila <- 1;
posicion_columna <- 1;
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 posición es: "), posicion_fila, posicion_columna;
FINPARA
FINALGORITMO
37
DIMENSION A[4,3];
DEFINIR posicion_fila COMO ENTERO;
DEFINIR posicion_columna COMO ENTERO;
DEFINIR posicion_fila1 COMO ENTERO;
DEFINIR posicion_columna1 COMO ENTERO;

ESCRIBIR ("Introduce un numero");
FINPARA
FINPARA
Mayor <- A[1,1];
Posicion_fila <- 1;
Posicion_columna <- 1;
SI (A[fila,columna] > mayor) ENTONCES
Mayor <- A[fila,columna];
Posicion_fila <- [fila];
Posicion_columna <- [columna];
FINSI
FINPARA
ESCRIBIR ("La posición es: "), posicion_fila, posicion_columna;
FINPARA
Menor <- 1;
Posicion_fila1 <- 1;
Posicion_columna1 <- 1;
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 posición es: "), posicion_fila1, posicion_columna1;
FINALGORITMO
38
ALGORITMO ejercicio_42 //resultado muchas veces incorrecto, problema de código
(ir al índice)
DEFINIR pul COMO ENTERO;
DEFINIR tipo COMO CARACTER;
DEFINIR divisor COMO ENTERO;
DEFINIR resto COMO ENTERO;
DIMENSION resultado[20];
DEFINIR resultado COMO CADENA;
ESCRIBIR ("Ingrese un número");
LEER numero;
ESCRIBIR ("Ingrese el tipo de base");
LEER tipo; // O,H,B
cociente <- numero;
SEGÚN tipo HACER
'B': divisor <- 2;
'O': divisor <- 8;
'H': divisor <- 16;
FINSEGÚN
pul <- 0;
REPETIR
pul <- pul + 1;
resto <- cociente % divisor;
SEGÚN 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);
FINSEGÚN
cociente <- trunc(cociente/divisor);
HASTA QUE (cociente = 0)
PARA indice <-pul HASTA 1 CON PASO -1 HACER
ESCRIBIR (resultado[pul]);
FINPARA
FINALGORITMO
Código 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 n£mero ");

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
DIMENSION A[20]; //de 20 elementos
LEER A[indice];
FINPARA
suma <- 0;
suma <- suma + A[indice];
FINPARA
mayor <- A[1];
SI (A[indice] > mayor) ENTONCES
mayor <- A[indice];
FINSI
FINPARA
ESCRIBIR ("La suma es: "), suma;
FINALGORITMO
42
DIMENSION A[4,5];
DIMENSION V[20];
DEFINIR V COMO ENTERO;
DEFINIR saltador COMO ENTERO;

FINPARA
FINPARA
saltador<-0;

//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;
SI (V[indice] > V[indice + 1]) ENTONCES
Intermedio <- V[indice];
V[indice] <- V[indice +1];
V[indice +1] <- intermedio;
Intercambio <- 1;
FINSI
FINPARA

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
DIMENSION A[4,5];
FINPARA
FINPARA
REPETIR
intercambio <- 0;
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
ESCRIBIR A[fila,columna];
FINPARA
FINALGORITMO
44
DIMENSION A[20];

LEER A[indice];
FINPARA
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

TrabajoPseu en PseInt

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TrabajoPseu en PseInt

Transféré par

Droits d'auteur :

Formats disponibles

RUBEN

1. Leer un número y mostrar por la salida estándar si dicho número es o no es par.

Véase página Ejercicios de Pseudocódigo Parte 2 para la segunda parte

ESCRIBIR ("Introduce un número");

ESCRIBIR ("Introduce un número");

ESCRIBIR "Ingrese un número";

ESCRIBIR ("introduce el dividendo");

Limite <- "f";

MIENTRAS (cociente<> 0) HACER

ESCRIBIR ("introduce un número");

ESCRIBIR ("introduce un número");

SUBPROCESO suma <- factorial ( numero )

SUBPROCESO suma <- factorial ( numero )

ffin <- "F";

ffin <- "F";

ESCRIBIR ("Introduce b");

Limite1 <- "N";

SUBPROCESO Leer_valores (valor1 Por Referencia, valor2 Por Referencia)

SUBPROCESO retorno <- mayor (valor1, valor2)

Leer un número y mostrar su tabla de multiplicar (hecho sin usar variables

SUBPROCESO retorno <- leer_valores(numero Por Referencia, cota_superior

SUBPROCESO Tabla_multiplicar(numero Por Referencia, cota_superior Por

funcion retorno <- amigos (v1, v2)

funcion suma <- suma_divisores (vvalor)

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

funcion productos <- procedimiento_vector_productos(vector, cota_inferior,

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

FUNCION retorno <- funcion_Bisiesto(anio)

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

Define una función que recibiendo un vector y un entero devuelva la existencia o

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

SUBPROCESO Leer_valores (valor1 Por Referencia, valor2 Por Referencia)

FUNCION retorno <- numeros_primos (numero)

SUBPROCESO retorno <- factorial_de_un_numero (numero)

SUBPROCESO retorno <- factorial_de_un_numero (numero)

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

SUBPROCESO contador_palabra <- palabra_mas_larga (parrafo)

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

SUBPROCESO indice <- longitud_cadena

SUBPROCESO parrafo <- touppercase_java (parrafo)

SUBPROCESO retorno <- simula_autoi (texto)

SUBPROCESO apariciones (texto)

Ir a Ejercicios de Pseudocódigo Parte 1

DEFINIR indice COMO ENTERO;

MIENTRAS (indice <MAX) HACER

//Adaptado a PSeInt desde código que se encuentra en

SI (indice%3=0) ENTONCES //Si numero del índice es múltiplo de 3

PSeInt no puede hacer eso.

PARA indice <- 1 HASTA 15 CON PASO 1 HACER

PARA indice <- 1 HASTA 15 CON PASO 1 HACER

PARA indice <-0 HASTA 9 CON PASO 1 HACER

PARA i <- 0 HASTA 19 CON PASO 1 HACER

PARA i <-0 HASTA 19 CON PASO 1 HACER

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA fila <- 0 HASTA 4 CON PASO 1 HACER

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

Código fuente (con errores):

printf ("Ingrese un n£mero ");

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

PARA fila <- 0 HASTA 3 CON PASO 1 HACER

Para fila <- 0 HASTA 19 CON PASO 1 HACER