Algoritmos

Facultad de Ingeniería de Sistemas, Cómputo y
Telecomunicaciones
Sistema a Distancia
ALGORITMOS
Un enfoque práctico
FRANKLIN ARRIOLA RAMÍREZ

YULIANA JÁUREGUI ROSAS
2009
Algoritmos: Un enfoque práctico - Capítulo I Franklin Arriola R. / Yuliana Jáuregui R.
Índice General
Presentación .......................................................................................... 1
Introducción .......................................................................................... 2
Capitulo I
Nociones de algoritmos ......................................................................... 3
1. Definición de algoritmos ....................................................................... 3
2. Visión histórica .................................................................................... 3
3. Características de los algoritmos ............................................................ 3
4. Herramientas para el diseño de algoritmos ............................................. 4
4.1. Diagramas de flujo ...................................................................... 4
4.2. Diagramas Nassi-Schneiderman ..................................................... 5
4.3. Pseudocódigo .............................................................................. 5
5. Composición de los algoritmos .............................................................. 6
5.1. Sección de datos ....................................................................... 7
5.1.1. Variables ............................................................................. 7
5.1.2. Constantes .......................................................................... 7
5.1.3. Tipos de datos ...................................................................... 7
5.2. Sección del código ..................................................................... 8
5.2.1. Expresión ............................................................................ 8
5.2.2. Operadores u Operandos ....................................................... 8
5.2.2.1. Prioridad de los operadores ......................................... 10
5.2.2.2. Uso de paréntesis ...................................................... 10
5.2.3. Funciones predefinidas ......................................................... 11
5.2.4. Asignación .......................................................................... 11
6. Secuencia de los algoritmos ................................................................. 12
6.1. Entrada de datos ...................................................................... 12
6.2. Salida de datos ........................................................................ 13
Capitulo II
Programación estructurada .................................................................. 14
1. Definición de programación estructurada ............................................... 14
2. Estructura secuencial ...........................................................................14
2.1. Ejercicios resueltos ....................................................................14
2.2. Ejercicios propuestos ................................................................ 29
3. Estructura selectiva .............................................................................30
3.1. Estructura selectiva simple: Si – Fin_si .........................................31
3.2. Estructura selectiva doble: Si – Sino – Fin_si ................................34
3.3. Estructura selectiva múltiples ..................................................... 41
3.3.1. Estructura selectiva múltiple: Si anidado ................................ 41
3.3.2. Estructura selectiva múltiple: En caso sea – Fin_caso ............... 51
3.3.3. Estructura selectiva múltiple: En caso sea múltiple .................. 58
3.4. Ejercicios propuestos ................................................................ 62
4. Estructura repetitiva ........................................................................... 65
4.1. Conceptos básicos .................................................................... 65
4.2. Estructura repetitiva Mientras - Fin_mientras ............................... 65
4.3. Estructura repetitiva Repetir – Hasta_que..................................... 81
4.4. Estructura repetitiva Desde – Fin_desde ...................................... 90
4.5. Variantes de las estructuras repetitivas ....................................... 99
4.5.1. Bucles anidados ................................................................... 99
4.5.2. Bucles infinitos .................................................................. 107
4.6. Ejercicios propuestos .............................................................. 108
Capitulo III
Programación modular ....................................................................... 112
1. Definición de programación modular ................................................... 112
1 Sistema a Distancia
2. Módulos .......................................................................................... 112

3. Partes de un módulo ......................................................................... 112
4. Parámetros ...................................................................................... 113
5. Tipos de módulos ............................................................................. 113
5.1. Funciones .............................................................................. 113
5.2. Procedimientos ....................................................................... 114
6. Estructura de un algoritmo que contiene módulos ................................ 114
7. Proceso de llamada a un módulo ........................................................ 115
8. Valor de retorno de un módulo ........................................................... 116
9. Cuando crear módulos con parámetros ................................................ 116
10. Métodos para el paso de parámetros ................................................... 116
10.1. Por valor ............................................................................... 117
10.2. Por referencia ........................................................................ 117
11. Variables Globales y Locales .............................................................. 118
12. Ejercicios resueltos ........................................................................... 118
13. Ejercicios propuestos ........................................................................ 151
14. Recursividad .................................................................................... 153
14.1. Características ....................................................................... 153
14.2. Ventajas y desventajas ........................................................... 153
14.3. Ejercicios resueltos ................................................................. 153
14.4. Ejercicios propuestos .............................................................. 169
Capitulo IV
Arreglos............................................................................................... 171
1. Arreglos .......................................................................................... 171
2. Tipos de arreglos .............................................................................. 171
2.1. Arreglos Unidimensionales o vectores......................................... 171
2.1.1. Declaración de un vector .................................................... 171
2.1.2. Acceso a los elementos de un vector .................................... 172
2.1.3. Operaciones con vectores ................................................... 172
2.2. Arreglos Bidimensionales o matrices ......................................... 172
2.2.1. Declaración de una matriz .................................................. 173
2.2.2. Acceso a los elementos de una matriz .................................. 173
2.3. Arreglos Multidimensionales ..................................................... 173
3. Formas de inicialización de los arreglos ............................................... 174
3.1. En vectores ............................................................................ 174
3.2. En matrices ........................................................................... 174
4. Arreglos sin tamaño .......................................................................... 175
5. Lectura e impresión de un arreglo ....................................................... 175
5.1. Lectura en vectores ................................................................ 175
5.2. Lectura en matrices ................................................................ 175
5.3. Impresión en vectores ............................................................. 175
5.4. Impresión en matrices ............................................................ 176
6. Ejercicios resueltos ............................................................................. 176
8. Paso de vectores a módulos ............................................................... 191
8.1. Parámetro actual .................................................................... 191
8.2. Parámetro formal ................................................................... 192
9. Paso de una matriz a módulos ............................................................ 192
9.1. Parámetro actual .................................................................... 192
9.2. Parámetro formal ................................................................... 192
10. Ejercicios resueltos ........................................................................... 193
Capitulo V
Métodos de ordenación y búsqueda .................................................... 253
1. Métodos de ordenación por selección .................................................. 253
1.1. Método de ordenación por selección simple ................................ 253

1.2. Método de ordenación por conteo ............................................. 256
2. Métodos de ordenación por Comparación-Intercambio (C/I) ................... 259
2.1. Método de ordenación en burbuja ............................................. 259
2.2. Método de ordenación shell ...................................................... 262
2.3. Método de clasificación par – impar .......................................... 265
3. Métodos de ordenación por inserción ................................................... 268
3.1. Método de ordenación por inserción con desplazamiento ............. 268
3.2. Método de ordenación por inserción binaria ................................ 273
4. Métodos de búsqueda ....................................................................... 275
4.1. Búsqueda secuencial ............................................................... 275
4.1.1. En arreglos desordenados ................................................... 275
4.1.2. En arreglos ordenados ......................................................... 277
4.2. Búsqueda binaria .................................................................... 278
Bibliografía ......................................................................................... 281
Introducción
La construcción de programas de computadores es un proceso que involucra las

siguientes actividades: definición del problema, diseño del algoritmo, codificación,
ejecución y validación. Se considera al diseño del algoritmo como una actividad
clave para la programación.
El presente material esta dirigido principalmente a quienes están iniciando sus

estudios en programación. Sirve como texto básico o de consulta para cursos
impartidos en los diferentes centros de estudios donde se trata este tema. En este
contexto, se aborda con mayor énfasis el enfoque de la programación estructurada
y modular. Así como el manejo de las estructuras estáticas que sirven de base para
estos enfoques.
En cada capitulo del libro se considera una parte teórica, importante para el
entendimiento de los temas tratados, así como un número significativo y variado de
ejercicios resueltos, que ayude al lector a comprender y experimentar el manejo de
algoritmos, además se proporciona una lista de problemas planteados, que pueden
ser resueltos como resultado de la lectura del libro.
El libro esta organizado en cinco capítulos. En el primer capítulo se contempla

nociones de algoritmos, como punto introductorio al tema central; en el capítulo
dos se definen los conceptos necesarios sobre programación estructurada
definiendo las estructuras de control propios de este enfoque; en el capítulo tres se
introduce al lector a la programación modular considerando los conceptos
necesarios para el entendido de esta técnica de programación; en el capítulo cuatro
se desarrolla el manejo de las estructuras de datos estáticas y finalmente en el
capítulo cinco se presenta y explica los principales métodos de ordenación y
búsqueda.
Nociones de algoritmos
1. Definición de algoritmos
Un algoritmo es un conjunto finito de instrucciones para llevar a cabo una tarea

específica, como la solución de un problema en un número finito de pasos. Esto es,
que la ejecución del algoritmo concluye en algún momento.
Se puede comparar el concepto de algoritmo con una receta de cocina, así pues, los
algoritmos habitualmente están formados por secuencias de instrucciones que
probablemente se repiten (iteran) o que requieren decisiones (comparaciones
lógicas) hasta que completan su tarea.
Cuando un algoritmo está asociado con el procesamiento de información, los datos

se leen de una fuente o dispositivo de entrada, se procesan y emiten un resultado
por un dispositivo de salida, o bien se almacenan en otro dispositivo para su uso
posterior.
2. Visión histórica
La palabra algoritmo proviene del nombre del matemático y astrónomo Abu Ja’far
Muhammad ibn Musa al-Khwarizmi que vivió entre los siglos VIII y IX. Este
personaje no se destaca por crear nuevos teoremas, sino más bien por escribir
libros de muy fácil comprensión, simplificando el entendimiento de la matemática,
pudiendo ser aplicada por un mayor número de personas. Desarrolló en el Al-yebr-
mugabata, fórmulas para posibilitar que con un número limitado de pasos e
indicaciones claras de ejecución, se pudieran resolver ecuaciones de primer y
segundo grado; explicó por medio de algoritmos el uso de dispositivos mecánicos
como los ábacos. Es por esto y otras razones, que aun no siendo el creador del
primer algoritmo, el concepto lleva aunque no su nombre, sí su pseudónimo.
Así, de la palabra algorismo, que originalmente hacía referencia a las reglas de uso
de la aritmética utilizando dígitos árabes, se evolucionó a la palabra latina,
derivación de al-Khwarizmi, algobarismus, que en el siglo XVIII mutaría a algoritmo
abarcando su definición a toda clase de procedimientos utilizados con el propósito
de resolver problemas o realizar determinadas tareas.
Ya en el siglo XIX, se produjo el primer algoritmo escrito para un computador. La

autora fue Ada Byron, en cuyos escritos se detallaban la máquina analítica en 1842.
Por ello que es considerada por muchos como la primera programadora, aunque
desde Charles Babbage, nadie completó su máquina, por lo que el algoritmo nunca
se implementó.
3. Características de los algoritmos
Todo algoritmo debe cumplir las siguientes características:

• Preciso: debe especificar sin ambigüedad el orden en que se deben ejecutar
todas las instrucciones.
• Definido: cada vez que se ejecute bajo las mismas condiciones, la secuencia de
ejecución deberá ser la misma proporcionándonos el mismo resultado.
• Finito: debe terminar en un número finito de pasos, en un tiempo finito y
requiriendo una cantidad finita de esfuerzo.
En la práctica, para evaluar un buen algoritmo se considera el tiempo que requiere

su ejecución, esto puede ser expresado en términos del número de veces que se
ejecuta cada paso. Muchas veces se tienen varios algoritmos para dar solución a un
mismo problema, en este caso, se debe decidir por el mejor, considerando su

simplicidad, elegancia y eficiencia.
4. Herramientas para representar algoritmos
Existen varias maneras para representar algoritmos, así, podemos considerar:
4.1. Diagramas de flujo
Los diagramas de flujo, son representaciones gráficas mediante el cual se

especifica la dirección que sigue la información que contiene un algoritmo para
poder producir un resultado; los datos se encierran en diferentes figuras, las
cuales se denominan figuras lógicas. Cada una de estas figuras están
relacionadas entre si mediante flechas que indican el orden que deben ser
ejecutadas.
Para hacer comprensibles los diagramas a todas las personas, los símbolos
utilizados han sido normalizados por el Instituto Nacional Estadounidense de
Estándares (ANSI, por sus siglas en inglés: American National Standards
Institute).
Diagrama Descripción
Terminal: Indica el inicio y fin del diagrama de

flujo.
Entrada/Salida: Indica la entrada y salida de

datos.
Procesos: Indica la asignación de un valor a

memoria y/o alguna operación aritmética.
Decisión: Indica la decisión que se toma ante

una comparación de valores, determinando el
camino a seguir.
Subrutina: Representa los subprogramas.
Conector: Representan la continuidad del

diagrama de flujo dentro de una página.
Conector: Representan la continuidad del

diagrama de flujo en otra página.
Impresora: Indica la salida de la información

por la impresora.
Pantalla: Indica la salida de la información por

medio de la pantalla.
Teclado: se utiliza en ocasiones en lugar del

símbolo de Entrada/Salida.
Comentario: Permite añadir anotaciones al

diagrama.
Flechas de dirección: Dirección en la que se

realiza el flujo
4.2. Diagramas Nassi-Schneiderman
El diagrama N-S, también conocido como diagrama de Chapin, es como un

diagrama de flujo en el que se omiten las flechas de dirección.
Su representación se realiza por medio de cajas rectangulares que se encuentra

una a continuación de la otra. Cada una de estas cajas indica la acción que se
va a realizar.
Inicio
Acción1
Acción2
.
.
.
AcciónN
Fin
4.3. Pseudocódigo
Es una mezcla de frases de un idioma nativo (español, inglés, etc.),

instrucciones de programación y algunas palabras claves, que nos permite
representar la secuencia lógica de las acciones de un algoritmo.
La ventaja del pseudocódigo es que en la planificación de un programa, el

programador se concentra en la lógica sin preocuparse de la rigidez sintáctica
que un lenguaje de programación exige.
Inicio
Acción1
Acción2
.
.
.
AcciónN
Fin
Problemas de tipo cotidiano representado en pseudocódigo y/o diagramas de

flujos:
Ejercicio 01
Algoritmo para hacer una llamada desde un teléfono fijo, conociendo el número
al cual se llamará.
Pseudocodigo Diagrama de flujo
Inicio
Inicio
Levanto fono Levanto fono
Espero tono
Marco número Espero tono
Espero que contesten
Hablo con la otra persona Marco número
Cuelgo el fono
Fin
Espero que contesten
Hablo con la otra persona
Cuelgo el fono
Fin
Ejercicio 02
Algoritmo para freír un huevo asumiendo que todo lo que se necesita se tiene
disponible.
Inicio
Abrir la llave del gas
Coger un fósforo
Prender la cocina
Poner aceite en la sartén
Romper huevo haciendo caer el contenido en la sartén
Tirar cáscaras a la basura
Poner sal al huevo
Mover el huevo con una rasera mientras se esta friendo
Una vez frito el huevo sacarlo con una rasera y colocarlo en un plato
Apagar la cocina.
Fin
5. Composición de los algoritmos
Básicamente los algoritmos están compuestos por una sección de datos y otra del
código, así tenemos:
Inicio
Constante real: pi 3.1416
Variable real: r, c Sección de datos
Escribir ("Introduzca el radio de la circunferencia")

Leer (r)
a 2 * pi * r * r Sección del código
Escribir ("El área es: ", a)
Fin
5.1. Sección de datos
En esta sección se encuentran los identificadores (constantes, variables, tipos

de datos) que representan los datos de un algoritmo. Un identificador es una
secuencia de caracteres que sirve para identificar una posición de memoria del
computador, pudiéndose acceder a su contenido. Para definir un identificador se
debe seguir las siguientes reglas:
• El primer carácter debe ser una letra, los siguientes caracteres pueden ser
letras, dígitos o el símbolo de subrayado (_).
• No debe de comenzar con un número, ni debe contener espacios en blanco,
pues indicaría la posible existencia de dos o más identificadores. Por ejemplo
ahorroTotal es un identificador válido, sin embargo ahorro Total no lo es, ya
que el espacio en blanco incluido entre ahorro y Total indicaría la presencia
de dos identificadores: ahorro y Total respectivamente.
• Se aconseja elegir nombres de identificadores que describan la información
que ellos representan. Esto facilita la lectura, comprensión y escritura del
algoritmo. No es conveniente utilizar nombres cortos ni tampoco
excesivamente largos. Por ejemplo para referirse al sueldo de un trabajador
se podría usar como identificador sueldo, que es mas apropiado que
nombrarlo como x o nombrarlo como elsueldodeltrabajador, en este caso x
no sugiere nada y elsueldodeltrabajador no facilita su escritura.
Identificador Validez Explicación

Calculo1 √ Contiene un número.
2edad x Comienza con un número.
salario Bruto x Tiene un espacio en blanco intermedio.
sueldo_trabajador √ Puede incluir el símbolo de subrayado.
Tabla 1. Identificadores validos (√) y no validos(x)
5.1.1. Variables
Una variable se define como un identificador que se utiliza para almacenar

los datos. Es un nombre que hace referencia a un valor que puede variar a
lo largo de la ejecución del programa. Pueden ser:
• Variable Numérica, que representa un valor entero o real, por ejemplo,
entero: edad, cantidad; real: sueldo, descuento.
• Variable Alfanumérica o literal: que representa un carácter o una
secuencia de caracteres. Por ejemplo caracter: sección, categoría;
cadena: nombre, profesión.
5.1.2. Constantes
Es aquel elemento que no cambia de valor durante la ejecución de un

programa (o comprobación de un algoritmo). Puede ser:
• Constante Numérica, que representa un determinado valor, por ejemplo,
son constantes enteras: 20, 30; constantes reales: 3.1416, 20.8.
• Constante Alfanumérica o literal: cualquier carácter o secuencia de
caracteres (dígito, letra, símbolo especial) comprendidos entre comillas.
Por ejemplo prof “Doctor”.
5.1.3. Tipos de datos
El tipo de una variable, define el contenido que ésta tendrá, es decir,

indica el propósito de la variable.
Los datos se clasifican en diversas categorías, según el tipo de máquina o

del lenguaje en uso. Generalmente podemos encontrar las siguientes
categorías:
• Enteros
Son números que no contienen componentes decimales o fraccionarias;
pueden ser positivos o negativos. Permite realizar operaciones
aritméticas.
• Reales
Son números, siempre tienen un punto decimal y pueden ser positivos o
negativos. Un número real consta de un número entero y una parte
decimal. Permite realizar operaciones aritméticas.
• Carácter
Es un conjunto finito y ordenado de caracteres que la computadora
reconoce. Un dato de este tipo contiene solo un carácter. Dentro del
algoritmo se distingue de las variables, porque son delimitados por
apóstrofes o comillas simples.
Así tenemos:
o Caracteres Alfabéticos (‘A’,’B’,’C’,… ‘Z’, ‘a’, ‘b’, ‘c’… ‘z’)
o Caracteres Numéricos (‘0’, ‘1’, ‘2’,… ‘9’)
o Caracteres Especiales (‘+’, ‘-’, ‘/’, ‘^’, ‘;’, ‘<‘, ‘>’, ‘$’, ...)
• Cadena
Es un sucesión de caracteres que se encuentran delimitados por comillas
doble, representan información textual (palabras, frases, etc). La
longitud de una cadena es el número de caracteres comprendidos entre
los separadores o delimitadores, los espacios en blanco tambien los
cuenta. Por ejemplo:
“Hola amigos” Longitud = 11
“Bienvenidos al mundo de los algoritmos” Longitud = 38
• Lógicos
Denominados también Booleano, es aquél dato que solo puede tomar
uno de dos valores: verdadero (true) o falso (false).
5.2. Sección del Código
A esta sección se le considera el corazón del algoritmo. En ella van el cuerpo del
programa, conformado por las sentencias que indican los pasos que se van a
realizar durante la ejecución del algoritmo.
5.2.1. Expresión
Las expresiones son combinaciones de variables, constantes, operadores,

funciones especiales, paréntesis, entre otros, que se forman para
representar las operaciones aritméticas, relacionales y lógicas. Por ejemplo:
a+2*b–c/3
Una expresión consta de operadores y operandos. Según sea el tipo de

datos que manipulan, se clasifican las expresiones en:
• Aritméticas
• Relaciónales
• Lógicas
5.2.2. Operadores y Operandos
Los operadores son símbolos especiales que relacionan los valores de una o
más variables y/o constantes. Es decir, los operadores nos permiten
manipular valores.
Los operandos son los valores, constantes, variables o expresiones que
intervienen en una expresión.
Operando Operador Operando
Variable o Constante
Los tipos de operadores son:
a) Operadores Aritméticos
• Permite la realización de operaciones matemáticas con los valores de
las variables y constantes.
• Pueden ser utilizados con tipos de datos enteros o reales.
• Cuando en una operación aritmética los operandos son de tipos
diferentes, ambos son convertidos al tipo de operando de precisión
mas alta, es decir si ambos son enteros, el resultado es entero, si
alguno de ellos es real, el resultado es real.
Los operadores aritméticos son:
Operador Expresión Aritmética Resultado

Significado
Aritmético (a = 13, b = 2)
+ Suma a+b 15
- Resta a–b 11
* Multiplicación a * b 26
/ División real a / b 6.5
div División entera a div b 6
Residuo de una
mod a mod b 1
división
^ Exponenciación a^2 169
Tabla 2. Operadores Aritméticos
b) Operadores Relacionales
• Se utiliza para comparar dos valores, produciendo un resultado lógico
(verdadero o falso)
• La comparación se realiza entre valores del mismo tipo de datos
(numéricos o cadenas).
• Estos operadores sirve para expresar las condiciones en los
algoritmos.
Los operadores relacionales son:
Operador Expresión Relacional

Significado Resultado
Relacional (a = 3, b = 2)
> Mayor que a>b true
>= Mayor o igual que a >= b true
< Menor que a Distinto de a <> b true
Tabla 3. Operadores Relaciónales
c) Operadores Lógicos
• Permite establecer comparaciones entre valores lógicos
• El resultado de esta comparación es de tipo lógico o booleano
(verdadero o falso).
Los operadores lógicos son:
Variables Operador
x y x and y x or y not x
true true true true false

true false false true false
false true false true true
false false false false true
Tabla 4. Operadores Lógicos
Se observa en la tabla que el resultado de una operación and será cierto solo
si los dos operandos son ciertos, el resultado de una operación or será cierto
si alguno de los dos operandos es cierto o ambos a la vez, en el caso del
operador not niega el operando, obteniéndose true (verdadero) si el
operando es falso o viceversa.
5.2.2.1. Prioridad de los operadores
• Todas las expresiones entre paréntesis se evalúan primero. Las

expresiones con paréntesis anidados se evalúan de dentro a fuera, el
paréntesis más interno se evalúa primero.
• Dentro de una misma expresión los operadores se evalúan en el
siguiente orden.
^ Exponenciación
*, /, mod Multiplicación, división, modulo.
+, - Suma y resta.
Los operadores en la misma prioridad se evalúan de izquierda a derecha.
Por ejemplo: 2 + 3 * 10
El operador de multiplicación tiene mayor prioridad que la suma, por lo

cual el compilador evaluara primero la multiplicación 3*10 y a
continuación la suma obteniendo como resultado 32.
Por ejemplo: 2*3 – 8 / 4
El operador de multiplicación tiene igual prioridad que la división, por lo

cual el compilador evaluará primero la multiplicación 2*3, y a
continuación la división obteniéndose 6 – 2 dando como resultado 4.
5.2.2.2. Uso de paréntesis
Los paréntesis se utilizan para cambiar el orden preestablecido, ya que

las operaciones encerradas entre paréntesis se evalúan primero.
Por ejemplo, hallar el promedio de dos números:
x=a+b/2
x = (a+b) / 2
En la primera expresión, debido a la prioridad en primer lugar se divide b

entre 2, y después se suma el valor de a, esta expresión es distinta
cuando se utilizan paréntesis, primero se suma a+b y luego dividirlo
entre dos.
Cuando en una expresión contiene subexpresiones que se encuentran

anidadas por paréntesis, primero se evalúan las subexpresiones anidados
en el nivel mas interno luego el siguiente nivel mas interno y así
sucesivamente.
Por ejemplo:
8 + ( 6 – ( 8 – 3 ) + 2)
Primero efectuamos el paréntesis mas interno (8 – 3) obteniendo 5 como
resultado, reemplazamos obtenemos 8 + (6 – 5 + 2).
Efectuamos el paréntesis ya que tiene mayor prioridad que la suma

obteniendo 3, luego efectuamos la suma obteniendo como resultado 11.
5.2.3. Funciones predefinidas
En los lenguajes de programación existen ciertas funciones predefinidas o

internas que aceptan un argumento y producen un valor. Así tenemos,
algunas funciones numéricas que serán usadas en el desarrollo de
algoritmos:
Función Descripción
absoluto(x) Valor absoluto
cos(x) Coseno
sin(x) Seno
entero(x) Parte entera de un número
ln(x) Logaritmo natural
log(x) Logaritmo decimal
raiz(x) Raíz cuadrada
redondeo(x) Redondear un número
Las funciones se utilizarán en una expresión escribiendo su nombre, seguido

de los argumentos adecuados encerrados entre paréntesis.
5.2.4. Asignación
Un operador de asignación altera el valor de una variable sin alterar su tipo.

Se representa por una flecha que apunta hacia la izquierda (); este
operador copia el valor del operando o la expresión de la derecha en la
variable de la izquierda, aplicando las conversiones de tipo usuales cuando
es necesario. El formato general de asignación es:
Nom_variable Expresión
Donde Expresión puede ser una variable, constante, operación o función.
Ejemplo:
a 2
Significa que a la variable a se le ha asignado el valor 2. La acción de

asignar es destructiva, ya que el valor que tuviera la variable antes de la
asignación se pierde y se reemplaza por el nuevo valor. Así en la secuencia
de operaciones:
a 30
a 189
a9
El valor de la variable a será 9, es decir el último valor asignado, ya que los

valores anteriores se han destruido.
6. Secuencia de los algoritmos
En un algoritmo se definen tres partes: Entrada, Proceso y Salida.
Entrada Proceso Salida
• La entrada está conformada por la información dada al algoritmo o conjunto de

instrucciones que generan los valores con los que se ha de trabajar en caso de
que carezca de datos de entrada.
• El proceso lo conforman los cálculos y operaciones necesarias para que a partir
de los datos o instrucciones de entrada se llegue a los resultados.
• La salida son las transformaciones que ha sufrido la información de entrada a
través del proceso para obtener los resultados finales
Inicio
Constante real: pi 3.1416

Variable real: r, c Entrada
Escribir (“Introduzca el radio de la circunferencia”)
Leer (r)
Proceso
a 2*pi*r*r
Escribir (“El área es: ”, a) Salida

Fin
6.1. Entrada de datos
Consiste en recibir desde un dispositivo de entrada (por ejemplo el teclado) un

valor o dato. Se representa por la palabra Leer la cual, está seguida por el
nombre de la variable delimitado entre paréntesis: Leer (nombre_variable)
Se utiliza para que un usuario introduzca los datos requeridos por un algoritmo.
Cuando se leen más de una variable es necesario separarlas por comas:

Leer (nombre_variable1, nombre_variable2,...)
Por ejemplo para leer las variables a, b, c, se tiene:
En Pseudocódigo En Diagrama de flujo
Leer (a, b, c) a, b, c
6.2. Salida de datos
Consiste en transferir el valor de una variable o un mensaje a un dispositivo de

salida (por ejemplo la pantalla, impresora). Se representa por la palabra
Escribir, la cual está seguida por el nombre de la variable delimitado entre
paréntesis: Escribir (nombre_variable)
Se utiliza para mostrar al usuario los resultados obtenidos.
Cuando se escriben mas de una variable es necesario separarlas por comas:

Escribir (nombre_variable1, nombre_variable2,...)
El nombre de variable puede ser de dos tipos: constantes alfanuméricas o

variables.
Los mensajes se escriben entre comillas dobles " ". Si una variable es escrita
entre comillas, se mostrará el nombre de la variable correspondiente, y si la
variable es escrita sin comillas se mostrara el contenido de la variable.
Así se tiene:
• Escribir (“Cualquier mensaje”)
• Escribir (variable1, variable2)
Estas dos formas se puede representar en una sola instrucción como:

• Escribir (“Cualquier mensaje ”, variable1, variable2)
Por ejemplo para imprimir el M.C.D. de dos números, se tiene:
En Pseudocódigo En Diagrama de flujo
Escribir (“El M.C.D es ”, m) “ El M.C.D. es ”,m
Algoritmos: Un enfoque práctico - Capítulo II Franklin Arriola R. / Yuliana Jáuregui R.
Programación estructurada
1. Definición
La programación estructurada es un conjunto de técnicas utilizadas para escribir

programas de forma clara.
La programación estructurada se basa en el diseño descendente, esto es, se

plantea una operación como un todo y se divide en segmentos más sencillos o de
menor complejidad, facilitando así el desarrollo de un programa; una vez terminado
todos los segmentos del programa se procede a unirlos.
La programación estructurada logra minimizar la complejidad y errores de los

programas.
La principal desventaja de la programación estructurada, es que en el momento de

hacerse demasiado grande puede resultar bastante problemático su manejo, ya que
todo se constituye en un solo bloque.
Utiliza únicamente tres estructuras: la secuencial, la selectiva y la iterativa.
2. Estructura secuencial
Se representa por una sentencia ó un conjunto de sentencias (a la que en adelante

llamaremos acción) que se ejecutan una a continuación de otra a modo de
secuencia. Las sentencias se suceden de tal modo que la salida de una es la
entrada de la siguiente, y así sucesivamente hasta finalizar el algoritmo. Su sintaxis
es:
Pseudocodigo Diagrama de flujo
inicio
Inicio
Acción1 Accion1
Acción2
. Accion2
.
. .
AcciónN .
Fin .
AccionN
Fin
2.1. Ejercicios resueltos
Ejemplo 01
Pseudocódigo para sumar dos números.
Lectura de datos Impresión de datos
nro1, nro2 suma nro1 + nro2 suma
Variables a utilizar en el pseudocódigo

nro1 primer número
nro2 segundo número
suma suma dos números
Inicio
// Definir variables
entero: nro1, nro2, suma
// Lectura de datos
Escribir (“Ingresar dos valores”)
Leer (nro1, nro2)
// Calcular suma
suma nro1 + nro2
Escribir (“La suma de ambos números es: ” , suma)
Fin
Explicación
• Los Pseudocódigos están delimitados por las palabras: Inicio y Fin.
• Los comentarios son mensajes de texto opcionales que se utiliza para
documentar un programa haciéndolo fácilmente entendibles a los lectores.
Empieza con los caracteres “//” seguido a continuación del comentario deseado.
En nuestro ejemplo se ha utilizado:
// Definir e inicializar variables
// Lectura de datos
// Calcular suma
• Se definen todas las variables que se van a utilizar en el desarrollo del
algoritmo. En nuestro ejemplo:
entero: nro1, nro2, suma
Aqui se define el tipo de dato de las variables y a continuación la lista de
variables separadas por comas.
• Se utiliza la palabra Leer para introducir el valor de una variable a través del
teclado o algún otro medio. En nuestro ejemplo:
Leer (nro1, nro2)
• Se asigna un valor a una variable, a través del símbolo flecha () que dice que
el valor a la derecha tiene que ser asignado a la variable que esta a la izquierda.
En nuestro ejemplo:
suma nro1 + nro2
Se suman los números nro1 y nro2 utilizando el operador “+”. Luego este
resultado es asignado a la variable suma.
• Se usa la palabra Escribir para identificar una salida estándar a través del
monitor o consola. En nuestro ejemplo:
Escribir (“La suma de ambos números es: ”, suma)
De esta forma, se muestra en la pantalla el siguiente texto: La suma de ambos
números es: … , en este caso el operador “,” une el texto La suma de ambos
números es: con el contenido de la variable suma.
Ejemplo 02
Pseudocódigo para calcular el área de un rectángulo, donde la base y la altura
serán ingresados. La fórmula es:
area = base * altura

base, altura area base * altura area

base base del rectángulo
altura altura del rectángulo
area área del rectángulo
Inicio
entero: base, altura, area
// Lectura de datos
Escribir (“Ingrese la base y la altura”)
Leer (base, altura)
// Proceso: calculo del area
area base * altura
// Salida de resultados
Escribir (“El área del rectángulo es ”,area)
Fin
Ejemplo 03
Pseudocódigo para determinar la suma de las cifras de un número entero positivo
de 3 cifras.
Por ejemplo para sumar las cifras del número 257 se tiene:
2 + 5 + 7 = 14
Para obtener cada cifra del número será necesario realizar divisiones sucesivas
entre 10.
unidades nro Mod 10

nro nro Div 10
nro decenas nro Mod 10 suma
nro nro Div 10
centenas nro Mod 10
suma unidades + decenas + centenas

nro número ingresado de tres dígitos
suma suma de los dígitos del número
unidades unidades del número
decenas decenas del número
centenas centenas del número
Inicio
entero: nro, unidades, decenas, centenas, suma 0
// Lectura de datos
Leer (nro)
// Proceso de cálculo
unidades nro Mod 10
nro nro Div 10
decenas nro Mod 10
nro nro Div 10
centenas nro Mod 10
suma unidades + decenas + centenas
Escribir (“La suma de los dígitos es ”, suma)
Fin
Ejemplo 04
Pseudocódigo para sumar dos tiempos dados en horas, minutos y segundos.
Por ejemplo:
Tiempo 1 = 8:15:56
Tiempo 2 = 10:58:43
1 1
8 : 15 : 56
10 : 58 : 43
19 74 60 99 60
60 1 60 1
19 : 14 : 39
Para el desarrollo del pseudocódigo se suman los segundos de los dos tiempos, el
resultado de esta suma se divide entre 60, siendo el residuo de esta división el total
de segundos y el cociente se suma a los minutos, de igual forma se realiza la suma
de los minutos, el resultado de esta suma se divide entre 60, siendo el residuo de
la división el total de minutos y el cociente se suma a las horas.
seg seg1 + seg2

hor1, min1, seg1 llevaMin seg Div 60
hor2, min2, seg2 seg seg Mod 60 hor, min, seg
min llevaMin + min1 + min2
llevaHora min Div 60
min min Mod 60
hor llevaHora + hor1 + hor2

hor1 horas del primer tiempo
min1 minutos del primer tiempo
seg1 segundos del primer tiempo
hor2 horas del segundo tiempo
min2 minutos del segundo tiempo
seg2 segundos del segundo tiempo
llevaMin minutos que se lleva
llevaHora hora que se lleva
hor horas resultante
min minutos resultante
seg segundos resultante
Inicio
entero: hor1, min1, seg1, llevaMin,hor2, min2, seg2, llevaHora, hor, min, seg
// Lectura de datos
Escribir (“Ingresar primer tiempo”)
Leer (hor1, min1, seg1)
Escribir (“Ingresar segundo tiempo”)
Leer (hor2, min2, seg2)
// Determina la cantidad total de segundos entre los dos tiempos
seg seg1 + seg2
llevaMin seg Div 60
seg seg Mod 60
min llevaMin + min1 + min2
llevaHora min Div 60

min min Mod 60
hor llevaHora + hor1 + hor2
Escribir (“La suma de los 2 tiempos es ”, hor, min, seg)
Fin
Ejemplo 05
Pseudocódigo que permita pasar de grados centígrados a grados Farenheit sabiendo
que:
9
º F = º C + 32
5
El siguiente cuadro muestra resultados con datos de prueba, para diferentes

valores de la variable centi.
centi faren
10 50
20 68
30 86
40 104
centi faren9/5*centi +32 faren

centi medida ingresada en centígrado
faren medida en farenheit
Inicio
real: centi, faren
// Lectura de datos
Escribir (“Ingresar grados centígrados”)
Leer (centi)
// Proceso de cálculo: conversión de temperatura
faren 9 / 5 * centi +32
Escribir (centi, “ centígrado equivale a ”, faren, “ Farenheit“)
Fin
Ejemplo 06
Pseudocodigo calcular la suma de los “n” primeros números naturales. Emplear la
fórmula:
n (n + 1)
suma =
2
nro suma nro*(nro+1)/2 suma

nro nro ingresado
suma suma de los nros
Inicio
entero: nro, suma
// Lectura de datos
Escribir (“Ingresar cantidad de números a sumar”)
Leer (nro)
// Proceso de cálculo: Suma de los “n” nros naturales
suma nro * (nro + 1) / 2
Escribir (“La suma es ”, suma)
Fin
Factor de conversión
Es una fracción en la que el numerador y denominador son medidas iguales
expresadas en unidades distintas, de tal manera, que esta fracción vale la unidad.
Método efectivo para cambio de unidades y resolución de ejercicios sencillos
dejando de utilizar la regla de tres.
Ejemplo 1: Pasar 15 pulgadas a centímetros (1 pulgada = 2.54 cm)
15 pulgadas × (2.54 cm / 1 pulgada) = 15 × 2.54 cm = 38.1 cm.
Ejemplo 2: Pasar 25 metros por segundo a kilómetros por hora (1 kilómetro =

1000 metros, 1 hora = 3600 segundos)
25 m/s × (1 km / 1000 m ) × (3600 s / 1 h) = 90 km/h.
Ejemplo 07
Pseudocódigo para convertir una longitud dada en metros a sus equivalentes en
milímetros, centímetros, pies, pulgadas y yardas. Se sabe que:
1 metro = 1000 milímetros

1 metro = 100 centímetros
1 pulgada = 2.54 centímetros
1 pie = 12 pulgadas
1 yarda = 3 pies
1 Kilómetro = 1000 metros

valores:
Metros Milímetros Centímetros Pulgadas Pies Yardas Kilómetros

5 5000 500 196.85 16.4042 5.46807 0.005
10 10000 1000 393.701 32.8084 10.9361 0.01
20 20000 2000 787.402 65.6168 21.8723 0.02
50 50000 5000 1968.50 164.042 54.6807 0.05
70 70000 7000 2755.91 229.659 76.5529 0.07

mili 1000*metros
cent metros*100
metros mili, cent, pulg, pies,
pulg cent/2.54
yardas, km
pies pulg/12
yarda pies/3
km m /1000

metros medida ingresada en metros
mili medida en milímetros
cent medida en centímetros
pies medida en pies
pulg medida en pulgadas
yarda medida en yardas
Inicio
real: metros, mili, cent, pies, pulg, yarda, km
// Lectura de datos
Escribir (“Ingresar medida en metros”)
Leer (metros)
// Proceso de cálculo: conversiones métricas
mili 1000 * metros
cent metros * 100
pulg cent / 2.54
pies pulg / 12
yarda pies / 3
km metros / 1000
Escribir (metros, “metros equivale a ”, mili, “ milímetros ”, cent,
“Centímetros ”, pulg, “pulgadas ”, pies, “ pies ”, yarda, “ yardas ”, km,
“Kilómetros”)
Fin
Ejemplo 08
Pseudocódigo para convertir pesos, dado en gramos a sus equivalentes en
miligramos, kilogramos, onza y libras. Se sabe que:
1 gramo = 1000 miligramos

1 kilogramo = 1000 gramos
1 onza = 28.35 gramos
1 libra = 16 onzas = 453.6 gramos
1 tonelada = 2000 libras

valores:
Gramos Miligramos Kilogramos Onza Libra Toneladas

500 500000 0.5 17.6367 1.10229 0.0005
300 300000 0.3 10.5822 0.66139 0.0003
600 20000 0.6 21.1644 1.32277 0.0006
700 50000 0.7 24.6918 1.54324 0.0007
900 900000 0.9 31.7466 1.98416 0.0009
mili 1000*gramo
kilo gramo/1000
gramo onza gramo/28.35 mili, kilo, onza, libra
libra gramo/453.6

gramo peso ingresada en gramos
mili peso en miligramos
kilo peso en kilos
onza peso en onza
libra peso en libra
tm peso en toneladas
Inicio
real: gramo, mili, kilo, onza, libra, tm
// Lectura de datos
Escribir (“Ingresar peso en gramos”)
Leer (gramo)
// Proceso de cálculo: conversiones de pesos
mili 1000 * gramo
kilo gramo / 1000
onza gramo / 28.35
libra gramo / 453.6
tm libra / 2000
Escribir (gramo, “gramos equivale a ”, mili, “ miligramos “, kilo, “
Kilogramos ”, onza, “ Onzas ”, libra, “ Libra ”, tm , “ toneladas ”)
Fin
Ejemplo 09
Pseudocódigo para convertir velocidades dada en metros/segundos a sus
equivalentes en km/hora, km/seg, pies/seg, milla/hora, nudo. Se sabe que:
1 km = 1000 metros
1 minuto = 60segundos
1 hora = 3600 segundos
1 nudo = 1.852 km
1 pie = 12 pulgadas =0.3048 metros
1 milla =1.609 km

valores:
Mts/seg Km/hora Km/seg Pies/seg Milla/hora Nudo

10 36 0.01 32.8084 22.3741 19.4384
20 72 0.02 65.6168 44.7483 38.8769
30 108 0.03 98.4252 67.1224 58.3153
40 144 0.04 131.234 89.4966 77.7538
50 180 0.05 164.042 111.871 97.1922
kmHora metroSeg * 3.6

metroSeg kmSeg metroSeg/1000 kmHora, kmSeg,
piesSeg 100 * metroSeg /30.48 piesSeg, millaHora,
millaHora 3600 * metroSeg /1609 nudo
nudo 3600 * metroSeg /1852

metroSeg medida ingresada en metros/ seg
kmHora medida en kilómetros/ Hora
kmSeg medida en kilómetros/seg
piesSeg medida en pies/ seg
millaHora medida en millas /hora
nudo medida en nudos
Inicio
real: metroSeg, kmHora, kmSeg, piesSeg, millaHora, nudo
// Lectura de datos
Escribir (“Ingresar velocidad en metros y segundos”)
Leer (metroSeg)
// Proceso de cálculo: conversiones de velocidades
kmHora metroSeg * 3.6
kmSeg metroSeg / 1000
piesSeg metroSeg / 0.3048
millaHora 3600 * metroSeg / 1609
nudo 3600 * metroSeg / 1852
Escribir (metroSeg, “ Metros/seg equivale a ”, kmHora, “ Kilómetros/hora ”,
kmSeg, “ Kilómetros /seg ”, piesSeg, “ Pie/seg ”, millaHora, “ Millas/hora ”,
nudo, “ Nudo ”)
Fin
Ejemplo 10
En una tienda se ha puesto en oferta la venta de cierto tipo de producto ofreciendo
un descuento fijo del 15% del monto de la compra. Elabore un algoritmo que
determine el monto del descuento y el monto a pagar por la compra de cierta
cantidad de unidades del producto.
compra precio * cantidad

precio, cantidad desc 0.15 * compra desc, compra
montoAPagar compra - desc

cantidad cantidad de productos a comprar
precio precio del producto
desc monto descontado
compra monto de la compra
montoAPagar monto a pagar
Inicio
entero: cantidad
real: precio, desc, compra, montoAPagar
// Lectura de datos
Escribir (“Ingresar precio del producto”)
Leer (precio)
Escribir (“Ingresar cantidad”)
Leer (cantidad)
// Proceso de calculo
compra precio * cantidad
desc 0.15 * compra
montoAPagar compra - desc
Escribir (“El monto del descuento es ”, desc)
Escribir (“El monto a pagar es ”, montoAPagar)
Fin
Ejemplo 11
Pseudocódigo que determina el porcentaje de varones y de mujeres que hay en un
salón de clase.
total cvar + cmuj

cvar, cmuj pvar (cvar * 100) / total pvar, pmuj
pmuj 100 - pvar

cvar cantidad de varones
cmuj cantidad de mujeres
total total de alumnos
pvar porcentaje de varones
pmuj porcentaje de mujeres
Inicio
entero: cvar, cmuj, total
real: pvar, pmuj
// Lectura de datos
Escribir (“Ingresar cantidad de varones”)
Leer (cvar)
Escribir (“Ingresar cantidad de mujeres”)
Leer (cmuj)
total cvar + cmuj
pvar (cvar * 100) / total
pmuj 100 - pvar
Escribir (“El porcentaje de varones es ”, pvar)
Escribir (“El porcentaje de mujeres es ”, pmuj)
Fin
Ejemplo 12
Pseudocódigo que intercambie las cifras de las unidades de dos números naturales.
Por ejemplo:
Número 1: 2485
Número 2: 17
Intercambiando sus unidades se obtiene: 2487 y 15.

unro1 nro1 Mod 10
unro2 nro2 Mod 10
nro1, nro2 nro1, nro2
nro1 nro1 – unro1 + unro2

nro1 primer número ingresado
nro2 segundo número ingresado
unro1 unidades del primer número
unro2 unidades del segundo número
Inicio
entero: nro1, nro2, unro1, unro2
// Lectura de datos
Escribir (“Ingresar dos números”)
Leer (nro1, nro2)
unro1 nro1 Mod 10
unro2 nro2 Mod 10
Escribir (“Los números intercambiados son ”, nro1, nro2)
Fin
Ejemplo 13
Pseudocódigo que convierte una hora expresada como un número real a su
equivalente en horas, minutos y segundos.
Por ejemplo:
Hora: 16.235
Equivale a: 16 horas, 14 minutos y 6 segundos

hor entero (hora)
hora hora - hor
minuto hora * 60
min entero (minuto)
minuto minuto - min
hora hor, min, seg, cs
segundo minuto * 60
seg entero (segundo)
segundo segundo – seg
cs segundo * 100
Para la resolución de este ejemplo se hace uso de la función predefinida entero().

hora hora real
minuto minuto real
segundo segundo real
hor hora entera
min minuto entero

seg segundo entero
cs centésimo de segundos entero
Inicio
real: hora, minuto, segundo
entero: hor, min, seg, cs
// Lectura de datos
Escribir (“Ingresar hora”)
Leer (hora)
hor entero (hora)
hora hora - hor
minuto hora * 60
min entero (minuto)
minuto minuto - min
segundo minuto * 60
seg entero (segundo)
segundo segundo – seg
cs segundo * 100
Escribir (“El equivalente es ”, hor, min, seg, cs)
Fin
Ejemplo 14
Pesudocódigo para calcular el monto final que se paga por la compra de un auto al
crédito, al precio de venta se le aumenta el 4% de impuestos estatales, de tal
forma que el cliente tendrá que pagar como cuota inicial el 20% de este nuevo
precio, el monto financiado tendrá un interés del 7% anual.

imp 0.04 * precio
precio precio + imp
cuota 0.20 * precio
precio, tiempo finan precio - cuota total
inter 0.07 * finan * tiempo
total cuota + finan + inter

imp impuesto estatal
precio precio del auto
cuota cuota inicial
finan monto financiado
inter intereses generados
total total a pagar
tiempo tiempo a financiar
Inicio
real: imp, precio, cuota, finan, inter, total
// Lectura de datos
Escribir (“Ingresar precio”)
Leer (precio)
Escribir (“Ingresar años financiados”)
Leer (tiempo)
imp 0.04 * precio
precio precio + imp
cuota 0.20 * precio
finan precio - cuota
inter 0.07 * finan * tiempo
total cuota + finan + inter
Escribir (“El total a pagar es ”, total)
Fin
Ejemplo 15
Pseudocódigo para calcular la cantidad de arena que se necesita para pulir una
pared, se conoce las medidas de la pared (largo y alto) y se sabe que se necesita
0,5 metros cúbicos de arena por cada metro cuadrado de pared.

area largo * alto
largo, alto arena 0.5 * area arena

largo largo de la pared
ancho ancho de la pared
area área total de la pared
arena cantidad de arena que se necesita
Inicio
real: largo, alto, area, arena
// Lectura de datos
Escribir (“Ingresar largo y alto de la pared”)
Leer (largo, alto)
area largo * alto
arena 0.5 * area
Escribir (“Se necesita ”, arena, “metros cúbicos de arena”)
Fin
Ejemplo 16
Pesudocódigo para calcular el tiempo que tarda el atleta en dar 2 vueltas a una
pista de atletismo, se tiene como datos la velocidad en metros/segundos y el radio
de la circunferencia de la pista, se sabe además que el atleta descansa 1 minuto
cada 100 metros.

recor (2 * 3.1416 * radio) * 2
tiempo recor / vel
vel, radio tiemdes (recor Div 100) * 2 tiempo
tiempo tiempo + tiemdes

vel velocidad que corre el atleta
radio radio de la pista de atletismo
recor recorrido total
tiemdes tiempo que descansa el atleta
tiempo tiempo empleado en dar 2 vueltas a la pista
Inicio
real: vel, radio, recor, tiempo, tiemdes
// Lectura de datos
Escribir (“Ingresar velocidad”)
Leer (vel)
Escribir (“Ingresar radio”)
Leer (radio)
recor (2 * 3.1416 * radio) * 2
tiempo recor / vel
tiemdes (recor Div 100) * 2
tiempo tiempo + tiemdes
Escribir (“El tiempo empleado en dar 2 vueltas es ”, tiempo)
Fin
Ejemplo 17
Pseudocódigo para calcular el precio de venta de una pizza; el tamaño de la pizza
varía según la solicitud del cliente, quien determina el diámetro en centímetros que
tendrá la pizza. El costo básico (pizza sin ingredientes extras) es de 0,48 soles por
cm, el costo de cada ingrediente extra agregado a la pizza base es de 0,10 soles
por cm, el precio de venta de la pizza se obtiene recargando un 120% en costo
total.

precio diam * 0.48
adic extra * diam
diam, extra recar (precio + adic) * 1.2 venta
venta precio + adic + recar

diam diámetro de la pizza
extra cantidad de ingredientes extras
precio precio base de la pizza
adic monto adicional por los ingredientes extras
recar monto recargado
venta precio de venta
Inicio
entero: diam, extra
real: precio, adic, recar, venta
// Lectura de datos
Escribir (“Ingresar diámetro de la pizza”)
Leer (diam)
Escribir (“Ingresar cantidad de ingredientes extras”)
Leer (extra)
precio diam * 0.48
adic extra * diam
recar (precio + adic) * 1.2
venta precio + adic + recar
Escribir (“El precio de venta es ”, venta)
Fin
Ejemplo 18
Pesudocódigo para calcular el mínimo de monedas de 2.00, 1.00, 0.50, 0.20 y 0.10
que una máquina electrónica da como vuelto por la compra de un paquete de
galletas, dicha maquina solo acepta monedas de 5 soles.

vuelto 5 – precio
vueltoEnt entero (vuelto)
vueltoReal (vuelto – vueltoEnt) * 100
m2 vueltoEnt Div 2
precio m1 vueltoEnt Mod 2 m1, m2, m50,
m50 vueltoReal Div 50 m20, m10
vueltoReal vueltoReal Mod 50
m20 vueltoReal Div 20
m10 vueltoReal Mod 20

precio precio de la galleta
vuelto vuelto de la compra
vueltoEnt parte entera del vuelto expresado como valor entero
vueltoReal parte fraccionaria del vuelto expresado como valor entero
m2 cantidad de monedas de 2.00 soles
m1 cantidad de monedas de 1.00 sol
m50 cantidad de monedas de 0.50 céntimos
Inicio
entero: vueltoEnt, vueltoReal, m1, m2, m50, m20, m10
real: precio, vuelto
// Lectura de datos
Escribir (“Ingresar precio de la galleta”)
Leer (precio)
vuelto 5 – precio
vueltoEnt entero (vuelto)
vueltoReal (vuelto – vueltoEnt) * 100
m2 vueltoEnt Div 2
m1 vueltoEnt Mod 2
vueltoReal vueltoReal Mod 50
m10 vueltoReal Mod 20
Escribir (“Se recibe ”, m2, “monedas de 2.00 soles”, m1, “monedas de 1.00
sol”, m50, “monedas de 0.50 céntimos”, m20, “monedas de 0.20 céntimos”,
m10, “monedas de 0.10 céntimos”)
Fin
Ejemplo 19
Pseudocódigo para calcular el tiempo, en horas y minutos que emplea un profesor
para calificar un grupo de exámenes. Se tienen tres tipos de examen A, B, C y el
tiempo en minutos requerido para cada tipo son: A = 5 min, B = 7 min y C = 8
min.
tiempo (ca*5) + (cb*7) + (cc*8)

ca, cb, cc hor tiempo Div 60 hor, min
min tiempo Mod 60

ca cantidad de exámenes tipo a
cb cantidad de exámenes tipo b
cc cantidad de exámenes tipo c
hor horas empleadas para calificar los exámenes
min minutos empleados para calificar los exámenes
tiempo tiempo en horas,minutos para calificar los exámenes
Inicio
entero: ca, cb, cc, hor, min
// Lectura de datos
Escribir (“Ingresar cantidad de exámenes tipo A”)
Leer (ca)
Escribir (“Ingresar cantidad de exámenes tipo B”)
Leer (cb)
Escribir (“Ingresar cantidad de exámenes tipo C”)
Leer (cc)
tiempo (ca * 5) + (cb * 7) + (cc * 8)
hor tiempo Div 60
min tiempo Mod 60
Escribir (“Se emplea ”, hor, “horas con”, min, “minutos”)
Fin
2.2.Ejercicios Propuestos
1. Dada las siguientes ecuaciones:

a = b + 2c + 3m
c = a + 3b + n
z = m + n + 5a
Diseñe un pesudocódigo que determine los valores de m y z conociendo los
valores de a, b, y c.
2. Una persona tiene 2 recipientes llenos de gasolina cuyas capacidades están
dadas en galones y pies cúbicos, respectivamente. Diseñe un pesudocódigo
que determine la cantidad total de gasolina en metros cúbicos, pies cúbicos
y yardas cúbicas. Considere los siguientes factores de conversión:
1 pie cúbico = 0.0283 metros cúbicos

1 galón = 3.79 litros
1 metro cúbico = 1000 litros
1 yarda cúbica = 27 pies cúbicos
3. Diseñe un pesudocódigo que calcule las HH:MM:SS transcurridos entre dos
tiempos. Ambos tiempos vienen dados en el formato HH:MM:SS.
4. Diseñe un pesudocódigo que lea la hora actual del día HH:MM:SS y
determine cuantas horas, minutos y segundos restan para culminar el día.
5. El sueldo neto de un vendedor se calcula como la suma de un sueldo básico
más el 12% del monto total que ha vendido. Diseñe un pesudocódigo que
determine el sueldo neto de un vendedor sabiendo que hizo tres ventas en
el mes.
6. Elaborar un pseudocódigo que permita convertir un volumen dado en litros a
sus equivalentes en mililitros, hectolitro, pie cúbico, pinta, galones. Se sabe
que:
1 litro = 1000 mililitros
1 hectolitro = 100 litros
1 pie cúbico = 28.32 litros
1 onza fluida = 29.57 mililitro
1 pinta = 16 onza fluida
1 galón = 3.785 litros
7. Desarrollar un programa que dado el largo y el ancho de un campo, permita
determinar cuantos metros de alambre serán necesarios para colocar al
perímetro 5 hilos de alambrado.
8. Una empresa exportadora de trigo trabaja con 2 proveedores; el primer
proveedor le brinda una cierta cantidad de trigo en gramos y el segundo
proveedor otra cierta cantidad de trigo en libras. Se pide elaborar un
pesudocódigo que calcule la cantidad total de trigo que obtiene la empresa.
1 libras = 16 onzas
1 onza = 28.35 gramos
1 kilogramo = 1000 gramos
1 tonelada = 1000 kilogramos
9. Calcular el perímetro de una circunferencia dado su radio. Luego calcule el
perímetro de la misma si se reduce al 50%, y el perímetro de la misma si se
reduce al 25% con respecto al resultado anterior.
10. La calificación final de un estudiante viene dada por tres calificaciones: nota
de laboratorio que cuenta un 30% del total, nota de examen parcial que
cuenta un 20% del total y nota de examen final que cuenta el 50% restante.
Diseñar un pesudocódigo que lea la nota de laboratorio, la nota del examen
parcial y la nota del examen final de un estudiante y muestre el tanto por
ciento correspondiente a cada una de las notas así como la calificación final.
11. Diseñe un algoritmo que lea un número de 4 dígitos luego intercambie el
primer digito con el último dígito.
12. Una empresa constructora ofrece departamentos al crédito, para adquirir un
departamento se abona una cuota inicial del 12% y se determina la cantidad
de años que se financia. Al monto financiado se le aplica un interés del 10%
anual. Diseñar un pesudocódigo que calcule el monto mensual que se paga
por un departamento.
13. Tres personas deciden invertir su dinero para fundar una empresa. Cada una
de ellas invierte una cantidad distinta. Obtener el porcentaje que cada
persona invierte con respecto a la cantidad total invertida.
3. Estructura selectiva
Para poder desarrollar aplicaciones, no basta con ejecutar sentencias secuenciales,

también resulta esencial tomar decisiones en base a evaluaciones de expresiones
lógicas que nos señalaran el camino alternativo a seguir.
El tipo de resultado de una estructura selectiva es lógico (booleano), es decir,

verdadero (true) o falso (false).
Las estructuras selectivas que se utilizan para tomar decisiones podemos

clasificarlas en: simple, doble y múltiple.
3.1.Estructura selectiva simple: Si - Fin_si
Evalúa una expresión lógica y si su resultado es verdadero (true), se ejecuta

una acción determinada. Su sintaxis es la siguiente:
Si (expresión_lógica) entonces
Acción(es)
Fin_si
Funcionamiento de la estructura selectiva Si - Fin_si

Cuando la sentencia Si - Fin_si inicia su ejecución, se suceden los siguientes
pasos:
a) Se evalúa una expresión_lógica, obteniéndose un resultado lógico.
b) Si este resultado es verdadero (true), se ejecuta una acción, luego el
pseudocódigo proseguirá con la siguiente acción que sigue al Fin_si.
c) Si este resultado es falso (false), la ejecución del pseudocódigo saltará a la
acción que sigue al Fin_si, es decir, no se ejecuta la acción que se
encuentra a continuación del Si.
Ejemplo 01
Pseudocódigo que lea tres notas de un alumno: examen parcial, examen final y
promedio de prácticas imprima el promedio final del estudiante y el mensaje
“aprobado”, solo si el promedio final es mayor o igual que 10.5.
El siguiente cuadro muestra los resultados con datos de prueba:
promedio =
exPar exFin promP mensaje
(exPar+exFin+promP)/3
14 16 12 14.00 aprobado
10 14 15 13.00 aprobado

exPar examen parcial
exFin examen final
promP promedio de prácticas
promedio promedio final
Inicio
real: exPar, exFin, promP, promedio
// Lectura de datos
Escribir (“Ingresar tres notas:”)
Leer (exPar, exFin, promP)
// Calcula promedio
promedio (exPar + exFin + promP) / 3
Si (promedio >= 10.5) entonces
Escribir (“El promedio es ”, promedio, "aprobado”)
Fin_si
Fin
Explicación
Para resolver el ejemplo planteado se definen las variables reales exPar, exFin,
promP y promedio:
Se ingresa tres notas exPar, exFin, promP:

Escribir (“Ingresar tres notas”)
Posteriormente se calcula el promedio de las tres notas ingresadas exPar, exFin,
promP:
Con el promedio calculado se evalua la expresión lógica (promedio >= 10.5) si

esta condición es verdadera se imprime el mensaje solicitado:
Si (promedio>=10.5) entonces
Escribir (“El promedio es ”, promedio, "aprobado”)
Fin_si
Ejemplo 02
Pseudocódigo que lea el sueldo de un trabajador, aplique un aumento del 15%
si su sueldo es inferior a 500 e imprima el nuevo sueldo.

sueldo sueldo
aum aumento
nuevoSueldo nuevo sueldo
Inicio
real: sueldo, nuevoSueldo, aum 0
// Lectura de datos
Escribir (“Ingresar sueldo: ”)
Leer (sueldo)
// Calcula el sueldo
Si (sueldo >=0 and sueldo < 500) entonces
aum 0.15*sueldo
Fin_si
nuevoSueldo sueldo + aum
Escribir (“Nuevo sueldo ”, nuevoSueldo)
Fin
Ejemplo 03
Pseudocódigo calcula el monto final que se paga por un consumo en un
restaurante, sabiendo que por consumos mayores a S/.100.00 se aplica un
descuento del 20%.

consumo monto del consumo
desc descuento
montoFinal monto final a pagar
Inicio
real: consumo, desc 0, montoFinal
// Lectura de datos
Escribir (“Ingresar consumo: ”)
Leer (consumo)
// Calcula el descuento
Si (consumo > 100) entonces
desc 0.20 * consumo
Fin_si
montoFinal consumo - desc
Escribir (“El total a pagar es ”, montoFinal)
Fin
Ejemplo 04
Pseudocódigo que calcula el sueldo semanal de un obrero que trabaja por horas,
si durante la semana trabajó más de 40 horas se le paga por cada hora extra
dos veces la tarifa normal.

tarifa tarifa de cada hora trabajada
horas total de horas trabajadas
extra pago extra
sueldo sueldo del obrero
Inicio
real: tarifa, sueldo, extra 0
entero: horas
// Lectura de datos
Escribir (“Ingresar tarifa: ”)
Leer (tarifa)
Escribir (“Ingresar horas trabajadas: ”)
Leer (horas)
// Calcula el sueldo
sueldo horas * tarifa
Si (horas > 40) entonces
extra (horas – 40) * (2*tarifa)
Fin_si
sueldo sueldo +extra
Escribir (“El sueldo final es ”, sueldo)
Fin
Ejemplo 05
Pseudocódigo para hallar el menor de 4 números.

nro1 primer número
nro3 tercero número
nro4 cuarto número
menor menor número
Inicio
entero: nro1, nro2, nro3, nro4, menor
// Lectura de datos
Escribir (“Ingresar 4 números: ”)
Leer (nro1, nro2, nro3, nro4)
// Proceso
menor nro1
Si (nro2 < menor) entonces
menor nro2
Fin_si
menor nro3
Fin_si
menor nro4
Fin_si
Escribir (“El menor es ”, menor)
Fin
3.2. Estructura selectiva doble: Si – Sino – Fin_si
Se evalúa la expresión-lógica, si este resultado es verdadero se ejecuta la

Accion1, si el resultado es falso se ejecuta la Accion2. En ambos casos, luego de
finalizar la acción seleccionada, se termina la sentecia Si – Sino - Fin_si y la
ejecución del pseudocódigo proseguirá con la primera sentencia que sigue al Si
- Sino - Fin_si. Su sintaxis es la siguiente:
Si (expresión_lógica) entonces
Acción1
Sino
Acción2
Fin_si
Funcionamiento de la estructura selectiva Si – Sino - Fin_si

Cuando la sentencia Si – Sino - Fin_si inicia su ejecución, se suceden los
siguientes pasos:
a) Se evalúa expresión-lógica, obteniendo un resultado lógico.
b) Si este resultado es verdadero, se ejecuta la Acción1 y se va al paso d.
c) Si este resultado es falso, se ejecuta la Acción2 y se va al paso d.
d) La ejecución del pseudocódigo proseguirá con la siguiente sentencia que
sigue al Fin_si
Ejemplo 06
Pseudocódigo para hallar el mayor de dos números.
El siguiente cuadro muestra resultados con datos de prueba:
nro1 nro2 mayor

14 16 16
12 10 12

nro1 primer número
mayor mayor de dos números
Inicio
entero: nro1, nro2, mayor
// Lectura de datos
Escribir (“Ingresar dos números: ”)
Leer (nro1, nro2)
// Calcula el mayor de dos números
Si (nro1 > nro2) entonces
mayor nro1
Sino
mayor nro2
Fin_si
Escribir ("El mayor de dos números es:", mayor)
Fin
Explicación
Para resolver el ejemplo planteado se definen las variables enteras nro1, nro2,
mayor:
entero: nro1, nro2, mayor
Se lee dos números:

Leer (nro1, nro2)
Se evalua la expresión logica (nro1 > nro2) si esta condicion es verdadera se

asigna nro1 a mayor, de lo contrario se asigna nro2 a mayor.

mayor nro1
Sino
mayor nro2
Fin_si
Ejemplo 07
Pseudocódigo para hallar el mayor de tres números
nro1 nro2 nro3 mayor

14 16 18 18
12 14 11 14
08 05 04 08

nro1 primer número
nro3 tercer número
t variable temporal
mayor mayor de tres números
Inicio
entero: nro1, nro2, nro3, t, mayor
// Lectura de datos
Escribir (“Ingresar tres números:”)
Leer (nro1, nro2, nro3)
// Calcula el mayor de tres números
t nro1
Sino
t nro2
Fin_si
Si (t > nro3) entonces
mayor t
Sino
mayor nro3
Fin_si
Escribir (“El mayor de tres números es: ”, mayor)
Fin
Ejemplo 08
Pseudocódigo que lea el espacio recorrido por un auto y su tiempo empleado en
este recorrido. Se pide hallar la velocidad del recorrido. Fórmula:
velocidad = espacio / tiempo.
Tenga en cuenta que en caso de que el tiempo sea igual a cero la velocidad no
se podrá calcularse.

espacio espacio recorrido
tiempo tiempo empleado
velocidad velocidad del recorrido
Inicio
real : espacio, tiempo, velocidad
// Lectura de datos
Escribir (“Ingresar espacio recorrido y tiempo”)
Leer (espacio, tiempo)
// Calcula velocidad
Si (tiempo <> 0) entonces
velocidad espacio / tiempo
Escribir (“La velocidad es: ”, velocidad)
Sino
Escribir (“Error”)
Fin_si
Fin
Ejemplo 09
Pseudocódigo que lea tres valores tal como a, b, c. Calcular el resultado de la
siguiente expresión:
y = (a - b) / c
Donde: a > b > c, además c no puede ser cero.

a primer valor
b segundo valor
c tercer valor
y resultado de la expresión
Inicio
real: a, b, c, y
// Lectura de datos
Escribir (“Ingresar tres números”)

Leer (a, b, c)
// Calcula expresión
Si (c <> 0 ) entonces
y (a - b ) / c
Escribir (y)
Sino
Escribir (“No se puede calcular la expresión”)
Fin_si
Fin
Ejemplo 10
Pseudocódigo que lea tres notas de un alumno: examen parcial, examen final y
promedio de prácticas, imprima el promedio y el mensaje aprobado en caso de
que el promedio es mayor o igual que 10.5, si su promedio es menor de 10.5
imprimir el promedio y el mensaje desaprobado.
exPar exFin promP promedio = mensaje

(exPar+exFin+promP)/3
14 16 12 14.00 aprobado
10 08 06 8.0 desaprobado

exPar examen parcial
exFin examen final
promP promedio de practicas
promedio promedio final
Inicio
// Lectura de datos
Escribir ("Ingrese tres notas: ")
// Calcula promedio
Si (promedio >= 10.5) entonces
Escribir (promedio, “aprobado”)
sino
Escribir (promedio, “desaprobado”)
Fin_si
Fin
Ejemplo 11
Pseudocódigo que lea como dato el sueldo de un trabajador, aplique un
aumento del 15% si su sueldo es inferior a 500 y 10% en caso contrario.
Imprima el nuevo sueldo del trabajador.

sueldo sueldo
aum aumento
nuevoSueldo nuevo sueldo
Inicio
real: sueldo, aum, nuevoSueldo

// Lectura de datos
Escribir (“Ingrese sueldo)
Leer (sueldo)
// Calcula sueldo
Si (sueldo < 500) entonces
aum 0.15 * sueldo
sino
aum 0.10 * sueldo
Fin_si
nuevoSueldo sueldo + aum
Escribir (“Nuevo sueldo ”, nuevoSueldo)
Fin
Ejemplo 12
Pseudocódigo que determine si un número es múltiplo de otro. Un número a es
múltiplo de otro numero b, cuando el residuo de la división de a entre b es cero.
En la siguiente tabla se muestra resultados para diferentes valores de las

variables:
nro1 nro2 r = nro1 Mod nro2 Mensaje a mostrar

20 5 0 20 es múltiplo de 5
18 6 0 18 es múltiplo de 6
9 2 1 9 no es múltiplo de 2

nro1 primer número
r residuo de dos números
Inicio
entero: nro1,nro2, r
// Lectura de datos
Escribir (“Ingresar dos numeros”)
Leer (nro1, nro2)
// Calcular múltiplo
r nro1 Mod nro2
Si (r = 0) entonces
Escribir (nro1, “es múltiplo de”, nro2)
sino
Escribir (nro1, “no es múltiplo de”, nro2)
Fin_si
Fin
Ejemplo 13
Pseudocódigo que lea tres números e imprima su producto si el primero de ellos
es positivo, en caso contrario imprima su suma.
Por ejemplo:
a = 4, b = 3, c = 2 entonces su producto es p = a * b * c = 42
a = -4, b = 3, c = 2 entonces la suma es s = a + b + c = 1

a primer número
b segundo número
c tercer número
p producto
s suma
Inicio
entero: a, b, c, p, s
// Lectura de datos
Escribir (“Ingresar primer numero:”)
Leer (a)
Escribir (“Ingresar segundo número:”)
Leer (b)
Escribir (“Ingresar tercer número:”)
Leer (c)
Si (a > 0) entonces
pa*b*c
Escribir (“El producto es igual ”, p)
Sino
s a+b+c
Escribir (“La suma es igual ”, s)
Fin_si
Fin
Ejemplo 14
Pseudocódigo que lea dos números y diga si la suma de los números es par o
impar.
Por ejemplo:
a = 4, b = 3 entonces su suma es s = a + b = 7 es impar
a = 4, b = 4 entonces la suma es s = a + b = 8 es par

a primer número
b segundo número
s suma
Inicio
entero: a, b, s
// Lectura de datos
Escribir ("Ingresar primer numero:")
Leer (a)
Escribir ("Ingresar segundo número:")
Leer (b)
s a+b
Si (s Mod 2 = 0) entonces
Escribir (s, “La suma es par”)
Sino
Escribir (s, “La suma es impar”)
Fin_si
Fin
Ejemplo 15
Pseudocódigo que determine si un año es bisiesto. Un año es bisiesto si es
múltiplo de 4 y no de 100 o cuando es múltiplo de 400.
Un año es bisiesto si es múltiplo de 4. Para esto tendremos que verificar si el

residuo de la división del año entre 4 es igual a cero.
a Mod 4 = 0
Además, se sabe que no debe ser múltiplo de 100 para lo cual escribimos
a Mod 100 <> 0
Sea múltiplo de 400.
a Mod 400 = 0
Entonces un año es bisiesto si múltiplo de 4, que no debe ser multiplo de 100 a
menos que sea múltiplo de 400
(((a Mod 4 = 0 ) and (a Mod 100 <> 0)) or (a Mod 400 = 0))

a año
Inicio
// Definir variable
entero: a
// Lectura de datos
Escribir ("Ingresar año:")
Leer (a)
Si (((a Mod 4 = 0) and (a Mod 100 <> 0)) or (a Mod 400 = 0)) entonces
Escribir (“El año es bisiesto”)
Sino
Escribir (“El año no es bisiesto”)
Fin_si
Fin
Ejemplo 16
Pseudocódigo que calcule el total a pagar por la compra de camisas. Si se
compran tres camisas o más se aplica un descuento del 20% sobre el total de
la compra, sino se aplica un descuento del 10%.

precio precio de cada camisa
cant cantidad a comprar
compra monto de la compra
desc descuento
total total a pagar
Inicio
entero: cant
real: precio, compra, desc, total
// Lectura de datos
Escribir ("Ingresar precio unitario:")
Leer (precio)
Escribir ("Ingresar cantidad de camisas:")
Leer (cant)
compra cant * precio
Si (compra >=3) entonces
desc 0.20 * compra
Sino
desc 0.10 * compra
Fin_si
total compra – desc
Fin
Ejemplo 17
Pseudocódigo que calcule el total que se paga en una playa de estacionamiento,
en el que se registra la hora de ingreso y la hora de salida del vehículo en
HH:MM, la tarifa por hora o fracción de S/.2.00.
Por ejemplo:
Hora de inicio:4:20
Hora de término: 7:10
Total a pagar: 7:10- 4:20= 2: 40 = 6
Hora de inicio:3:20
Hora de termino: 8:40
Total a pagar: 8:40- 3:20= 5: 20 = 12

h1, m1 hora de ingreso
h2, m2 hora de salida
pago total a pagar
Inicio
entero: h1, m1, h2, m2, min, hor 0
real : pago
// Lectura de datos
Escribir ("Ingresar hora de ingreso:")
Leer (h1, m1)
Escribir ("Ingresar hora de salida:")
Leer (h2, m2)
Si (m2 >= m1) entonces
min m2 – m1
Sino
min (m2 + 60) – m1
h2 h2 - 1
Fin_si
hor h2 – h1
Si (min > 0)
hor hor + 1
Fin_si
pago hor * 2
Escribir (“El total a pagar es ”, pago)
Fin
3.3.Estructura selectiva múltiple
3.3.1. Estructura selectiva múltiple: Si anidado
Un Si anidado es una sentencia Si que esta contenido dentro de otro Si o

Sino. Cuando se anidan Si, cada sentencia Sino siempre se corresponde a la
sentencia Si mas próxima dentro del mismo bloque y que no este asociada
con otro Sino. Un caso particular de una sentencia Si anidada es la
siguiente:
Si (expresión_lógica1) entonces
Acción1
Sino
Si (expresión_lógica2) entonces
Acción2
Sino
Acción3
Fin_si
Fin_si
Funcionamiento de Si anidado: Si – Sino - Si ...

Cuando la sentencia si múltiple inicia su ejecución, se suceden los siguientes
pasos:
a) Se evalúa expresión_lógica1, obteniendo un resultado lógico.
b) Si este resultado es verdadero (true), se ejecuta la Accion1 y se va al
paso d.
c) Si este resultado es falso, se evalúa expresión_lógica2, obteniendo un
resultado lógico, si este resultado es verdadero, se ejecuta la Accion2 y
se va al paso d, si este resultado es falso, se ejecuta la Accion3 y se va
al paso d.
d) La ejecución del pseudocódigo proseguirá con la siguiente sentencia que
sigue al ultimo Fin_si
Ejemplo 18
Pseudocódigo que lea un número y determine si es positivo, negativo o cero.

nro número a ingresar
mensa mensaje a mostrar
Inicio
entero: nro
cadena: mensa
// Lectura de datos
Escribir (“Ingresar numero:”)
Leer (nro)
Si (nro = 0 ) entonces
mensa “Cero”
Sino
Si (nro>0) entonces
mensa “Positivo”
Sino
mensa “Negativo”
Fin_si
Fin_si
Escribir (nro, mensa)
Fin
Explicación
Para resolver el ejemplo planteado se define la variable entera nro y la

variable cadena mensa:
entero: nro
cadena: mensa
Se ingresa un número cualquiera:

Escribir (“Ingresar numero:”)
Leer (nro)
Se evalua la expresión lógica (nro = 0) en caso de cumplirse la igualdad se

asigna “Cero” a la variable mensa:
Si (nro = 0 ) entonces
mensa “Cero”
Después de esta asignación la ejecución pasa a la sentencia escribir y

finaliza el pseudocodigo:
Pero, si la expresión lógica (nro = 0) resulta ser falsa, se ejecuta el SINO

asociado al primer SI:
SINO
Este sino esta conformado por un SI que evalua la expresión logica (nro >
0), si la asignación es verdadera se asigna “Positivo” a la variable mensa:
Si (nro>0) entonces
mensa “Positivo”

Pero, si la expresión logica resulta ser falsa se ejecuta el SINO asociado al

segundo SI en la cual se asigna “Negativo” a la variable mensa:
mensa “Negativo”

Ejemplo 19
En una tienda comercial se realizan descuentos en las compras en función
del importe total de dichas compras. Se desea calcular el importe que se
cobra a un cliente, teniendo en cuenta los siguientes supuestos:
• Si el importe total de la compra es menor de 200 soles no hay

descuentos.
• Si el importe total de la compra esta comprendido entre 200 y 800 se
hace un descuento del 10%
• Si el importe total de la compra es mayor de 800 se hace un descuento
del 20%.
Se pide mostrar el nombre del cliente, el importe total, el descuento y el

importe a cobrar a un cliente cualquiera

nombre nombre del cliente
importeTotal importe total
descto descuento
importeACobrar importe a cobrar
Inicio
real: importeTotal, descto, importeACobrar
cadena: nombre
// Lectura de datos
Escribir (“Ingresar nombre del cliente:”)
Leer (nombre)
Escribir (“Ingresar monto total de la compra:”)
Leer (importeTotal)
// Calcula el importe a Cobrar
Si (importeTotal >= 0 and importeTotal < 200) entonces
descto 0
Sino
Si (importeTotal <= 800) entonces
descto 0.10*importeTotal
Sino
descto 0.20*importeTotal
Fin_si
Fin_si
ImporteACobrar importeTotal - descto
Escribir (“Cliente: ”, nombre)
Escribir (“Descuento: ”, descto)
Escribir (“Importe total: ”, importeTotal)
Escribir (“Importe a cobrar: ”, importeACobrar)
Fin
Ejemplo 20
Una compañía de gaseosas está realizando una promoción por la compra de
su producto. Dentro de cada chapa viene un número que determina el
premio que obtiene un comprador.
Si la chapa tiene un número entre 1 y 5 el comprador obtiene como
premio el doble del precio pagado por la gaseosa.
Si la chapa tiene un número entre 6 y 8 el comprador obtiene como
premio la devolución del precio pagado por la gaseosa.
Si chapa tiene un número entre 9 y 10 el comprador no gana ningún
premio.
Escribir un pseudocódigo que muestre los diferentes resultados que se
podría obtener al comprar una gaseosa.
nro datos Premio

corrida precio nroChapa (soles)
1 0.50 5 1.0
2 1.00 4 2.0
3 3.00 9 0.0
4 5.00 7 5.0

nroChapa numero de chapa
precio precio de la gaseosa
premio premio a recibir
Inicio
entero: nroChapa
real: premio, precio
// Lectura de datos
Escribir (“Ingresar precio y nro de chapa: ”)
Leer (precio, nroChapa)
Si (nroChapa >=1 and nroChapa<=5 ) entonces
premio 2*precio
Sino
Si (nroChapa >=6 and nroChapa<= 8) entonces
premio precio
Sino
Si (nroChapa >=9 and nroChapa<=10) entonces
premio 0
Fin_si
Fin_si
Fin_si
Escribir (“Premio: ”, premio)
Fin
Ejemplo 21
El precio de venta de DVD varía de acuerdo a la cantidad que se compra:
• S/.2.50 si se compran unidades separadas hasta 9.
• S/.2.20 si se compran entre 10 unidades hasta 99.
• S/.1.90 entre 100 y 499 unidades
• S/.1.50 para mas de 500
El vendedor gana por cada CD vendido el 20% del costo. Realizar un
pseudocódigo que calcule el pago total y la ganancia para el vendedor.

cant cantidad de dvd
pago pago total
ganan ganancia del vendedor
Inicio
entero: cant
real: pago, ganan
// Lectura de datos
Escribir (“Ingresar cantidad de DVD: ”)
Leer (cant)
Si (cant < 10) entonces
pago 2.50 * cant
Sino
pago 2.20 * cant
Sino
pago 1.90 * cant
Sino
pago 1.50 * cant
Fin_si
Fin_si
Fin_si
ganan 0.20 * pago
Escribir (“El pago total es: ”, pago)
Escribir (“La ganancia del vendedor es: ”, ganan)
Fin
Ejemplo 22
Pseudocódigo que calcule el sueldo neto de un trabajador, que tiene los
siguientes descuentos:
• 11% del sueldo bruto si pertenece a la AFP A

• 10% del sueldo bruto si pertenece a la AFP B
• 7% del sueldo bruto por seguro si gana mas de 4000
• 6% del sueldo bruto por seguro si gana mas de 3000
• 5% del sueldo bruto por seguro si gana menos o igual a 3000

afp afp al que pertenece el empleado
sueldoBruto sueldo bruto
desc1 descuento por AFP
desc2 descuento por seguro
sueldoNeto sueldo neto
Inicio
caracter: afp
real: sueldoBruto, desc1, desc2, sueldoNeto
// Lectura de datos
Escribir (“Ingresar sueldo bruto: ”)
Leer (sueldoBruto)
Escribir (“Ingresar AFP: ”)
Leer (afp)
Si (afp = ‘A’) entonces
desc1 0.11 * sueldoBruto
Sino
Si (afp = ‘B’) entonces
Fin_si
Fin_si
Si (sueldoBruto > 4000) entonces
Sino
Si (sueldoBruto > 3000) entonces
Sino
Fin_si
Fin_si
sueldoNeto sueldoBruto – desc1 – desc2
Escribir (“El sueldo neto es: ”, sueldoNeto)
Fin
Ejemplo 23
Un supermercado ofrece a sus clientes descuentos de acuerdo al monto de
compra, como se muestra en el siguiente cuadro:
Compra (S/.) Descuento (%)

0 – 250 0
251 – 500 10
501 – 1000 15
1001 – más 20
Elaborar un pseudocódigo que calcule el monto final que paga un cliente por
una compra.

montoCompra monto de la compra
desc descuento
montoFinal monto final
Inicio
real: montoCompra, desc, montoFinal

// Lectura de datos
Escribir (“Ingresar monto compra: ”)
Leer (montoCompra)
Si (montoCompra <= 250) entonces
desc 0
Sino
desc 0.10 * montoCompra
Sino
Sino
Fin_si
Fin_si
Fin_si
montoFinal montoCompra – desc
Escribir (“El total a pagar es: ”, montoFinal)
Fin
Ejemplo 24
En empresa ensambladora de computadoras oferta a sus clientes descuentos
que varían de acuerdo al número de computadoras que se compre. Si se
compra hasta cinco computadoras se descontará el 10%, si se compra entre
6 y 10 computadoras se descuenta el 20% y si se compra más de 10
computadoras se descuenta el 40%.
Elaborar un pseudocódigo que calcule el monto final que se paga por un
cierto número de computadoras.

precio precio de venta
total total a pagar
desc descuento
cant cantidad de computadoras
Inicio
real: precio, total, desc
entero: cant
// Lectura de datos
Escribir (“Ingresar precio: ”)
Leer (precio)
Escribir (“Ingresar cantidad: ”)
Leer (cant)
total precio * cant
Si (cant <= 5) entonces
desc 0.10 * total
Sino
desc 0.20 * total
Sino
desc 0.40 * total
Fin_si
Fin_si
total total – desc
Escribir (“El total a pagar es: ”, total)
Fin
Ejemplo 25
Pseudocódigo que compruebe si tres lados forman un triángulo, de ser así
calcule su área y muestre que tipo de triangulo forma: equilátero, isósceles
o escaleno.
Teorema: En todo triángulo cada lado es menor que la suma de los otros dos
lados, pero mayor que su diferencia.
Para hallar el área de un triángulo conociendo sus lados se aplica la

siguiente fórmula:
area = p( p − a)( p − b)( p − c)
Donde, p es el semiperímetro.

a, b, c lados del triángulo
p semiperímetro
area área del triángulo
Inicio
real: p, area
entero: a, b, c
// Lectura de datos
Escribir (“Ingresar lados: ”)
Leer (a, b, c)
Si ((a < b + c) and (b < a + c) and (c < a + b)) entonces
Escribir (“Forman un triángulo”)
p (a + b + c) /2
area raiz (p * (p - a) * (p - b) * (p - c))
Si (a = b and b = c) entonces
Escribir (“Equilátero”)
Sino
Si (a = b or b = c or a = c) entonces
Escribir (“Isósceles”)
Sino
Escribir (“Escaleno”)
Fin_si
Fin_si
Escribir (“El área es ”, area)
Sino
Escribir (“No forman un triángulo”)
Fin_si
Fin
Ejemplo 26
Pseudocódigo que calcula la calificación de un alumno en base a 3 notas,
validar el ingreso de notas entre 0 y 100, considerar la siguiente tabla:
Promedio Calificación
90 – 100 A
80 – 89 B
70 – 79 C
50 – 69 D
0 – 49 E

nt1 nota 1
nt2 nota 2
nt3 nota 3
caft carácter de calificación
prom promedio
Inicio
entero: nt1, nt2, nt3, prom
caracter: calf
// Lectura de datos
Escribir (“Ingresar tres notas: ”)
Leer (nt1, nt2, nt3)
Si ((nt1 >= 0 and nt1 <= 100) and (nt2 >= 0 and nt2 <= 100) and
(nt3 >= 0 and nt3 <= 100)) entonces
prom (nt1 + nt2 + nt3) Div 3
Si (prom > 89) entonces
calf ‘A’
Sino
calf ‘B’
Sino
calf ‘C’
Sino
calf ‘D’
Sino
calf ‘E’
Fin_si
Fin_si
Fin_si
Fin_si
Escribir (“La calificación es: ”, calf)
Sino
Escribir (“Ingreso incorrecto”)
Fin_si
Fin
Ejemplo 27
Una clínica ofrece tres tipos de seguro:
Tipo Máximo De consultas Pago mensual (S/.)

A 8 80.00
B 6 60.00
C 4 40.00
Si el cliente realiza más consultas de las indicadas en el cuadro anterior

tendrá que pagar S/.8.50 por cada consulta adicional si el seguro es de tipo
A, S/.6.50 por cada consulta adicional si el seguro es de tipo B, y S/.5.00
mensuales por cada consulta adicional si el seguro es de tipo C. Calcular el
monto que paga un cliente durante un mes.

tipo tipo de seguro
cant cantidad de consultas realizadas en el mes
max maximo número de consultas
padic pago adicional
pago pago mensual
Inicio
entero: cant, max
real: pago 0, padic
caracter: tipo
entero: cant
// Lectura de datos
Escribir (“Ingresar tipo de seguro: ”)
Leer (tipo)
Escribir (“Ingresar cantidad de consultas: ”)
Leer (cant)
Si (tipo = ‘A’) entonces
pago 80.00
max 8
padic 8.50
Sino
Si (tipo = ‘B’) entonces
pago 60.00
max 6
padic 6.50
Sino
Si (tipo = ‘C’) entonces
pago 40.00
max 4
padic 5.00
Fin_si
Fin_si
Fin_si
Si (cant > max) entonces
padic padic * (cant - max)
Fin_si
pago pago + padic
Escribir (“El total a pagar es: ”, pago)
Fin
Ejemplo 28
Un centro comercial bonifica a sus clientes con puntos los cuales son
reemplazados por obsequios. Por compras menores a S/.10.00 el cliente
recibe 1 punto, por compras de S/.10.00 a más el cliente recibe 2 puntos
por cada S/.10.00 y un punto por el monto adicional. Elaborar un
pseudocódigo que calcule la cantidad de puntos que obtiene un cliente en
una compra.
Por ejemplo:
• Si la compra es de S/.7.00 el cliente recibe 1 punto
• Si la compra es de S/.23.00 el cliente recibe 5 puntos (2 puntos por cada
S/.10.00 y 1 punto por los S/.3.00).
• Si la compra es de S/.40.00 el cliente recibe 8 puntos (2 puntos por cada
S/.10.00)

punto puntos obtenidos
monto monto de la compra
parEnt valor entero de la compra
resto1 residuo del valor entero de la compra
resto2 valor real de la compra
c10 cantidad de montos de S/.10.00
Inicio
entero: punto 0, parEnt, resto2, c10
real: monto, resto1 0
// Lectura de datos
Escribir (“Ingresar monto de la compra: ”)
Leer (monto)
Si (monto < 10) entonces
punto 1
Sino
parEnt entero (monto)
resto1 monto – parEnt
resto2 parEnt Mod 10
c10 parEnt Div 10
Si (resto1 > 0 or resto2 >0) entonces
punto (2 * c10) + 1
Sino
punto 2 * c10
Fin_si
Fin_si
Escribir (“Los puntos obtenidos son: ”, punto)
Fin
Ejemplo 29
Un grupo de alumnos de un centro educativo, desea saber cuanto se va a
gastar en pasajes para realizar el viaje de promoción, el precio de cada
pasaje varía de acuerdo al día en que viajan y al número de alumnos que
viajan:
Cantidad de Precio x pasaje ($)

alumnos Hasta el día 15 del mes Después del día 15 del mes
1 – 10 60 50
11 – 20 55 45
21 – mas 50 40
Elaborar un pseudocódigo que muestre el costo total de los pasajes.

dia dia del mes en el que se desea viajar
cant cantidad de alumnos
total monto total a pagar por los pasajes
Inicio
entero: dia, cant
real: total
// Lectura de datos
Escribir (“Ingresar día del mes: ”)
Leer (dia)
Escribir (“Ingresar cantidad de alumnos: ”)

Leer (cant)
Si (dia <= 15) entonces
total 60 * cant
Sino
total 55 * cant
Sino
total 50 * cant
Fin_si
Fin_si
Sino
total 50 * cant
Sino
total 45 * cant
Sino
total 40 * cant
Fin_si
Fin_si
Fin_si
Escribir (“El costo total de los pasajes es: ”, total)
Fin
3.3.2. Estructura selectiva múltiple: En caso sea – Fin_caso
Ejecuta una acción dependiendo del resultado del selector. Se presenta

como una alternativa de la sentencia Si anidada, ya que en ocasiones resulta
ser más comprensible y ordenado. Su sintaxis es la siguiente:
En caso sea (selector) hacer

c1: Acción 1
c2: Acción 2
.
.
.
cn: Acción N
Sino
Accion c
Fin_Caso
Donde:
• Selector, cuyo valor se compara con cada una de las alternativas (c1, c2,
etc).
• c1, c2, etc., son constantes enteras o de tipo caracter compatibles con el
selector. Si es de tipo caracter c1, c2, etc. deben de ir encerradas entre
comillas simples, es decir ‘c1’, ‘c2’, etc.
• Sino, cuando toma un valor distinto de las alternativas (c1, c2, etc). El
Sino es opcional, si se omite y no hay coincidencia finaliza la sentencia
En caso sea – Fin_caso sin ejecutar nada.
Las sentencias si anidadas pueden aplicarse a cualquier tipo de dato simple,

en contraste con la sentencia En caso – Fin_caso donde solo puede aplicarse
al selector variables: enteras y caracteres.
Funcionamiento de En caso sea – Fin_caso

Cuando la sentencia En caso sea – Fin_caso inicia su ejecución, se suceden
los siguientes pasos:
a) Se evalúa el Selector, obteniéndose un resultado de tipo entero o
carácter.
b) Se compara este resultado con las alternativas (constantes) c1, c2, etc.
c) Si algunas de estas constantes es igual al valor del selector, entonces se
ejecutan la acción correspondiente a esa alternativa y se va al paso e.
d) Si no existe coincidencia con las alternativas, se ejecutará la acción
correspondiente al Sino y se va al paso e.
e) La ejecución del pseudocódigo proseguirá con la siguiente sentencia que
sigue al Fin_Caso
Ejemplo 30
Pseudocódigo que lea una variable entera, que representa un día de la
semana y que muestre el texto correspondiente al día. Por ejemplo: Lunes si
es 1, Martes si es 2, …, Domingo si es 7.
El siguiente cuadro muestra resultados con datos de prueba:
Día Texto a mostrar

1 Lunes
4 Jueves
6 Sábado

dia día de la semana
Inicio
// Definir variable
entero: dia
// Lectura de datos
Escribir (“Ingresar dia:”)
Leer (dia)
En caso sea (dia) hacer
1 : Escribir (“lunes”)
2 : Escribir (“martes”)
3 : Escribir (“miércoles”)
4 : Escribir (“jueves”)
5 : Escribir (“viernes”)
6 : Escribir (“sábado”)
7 : Escribir (“domingo”)
Sino
Escribir (“Fuera de rango”)
Fin_Caso
Fin
Explicación
Para resolver el ejemplo planteado se define la variable entera dia:

entero: dia
Se ingresa la variable dia

Escribir (“Ingresar dia:”)
Leer (dia)
Y se evalua el contenido de la variable dia mediante la sentencia En caso sea

- hacer, si coincide con algunos de los valores de 1 a 7 se ejecuta la
sentencia correspondinte al valor que coincide y la ejecución del
pseudocódigo proseguira con la siguiente sentencia a Fin_caso:
En caso sea (dia) hacer
1 : Escribir (“lunes”)
2 : Escribir (“martes”)
3 : Escribir (“miércoles”)
4 : Escribir (“jueves”)
5 : Escribir (“viernes”)
6 : Escribir (“sábado”)
7 : Escribir (“domingo”)
Si no coincide con algunos de los valores de la sentencia En caso sea – hacer

se ejecuta la sentencia Sino, ejecutándose:
Sino
Ejemplo 31
Pseudocódigo que permite ingresar una calificación expresada con un
caracter (a, b, c o d) y averiguar su equivalencia correspondiente de acuerdo
a la siguiente tabla:
Nota Descripción
A Sobresaliente
B Notable
C Aprobado
D Insuficiente
Otra letra Nota no esta en el rango

nota nota del alumno
Inicio
// Definir variable
caracter: nota
// Lectura de datos
Escribir (“Ingresar nota”)
Leer (nota)
En caso sea (nota) hacer
‘A’: Escribir (“Sobresaliente”)
‘B’: Escribir (“Notable”)
‘C’: Escribir (“Aprobado”)
‘D’: Escribir (“Insuficiente”)
Sino
Escribir (“Nota no esta en el rango”)
Fin_caso
Fin
Ejemplo 32.
Una compañía incrementa el sueldo actual de sus empleados de acuerdo a
su categoría como se muestra en el siguiente cuadro:
Categoría Incremento (%)

A 25
B 20
C 15
D 10
Además recibe un aumento especial de 2.5% de su sueldo actual por cada

hijo que tuviese. Así mismo si el nuevo sueldo excede a S/.2000 se
descuenta el 3% por impuesto de solidaridad. Construir un pesudocódigo
que permita calcular el sueldo neto que recibe un empleado de dicha
compañía.

cat categoría del empleado
sueldo sueldo del empleado
cant cantidad de hijos del empleado
aum aumento
adic pago adicional por cada hijo
desc descuento de solidaridad
sueldoNeto sueldo neto
sw bandera que cambia de valor cuando se ingresa una
categoría no existente
Inicio
entero: cant
real: sueldo, aum, adic, desc, sueldoNeto
caracter: cat
// Lectura de datos
Escribir (“Ingresar categoría”)
Leer (cat)
Escribir (“Ingresar sueldo”)
Leer (sueldo)
Escribir (“Ingresar cantidad de hijos”)
Leer (cant)
En caso sea (cat) hacer
‘A’: aum 0.25 * sueldo
‘B’: aum 0.20 * sueldo
‘C’: aum 0.15 * sueldo
‘D’: aum 0.10 * sueldo
Sino
Escribir (“Categoría no existe”)
sw 1
Fin_caso
Si (sw = 0) entonces
sueldo sueldo + aum
Si (cant > 0) entonces
adic 0.025 * sueldo * cant
Fin_si
sueldo sueldo + adic
Si (sueldo > 2000) entonces
desc 0.03 * sueldo
Fin_si
sueldoNeto sueldo - desc
Escribir (“El sueldo neto del empleado es ”, sueldoNeto)
Fin_si
Fin
En ocasiones es necesario el uso de una variable que altere el

funcionamiento del algoritmo, cambiando su valor entre 0 y 1 ó entre
verdadero y falso, a esta variable también se le conoce como switch o
bandera. Para nuestro ejemplo se ha utilizado la variable sw inicializado en

cero; este valor cambia a 1 al entrar al sino del En caso sea, luego de
identificar que se ha ingresado una categoría diferente a las existentes; esto
permite que una vez impreso el mensaje de error ya no se realice los
siguientes cálculos.
Ejemplo 33
Pseudocódigo que actúe como una calculadora, permitiendo realizar las
operaciones de suma, resta, multiplicación y división entre dos números
cualquiera.

n1 primer número
n2 segundo número
res resultado de la operación
oper operador
sw bandera que cambia de valor cuando en la división se ingresa
un divisor igual a 0
Inicio
real: n1, n2, res
caracter: oper
entero: sw 0
// Lectura de datos
Escribir (“Ingresar primer número”)
Leer (n1)
Escribir (“Ingresar operador”)
Leer (oper)
Escribir (“Ingresar segundo número”)
Leer (n2)
En caso sea (oper) hacer
‘+’: res n1 + n2
‘-’ : res n1 - n2
‘*’: res n1 * n2
‘/’ : Si (n2 <>0)
res n1 / n2
Sino
Escribir (“Error”)
sw 1
Fin_si
Sino
Escribir (“Operador no válido”)
sw 1
Fin_caso
Escribir (“El resultado es ”, res)
Fin_si
Fin
Ejemplo 34
Un centro comercial ofrece ventas financiadas por medio de 3 tipos de
tarjetas de crédito como indica a continuación:
Tipo de Tarjeta Máximo de Letras Interés (%)

A 36 7
B 24 6
C 12 5
El cliente solo puede financiar una compra hasta el máximo de letras que se
indica en el cuadro anterior, en caso contrario la venta no debe proceder.
Calcular el monto de cada letra por pagar así como el monto total.

tipo tipo de tarjeta
monto monto de la compra
cant cantidad de letras que se desea financiar
max máximo de letras a financiar
inte interés del la compra
letra monto de cada letra
Inicio
entero: cant, max, sw 0
real: monto, inte, letra
caracter: tipo
// Lectura de datos
Escribir (“Ingresar tipo de tarjeta”)
Leer (tipo)
Escribir (“Ingresar monto de la compra”)
Leer (monto)
Escribir (“Ingresar cantidad de letras a financiar”)
Leer (cant)
En caso sea (tipo) hacer
‘A’: max 36
inte 0.07 * monto
‘B’: max 24
inte 0.06 * monto
‘C’: max 12
inte 0.05 * monto
Sino
Escribir (“Tipo de tarjeta no existe”)
sw 1
Fin_caso
monto monto + inte
Si (cant <= max) entonces
letra monto / cant
Escribir (“El monto total a pagar es ”, monto)
Escribir (“El monto de cada letra es ”, letra)
Sino
Escribir (“La venta no procede”)
Fin_si
Fin_si
Fin
Ejemplo 35
Calcular el consumo de combustible y el total que se invirtió en el recorrido
de un automóvil. Para esto se debe diseñar un algoritmo en el que se
ingresa los kilometrajes con el que inicia y termina el recorrido, así como la
cantidad de galones de combustible con el que se inicia y termina el
recorrido. Además calcular la cantidad de galones que consume el auto por
cada 100 kilómetros. Los precio por cada galón de combustible son:
Tipo de combustible Precio (S/.) x galón

Gasolina 97 16.98
Gasolina 95 15.60
Gasolina 89 13.50
Diesel 10.20

kil1 kilometraje de incio de recorrido
kil2 kilometraje fin del recorrido
gal1 galones de inicio de recorrido
gal2 galones fin de recorrido
tipo tipo de combustible
kilRec kilómetros recorridos
totGal total de galones
total total que se invirtio en el recorrido
c100 cantidad de galones que consume el auto por cada 100 km
Inicio
entero: tipo
real: kil1, kil2, gal1, gal2, kilRec 0, totGal 0, total, c100
// Lectura de datos
Escribir (“Ingresar kilometraje de inicio y fin del recorrido”)
Leer (kil1, kil2)
Escribir (“Ingresar galones con el que inicia y termina el recorrido”)
Leer (gal1, gal2)
Escribir (“Ingresar tipo de combustible que usa el automóvil
(1)Gasolina 97, (2)Gasolina 95, (3)Gasolina 89, (4)Diesel”)
Leer (tipo)
Si (tipo > 0 and tipo < 5) entonces
En caso sea (tipo) hacer
1 : precio 16.98
2 : precio 15.60
3 : precio 13.50
4 : precio 10.20
Fin_caso
kilRec kil2 – kil1
totGal gal2 – gal1
total totGal * precio
c100 (totGal * 100) / kilRec
Escribir (“El total de combustible que se consumió es ”, totGal)
Escribir (“El total de se invirtió en el recorrido es ”, total)
Escribir (“El consumo por cada 100 kilómetros es ”, c100)
Sino
Escribir (“El tipo de combustible no es válido”)
Fin_si
Fin
3.3.3. Estructura selectiva múltiple: En caso sea múltiple
La sentencia En caso sea múltiple se presenta de dos formas:
a) Cuando más de una alternativa debe ejecutar la misma acción; para

estos casos se agrupan todas las alternativas con acciones comunes.
Ejemplo 36
Pseudocódigo que determine si un número que se encuentre en el rango de
1 a 9, es par o impar.
valores de la variable nro.
Nro de
Nro Resultado
corrida
1 5 impar
2 2 par
3 9 impar
5 10 Error fuera de rango

nro número a determinar si es par o impar
Inicio
// Definir variable
entero: nro
// Lectura de datos
Escribir (“Ingresar número:”)
Leer (nro)
En caso sea (nro) hacer
1: 3: 5: 7: 9: Escribir (“impar”)
2: 4: 6: 8 : Escribir (“par” )
sino
Fin_Caso
Fin
Ejemplo 37
En un campeonato de tiro al blanco se ha llegado a un acuerdo entre los
participantes para que el puntaje obtenido sea calculado en base al puntaje
original (el que esta entre 0 y 10) alcanzado en el tiro multiplicado por un
factor el cual se muestra en el siguiente cuadro. Hacer un pseudocódigo que
muestre el nuevo puntaje obtenido por cualquier participante.
Puntaje original Factor

0 0
Entre 1 y 5 6
Entre 6 y 8 9
Entre 9 y 10 10

puntaje puntaje original
factor factor multiplicativo
nuevoPuntaje nuevo puntaje del participante
sw bandera que condiciona el cálculo del nuevo puntaje
Inicio
entero: factor, puntaje, nuevoPuntaje, sw 0
// Lectura de datos
Escribir (“Ingresar puntaje:”)
Leer (puntaje)
// Calcula puntaje
En caso sea (puntaje) hacer
0: factor 0
1: 2: 3: 4: 5: factor 6
6: 7: 8: factor 9
9: 10: factor 10
Sino
sw 1
Fin_Caso
nuevoPuntaje puntaje + factor
Escribir (“El nuevo puntaje es ”, nuevoPuntaje)
Fin_si
Fin
Ejemplo 38
Pseudocódigo que permita calcular cuántos días tiene un mes, teniendo en
cuenta lo siguiente:
a) El orden del calendario indica que enero es 1, febrero es 2, etc.
b) Enero, marzo, mayo, julio, agosto, octubre y diciembre tienen 31 días.
c) Abril, junio, setiembre y noviembre tienen 30 días.
d) Febrero tiene 28 días o 29 días si el año bisiesto. Un año es bisiesto si es
múltiplo de 4 y no de 100 o cuando es múltiplo de 400.

variables:
Nro datos Resultado

corrida Mes Año Día
1 2 2004 29
2 4 2016 29
3 2 2001 28
4 2 2000 29
5 10 2006 31
6 4 2007 30

dia día que tiene un mes
mes mes del año
year año a determinar si es bisiesto
Inicio
entero: mes, year, dias
// Lectura de datos
Escribir (“Ingresar mes, año ”)
Leer (mes, year)
En caso sea (mes) Hacer
1: 3: 5: 7: 8: 10: 12: dias 31
4: 6: 9: dias 30
2: Si (year Mod 4 = 0) and (year Mod 100 <> 0) or
(year Mod 400 = 0)) entonces
dias 29
Sino
dias 28
Fin_si
Fin_Caso
Escribir (mes, year, dias)
Fin
b) Cuando se presentan selecciones basadas en dos o más niveles; en estos

casos se utiliza la sentencia En caso sea anidado.
Ejemplo 39
Pseudocódigo para calcular la pensión que tiene que pagar un alumno de un
instituto cuya cuota de matricula tiene un porcentaje de descuento que se
establece en la siguiente tabla y esta en función del colegio de procedencia
del alumno y de las tres categorías que existe en el instituto. Considere que
la pensión esta exonerada de impuesto.
Colegio de Categoría
procedencia A B C
Nacional 50 40 30
Particular 15 20 25

variables:
Pensión Colegio Categoría Descuento Pensión final

1000 Nacional A 1000*0.05=500 500.0
1500 Particular B 1500*0.20=300 1200.0

colegio colegio de procedencia
categoria categoría dentro del instituto
dscto descuento a realizar
cuota pago mensual
importe importe a pagar
Inicio
real: cuota, dscto, importe 0
caracter: colegio, categoría
entero: sw 0
// Lectura de datos
Escribir (“Ingresar colegio de procedencia (N)acional, (P)articular:”)
Leer (colegio)
Escribir (“Ingresar categoría (A, B, C):”)
Leer (categoria)
Escribir (“Ingresar cuota:”)
Leer (cuota)
// Cálculos
En caso sea (colegio) hacer
‘N’: En caso sea (categoria) hacer
‘A’ : dscto 0.50 * cuota
‘B’ : dscto 0.40 * cuota
‘C’ : dscto 0.30 * cuota
Sino
Escribir (“Opción no contemplada”)
sw 1
Fin_caso
‘P’: En caso sea (categoria) hacer
‘A’ : dscto 0.25 * cuota
‘B’ : dscto 0.20 * cuota
‘C’ : dscto 0.15 * cuota

Sino
sw 1
Fin_caso
Sino
sw 1
Fin_caso
importe cuota – dscto
Escribir(“El importe a pagar es: ”, importe)
Fin_si
Fin
Ejemplo 40
Calcular el pago de un obrero que trabaja al destajo. El pago que recibe el
obrero por cada unidad producida depende de su categoría y del tipo de
producto que produce, como se muestra en el siguiente cuadro:
Tarifa (S/. x unidad)

Categoría
Tejas Losetas
A 2.50 2.00
B 2.00 1.50
C 1.50 1.00
Así mismo, el obrero recibe una bonificación especial de acuerdo a la

cantidad que produce:
Unidades Producidas Bonificación (%)

1 – 250 0.00
251 – 500 50.00
501 – 1000 100.00
1001 – mas 150.00
Además del total de ingresos se descuenta S/.25.00 por seguro.

cat categoría del obrero
prod producto que se produce
cant cantidad producida
pago pago del obrero
bonf bonificación
desc descuento
sw bandera
Inicio
entero: cant, sw 0
real: pago, bonf, desc 25.00
caracter: cat, prod
// Lectura de datos
Escribir (“Ingresar categoría:”)
Leer (cat)
Escribir (“Ingresar producto que produce (T)ejas, (L)osetas”)
Leer (prod)
Escribir (“Ingresar cantidad producida:”)
Leer (cant)
// Cálculos
En caso sea (prod) hacer
‘T’: En caso sea (cat) hacer
‘A’ : pago 2.50 * cant
‘B’ : pago 2.00 * cant
‘C’ : pago 1.50 * cant
Sino
sw 1
Fin_caso
‘L’: En caso sea (cat) hacer
‘A’ : pago 2.00 * cant
‘B’ : pago 1.50 * cant
‘C’ : pago 1.00 * cant
Sino
sw 1
Fin_caso
Sino
Escribir (“Producto no existe”)
sw 1
Fin_caso
bonf 0
Sino
bonf 50.00
Sino
bonf 100.00
Sino
bonf 150.00
Fin_si
Fin_si
Fin_si
pago pago + bonf – desc
Escribir (“El pago del obrero es: ”, pago)
Fin_si
Fin
3.4.Ejercicios propuestos
1. Evaluar la siguiente función:
x 2 si ( x Mod 4 ) = 0

x / 6 si ( x Mod 4 ) = 1
f (x ) = 
 x si ( x Mod 4 ) = 2
x 3 + 5 si ( x Mod 4 ) = 3

2. Una compañía de gaseosas esta realizando una promoción por la compra de

sus productos. Dentro de cada chapa viene un número que determina el
premio que obtiene un comprador.
Si la chapa tiene un número entre 1 y 5 el comprador obtiene como premio

el doble del precio pagado por la gaseosa.
Si la chapa tiene un número entre 6 y 8 el comprador obtiene como premio
la devolución del precio pagado por la gaseosa
Si chapa tiene un número entre 9 y 10 el comprador no gana ningún premio
Se pide mostrar los diferentes resultados que podría obtener un comprador
al comprar una gaseosa. Utilizar la sentencia En caso sea.
3. Escribir un programa para hallar el valor absoluto de un número:
 0, si x = 0

x =  x, si x > 0
- x, si x < 0

Por Ejemplo:
• De -7 su valor absoluto es: -(-7) = 7 (cuando es negativo se cambia de
signo)
• De 7 su valor absoluto es: (7) = 7 (cuando es positivo nos da el mismo
número)
4. Escribir un programa para leer dos números a, b y obtenga el valor
numérico de la función.
 2 a + b, si a2 - b 2 < 0

f (x ) = a2 - 2b, si a2 - b 2 = 0
 a + b, si a2 - b 2 > 0

5. Pseudocódigo que determine si un número es divisible por 5. Un número es
divisible por 5 cuando acaba en cero 0 en 5.
6. Mostrar el nombre correspondiente a un número de mes y además mostrar
la estación al cual pertenece. Considerar 3 meses por estación.
Verano = enero, febrero, marzo
Otoño = abril, mayo, junio
Invierno = julio, agosto, setiembre
Primavera = octubre, noviembre, diciembre.
7. Ingresar cuatro valores por el teclado a, b, c, d. Se desea redondear a la
centena más próxima y visualizar la salida. Por ejemplo:
a = 2, b = 3, c = 6 y d = 2 entonces n = 2362 el resultado redondeado será
2400.
Si n = 2342 el resultado redondeado será 2300
Si n = 2962 el resultado redondeado será 3000
8. Pseudocódigo que lea tres números y diga si la suma de los dos primeros
números es igual al tercer número.
9. Una empresa de bienes y raíces ofrece casas de interés social bajo las
siguientes condiciones: si el ingreso mensual del comprador es menos de
S/2250 la cuota inicial será igual al 15% del costo de la casa y el resto se
distribuirá en 120 cuotas mensuales. Si el ingreso mensual del comprador es
mayor o igual a S/.2250 la cuota inicial será igual al 30% del costo de la
casa y el resto se distribuirá en 75 cuotas mensuales. Diseñe un algoritmo
que permita determinar cuanto debe pagar un comprador por concepto de
cuota inicial y cuanto por cada cuota mensual.
10. En una escuela la colegiatura de los alumnos se determina según el número
de materias que cursan. El costo de todas las materias es el mismo. Se ha
establecido un programa para estimular a los alumnos, el cual consiste en lo
siguiente: si el promedio obtenido por un alumno en el ultimo periodo es
mayor o igual que 15, se le hará un descuento del 30% sobre la colegiatura
y no se le cobrara impuesto; si el promedio obtenido es menor que 15
deberá pagar la colegiatura completa, la cual incluye el 10% de impuesto.
Obtener cuanto debe pagar un alumno.
11. Una persona desea iniciar un negocio, para lo cual piensa verificar cuanto
dinero le prestará el banco por hipotecar su casa. Tiene una cuenta
bancaria, pero no quiere disponer de ella a menos que el monto por
hipotecar su casa sea muy pequeño. Si el monto de la hipoteca es menor
que $30,000 entonces invertirá el 50% de la inversión total y un socio
invertirá el otro 50%. Si el monto de la hipoteca es de $30,000 o mas,
entonces invertirá el monto total de la hipoteca y el resto del dinero que se
necesite para cubrir la inversión total se repartirá a partes iguales entre el
socio y el.
12. Elaborar un algoritmo que tenga como entrada los valores de dos ángulos,
expresados en grados, minutos y segundos, obtenga el valor de su suma de
la misma forma. Se supone que las entradas son correctas, en el sentido de
que cada ángulo está expresado como tres números enteros, en los rangos
respectivos (0 - 360), (0 - 60) y (0 - 60). La salida debe estar expresada de
la misma manera.
13. El ministerio de agricultura ha distribuido la siembra de 3 productos en
terrenos con más de 1000 hectáreas de la siguiente manera:
Producto Terreno (%)

Papa 50
Zanahoria 30
Camote 20
Si la superficie del terreno es menor o igual 1000 hectáreas, se deberá
sembrar de la siguiente manera:
Producto Terreno (%)

Papa 60
Zanahoria 25
Camote 15
Se desea saber la cantidad de toneladas de papa, zanahoria y camote que se
espera cosechar, si se sabe que se obtiene 2 toneladas de papa, zanahoria y
camote en 10, 8 y 9 hectáreas respectivamente.
14. Una empresa eléctrica dispone de la siguiente tabla de costos:
Cod. de tarifa Descripción Tarifa 1 kw/hora (S/.) Porcentaje (%)

1 Domestico 35.00 1.5
2 Industrial 80.00 2.5
3 Comercial 100.00 3
Además se dispone del cobro de un impuesto especial que esta dado por los
porcentajes mencionados en el cuadro anterior, así como el cobro por
arbitrios municipales:
Alumbrado público 4.5%
Limpieza pública 10%
Parques y jardines 2.5%
15. Calcular el costo del servicio de mudanza, de acuerdo a la distancia entre el
punto de partida y de llegada, el tipo de carga y al número de viajes ida y
vuelta. Para calcular el costo se debe tener en cuenta:
a) Si la distancia por cada viaje es mayor o igual a 5 Km., se cobrará
S/.5.00 por kilómetro, de lo contrario se cobrará el monto básico que
será igual a S/.25.00.
b) La carga puede ser frágil o no frágil. Solo si la carga es frágil al monto
calculado anteriormente se le aumentará 20%.
c) El monto resultante de acuerdo a la distancia y al tipo de carga se
multiplicará por el número de viajes.
16. Una empresa calcula las bonificaciones de sus empleados teniendo en
cuenta lo siguiente: si el sueldo del empleado es menor a S/.750, recibe una
bonificación del 15% del sueldo, si el sueldo esta entre S/.750 y S/.1200,
recibe una bonificación del 10% y si el sueldo es superior a los S/.1200,

recibe una bonificación del 7%.
4. Estructura repetitiva
Las estructuras repetitivas se utilizan cuando es necesaria la repetición de una o

mas sentencias, en un número determinado de veces, ó tantas veces como lo
permita el resultado de una expresión lógica. Los controles de esta estructura son:
mientras, repetir y para.
Dentro de las estructuras repetitivas intervienen los contadores y acumuladores,

que son variables que toman valores iniciales antes de que empiece el proceso
repetitivo, para que luego, dentro del proceso repetitivo, incrementar sus valores
según la lógica de solución del problema.
4.1.Conceptos básicos
• Contador
Es una variable numérica entera que se incrementa o decrementa cada vez que
se ejecuta la acción que lo contiene, toma un valor inicial de cero o uno, según
sea el caso. En la siguiente figura la variable i representa a un contador.
i = i + 1
valor actual valor anterior cantidad a incrementar
• Acumulador o totalizador
Es una variable numérica que se incrementa o decrementa de forma no
constante, toma un valor inicial de cero o uno según sea el caso. En la siguiente
figura, la variable total representa a un acumulador y la variable parcial es la
cantidad que se incrementará el acumulador en cada iteración.
total = total + parcial
valor actual valor anterior cantidad a incrementar
• Bucle
Es un mecanismo de programación que repite un segmento de un programa
(una o mas sentencias) un cierto número de veces. Los bucles se implementan
utilizando las sentencias repetitivas: mientras, repetir y para.
• Cuerpo del bucle

Son las sentencias que se ejecutarán repetidamente un cierto número de veces.
• Iteración
Representa cada repetición del cuerpo de bucle.
4.2.Estructura repetitiva Mientras – Fin_mientras
Repite una o mas acciones mientras el resultado de una expresión lógica es

verdadera (true). Si el resultado de la expresión lógica es falsa (false), este
proceso de repetición termina, y la ejecución del programa continúa con la
siguiente sentencia que sigue al Fin_mientras. Su sintaxis es la siguiente:
Mientras (expresión_lógica) hacer

Acción
Fin_Mientras
Funcionamiento de Mientras – Fin_mientras

Cuando la sentencia Mientras inicia su ejecución, se suceden los siguientes
pasos:
a) Se evalúa expresión_lógica, obteniéndose un resultado lógico.
b) Si este resultado es verdadero (true), se ejecuta la acción y se retorna al
paso a.
c) Si este resultado es falso (false), la ejecución del pseudocódigo proseguirá
con la sentencia siguiente al Fin_Mientras.
Ejemplo 01
Pseudocódigo que invierta un número entero positivo.

nro número a invertir
nro1 variable auxiliar donde guardamos el número nro
nroinvertido número invertido
digito dígito
Inicio
entero: nro, nro1, digito, nroinvertido 0
// Leer Datos
Leer (nro)
// Calcular número invertido
nro1 nro
Mientras (nro > 0) hacer
digito nro Mod 10
nroinvertido 10 * nroinvertido + digito
nro nro Div 10
Fin_Mientras
Escribir (“El número invertido de ”, nro1, “es ”, nroinvertido)
Fin
Explicación
Para resolver el ejemplo planteado se definen las variables enteras: nro, nro1,
dígito y se inicializa en cero la variable nroinvertido
entero: nro, nro1, digito, nroinvertido 0
Se ingresa la variable nro:
Leer (nro)
Y se asigna nro a una nueva variable nro1, para conservar el valor original del
número ingresado:
nro1 nro
La sentencia Mientras ejecuta tres sentencias, mientras que la expresión lógica
(nro > 0) es verdadera, en estas sentencia se va extrayendo cada dógito del
número ingresado:
digito nro Mod 10
nroinvertido 10 * nroinvertido + digito
nro nro Div 10
Fin_Mientras
Cuando la expresión logica (nro > 0) llega a ser falsa, se ejecuta la sentencia
escribir y finaliza el pseudocódigo:
Escribir (“El número invertido de ”, nro1, “es ”, nroinvertido)
Por ejemplo si el número es 134, entonces el número invertido será 431. Para
ir reduciendo cada número emplearemos la operación:
nro nro Div 10

Así tenemos:
134 Div 10 = 13
13 Div 10 = 1
1 Div 10 = 0 Se detiene cuando
es cero
A la vez, para obtener cada dígito emplearemos la operación:
digito digito Mod 10
Así tenemos:
134 Mod 10 = 4
13 Mod 10 = 3
1 Mod 10 = 1
Se puede ir formando el número invertido multiplicando el mismo número

invertido por 10 y agregándole cada digito empleando la operación:
nroinvertido = 10 * nroinvertido + digito
Que en valores es:
10 * 0 + 4 = 4
10 * 4 + 3 = 43
10 * 43+ 1 = 431
Inicialmente nroinvertido = 0
La siguiente tabla muestra los resultados de la corrida del algoritmo.
Resultado
Iteración Valores Expresión Resultados del cuerpo del bucle
de la
nro de Lógica digito = nroinvertido = nro =
Expresión
nro nro > 0 nro Mod 10 10*nroinvertido nro Div 10
Lógica
+ digito
1 134 134>0 True 4 4 13
2 13 13 >0 True 3 43 1
3 1 1> 0 True 1 431 0
--- 0 0>0 False Fin del Mientras
Ejemplo 02
Pseudocódigo que multiplique dos números enteros utilizando el siguiente
algoritmo:
• Proceso de división: Se divide por 2 el primer número y se obtiene un

cociente. Se divide por 2 este cociente y se obtiene otro cociente. Se
continúa este proceso de división por 2, hasta que el número cociente sea 1.
• Proceso de Multiplicación: Se multiplica por 2 el segundo número y se

obtiene un número. Se multiplica por 2 este número y se obtiene otro
número. Se continúa este proceso de multiplicación por 2 hasta que el
cociente obtenido en el paso 1 sea igual a 1.
• Se suma el segundo número con todos los valores obtenidos al multiplicar el
segundo número por 2 siempre y cuando sus correspondientes valores al
dividir el primer número por 2 sea impar. El resultado de esta suma será la
multiplicación de ambos números.
Por ejemplo si se tiene los números 23 y 4, emplearemos para el proceso de

división la operación:
nro1 nro1 Div 2
mediante el cual se obtiene los siguientes valores:
23 Div 2 = 11
11 Div 2 = 5
5 Div 2 = 2 Se detiene cuando
2 Div 2 = 1 es 1
Para el proceso de multiplicación emplearemos la operación:

nro2 nro2 * 2
que permite obtener los siguientes valores:
4*2=8
8 * 2 = 16
16 * 2 = 32
32 * 2 = 64
Para sumar los valores de la multiplicación emplearemos la operación:
suma suma + nro2
que permite obtener los siguientes valores: 4 + 8 + 16 + 64 = 92, que es

igual al valor de multiplicar 23 * 4.

nro1, nro2 números a multiplicar
suma producto de dos números
Inicio
entero: nro1, nro2, suma 0
// Leer Datos
Escribir (“Ingresar dos números:”)
Leer (nro1, nro2)
// Calcula multiplicación
Mientras (nro1 >= 1) Hacer
Si (nro1 Mod 2 = 1) entonces
suma suma + nro2
Fin_si
nro1 nro1 Div 2
nro2 nro2 * 2
Fin_mientras
Escribir (“El producto es: ”, suma)
Fin
Ejemplo 03
Pseudocódigo que muestre los n términos de la siguiente serie y calcule su

suma:
2 + 5 + 8 + 11 + 14 + …

n cantidad de términos de la serie
ter cada término de la serie
suma suma de los elementos de la serie
con contador
Inicio
entero: n, ter 2, con , suma 0
// Leer Datos
Escribir (“Ingresar cantidad de términos:”)
Leer (n)
// Calcula serie y suma
con 1
Mientras (con <= n) Hacer
Escribir (ter)
suma suma + ter
ter ter + 3
con con + 1
Fin_mientras
Escribir (“La suma es: ”, suma)
Fin
Ejemplo 04
Pseudocódigo que calcule la suma total y determine cuantos números múltiplos
de M hay en los N primeros números naturales, tal que M <= N.
Por ejemplo:
Si se desea saber cuantos múltiplos de 7 hay en los primeros 80 números
naturales.
Diremos que existen 11 números y son:
7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77

n cantidad de números naturales
m múltiplo a validar
suma suma de los múltiplos de m
con contador
Inicio
entero: n, m, con, suma 0
// Leer Datos
Escribir (“Ingresar cantidad de números:”)
Leer (n)
Escribir (“Ingresar múltiplo a validar:”)
Leer (m)
con 1
Mientras (m <= n) Hacer
Escribir (m)
con con + 1
suma suma + m
mm+n
Fin_mientras
Escribir (“La cantidad de múltiplos de ”, m, “encontrados en los ”, n,
“primeros números naturales es ”, con)
Fin
Ejemplo 05
Pseudocódigo que calcule el cuadrado de un número realizando sólo sumas. El
cuadrado de un número n es la suma de los n primeros números impares.
Ejemplo: 32 = 1 + 3 + 5 = 9.

n número ingresado
ter números impares
cuad número al cuadrado
con contador
Inicio
entero: n, cuad 0, ter 1, con
// Leer Datos
Leer (n)
con 1
cuad cuad + ter
ter ter + 2
con con + 1
Fin_mientras
Escribir (“El cuadrado de ”, n, “es: ”, cuad)
Fin
Ejemplo 06
Pseudocódigo que imprima la serie y calcule el producto de los n términos de:
1/12 * 3/22 * 5/32 * 7/42 * …

num numerador
den denominador
prod producto de los términos de la serie
con contador
Inicio
entero: n, con
real : num 1, den 1, prod 1
// Leer Datos
Leer (n)
// Calcula serie y multiplica
con 1

Escribir (num, “/”, den, “^2”)
prod prod * (num/(den^2))
num num + 2
den den + 1
con con + 1
Fin_mientras
Escribir (“El producto es: ”, prod)
Fin
Ejemplo 07
Pseudocódigo que imprima la serie y calcule la suma de los n términos de:
1 + 2 + 5 + 10 + 17 + 26 + …

ter término de la serie
inc incremento
suma suma de los términos de la serie
con contador
Inicio
entero: n, con, ter 1, suma 0, inc 1
// Leer Datos
Leer (n)
con 1
Escribir (ter)
suma suma + ter
ter ter + inc
inc inc + 2
con con + 1
Fin_mientras
Fin
Ejemplo 08
Pseudocódigo en el que se ingresa un número entero y se calcula:
a) La suma de sus dígitos
b) El número total (cantidad) de dígitos.
c) La cantidad de dígitos pares e impares
Por ejemplo si se tiene el número 3897, es necesario reducir el número

empleando la operación nro nro Div 10, que en valores es:
3897 Div 10 = 389

389 Div 10 = 38
38 Div 10 = 3 Se detiene
3 Div 10 = 0 cuando es cero
Para obtener cada digito emplearemos la operación digito digito Mod 10, que
en valores es:
3897 Mod 10 = 7
389 Mod 10 = 9
38 Mod10 = 8
3 Mod 10 = 3
• Para calcular la suma de los dígitos de un número emplearemos la

operación: suma suma + digito
• Para calcular la cantidad total de dígitos de un número emplearemos un
contador tal como: c c + 1
• Para calcular la cantidad de dígitos pares e impares evaluamos cada dígito,
un dígito es par si el residuo de la división del dígito entre 2 es cero, en caso
contrario será impar. De manera se irán acumulando en dos contadores
diferentes la cantidad total de dígitos pares y de dígitos impares.

nro número ingresado
digito cada dígito del número
suma la suma total de dígitos
c contador que guarda la cantidad de dígitos
cpar contador que guarda la cantidad de dígitos pares
cimpar contador que guarda la cantidad de dígitos impares
Inicio
entero: nro, digito, suma 0, c 0, cpar 0, cimpar 0
// Leer Datos
Leer (nro)
Mientras (nro>0) Hacer
digito nro Mod 10
suma suma + digito
cc+1
Si (digito Mod 2 = 0) entonces
cpar cpar + 1
Sino
cimpar cimpar + 1
Fin_si
nro nro Div 10
Fin_mientras
Escribir (“El total de dígitos es: ”, c)
Escribir (“La cantidad de digitos pares es: ”, cpar)
Escribir (“La cantidad de digitos impares es: ”, cimpar)
Fin
Ejemplo 09
Pseudocódigo que calcula los salarios de un conjunto de N trabajadores,
conociendo la tarifa por hora y las horas trabajadas, asi como, la cantidad de
trabajadores que reciben un salario mayor o igual a S/.700. Considerar una
única tarifa por hora para todos los trabajadores.

n cantidad de trabajadores
tar tarifa por hora
hor horas trabajadas
salario salario
conS contador de trabajadores con salario mayor o igual a S/.700
con contador
Inicio
entero: tar, n, con, hor, salario, conS 0
// Leer Datos
Escribir (“Ingresar tarifa:”)
Leer (tar)
Escribir (“Ingresar cantidad de trabajadores:”)
Leer (n)
// Calculo
con 1
Escribir (“Ingresar horas trabajadas del trabajador”, con, “:”)
Leer (hor)
salario hor * tar
Si (salario >= 700) entonces
conS conS + 1
Fin_si
con con + 1
Escribir (“El salario del trabajador ”, con, “ es ”, salario)
Fin_mientras
Escribir (“La cantidad de trabajadores con salarios mayores o iguales a
S/.700.00 es: ”, conS)
Fin
Ejemplo 10
Durante un censo se registra los datos de n personas como: sexo (masculino,
femenino), edad y estado civil (soltero, casado, viudo, divorciado). Elaborar un
pseudocódigo que muestre el número de jóvenes solteras que tienen entre 18 y
30 años.

n cantidad de personas
sexo sexo de la persona
edad edad de la persona
estCiv estado civil
conM cantidad de mujeres solteras entre 18 y 30 años
con contador
Inicio
entero: n, edad, con 1 , conM 0
caracter: sexo, estCiv
// Leer Datos
Escribir (“Ingresar cantidad de personas:”)
Leer (n)
// Calculo
con 1
Escribir (“Ingresar sexo (M)asculino, (F)emenino:”)
Leer (sexo)
Escribir (“Ingresar edad:”)
Leer (edad)
Escribir (“Ingresar estado civil (S)oltero, (C)asado, (V)iudo, (D)ivorsiado:”)
Leer (estCiv)
Si (sexo = ‘F’ and estCiv = ‘S’ and edad>=18 and edad <=30) entonces
conM conM + 1
Fin_si
con con + 1
Fin_mientras
Escribir (“La cantidad de mujeres solteras entre 18 y 30 años son: ”, conM)
Fin
Ejemplo 11
Una organización de bienestar familiar registra los pesos de las N personas de
un centro poblado, a partir de estos datos, se desea determinar el promedio de
peso de los niños, jóvenes, adultos y ancianos que existen en la zona.
Considerar la siguiente tabla de categorías:
Categoría Edad
Niños 0 – 12
Jóvenes 13 – 29
Adultos 30 – 59
Ancianos 60 – más

n cantidad de personas del centro poblado
edad edad de cada persona
peso peso de cada persona
con contador
sumaN suma de los pesos de los niños
sumaJ suma de los pesos de los jóvenes
sumaA suma de los pesos de los adultos
sumaC suma de los pesos de los ancianos
conN contador de niños
conJ contador de jóvenes
conA contador de adultos
conC contador de ancianos
promN promedio de peso de los niños
promJ promedio de peso de los jóvenes
promA promedio de peso de los adultos
promC promedio de peso de los ancianos
Inicio
entero: n, edad, con 1, conN 0, conJ 0, conA 0, conC 0
real: peso, sumaN 0, sumaJ 0, sumaA 0, sumaC 0, promN,
promJ, promA, promC
// Leer Datos
Escribir (“Ingresar cantidad de población”)
Leer (n)
// Calculo
con 1
Escribir (“Ingresar edad”)
Leer (edad)
Escribir (“Ingresar peso”)
Leer (peso)
Si (edad <= 12) entonces
sumaN sumaN + peso
conN conN + 1
Sino
sumaJ sumaJ + peso

conJ conJ + 1
Sino
sumaA sumaA + peso
conA conA + 1
Sino
sumaC sumaC + peso
conC conC + 1
Fin_si
Fin_si
Fin_si
Fin_mientras
promN sumaN / conN
promJ sumaJ/ conJ
promA sumaA / conA
promC sumaC / conC
Escribir (“El promedio de peso de los niños es: ”, promN)
Escribir (“El promedio de peso de los jóvenes es: ”, promJ)
Escribir (“El promedio de peso de los adultos es: ”, promA)
Escribir (“El promedio de peso de los ancianos es: ”, promC)
Fin
Ejemplo 12
Pseudocódigo para calcular el máximo común divisor (M.C.D.) de dos números a
y b, empleando el algoritmo de Euclides.
El algoritmo consiste en:
a) Dividir el mayor número entre el menor número, obteniendo el cociente q1 y
el resto r1.
b) Si r1 < > 0, se divide el menor número entre r1, obteniendo el cociente q2
y el resto r2.
c) Si r2 < > 0, se divide r1 entre r2 obteniendo cociente q3 y resto r3.
d) Este proceso continua hasta obtener un resto igual a 0.
e) El máximo común divisor (M.C.D.) es el resto anterior al resto igual a 0.
Por ejemplo se queremos hallar el M.C.D. de 1560 y 432, dividimos el mayor

entre el menor.
b
q1 q2 q3 q4 q5 q6
Cociente 3 1 1 1 1 3
a 1560 432 264 168 96 72 24
Residuo 264 168 96 72 24 0
r1 r2 r3 r4 r5 r6
r1<>0 r2<>0 r3<>0 r4<>0 r5<>0 r6 = 0

El M.C.D. es 24
Observamos que a toma el valor de b y b toma el valor del residuo para lo cual
escribimos a b y b residuo.

n1 primer número ingresado
n2 segundo número ingresado
a dividendo
b divisor
residuo residuo
Inicio
entero: a, b, residuo, n1, n2
// Leer Datos
Escribir (“Ingresar dos números:”)
Leer (n1, n2)
// Calculo
Si (n1 > n2) entonces
a n1
b n2
Sino
a n2
b n1
Fin_si
Mientras (b > 0) Hacer
residuo a Mod b
ab
b residuo
Fin_mientras
Escribir (“El máximo común divisor es: ”, a)
Fin
Ejemplo 13
Para convertir un número en base diferente de 10 a base 10, emplearemos la
descomposición polinómica, se denomina así por que tiene la característica de
un polinomio donde la variable del polinomio viene a estar dado por la base en
la cual se ha escrito el número. Se pide realizar un Pseudocódigo para realizar la
descomposición polinómica
La siguiente tabla muestra la descomposición polinómica:
Numero a
Resultado
convertir y su Proceso de Conversión
de la
correspondiente (descomposicion polinomica)
conversión
base
344(7 3*72 + 4*71 + 4*70 = 3*49 + 4*7 + 4 179
*1= 147 + 28 + 4
1304(5 1*53 + 3*52 + 0*51 + 4*50 = 1*125 + 204

3*25 + 0*5 + 4*1 = 125 + 75 + 0 + 4
Por ejemplo, sea el número 344.
Para ir reduciendo cada número emplearemos la operación nro nro Div 10,
que en valores es:
344 Div 10 = 34
34 Div 10 = 3
3 Div 10 = 0 Se detiene cuando es cero
Para obtener cada dígito emplearemos la operación digito digito Mod 10, que
en valores es:
344 Mod 10 = 4
34 Mod 10 = 4
3 Mod 10 = 3
Se puede ir formando la descomposición polinómica multiplicando el primer

residuo por la base elevado a la cero, el segundo residuo multiplicado por la
base elevado a la 1 y así sucesivamente, guardando el resultado de esta
operación en un acumulador suma, expresado mediante la operación: suma
suma + digito * baseexpo , así, inicializando suma en cero tenemos:
0 + 4 * 70 = 4
4 + 4 * 71 = 32
32 + 3 * 72 = 179

digito cada dígito del número
base base del número
nro número a realizar la descomposición polinómica
nro1 variable auxiliar donde guardamos el nro
expo exponente
suma resultado de la descomposición polinómica
Inicio
entero: nro, nro1, base, digito, suma 0, expo 0
// Leer datos
Escribir (“Ingresar un número y su base”)
Leer (nro, base)
nro1 nro
Mientras( nro > 0) hacer
digito nro Mod 10
suma suma + digito * base ^ expo
expo expo +1
nro nro Div 10
Fin_mientras
Escribir (“El número ”, nro1, “en base 10 es ”, suma)
Fin
Ejemplo 14
Pseudocódigo para convertir un número decimal a una base que puede ser
binario u octal.
Existe varios sistemas de numeración como:
• El sistema binario utiliza los dígitos 0, 1
• El sistema octal usa ocho dígitos 0, 1, 2, 3, 4, 5, 6 y 7.
• El sistema hexadecimal utiliza 16 dígitos, del 0 al 9 y para los otros seis se
usan las letras A, B, C, D, E y F, que tienen valores 10, 11, 12, 13, 14 y 15,
respectivamente. Se usan indistintamente mayúsculas y minúsculas.
• En la tabla se muestran los primeros diecisiete números decimales con su
respectiva equivalencia binaria, octal y hexadecimal.
Decimal Binario Octal Hexadecimal

0 0000 0 0
1 0001 1 1
2 0010 2 2
3 0011 3 3
4 0100 4 4
5 0101 5 5
6 0110 6 6
7 0111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
16 10000 20 10
17 10001 21 11
Para convertir un número de base decimal a cualquier base, se emplea el

método de las divisiones sucesivas que consiste en dividir sucesivamente el
número decimal y los cocientes que se van obteniendo entre la base, hasta que
una de las divisiones se haga 0. La unión de todos los restos obtenidos escritos
en orden inverso, nos proporcionan el número inicial expresado en el sistema
deseado. Por ejemplo convertir el número 10 en base 2, obtenemos:
10 2
0 5 2
1 2 2 10(10)=1010(2)
0 1
a) Se plantea una primera solución mediante el empleo de una fórmula

aritmética que permita calcular la conversión del número.

digito cada digito del número
base base que puede ser binario u octal
nro número al cual vamos a convertir a otra base
nro1 variable auxiliar donde guardamos nro
coeficiente forma los coeficientes del nro
mensa guardamos el texto correspondiente, si el número es
binario u octal
nuevonro número convertido a otra base
Inicio
entero: nro, nro1, base, residuo, nuevonro 0, coeficiente 1
cadena: mensa
// Lectura de datos
Escribir ("Ingrese numero en base decimal: " )
Leer (nro)
Escribir ("Ingrese base: ")
Leer (base)
nro1 nro
Mientras (nro >0) hacer
residuo nro Mod base
nuevonro nuevonro + coeficiente * residuo

coeficiente 10*coeficiente
nro nro Div base
Fin_mientras
Si (base = 2) entonces
mensa "Binario"
Fin_si
mensa "Octal"
Fin_si
Escribir (“El número ”,nro1,“ en ”, mensa, “es ”, nuevonro)
Fin
b) Se plantea una segunda solución usando cadenas, permitiendo concatenar

cada digito del número.
Concatenar significa unir, enlazar elementos de texto en uno solo.
Concatenar ( unir)
digito = nro Mod base nro = nro / base
cadena = digito + cadena
12 Mod 2 = 0 0+“”=0 12 Div 2 = 6
6 Mod 2 = 0 0 + 0 = 00 6 Div 2 = 3
3 Mod 2 = 1 1 + 00 = 100 3 Div 2 = 1
1 Mod 2 = 1 1 + 100 = 1100 1 Div 2 = 0
El resultado es 1100.

residuo residuo de nro y base
base base que puede se binario u octal
nro1 variable auxiliar donde guardamos nro
mensa guardamos el texto correspondiente, si el número es
binario u octal
Inicio
entero: nro,nro1,base,residuo
cadena: nuevonro “ ”, mensa
// Lectura de datos
Escribir (“Ingrese numero en base decimal:”)
Leer (nro)
Escribir (“Ingrese base:”)
Leer (base)
nro1nro
Mientras (nro >0) hacer
nuevonro residuo + nuevonro
nro nro Div base
Fin_mientras
mensa “Binario”
Fin_si
mensa “Octal”
Fin_si
Escribir (“El número ”,nro1,“ en ”, mensa, “es ”, nuevonro)

Fin
c) Se plantea una tercera solución usando cadenas, pero en este caso se

procede a calcular conversiones a cualquier base incluyendo la base
hexadecinal.
Para hexadecimal tenemos que tener en cuenta las letras a, b, c, d, e, f para

ello preguntamos si dígito es 10, 11, 12, 13, 14, 15 para lo cual hacemos las
asignaciones correspondientes mediante la operación binario "letra" +
binario.
Si los dígitos son menores o igual que 9 para formar la conversión
correspondiente hacemos la operación binario digito + binario.

residuo residuo de nro y base
base base que puede se binario, octal o hexadecimal
nro1 variable auxiliar donde guardamos el nro
mensa variable donde guardamos si el numero es binario, octal
o Hexadecimal
Inicio
entero: nro, base, residuo, nro1
cadena: nuevonro “ ”, mensa “ ”
// Lectura de datos
Escribir (“Ingresar número en base dcimal: ”)
Leer (nro)
Escribir (“Ingresar base: ”)
Leer (base)
nro1 nro
Si (residuo <= 9) entonces
nuevonro residuo + nuevonro
Fin_si
nuevonro “a” + nuevonro
Fin_si
nuevonro “b” + nuevonro
Fin_si
nuevonro “c” + nuevonro
Fin_si
nuevonro “c” + nuevonro
Fin_si
nuevonro “d” + nuevonro
Fin_si
Si (residuo <=15 ) entonces
nuevonro “f” + nuevonro
Fin_si
mensa “Binario”
Fin_si
mensa “Octal”
Fin_si
mensa “Hexadecimal”
Fin_si
nro nro Div base
Fin_mientras
Escribir (nro1, “ en base ”, mensa, “ es ”, nuevonro)
Fin
4.3.Estructura repetitiva Repetir – Hasta_que
Esta sentencia repite una sentencia o más sentencias hasta que el resultado de
una expresión lógica sea verdadero (true), momento en que termina la
sentencia Repetir y se continúa con el resto del algoritmo. Su sintaxis es la
siguiente:
Repetir
Acción
Hasta_que (expresión_lógica)
Funcionamiento de Repetir – Hasta_que

Cuando la sentencia Repetir – hasta_que inicia su ejecución, se suceden los
siguientes pasos:
a) Se ejecuta la acción (o conjunto de sentencias).

b) Se evalúa Expresión_lógica, obteniéndose un resultado lógico.
c) Si este resultado es falso (false), se retorna al paso a.
d) Si este resultado es verdadero (true), la ejecución del pseudocódigo
proseguirá con sentencia siguiente al hasta_que.
Ejemplo 15
Pseudocódigo que imprime los 10 primeros términos de la serie:
1, 3, 5, 7, ...
Observamos que cada término de la serie se incrementa en 2, para lo cual

emplearemos la operación termino termino + 2.
Para imprimir los 10 primeros términos se requiere de un contador que empieza
en 1 y acaba en 10, de esta manera cada vez que se obtiene un término el
contador se incrementa en 1 para lo cual usaremos con con + 1.

con controla la estructura repetitiva repetir - hasta_que
termino cada uno de los términos de la serie
Inicio
entero: termino 1, con 1
// Calcula e imprime termino
Repetir
Escribir (termino)
termino termino + 2
con con + 1
Hasta_que (con = 10)

Fin
La siguiente tabla muestra los resultados de la corrida del algoritmo.
Iteración Resultados del Expresión Resultado

numero cuerpo del bucle lógica de la
Expresión
con termino = con = con = 10 lógica
Escribir termino
termino + 2 con + 1
1 1 3 2 2 = 10 false
2 3 5 3 3 = 10 false
3 5 7 4 4 = 10 false
….. …… ….. …. …… ……
….. …… ….. ….. …… …..
10 19 21 10 10 = 10 true
Ejemplo 16
Pseudocódigo que encuentra el menor número, de un conjunto de números
positivos ingresados. El pseudocódigo termina cuando se ingresa el cero o un
número negativo.
Asumimos que el valor inicial del menor número es un número grande:

menor 99999, para poder iniciar la comparación con todos los números
ingresados.

nro cada número ingresado
menor menor número
Inicio
entero: nro, menor 99999
// Calcula e imprime término
Repetir
Escribir (“Ingresar número”)
Leer (nro)
Si (nro < menor) entonces
menor nro
Fin_si
Hasta_que (nro <= 0)
Escribir (“El menor número ingresado es ”, menor)
Fin
Ejemplo 17
Pseudocódigo que genere una secuencia de números utilizando el siguiente
algoritmo:
• Que empiece con cualquier número entero positivo.

• Si es par, lo dividimos por dos, si es impar lo multiplicamos por tres y le
sumamos 1.
• Repetimos el paso anterior con el número resultante, la secuencia se puede
repetir indefinidamente.
Por ejemplo si ingresemos el número 7, la secuencia generada seria:
22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1 4 2 1 …
Que se obtuvo de la siguiente manera:
Número Proceso
7 7 es impar, entonces 7 * 3 + 1 = 22
22 22 es par, entonces 22 / 2 = 11
11 11 es impar, entonces 11 * 3 + 1 =34
34 34 es par, entonces 34 / 2 = 17
52 52 es par, entonces 52 / 2 = 26
26 26 es par, entonces 26 / 2 = 13
40 40 es par, entonces 40 / 2 = 10
10 10 es par, entonces 10 / 2 = 5
16 16 es par, entonces 16 / 2 = 8
8 8 es par, entonces 8 / 2 = 4
1
Observar que la serie comienza a repetir la serie 4 2 1 indefinidamente, el

algoritmo debe de leer el número inicial, imprimir el número de valores
encontrados hasta la aparición de un valor 1 en la secuencia.
Para los números pares emplearemos la operación: nro nro Div 2

Para los números impares emplearemos la operación: nro 3 * nro + 1

residuo residuo del numero
nro numero inicial de la serie
Inicio
entero: nro, residuo
// Leer Datos
Leer (nro)
// Calcula la serie
Repetir
residuo nro Mod 2
Si (residuo = 0) entonces
nro nro Div 2
Sino
nro 3 * nro + 1
Fin_si
Escribir (nro)
Hasta_que (nro = 1)
Fin
Ejemplo 18
Pseudocódigo que calcule el promedio de números positivos y el promedio de
números negativos de un conjunto de números ingresados. El pseudocódigo
termina cuando se ingresa el cero.

sumap suma de números positivos
suman suma de números negativos
cp contador de números positivos
cn contador de números negativos
promp promedios de los números positivos
promn promedios de los números negativos
Inicio
entero: nro, sumap 0, suman 0, cp 0, cn 0
real: promp, promn
// Ingreso y cálculo
Repetir
Leer (nro)
Si (nro > 0) entonces
sumap sumap + nro
cp cp + 1
Sino
Si (nro < 0) entonces
suman suman + nro
cn cn + 1
Fin_si
Fin_si
Hasta_que (nro = 0)
promp sumap / cp
promn suman / cn
Escribir (“El promedio de los números positivos es ”, promp)
Escribir (“El promedio de los números negativos es ”, promn)
Fin
Ejemplo 19
Pseudocódigo que lee N consumos de un restaurante. Si el consumo ingresado
excede los S/.70.00, se le descontará el 15%. Mostrar el monto de cada
consumo realizado y el total que recauda el restaurante por todos los consumos.

n cantidad de consumos
consumo monto consumido
desc descuento
total total que recauda el restaurante
con contador
Inicio
entero: n, con 0
real: consumo, desc 0, total 0
Escribir (“Ingresar cantidad de consumos”)
Leer (n)
// Cálculo
Repetir
Escribir (“Ingresar consumo”)
Leer (consumo)
Si (consumo > 70.00) entonces
desc 0.15 * consumo
Fin_si
consumo consumo – desc

Escribir (“El monto final del consumo es ”, consumo)
total total + consumo
con con +1
Hasta_que (con = n)
Escribir (“El total que recauda el restaurante es ”, total)
Fin
Ejemplo 20
Pseudocódigo que calcula la compra de N productos de diferentes precios, dicha
compra se realiza hasta que el cliente ya no desea seguir comprando. Mostrar el
monto total que paga el cliente.

cant cantidad de productos
subTot monto del subtotal
total monto total
resp respuesta
Inicio
entero: cant
real: precio, subTot, total 0
caracter: resp
// Cálculo
Repetir
Escribir (“Ingresar precio del producto”)
Leer (precio)
Escribir (“Ingresar cantidad de productos”)
Leer (cant)
subTot precio * cant
total total + subTot
Escribir (“¿Desea seguir comprando (S/N)?”)
Leer (resp)
Hasta_que(resp = ‘N’)
Fin
Ejemplo 21
Pseudocódigo que calcula el monto total que se paga por una entrada a un
evento cultural, los precios varían de acuerdo al tipo de entrada:
Tipo Precio (S/.)

Vip 70.00
Platea 50.00
Popular 30.00
Además el precio tiene un incremento del 12% por impuesto. Validar el ingreso
de datos.

tipo tipo de entrada
inc incremento
Inicio
real: precio, inc
caracter: tipo
// Cálculo
Repetir
Escribir (“Ingresar tipo de entrada (V)ip, (P)latea, Popu(L)ar”)
Leer (tipo)
Si (tipo <> ‘V’ and tipo <> ‘P’ and tipo <> ‘L’)
Escribir (“Tipo no existe”)
Fin_si
Hasta_que (tipo = ‘V’ or tipo = ‘P’ or tipo = ‘L’)
Según sea (tipo)
‘V’: precio 70.00
‘P’: precio 50.00
‘L’: precio 30.00
Fin_según
inc precio * 0.12
precio precio + inc
Escribir (“El precio final a pagar es ”, precio)
Fin
Ejemplo 22
Un entrenador le ha propuesto a un atleta recorrer una ruta de cinco kilómetros
durante 10 días, para determinar si es apto para competir. Para que el atleta
sea considerado apto debe cumplir por lo menos una de las siguientes
condiciones:
• Que en ninguna de las pruebas haga un tiempo mayor a 16 minutos.
• Que su promedio de tiempos sea menor o igual a 15 minutos.

tpo tiempo en minutos
ct cantidad de dias que recorre en mas de 16 minutos
suma suma de tiempos
con contador
prom promedio de tiempos
Inicio
entero: tpo, ct 0, suma 0, con 0
real: prom
// Cálculo
Repetir
Escribir (“Ingresar tiempo en minutos”)
Leer (tpo)
Si (tpo > 16) entonces
ct ct + 1
Fin_si
suma suma + tpo
con con + 1
Hasta_que (con = 10)
prom suma / 10
Si ((ct = 0) or (prom <= 15))
Escribir (“Si es apto para competir”)
Sino
Escribir (“No es apto para competir”)
Fin_si
Fin
Ejemplo 23
Se ingresan los resultados de la evaluación de un cierto número de alumnos del
curso de Programación; por cada alumno se informa: su asistencia (1 =
presente; 0 = ausente) y su calificación. A partir de esta información se debe
calcular:
• La cantidad y el porcentaje de alumnos presentes.
• Promedio de calificaciones de alumnos presentes.
Si un alumno esta ausente no se registra su calificación. El pseudocódigo
termina cuando se ingresa como asistencia un valor diferente a 1 ó 0.

asis asistencia del alumno
calf calificación
suma suma de calificaciones de los alumnos presentes
cap cantidad de alumnos presentes
caa cantidad de alumnos ausentes
cant cantidad de alumnos registrados
porp porcentaje de alumnos presentes
prom promedio de calificaciones de los alumnos presentes
Inicio
entero: asis, calf, suma 0, cap 0, caa 0, cant 0
real: porp, prom
// Cálculo
Repetir
Escribir (“Ingresar asistencia (1)Presente, (0)Ausente”)
Leer (asis)
Si (asis = 1)
Escribir (“Ingresar calificación”)
Leer (calf)
suma suma + calf
Fin_si
Según sea (asis) hacer
1 : cap cap + 1
0 : caa caa + 1
Fin_según
cant cant + 1
Hasta_que (asis <> 0 or asis <>1)
porp (cap * 100) / cant
prom suma / cap
Escribir (“La cantidad de alumnos presentes es ”, cap)
Escribir (“El porcentaje de alumnos presentes es ”, porp)
Escribir (“El promedio de calificaciones de los alumnos presentes es ”, prom)
Fin
Ejemplo 24
Pseudocódigo que lee de forma consecutiva y aleatoria una serie de números, y
finalice cuando se ingresa un número mayor que la suma de los dos números
anteriores ingresados, mostrándose la cantidad de números ingresados y los
tres números que cumplieron la condición.

n1 primer número antes del número ingresado
n2 segundo número antes del número ingresado
con contador de números

suma suma del primer y segundo número antes del número ingresado
sw bandera
Inicio
entero: nro, sw 0, n1 0, n2 0, con 0, suma
// Cálculo
Repetir
Leer (nro)
Si (con >= 2)
suma n1 + n2
Si (nro > suma) entonces
sw 1
Fin_si
Fin_si
Si (con Mod 2 = 0) entonces
n1 nro
Sino
n2 nro
Fin_si
Fin_si
con con + 1
Hasta_que (sw = 1)
Escribir (“La cantidad de números ingresados es ”, con)
Escribir (“Los números que cumplieron la condicion son ”, n1, n2, nro)
Fin
Ejemplo 25
Pseudocódigo que lee números de forma consecutiva y aleatoria hasta que se
ingrese el número 0 (cero). Calcular la suma de todos los números ingresados
antes de que aparezca el primer número mayor a 150, asi como la suma de
todos los números que entran a continuación de éste, hasta la aparición del
cero.
Mostrar la cantidad de números ingresados (sin contar el cero ni el primer
número mayor de 150), en la primera y la segunda suma.
Contemplar la posibilidad de que entre antes el 0 que el primer número mayor
de 150.

suma1 primera suma
suma2 segunda suma
con contador de números
sw bandera
Inicio
entero: nro, sw 0, suma1 0, suma2 0, con 0
// Cálculo
Repetir
Leer (nro)
Si (nro <> 0) entonces
con con + 1
Fin_si
suma2 suma2 + nro
Fin_si
Si ((nro < 150) and (sw = 0)) entonces
suma1 suma1 + nro
Sino
sw = 1
con con - 1
Fin_si
Hasta_que (nro = 0)
Escribir (“La cantidad de números ingresados es ”, con)
Escribir (“La primera suma es ”, suma1)
Escribir (“La segunda suma es ”, suma2)
Fin
Ejemplo 26
Suponga que se piden X soles prestados a un banco, con el acuerdo de devolver
Y soles cada mes hasta devolver el préstamo completo. Parte del pago mensual
serán los intereses calculados como el i por ciento del capital por devolver en
ese momento. El resto del pago mensual se aplica a reducir el capital a
devolver. El algoritmo debe determinar:
• La cantidad de intereses que se paga cada mes.
• La cantidad de dinero aplicada cada mes al capital por devolver.
• La cantidad acumulada de intereses.
• La cantidad del préstamo aún pendiente al final de cada mes.
• La cantidad probable que se devuelve en el último pago.
Por ejemplo, si se pide prestado S/.1000.00 prestados a un banco a un interes

del 15% se tiene:
Nro Amortización Interés Interes Préstamo Couta

Acumulado Pendiente (Y)
1 50.00 150.00 150.00 950.00 200
2 57.50 142.50 292.50 892.50 200
3 66.125 133.875 426.375 826.375 200
4 76.0438 123.956 550.331 750.3312 200
5 87.4503 112.55 662.881 662.8809 200
6 100.568 99.4321 762.3131 562.3129 200
7 115.653 84.347 846.6601 446.6599 200
8 133.001 66.999 913.6591 313.6589 200
9 152.951 47.0489 960.708 160.7079 200
10 160.708 24.1062 984.8142 0 200
1000.00
Variables a utilizar en el Pseudocódigo

x monto prestado
i interes
y monto que se devuelve
ma monto aplicado al capital
inte interés generado
suma suma de intereses
Inicio
real: x, i, inte, y, ma, suma 0
// Leer dato
Escribir (“Ingresar monto prestado”)
Leer (x)
Escribir (“Ingresar interes”)
Leer (i)
Escribir (“Ingresar monto que se devuelve”)
Leer (y)
Repetir
inte (i/100) * x
Escribir (“El interes del mes es”, inte)
ma y - inte
Si (y > x) entonces
Escribir (“El monto aplicado al capital es ”, x)
Sino
Escribir (“El monto aplicado al capital es ”, ma)
Fin_si
x x - ma
Si (x < 0) entonces
Escribir (“El monto pendiente es 0”)
Escribir (“Se le devuelve ”, -x)
Sino
Escribir (“El monto pendiente es ”,x)
Fin_si
suma suma + inte
Hasta_que (x > 0)
Escribir (“La cantidad acumulada de interés es ”, suma)
Fin
4.4.Estructura repetitiva Desde – Fin_desde
La sentencia Desde, repite una o más acciones un número determinado de

veces. Se utiliza cuando se conoce por anticipado el número de veces que se
van a repetir estas acciones. Su sintaxis es la siguiente:
Desde (iValor_Inicial) hasta (expresión_Lógica) con incremento N hacer

Acción
Fin_desde
• Valor_Inicial: especifica el primer valor asignado a la variable de control.

Esta inicialización se realiza solo la primera vez que se repite el bucle.
• Expresión_Lógica: esta expresión debe ser verdadera para que se ejecute el
bucle. La expresión_Lógica se compara con la variable de control cada vez
que se repite el bucle.
• Incremento N: indica el valor que va ha aumentar o disminuir a la variable
de control.
Funcionamiento de Desde – Fin_desde

Cuando la sentencia Desde inicia su ejecución, se suceden los siguientes pasos:
• Se asigna un Valor_Inicial a la variable de control, en nuestro caso i.

• Si la variable de control cumple la expresión_Lógica, se ejecuta la acción
luego se incrementa (o disminuye) la variable de control.
• Si la variable de control no cumple la Condición se ejecuta la sentencia
siguiente a Fin_desde.
Ejemplo 27
Pseudocódigo que calcule la suma de los cuadrados y los cubos de los N
primeros números naturales.

n cantidad de números naturales
nro cada número natural
cuad cuadrado del número
cubo cubo del número
raiz raíz cuadrada del número
Inicio
entero: n, nro, cuad, cubo, sumaCuad 0, sumaCubo 0
// Leer dato
Escribir (“Ingresar cantidad de números naturales”)
Leer (n)
Desde (nro 1) hasta (nro <= n) con incremento 1 Hacer
cuad nro * nro
sumaCuad sumaCuad + cuad
cubo nro * nro * nro
sumaCubo sumaCubo + cubo
Fin_desde
Escribir(“La suma de los cuadrados es ”, sumaCuad)
Escribir(“La suma de los cubos es ”, sumaCubo)
Fin
Explicación
Para realizar el ejercicio planteado se definen las variables enteras n, nro, cuad,
cubo y se define e inicializa en cero las variables sumaCuad, sumaCubo:
entero: n, nro, cuad, cubo, sumaCuad 0, sumaCubo 0
Se ingresa la cantidad de números que se desea sumar mediante la variable n:

Escribir (“Ingresar cantidad de números naturales”)
Leer (n)
Enseguida se ejecuta la sentencia Desde, en el que se asigna a la variable nro el

valor de 1 y se evalúa la expresión lógica (nro<=n), si es verdadera se ejecuta
las cuatro sentencias que tiene esta estructura, luego se incrementa en una
unidad el valor de la variable nro, en ese momento la sentencia Desde vuelve a
verificar la expresión logica (nro<=n) si es verdadero continua el bucle:
Desde (nro 1) hasta (nro <= n) con incremento 1 Hacer
cuad nro * nro
sumaCuad sumaCuad + cuad
cubo nro * nro * nro
sumaCubo sumaCubo + cubo
Fin_desde
Cuando la expresión lógica (nro<=n) llega a ser falso el bucle termina y se

ejecuta la sentencia escribir y finaliza el pseudocódigo:
Escribir(“La suma de los cuadrados es ”, sumaCuad)
Escribir(“La suma de los cubos es ”, sumaCubo)
Ejemplo 28
Pseudocódigo que calcula el numero PI, de acuerdo a la siguiente fórmula:
PI/4 = 1 - 1/3 + 1/5 - 1/7 + ...
El número de términos debe ser ingresado.

n cantidad de números
num numerador
den denminador
con contador
suma suma
pi valor de PI
Inicio
entero : n, con
real : pi, suma 0, num 1, den 1
// Leer dato
Escribir (“Ingresar cantidad de términos”)
Leer (n)
Desde (con 1) hasta (con <= n) con incremento 1 Hacer
suma suma + (num / den)
num num * -1
den den + 2
Fin_desde
pi suma * 4
Escribir (“El valor de PI es ”, pi)
Fin
Ejemplo 29
Pseudocódigo para encontrar todos los divisores de un número ingresado. Un

número a es divisor de otro número b, cuando el residuo de la división de b
entre a es cero, en otras palabras cuando el residuo es exacto.
Así pues, decimos que 5 es divisor de 20, porque 20 Mod 5 nos da residuo cero.
Por ejemplo, los divisores de 24 son: 1, 2, 3, 4, 6, 8, 12, 24, para hallar estos
valores es necesario dividir al número 24 con valores comprendidos entre 1 y
24, los cuales se trabajarán mediante la variable i, si el residuo de la división
del número 24 entre i es cero entonces i es uno de los divisores de 24.
Nro Mod i
24 Mod 1 = 0 entonces 1 es divisor de 24
24 Mod 5 <> 0 entonces 5 no es divisor de 24
y así sucesivamente

nro número al cual calculamos sus divisores
i divisor del numero
Inicio
entero: nro, i 1
// Leer datos
Leer (nro)
Desde (i 1) hasta (i <= nro) con incremento 1 hacer
Si (nro Mod i = 0) entonces
Escribir (i)
Fin_si
Fin_desde
Fin
Ejemplo 30
Pseudocódigo que calcule el factorial de un número entero. El factorial de un
número n se representa por n! y su fórmula es:
n ! = 1 * 2 * 3 * 4 * … * (n-2) * (n-1) * n
Así por ejemplo:

1! = 1
2! = 1*2=2
3! = 1*2*3=6
4! = 1 * 2 * 3 * 4 = 24
4! = 3 ! * 4 = 24
Se observa que el factorial de 4 es el factorial de 3 multiplicado por 4, quiere

decir que el factorial de n es el factorial de (n -1) multiplicado por n.
n! = (n-1)! * n
Esto nos sirve para implementar la lógica del programa empleando:
fact fact * i

i controla el bucle desde
fact calcula el factorial
nro numero al cual se va a calcular el factorial
Inicio
entero i, nro, fact 1
// Leer Datos
Leer (nro)
// Calcula el factorial
fact fact * i
Fin_desde
Escribir (“El factorial es: ”, fact)
Fin
La siguiente tabla muestra los resultados de la corrida del algoritmo para 5!
Resultados
Iteración Expresión Valor de la del cuerpo
Nro lógica Expresión del bucle Incremento
i i<=5 lógica fact = fact * i i=i+1
1 1<= 5 true 1 2
2 2<= 5 true 2 3
3 3 <=5 true 6 4
4 4 <=5 true 24 5
5 5<= 5 true 120 6
6 6<= 5 false Finaliza la sentencia desde
Ejemplo 31
Pseudocódigo que obtenga el cuadrado de un número entero utilizando la
formula:
n2 = 1 + 3 + 5 + . . . + 2n-1.
Para obtener cada termino de la serie emplearemos la fórmula 2 * n – 1.
Si n = 1 2*1–1=1
Si n = 2 2*2-1=3
Si n = 3 2*3–1=5
Posteriormente es necesario sumar cada uno de los términos empleando la

operación suma suma + termino.
10+1
41+3
94+5

i controla el bucle desde
suma cuadrado de un número
termino cada termino de la serie
nro número al cual se va a calcular su cuadrado
Inicio

entero: nro, i, termino, suma 0
// Leer Datos
Leer (nro)
termino 2 * i - 1
Escribir (termino)
suma suma + termino
Fin-desde
Escribir (“El número al cuadrado es : ”, suma)
Fin
Ejemplo 32
Pseudocódigo para determinar si un año es bisiesto en un rango dado. Un año
es bisiesto si es múltiplo de 4 pero no múltiplo de 100 excepto los múltiplos de
400.
Como tenemos que hallar los años bisiestos en un rango, empleamos un bucle
repetitivo que permita recorrer los años determinados en el rango añoinicio y
añotermino que definen el año de inicio y término respectivamente, de esta
manera usamos un contador año que empieza en añoinicio y termina en
añotermino que se irá incrmentando en 1, el mismo que definirá cada año que
se evalúa como bisiesto. De esta manera, dentro del bucle realizamos los
cálculos correspondientes

añoinicio año el cual vamos a empezar la búsqueda
añotermino año el cual vamos a terminar la búsqueda
a cada uno de los años comprendidos en un rango
Inicio
entero: añoinicio, añotermino, a
// Leer dato
Escribir (“Ingresar año inicial y año final”)
Leer (añoinicio, añotermino)
Desde (a añoinicio) hasta (a <= añotermino) con incremento 1 Hacer
Si ((a Mod 4 = 0) and (a Mod 100 <> 0) or (a Mod 400 = 0)) entonces
Escribir (“El año ”, a, “es bisiesto”)
Fin_si
Fin_desde
Fin
Ejemplo 33
Pseudocódigo que muestra y calcula el promedio de todos los números pares
comprendidos entre a y b. Indistintamente a puede ser menor que b o b menor
que a.

a, b límites
n1, n2 auxiliares
nro número evaluado como par entre los límites a y b
suma suma de números pares
con contador de números pares
prom promedio
Inicio
entero: a, b, nro, suma 0, con 0
real: prom
// Leer Datos
Escribir (“Ingresar límites:”)
Leer (a, b)
Si (a > b) entonces
n1 a
n2 b
Sino
n1 b
n2 a
Fin_si
Desde (nro n1) hasta (nro <= n2) con incremento 1 hacer
Si (nro Mod 2 = 0) entonces
Escribir (nro)
suma suma + nro
con con +1
Fin_si
Fin-desde
prom suma / con
Escribir (“El promedio es ”, prom)
Fin
Ejemplo 34
Pseudocódigo que lee dos números, el primero representa el número a ser
transformado, y el segundo el transformador, se debe hacer girar hacia la
derecha el número a transformarse, tantas veces lo indique el transformador, e
ir desplegando el número después de cada transformación.
Ejemplo: Primer número: 35241, Segundo número: 4

Girado a la derecha se tiene
Número de giros Transformaciones

1 13524
2 41352
3 24135
4 52413
Variables a utilizar en el Pseudocódigo

n1 número a transformar
n2 número transformador
aux auxiliar
dig dígito
cd cantidad de dígitos
con contador
Inicio
entero: n1, n2, aux, dig, cd 0, con
// Leer dato
Leer (n1, n2)
aux n1
Mientras (aux > 0) hacer
dig aux Mod 10
cd cd + 1
aux aux Div 10
Fin_mientras
cd cd - 1
Desde (con 0) hasta (con < n2) con incremento 1 Hacer
dig n1 Mod 10
n1 n1 Div 10
dig dig * 10 ^ cd
n1 dig + n1
Fin_desde
Escribir(“El número transformado es ”, n1)
Fin
Ejemplo 35
Pseudocódigo para averiguar si un número ingresado es primo. Un número es
primo, si solo tiene como divisores al mismo número y a la unidad.

d posibles divisores del número ingresado
con contador de divisores del número
nro numero ingresado
Inicio
// Declarar e inicializar variables
entero: nro, d, con 0
// Leer Datos
Leer (nro)
Desde (d 1) hasta (d <= nro) con incremento 1 hacer
Si (nro Mod d = 0) entonces
con con + 1
Fin_si
Fin-desde
Si (con <= 2)
Escribir (“El número es primo”)
Sino
Escribir (“El número no es primo”)
Fin_si
Fin
Ejemplo 36
Una empresa almacena los datos de N empleados, para esto, en un proceso
repetitivo se ingresa el sexo (masculino, femenino) y el salario de cada
empleado. Se pide calcular:
a) El mayor y el menor salario
b) El promedio de salarios.
c) La cantidad de mujeres y varones que trabajan en esa empresa

n cantidad de empleados
sexo sexo del empleado
sal salario
mayor mayor salario
menor menor salario
suma suma de salarios
conVar contador de empleados varones
conMuj contador de empleadas mujeres

prom promedio de salarios

con contador de empleados
Inicio
entero: n, con, conVar 0, conMuj 0
real: sal, mayor 0, menor 99999, suma 0, prom
caracter: sexo
// Leer dato
Escribir (“Ingresar cantidad de empleados”)
Leer (n)
Desde (con 1) hasta (con <= n) con incremento 1 Hacer
Escribir (“Ingresar sexo”)
Leer (sexo)
Escribir (“Ingresar salario”)
Leer (sal)
Si (sal > mayor) entonces
mayor sal
Fin_si
Si (sal < menor) entonces
menor sal
Fin_si
suma suma + sal
Según sea (sexo) hacer
‘M’ : conVar conVar + 1
‘F’ : conMuj conMuj + 1
Fin_según
Fin_desde
prom suma / n
Escribir (“El mayor salario es ”, mayor)
Escribir (“El menor salario es ”, menor)
Escribir (“El promedio de salarios es ”, prom)
Escribir (“La cantidad de varones que trabajan en la empresa es ”, conVar)
Escribir (“La cantidad de mujeres que trabajan en la empresa es ”, conMuj)
Fin
Ejemplo 37
Pseudocódigo que indica mediante un mensaje si dos números son amigos o no.
Se dice que dos números son amigos si la suma de los divisores del primer
número (excepto él mismo) coincide con el segundo número y viceversa.
Por ejemplo 220 y 284 son amigos, porque:

La suma de los divisores de 220 es:
1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284
Y la suma de los divisores de 284 es:
1 + 2 + 4 + 71 + 142 = 220

nro1 primer número ingresado
nro2 segundo número ingresado
d posibles divisores de los números ingresados sin incluir el
mismo número
suma1 suma de los divisores del primer número ingresado
suma2 suma de los divisores del segundo número ingresado

Inicio
entero: nro1, nro2, d, suma1 0, suma2 0
// Leer Datos
Escribir (“Ingresar primer número:”)
Leer (nro1)
Escribir (“Ingresar segundo número:”)
Leer (nro2)
Desde (d 1) hasta (d <= (nro1 Div 2)) con incremento 1 hacer
Si (nro1 Mod d = 0) entonces
suma1 suma1 + d
Fin_si
Fin-desde
Desde (d 1) hasta (d <= (nro2 Div 2)) con incremento 1 hacer
Si (nro2 Mod d = 0) entonces
suma2 suma2 + d
Fin_si
Fin-desde
Si (suma1 = nro2 and suma2 = nro1)
Escribir (“Los números ”, nro1, “y ”, nro2, “son amigos”)
Sino
Escribir (“Los números ”, nro1, “y ”, nro2, “no son amigos”)
Fin_si
Fin
Ejemplo 38
Se ha seleccionado n números de personas para realizar una encuesta, en un
proceso repetitivo se ingresa el grado de instrucción y la edad de cada persona.
Se desea saber el promedio de edades, la mayor edad y el porcentaje de
personas con instrucción Primaria, Secundaria y Superior (P, S, R).

n cantidad de personas encuestadas
edad edad de cada persona
grad grado de instrucción de cada persona
suma suma de edades
prom promedio de edades
mayor mayor edad
conp cantidad de personas con instrucción primaria
cons cantidad de personas con instrucción secundaria
conr cantidad de personas con instrucción superior
p1 porcentaje de personas con instrcucción primaria
p2 porcentaje de personas con instrcucción secundaria
p3 porcentaje de personas con instrcucción superior
con contador
Inicio
entero: n, con, edad, suma 0, mayor 0, conp 0, cons 0, conr 0
real: prom, p1, p2, p3
caracter: grad
// Leer Datos
Escribir (“Ingresar cantidad de personas:”)
Leer (n)
Desde (con 1) hasta (con <= n) con incremento 1 hacer
Escribir (“Ingrese grado de instrucción (P)rimaria, (S)ecunadaria, supe(R)ior:”)
Leer (grad)

Escribir (“Ingrese edad:”)

Leer (edad)
suma suma + edad
Si (edad > mayor) entonces
mayor edad
Fin_si
Según sea (grad) hacer
‘P’: conp conp + 1
‘S’: cons cons + 1
‘R’: conr conr + 1
Fin_según
Fin-desde
prom suma / n
p1 (conp * 100) / n
p2 (cons * 100) / n
p3 (conr * 100) / n
Escribir (“El promedio de edades es ”, prom)
Escribir (“La mayor edad es ”, mayor)
Escribir (“El porcentaje de personas con instrucción primaria es ”, p1)
Escribir (“El porcentaje de personas con instrucción secundaria es ”, p2)
Escribir (“El porcentaje de personas con instrucción superior es ”, p3)
Fin
4.5.Variantes de las estructuras repetitivas
4.5.1. Bucles anidados

Los bucles anidados, son bucles incluidos dentro de otro bucle. Se pueden
tener los siguientes tipos de anidamiento:
a) Un bucle Mientras dentro de un bucle Mientras, Repetir – Hasta_que o

Desde.
b) Un bucle Repetir – Hasta_que dentro de un bucle Repetir – Hasta_que,
Mientras o Desde.
c) Un bucle Desde dentro de un bucle Desde, Mientras o Repetir –
Hasta_que.
Consideraciones a tener en cuenta al trabajar con bucles

• Un bucle interno debe de estar completamente dentro del bucle externo
que lo contiene de lo contrario si los bucles se cruzan se obtendrían
resultados no previstos.
• Cuando se construyan los bucles anidados considere cada bucle como
una sentencia y siga la sintaxis ya definida para ellas.
Ejemplo 39
Bucle anidado Desde dentro de otro Desde, para hallar la tabla de multiplicar
del 1 y del 2. Se pide la siguiente salida:
Tabla de multiplicar del 1

1*1 =1
1*2 =2
…….
1 * 12 = 12
Tabla de multiplicar del 2

2*1 =2
2*2 =4

……
2 * 12 = 24
Observamos que en la tabla del 1, el primer número aparece fijo mientras

que el segundo número varia de 1 a 12, incrementándose cada número en
1, lo mismo sucede en la tabla del 2.
Para calcular el producto emplearemos la operación:
m=i*j
Tenemos bucles anidados donde el bucle externo varía de 1 a 2, y el bucle
interno de 1 a 12

i controla el bucle externo
j controla el bucle interno
m producto de los números i, j
Inicio
//Definir variables
entero: i, j, m
Desde (i 1) hasta (i <= 2) con incremento 1 Hacer
Escribir (“Tabla de multiplicar del” , i)
Desde (j 1) hasta (j <= 12) con incremento 1 Hacer
mi*j
Escribir (i , “ * ”, j, “ = ” , m )
Fin_desde
Fin-desde
Fin
Ejemplo 40
Un centro de estudios desea saber cuál ha sido el promedio más alto, de un
conjunto de 120 alumnos, sabiendo que cada alumno a llevado 5
asignaturas.

nota nota de cada una de las 5 asignaturas
suma suma de las 5 notas
prom promedio de cada alumno
mayor mayor promedio
con1 contador, que cuenta cada alumno
con2 contador, que cuenta cada nota
Inicio
entero: nota, suma 0, prom, mayor 0, con1 1, con2 1
// Calculo
Mientras (con1 <= 120) Hacer
Mientras (con2 <= 5) Hacer
Escribir (“Ingresar nota de asignatura”, con, “:”)
Leer (nota)
suma suma + nota
Fin_mientras
prom suma / 5
Si (prom > mayor) entonces
mayor prom
Fin_si
Fin_mientras
Escribir (“El mayor promedio es: ”, mayor)
Fin

Ejemplo 41
Pesudocódigo que reduce una fracción a su mínima expresión.
Por ejemplo:
Si se ingresa 36 / 48
num den
36 48 2
18 24 2
9 12 3
3 4
En su mínima expresión es 3 / 4

num numerador
den denominador
d divisor
Inicio
entero: num, den, d 2
// Leer Datos
Escribir (“Ingresar fracción:”)
Leer (num, den)
// Calcula serie y multiplica
Mientras ((d < num) and (d < den)) Hacer
Mientras ((num mod d = 0) and (den mod d = 0)) Hacer
num num Div d
den den Div d
Fin_mientras
dd+1
Fin_mientras
Escribir (“La fracción en su mínima expresión es: ”, num, “/”, den)
Fin
Ejemplo 42
Pseudocódigo que lea N notas de un estudiante y calcule su promedio,
sabiendo que se elimina la nota mas baja. Se debe validar el ingreso de
notas, que debe estar comprendido entre 0 y 20.

n cantidad de notas
nota nota
suma suma de notas
menor nota mas baja
prom promedio
con contador
Inicio
entero: n, con, nota, menor 21
real: suma 0, prom
Escribir (“Ingresar cantidad de notas”)
Leer (n)
// Calculo
con 1

Mientas (con <= n)

Repetir
Leer (nota)
Hasta_que(nota >= 0 and nota <= 20)
suma suma + nota
con con + 1
Si (nota < menor)
menor nota
Fin_si
Fin_mientras
prom (suma – menor) / (n – 1)
Fin
Ejemplo 43
Pseudocódigo para encontrar todos los números que sean capicúas en un
rango dado. Un número es capicúa o poliandro, si al invertir el número nos
da el mismo número.
Por ejemplo, los siguientes números son capicúas.

44 44
373 373
18481 18481
Así, para determinar si el número 44 es capicúa, emplearemos la variable

inver que guardará el resultado de invertir el número 44, de esta manera, si
inver es igual a 44 entonces es número capicúa.
Es necesario guardar el número 44 en otra variable por que al calcular el

número invertido perderá su valor original, que es indispensable para
realizar la comparación final.
Se pide que hallar los capicúas de un rango determinado, para esto

utilizamos las variable vi y vf que representan los valores inicial y final
respectivamente, el contador i que indica cada uno de los números que
existe dentro del rango dado, este contador empieza en vi y termina en vf
incrementándose en una unidad. Dentro del bucle guardamos i en nro, para
no perder el valor original del número que se esta evaluando.
El bucle interno se encarga de invertir nro, y guardarlo en la variable inver

cuando acaba este bucle incrementamos i para empezar nuevamente el ciclo
externo.

vi número inicial
vf número final
nro variable auxiliar donde guardamos cada número a invertir
inver número invertido
Inicio
entero: vi, vf, nro, digito, inver 0, i
// Leer datos
Escrbir (“Ingresar el valor inicial y final de un rango de números”)
Leer (vi, vf)

// Calcula número capicúa

Desde (i vi) hasta (i<= vf) com incremento 1 Hacer
nro i
inver 0
Mientras (nro >0) Hacer
digito nro Mod 10
inver 10 * inver + digito
nro nro Div 10
Fin_ mientras
Si (inver = i) entonces
Escribir (inver)
Fin_si
Fin_desde
Fin
Ejemplo 44
Pseudocódigo para buscar el número del tarot de una persona; para hallar el
número del tarot, se tiene que sumar cada uno de los números de la fecha
de nacimiento de una persona y a continuación reducirlos hasta obtener un
solo dígito.
Por ejemplo, para una fecha: 17/10/1970, se realiza:
17 + 10+ 1970 = 1997 1 + 9 + 9 + 7 = 26 2+6=8
El número del tarot calculado es 8
Para realizar este calculo, el algoritmo pide una fecha en el formato

dd/mm/aa, donde dd es el dia, mm es el mes y aa es el año.
La suma de cada una de estas variables que compone la fecha, se realiza

mediante la operación: nro dd + mm + aa, que en valores es:
nro 17 + 10 + 1970 = 1997
Luego, tenemos que descomponer nro, hallando cada dígito e ir sumándolo.

Para este caso emplearemos las operaciones:
• digito nro Mod 10, para hallar cada dígito.

• tarot tarot + digito, para sumar cada dígito
• nro nro Div 10, para acortar el número
Al acabar la primera iteración del bucle, obtendremos el valor de 26 para la

variable tarot, pero como el enunciado nos pide que el número del tarot sea
de un solo digito, entonces es necesario repetir el mismo proceso, para lo
cual hacemos nro tarot utilizando otro bucle que sea externo.

d día de nacimiento
m mes de nacimiento
a año de nacimiento
nro número al cual vamos a calcular el tarot
tarot número de tarot
Inicio

entero: d, m, a, nro 0, digito, tarot 0

// Leer datos
Escribir (“Ingresar fecha”)
Leer (d, m, a)
nro d + m + a
tarot 0
Mientras (nro > 0) Hacer
digito nro Mod 10
tarot tarot + digito
nro nro Div 10
Fin_mientras
nro tarot
Fin_mientras
Escribir (“El número del tarot es ”, tarot)
Fin
Ejemplo 45
Pseudocódigo para hallar los números primos en un rango dado, un número
es primo si es divisible por si mismo y por la unidad. Algunos números
primos son:
1 2 3 5 7 11 13
Por ejemplo, si queremos determinar si el número 11 es primo, primero

hallamos todos los divisores del número y mediante un contador calculamos
la cantidad de divisores que tiene el número, luego comparamos si la
cantidad de divisores es menor o igual que 2, entonces el número evaluado
es número primo.
Como tenemos que hallar los números primos en un rango determinado, es

necesario usar dos bucles repetitivos. Un primer bucle al que llamamos bucle
externo, que nos permite recorrer cada número (nro) definido en el rango vi
y vf. Un segundo bucle, llamado bucle interno que se encarga de calcular la
cantidad de divisores que tiene cada número del rango, mediante un
contador p. Finalmente, al acabar el bucle interno se pregunta si p <= 2 si
cumple es primo, luego se incrementa nro para ir nuevamente al bucle
externo.

vi número inicial
vf número final
nro variable auxiliar donde guardamos el nro
p contador de números primos
k contador que representa los posibles divisores
i controla el bucle mientras
Inicio
entero: vi, vf, nro, k, p
// Leer datos
Escribir (“Ingresar valor inicial y final de un rango”)
Leer (vi, vf)
// Calcula los números primos
Desde (nro vi) hasta (nro <= vf) con incremento 1 hacer
p0

Desde (k 1) hasta (k <= nro) con incremento 1 hacer

Si (nro Mod k = 0) entonces
pp+1
Fin_si
Fin_desde
Si (p <= 2 ) entonces
Escribir (nro)
Fin_si
Fin_desde
Fin
Ejemplo 46
Pseudocódigo que solicite un valor no negativo (si se ingresa un valor
negativo volverá a pedir el número hasta que se ingrese un número
positivo), una vez ingresado el número mostrar los números naturales desde
el 1 hasta el número ingresado de forma consecutiva de manera que se vaya
mostrando un número menos hasta que se muestre solo la unidad.
Por ejemplo, si se ingreso n=6, se mostrará:

123456
12345
1234
123
12
1

aux guarda el valor original del número ingresado
con contador de líneas de impresión
n cada número impreso
Inicio
entero: nro, aux, con, n
// Leer Datos
Repetir
Leer (nro)
Hasta_que (nro>0)
aux nro
Desde (con 1) hasta (con <= aux) con incremento 1 hacer
Desde (n 1) hasta (n <= nro) con incremento 1 hacer
Escribir (n)
Fin_desde
nro nro -1
Fin-desde
Fin
Ejemplo 47
Pseudocódigo que permita ingresar números enteros, y calcule el factorial de
cada número ingresado. El algoritmo termina cuando se ingresa un número
negativo.

fact factorial

con contador
Inicio
entero: nro, fact, con
// Leer Datos
Repetir
Leer (nro)
fact 1
Si (nro >= 0) entonces
Desde (con 1) hasta (con <= nro) con incremento 1 hacer
fact fact * con
Fin_desde
Escribir (“El factorial de ”, nro, “es ”, fact)
Fin_si
Hasta_que (nro < 0)
Fin
Ejemplo 48
Se desea calcular los sueldos semanales de N obreros; durante los 5 días de
la semana se registran la cantidad de horas diarias y el turno en el que
trabajó el obrero. Un obrero puede alternar su trabajo en cualquiera de los
dos turnos. La tarifa de cada hora trabajada para el turno mañana es de
S/23.00 y para el turno tarde S/25.40. Además, si un obrero trabajó durante
una semana más de 40 horas, se le pagará S/.12.00 por cada hora adicional
a las 40.

n cantidad de obreros
hor horas trabajadas
dia cada dia de la semana
totHor total de horas que trabaja un obrero durante una semana
con contador de obreros
tur turno en el que trabaja un obrero
pagoDia pago del día
pagoSem pago de la semana
pagoExtra pago extra
Inicio
entero: n, hor, dia, con 0, totHor
caracter: tur
real: pagoDia, pagoSem, pagoExtra
// Leer Datos
Escribir (“Ingresar cantidad de obreros:”)
Leer (n)
Repetir
pagoSem 0
totHor 0
Desde (dia 1) hasta (dia <= 5) con incremento 1 hacer
Escribir (“Ingresar turno (M)añana, (T)arde”)
Leer (tur)
Escribir (“Ingresar cantidad de horas trabajadas”)
Leer (hor)
Según sea (tur) hacer
‘M’: pagoDia hor * 23.00

‘T’ : pagoDia hor * 25.40

Fin_según
pagoSem pagoSem + pagoDia
totHor totHor + hor
Fin_desde
Si (totHor >40) entonces
pagoExtra (hor – 40) * 12.00
Fin_si
pagoSem pagoSem + pagoExtra
Escribir (“El pago semanal es ”, pagoSem)
con con + 1
Hasta_que (con = n)
Fin
4.5.2. Bucles infinitos
Son bucles que nunca terminan (no tienen fin). Pueden implementarse
fácilmente utilizando las sentencias Mientras o Repetir – Hasta_que.
Generalmente son condiciones no deseadas y el programador las utiliza
según su criterio, colocando en su interior una instrucción que fuerza la
terminación del bucle, para nuestro caso se utiliza la palabra Salir (break).
Para este caso, reemplazamos en la expresión_lógica por verdadero (true)
Mientras (verdadero) Hacer Repetir

instrucciones instrucciones
Si (condición) entonces Si (condición) entonces
Acción Acción
Salir //termina el bucle infinito Salir //termina el bucle infinito
Fin_si Fin_si
Acción Acción
Fin_Mientras Hasta_que (verdadero)
Ejemplo 49
Pseudocódigo que genera una secuencia de números utilizando el siguiente
algoritmo:
• Empezamos por cualquier número entero positivo
• Si es par, Lo dividimos por dos, si es impar lo multiplicamos por tres y le
sumamos 1
• Repetimos el segundo paso con el número resultante, la secuencia se
puede repetir indefinidamente, detenerlo hasta que aparezca el primer
número 1
Por ejemplo si ingresemos el número 20, la secuencia generada seria:

10 5 16 8 4 2 1 4 2 1….
Observar que la serie comienza a repetir la serie 4 2 1 indefinidamente, el

algoritmo debe de leer el número inicial, imprimir el número de valores
encontrados hasta la aparición de un valor 1 en la secuencia.

nro cada número de la serie
Inicio
// Definir variable
entero: nro

// Leer Datos
Escribir (“Ingresar número que inicia la serie:”)
Leer (nro)
Mientras (verdadero) hacer // bucle infinito
Si (nro Mod 2 = 0)
nro nro / 2
Sino
nro 3*nro + 1
Fin_si
Escribir (nro)
Si (nro = 1) entonces // cuando nro es igual a 1
Salir // termina el bucle infinito
Fin_si
Fin_mientras
Fin
Ejemplo 50
Pseudocódigo que muestra el mensaje “BUCLE INFINITO” infinitas veces.

No es necesario el uso de ninguna variable
Inicio
Mientras (verdadero)
Escribir (“BUCLE INFINITO”)
Fin_mientras
Fin
Ejemplo 51
Pseudocódigo que imprima el mensaje es par o impar, en caso se ingrese un
número entre 3 y 13, sino está en el intervalo, imprimir el mensaje “fuera de
rango”.

nro número que se evalúa como par o impar
Inicio
// Definir e inicializar variable
lógico: r falso
Repetir
Leer (nro)
Si (nro >= 3 and nro <= 13) entonces
Si ( nro Mod 2 = 0 ) entonces
Escribir (“Es par”) // es par
Sino
Escribir (“Es impar”) // es impar
Fin_si
r verdadero // r se hace verdadero para que
// salga del bucle infinito
Sino
Escribir (“No esta entre 3 y 13”)
r falso // r se hace falso para que siga en
el bucle infinito
Fin_si
Hasta_que (r)

Fin
4.6.Ejercicios propuestos
1. Determinar el factorial de los N primero números pares

Número Factorial
2 2
4 24
6 720
8 40320
2. Escribir un pseudocódigo muestre todos los números de tres cifras tales que
la suma de los cuadrados de sus dígitos sea igual al cociente de la división
entera del número entre 3.
3. Los números amigos son aquellos en los que la suma de los divisores de uno
es el otro.
220 = 1+2+4+5+10+11+20+22+44+55+110 = 284
284 = 1+2+4+71+142 = 220
Este par de números amigos era conocido por los griegos (220, 284). El
siguiente par de números amigos fue descubierto en el siglo XIII y
redescubierto por Fermat en 1636 (los números 17296 y 18416). Descartes
descubrió el siguiente par: 9363584 y 9437056. Todos estos grandes
matemáticos se saltaron el par 1184-1210 que fue descubierto por un niño
italiano de 16 años Niccolò Paganini. Elaborar un pseudocódigo que
encuentre todos estos números amigos.
4. El horóscopo de la alquimia, basado en la numerología y las
correspondencias planetarias, te permitirá conocer qué poderosas energías,
llegadas del cielo en forma de metales, rigen tu vida. Las civilizaciones
antiguas consideraban los metales como la carne de los dioses, y eran
conscientes de sus poderes mágicos.
Crearon el horóscopo de los metales, gracias al cuál no sólo conocerás qué
metal te corresponde por tu fecha de nacimiento, sino también el que te rige
cada año. Ponerte joyas con el metal que te pertenezca o llevarlo
simplemente en el bolsillo aumentará los dones que te concede éste y te
aportará protección y suerte.
Elaborar un pseudocódigo que averigüe a qué metal pertenece una persona,
para esto sume los números de tu fecha de nacimiento y a continuación
reducirlos a un sólo dígito. Una vez que tengas el número busca en la tabla
siguiente el metal correspondiente.
Por ejemplo, alguien nacido el 12 de marzo de 1973 estaría bajo la
influencia de:
Metal de nacimiento: 1+2+3+1+9+7+3= 26 (2+6) = 8= Níquel
Número Metal Virtudes
1 Plata Seductores y volubles
2 Hierro Dinámicos y combativos
3 Mercurio Locuaces y simpáticos
4 Zinc Impulsivos y serviciales
5 Estaño Inconstantes y sociables
6 Plomo Pesimistas y tímidos
7 Platino Intelectuales y apasionados
8 Niquel Vagabundos y poetas
9 Oro Altruistas y encantadores
0 Cobre Afectuosos y detallistas
Sólo en el caso de que la suma resultante sea 10, 20, 30, 40, 50, 60, 70, 80
ó 90, no se reducirá y se tomará el 0 como número y el Cobre como metal
correspondiente.

5. Escribir un pseudocódigo que encuentre el siguiente primo dado un número

ingresado por el usuario. Por ejemplo: si el número ingresado es 20, el
siguiente primo seria 23.
6. Escribir un pseudocódigo que lea un número y lo despliegue como sumas
sucesivas de números. Por ejemplo:
numero = 15245
10000 + 5000 + 200 + 40 + 5
7. Escribir un pseudocódigo para buscar un número cuyo cuadrado sea igual o
más cercano a un número ingresado.
Por ejemplo:
Si se ingresa 14 el cuadrado más cercano es 3.
Si se ingresa 16 el cuadrado más cercano es 4.
8. Escribir un pseudocódigo que lea 100 números positivos de forma aleatoria
y consecutiva, calcular y mostrar el mayor número por cada 10 números
ingresados. Además mostrar el mayor número ingresado y diga en que
decena se ingresó.
9. Construir un algoritmo que permita ingresar números enteros, calcular la
suma de los dígitos pares y la suma de sus dígitos impares de cada número
positivo ingresado. El algoritmo termina cuando se ingresa el cero.
10. Se registran las N aulas de la sección secundaria de un centro educativo, y
por cada sección se registran los promedios finales de sus M alumnos.
Elaborar un algoritmo que muestre el nombre del mejor alumno de cada
aula y el mejor alumno de toda la sección secundaria, así mismo calcular el
promedio general del aula.
11. Un número perfecto es aquel cuya suma de sus divisores excluyendo el
mismo número da como resultado el número. Por ejemplo 6 es un número
perfecto, porque 1 + 2 + 3 = 6. Se pide elaborar un algoritmo que muestre
los 5 primeros números perfectos.
12. Los números Amstrong o cubos perfectos, son aquellos que sumados sus
dígitos al cubo nos da el mismo número. Por ejemplo 153 es un número
Amstrong pues 13 + 53 + 33 = 153. Elaborar un algoritmo que encuentre los
3 primeros números Amstrong.
13. Un centro comercial ofrece tres tipos de productos, como se muestra en el
siguiente cuadro.
Producto Precio Descuento (%)
A 15.20 10
B 12.47 8
C 10.50 5
El centro comercial vende dichos productos a N número de clientes. Un
cliente cualquiera puede comprar M productos de cada tipo. Se pide elaborar
un algoritmo que calcule el total que paga cada cliente y el total que recauda
el centro comercial.
14. Escribir un pseudocódigo en el que se ingrese un número entre el 1 y el 9
(se pedirá el ingreso de dicho número hasta que cumpla la condición), una
vez ingresado el número correcto mostrar la tabla de multiplicar de ese
número, después de mostrar la tabla, el pseudocódigo debe preguntar:
¿Desea ingresar otro número? S/N, si la respuesta es S, se volverá a
ingresar otro número y si la respuesta es N finalizará el pesudocódigo. Las
tablas de multiplicar debe tener el siguiente formato:
5X1=5
5 X 2 = 10
…
5 X 9 = 45
15. Un almacén se encuentra de aniversario y ha programado una serie de
ofertas con la finalidad de brindar facilidades a sus clientes y al a vez de
incrementar sus ventas. Estas ofertas se basan específicamente en un

porcentaje de descuento sobre el total de compra el cual varía de acuerdo al

monto:
• Por un monto mayor o igual a $500 se hará un descuento del 30%
• Por un monto menor de $500 pero mayor o igual a 200 se hará un
descuento del 20%
• Por un monto menor de $200 pero mayor o igual a 100 se hará un
descuento del 10%
Se pide elaborar un algoritmo que calcule el monto total que recauda el
almacén, así como, el monto final que paga un cliente. El algoritmo termina
cuando se ingresa una compra negativa.
16. El un proceso repetitivo se ingresa números enteros, se pide elaborar un
algoritmo que calcule el promedio de números negativos. El pseudocódigo
termina cuando se ingresa el número cero.
17. Hacer un algoritmo que lea N consumos de un restaurante. Si el consumo
ingresado excede los 70 soles, el descuento será de 5%. Se pide mostrar el
monto que paga cada cliente.
18. Construir un algoritmo que muestre el mayor y el menor dígito de un
número ingresado.
19. Determinar la suma de los términos que ocupan las posiciones pares y la
suma de los términos que ocupan las posiciones impares, de la siguiente
serie, considerando los n primeros términos:
1/3 + 2/5 + 3/7 + 4/9 + 5/11 + ...
20. Un almacén se encuentra de aniversario y ha programado una serie de
ofertas. Estas ofertas se basan específicamente en un porcentaje de
descuento sobre el total de compra, de esta manera:
• Por una compra mayor o igual a S/.350.00 se hará un descuento del
30%.
• Por una compra menor de S/.350.00 pero mayor o igual a S/.200.00 se
hará un descuento del 20%.
• Por un monto menor de S/.200.00 pero mayor o igual a S/.100.00 se
hará un descuento del 10%.
Se pide elaborar un algoritmo que calcule el monto total que recauda el
almacén por las 25 primeras compras realizadas, así como, el monto final
que paga cada cliente.
21. Una compañía de seguros está preparando un estudio concerniente de todos
sus asegurados. Por cada asegurado se registra los siguientes datos: año de
nacimiento y sexo (‘M’ o ‘F’), se pide calcular:
• El porcentaje de asegurados menores de 30 años
• El porcentaje de asegurados de sexo femenino y masculino
• La mayor y la menor edad de los asegurados
El registro de asegurados finaliza cuando se ingresa un año negativo.
22. El Ministerio de transportes desea saber, de los N autos que entran a
nuestro país, cuántos entran con calcomanía de cada color. Conociendo el
último dígito de la placa de cada automóvil se puede determinar el color de
la calcomanía, como se muestra en el siguiente cuadro:
Dígito Color
1o2 amarilla
3o4 negro
5o6 rojo
7o8 verde
9o0 azul
23. Ingresar números enteros y mostrar la cantidad de dígitos que tiene cada
número ingresado. El pseudocódigo termina cuando se ingresa el número
100.
24. Construir un pseudocódigo que calcule y muestre el sueldo de los N
empleados de un empresa que trabajan por horas, la tarifa por cada hora
trabajada es única (igual) para todos los empleados, asimismo, calcular la

cantidad de empleados que reciben un sueldo menor a S/.500.00, la

cantidad de empleados que reciben un sueldo entre S/.500.00 y S/.1200.00
y la cantidad de empleados que reciben un sueldo mayor a S/.1200.00.
25. La oficina de bienestar social del ministerio de vivienda, realiza un muestreo
en 10 departamentos de nuestro país, de esta manera por cada
departamento se registran los datos de N personas, como edades y pesos.
Se pide elaborar un algoritmo que determine la cantidad de los niños,
jóvenes, adultos y adultos mayores registrados en cada departamento, el
mayor y el menor peso en cada departamento. Se sabe que:
• De 0 a 12 años, es niño
• De 13 a 29 años, es joven
• De 30 a 59 años, es adulto
• De 60 a más años, es adulto mayor.

Algoritmos: Un enfoque práctico - Capítulo III Franklin Arriola R. / Yuliana Jáuregui R.
Programación Modular
1. Definición de programación modular
La programación modular es un método de diseño que permite resolver un

problema dividiendolo en problemas mas pequeños. Se basa en la descomposición
descendente o jerarquía de módulos, que se enlazan mediante un módulo principal.
A este tipo de programación se le suele llamar también diseño descendente o

metodología del “divide y vencerás” o programación top-down.
Siempre existe un módulo o programa principal que es con el que comienza la

ejecución de todo programa y luego desde él, se va llamando al resto de los
subprogramas o módulos.
Los subprogramas son programas independientes que resuelven la función definida

por los módulos, además pueden representar tareas simples que se ejecutan una
vez o cuantas veces se precise, son llamados desde el programa principal u otro
módulo o subprograma.
Raíz
Módulo 1 Módulo 2 Módulo 3
Módulo 4 Módulo 5 Módulo 6 Módulo 7
Módulo 8 Módulo 9 Módulo 10 Módulo 11
Módulo 12
Fig. 1. Representación de módulos
2. Módulo
Es un subprograma que representa una tarea determinada, se identifica por medio

de un nombre y es llamado o invocado desde otras partes del programa. Durante la
llamada del módulo se pueden intercambiar datos, logrando así, que el módulo
reciba datos y devuelva resultados utilizando para ello unas variables llamadas
parámetros.
3. Partes de un módulo
Podemos decir que está conformado por dos partes: La declaración del módulo y el
cuerpo del módulo, tal como se ilustra a continuación.
tipoDeMódulo nombreDelMódulo (Lista de parámetros) Declaración del módulo
// Sentencias
Cuerpo del módulo
Fin_módulo

El siguiente es un ejemplo de la estructura de un módulo que calcula la suma de

dos números enteros, así tenemos:
Función suma (entero nro1, entero nro2) : entero

entero: r
r nro1 + nro2
retornar r
Fin_función
• Declaración del módulo

a) tipoDeMódulo, específica el tipo de módulo que puede ser una función o un
procedimiento. En nuestro ejemplo, es una Función.
b) nombreDelMódulo, puede ser cualquier nombre que no contenga espacios en
blanco. Para nuestro ejemplo el nombre del módulo es suma.
c) Lista de parámetros, puede contener cero o más parámetros formales
(variables). Cada parámetro debe contener su respectivo tipo de dato, estos
deben ir separados por una coma. En el ejemplo los parámetros son nro1 y
nro2.
• Cuerpo del módulo
Conformado por las sentencias del subprograma que definen la tarea que va a
realizar el módulo.
4. Parámetros
Son datos mediante los cuales se comunica explícitamente con la unidad de

programa que llama. Los parámetros pueden ser de 2 tipos:
• Parámetros actuales; son los datos que se mandan desde el módulo principal al
resto de módulos.
• Parámetros formales; son los datos que reciben los módulos.
En una llamada a un módulo tiene que verificarse que:
• El número de parámetros actuales debe de ser igual al número de parámetros
formales.
• Los parámetros que ocupan el mismo orden en cada una de las listas deben de
ser compatibles en tipo.
5. Tipos de Módulos
Los módulos se pueden clasificar según el tipo de retorno o valor que devuelve, en:
funciones y procedimientos.
5.1. Funciones
Es un subprograma que realiza ciertos cálculos con una o más variables de

entrada, y produce un único valor o resultado que puede ser un valor numérico,
un carácter, una cadena o un valor booleano.
Se caracteriza porque devuelve un único valor al lugar desde donde se efectuó

la llamada, y es necesario especificar el tipo de dato que devuelve el módulo
(tipo de resultado). Además se debe incluir la palabra reservada retornar
seguido del valor devuelto. Así tenemos:
Función NombreDeLaFunción (Lista de parámetros): tipo de resultado

Acciones

Retornar valor
Fin_función
La llamada a una función se realiza mediante un nombre y una lista de

parámetros:
x nombreDeLaFunción (lista de parámetros)
La variable x nos sirve para guardar el valor devuelto de la función, debe ser
del mismo tipo del valor que se devuelve.
Por ejemplo:
x suma (n1, n2)
Escribir (“La suma es ”, x)
La función puede ser llamada desde el programa principal o desde cualquier

otro módulo o subprograma.
Si el módulo no tiene parámetros, los paréntesis estarán vacíos. Al utilizar

parámetros se debe tener en cuenta, que estos deben coincidir en número, tipo
y orden, tanto en la declaración del módulo como en la llamada a este.
Pasos para hacer la llamada a una función:
1. Al hacer la llamada se cede el control a la función, se asocia (asigna el valor)

cada parámetro actual a cada parámetro formal, siempre por orden de aparición
y de izquierda a derecha, debe coincidir los tipos de datos y el número de
parámetros reales y formales.
2. Se ejecutan las acciones de la función hasta que lleguemos a una de tipo
retornar <valor> que pondrá fin a la ejecución.
3. Se devuelve el control al subprograma que hizo la llamada pero sustituyendo el
nombre de la función por el valor devuelto.
5.2. Procedimientos
Es un subprograma que proporciona cero, uno o varios valores en función de

sus parámetros definidos en su formato.
Se caracteriza porque no se devuelve ningún valor al lugar desde donde se

efectuó la llamada, y es por ello que no se especifica ningún tipo de resultado.
Como no se devuelve ningún valor, la palabra reservada retornar no es
necesaria. Así tenemos:
Procedimiento NombreDelProcedimiento (Lista de parámetros)

Acciones
Fin_procedimiento
Para llamar a un procedimiento basta con escribir su nombre y los

correspondientes parámetros si los hubiera. El tratamiento de los parámetros
es idéntico al ya mencionado para la función.
6. Estructura de un algoritmo que contiene módulos
A continuación se define la estructura de un algoritmo con módulos, en este se

identifica al módulo principal y a los otros módulos creados por el desarrollador, así
como las listas de parámetros actuales y formales.

Parámetros actuales
Inicio
//Cuerpo del módulo principal
nombreDelMódulo1 (Lista de parámetros)
Fin
tipoDeMódulo nombreDelMódulo1 (Lista de parámetros)
// Cuerpo del módulo Parámetros formales
Fin_modulo
// Cuerpo del módulo
Fin_modulo
// Cuerpo del módulo
Fin_modulo
7. Proceso de llamada a un módulo
Una vez que se encuentra una llamada a un módulo, se transfiere el control del
programa al módulo invocado, se ejecuta las instrucciones del cuerpo del módulo y
finalmente, el control del programa regresa a la siguiente instrucción de la llamada
del módulo.
En el siguiente ejemplo se tiene un programa que utiliza el módulo suma en el cual

se ilustra el proceso de llamada a un módulo.
El control Inicio
retorna a la entero x, nro1 3, nro2 5
instrucción Transfiere
x suma (n1, n2) //llamada a la función el control
que sigue a
la llamada Escribir (“La suma es ”, x) a la función
Fin
Función suma (entero pnro1, entero pnro2): entero

entero: r
r pnro1 + pnro2
retornar r
Fin_función
Pasos del proceso de llamada:
a) Se ejecuta el módulo principal (Inicio - Fin), y se asignan valores para las

variables nro1 3 y nro2 5.
b) Se llama al módulo suma() y los valores de nro1 y nro2, son asignados a los
parámetros pnro1 y pnro2 respectivamente, así entonces pnro1 recibe el valor 3
y pnro2 recibe el valor de 5.
• Se ejecutan las sentencias que están dentro del cuerpo del módulo suma,
esto es, se suman los dos números: 3 + 5, obteniéndose el valor de r 8.
• Se ejecuta la sentencia retornar, para el valor de r 8, devolviendo este
valor al lugar donde se hizo la llamada, y asignando a x el valor de 8.
c) Finalmente se obtiene la suma de dos números que en este caso es 8.

8. Valor de retorno de un módulo
Cuando se declara un módulo, el tipo de resultado nos indica el tipo de dato que ha
de devolver, es decir se está trabajando con una función, si el módulo no devuelve
ningún valor se trata de un procedimiento.
9. Cuándo crear módulos con parámetros
La ventaja de utilizar parámetros, es que facilitan la generalización de un módulo.

De esta manera el módulo pueda operar sobre un gran número de situaciones
diferentes.
Ejemplo
Pseudocódigo para hallar el mayor de dos números ingresados.
Módulos que se utilizan:
• Función mayor (entero pnro1, entero pnro2), devuelve un valor entero que
representa el mayor de dos números.
Inicio
entero: nro1 5, nro2 6, m
m mayor(nro1, nro2)
Escribir (“El mayor numero es : ” , m)
Fin
Función mayor (entero pnro1, entero pnro2) : entero

entero: my
Si (pnro1 > pnro2) entonces
my pnro1
Sino
my pnro2
Fin_si
retornar my
Fin_función
a) Se ejecuta el módulo principal (Inicio - Fin) y se asignan los valores:

nro1 5 y nro2 6
b) Se llama al módulo mayor() y los valores de nro1 y nro2, son asignados a los
parámetros pnro1, pnro2 respectivamente, así entonces:
pnro1 5 y pnro2 6
a. Se ejecutan las sentencias que están dentro del cuerpo del módulo para
estos valores obteniéndose un valor de my 6.
b. Se ejecuta la sentencia retornar para un valor de my 6, devolviendo
este valor al lugar donde fue llamada, y asignando a la variable m un
valor de 6.
3. Finalmente se obtiene el mayor de dos números que en este caso es 6.
10.Métodos para el paso de parámetros
El paso de parámetros pueden realizarse por medio de dos métodos:

10.1. Por valor
Pasar parámetros por valor significa copiar los parámetros actuales en sus
correspondientes parámetros formales, operación que se hace
automáticamente cuando se llama a un módulo, con lo cual no se modifica los
parámetros actuales.
Se puede modificar el valor de un parámetro formal dentro del módulo, pero el
valor del parámetro actual en el punto de llamada no cambiará. Los parámetros
por valor no pueden ser modificados por el subprograma.
Ejemplo
Pasar por valor a 3
Inicio
//Definir e inicializar variable
entero: a 3
Escribir (“Antes de la llamada a = ”, a)
porValor (a) // llamada al módulo
Escribir (“Después de la llamada a = ”, a)
Fin
Procedimiento porValor (entero x)

xx+1
Fin_procedimiento
La salida del algoritmo:
Antes de la llamada a = 3
Después de la llamada a = 3 (no cambia el parámetro actual)
10.2. Por referencia
Es aquel en el que se pasa una referencia a una variable y no el valor, lo que

permite que pueda ser modificada por el módulo llamado. Cualquier cambio de
valor que sufra un parámetro dentro del módulo, también se produce en el
parámetro actual correspondiente de la llamada al módulo.
Pasar una referencia significa darle la dirección de memoria de la variable, la

cual será representada por el ampersand (&).Por ejemplo
Dirección 205
18
Si llamamos a la variable x nos devuelve el valor de 18, pero si referenciamos

&x nos devuelve la dirección 205.
Ejemplo
Pasar por referencia a 3
Inicio
//Definir e inicializar variable
entero: a 3
Escribir (“Antes de la llamada a = ”, a)

porReferencia (a) // llamada al módulo

Escribir (“Después de la llamada a = ”, a)
Fin
Procedimiento porReferencia (entero &x)

xx+1
Fin_procedimiento
La salida del algoritmo:
Antes de la llamada a = 3
Después de la llamada a = 4 (cambia el parámetro actual)
11.Variables Globales y Locales
• Las Variables Globales, son aquellas variables que pueden ser usadas en todos
los módulos del algoritmo, estas variables son declaradas fuera de todos los
módulos.
• Las Variables Locales, son aquellas variables que sólo son usadas dentro del
módulo donde es declarada.
Ejemplo:
// Declaración de variables globales

tipo: nombreDeVariableGlobal1, nombreDeVariableGlobal2
Inicio
// Declaración de variables locales
tipo: nombreDeVariableLocal1, nombreDeVariableLocal2
Fin

Cuerpo del módulo1
Fin_modulo
Cuerpo del módulo2
Fin_modulo

Cuerpo del módulo3
Fin_modulo
12.Ejercicios resueltos
Ejemplo 01
Pseudocódigo que calcule el área de un cuadrado. La fórmula es:

área del cuadrado = lado * lado
Módulos que se utilizan

• Función areaCuadrado(entero plado), devuelve un número entero que
representa el área de un cuadrado.
Parámetros a utilizar en el pseudocódigo

lado parámetro actual del módulo areaCuadrado()
r guarda el valor de retorno del módulo areaCuadrado()
plado parámetro formal del módulo areaCuadrado( )
Inicio
entero: lado, r
Escribir (“Ingrese lado del cuadrado ")
Leer (lado)
r areaCuadrado (lado)
Escribir (" El área del cuadrado es ", r)
Fin
Función areaCuadrado (entero plado) : entero

entero: a
a plado*plado
retornar a
Fin_función

1. Se ejecuta el módulo principal (Inicio-Fin) en donde se lee el lado. Por ejemplo
lado 4
2. Se llama al módulo areaCuadrado( ), se pasa el valor de lado que es asignado a
plado, entonces plado 4 .
a. Se ejecutan las sentencias que están dentro del módulo obteniéndose el
valores de a 16.
b. Se ejecuta la sentencia retornar para un valor de a 16, devolviendo
este valor al lugar donde fue la llamada y asignando a la variable r un
valor de 16.
3. Finalmente se obtiene el área de un cuadrado que en este caso es : 16
Ejemplo 02
Pseudocódigo para calcular el determinante de una matriz de orden 2; un
determinante se obtiene multiplicando en cruz y restando.
a b
= a*d − b *c
c d

• Procedimiento ingresar(entero &pa, entero &pb, entero &pc, entero &pd),
permite ingresar cuatro valores a través de los parámetros por referencia &pa,
&pb, &pc y &pd.
• Función calculaDeterminante (entero pa, entero pb, entero pc, entero pd),
devuelve un valor entero que representa el resultado de la operación pa * pd –
pb * pc.
• Procedimiento imprimir(entero pm), muestra el valor calculado del
determinante.


a, b, c, d parámetros actuales de los módulos ingresar() y
calculaDeterminante()
m guarda el valor de retorno del módulo calculaDeterminante()
y es parámetro actual del módulo imprimir()
pa, pb, pc, pd parámetros formales de los módulos ingresar() y
calculaDeterminante()
pm parámetro formal del módulo imprimir().
Inicio
entero: a, b, c, d, m
ingresar (a, b, c, d)
m calculaDeterminante (a, b, c, d)
imprimir(m)
Fin
Procedimiento ingresar(entero &pa, entero &pb, entero &pc, entero &pd)

Escribir (“Ingresar números de la matriz”)
Leer (pa, pb, pc, pd)
Fin_procedimiento
Función calculaDeterminante(entero pa, entero pb, entero pc, entero pd) : entero
entero: t
t pa * pd – pb * pc
retornar t
Fin_función
Procedimiento imprimir(entero pm)

Escribir (“El Determinante es: ”, pm)
Fin_procedimiento

1. Se ejecuta el módulo principal y se llama al módulo ingresar() en el en donde se
leen los valores para a, b, c, d. Por ejemplo a 4 , b 3, c 7 y d 8.
2. Se llama al módulo calculaDeterminante() y se pasa los valores de a, b, c y d.
que son asignados a los parámetros pa, pb, pc y pd respectivamente entonces
pa 4, pb 3, pc 7 y pd 8.
a. Se ejecutan las sentencias dentro del módulo para estos valores
obteniéndose un valor de t 11.
b. Se ejecuta la sentencia retornar para un valor de t 11, devolviendo
este valor al lugar donde fue llamada, y asignando a la variable m un
valor de 11.
3. Finalmente se llama al módulo imprimir(), donde se muestra el valor del
determinante que en este caso es 11
Ejemplo 03
Pseudocódigo que identifique si un número entero es par o impar.

• Procedimiento ingresar(entero &pnro), permite ingresar un número cualquiera a
través del parámetro por referencia &pnro.
• Función esparImpar(entero pnro), devuelve un resultado booleano, si pnro es
par devuelve verdadero en caso contrario devuelve falso.

• Procedimiento imprimir(entero pnro, booleano pm), muestra un mensaje en el

que se indica si el número ingresado es par o impar.

nro parámetro actual de los módulos ingresar(), esparImpar() e
imprimir()
m guarda el valor de retorno del módulo esparImpar() y es parámetro
actual del módulo imprimir()
pnro parámetro formal de los módulos ingresar(), esparImpar() e
imprimir()
pm parámetro formal del módulo imprimir()
Inicio
entero: nro
booleano: m
ingresar (nro)
m esparImpar (nro)
imprimir (nro, m)
Fin
Procedimiento ingresar(entero &pnro)

Leer (pnro)
Fin_procedimiento
Función esparImpar(entero pnro) : booleano

// Definir variable
boolean: r
r pnro Mod 2
retornar r
Fin_función
Procedimiento imprimir(entero pnro, booleano pm)

Si (pm) entonces
Escribir (pnro, “Es número impar”)
Sino
Escribir (pnro, “Es número par”)
Fin_si
Fin_procedimiento
Pasos del proceso de llamada

1. Se ejecuta el módulo principal (Inicio-Fin) y se llama al módulo ingresar(), en
el que se lee un valor para nro, por ejemplo 8.
2. Se llama al módulo esparImpar(), devolviéndose un valor falso, dado que el
número es igual a 8 (el rsiduo es cero)
3. Finalmente se llama la módulo imprimir() donde se obtiene el resultado: 8 “Es
número par”
Ejemplo 04
Pseudocodigo para intercambiar los valores de dos números enteros.

• Procedimiento ingresar(entero &pa, entero &pb), permite ingresar dos números
enteros a través de los parámetros por referencia &pa y &pb.
• Procedimiento intercambio (entero &pa, entero &pb), halla el intercambio entre
los parámetros por referencia &pa y &pb.

• Procedimiento imprimir(entero pa, entero pb), muestra los valores

intercambiados de a y b.

a, b parámetros actuales de los módulos ingresar(), intercambio() e
imprimir()
pa, pb parámetros formales de los módulos ingresar(), intercambio() e
imprimir()
Inicio
entero: a, b
ingresar (a, b)
intercambio (a, b)
imprimir (a, b)
Fin
Procedimiento ingresar(entero &pa, entero &pb)

Escribir (“Ingrese primer numero ")
Leer (pa)
Escribir (“Ingrese segundo numero ")
Leer (pb)
Fin_procedimiento
Procedimiento intercambio(entero &pa, entero &pb)

// Definir variable
entero: temp
temp pa
pa pb
pb temp
Fin_procedimiento
Procedimiento imprimir(entero pa, entero pb)

Escribir (“a= ”, pa, “b = ”, pb)
Fin_procedimiento

1. Se ejecuta el módulo principal (Inicio-Fin) y se llama al módulo ingresar() en
donde se leen los valores para a, b. Por ejemplo a 4, b 3.
2. Se llama al módulo intercambio() con los valores de a, b que son asignados a
los parámetros pa, pb respectivamente entonces pa 4 y pb 3.
a. Se ejecutan las sentencias que están dentro del módulo obteniéndose los
valores de pa 3 y pb 4.
b. El módulo devuelve estos valores al lugar donde fue la llamada.
3. Finalmente se llama al módulo imprimir() y se muestra el intercambio de las dos
variables que en este caso es: a 3 , b 4
Ejemplo 05
Pseudocódigo que construye un número a través de 3 valores ingresados.
Por ejemplo:
Primer valor: 4
Segundo valor: 5
Tercer valor: 6
El número compuesto es: 456

• Procedimiento ingresar(entero &pa, entero &pb, entero & pc), permite ingresar
tres números enteros de un dígito a través de los parámetros por referencia
&pa, &pb y &pc.
• Función compone (entero pa, entero pb, entero pc), devuelve un número
entero que representa la concatenación de tres valores.
• Procedimiento imprimir(entero px), muestra el número construido a partir de los
valores ingresados.

a, b, c parámetros actuales de los módulos ingresar() y compone()
pa, pb, pc parámetros formales de los módulos ingresar() y compone()
x guarda el valor de retorno del módulo compone() y es
parámetro actual del módulo imprimir()
px parámetro formal del módulo imprimir()
Inicio
entero: a, b, c, x
// Lectura de datos
ingresar (a, b, c)
x compone (a, b, c)
imprimir (x)
Fin
Procedimiento ingresar(entero &pa, entero &pb, entero &pc)

Escribir (“Ingrese tres números”)
Leer (pa, pb, pc)
Fin_procedimiento
Función compone(entero pa, entero pb, entero pc) : entero

// Definir variable
entero : result
result100 * pa + 10 * pb + pc
retornar result
Fin_función
Procedimiento imprimir(entero px)

Escribir (“El número compuesto es ”, px)
Fin_procedimiento

1. Se ejecuta el módulo principal (Inicio-Fin) y se llama al módulo ingresar() en
donde se leen los valores para a, b, c. Por ejemplo a 4, b 5, c 6.
2. Se llama al módulo compone(), se pasa los valores de a, b y c que son
asignados a los parámetros pa, pb y pc respectivamente entonces pa 4, pb
5 y pc 6.
c. Se ejecutan las sentencias dentro del módulo para estos valores
obteniéndose un valor de result 456.
d. Se ejecuta la sentencia retornar para un valor de result 456,
devolviendo este valor al lugar donde fue llamada, y asignando a la
variable x un valor de 456.
3. Finalmente se llama al módulo imprimir() donde se muestra el valor del número
construido que en este caso es 456
Ejemplo 06
Pseudocódigo que lea un número entero N y un digito D, y averigüe si D es o no un
digito de N.

Por ejemplo:
n =123, d = 3 devuelve verdad (3 es dígito de 123)
n =123, d = 4, devuelve falso (4 no es dígito de 123)

• Procedimiento ingresar(entero &pn, entero &pd), permite ingresar un número
entero y un dígito a través de los parámetros por referencia &pn y &pd.
• Función encontroDigito(entero pn, entero pd), devuelve un valor booleano que
determina si se encontró o no al dígito.
• Procedimiento imprimir(booleano pr, entero pd), muestra el mensaje
correspondiente si encontró o no al dígito en el número.

n parámetro actual de los módulos ingresar() y encontroDigito()
d parámetro actual de los módulos ingresar(), encontroDigito() e
impimir()
pn parámetro formal de los módulos ingresar() y encontroDigito()
pd parámetro formal de los módulos ingresar(), encontroDigito() e
imprimir()
r guarda el valor de retorno del módulo encontroDigito() y es

pr parámetro formal del módulo imprimir()
Inicio
entero: n, d
booleano: r
ingresar (n, d)
r encontroDigito (n, d)
imprimir (r, d)
Fin
Procedimiento ingresar(entero &pn, entero &pd)

Escribir (“Ingrese numero”)
Leer (pn)
Escribir (“Ingrese digito”)
Leer (pd)
Fin_procedimiento
Función encontroDigito(entero pn, entero pd) : booleano

// Definir variable
entero: digito
boolean: encontro falso
Mientras ((pn > 0) and (encontro = falso))
digito pn Mod 10
Si (pd = digito) entonces
encontro verdadero
Fin_si
pn pn Div 10
Fin_mientras
retornar encontro
Fin_funcion
Procedimiento imprimir(booleano pr, entero pd)

Si (pr) entonces

Escribir (“Encontró dígito ”, pd)

Sino
Escribir (“No encontró dígito ”, pd)
Fin_si
Fin_procedimiento

1. Se ejecuta el módulo principal (Inicio-Fin) y se llama al módulo ingresar() en el
que se lee los valores n y d. Por ejemplo n 123 y d 3.
2. Se llama al módulo encontroDigito() se pasa los valores de n y d que son
asignados a los parámetros pn y pd respectivamente entonces pn123, pd 3.
a. Se ejecutan las sentencias dentro del módulo para estos valores
obteniéndose un valor de encontro verdadero.
b. Se ejecuta la sentencia retornar para un valor de encontro verdadero,
variable r un valor booleano de verdadero.
3. Finalmente se llama al módulo imprimir(), donde se obtiene el resultado:
Encontró digito 3
Ejemplo 07
Pseudocódigo que permite ingresar un número entero que representa la cantidad
de horas y devuelve su equivalente en minutos y segundos.

• Procedimiento ingresar(entero &phor), permite ingresar un número que
representa la cantidad de horas al cual se calculará su equivalente a través del
parámetro por referencia &phor.
• Procedimiento equivalente(entero phor, entero &pmin, entero &pseg), obtiene
las equivalencias de la hora ingresada en minutos y segundos por medio de los
parámetros por referencia &pmin y &pseg.
• Procedimiento imprimir(entero phor, entero pmin, entero pseg), muestra el
equivalente de las horas ingresadas en minutos y en segundos.

hor parámetro actual de los módulos ingresar(), equivalente() e
imprimir()
min, seg parámetros actuales del módulo equivalente() e imprimir()
phor parámetro formal de los módulos ingresar(), equivalente() e
imprimir()
pmin, pseg parámetros formales de los módulos equivalente() e
imprimir()
Inicio
entero: hor, min, seg
ingresar (hor)
equivalente (hor, min, seg)
imprimir (hor, min, seg)
Fin
Procedimiento ingresar(entero &phor)

Escribir (“Ingresar horas:”)
Leer (phor)
Fin_procedimiento
Procedimiento equivalente(entero phor, entero &pmin, entero &pseg)

pmin phor * 60
pseg phor * 3600

Fin_procedimiento
Procedimiento imprimir(entero phor, entero pmin, entero pseg)

Escribir (phor, “horas equivale a ”, pmin, “minutos y”, pseg, “segundos”)
Fin_procedimiento

1. Se ejecuta el módulo principal (Inicio-Fin) y se llama al módulo ingresar(), este
módulo permite leer una hora, por ejemplo 8.
2. Se llama al módulo equivalente(), en donde se calcula el equivalente de la hora
ingresada en minutos y segundos.
3. Finalmente se llama al módulo imprimir() donde se muestra el resultado: 8
horas equivale a 480 minutos y 28800 segundos.
Ejemplo 08
Pseudocódigo que lea un número entero y diga si es capicúa o no. Un número es
capicúa, si al invertir el número nos da el mismo número.
Por ejemplo, los siguientes números son capicúas.

44 44
373 373
18481 18481

• Procedimiento ingresar(entero &pn), permite ingresar un número a través del
parámetro por referencia &pn.
• Función capicua(entero pn), devuelve el número pn invertido.
• Procedimiento imprimir(entero pn, entero pr), muestra el mensaje
correspondiente si pn es o no capicua.

n parámetro actual de los módulos ingresar(), capicua() e imprimir()
pn parámetro formal de los módulos ingresar(), capicua() e imprimir()
r guarda el valor de retorno del módulo capicua() y es parámetro
actual del módulo imprimir()
pr parámetro formal del módulo imprimir().
Inicio
entero: n, digito, r
ingresar (n)
r capicua (n)
imprimir (n, r)
Fin
Procedimiento ingresar(entero &pn)

Escribir (“Ingrese número”)
Leer (pn)
Fin_procedimiento
Función capicua(entero pn) : entero

entero: digito, inver 0
Mientras (pn > 0) Hacer
digito pn Mod 10
pn pn Div 10

Fin_mientras
retornar inver
Fin_función
Procedimiento imprimir(entero pn, entero pr)

Si (pr = pn) entonces
Escribir (pn, “Es capicúa”)
Sino
Escribir (pn, “No es capicúa”)
Fin_si
Fin_procedimiento

que se lee un valor para n, por ejemplo 12521.
2. Se llama al módulo capicua(), devolviéndose el valor invertido del número
ingresado, para nuestro ejemplo 12521.
3. Finalmente se llama al módulo imprimir(), donde se muestra el resultado:
12521 es capicúa.
Ejemplo 09
Pseudocódigo para hallar el mayor de tres números.

• Procedimiento ingresar(entero &pa, entero &pb, entero &pc), permite ingresar
tres valores a través de los parámetro por referencia &pa, &pb y &pc.
• Función mayor(entero pa, entero pb), la función devuelve un valor entero que
representa el mayor de dos números.
• Procedimiento imprimir (entero pm), muestra el mayor número.

a, b, c parámetros actuales de los módulo ingresar() y mayor()
m1 guarda el valor de retorno del módulo mayor() y es parámetro actual
del módulo mayor()
m2 guarda el valor de retorno del módulo mayor() y es parámetro actual
del módulo imprimir()
pa, pb parámetros formales de los módulos ingresar() y mayor()
pc parámetro formal del módulo ingresar()
pm parámetros formal del módulo imprimir()
Inicio
entero: a, b, c, m1, m2
ingresar (a, b, c)
// Se halla el mayor de los dos primeros números
m1 mayor (a, b)
// Se halla el mayor entre el resultado de los dos primeros números y el
// tercer número
m2 mayor (m1, c)
imprimir (m2)
Fin
Procedimiento ingresar(entero &pa, entero &pb, entero &pc)

Escribir (“Ingresar 3 números”)
Leer (pa, pb, pc)
Fin_procedimiento

Función mayor (entero pa, entero pb) : entero

// Definir variable
entero: m
Si (pa > pb) entonces
m pa
Sino
m pb
Fin_si
retornar m
Fin_función
Procedimiento imprimir(entero pm)

Escribir (“El mayor número es”, pm)
Fin_procedimiento

1. Se ejecuta el módulo principal y se llama al módulo ingresar() en el que se leen
por ejemplo los valores de:
a 4 , b 7, c 6
2. Luego se llama al módulo mayor() dos veces
a. La primera vez con los valores de a 4, b 7. Por ejemplo mayor (4, 7).
Se ejecutan las sentencias del módulo obteniéndose un valor de m 7.
Logrando hallar el mayor de los dos primeros números.
Se ejecuta la sentencia retornar para un valor de m = 7, devolviendo este
valor al lugar donde fue llamada, y asignando a la variable m1 un valor de 7
b. En la segunda vez con los valores de m1 7, c 6. por ejemplo mayor (7,
6). Siendo el valor de m1 el mayor valor obtenido en la primera llamada.
Se ejecutan las sentencias del módulo obteniéndose un valor de m 7.
Se ejecuta la sentencia retornar para un valor de m 7, devolviendo este
valor al lugar donde fue llamada, y asignando a la variable m2 un valor de 7
3. Finalmente se llama al módulo imprimir(), donde se muestra el mayor de los
tres números que en este caso es 7.
Ejemplo 10
Pseudocódigo para calcular la suma de los N términos de la serie:
1/2 + 2/22 + 3/23 + 4/24 + 5/25+ …

• Procedimiento ingresar(entero &pn), permite ingresar un valor a través del
• Función potencia(entero pnro, entero pexpo), devuelve un número entero que
representa la potencia de pnro elevado a pexpo.
• Procedimiento imprimir(real ps), muestra el valor del calculo de la sumatoria de
la serie.

n parámetro actual del módulo ingresar()
r guarda el valor de retorno del módulo potencia()
2, i parámetros actuales del módulo potencia()
s parámetro actual del módulo imprimir().
pn parámetro formal del módulo ingresar()
pnro, pexpo parámetros formales del módulo potencia()
ps parámetro formal del módulo imprimir().
Inicio

entero: n, i, r
real: s 0
ingresar (n)
Desde (i 1) hasta (i <= n) con incremento 1 Hacer
r potencia (2, i)
ss+i/r
Fin_desde
Imprimir (s)
Fin

Escribir (“Ingrese el numero”)
Leer (pn)
Fin_procedimiento
Función potencia (entero pnro, entero pexpo) : entero
// Definir variable
entero: result
result pnro ^ pexpo
retornar result
Fin_función
Procedimiento imprimir(real ps)

Escribir (“La suma es ”, ps)
Fin_procedimiento
Ejemplo 11
Pseudocódigo que calcula la cantidad de números múltiplos de N en un rango de 1 y
50.

• Procedimiento ingresar(entero &pn), permite ingresar un número del cual se
hallarán sus múltiplos.
• Procedimiento multiplo(entero pn), calcula la cantidad de múltiplos de pn que
existe entre 1 y 50.
• Procedimiento imprimir(entero pn, entero pcm), muestra la cantidad de
múltiplos de pn.

n parámetro actual de los módulos ingresar() y multiplo()
pn parámetro formal de los módulos ingresar() y multiplo() y es
ppn, pcm parámetros formales del módulo imprimir()
Inicio
entero: n
ingresar (n)
múltiplo (n)
Fin

Escribir (“Ingresar múltiplo:”)
Leer (pn)
Fin_procedimiento
Procedimiento multiplo(entero pn)

entero: con, cm 0

Desde (con 1) hasta (con <= 50) con incremento 1 hacer

Si (con Mod pn = 0) entonces
cm cm + 1
Fin_si
Fin_desde
imprimir (pn, cm)
Fin_procedimiento
Procedimiento imprimir(entero ppn, entero pcm)

Escribir (“La cantidad de múltiplos de “, ppn, “es:”, pcm)
fin_procedimiento
Ejemplo 12
Pseudocódigo para calcular la suma de los dígitos de un número.

• Procedimiento ingresar(entero &pnro), permite ingresar un valor a través del
parámetro por referencia &pnro.
• Función sumaDigitos(entero pnro), devuelve un numero entero que representa
la suma de los dígitos de pnro.
• Procedimiento imprimir (entero pr), muestra la sumas de dígitos del número.

nro parámetro actual de los módulos ingresar() y sumaDigitos()
r guarda el valor de retorno del módulo sumaDigitos() y es parámetro
actual del modulo imprimir()
pnro parámetro formal de los módulos ingresar() y sumaDigitos()
Inicio
entero: nro, r
ingresar (nro)
r sumaDigitos (nro)
imprimir (r)
Fin
Procedimiento ingresar(entero &pnro)

Leer (pnro)
Fin_procedimiento
Función sumaDigitos(entero pnro) : entero

entero: digito, suma 0
Mientras (pnro > 0) Hacer
digito pnro Mod 10
suma suma + digito
pnro pnro Div 10
Fin_mientras
retornar suma
Fin_función
Procedimiento imprimir(entero pr)

Escribir (“La suma de dígitos es ”, pr)
Fin_procedimiento


que se lee un valor para nro, por ejemplo 5247.
2. Se llama al módulo sumaDigitos(), se pasa el valor de nro que es asignado al
parámetro pnro entonces pnro 5247
a. Se ejecutan las sentencias dentro del módulo para este valor
obteniéndose el valor de suma 18.
b. Se ejecuta la sentencia retornar para un valor de suma 18,
devolviendo este valor al lugar donde fue llamado y asignando a la
variable r un valor de 18
3. Finalmente se llama al módulo imprimir() donde se muestra el resultado: La
suma de dígitos es 18
Ejemplo 13
Pseudocódigo que realice la “prueba de la suma” que consiste en comprobar si una
suma esta correcta o no.
Por ejemplo:
Para probar la siguiente operación: 39 + 47 = 86
Sumamos los dígitos de cada uno de los sumandos por separado hasta que quede
una sola cifra, de esta forma:
3 + 9 = 12, 1 + 2 = 3
4 + 7 = 11, 1 + 1 = 2
Luego sumamos 3 + 2 = 5, si el resultado tiene dos cifras, se tendrá que volver a
sumar hasta obtener una sola cifra.
De la misma forma se suma las cifras del resultado de la suma: 8 + 6 = 14, 1 + 4
= 5.
Si la suma de las cifras de los sumandos y la suma de las cifras del resultado son
iguales, decimos que la suma es correcta. Así:
Operación 39 + 47 = 86
12 11 14
Suma de dígitos 3 2 5
5 = 5

• Procedimiento ingresar(entero &pa, entero &pb, entero &ps), permite ingresar
tres valores a través del parámetro por referencia &pa, &pb y &pc.
• Función pruebaSuma(entero pnro), devuelve un número entero que representa
la suma de pnro.
• Procedimiento imprimir (entero pr, entero ps), muestra el mensaje si la suma
esta realizada correctamente o no.

a, b parámetros actuales de los módulo ingresar() y pruebaSuma()
s parámetro actual de los módulos ingresar() y pruebaSuma()
r1, r2 guarda el valor de retorno del módulo pruebaSuma() y además son
parámetros actuales del mismo módulo
r, r3 guarda el valor de retorno del módulo pruebaSuma() y son
parámetros actuales del módulo imprimir()
pa, pb parámetros formales del módulo ingresar()
ps parámetro formal de los módulos ingresar() e imprimir()
pnro parámetro formal del módulo pruebaSuma()
Inicio

entero: a, b, r, r1, r2, r3, s 0

ingresar(a, b, s)
r1 pruebaSuma (a)
r2 pruebaSuma (b)
Si ((r1+r2) > 9) entonces
r pruebaSuma (r1 + r2)
Sino
r r1+r2
Fin_si
r3 pruebaSuma (s)
imprimir (r, r3)
Fin
Procedimiento ingresar(entero &pa, entero &pb, entero &ps)

Escribir (“Ingrese el primer número ")
Leer (pa)
Escribir (“Ingrese el segundo número ")
Leer (pb)
Escribir (“Ingrese el resultado de la suma ")
Leer (ps)
Fin_procedimiento
Función pruebaSuma(entero pnro) : entero

entero: d, suma 0
if (pnro>0) entonces
suma 0
d pnro Mod 10
suma suma + d
pnro pnro Div 10
Fin_mientras
pnro suma
Fin_mientras
Sino
suma pnro
Fin_si
retornar suma
Fin_función
Procedimiento imprimir(entero pr, entero ps)

Si (pr = ps) entonces
Escribir (“La suma es correcta”)
Sino
Escribir (“La suma es incorrecta”)
Fin_si
Fin_procedimiento
Ejemplo 14
Pseudocódigo que resuelva la fórmula del análisis combinatorio. Esta fórmula se
muestra a continuación, siendo los valores de m y n números enteros, donde m>n.
M M!
  =
 N  N! (M - N)!
Ejemplo:

6 6! 720
  = = = 20
 3  3! (6 - 3)! 6 * 6

• Procedimiento ingresar(entero &pa, entero &pb), permite ingresar dos valores
a través del parámetros por referencia &pa, &pb.
• Función factorial(entero pnro), la función devuelve un valor entero que
representa el factorial de pnro.
• Procedimiento imprimir(entero pc), muestra el resultado de la fórmula del
análisis combinatorio.

a, b parámetros actuales de los módulos ingresar() y factorial()
x, y, z guarda el valor de retorno del módulo factorial()
c parámetro actual del módulo imprimir()
pa, pb parámetros formales del módulo ingresar()
pnro parámetro formal del módulo factorial()
pc parámetro formal del módulo imprimir()
Inicio
entero: a, b, x, y, z, c
ingresar (a, b)
x factorial (a)
y factorial (b)
z factorial (a - b)
c x / (y*z)
imprimir(c)
Fin

Leer (pa, pb)
Fin_procedimiento
Función factorial (entero pnro) : entero

entero: i, fact 1
Desde (i 1) hasta (i <= pnro) con incremento 1 hacer
fact fact * i
Fin_desde
retornar fact
Fin_función
Procedimiento imprimir(entero pc)

Escribir (“La fórmula resuelta es ” , pc)
Fin_procedimiento

1. Se ejecuta el módulo principal y se llama al módulo ingresar(), donde se leen
por ejemplo los valores de:
a6,b3
2. Se llama al módulo factorial() tres veces
a. La primera vez el valor de a 6. Por ejemplo factorial (6).
Se ejecutan las sentencias del módulo obteniéndose un valor de fact
720. Logrando hallar el factorial de 6

Se ejecuta la sentencia retornar para un valor de fact 720,

variable x un valor de 720.
b. En la segunda vez el valor de a 3. por ejemplo factorial (3).
Se ejecutan las sentencias del módulo obteniéndose un valor de fact
6. Logrando hallar el factorial de 3.
Se ejecuta la sentencia retornar para un valor de fact 6, devolviendo
este valor al lugar donde fue llamada, y asignando a la variable y un
valor de 6.
c. En la tercera vez el valor de (a – b = 3). por ejemplo factorial (3).
Se ejecutan las sentencias del método obteniéndose un valor de fact
6. Logrando hallar el factorial de 3.
Se ejecuta la sentencia retornar para un valor de fact 6, devolviendo
este valor al lugar donde fue llamada, y asignando a la variable z un
valor de 6.
3. Se calcula la formula c x / (y * z)
4. Finalmente se llama al módulo imprimir() donde se muestra el resultado del
análisis combinatorio respectivo.
Ejemplo 15
Pseudocódigo para calcular los N términos de la serie
1 +1/1! + 2/2! + 3/3! + 4/4! + …

• Función factorial(entero pa), devuelve un valor entero que representa el
factorial de pa.
• Procedimiento imprimir (real ps), muestra el resultado de la suma de la serie.

i parámetro actual del módulo factorial()
s parámetro actual del módulo imprimir()
r guarda el valor de retorno del módulo factorial()
pn parámetro formal del módulo ingresar()
pa parámetro formal del módulo factorial()
ps parámetro formal del módulo imprimir()
Inicio
entero: n, i, r
real: s 1
ingresar (n)
Desde (i 0) hasta (i< n) con incremento 1 Hacer
r factorial (i)
ss+i/r
Fin_desde
imprimir (s)
Fin

Escribir (“Ingrese primer número ")
Leer (pn)
Fin_procedimiento

Función factorial(entero pa) : entero

entero: i, fact 1
Desde (i 1) hasta (i<=pa) con incremento 1 Hacer
fact fact * i
Fin-desde
retornar fact
Fin_función
Procedimiento imprimir(real ps)

Fin_procedimiento
Ejemplo 16
Pseudocódigo para calcular los N términos de la serie de Catalán. La serie es:
1, 2, 5, 14, 42, 132 ...
Cada término de la serie de catalán se obtiene con la formula:
2n!
cn =
(n + 1)! n!
Donde n >= 1
Ejemplo:
6! 6 * 5 * 4! 30
c3 = = = =5
(4)! 3! 4! * 3! 6

• Función factorial(entero pn), la función devuelve un valor real que representa el
factorial de un número entero.

i parámetro actual del módulo factorial()
r1, r2, r3 guarda el valor de retorno del módulo factorial()
pn parámetro formal de los módulos ingresar() y factorial()
Inicio
entero: n, i
real: r1, r2, r3, c
ingresar (n)
Desde (i 1) hasta (i <= n) con incremento 1 Hacer
r1 factorial (2 * i)
r2 factorial (i + 1)
r3 factorial (i)
c r1 / (r2 * r3)
Escribir (c)
Fin_desde
Fin

Escribir (“Ingrese cantidad de términos ")
Leer (pn)

Fin_procedimiento
Función factorial(entero pn) : real

entero: i
real : fact 1
Desde (i 1) hasta (i <= pn) con incremento 1 Hacer
fact fact * i
Fin_desde
retornar fact
Fin_función

que se lee un valor para n, por ejemplo 3.
2. Repetidas veces se llama al módulo factorial(), devolviéndose el factorial de un
valor enviado como parámetro.
3. Se calcula cada término de la serie mediante la fórmula c r1 / (r2 * r3)
4. Repetidas veces se escribe cada términos de la serie.
Ejemplo 17
Pseudocódigo para leer dos números y calcular si son parientes. Se dice a es
“pariente” de b si la suma de los dígitos de a2 es igual a b y recíprocamente la
suma de los dígitos de b2 es igual a a.
Por ejemplo: 13 y 16 son parientes:
132 = 169 1 + 6 + 9 = 16
162 = 256 2 + 5 + 6 = 13

• Procedimiento ingresar(entero &pa, entero &pb), permite ingresar dos valores a
través de los parámetros por referencia &pa y &pb.
• Función parientes(entero pa), devuelve un número entero que representa la
suma de los dígitos de pa.
• Procedimiento imprimir (entero pa, entero pb, entero pr, entero ps), muestra un
mensaje en el que se indica si pa es o no pariente de pb.

a, b parámetros actuales de los módulos ingresar(), parientes() e
imprimir()
r, s guarda el valor de retorno del módulo parientes() y son
parámetros actuales del módulo imprimir()
pa parámetro formal del módulo parientes() e imprimir()
pb, pr, ps parámetros formales del módulo imprimir()
Inicio
entero: a, b, r, s
ingresar (a, b)
r parientes (a * a)
s parientes (b * b)
imprimir (a, b, r, s)
Fin

Escribir (“Ingrese primer número”)
Leer (pa)
Escribir (“Ingrese segundo número”)

Leer (pb)
Fin_procedimiento
Función parientes(entero pa) : entero

entero: digito , s 0
Mientras (pa > 0) Hacer
digito pa Mod 10
s s + digito
pa pa Div 10
Fin_mientras
retornar s
Fin_función
Procedimiento imprimir(entero pa, entero pb, entero pr, entero ps)

Si ((pr = pb) and (ps = pa)) entonces
Escribir (pa, “Es pariente de”, pb)
Sino
Escribir (pa, “No es pariente de”, pb)
Fin_si
Fin_procedimiento

que se lee dos valores para a y b. Por ejemplo a 13, b 16
2. Se llama al módulo parientes() dos veces:
a. La primera vez con el valor de a 13. Por ejemplo parientes (13*13), se
ejecutan las sentencias del módulo obteniéndose la suma de los dígitos del
cuadrado de 13 que es 169, entonces: s 16 (1+6+9).
Se ejecuta la sentencia retornar para un valor de s 16, devolviendo este
valor al lugar donde fue la llamada y asignando a la variable r un valor de 16
b. En la segunda vez con el valor de b 16. Por ejemplo parientes (16*16), se
ejecutan las sentencias dentro del módulo obteniéndose la suma de los
dígitos del cuadrado de 16 que es 256,entonces: s 13 (2+5+6).
Se ejecuta la sentencia retornar para un valor de s 13, devolviéndose este
valor al lugar donde fue la llamada y asignando a la variable r1 un valor de
13.
3. Finalmente obtiene se llama al módulo imprimir() en el que se muestra el
resultado: 13 es pariente con 16.
Ejemplo 18
Pseudocódigo para calcular la división y el resto de dos números enteros, mediante
el método de restas sucesivas. El método consiste en restar el dividendo con el
divisor hasta que el dividendo sea menor que el divisor, este número es el resto de
la división y la cantidad de restas realizadas es el cociente. Por ejemplo:
Dividendo Divisor Resto

7 - 2 = 5
5 - 2 = 3
3 - 2 = 1
1 - 2
Cociente = 3
Residuo = 1


• Función restoCociente(entero pa, entero pb, entero &r, entero &q), el parámetro
pa representa el dividendo, el parámetro pb representa el divisor el parámetro r
representa el residuo que se va a calcular y el parámetro q representa el
cociente que se va a calcular. La función devuelve el cociente y el resto de pa
entre pb.
• Procedimiento imprimir(cadena mensaje, entero pr), muestra el resultado del
residuo y el cociente de la división.

a, b parámetros actuales de los módulos ingresar() y restoCociente()
r, q parámetros actuales de los módulos restoCociente() e imprimir()
pa, pb parámetros formales de los módulos ingresar y restoCociente()
r, q parámetros formales de los módulos restoCociente() e imprimir()
mensaje, pr parametro formal del módulo imprimir()
Inicio
entero: a, b, r 0, q 0
ingresar (a, b)
restoCociente (a, b, r, q)
imprimir (“El cociente es ”, q)
imprimir (“El residuo es ”, r)
Fin

Escribir (“Ingrese dividendo:”)
Leer (pa)
Escribir (“Ingrese divisor:”)
Leer (pb)
Fin_procedimiento
Procedimiento restoCociente(entero pa, entero pb, entero &r, entero &q)

entero: residuo, cociente 0
Mientras (pa >= pb) Hacer
residuo pa – pb
pa residuo
cociente cociente + 1
Fin_mientras
r pa
q cociente
Fin_procedimiento
Procedimiento imprimir(cadena mensaje, entero pr)

Escribir (mensaje, pr)
Fin_procedimiento

que se lee dos valores para a y b. Por ejemplo 7 y 2.
2. Se llama al módulo restoCociente(), devolviéndose el residuo y el cociente al
lugar donde fue la llamada.
3. Finalmente se llama al módulo imprimir() y se muestra el resultado: El residuo
es: 1 y el cociente es: 3.

Ejemplo 19
Pseudocódigo para calcular el máximo común divisor y el mínimo común múltiplo
de dos números

• Función mcd(entero pa, entero pb), devuelve un numero entero que representa
el máximo común divisor de los números pa, pb
• Función mcm(entero pa, entero pb), devuelve un numero entero que representa
el mínimo común múltiplo de los números pa, pb
• Procedimiento imprimir(cadena mensaje, entero pr), muestra el maximo común
divisor y el mínimo común multiplo de los dos números ingresados.

a, b parámetros actuales de los módulo ingresar(), mcd() y mcm()
r, r1 guarda el valor de retorno de los módulos mcd() y mcm() y
son parámetrso actuales del módulo imprimir()
pa, pb parámetros formales de los módulo ingresar(), mcd() y mcm()
mensaje, pr parámetros formales del módulo imprimir()
Inicio
entero: a, b, r ,r1
ingresar (a, b)
r mcd (a, b)
r1 mcm (a, b)
imprimir (“MCD”, r)
imprimir (“MCM”, r1)
Fin

Leer (pa)
Leer (pb)
Fin_procedimiento
Función mcd (entero pa, entero pb): entero

entero residuo
Mientras (pb > 0) Hacer
residuo pa Mod pb
pa pb
pb residuo
Fin_mientras
retornar pa
Fin_función
Funcion mcm (entero pa, entero pb)

entero: i, x 1
i2
Mientras (i <= pa or i <= pb) Hacer
Si ((pa Mod i = 0) or (pb Mod i = 0)) entonces
xx*i
Si (pa Mod i = 0) entonces

pa pa / i
Fin_si
Si (pb Mod i = 0) entonces
pb pb / i
Fin_si
Sino
ii+1
Fin_si
Fin_mientras
retornar x
Fin_funcion
Procedimiento imprimir(cadena mensaje, entero pr)

Escribir (“El ”, mensaje, “es: ”, pr)
Fin_procedimiento
Ejemplo 20
Pseudocódigo para calcular la suma de los N términos de la serie de leibnitz:
π/4 = 1/1 – 1/3 + 1/5 – 1/7 + …
Por ejemplo:
Si n = 3 la suma es igual a 0.8667
Si n = 5 la suma es igual a 0.8349

• Procedimiento ingresar(entero &pn), permite ingresar dos valores a través de
los parámetros por referencia &pn.
• Función sumaFraccionAlterna(entero pn), devuelve la suma de los pn términos
de la serie.
• Procedimiento imprimir(real pr), muestra el resultado de la suma de la serie.

n parámetro actual de los módulos ingresar() y sumaFraccionAlterna()
r guarda el valor del módulo fraccionSuma() y es parámetro actual del
módulo imprimir()
pn parámetro formal de los módulos ingresar() y sumaFraccionAlterna ()
Inicio
// Definir variable
entero: n
real: r
ingresar (n)
r sumaFraccionAlterna (n)
imprimir (r)
Fin

Escribir ("Ingresar el numero de terminos ")
Leer (pn)
Fin_procedimiento
Función sumaFraccionAlterna(entero pn) : real

entero: i 1, d 1, signo 1
real: s 0
Desde (i 1) hasta (i <= pn) con incremento 1 Hacer

s s + signo / d
d d+ 2
signo -signo
Fin_desde
retornar s
Fin_función
Procedimiento imprimir(real pr)

Escribir (“La suma de los números es ”,pr)
Fin_procedimiento
Ejemplo 21
Pseudocódigo para construir un nuevo número a partir de un número ingresado,
donde el último dígito del número será el primer dígito del nuevo número, el
penúltimo dígito del número será el segundo dígito del nuevo número, y así
sucesivamente. Al finalizar el pseudocódigo el número ingresado será cero.
Por ejemplo si se ingresa un número tal como 21457, se tiene:
Número Nuevo número

21457 0
2145 7
214 75
21 754
2 7541
0 75412

• Procedimiento ingresar(entero &pa), permite ingresar un valor a través del
parámetro por referencia &pa.
• Procedimiento invertir(entero pa, entero &pb), calcula el número invertido a
partir del número pa y lo guarda en el parámetro por referencia &pb.
• Procedimiento imprimir(entero pb), muestra el número invertido.

a parámetro actual de los módulos ingresar() e invertir()
b parámetro actual de los módulos invertir() e imprimir()
pa parámetro formal de los módulos ingresar() e invertir()
pb parámetro formal de los módulos invertir() e imprimir()
Inicio
entero: a, b 0
ingresar (a)
invertir (a, b)
imprimir (b)
Fin
Procedimiento ingresar(entero &pa)

Escribir (“Ingrese el número”)
Leer (pa)
Fin_procedimiento
Procedimiento invertir(entero pa, entero &pb)


entero: digito, inver 0
Mientras (pa > 0) hacer
digito pa Mod 10
pa pa Div 10
Fin_mientras
pb inver
Fin_procedimiento
Procedimiento imprimir(entero pb)

Escribir (“El número invertido ”, pb)
Fin_procedimiento
Ejemplo 22
Pseudocódigo para averiguar si una fecha ingresada es correcta y de ser así calcular
el día anterior.
Por ejemplo:
Si se ingresa 23/15/2007 se mostrará “La fecha no es correcta”
Si se ingresa 19/11/2007 se mostrará “El día anterior es 18/11/2007”

• Procedimiento ingresar(entero &pd, entero &pm, entero &pa), permite ingresar
una fecha a través de los parámetros por referencia &pd, &pm, &pa.
• Función cantidadDias(entero pm, entero pa), devuelve la cantidad de días que
trae el mes pm.
• Procedimiento diaAnterior(entero pd, entero pm, entero pa), calcula el día
anterior.

d parámetro actual de los módulos ingresar() y diaAnterior()
m, a parámetros actuales de los módulos ingresar(), cantidadDias() y
diaAnterior()
pd parámetro formal de los módulos ingresar() y diaAnterior()
pm, pa parámetros formales de los módulos ingresar(), cantidadDias() y
diaAnterior()
Inicio
entero: d, m, a, maxDia
//Lectura de datos
ingresar (d, m, a)
maxDia cantidadDias (m, a)
Si (d>0 and d<=maxDia and m>0 and m<13 and a>0) entonces
diaAnterior(d, m, a)
Sino
Escribir (“La fecha no es correcta”)
Fin_si
Fin
Procedimiento ingresar(entero &pd, entero &pm, entero &pa)

Escribir (“Ingrese fecha”)
Leer (pd, pm, pa)
Fin_procedimiento
Función cantidadDias(entero pm, entero pa) : entero


entero: md
Según sea (pm) hacer
1, 3, 5, 7, 8, 10, 12 : md 31
4, 6, 9, 11 : md 30
2 : Si (((pa Mod 4 = 0) and (pa Mod 100 <> 0)) or
(pa Mod 400 = 0)) entonces
md 29
Sino
md 28
Fin_si
Fin_según
retornar md
Fin_Función
Procedimiento diaAnterior(entero pd, entero pm, entero pa)

pd pd - 1
Si (pd = 0) entonces
pm pm – 1
pd cantidadDias (pm, pa)
Si (pm = 0)
pa pa – 1
pm 12
pd 31
Fin_si
Fin_si
Escribir( pd, pm, pa)
Fin_procedimiento
Ejemplo 23
Dada una fecha obtenga la cantidad de días transcurridos en el año
correspondiente. Por ejemplo si se ingresa 15/06/2007, se ha transcurrido 166 días
del año 2007.

• Procedimiento ingresar(entero &pd, entero &pm, entero &pa), permite ingresar
una fecha a través de los parámetros por referencia &pd, &pm, &pa.
• Función cantidadDias(entero pm, entero pa), devuelve la cantidad de días que
trae el mes pm.
• Procedimiento diasTranscurridos(entero dias, entero &dt), calcula la cantidad de
días transcurridos.

d parámetro actual de los módulos ingresar() y
diasTranscurridos()
m parámetro actual de los módulos ingresar() y cantidadDias()
a parámetro actual de los módulos ingresar() y cantidadDias()
mes parámetro actual del módulo cantidadDias()
maxDia guarda el valor de retorno del módulo cantidadDias() y es
parámetro actual del módulo diasTranscurridos()
diaTrans parámetro actual del módulo diasTranscurridos()
pd parámetro formal del módulo ingresar()
pm, pa parámetros formales de los módulos ingresar() y cantidadDias()
dias, dt parámetros formales del módulo diasTranscurridos()
Inicio

entero: d, m, a, mes, maxDia, diaTrans 0

//Lectura de datos
ingresar (d, m, a)
maxDia cantidadDias (m, a)
Si (d>0 and d<=maxDia and m>0 and m<13 and a>0) entonces
Desde (mes 1) hasta (mes < m) con incremento 1 hacer
maxDia cantidadDias (mes, a)
diasTranscurridos (maxDia, diaTrans)
Fin_desde
diasTranscurridos(d, diaTrans)
Escribir (“Han transcurrido ”, diaTrans, “días”)
Sino
Escribir (“La fecha es incorrecta”)
Fin_si
Fin
Procedimiento ingresar(entero &pd, entero &pm, entero &pa)

Escribir (“Ingrese fecha”)
Leer (pd, pm, pa)
Fin_procedimiento
Función cantidadDias(entero pm, entero pa) : entero

entero: md
Según sea (pm) hacer
1, 3, 5, 7, 8, 10, 12 : md 31
4, 6, 9, 11 : md 30
2 : Si (((pa Mod 4 = 0) and (pa Mod 100 <> 0)) or
(pa Mod 400 = 0)) entonces
md 29
Sino
md 28
Fin_si
Fin_según
retornar md
Fin_Función
Procedimiento diasTranscurridos(entero dias, entero &dt) : entero

dt dt + dias
Fin_Función
Ejemplo 24
Pseudocódigo que realiza la conversión de un número que esta en una base x a
base decimal. Por ejemplo el número 325(7 que esta en base 7 (x = 7) se convierte
en base decimal en 166.
En la siguiente tabla muestra los datos de prueba y los resultados obtenidos al

ejecutar el Pseudocódigo.
Número a
Resultado
convertir y su Proceso de Conversión
de la
correspondiente (descomposición polinómica)
conversión
base
1304(5 1*53 + 3*52 + 0*51 + 4*50 = 125 + 75 + 0 204
+4
325(7 3*72 + 2*71 + 5*70 = 147 + 14 + 5 166


• Procedimiento ingresar(entero &pnro, entero &pbase), permite ingresar un
número y su base a través de los parámetros por referencia &pnro, &pbase.
• Función convertirBaseX_Base10(entero pnro, entero pbase), devuelve un valor
entero que representa el número convertido a base decimal.
• Procedimiento imprimir(entero pr), muestra el resultado del número convertido
a base decimal.

nro, base parámetros actuales de los módulos ingresar() y
convertirBaseX_Base10()
r guarda el valor de retorno del módulo
convertirBaseX_Base10() y es parámetro actual del modulo
imprimir()
pnro, pbase parámetros formales de los módulos ingresar() y
Inicio
entero: nro, base, r
ingresar (nro , base)
r convertirBaseX_Base10 (nro, base)
imprimir (r)
Fin
Procedimiento ingresar(entero &pnro, entero &pbase)

// Leer variables
Leer (pnro, pbase)
Fin_procedimiento
Función convertirBaseX_Base10 (entero pnro, entero pbase) : entero

entero: digito, suma 0, expo 0
Mientras (pnro >0) Hacer
digito pnro Mod 10
suma suma+ (digito * (pbase ^ expo))
expo expo + 1
pnro pnro Div 10
Fin_mientras
retornar suma
Fin_función

Escribir (“El numero es ”, pr)
Fin_procedimiento

1. Se ejecuta el módulo principal y se llama al módulo ingresar(), donde se lee los
valores de nro y base. Por ejemplo nro 325 que es numero a convertir y base
7 la nueva base de este numero.
2. Se llama al módulo convertirBaseX_Base10(), se pasa los valores de nro y base,
que son asignados a los parámetros pnro, pbase respectivamente, así entonces
pnro 325 y pbase 7.
a. Se ejecutan las sentencias dentro del módulo, para estos valores
obteniéndose un valor de suma 166.

b. Se ejecuta la sentencia retornar para un valor suma 166, devolviendo

este valor al lugar donde fue llamada, y asignando a la variable s un
valor de 166.
3. Finalmente se llama al módulo imprimir(), donde se muestra el número en base
decimal, que en este caso es 166.
Ejemplo 25
Realizar un pseudocódigo que convierta un número que esta en una base x a otra
base y.
m n
10
Descomposición Divisiones
polinómica sucesivas
Por ejemplo el número 465(9 que esta en base 9 (x = 9) se convertirá a base 6
(y = 6) en 1435(6 para lo cual se realiza los siguientes pasos:
1. Conversión de Base x = 9 a base decimal. Utilizando la descomposición

polinómica
465(9 = 4*92 + 6*91 + 5*90 = 4*81 + 54 + 5 = 383(10
2. Conversión de base decimal a base y = 6. Utilizando divisiones sucesivas

383(10 B(6
383
6
63
5 6
10
3 6
1
4
3. Finalmente obtenemos el numero convertido en su base apropiada 1435(6

• Procedimiento ingresar(entero &pnro, entero &pbase, entero &pbase1), permite
ingresar tres valores a través de los parámetros por referencia &pnro, &pbase y
&pbase1.
• Función convertirBaseX_Base10(entero pnro, entero pbase), convierte un
número de base x a base 10. El parámetro pnro representa el número a
convertir a base decimal y pbase representa la base del número a convertir.
Devuelve un valor entero que representa el número convertido a base decimal.
• Función convertirBase10_BaseY(entero pnro, entero pbase), convierte un
número de base 10 a base y. El parámetro pnro representa el número en base
decimal y pbase representa la base a la cual se convertirá este número.
Devuelve un número entero convertido a otra base y.
• Procedimiento imprimir(entero pr), muestra el resultado del numero convertido
a otra base.

nro, base parámetros actuales de los módulos ingresar() y

convdeci guarda el valor de retorno del módulo convertirBaseX_Base10 y

es parámetro actual del módulo convertirBase10_BaseY()
base1 parámetro actual de los módulos ingresar() y
convertirBase10_BaseY()
r guarda el valor de retorno del módulo convertirBase10_BaseY()
pnro, pbase parámetros formales de los módulos ingresar(),
convertirBaseX_Base10() y convertirBase10_BaseY()
Inicio
entero: nro, base, base1, r, convdeci
ingresar (nro, base, base1)
convdeci convertirBaseX_Base10 (nro, base)
r convertirBase10_BaseY (convdeci, base1)
imprimir (r)
Fin
Procedimiento ingresar(entero &pnro, entero &pbase, entero &pbase1)

// Leer variables
Leer (pnro, pbase)
Escribir (“Ingresar la nueva base que tendrá el número ”)
Leer (pbase1)
Fin_procedimiento
Función convertirBaseX_Base10(entero pnro, entero pbase) : entero

entero: digito 0, suma 0, expo 0
digito p_nro Mod 10
suma suma + digito * (pbase ^ expo)
expo expo + 1
pnro pnro Div 10
Fin_mientras
retornar suma
Fin_función
Función convertirBase10_BaseY(entero pnro, entero pbase) : entero

entero : residuo, coeficiente 1, nvoNro 0
Mientras (pnro > 0) hacer
residuo pnro Mod pbase
nvoNro nvoNro + coeficiente * residuo
coeficiente 10 * coeficiente
pnro pnro Div pbase
Fin_mientras
retornar nvoNro
Fin_función

Escribir (“El nuevo número es ”,pr)
Fin_procedimiento

1. Se ejecuta el módulo principal y se llama al módulo ingresar(), donde se leen

los valores nro, base, base1. Por ejemplo nro 465 , base 9, base1 6.
2. Se llama al módulo convertirBaseX_Base10( ) y los valores de nro y base son
asignados a los parámetros pnro y pbase respectivamente, así entonces pnro
465, pbase 9.
estos valores obteniéndose un valor de suma 383.
b. Se ejecuta la sentencia retornar para un valor de suma 383,
variable converdeci un valor de 383.
3. Se llama al módulo convertirBase10_BaseY() y los valores de converdeci y
base1 son asignados a los parámetros pnro y pbase respectivamente, así
entonces pnro 383, pbase 6.
estos valores obteniéndose un valor de binario 1435
b. Se ejecuta la instrucción retornar para un valor de binario 1435,
variable r un valor de 1435.
4. Finalmente se llama al módulo imprimir(), donde se muestra el valor de 1435,
que es el número en base 6.
Ejemplo 26
Construir un pseudocódigo que actúe como un cajero, mediante el cual se puede
realizar sucesivos retiros de montos múltiplos de S/.20.00, luego muestre la
cantidad de billetes correspondientes al monto solicitado (billetes de 20, 100); si no
se ingresa el monto correcto ya sea un monto que no es múltiplo de 20 o un monto
mayor al que se dispone, que muestre un mensaje correspondiente y continúe
solicitando el monto a retirar, el pseudocódigo termina cuando el cliente ya no
desea realizar retiros o cuando se dispone de un saldo menor a S/.20.00.

• Procedimiento ingresar(real &pdep), permite ingresar el monto del depósito a
través del parámetro de referencia &pdep.
• Procedimiento nvoDeposito (real &pdep, caracter &pr), permite realizar
sucesivos retiros, calcular la cantidad de billetes que se recibe y su nuevo saldo.

dep parámetro actual de los módulos ingresar() y nvoDeposito()
resp parámetro actual del módulo nvoDeposito()
pdep parámetro formal de los módulos ingresar() y nvoDeposito()
pr parámetro formal del módulo nvoDeposito()
Inicio
real: dep
caracter: resp
ingresar (dep)
Repetir
nvoDeposito (dep, resp)
Hasta_que (dep < 20 or resp = ‘N’)
Fin
Procedimiento ingresar(real &pdep)

Escribir (“Ingresar deposito”)
Leer (pdep)
Fin_procedimiento
Procedimiento nvoDeposito (real &pdep, caracter &pr)


entero: retiro
Escribir (“Ingresar retiro”)
Leer (retiro)
Si (retiro <= pdep) entonces
Si (retiro Mod 20 = 0)
pdep pdep – retiro
b100 retiro Div 100
retiro retiro Mod 100
b20 retiro Div 20
Escribir (“Cantidad de billetes de 100 ”, b100)
Escribir (“Cantidad de billetes de 20 ”, b20)
Escribir (“Su nuevo saldo es ”, pdep)
Sino
Escribir (“El monto debe ser múltiplo de 20”)
Fin_si
Sino
Escribir (“El monto ingresado supera al saldo”)
Fin_si
Si (pdep >= 20) entonces
Escribir (“¿Desea seguir retirando (S/N)?”)
Leer (pr)
Fin_si
Fin_procedimiento
Ejemplo 27
Los surtidores de una gasolinera registran las ventas por galones, pero el precio de
la gasolina está fijado en litros. El programa debe calcular lo que los clientes deben
pagar y el total recaudado por la gasolinera, tomando en cuenta lo siguiente:
• Cada galón tiene 3,785 litros
• El precio del litro es para el Tipo A S/.5.80, para el Tipo B S/.4.90 y para el Tipo
C S/.3.10
• El programa finaliza cuando se introduce un tipo distinto a los existentes.

• Procedimiento ingresar(caracter &pt, real &cg), permite ingresar el tipo de
gasolina y la cantidad de galones que solicita un cliente a través de los
parámetros de referencia &pt, &cg.
• Función convertir(real cg), devuelve el equivalente de los galones en litros.
• Procedimiento calculos (caracter pt, entero cl, real &pg, real &tot), calcula el
monto que paga cada cliente, asi como el total que recauda la gasolinera.

tipo parámetro actual de los módulos ingresar() y calculos()
cantGal parámetro actual de los módulos ingresar() y convertir()
pago, total parámetros actuales del módulo calculos()
cantLitros guarda el valor de retorno del módulo convertir() y es parámetro
actual del módulo calculos()
pt parámetro formal de los módulos ingresar() y calculos()
cg parámetro formal de los módulos ingresar() y convertir()
cl, pg, tot parámetros formales del módulo calculos()
Inicio
real: cantGal, cantLitros, pago, total 0
caracter: tipo
Repetir

ingresar (tipo, cantGal)

cantLitros convertir (cantGal)
calculos (tipo, cantLitros, pago, total)
Escribir (“El cliente paga ”, pago)
Hasta_que ((tipo <> ‘A’) and (tipo <> ‘B’) and (tipo <> ‘C’))
Escribir (“La gasolinera recauda ”, total)
Fin
Procedimiento ingresar(caracter &pt, real &cg)

Escribir (“Ingrese tipo de gasolina”)
Leer (pt)
Escribir(“Ingrese cantidad de galones”)
Leer (cg)
Fin_procedimiento
Función convertir (real cg) : real

real: clit
clit cg * 3.785
returnar clit
Fin_función
Procedimiento calculos (caracter pt, entero cl, real &pg, real &tot)
En caso sea (pt) hacer
‘A’: pg cl * 5.80
‘B’: pg cl * 4.90
‘C’: pg cl * 3.10
Fin_caso
tot tot + pg
Fin_procedimiento
Ejemplo 28
Pseudocódigo para realizar las cuatro operaciones, haciendo uso de menús.

• Procedimiento ingreso(entero &a, entero &b), permite ingresar dos números
enteros.
• Procedimiento menu(), muestra las opciones del menú.
• Función calculo (entero pa, entero pb, caracter oper), devuelve el resultado de
la operación indicada en el parámetro oper.
• Procedimiento imprimir(cadena operación, entero res), imprime el resultado de
la operación calculada.

a, b parámetros actuales de los módulos ingreso() y calculo()
r guarda el valor de retorno del módulo calculo() y es parámetro
actual del módulo imprimir().
pa, pb parámetros formales de los módulos ingreso() y calculo()
oper parámetro formal del módulo calculo()
operacion, res parámetros formales del módulo imprimir()
Inicio
entero: a, b, r, opcion
Hacer
menu ()
Escribir (“Ingrese opción”)
Escribir (opcion)

Si (opcion >= 1 and opcion <=4) entonces

ingreso (a, b)
Sino
Si (opcion = 5)
Escribir (“Salio del sistema”)
Sino
Escribir (“No existe opción”)
Fin_si
Fin_si
En caso sea (opcion) Hacer
1: r calculo (a, b, ‘+’)
imprimir (“suma”, r);
2: r calculo (a, b, ‘-’)
imprimir (“resta”, r);
3: r calculo (a, b, ‘*’)
imprimir (“multiplicación”, r);
4: r calculo (a, b, ‘/’)
imprimir (“división”, r);
Fin_caso sea
Mientras (opcion <> 5)
Fin
Procedimiento menu()
Escribir (“1 sumar”)
Escribir ("2 restar”)
Escribir (“3 multiplicar”)
Escribir (“4 dividir”)
Escribir (“5 salir”)
Fin_procedimiento
Procedimiento ingreso(entero &a, entero &b)

Escribir ("Ingrese primer valor")
Leer (a)
Escribir(“Ingrese segundo valor ")
Leer (b)
Fin_procedimiento
Función calculo (entero pa, entero pb, caracter oper) : entero

entero: res
Según sea (oper)
‘+’ : res pa + pb
‘-’ : res pa - pb
‘*’ : res pa * pb
‘/’ : res pa / pb
Fin_según
retornar res
Fin_función
Procedimiento imprimir (cadena operación, entero res)

Escribir (“La ”, operación, “ es ”, res)
Fin_procedimiento
13.Ejercicios propuestos
1. Elaborar un pseudocódigo para calcular el área y el perímetro de un rectángulo.

Area = base * altura

Perímetro = 2 *(base + altura)

2. Elaborar un pseudocódigo que lea dos números tal como a y b, y diga si a es o
no múltiplo de b.
3. Elaborar un pseudocódigo que calcule la potencia de un número.
4. Construir un pseudocódigo para calcular la cantidad de dígitos de un número
entero.
5. Diseñar un pseudocódigo que reste dos números enteros, devolviendo un
mensaje de error si el segundo número es mayor al primero. Por ejemplo:
Restar: 45 – 12 = 33
Restar: 12 – 45 ERROR
6. Construir un pseudocódigo que calcule la suma de los N términos de la siguiente
serie:
1-2+3-4+5–6+…
Por ejemplo:
Si n = 3 la suma es igual a 2
Si n = 5 la suma es igual a 3
7. Construir un pseudocódigo que calcule el producto de los N términos de la
siguiente serie:
1 * 1/2 * 1/3 * 1/4 * 1/5 * …
Por ejemplo:
Si n = 3 el producto es igual a 0.16666
Si n = 5 el producto es igual a 0.00833
8. La oficina central de climatología de nuestro país desea averiguar la
temperatura promedio de un determinado mes. Elaborar un algoritmo que
registre la temperatura diaria teniendo presente la cantidad de días que trae el
mes en evaluación, además mostrar la temperatura más alta y más baja del
mes.
9. El máximo común divisor de varios números es el mayor que divide a todos.
Vamos a explicarlo a través de un ejemplo: mcd de los números 24 y 32
divisores de 24 = {1, 2, 3, 4, 6, 8, 12, 24}
divisores de 32 = {1, 2, 4, 8, 16, 32}
divisores comunes = {1, 2, 4, 8}
El mayor divisor común es 8, entonces el m.c.d es 8
El pseudocódigo constará de tres módulos:
a) divisores()
b) divisores comunes()
c) mayor()
10. Elaborar un pseudocódigo que averigue si una fecha ingresada es correcta o no,
en caso sea correcta calcular el día siguiente.
11. Elabore un pseudocódigo que muestre los tres primeros números perfectos.
12. Calcular la cantidad de números múltiplos de 3 en un rango de a y b
(indistintamente a o b puede ser el menor o mayor rango).
13. Una farmacia a recopilado los datos de N medicinas, para esto se ingresan en
un proceso repetitivo: el tipo (Antibiótico, Vitaminas, Otros), la procedencia
(Nacional, Importado) y el precio de cada medicina. Construya un pseudocódigo
que permita calcular el promedio de precios según la procedencia del
medicamento, el mayor precio y la cantidad de medicinas de tipo Antibiótico,
Vitaminas y Otros.
14. Clasificar a N personas según la edad y el sexo al final deberá visualizar la
cantidad de personas masculinas mayores de edad, la cantidad de personas
femeninas menores de edad, cantidad de personas mayores y menores, además
deberá indicar el porcentaje que representa las personas mayores y menores de
edad.
15. Dada una fecha (día/mes/año), cuantos días faltan para que termine el año.
Recuerde que un año bisiesto tiene 366 días y un año normal 365 días.
16. En una universidad los alumnos están categorizados en 4 categorías como se
muestra el siguiente cuadro:

Categoría Pensión (S/.)

A 750
B 650
C 550
D 450
Semestralmente la universidad efectúa rebajas en las pensiones de sus
estudiantes a partir del segundo ciclo en base al promedio ponderado del ciclo
anterior, según el siguiente cuadro:
Promedio Descuento (%)
0 – 13 0
14 – 16 10
17 – 18 12
19 – 20 15
Diseñe un algoritmo que determine cuánto de rebaja recibirá un estudiante
sobre su pensión actual y cual es el monto de su nueva pensión.
17. Dada una fecha, averiguar cuantos días tiene una persona.
18. Muestre y calcule el promedio de todos los números de 4 dígitos que tengan 2
dígitos pares.
19. Una empresa almacena los datos de N empleados, para esto, en un proceso
repetitivo se ingresa el sexo y el salario de cada empleado. Se pide calcular:
• El mayor y el menor salario
• El promedio de salarios.
• La cantidad de mujeres y varones que trabajan en esa empresa
20. Construya un algoritmo que lea un número positivo y lo parta en dos sumandos
de tal manera que su producto tenga un valor máximo.
21. Construir un pseudocódigo que acepte un número en le rango de 1 a 999, luego
muestre dicho número en romano. Por ejemplo: Si se ingresa: 32, se obtiene:
XXXII.
14.Recursividad
Una función que se llama a sí misma se denomina recursiva.
14.1. Características
En la función recursiva podemos determinar dos partes principales:

• Caso base es una condición de terminación (no recursiva).
• Llamadas recursivas (a sí misma) que reducen el tamaño del problema
(convergen al caso base).
Las llamadas recursivas van quedando pendientes hasta llegar al caso base. Al
llegar a la condición de salida (el caso base) se desencadena el cálculo de los
resultados pendientes.
La existencia del caso base cubre fundamentalmente dos objetivos:

1. Actuar como condición de finalización de la función recursiva. Sin el caso
base la rutina recursiva se llamaría indefinidamente y no finalizaría nunca.
2. Es el cimiento sobre el cual se construirá la solución completa al problema.
Algo muy importante a tener en cuenta cuando usemos la recursividad es

asegurarnos que llega un momento en que no hacemos más llamadas
recursivas. Si no se cumple esta condición el programa no parará nunca.
14.2. Ventajas y desventajas

La principal ventaja es la simplicidad de comprensión y su gran potencia,

favoreciendo la resolución de problemas de manera natural, sencilla y elegante;
facilidad para comprobar y convencerse de que la solución del problema es
correcta.
El principal inconveniente es la ineficiencia tanto en tiempo como en memoria,

dado que para permitir su uso es necesario transformar el programa recursivo
en otro iterativo, que utiliza bucles y pilas para almacenar las variables.
14.3. Ejercicios resueltos
Ejemplo 01
Pseudocódigo para sumar dos números.
La suma lo podemos expresar como: a + b = a + 1

+1+
1+...
+
1
b " Unos"
 a Si, b = 0
suma (a, b) = 
1 + suma (a, b - 1) Si, b > 0
Por ejemplo: la evaluación de la suma (2,3)
2+3=2+1
+1 +
1 =5
3 " Unos"
suma(2, 3) ->
1+ suma(2, 2) ->
1+ 1+ suma(2, 1) ->
1+1 +1+suma(2, 0) ->
1+1+1+ 2 ->5

• Procedimiento ingresarDatos(entero &pa, entero &pb), permite ingresar dos
números a través de los parámetros de referencia &pa, &pb.
• Función suma(entero pa, entero pb), devuelve un valor entero que
representa la suma de dos números enteros.
• Procedimiento imprimir(entero px), imprime el resultado de la operación
calculada.

a, b parámetros actuales del módulo ingresarDatos() y del módulo
recursivo suma().
x guarda el valor de retorno del módulo recursivo suma() y es
parámetro actual del módulo imprimir().
pa, pb parámetros formales del módulo ingresarDatos() y del módulo
recursivo suma().
px parámetro formal del módulo imprimir().
Inicio
entero: x, a, b
ingresarDatos (a, b)
x suma (a, b)
imprimir (x)

Fin
Procedimiento ingresarDatos(entero &pa, entero &pb)

Escribir (“Ingresar primer número”)
Leer (pa)
Escribir (“Ingresar segundo número”)
Leer (pb)
Fin_procedimiento
Función suma(entero pa, entero pb) : entero

// Definir variable
entero: result
Si (pb =0) entonces
result pa
Sino
result 1+ suma (pa, pb-1)
Fin_si
retornar result
Fin_función

Escribir (“La suma es ”, px)
Fin_procedimiento
Ejemplo 02
Pseudocódigo para calcular el factorial de un número. El factorial se simboliza
como n!, se lee como "n factorial", y la definición es:
n! = n * (n-1) * (n-2) * ... * 1
 1 si n = 0
factorial (n) = 
 n * factorial (n - 1) si n > 0
Por ejemplo 5:
5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
1! = 1 * 0!
factorial(5) ->
(5) factorial(4) ->
(5) (4) factorial(3) ->
(5) (4) (3) factorial(2) ->
(5) (4) (3) (2) factorial(1) ->
(5) (4) (3) (2) (1) factorial(0) ->
(5) (4) (3) (2) (1) ->
120

• Procedimiento ingresarDatos(entero &pn), permite ingresar un número al
cual se hallará el factorial.
• Función factorial(entero pn), devuelve un valor entero que representa el
factorial de un número entero.

• Procedimiento imprimir(entero px), imprime el resutado de la operación

calculada.

n parámetro actual del módulo recursivo factorial() y del módulo
ingresarDatos().
x guarda el valor de retorno del módulo recursivo factorial() y es
pn parámetro formal del módulo recursivo factorial() y del
módulo ingresarDatos().
Inicio
entero: n, x
ingresarDatos (n)
x factorial (n)
imprimir (x)
Fin
Procedimiento ingresarDatos(entero &pn)

Leer (pn)
Fin_procedimiento
Función factorial(entero pn)

// Definir variable
entero: result
Si (pn = 0) entonces
result 1
Sino
result pn * factorial (pn - 1)
Fin_si
retornar result
Fin_función

Escribir (“El factorial es ”, px)
Fin_procedimiento
Como se observa, en cada llamada recursiva se reduce el valor de n, llegando

el caso en el que n es 0 y no efectúa más llamadas recursivas.
Ejemplo 03
Pseudocódigo para calcular cualquier término de la serie de fibonacci:
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144
El tercer término se obtiene sumando el segundo y el primer termino, el cuarto

a partir de la suma del tercer y segundo termino.
 1 Si, n = 1 ó n = 2
fibonacci(n) = 
fibonacci(n - 1) + fobonacci(n - 2) Si, n > 0
Por ejemplo: la evaluación de fibonacci(4)

fibonacci(4) ->
fibonacci(3)+ fibonacci(2) ->

fibonacci(2)+ fibonacci(1) + 1 ->

1 +1 + 1 -> 3

• Procedimiento ingresarDatos(entero &pn), permite ingresar número de
termino de la serie de fibonacci que se desea hallar.
• Funcion fibonacci(entero pn), La función devuelve un valor entero que
representa cualquier término de la serie de fibonacci.
• Procedimiento imprimir(entero pn, entero px), imprime un término de la
serie de fibonacci.

n parámetro actual del módulo recursivo fibonacci() y de los
módulos ingresarDatos() e imprimir().
x guarda el valor de retorno del módulo recursivo fibonacci() y
es parámetro actual del módulo imprimir().
pn parámetro formal del método recursivo fibonacci() y de los
Inicio
entero: x, n
ingresarDatos (n)
x fibonacci (n)
imprimir (n, x)
Fin

Escribir (“Ingresar número término de la serie de fibonacci”)
Leer (pn)
Fin_procedimiento
Función fibonacci (entero pn)

// Definir variable
entero: result
Si (pn =1 or pn =2) entonces
result 1
Sino
result fibonacci (pn-1) + fibonacci (pn-2)
Fin_si
retornar result
Fin_función
Procedimiento imprimir(entero pn, entero px)

Escribir (“El término ”, pn , “ es ”, px)
Fin_procedimiento
Ejemplo 04
Pseudocódigo para calcular la potencia de un número.
La potencia lo podemos calcular como:
2 3 = 2 * 2 2 = 2 * 2 * 21 = 2 * 2 * 2 * 2 0 = 2 * 2 * 2 * 1 = 8
 1 Si, n = 0
potencia (x, n) = 
x * x
n -1
Si, n > 0

Por ejemplo, para evaluar la potencia de (2,3) se tiene:

potencia(2, 3) ->
(2) potencia(2, 2) ->
(2) (2) potencia(2, 1) ->
(2) (2) (2) potencia(2, 0) ->
(2) (2) (2) 1

• Procedimiento ingresarDatos(entero &pbase, entero &pexpo), permite
ingresar la base y el exponente de un número para calcular la potencia.
• Función potencia(entero pbase, entero pexpo), la función devuelve un valor
entero que representa la potencia de un número entero.
• Procedimiento imprimir(entero px), imprime la potencia calculada.

base, expo parámetros actuales del módulo recursivo potencia() y
del módulo ingresarDatos().
x guarda el valor de retorno del módulo recursivo
potencia() y es parámetro actual del módulo imprimir().
pbase, pexpo parámetros formales del módulo recursivo potencia() y
del módulo ingresarDatos().
Inicio
entero: x, base, expo
ingresarDatos (base, expo)
x potencia (base, expo)
imprimir (x)
Fin
Procedimiento ingresarDatos(entero &pbase, entero &pexpo)

Escribir (“Ingresar base”)
Leer (pbase)
Escribir (“Ingresar exponente”)
Leer (pexpo)
Fin_procedimiento
Función potencia(entero pbase, entero pexpo) : entero

// Definir variable
entero: result
Si (pexpo = 0) entonces
result 1
Sino
result pbase * potencia (pbase, pexpo - 1)
Fin_si
retornar result
Fin_funcion

Escribir (“La potencia es ”, px)
Fin_procedimiento
Ejemplo 05
Pseudocódigo para calcular la suma de los N primeros números naturales.

S=1+ 2+3+4+5+…+n
La serie anterior lo podemos expresar como:
s = 1 + 2 + 3 + 4 + 5 + ... + (n - 1) + n

sumaNatura l (n - 1)
 0 Si, n = 0
sumaNatural (a, b) = 
sumaNatural (n - 1) + n Si, n > 0

• Procedimiento ingresarDatos(entero &pn), permite ingresar un número.
• Funcion sumaNatural (entero pn), devuelve un valor entero que representa
la suma de los pn números naturales.
• Procedimiento imprimir(entero px), imprime la suma de los primeros N
números naturales.

n parámetro actual del módulo recursivo sumaNatural() y del
r guarda el valor de retorno del módulo recursivo sumaNatural()
y es parámetro actual del módulo imprimir().
pn parámetro formal del módulo recursivo sumaNatural() y del
Inicio
entero: n, r
ingresarDatos (n)
r sumaNatural(n)
imprimir (r)
Fin

Leer (pn)
Fin_procedimiento
Función sumaNatural(entero pn) : entero

// Definir variable
entero: result
Si (pn =0) entonces
result 0
Sino
result sumaNatural (pn-1) + pn
Fin_si
retornar result
Fin_función

Escribir (“La suma es ”, pr)
Fin_procedimiento

Ejemplo 06
Pseudocódigo para sumar la siguiente serie:
1 - 1/2 + 1/3 – 1/4 + 1/5 + … - 1/2i + 1/2i+1
 0 Si, n = 0
sumaSerie (n) = 
sumaSerie (n - 1) + 1/n Si, n > 0

• Procedimiento ingresarDatos(entero &pn), permite ingresar la cantidad de
términos que tendrá la serie.
• Función sumaSerie(entero pn). La función devuelve un valor real que
representa la suma de la serie.
• Función par(entero n) que devuelve -1 si n es par y 1 si n es impar.
• Procedimiento imprimir(entero px), imprime la suma calculada.

n parámetro actual del módulo recursivo sumaSerie() y del
s guarda el valor de retorno del módulo recursivo sumaSerie() y
es parámetro actual del módulo imprimir().
pn parámetro formal del módulo recursivo sumaSerie() y de los
módulos ingresarDatos() y par().
Inicio
// Definir variable
entero: n
real: s
ingresarDatos (n)
s sumaSerie (n)
imprimir (s)
Fin

Escribir (“Ingrese número de términos”)
Leer (pn)
Fin_procedimiento
Función sumaSerie (entero pn) : real

// Definir variable
entero: r
real: result
result 0
Sino
r par (pn)
result sumaSerie (pn - 1) + r / pn
Fin_si
retornar result
Fin_función
Función par(entero pn): entero


entero: r, result
r pn Mod 2
Si (r = 0) entonces
result -1
Sino
result 1
Fin_si
retornar result
Fin_función
Procedimiento imprimir(entero ps)

Escribir (“La suma ”, ps)
Fin_procedimiento
Ejemplo 07
Pseudocódigo para calcular la suma de los N términos de la serie:
1 + 1/2 + 1/3 + 1/4 + … +1/n
1 + 1 / 2 + ... + 1/n = (1 + 1/2 + ... + 1/n - 1) + 1/n

sumaFraccion (n - 1)
 0 Si, n = 0
sumaFraccion (n) = 
sumaFraccion (n - 1) + 1/n Si, n > 0

• Procedimiento ingresarDatos(entero &pn), permite ingresar la cantidad de
términos que tendrá la serie.
• Función sumaFraccion(entero pn), devuelve la suma de los pn términos de la
serie.
• Procedimiento imprimir(entero ps), imprime el resultado de la operación
calculada.

n parámetro actual del módulo recursivo sumaFraccion() y del módulo
ingresarDatos().
s guarda el valor de retorno del módulo recursivo sumaFraccion() y es
pn parámetro formal del módulo recursivo sumaFraccion() y del módulo
ingresarDatos().
Inicio
// Definir variable
entero: n
ingresarDatos (n)
s sumaFraccion (n)
imprimir (s)
Fin


Leer (pn)
Fin_procedimiento
Función sumaFraccion(entero pn) : real

// Definir variable
real: result
result 0
else
result sumaFraccion (pn - 1) +1/pn
Fin_si
return result
Fin_función
Fin_procedimiento
Ejemplo 08
Pseudocódigo para calcular la suma de los cuadrados de los N primeros
números naturales:
S = 12 + 22 + 3 2 + 4 2 + 5 2 + … + n 2
S = 11 + 2 2 + 33 + ... + (n - 1)2 + n2

sumaCuadrado (n - 1)
 0 Si, n = 0
sumaCuadrado (n) = 
sumaCuadrado (n - 1) + n Si, n > 0
2

• Procedimiento ingresarDatos(entero &pn), permite ingresar un la cantidad
de términos que tendrá la serie.
• Función sumaCuadrado(entero pn), devuelve un valor entero que representa
la suma de los cuadrados de los “n” números naturales
• Procedimiento imprimir(entero pr), imprime la suma de los cuadrados de los
N primeros números naturales.

n parámetro actual del módulo recursivo sumaCuadrado() y del
r guarda el valor de retorno del módulo recursivo
sumaCuadrado() y es parámetro actual del módulo imprimir().
pn parámetro formal del módulo recursivo sumaCuadrado() y del
Inicio
entero: r, n
ingresarDatos (n)

r sumaCuadrado (n)
imprimir (r)
Fin

Leer (pn)
Fin_procedimiento
Función sumaCuadrado(entero pn) : entero

// Definir variable
entero: result
Si (pn =0) entonces
result 0
Sino
result sumaCuadrado (pn - 1) + pn ^ 2
Fin_si
retornar result
Fin_función

Escribir (“Suma de los cuadrados es ”, pr)
Fin_procedimiento
Ejemplo 09
Pseudocódigo para calcular la suma de las cifras de un número.
Por ejemplo: La suma de las cifras de 384 es 3 + 8 + 4 = 15
 0 Si, n = 0
sumaDigito (n) = 
sumaDigito (n/10) + (n Mod 10) Si, n > 0

• Procedimiento ingresarDatos(entero &pn), permite ingresar un número.
• Función sumaDigito(entero pm), devuelve un valor entero que representa la
suma de los dígitos de un numero entero
• Procedimiento imprimir(entero pr), imprime la suma de las cifras de un
número.

n parámetro actual del módulo recursivo sumaDigito() y del
r guarda el valor de retorno del módulo recursivo sumaDigito()
pn parámetro formal del módulo recursivo sumaDigito() y del
Inicio
entero: r, n
ingresarDatos (n)
r sumaDigito (n)
imprimir (r)
Fin


Leer (pn)
Fin_procedimiento
Función sumaDigito(entero pn) : entero

// Definir variable
entero: result
Si (n = 0) entonces
result 0
Sino
result sumaDigito (n / 10) + (n Mod 10)
Fin_si
retornar result
Fin_función

Escribir (“La suma de los dígitos es ”, pr)
Fin_procedimiento
Ejemplo 10
Pseudocódigo para calcular el residuo de dos números enteros mediante el
método de restas sucesivas. El método consiste en restar el dividendo del
divisor hasta que el dividendo sea menor que el divisor, en este caso el
resultado es el dividendo.
Por ejemplo, dividir 10 entre 3
Dividendo Divisor Resto

10 - 3 = 7
7 - 3 = 4
4 - 3 = 1
1 - 3
 a Si, a = b

• Procedimiento ingresarDatos(entero &pa, entero &pb), permite ingresar dos
números enteros a través de los parámetros de referencia &pa, &pb.
• Funcion resto(entero pa, entero pb) la función devuelve un valor entero que
representa el resto de la división de dos números.
• Procedimiento imprimir(entero ps), imprime el residuo de dos números
enteros.

a, b parámetros actuales del módulo recursivo resto() y del módulo
ingresarDatos()
s guarda el valor de retorno del módulo recursivo resto() y es
pa, pb parámetros formales del módulo recursivo resto() y del
Inicio
entero: a, b, s

ingresarDatos (a, b)
s resto (a, b)
imprimir (s)
Fin
Procedimiento ingresarDatos(entero &pa, entero &pb)

Leer (pa)
Leer (pb)
Fin_procedimiento
Función resto(entero pa, entero pb) : entero

// Definir variable
entero: result
Si (pa < pb) entonces
result pa
Sino
result resto (pa - pb, pb)
Fin_si
retornar result
Fin_función

Escribir (“El resto de la división de dos números es ”, ps)
Fin_procedimiento
Ejemplo 11
Pseudocódigo para calcular el máximo común divisor de dos números:
 n Si, m Mod n = 0
mcd (m, n) = 
mcd (n, m Mod n) Si, m, n > 0
Por ejemplo: Para evaluar el mcd de 30 y 20.

Observamos que de la expresión anterior se cumple: Si, m, n > 0, entoces
mcd(n, m Mod n), de esta manera tenemos:
mcd (30, 20) ->

mcd (20, 10) ->
mcd (10, 0) -> 10

• Procedimiento ingresarDatos(entero &pm, entero &pn), permite ingresar dos
números a través de los parámetros por referencia &pm, &pn.
• Función mcd(entero m, entero n) la función devuelve un valor entero que
representa el mcd de dos números.
• Procedimiento imprimir(entero ps), imprime el maximo común divisor de dos
números enteros.

m, n parámetros actuales del módulo recursivo mcd() y del módulo
ingresarDatos().
s guarda el valor de retorno del módulo recursivo mcd() y es
pm, pn parámetros formales del módulo recursivo mcd() y del módulo
ingresarDatos().

Inicio
entero: m, n, s
ingresarDatos (m, n)
s mcd (m, n)
imprimir (s)
Fin
Procedimiento ingresarDatos(entero &pm, entero &pn)

Leer (pm)
Leer (pn)
Fin_procedimiento
Función mcd (entero pm, entero pn) : entero

// Definir variable
entero: result
Si (pm Mod pn = 0) entonces
result pn
Sino
result mcd (pn, pm Mod pn)
Fin_si
retornar result
Fin_función

Escribir (“El máximo común divisor es ”, ps)
Fin_procedimiento
Ejemplo 12
Pseudocódigo para convertir un número decimal a binario.
 n Si, n < base

deci_Binario(n) = 
(n Mod 2) + 10 * dici_Binar io (n/2) Si, n >= base
Módulos que se utilizan: Procedimiento ingresarDatos(entero &pn), permite

ingresar un número.
• Función deci_Binario(entero pm), devuelve un valor entero que representa
la conversión de un número decimal a binario.
• Procedimiento imprimir(entero pn, entero px), imprime el número pn en
binario.

n parámetro actual del módulo recursivo deci_Binario() y de los
x guarda el valor de retorno del módulo recursivo deci_Binario()
pn parámetro formal del módulo recursivo deci_Binario() y de los
Inicio

entero: x, n
ingresarDatos (n)
x deci_Binario (n)
imprimir (n, x)
Fin

Leer (pn)
Fin_procedimiento
Función deci_Binario(entero pn) : entero

// Definir variable
entero: result
result 0
Sino
result (pn Mod 2) +10 * deci_Binario (pn / 2)
Fin_si
retornar result
Fin_función

Escribir (pn, “ a base Binaria”, px)
Fin_procedimiento
Ejemplo 13
Pseudocódigo para calcular la descomposición polinómica, utilizando
recursividad.
Por ejemplo: 321(4 = 3 * 42 + 2 * 41 + 1 * 40 = 57
 0 Si, n = 0
descomPoli (n, base) = 
descomPoli (n/10, base) * base + (n Mod 10) Si, n > 0

• Procedimiento ingresarDatos(entero &pn, entero &pbase), permite ingresar
un número y su base, a través de los parámetros por referencia &pn y
&pbase.
• Función descomPoli(entero pn, pbase), devuelve un valor entero que
representa la descomposición polinómica de un número entero
• Procedimiento imprimir(entero pn, entero px), imprime la descomposición
polinómica del número pn.

n, base parámetros actuales del módulo recursivo descomPoli() y del
x guarda el valor de retorno del módulo recursivo descomPoli() y es
pbase parámetro formal del módulo recursivo descomPoli() y del
pn parámetro formal del módulo recursivo descomPoli() y de los
Inicio
entero: x, n, base

ingresarDatos (n, base)

x descomPoli (n, base)
imprimir (n, x)
Fin
Procedimiento ingresarDatos(entero &pn, entero &pbase)

Leer (pn)
Escribir (“Ingrese base”)
Leer (pbase)
Fin_procedimiento
Función descomPoli(entero pn, entero pbase) : entero

// Definir variable
entero: result
result 0
Sino
result descomPoli (pn Div 10, pbase) * pbase + (pn Mod 10)
Fin_si
retornar result
Fin_funcion

Escribir (“ La descomposición polonómica de ”, pn, “es ”, px)
Fin_procedimiento
Ejemplo 14
Pseudocódigo que cuente el número de apariciones de un digito en un número
positivo. Por ejemplo:
digito = 4, número = 3424, numero de apariciones es 2

digito = 5, número = 3424, no tiene apariciones
Emplearemos dos módulos:
 0 Si, n = 0
apariciones(d, nro) = 
coincide (d, nro Mod 10) + apariciones(d, nro Div 10) Si, n > 0
0 Si, d <> nro

coincide(d, nro) = 
1 Si, d = nro

• Procedimiento ingresarDatos(entero &d, entero &pnro), permite ingresar el
digito y el número.
• Función apariciones(entero pd, entero pnro) La función devuelve un valor
entero que representa si tiene o no repeticiones un digito en un número.
• Función coincide(entero pd, entero pnro) La función devuelve un número
entero que representa si un digito es igual a un elemento del número
• Procedimiento imprimir(entero pr), imprime el número de apariciones de un
digito dentro de un número.

d, nro parámetros actuales del módulo recursivo apariciones() y del
módulo ingresarDatos()

r guarda el valor de retorno del módulo recursivo apariciones()

pd, pnro parámetros formales de los módulos recursivos apariciones() y
coincide() y del módulo ingresarDatos()
Inicio
entero: d, nro, r
ingresarDatos (d, nro)
r apariciones (d, nro)
imprimir (r)
Fin
Procedimiento ingresarDatos(entero &pd, entero &pnro)
Escribir (“Ingresar digito”)
Leer ( pd)
Escribir("Ingresar nro")
Leer (pnro)
Fin_procedimiento
Función apariciones(entero pd, entero pnro) : entero

entero: r, result
Si (pnro = 0) entonces
result 0
Sino
r coincide(pd, pnro Mod 10)
result r + apariciones(pd, pnro Div 10)
Fin_si
retornar result
Fin _ función
Función coincide (entero pd, entero pnro) : entero

// Definir variable
entero: result
Si (pd = pnro) entonces
result 1
Sino
result 0
Fin_si
retornar result
Fin _ función

Si (pr) entonces
Escribir (“Nro de apariciones ”, pr)
Sino
Escribir (“No tiene apariciones”)
Fin_si
Fin_procedimiento
14.4. Ejercicios propuestos
1. Realizar un pseudocódigo para multiplicar dos números.
El producto lo podemos representar como una suma:

a*b = a
+a+a +...
+a
" b" veces " a"
 0 Si, b = 0
producto (a, b) = 
a + producto (a, b - 1) Si, b > 0
Por ejemplo: la evaluación del producto (2,3)
2*3 = +2
2 +2 =6
"3" veces "2"
2. Escriba una función recursiva para calcular el término n-ésimo de la

secuencia de Lucas:
1, 3, 4, 7, 11, 18, 29, 47, ...
El tercer término se obtiene sumando el segundo y el primer término, el

cuarto a partir de la suma del tercer y segundo término y así sucesivamente.
 1 Si, n = 1

lucas(n) =  3 Si, n = 2
lucas(n) = lucas(n - 1) + lucas(n - 2) Si, n > 2

3. Elaborar un pseudocódigo para calcular la suma de los cubos de los “n”

primeros números naturales
S = 13 + 23 + 33 + 43 + 53 +………+ n3

S = 13 + 2 3 + 33 + ... + (n - 1)3 + n3

sumaCubo (n - 1)
 0 Si, n = 0
sumaCubo (n) = 
sumaCubo (n - 1) + n3 Si, n > 0
4. Escriba un pseudocódigo para convertir un número decimal a cualquier base.
 n Si, n = b
5. Escriba una función recursiva para calcular el máximo común divisor de dos
números enteros dados mediante restas sucesivas.
 a Si, a = b

mcd(a, b) = mcd(a - b, b) Si, a > b
 mcd(b, a) Si, a < b

6. Escribir una función recursiva pascal (i, j) que calcule el elemento i, j del
triangulo de pascal, que sigue el siguiente patrón:
1
1 1
1 2 1

1 3 3 1
1 4 6 1 4
1 5 10 10 5 1
. . . . . . . . . . .
Como puede apreciarse, los elementos en el borde del triángulo son unos, y
el resto de los elementos son iguales a la suma de los dos elementos que
hay entre ellos.

Algoritmos: Un enfoque práctico - Capítulo IV Franklin Arriola R. / Yuliana Jáuregui R.
Arreglos
En los pseudocódigo realizados se han utilizado algunas variables. En algunas

ocasiones es necesario manipular un gran número de variables. Por ejemplo, para
hallar el mayor de 1000 números, resulta muy laborioso tener que utilizar 1000
variables diferentes para almacenar cada uno de estos valores y compararlas entre
si, el pseudocódigo se vería enormemente incrementado y complejo.
Para resolver esta situación se utiliza el concepto de arreglos, de modo que

podamos almacenar, acceder y procesar todas estas variables con un solo nombre,
sin necesidad de definir una variable para cada uno de ellos.
1. Arreglos
Es un conjunto finito de elementos todos del mismo tipo, que son representados
mediante una variable común. Los elementos del arreglo tienen un índice que se
enumera consecutivamente 0, 1, 2, 3,…., n-1. Siendo n el numero de elementos del
arreglo. Un índice que no esta en el intervalo de 0 a n -1 esta fuera de los límites.
x[n]=
índice 0 1 2 3 4 5 6 7 … n-1
2. Tipos de Arreglos
Los arreglos pueden ser unidimensionales o multidimensionales
2.1. Arreglos Unidimensionales o vectores
Llamados también vectores, son aquellos que tienen un solo índice. Sus
elementos se diferencian entre si por el valor que toma el índice.
2.1.1. Declaración de un vector
Igual que sucede con otras variables, es necesario declarar un vector antes
de utilizarlo, para lo cual se especifica el tipo base de sus elementos y se
añade corchetes ([]) al nombre del vector, para indicar que la variable
corresponde a un vector.
tipo nombre_del_vector[tamaño]
Donde:
tipo tipo de dato del vector que puede ser entero, real, etc.
nombre_del_vector nombre identificador de la variable
tamaño número entero que indica la cantidad de elementos del
vector.
Ejemplo:
entero a[5]
a[5] = 2 6 8 4 1
indice 0 1 2 3 4

2.1.2. Acceso a los elementos de un vector
Un índice describe la posición de un elemento dentro de un vector, un índice

se enumera desde 0 hasta tamaño-1, siendo tamaño el número de
elementos del vector.
Se tiene acceso a un elemento individual especificando el nombre del vector
y un índice encerrado por corchetes, es decir:
nombre_del_vector [índice]
Por ejemplo: un vector entero x de 10 elementos:
x[10]= 4 8 7 5 6 10 12 3 1 18
Indice 0 1 2 3 4 5 6 7 8 9
Primer elemento del vector: x[0] = 4

Segundo elemento del vector: x[1] = 8
Tercer elemento del vector: x[2] = 7
.
.
.
Ultimo elemento del vector: x[9] = 18
2.1.3. Operaciones con vectores
a) Un elemento de un vector se puede utilizar de la misma forma que

cualquier otra variable.
Por ejemplo, las siguientes operaciones son validas:
c[2]  10 // Asignación de un valor

z  x[5]
a  x[2] + x[5]
c[k]  a[k] * b[k]
b) Los índices se pueden alterar o cambiar su valor como resultado de

hacer una operación aritmética.
i4
x[i + 4]  40 // asigna el valor de 40 a x[8]
c) El índice puede tomar un valor específico, que al ser utilizado en el

vector nos da su valor (contenido).
i7
x[i] // nos da el valor (contenido) del elemento x[7]
2.2. Arreglos bidimensionales o matrices
Llamados también matrices o tablas. Es un conjunto de elementos del mismo

tipo de datos que se almacena bajo un mismo nombre, se necesita especificar
dos índices para identificar a cada elemento del arreglo.
Cuando en un arreglo bidimensional el número de filas y columnas son iguales,

se dice que es una matriz cuadrada.

2.2.1. Declaración de una matriz
Para declarar una matriz es necesario especificar el tipo base de sus

elementos y añadir corchetes ([][]) al nombre de la matriz, para indicar que
la variable corresponde a una matriz. El primer corchete contiene el índice
que representa a la fila y el segundo corchete contiene el índice que
representa a la columna. Su sintaxis es:
tipo nombre_de_la_matriz[fila][columna]
Donde:
tipo tipo de dato del arreglo que puede ser entero,
real, etc.
nombre_de_la_matriz nombre identificador de la variable
fila número entero que indica número de filas de la
matriz
columna número entero que indica la número de
columnas de la matriz
Ejemplo:
entero x[4][5]
0 1 2 3 4
0 25 8 2 10 7
x[4][5]= 1 7 13 18 1 6
2 1 9 11 14 4
3 24 17 6 20 15
2.2.2. Acceso a los elementos de una matriz
Para tener acceso a cada elemento individual de una matriz, se usan dos
índices: el primero indica la fila y el segundo la columna, es decir
nombre_de_ la_matriz[fila][columna]
Por ejemplo si tenemos un matriz x de 3 filas y 4 columnas.
0 1 2 3
0 5 8 12 7
X[3][4]= 1 2 3 18 6
2 1 9 11 4
Primer elemento de la matriz: x[0][0] = 5

Segundo elemento de la matriz: x[0][1] = 8
Tercer elemento de la matriz: x[0][2] = 12
.
.
.
Ultimo elemento: x[2][3] = 4
2.3. Arreglos Multidimensionales
Se refiere a los arreglos con tres o más dimensiones.
Su sintaxis es:

tipo nombre_arreglo[fila][columna][profundidad]
Ejemplo:
entero A[5][4][2]
0 1 2 3
Indice2
0 1 0 1 0 1 0 1
Indice1 0
1
A[5][4][2] = 2 Indice3
3
4
3. Forma de inicialización de los arreglos
Los arreglos como cualquier variable, se les puede dar valores iniciales, esto se
consigue especificando una lista de valores que tendrá el arreglo. Así tenemos:
3.1.En Vectores
El formato general de inicialización de vectores es:
tipo nombre_del_vector[tamaño] = {lista_de_valores}

Donde:
lista_de_valores valores separados por comas que son de un tipo
compatible con el tipo de base del arreglo
Por ejemplo:
entero a[5]  {1, 31, 2, 16, 8}
Esto significa que a[0] tiene el valor de 1, a[1] tiene el valor de 31 y que a[4]
tiene el valor de 8.
entero x[3]  {4, 3, 6} // x es un vector de enteros

caracter cad[5]  {‘a’, ‘e’, ‘i’, ‘o’, ‘u’} // cad es un vector de caracteres
que contiene las vocales
cadena dias[7]  {"Lun.", "Mar.", "Mie.", "Jue.", "Vie.", "Sáb.", "Dom."}
3.2.En Matrices
El formato general de inicialización de matrices es:
tipo nombre_de_la_matriz[fila][columna]={{valores_fila1},{valores_fila2},
…,{valores_filaN}}
Donde: Los valores_filaN es una lista de valores separados por comas que será
colocada en las columnas correspondientes de cada fila N. Ejemplo:
entero x[ ][ ]  { {10,2,50}, {30,15,25} }
Donde:
La primera fila es el primer par de llaves internas:

x[0][0]  10 ; x[0][1]  2; x[0][2]  50

La segunda fila es el segundo par de llaves internas:
x[1][0]  30 ; x[1][1]  15 ; x[1][2 ]  25
La matriz finalmente será:
10 2 50
x= 
30 15 25
4. Arreglos sin tamaño
Si esta inicializando un arreglo de una sola dimensión, no es necesario que

especifique su tamaño, sencillamente no ponga nada dentro de los corchetes. Si no
especifica el tamaño el compilador cuenta automáticamente el número de
constantes de inicialización y usa este valor como el tamaño del arreglo.
entero num[]  {2, 3, 56, 9 ,7, 6}
Para el ejemplo anterior el compilador crea un arreglo con 6 elementos de longitud.

Un arreglo sin tamaño es útil porque resultará mas fácil cambiar el tamaño inicial
del arreglo, sin tener que volver a contar los elementos del arreglo, cada vez que se
agregan o eliminan elementos.
5. Lectura e impresión de un arreglo
5.1.Lectura en vectores
Debe leerse elemento a elemento y para ello se utiliza las estructuras

repetitivas. Así tenemos:
n  número de elementos del vector

Desde (i  0) hasta (i < n) con incremento de 1 Hacer
Leer (x[i])
Fin_desde
5.2.Lectura en matrices
Al igual que en los vectores se debe leer elemento a elemento. Así tenemos:
fila  número de filas de la matriz

columna  número de columnas de la matriz
Desde (i  0) hasta (i < fila) con incremento de 1 Hacer
Desde (j  0) hasta (j < columna) con incremento de 1 Hacer
Leer (x[i][j])
Fin_desde
Fin_desde
5.3.Impresión en vectores
Debe de realizarse elemento a elemento y para ello se utiliza las estructuras

repetitivas. Así tenemos:

Desde (i  0) hasta (i < num) con incremento de 1 Hacer

Escribir (x[i])
Fin_desde
5.4.Impresión en matrices
Al igual que en los vectores se debe escribir elemento a elemento. Así tenemos:
Desde (i  0) hasta (i < fila) con incremento de 1 Hacer

Desde (j  0) hasta (j < columna) con incremento de 1 Hacer
Escribir (x[i][j] )
Fin_desde
Fin_desde
6. Ejercicios resueltos
Ejemplo 01: Pseudocódigo para calcular la suma de los elementos del siguiente
vector de enteros:
a[] = 1 5 10 15 -30 20 25 50 -100 40

i controla la estructura repetitiva Desde ... Fin_desde
n número de elementos del vector
a vector inicializado con los valores correspondientes
suma suma los elementos del vector
Inicio
// Definir e inicializar variables y vectores
entero: a[]  {1, 5, 10, 15, -30, 20, 25, 50, -100, 40}
entero: i, suma  0
// Proceso cálculo de la suma
Desde (i  0) hasta (i < 10) con incremento 1 hacer
suma  suma + a[i]
Fin_desde
Escribir (a[i])
Fin_desde
Escribir (“La suma del vector”, suma)
Fin
Para resolver el ejemplo planteado es necesario inicializar el vector a[] con 10

números enteros entre positivos y negativos, asi tambien se inicializa la variable
suma en cero, la cual funciona como un acumulador almacenando la suma de los
10 números del vector y se define una variable i que será usada como indice del
vector pudiendo recorrer cada elemento del vector.
entero: a[]  {1, 5, 10, 15, -30, 20, 25, 50, -100, 40}
entero: i, suma  0

Para sumar los elementos del vector, es necesario recorrer el vector desde su
primer elemento (a[0]) hasta su ultimo elemento (a[9]), para esto se puede
emplear alguna estructura repetitiva, en nuestro caso se utiliza la estructura Desde
– Fin_desde, de esta manera se irá acumulando la suma de cada elemento del
vector en la variable suma.

Fin_desde
Finalmente, como salida se muestra todos los elementos del vector, para lo cual es
necesario también usar una estructura repetitiva; en nuestro caso se utiliza la
estructura Desde – Fin_desde, que permite mostrar cada elemento del vector,
luego de esto, se muestra el resultado de la suma calculada.

Escribir (a[i])
Fin_desde
Escribir (“La suma del vector”, suma)
Ejemplo 02: Pseudocódigo para calcular el promedio de los valores del siguiente
vector:
numeros[] = 10 8 12 7 14 20 18

numeros vector inicializado con los valores correspondientes
resultado suma del vector
prom promedio del vector
Inicio
entero: numeros[]  {10, 8, 12, 7, 14, 20, 18}
entero: n  7, i
real: resultado  0, prom
// Proceso: calculo del promedio
Desde (i  0) hasta (i < n) con incremento 1 hacer
resultado  resultado + numeros[i]
Fin_desde
prom  resultado / n
Fin
Ejemplo 03: Pseudocódigo que halle el menor y el mayor valor del siguiente
vector:
a[] = 70 80 100 50 20 10 30 60 35 40

i controla la estructura repetitiva Desde….Fin_desde
a vector inicializado con los valores correspondientes
mayor mayor elemento del vector
menor menor elemento del vector

Inicio
// Definr e inicializar variables y vectores
entero: a[]  {70, 80, 100, 50, 20, 10, 30, 60, 35, 40}
entero: i, mayor, menor, n  10
mayor  a[0]
menor  a[0]
// Proceso: calculo del mayor y menor elemento del vector
Si (a[i] > mayor) entonces
mayor  a[i]
Fin_si
Si (a[i] < menor) entonces
menor  a[i]
Fin_si
Fin_desde
Escribir(a[i])
Fin_desde
Escribir (“El mayor elemento es ”, mayor)
Escribir (“El menor elemento es ”, menor)
Fin
Ejemplo 04: Pseudocódigo para determinar cuantos elementos son mayores e

iguales a 20 y cuantos elementos son menores a 20, en un conjunto de N números
enteros almacenados en un vector.
Por ejemplo:
n = 10
a[] = 15 30 12 50 70 30 25 35 33 13
La cantidad de números mayores e iguales a 20 es: 7

La cantidad de números menores a 20 es: 3

a vector con valores
mayorIgual20 total de elementos mayores o iguales a 20
menor20 total de elementos inferiores a 20
Inicio
entero: n, i, mayorIgual20  0, menor20  0, a[80]
// Lectura de datos
Escribir (“Ingresar cantidad de elementos”)
Leer (n)
Leer(a[i])
Fin_desde
// Proceso calculo de >=20 y <20
Si (a[i] >= 20) entonces
mayorIgual20  mayorIgual20 + 1
Sino

menor20  menor20 + 1
Fin_si
Fin_desde
Escribir (a[i])
Fin_desde
Escribir (“La cantidad de números mayores e iguales a 20 es ”, mayorIgual20)
Escribir (“La cantidad de números menores a 20 es ”, menor20)
Fin
Para resolver el ejemplo planteado se definen las variables n, i, a la vez que se

definen e inicalizan en cero las variables mayorIgual20 y menor20, estas dos
ultimas variables trabajan como un contador guardando la cantidad de números
mayores e iguales a 20 y la cantidad de números menores a 20 respectivamente,
asi mismo se define el vector a[] con un tamaño 80, lo que significa que se está
reservando un máximo de 80 espacios de memoria para este vector, que no quiere
decir que es necesario trabajar con estos 80 espacios. Si se ingresa más de 80
elementos a este vector, ocurrirá un error de desbordamiento de memoria, por lo
que se recomienda declarar un tamaño grande para los vectores.
entero: n, i, mayorIgual20  0, menor20  0, a[80]
A diferencia de los ejemplos desarrollados, en este caso se ingresa valores a un

vector empleando una estructura repetitivas, en nuestro caso Desde – Fin_desde,
ingresando antes la cantidad de elementos que tendrá el vector:
Escribir (“Ingresar cantidad de elementos”)

Leer (n)
Leer(a[i])
Fin_desde
Para el proceso de cálculo empleamos la estructura repetitiva Desde – Fin_desde

para recorrer todos los elementos del vector, a la vez que cada elemento del vector
es evaluado como >= 20 o como < 20 mediante la estructura selectiva Si – Sino –
Fin_si.

Si (a[i] >= 20) entonces
mayorIgual20  mayorIgual20 + 1
Sino
menor20  menor20 + 1
Fin_si
Fin_desde
Finalmente se muestra los elementos del vector empleando también la estructura

repetitiva Desde – Fin_desde, asi como se muestra la cantidad de números
mayores e iguales a 20 y la cantidad de números menores a 20 mediante las
variables mayorIgual20 y menor20 respectivamente.

Escribir (a[i])
Fin_desde
Escribir (“La cantidad de números mayores e iguales a 20 es ”, mayorIgual20)
Escribir (“La cantidad de números menores a 20 es ”, menor20)

Ejemplo 05: Guardar en dos vectores diferentes los códigos de N empleados y

número de horas trabajadas correspondientes. Se pide realizar un pseudocódigo
que haga lo siguiente:
a) Imprima el código de cada empleado y su respectiva hora trabajada. Además si
un empleado ha trabajado más de 40 horas, se indicará con un asterisco en la
impresión.
b) Imprima cuántos empleados han trabajado más de 40 horas y cuantas horas
extras se han acumulado entre todos los empleados.
Suponiendo que se ingresan los siguientes datos:
nempl[] = 125 128 129 130 131 132 133
htrab[] = 40 45 37 39 50 35 42
La salida que se obtiene luego de ejecutar el algoritmo es:
Código Horas extras Observación

125 40
128 45 *
129 37
130 39
131 50 *
132 35
133 42 *
Total de empleados con mas de 40 horas: 3

Total de horas extras: 17

n cantidad de empleados
codEmpl vector que contiene los códigos de los empleados
htrab vector que contiene las horas trabajadas
asterisco vector que contiene asteriscos
totalEmp total de empleados que trabajan mas de 40 horas
he horas extras
she suma de las horas extras
Inicio
entero: n, i, totalEmpl  0, he  0, she  0, codEmpl[30], htrab[30]
caracter: asterisco[30]
// Lectura de datos
Escribir (“Ingresar cantidad de empleados:”)
Leer (n)
Escribir (“Ingresar código del empleado”)
Leer (codEmpl [i])
Escribir (“Ingresar horas trabajadas”)
Leer (htrab [i])
Fin_desde
// Proceso
Desde (i  0) hasta (i < n) con incremento 1 Hacer
Si (htrab[i] > 40 ) entonces
asterisco[i]  '*'
totalEmp  totalEmp + 1

he  htrab[i] - 40
she  she + he
Fin_si
Fin_desde
Escribir (“Codigo Horas extras Observación")
Escribir (codEmpl[i], htrab[i], asterisco[i])
Fin_desde
Escribir (“Total de empleados con mas de 40 horas = ”, totalEmp)
Escribir (“Total de horas extras = ”, she)
Fin
Ejemplo 06: Pseudocódigo que sume dos números enteros. Ambos números tienen
la misma cantidad de dígitos. Los dígitos de estos números deberán guardarse en
los vectores correspondientes, asimismo, el resultado de la suma también se
deberá guardar en otro vector.
Por ejemplo:
a[] = 3 7 5 9
b[] = 8 7 3 6
suma[] = 1 2 4 9 5

i controla la estructura repetitiva Mientras…..Fin_mientras.
n número de elementos del vector.
a vector con los valores del primer número.
b vector con los valores del segundo número.
r si la suma es mayor que 9, toma el valor de 1, en caso contrario vale 0.
s almacena la suma de a[i] , b[i] y r.
Inicio
entero: n, i, r  0, s  0, a[30], b[30]
// Lectura de datos
Escribir (“Ingresar cantidad de dígitos de los números:”)
Leer (n)
Escribir (“Ingresar dígito”)
Leer (a[i])
Fin_desde
Escribir (“Ingresar dígito”)
Leer (b[i])
Fin_desde
i  (n - 1)
Mientras (i >= 0) Hacer
s  a[i] + b[i] + r
Si (s >9 ) entonces
s  s - 10
r1
Sino
r0
Fin_si

suma[i]  s
ii-1
Fin_mientras
Si (r > 0) entonces
Escribir (r)
Fin_si
Escribir (suma[i])
Fin_desde
Fin
Ejemplo 07: Pseudocódigo que indique cuantas unidades, decenas, centenas y

millares hay en un número entero.
Por ejemplo, si se tiene 134, el resultado será: 1 centena, 3 decenas y 4 unidades.

nro número a descomponer.
digito cada dígito del número.
b vector inicializado con las cadenas “unidades”, “decenas”, etc.
nDigito vector almacena cada uno de los dígitos de nro.
i,j índice de los vectores.
Inicio
entero: nro, i  0, k, digito  0, nDigito[10]
cadena: b[4] = { “Unidades”, “Decenas”, “Centenas”, “Millares”}
// Lectura de datos
Escribir (“Ingrese numero:”)
Leer (nro)
digito  nro Mod 10 // se obtiene cada digito
nDigito[i]  digito // se asigna cada digito en el vector nDigito
i  i +1 // incrementa índice
nro  nro Div 10 // reduce nro
Fin_mientras
//Salida de resultados
Desde (k  0) hasta (k < i) con incremento 1 Hacer
Escribir (nDigito[k], b[k])
Fin_desde
Fin
Ejemplo 08: Pseudocódigo para obtener la cantidad de billetes y monedas que

debe disponer una empresa para pagar el sueldo de sus N trabajadores.
Nota: se dispone de billetes de 200, 100, 50, 20, 10 y monedas de 5, 2, 1
Por ejemplo:
billete[]= 200 100 50 20 10 5 2 1

Sueldo: 358
1 billete 200
1 billete 100
1 billete 50
1 moneda 5
1 monedas 2

1 moneda 1
Desea seguir s/n:

i índice que controla la estructura repetitiva Desde….Fin_desde.
a vector que contiene los billetes y monedas correspondientes.
m vector inicializado con “billete”,...”moneda”
sueldo sueldo del trabajador.
seguir variable booleana que puede tomar dos valores verdadero o falso.
Inicio
entero: n  8, i, sueldo, b[40]
boolean: seguir  verdadero
entero: a[8]  {200, 100, 50, 20, 10, 5, 2, 1}
cadena: m[8]={“billete”, “billete”, “billete”, “billete”, “billete”, “moneda”,
“moneda”, “moneda”}
caracter: resp
Mientras (seguir) Hacer
Escribir (“Ingrese sueldo”)
Leer (sueldo)
// Proceso
b[i]  sueldo Div a[i]
sueldo  sueldo Mod a[i]
Fin_desde
Si (b[i] > 0) entonces
Escribir (b[i], m[i], a[i])
Fin_si
Fin_desde
Escribir (“Desea seguir s/n:”)
Leer (resp)
Si (resp = 's') entonces
seguir  verdadero
Sino
seguir  falso
Fin_si
Fin_mientras
Fin
Ejemplo 09: Pseudocódigo que elimina un elemento de un vector a partir de un

indice ingresado.
Por ejemplo sea el vector de enteros
a[]= 70 80 100 50 20 10 30 60 35 40
Posición a eliminar: 2
a[]= 70 80 50 20 10 30 60 35 40

i índice que controla la estructura repetitiva Desde … Fin_desde.

a vector con valores.

posi indice del elemento a eliminar.
k índice que controla la estructura repetitiva Mientras … Fin_mientras.
Inicio
entero: n, i, k  0, a[50]
// Lectura de datos
Escribir (“Ingresar cantidad de elementos del vector:”)
Leer (n)
Escribir (“Ingresar elemento”)
Leer (a[i])
Fin_desde
Escribir (“Ingresar indice del elemento a eliminar”)
Leer (posi)
k  posi
Mientras (k < (n – 1)) Hacer
a[k]  a[k+1]
k  k +1
Fin_mientras
Escribir (“Eliminando el indice: ”, posi, “se tiene ”)
Desde (i  0) hasta (i < n-1) con incremento 1 Hacer
Escribir(a[i])
Fin_desde
Fin
Ejemplo 10: Pseudocódigo para hallar el número de repeticiones de cada elemento

de un vector.
Por ejemplo si se tiene:
a[]= 12 18 20 12 20 23 20 25
La salida será:
12 se repite 2 veces
18 se repite 1 vez
20 se repite 3 veces
23 se repite 1 vez
25 se repite 1 vez

i, j índice que controla la estructura repetitiva Desde … Fin_desde.
a vector con valores correspondientes.
marca vector que marca con asterisco los elementos que se repiten.
b vector que contiene los elementos del vector a sin repeticiones.
repite vector donde guardamos el número de repeticiones.
n1 número de elementos del vector b y vector repite.
cuenta numero de repeticiones de un elemento de un vector.
Inicio
entero: n, i, j, n10, cuenta1, b[50], repite[50], a[50]
caracter: marca[50]
// Lectura de datos

Leer (n)
Leer (a[i])
Fin_desde
// Proceso calculo de repeticiones
Desde (i  0) hasta (i < n-1) con incremento 1 hacer
Si (marca[i] = ' ') entonces
Desde (j  i+1) hasta (i < n) con incremento 1 hacer
Si (a[i] = a[j]) entonces
cuenta  cuenta + 1
marca[j]  '*'
Fin_si
b[n1]  a[i]
repite[n1]  cuenta
cuenta  1
n1  n1+1
Fin_desde
Fin_si
Fin-desde
// Ultimo valor no estamos considerando
Si (marca[n-1] = ' ') entonces
b[n1]  a[n-1]
repite[n1]  1
Fin_si
Desde (i  0) hasta (i < n1) con incremento 1 hacer
Escribir (b[i], “se repite ”, repite[i], “veces”)
Fin_desde
Fin
Ejemplo 11: Pseudocódigo para hallar el mayor y menor elemento de una matriz
de N filas y M columnas.
Por ejemplo:
N=5
M=4
35 40 22 70
10 27 42 31
a[][]= 15 18 25 17
90 5 175 85
37 35 45 105
El mayor elemento es: 175

El menor elemento es: 5

i, j controla la estructura repetitiva Desde … Fin_desde
fila número de filas de la matriz
columna número de columnas de la matriz
a matriz de elementos.
mayor mayor elemento de la matriz
menor menor elemento de la matriz
Inicio
// Definir variables y matrices

entero: i, j, fila, columna, mayor, menor, a[50][50]

// Lectura de datos
Escribir (“Ingresar cantidad de filas de la matriz:”)
Leer (fila)
Escribir (“Ingresar cantidad de columnas de la matriz:”)
Leer (columna)
Desde (i  0) hasta (i < fila) con incremento 1 Hacer
Desde (j  0) hasta (j < columna) con incremento 1 Hacer
Leer (a[i][j])
Fin_desde
Fin_desde
// Se asigna el primer elemento de la matriz al mayor y menor
mayor  a[0][0]
menor  a[0][0]
// Proceso
Si (a[i][j] > mayor) entonces
mayor  a[i][j]
Fin_si
Si (a[i][j] < menor) entonces
menor  a[i][j]
Fin_si
Fin_desde
Fin_desde
Escribir(a[i][j])
Fin_desde
Fin_desde
Escribir (“El mayor elemento es ”, mayor)
Escribir (“El menor elemento es ”, menor)
Fin
Explicación:
Para desarrollar el ejemplo planteado se definen las variables i, j, fila, columna,
mayor, menor y la matriz a[][], con un tamaño de 50 filas y 50 columnas, es decir
se esta reservando 250 espacios de memoria.
entero: i, j, fila, columna, mayor, menor, a[50][50]
Para ingresar valores a una matriz es necesario emplear dos estructuras

repetitivas, en nuestro caso empleamos un doble Desde – Fin_desde; de esta
manera la primera estructura repetitiva permitirá recorrer las filas de la matriz a la
vez que la segunda estructura repetitiva recorre las columnas de la matriz. Asi
mismo, antes de ingresar los valores a la matriz ingresamos la cantidad de filas y
columnas que tendrá la matriz mediante las variables fila, columna:

Leer (fila)
Leer (columna)

Leer (a[i][j])
Fin_desde
Fin_desde
Se asigna el primer elemento de la matriz tanto a la variable mayor como a la

variable menor, esto es, para poder realizar la comparación entre todos los
elementos de la matriz.
mayor  a[0][0]
menor  a[0][0]
Se recorre la matriz mediante una doble estructura Desde - Fin_desde y va

comparando la variable mayor y menor con cada elemento de la matriz empleando
dos estructuras Si – Fin_si, obteniendose de esta manera el mayor y el menor
elemento de la matriz.

mayor  a[i][j]
Fin_si
Si (a[i][j] < menor) entonces
menor  a[i][j]
Fin_si
Fin_desde
Fin_desde
Finalmente se muestra los elementos de la matriz empleando también una dobles

estructura Desde – Fin_desde, asi también, se muestra el mayor y el menor
elemento de la matriz.

Escribir(a[i][j])
Fin_desde
Fin_desde
Escribir (“Mayor elemento es ”, mayor)
Escribir (“Menor elemento es ”, menor)
Ejemplo 12: Pseudocódigo que halle el mayor de cada fila de una matriz de N filas
y M columnas, y los almacene en un vector.
Por ejemplo:
N=5
M=4
80 40 50 70
10 27 42 31
a[][]= 15 30 25 10
90 5 175 85
55 35 45 105
Vector que contiene el mayor de cada fila es:
suma[]= 80 42 30 175 105

i, j controla la estructura repetitiva Desde … Fin_desde

fila número de filas de la matriz.
columna número de columnas de la matriz.
a matriz con elementos.
b vector que contiene el mayor de cada fila.
mayor mayor valor de cada fila de una matriz.
Inicio
entero: i, j, fila, columna, mayor, a[50][50]
// Lectura de datos
Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
// Se asigna a la variable mayor el primer elemento
mayor  a[0][0]
// Proceso mayor de cada fila
mayor  a[i][j]
Fin_si
Fin_desde
b[i]  mayor
mayor  0
Fin_desde
Escribir (a[i][j])
Fin_desde
Fin_desde
Escribir (“Mayor de cada fila”)
Escribir (b[i])
Fin_desde
Fin
Ejemplo 13: Pseudocódigo para llenar la matriz identidad de orden (tamaño) N.

Una matriz identidad es aquella en la que la diagonal principal está llena de unos y
el resto de los elementos son cero. Para este caso:
• Se asigna 1,cuando los índices i y j sean iguales
• Se asigna 0, cuando los índices i y j sean diferentes
1 0 0 0
a[][]= 0 1 0 0
0 0 1 0
0 0 0 1

i, j índice que controla la estructura repetitiva Desde … Fin_desde

n tamaño de la matriz
matriz matriz identidad a emplear
Inicio
entero: n, i, j, a[40][40]
// Lectura de datos
Escribir (“Ingresar tamaño de la matriz:”)
Leer (n)
// Proceso
Desde (j  0) hasta (j < n) con incremento 1 Hacer
Si (i = j) entonces
a[i][j]  1
Sino
a[i][j]  0
Fin_si
Fin_desde
Fin_desde
Desde (j  0) hasta (j < n) con incremento 1 Hacer
Escribir (a[i][j])
Fin_desde
Fin_desde
Fin
Ejemplo 14: Pseudocódigo que sume los elementos de cada fila de una matriz y
almacene el resultado en un vector.
80 40 50 70
10 27 42 31
a[][]= 15 30 25 10
90 5 175 85
55 35 45 105
Vector que contiene la suma de cada fila es:
b[]= 240 110 80 355 240

i, j controla la estructura repetitiva Desde..Fin_desde
fila número de filas de la matriz
columna número de columnas de la matriz
a matriz con elementos
suma vector que contiene la suma de cada fila
Inicio
entero: i, j, fila, columna, a[80][80], suma[80]
// Lectura de datos
Leer (fila)
Leer (columna)


Leer (a[i][j])
Fin_desde
Fin_desde
//Proceso
suma[i]  0
suma[i]  suma[i] + a[i][j]
Fin_desde
Fin_desde
Escribir(a[i][j])
Fin_desde
Fin_desde
Escribir(“La suma de cada fila es”)
Escribir(suma[i])
Fin_desde
Fin
7. Ejercicios propuestos
1. Elaborar un pseudocódigo donde se ingrese día, mes y año como valor

numérico:
Ingrese día: 04
Ingrese mes: 12
Ingrese año: 06
y se obtenga la siguiente salida: 04 de diciembre de 2006
Use vectores para almacenar los meses.
2. Elaborar un pseudocódigo que permita ingresar en un vector la cantidad de

artículos producidos por un obrero. Construir un pseudocódigo para calcular el
número de artículos producidos menores o iguales que 100, el número de
artículos producidos mayores a 100 pero menores o iguales a 200 y números de
artículos producidos mayores a 200.
3. Construir un pseudocódigo que permita eliminar los números enteros

consecutivos iguales de un vector. Por ejemplo:
a[]= 1 2 2 3 3 4 5 5 6
El vector modificado es:
a[]= 1 2 3 4 5 6
4. Pseudocódigo que elimina una fila y una fila y una columna de una matriz.
El algoritmo preguntara que fila y que columna desea eliminar
El usuario deberá introducir estos datos
Se mostrará las dos matrices, la original y el resultado luego de eliminar la
fila y la columna especificadas.

5. Construir un pseudocódigo que obtenga el menor valor de cada fila de una

matriz de N filas y M columnas, si hay más de uno, considerar solo el primer
valor encontrado, se pide mostrar en una matriz el menor valor y sus índices
correspondientes.
80 40 50 40
15 30 25 10
90 5 175 85
35 55 45 105
Se obtiene la siguiente matriz
Número Fila columna

40 1 2
10 2 3
5 3 2
35 4 1
6. Elaborar un pseudocódigo para realizar la multiplicación de dos números

enteros, por ejemplo 128 * 34
1 2 8 1 2 8 x
3 4 3 4
5 9 2 5 9 2
3 8 4 3 8 4
4 4 3 2 4 4 3 2
7. Realizar un pseudocódigo que lea N números enteros y los guarde en un vector,

encontrar el máximo valor e imprimirlo junto al número de veces que aparece,
asi también mostrar los índices en el que aparece este valor.
a[]= 7 18 143 10 52 143 72 10 143 17
La salida generada será:

143 aparece 3 veces, en posiciones 2, 5, 8.
8. Paso de vectores a módulos
Cuando se pasa un vector a un módulo los parámetros pasados de esta manera se

dice que son pasados por referencia, ya que el nombre del vector es una referencia
(puntero) a dicho vector.
De acuerdo al tipo de parámetro para pasar un vector a un módulo se debe de
tener en cuenta lo siguiente:
8.1.Parámetro Actual
El nombre del vector debe de aparecer solo es decir sin corchetes o

índices como un argumento actual dentro de la llamada al módulo. Así
temenos:
Cuando el módulo retorna un valor:

variable  NombreDelModulo(nombreDelVector, …)
Cuando el módulo no retorna un valor:
NombreDelModulo(nombreDelVector, …)
8.2.Parámetro formal
Se escribe de la misma manera, pero el vector debe de ser declarado,

estableciendo su tamaño.
TipoDeModulo NombreDelModulo (tipo nombreDelVector[tamaño], ...)
Si un elemento del vector es alterado dentro del módulo, esta alteración

será reconocida en la porción del programa desde la que se hizo la
llamada (en realidad en todo el ámbito de la definición del vector).
9. Paso de una matriz a módulo
Cuando se pasa una matriz a un módulo al igual que en los vectores, los
parámetros son pasados por referencia.
De acuerdo al tipo de parámetro para pasar una matriz a un módulo se debe de
tener en cuenta lo siguiente:
9.1.Parámetro actual
El nombre de la matriz debe de aparecer solo es, decir sin corchetes o índices
como un argumento actual dentro de la llamada al módulo.
Cuando el módulo retorna un valor:
variable  NombreDelModulo(nombreDeLaMatriz, …)
Cuando el módulo no retorna un valor:
NombreDelModulo(nombreDeLaMatriz, …)
9.2.Parámetro formal
Se escribe de la misma manera, pero la matriz debe de ser declarada,

estableciendo la cantidad de filas y columnas que tendrá.
TipoDeModulo NombreDelModulo (tipo nombreDeLaMatriz[fila][columna], ...)
Si un elemento de matriz es alterado dentro del módulo, esta alteración será

reconocida en todo el ámbito de la definición de la matriz.

10.Ejercicios resueltos
Durante la construcción de algunos pseudocódigos se utilizarán las siguientes

funciones:
• igual (entero valor1, entero valor2) será verdadero si valor1 y valor2 son
iguales
• super (entero valor1, entero valor2) será verdadero si valor1 es mayor que
valor2
• infer (entero valor1, entero valor2) será verdadero si valor1 es menor que
valor2
Función igual (entero valor1, entero valor2) : booleano

// Definir variable
boolean: r
Si (valor1 > valor2) entonces
r  verdadero
Sino
r  falso
Fin_si
retornar r
Fin_función
Función super (entero valor1, entero valor2): booleano

// Definir variable
boolean: r
Si (valor1 > valor2) entonces
x  verdadero
Sino
x  falso
Fin_si
retornar x
Fin_función
Función infer (entero valor1, entero valor2): booleano

// Definir variable
boolean: r
Si (valor1 < valor2) entonces
x  verdadero
Sino
x  falso
Fin_si
retornar x
Fin_función
Desarrollaremos la funcion igual(), super() y infer() utilizando expresiones

booleanas
Función igual (entero valor1, entero valor2) : booleano

// Definir variable
boolean: r
r (valor1 = valor2)
retornar r
Fin_función
Función super (entero valor1, entero valor2) : booleano

// Definir variable
boolean: r

r (valor1 > valor2)

retornar r
Fin_función
Función infer (entero valor1, entero valor2) : booleano

// Definir variable
boolean: r
r (valor1 < valor2)
retornar r
Fin_función
Ejemplo 01: Pseudocódigo que determine el mayor elemento de un vector. El

pseudocódigo se resolverá de dos formas:
a) Usando procedimiento
b) Usando funciones
Solución a:

• Procedimiento ingresarVector(entero a[80], entero &n), permite ingresar
números enteros al vector.
• Procedimiento maximo(entero a[80], entero n, entero &max), devuelve el
elemento máximo del vector a.
• Procedimiento imprimirVector(entero vector[80], entero n), imprime el
contenido del vector.
Inicio
entero: n, max 0 , a[80]
// Lectura de datos
ingresarVector(a, n)
// Proceso
maximo(a, n, max)
imprimirVector(a, n)
Escribir (“Mayor numero”, max)
Fin
Procedimiento ingresarVector(entero a[80], entero &n)

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento maximo(entero a[80], entero n, entero &max)

// Definir variable
entero: i
max  a[0]
Si (a[i] > max) entonces
max  a[i]
Fin_si

Fin_desde
Fin_procedimiento
Procedimiento imprimirVector(entero vector[80], entero n)

// Definir variable
entero: i
Escribir (vector[i])
Fin_desde
Fin_procedimiento
Solución b:

• Función maximo(entero a[80], entero n), devuelve un numero entero que
representa el elemento máximo del vector a.
• Procedimiento imprimirVector(entero vector[80], entero numel), imprime el
Inicio
entero: n, max, a[80]
// Lectura de datos
// Proceso
max  maximo(a, n)
Escribir (“El mayor elemento del vector ”, max)
Fin
Procedimiento ingresarVector (entero a[80], entero &n)

// Definir variable
entero: i
Leer (n)
Leer(a[i])
Fin_desde
Fin_procedimiento
Función maximo (entero a[80], entero n) : entero

entero: i, m
m a[0]
i0
Mientras (i < n) Hacer
Si (a[i] > m) entonces
m  a[i]
Fin_si
i  i+1
Fin_mientras
retornar m
Fin_función

Procedimiento imprimirVector(entero vector[80], entero numel)

// Definir variable
entero: i
Desde (i  0) hasta (i < numel) con incremento 1 hacer
Fin_desde
Fin_procedimiento
Ejemplo 02: Pseudocódigo para contar el número de ocurrencias de un elemento

en un vector.
a[]= 4 5 7 4 3 4 8 4 9 4
Elemento a contar: 4
Nro ocurrencias: 5

• Función ocurrencia(entero a[10], entero n, entero ele), devuelve el número de
ocurrencias de un valor en un vector.
• Funcion igual (entero pvalor1, entero pvalor2), devuelve un valor booleano
verdadero o falso. Si pvalor1 es igual pvalor2 devuelve verdadero, si pvalor1 es
diferente de pvalor2 devuelve falso.
• Procedimiento imprimirVector(entero vector[10], entero numel) imprime el
Inicio
entero: a[10]{4,5,7,4,3,4,8,4,9,4}
entero: n 10, ele, x
// Lectura de datos
Escribir (“Ingrese elemento”)
Leer (ele)
// Proceso
x  ocurrencia(a, n, ele)
Escribir (“El número de ocurrencias es ”, x)
Fin
Función ocurrencia(entero a[10], entero n, entero ele) : entero

entero: i  0, ocu  0
boolean: r
Mientras (i < n) hacer
r  igual (ele,a[i])
Si (r) entonces
ocu  ocu+1
Fin_si
i  i+1
Fin_mientras
retornar ocu
Fin_función
Función igual (entero pvalor1, entero pvalor2) : booleano

// Definir variable
boolean: r

r  (pvalor1 = pvalor2)
retornar r
Fin_procedimiento
Procedimiento imprimirVector (entero vector[10], entero numel)

// Definir variable
entero: i
Desde (i  0) hasta (i < numel) con incremento 1 Hacer
Fin_desde
Fin_procedimiento
Ejemplo 03: Pseudocódigo que permita ingresar N números enteros a un vector y

obtenga dos nuevos vectores. Un vector que contenga los números pares y otro
vector que contenga los números impares.

• Procedimiento separarpi(entero a[50], entero n1, entero b[50], entero &n2,
entero c[50], entero &n3), devuelve el vector b de pares y el vector c de
impares.
• Función parImpar(entero pvalor), devuelve un valor booleano verdadero o falso
dependiendo del parámetro pvalor, el cual representa un valor cualquiera del
vector, de esta manera, si pvalor es par devolverá verdadero, sino devolverá
falso
contenido del vector
Inicio
entero: n1, n20, n30, a[50] , b[50], c[50]
//Lectura de datos
ingresarVector(a, n1)
//Proceso
separarpi(a, n1, b, n2, c, n3)
Escribir (“El vector A es”)
imprimirVector(a, n1)
Escribir (“El vector de pares es”)
imprimirVector(b, n2)
Escribir (“El vector de impares es”)
imprimirVector(c, n3)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento

Procedimiento separarpi(entero a[50], entero n1, entero b[50], entero &n2,

entero c[50], entero &n3)
entero: i
boolean: r
i0
Mientras (i<n1) hacer
r  parImpar (a[i])
Si (r) entonces
b[n2]  a[i]
n2  n2+1
Sino
c[n3]  a[i]
n3  n3+1
Fin_si
i  i+1
Fin_mientras
Fin_procedimiento
Función parImpar (entero valor) : booleano

// definir variable
boolean: r
r  (valor Mod 2 = 0)
retornar r
Fin_función

// Definir variable
entero: i
Fin_desde
Fin_procedimiento

1. Se ejecuta el módulo principal, definiendo los vectores a, b, c y las variables
correspondientes.
2. Se llama al módulo ingresarVector(), para ingresar los elementos al vector a.
3. Se llama al módulo separarpi(), para formar los vectores b de pares y c de
impares.
4. Se llama al módulo parImpar() para determinar si un valor es par o impar.
5. Se llama al módulo imprimirVector() tres veces para imprimir al vector a, b, y c
respectivamente.
Ejemplo 04: Pseudocódigo que determinar el mayor y menor elemento de un

vector.

• Procedimiento maximo(entero a[80] ,entero n, entero &mayor, entero &menor),
devuelve el mayor y menor elemento del vector a.
Inicio

entero: n, max, min, a[80]

// Lectura de datos
//Proceso
maximo(a, n, max, min)
Escribir (“El mayor número es ”, max)
Escribir (“El menor número es ”, min)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento maximo (entero a[80], entero n, entero &mayor, entero &menor)

entero: i, mayor, menor
mayor  a[0]
menor  a[0]
mayor  a[i]
Fin_si
menor  a[i]
Fin_si
Fin_desde
Fin_funcion

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 05: Pseudocódigo para encontrar los elementos de a ∩ b. La intersección

esta formada por todos los elementos comunes que pertenecen a ambos vectores.
Por ejemplo:
a[] = 3 7 11 15 19
b[] = 4 7 13 15 18 19 20
El vector intersección será:

c[]= 7 15 19


• Procedimiento interseccion(entero a[80], entero n1, entero b[80], entero n2,
entero c[80], entero &n3), devuelve el vector c.
• Funcion igual(entero pvalor1, entero pvalor2), devuelve un valor booleano,
verdadero o falso, si pvalor1 es igual pvalor2 devuelve verdadero, si pvalor es
diferente de pvalor2 devuelve falso.
Inicio
// Definir variables y vectores
entero: n1, n2, n3 0, a[80], a[80], c[80]
// Lectura de datos
ingresarVector(b, n2)
// Proceso
interseccion(a, n1, b, n2, c, n3)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento interseccion (entero a[80], entero n1, entero b[80], entero n2,
entero: i, j
boolean: r
n3  0
Desde (i  0) hasta (i < n1) con incremento 1 Hacer
Desde (j  0) hasta (j < n2) con incremento 1 Hacer
r  igual (a[i],b[j] )
Si (r) entonces
c[n3]  a[i]
n3  n3+1
j  n2
Fin_si
Fin_desde
Fin_desde
Fin_procedimiento
Función igual (entero pvalor1, entero pvalor2) : booleano

// Definir variable
boolean: r

retornar r
Fin_función
Procedimiento imprimirVector(entero vector[80],entero numel)

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 06: Pseudocódigo donde se ingrese N elementos a un vector A y M

elementos a un vector B y se muestre en un nuevo vector C todos los elementos
del vector A que no esta en el vector B.
Por ejemplo:
a[] = 3 7 11 15 19
b[] = 4 7 13 15 18 19 20
El nuevo vector es:

c[]= 3 11

• Procedimiento diferencia(entero a[100], entero n1, entero b[100], entero n2,
entero c[100], entero &n3), devuelve el vector c.
Inicio
entero: n1, n2, n3 0, a[100], b[100], c[100]
// Lectura de datos
// Proceso
diferencia(a, n1, b, n2, c, n3)
imprimirVector(a,n1)
imprimirVector(b,n2)
imprimirVector(c,n3)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento

Procedimiento diferencia(entero a[100], entero n1, entero b[100], entero n2,

entero: i, j, sw0
n3  0
Desde (j  0) hasta (j < n2) con incremento 1 Hacer
Si (a[i] <> b[j]) entonces
sw 1
Sino
sw  0
j  n2
Fin_si
Fin_desde
Si (sw =1) entonces
c[n3]  a[i]
n3  n3 + 1
Fin_si
Fin_desde
Fin_procedimiento
Procedimiento imprimirVector (entero vector[100],entero numel)

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 07: Pseudocódigo donde se ingrese N elementos a un vector y sustituya

cada par positivo por una letra ‘p’, y cada impar positivo por la letra ‘i’, y los
números negativos son eliminados del vector resultado.

• Procedimiento sustituyepi(entero a[50], entero n1, caracter b[50], entero
&n2), devuelve el vector b.
• Función par(entero valor), devuelve un valor booleano.
• Procedimiento imprimirVectorA(entero vector[50], entero numel), imprimr el
vector.
• Procedimiento imprimirVectorB(caracter charvector[50], entero numel),
imprime el vector de carácter
Inicio
entero: n1, n2 0, a[50]
caracter: b[50]
sustituyepi (a, n1, b, n2)
imprimirVectorA(a, n1)
imprimirVectorB(b, n2)
Fin

// Definir variable

entero: i
Escribir ("Ingresar cantidad de elementos del vector:")
Leer (n)
Escribir ("Ingresar elemento")
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento sustituyepi( entero a[50], entero n1, carácter b[50], entero &n2)
entero: i
boolean: r
i0
Mientras (i < n1) hacer
Si (a[i] > 0) entonces
r  par(a[i])
Si (r) entonces
b[n2]  'p'
Sino
b[n2]  'i'
Fin_si
n2  n2 +1
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Función par(entero valor): booleano
// Definir variable
boolean: r
r  (valor Mod 2 = 0)
retornar r
Fin_función
Procedimiento imprimirVectorA(entero vector[50], entero numel)

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Procedimiento imprimirVectorB(caracter charvector[50], entero numel)

// Definir variable
entero: i
Escribir (charvector[i])
Fin_desde
Fin_procedimiento
Ejemplo 08: Pseudocódigo para obtener el instante de finalización de n procesos

mediante el algoritmo fcfs (first come, first served). El algoritmo ejecuta cada
proceso en el orden que llegue, el instante de finalización se obtiene sumando el
tiempo de ejecución.

Ejemplo:
Nombre proceso Tiempo ejecución Instante Finalización

A 3 3
B 5 8
C 2 10
D 6 16
E 4 20
El instante de finalización es:

a = 3, b = 8, c = 10, d = 16, e = 20

• Procedimiento ingresarVector(carácter proceso[100], entero t[100], entero &n)
permite ingresar datos al vector
• Procedimiento fcfs(caracter proceso[100], entero n1, entero t[100], entero
tf[100]), devuelve el vector tiempo final(tf).
• Procedimiento imprimirVector(caracter proceso[100], entero tf[100], entero n),
imprime el vector proceso y el vector tf.
Inicio
entero: n, t[100], tf[100]
caracter: proceso[100]
// Lectura de datos
ingresarVector(proceso, t, n)
// Proceso
fcfs(proceso, n, t, tf)
imprimirVector(proceso, tf, n)
Fin
Procedimiento ingresarVector (caracter proceso[100], entero t[100], entero &n)

// Definir variable
entero: i
Leer (n)
Escribir (“Ingresar proceso”)
Leer (proceso[i])
Escribir (“Ingresar Tiempo”)
Leer (t[i])
Fin_desde
Fin_procedimiento
Procedimiento fcfs(caracter proceso[100], entero n1, entero t[100], entero tf[100])

entero: i, s 0
s  s + t[i]
tf[i]  s
Fin_desde
Fin_procedimiento
Procedimiento imprimirVector(caracter proceso[100], entero tf[100], entero n)

// Definir variable
entero: i

Escribir(proceso[i], “ = ”, tf[i])
Fin_desde
Fin_procedimiento
Ejemplo 09: Pseudocódigo para intercalar los elementos de dos vectores

ordenados. Considerando los siguientes pasos:
• Si el elemento del vector a es igual al de b o viceversa:
o Se asigna el elemento del vector a o b a c
o Se leen los siguientes elementos del vector a y b.
• Si el elemento del vector a es menor que el elemento del vector b
o Se asigna el elemento del vector a a c
o Se lee el siguiente elemento del vector a
• Si el elemento del vector a es mayor que el elemento del vector b
o Se asigna el elemento del vector b a c
o Se lee el siguiente elemento del vector b
Por ejemplo, supongamos que tenemos dos vectores ordenados:
a[] = 1 2 5 7 9 11 14
b[] = 2 4 6 8 9 11 14 25 26
c[] = 1 2 4 5 6 7 9 11 14 25 26

• Función igual(entero pvalor1, entero pvalor2), devuelve un valor booleano, si
pvalor1 es igual a pvalor2 devuleve verdadero.
• Función infer(entero pvalor1, entero pvalor2), devuelve un valor booleano, es
verdadero si pvalor1 es menor que pvalor2.
• Procedimiento acaba(entero a[50] ,entero n1,entero c[50], entero i, entero
&n3), permite terminar los vectores a o b.
• Procedimiento merge(entero a[50] ,entero n1, entero b[50], entero n2, entero
c[50], entero &n3 ), obtiene el vector c, al intercalar los vectores a y b.
• Procedimiento imprimirVector(entero vector[50], entero num), imprime el
vector.
Inicio
entero: n1, n2, n3 0, a[50], b[50], c[50]
// Lectura de datos
ingresarVector (a, n1)
ingresarVector (b, n2)
// Proceso
merge (a, n1, b, n2, c, n3)
// impresiones
Escribir (“El vector A es”)
imprimirvector(a, n1)
Escribir(“El vector B es”)
Escribir(“El vector C es”)
Fin

// Definir variable
entero: i


Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento merge(entero a[50], entero n1, entero b[50], entero n2, entero
c[50], entero &n3)
entero: i, j
boolean: r
n3 0
i 0
j 0
Mientras (i < n1 and j < n2) Hacer
r  igual (a[i], b[j])
Si (r) entonces
c[n3]  a[i]
n3  n3 + 1
ii+1
jj+1
Sino
r  infer (a[i], b[j])
Si (r) entonces
c[n3]  a[i]
n3  n3 + 1
ii+1
Sino
c[n3]  b[j]
n3  n3 + 1
jj+1
Fin_si
Fin_si
Fin_mientras
// acaba a
acaba(a, n1, c, i, n3)
// acaba b
acaba(b, n2, c, j, n3)
Fin_procedimiento
Función igual(entero pvalor1, entero pvalor2) : booleano

// Definir variable
boolean: r
retornar r
Fin_función
Función infer(entero pvalor1, entero pvalor2) : booleano

// Definir variable
boolean: r
r  (pvalor1 < pvalor2)
retornar r
Fin_función
Procedimiento acaba(entero a[50], entero n1, entero c[50], entero i, entero &n3)

entero: x
xi
Mientras (x<n1) hacer
c[n3]  a[x]
n3  n3 + 1
xx+1
Fin_mientras
Fin_procedimiento
Procedimiento imprimirVector (entero vector[50], entero num)

// Definir variable
entero: i
Desde (i  0) hasta (i < num) con incremento 1 Hacer
Fin_desde
Fin_procedimiento
Ejemplo 10: Pesudocódigo para ingresar N números enteros a un vector, calcular

la suma de todos los números impares y el resultado de esta suma reemplazar al
menor número del vector.
Por ejemplo:
n=7
a[]= 7 3 14 26 4 18 9
La suma de los números impares es: 19

El menor número es: 3
El vector reemplazando es:
a[]= 7 19 14 26 4 18 9

• Procedimiento sumaPosi(entero a[50] , entero n1, entero &suma, entero &posi),
calcula la suma de los números impares y la posición del menor número dentro
del vector.
vector.
Inicio
entero: n1, suma  0, posi  0, a[50]
// Lectura de datos
// Proceso
sumaPosi(a, n1, suma, posi)
a[posi]  suma
Fin

// Definir variable
entero: i

Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento sumaPosi(entero a[50] , entero n1, entero &suma, entero &posi)

entero: i, m, s 0, k
m  a[0]
i0
Mientras (i < n1) Hacer
Si (a[i] Mod 2 = 1) entonces
Fin_si
Si (a[i] < m) entonces
m  a[i]
posi  i
Fin_si
i  i+1
Fin_mientras
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 11: Pseudocódigo donde se ingresa N y M números enteros a dos

vectores tal como A y B, luego se traslada todos los números impares tanto del
vector A como del vector B a un nuevo vector C.
Por ejemplo:
a[]= 7 3 14 26 9
b[]= 11 18 17 8 5 20 21
El vector C es:
c[]= 7 3 9 11 17 5 21

• Procedimiento intercala(entero d[50], entero n, entero c[50], entero &k), extrae
los números impares tanto del vector a como del vector b colocándolo en el
vector c.
vector.
Inicio
entero: n1, n2, k 0, a[50], b[50], c[50]

// Lectura de datos
ingresarVector (b, n2)
// proceso
intercala(a, n1, c, k)
intercala(b, n2, c, k)
imprimirVector(c, k)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento intercala(entero d[50], entero n, entero c[50], entero &k)

// Definir variable
entero: i
Si (d[i] Mod 2 = 1) entonces
c[k]  a[i]
k  k+1
Fin_si
Fin_desde
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 12: Pesudocódigo que intercambia el primer número múltiplo de 3 por el

último número par de un vector de N elementos. En caso no exista ningún número
múltiplo de 3 mostrar un mensaje correspondiente.
Por ejemplo:
a[]= 11 3 14 26 5 40 18 9
Primer número multiplo de 3: 3

Ultimo número par:18
a[]= 11 18 14 26 5 40 3 9


• Función multiplo(entero a[50], entero n1, entero val), encuentra el primer

múltiplo de 3 y el último número par del vector.
• Procedimiento intercambio(entero a[50], entero r1, entero r2), intercambia el
primer múltiplo de 3 con el último número par del vector.
vector.
Inicio
// Definir e inicializar variables y vector
entero: n1, r1, r2, k  0, a[50]
// Lectura de datos
r1  multiplo(a, n1, 3)
Si (r1 >= 0) entonces
r2  multiplo(a, n1, 2)
intercambio(a, r1, r2)
Sino
Escribir (“No tiene múltiplo de tres”)
Fin_si
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Función multiplo(entero a[50], entero n1, entero val) : entero

entero: i, posi
Si (a[i] Mod val = 0) entonces
posi  i
Si (val = 3)
i  n1
Fin_si
Fin_si
Fin_desde
retornar posi
Fin_función
Procedimiento intercambio(entero a[50], entero r1, entero r2)

// Definir variable
entero: temp
temp  a[r1]
a[r1] a[r2]
a[r2]  temp
Fin_procedimiento

// Definir variable

entero: i
Fin_desde
Fin_procedimiento
Ejemplo 13: Pesudocódigo que calcula el promedio entero del mayor y el menor
número de un vector y reemplazar este resultado a todos los números pares del
vector.
a[]= 7 3 14 31 4 18 9
Menor elemento = 3
Mayor elemento = 31
Promedio del mayor y el menor elemento del vector: (31 + 3) Div 2 = 17
a[]= 7 3 17 31 17 17 9

• Procedimiento mayorMenor(entero a[50], entero n1, entero &mayor, entero
&menor), calcula el mayor y el menor número del vector.
• Procedimiento reemplazaVector(entero a[50], entero n1, entero p), reemplaza
el promedio del mayor y el menor número del vector a todos los números pares.
vector.
Inicio
entero: n1, p, mayor  0, menor  0, a[50]
// Lectura de datos
mayorMenor(a, n1, mayor, menor)
p  (mayor+menor) Div 2
reemplazaVector(a, n1, p)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento mayorMenor(entero a[50], entero n1, entero &mayor, entero

&menor)
entero: i, m, n
mayor  a[0]
menor  a[0]

i0
mayor  a[i]
Fin_si
menor  a[i]
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Procedimiento reemplazaVector(entero a[50], entero n1, entero p)

// Definir variable
entero: i
Si (a[i] Mod 2 = 0) entonces
a[i]  p
Fin_si
Fin_desde
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 14: Pseudocódigo en el que se ingresa N y M números enteros a dos

vectores tal como A y B, si el vector A tiene más elementos que el vector B, al final
del vector B, trasladar la cantidad de elementos necesarios para que tenga el
mismo tamaño que el vector A, en el caso de que el vector B tiene mas elementos
que el vector A, realizar lo contrario.
Por ejemplo:
a[]= 7 3 14 26 9 20 21
b[]= 11 18 17 13
El vector C es:
b[]= 11 18 17 13 7 3 14

• Procedimiento empareja(entero a[50], entero &n1, entero b[50], entero &n2,
entero d) obtiene un array a o b con el mismo numero de elementos
vector.
Inicio
entero: n1, n2, d, a[50], b[50]
// Lectura de datos

// Lectura de datos
// proceso
Si (n1 = n2) entonces
Escribir (“Vectores con los mismos elementos”)
Sino
Si (n1>n2) entonces
d  n1-n2
empareja(a, n1, b, n2, d)
Sino
d  n2-n1
empareja(b, n2, a, n1, d)
Fin_si
imprimirVector(a,n1)
imprimirVector(b,n2)
Fin_si
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento empareja(entero a[50], entero &n1, entero b[50], entero &n2,

entero d)
// Definir variable
entero: i
Desde (i  0) hasta (i < d) con incremento 1 Hacer
b[n2]  a[i]
n2  n2 + 1
Fin_desde
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 15. Pseudocódigo para insertar un elemento en un vector indicando la

posición (indice). La inserción no debe realizarse sobre el mismo vector sino sobre
otro vector.
Para este caso se siguen los siguientes pasos:
• Se lee el vector original grabando los elementos leídos sobre el nuevo vector,
mientras el índice i del vector original sea menor a la posición a insertar.
• Cuando alcanza el índice i del vector original a la posición se graba el elemento a
insertar sobre el nuevo vector.

• Se continúa grabando los elementos restantes del vector original sobre el nuevo
vector.
• Finalmente se obtiene el nuevo vector con todos los elementos del vector original
más el valor insertado.
Por ejemplo:
Sea el vector a:
a[]= 1 2 13 24 26
Insertar el valor: 20
En la posición: 2
Se obtine:
b[]= 1 2 20 13 24 26

• Procedimiento ingresarDatos(entero &val, entero &pos), permite ingresar el valor
que se va a insertar en el vector y la posición donde se insertará.
• Procedimiento insertarPosi(entero a[50], entero n1, entero posi, entero
valInsertar, entero b[50]), obtiene el vector b.
vector a y el vector b.
Inicio
entero: n1, valInsertar, posi, a[50], b[50]
ingresarDatos(valInsertar, posi)
insertarPosi(a, n1, posi, valInsertar, b)
// impresiones
Escribir(“Vector A”)
Escribir (“Insertar posición”, posi )
Escribir (“Valor a insertar”,valInsertar)
Escribir (“Vector B”)
imprimirVector (b, n1+1)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento ingresarDatos(entero &val, entero &pos)

Escribir (“Ingresar valor a insertar:”)
Leer (val)
Escribir (“Ingresar posición:”)
Leer (pos)
Fin_procedimiento

Procedimiento insertarPosi (entero a[50] , entero n1, entero posi , entero

valInsertar, entero b[])
entero: i , k  0
i0
Mientras (i < posi) Hacer
b[k]  a[i]
kk+1
i  i +1
Fin_mientras
Si (i = posi) entonces
b[k]  valInsertar
k  k+1
b[k]  a[i]
kk+1
i  i+1
Fin_mientras
Fin_si
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 16: Pseudocódigo para eliminar un elemento de un vector ingresando su

valor.
La eliminación consiste en buscar un valor específico a eliminar.
La eliminación se realiza sobre el mismo vector.
Por ejemplo:
Sea el vector a:
a[]= 1 2 13 24 26
Valor a eliminar: 24
Se obtiene:
a[]= 1 2 13 26

• Procedimiento ingresarVector (entero a[50], entero &n), permite ingresar
• Procedimiento ingresarDatos(entero &val), permite ingresar la posición (indice)
del valor que se va a eliminar.
• Procedimiento suprimirValor(entero a[50] , entero &n1, entero valor, entero
b[50], entero &sw), obtiene los valores actualizados del vector a.
• Función igual(int v, int valor), devuelve un valor booleano verdadero.
• Procedimiento imprimirVector(entero vector[50], entero num), imprime el vector
original y el nuevo vector
Inicio
entero: n1, valor, sw  0, a[50], b[50]

ingresarDatos(valor)
suprimirValor(a, n1, valor , b, sw)
// impresiones
Escribir (“Vector A”)
Escribir (“Valor a eliminar ”, valor)
Si (sw = 1)
Escribir (“Nuevo vector A”)
Sino
Escribir (“El valor no existe dentro del vector”)
Fin_si
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento ingresarDatos(entero &val)

Escribir (“Ingresar valor a eliminar:”)
Leer (val)
Fin_procedimiento
Procedimiento suprimirValor(entero a[50], entero &n1, entero valor, entero b[50],

entero &sw)
entero: i, posi
booleano: r
r  igual (a[i], valor)
Si (r) entonces
posi = i
sw = 1
Fin_si
Fin_desde
Desde (i  posi) hasta (i < n) con incremento de 1 Hacer
a[i] = a[i+1]
Fin_desde
n1  n1 - 1
Fin_procedimiento
Función igual(int v, int valor) : boolean

// Definir variable
boolean: r
r  (v = valor)
retornar r
Fin_función

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
Ejemplo 17: Pseudocódigo para encriptar datos mediante el método de César.
Método de César: Consiste en reemplazar en el mensaje a enviar cada letra por la

letra situada tres posiciones hacia delante del alfabeto latino, aplicando a este
nuevo valor el residuo de la división entre 26.
Dentro del alfabeto no se considera la letra ñ.
a b c d e f g h i j k l m n o p q r s t u v w x y z
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Podemos cifrar el método de César con la siguiente fórmula:

E = (y + k) Mod 26
Donde:
E: el mensaje cifrado
y: la posición en el alfabeto
k: un valor constante 3
Por ejemplo, si encriptamos:
Texto: un aguila no caza moscas

Cifrado: xq djxlod qr fdcd prvfdv
Se siguieron los siguientes pasos:

Para la letra u
E = (20+3) Mod 26 = 23 mod 26 =23 x
Para la letra n
E = (13+3) Mod 26 = 16 Mod 26 =16 q
Para la letra a
E = (0+3) Mod 26 = 3 Mod 26 =3 d
….
Para la letra s
E = (18+3) Mod 26 = 21 Mod 26 =21 v

• Procedimiento cesar(caracter letras[],caracter cadena[]) convierte el vector de
cadena en una vector cadena encriptada
Notas:
• Una cadena de caracteres se guarda como un vector almacenándose cada
carácter en una posición diferente. Asi tenemos:
letras[]  “abcdefghijklmnopqrstuvwxyz”
• longitud(cadena), es um módulo definido (no necesita ser implementado) que

calcula la cantidad de caracteres que tiene la cadena.
• Cada carácter del alfabeto tiene un correspondiente valor en código ASCCII, las
letras minúsculas varian de 97 a 122, de esta manera el carácter ‘a’ = 97, ‘b’ =
98, etc. De esta manera se puede efectuar cualquier operación entre caracteres,
como por ejemplo:
car  ‘d’ - 2

Para car de tipo caracter se obtiene ‘b’.

Para car de tipo entero se obtine 98.
Inicio
// Inicializar cadenas
caracter: letras[]  “abcdefghijklmnopqrstuvwxyz”
caracter: cadena[80]
Escribir (“Ingrese cadena”)
Leer (cadena)
cesar(letras, cadena)
Escribir (“La cadena encriptada ”, cadena)
Fin
Procedimiento cesar(caracter letras[80], caracter cadena[80])

entero: i, posi  0, k  3, r
i0
r  longitud(cadena)
Mientras (i < r) Hacer
Si (cadena[i] <> ' ') entonces
posi  (cadena[i] - 'a' + k) Mod 26
cadena[i]  letras[posi]
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Ejemplo 18: Pseudocódigo para sumar los números positivos y negativos de una
matriz de N filas y M columnas.
Por ejemplo:
-1 2 3
a[][]= 4 -5 6
7 -8 9
Suma de positivos = 31
Suma de negativos = -14

• Procedimiento ingresarMatriz (entero a[50][50], entero &fila, entero &columna),
permite ingresar números enteros a la matriz.
• Procedimiento sumaMatriz(entero a[50][50], entero fila, entero columna, entero
&positivo, entero &negativo) obtiene la suma de los números positivos y
negativos.
• Procedimiento imprimirMatriz(entero a[50][50], entero nrofilas, entero
nrocolumnas), imprime el contenido de la matriz.
Inicio
// Definir e inicializar variables y matriz
entero: fila, columna, a[50][50], positivo 0, negativo 0
ingresarMatriz(a, fila, columna)
sumaMatriz(a, fila, columna, positivo, negativo)
imprimeMatriz(a, fila, columna)
Escribir (“Suma positiva ", positivo)
Escribir(“Suma negativa", negativo)
Fin

Procedimiento ingresarMatriz (entero a[50][50], entero &fila, entero &columna)

entero: i, j
Leer (fila)
Leer (columna)
Desde (i  0) Hasta (i < fila) con incremento 1 Hacer
Desde (j  0) Hasta (j < columna) con incremento 1 Hacer
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento sumaMatriz(entero a[50][50], entero fila, entero columna,

entero &positivo, entero &negativo)
entero: i, j
Desde ( i  0) hasta (i < fila) con incremento 1 Hacer
Desde ( j  0) hasta (j < columna) con incremento 1 Hacer
Si (a[i][j] >= 0) entonces
positivo  positivo + a[i][j]
Sino
negativo  negativo + a[i][j]
Fin_si
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero nrofilas, entero

nrocolumnas)
entero: i, j
Desde (i  0) hasta (i < nrofilas) con incremento 1 Hacer
Desde (j  0) hasta (j < nrocolumnas) con incremento 1 Hacer
Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 19: Pseudocódigo para realizar la transpuesta de una matriz cuadrada. La

matriz transpuesta cambia las filas por las columnas.
Por ejemplo:
1 2 3
a[][]= 4 5 6
7 8 9
Al realizar la transpuesta obtenemos:
1 4 7
a[][]= 2 5 8
3 6 9


• Procedimiento transpuesta(entero a[50][50], entero fila, entero columna),
obtiene la matriz transpuesta de a.
nrocolumnas), imprime el contenido de la matriz.
Inicio
entero: fila, columna, a[50][50]
transpuesta(a, fila, columna)
imprimirMatriz(a, fila, columna)
Fin

entero: i, j
Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento transpuesta(entero a[50][50], entero fila, entero columna)

entero: i, j
Desde (j  i+1) hasta (j < columna) con incremento 1 Hacer
aux  a[i][j]
a[i][j]  a[j][i]
a[j][i]  aux
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero nrofilas, entero

nrocolumnas)
entero: i, j
Desde (i  0) hasta (i < nrofilas) con incremento 1 Hacer
Desde (j  0) hasta (j < nrocolumnas) con incremento 1 Hacer
Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 20: Pseudocódigo que visualice un cuadrado mágico. Un cuadrado mágico

es un conjunto de números almacenados en celdas de una matriz cuadrada, de tal

modo que la suma de cada una de sus filas, de cada una de sus columnas y de
cada una de sus diagonales dé el mismo resultado.
Los números almacenados están comprendidos entre 1 y n2 . Para situar estos
números se sigue el siguiente algoritmo.
1. Colocar el número 1 en el centro de la primera fila

2. El siguiente número que es 2, debe colocarse encima y a la derecha del número
que acaba de ser situado.
3. Si al hacer esto se sale de los limites de la matriz por la parte superior o por la
derecha, la fila encima de la primera es la ultima fila y la ultima columna a la
derecha es la primera columna.
4. Cuando al situar un número su celda ya esta ocupada, se elige la celda situada
por debajo del número que acaba de ser previamente situado.
5. Del mismo modo se procede con los siguientes números 3, 4, 5, …, 9.
Ejemplo: Si queremos formar un cuadrado mágico de orden 3, entonces la matriz

será de orden 3*3 y los números consecutivos a almacenar estarán comprendidos
entre 1 y n2 , es decir del 1 al 9.
El número 1 se coloca en el centro de la primera fila:
Colocar el número 2, encima y a la derecha, como nos salimos del límite del
cuadrado, colocamos el número 2 en la posición correspondiente dentro de la
última fila. (paso 3)
El siguiente número (el numero 3), encima y a la derecha, pero como nos salimos
del limite del cuadrado, la ultima columna a la derecha es la primera columna.
(paso 3)
1
3
2
El siguiente número (el numero 4), encima y a la derecha, pero como esta
ocupada, se coloca el número 4 debajo del numero 3. (paso 4)
1
3
4 2
y así sucesivamente, obteniendo finalmente:
8 1 6
3 5 7
4 9 2


• Función impar(entero n), devuelve un valor booleano verdadero o falso verifica
si n es impar, si es verdadero el valor del parámetro es impar.
• Procedimiento magico(entero cuadrado[50][50], entero n), construye el
cuadrado mágico
• Procedimiento imprimirCuadrado(entero cuadrado[50][50], entero n) imprime el
cuadrado mágico
Inicio
// Definir e inicializar variables y matrices
entero: n, cuadrado[15][15]
boolean: r  verdadero
Repetir
// Leer variable
Escribir (“Ingresar tamaño del cuadrado mágico”)
Leer (n)
r  impar(n)
hasta_que (r)
magico (cuadrado, n)
imprimirCuadrado (cuadrado, n)
Fin
Procedimiento imprimirCuadrado (entero cuadrado[50][50], entero n)

// Definir variable
entero: i, j
Desde (i  0) hasta (i < f) con incremento 1 Hacer
Desde (j  0) hasta (j < c) con incremento 1 Hacer
Escribir (cuadrado[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Función impar (entero n) : booleano

Si (n >= 3 and n <= 13) entonces
Si (n Mod 2 <> 0) entonces
retornar verdadero // es impar
Sino
retornar falso // es par
Fin_si
Sino
Escribir (“No esta entre 3 y 11”)
retornar verdadero
Fin_si
Fin_función
Procedimiento magico(entero cuadrado[50][50], entero n)

entero: m, a, b, i  0, j  (n / 2), k
mn*n
Desde (k  1) hasta (k <= m) con incremento 1 Hacer
// guardar la posicion actual
ai
b j
// colocar el numero
cuadrado[i][j]  k
// Avanzar a la parte superior
Si ( i = 0 ) entonces

i  n-1
Sino
i  i-1
Fin_si
// Ir a la dercha
Si ( j = n-1 ) entonces
j0
Sino
jj+1
Fin_si
// verificar si esta ocupado
Si (cuadrado[i][j]>=1) entonces
// Poner abajo del numero
Si ( a = n-1 ) entonces
a0
Sino
a a + 1
Fin_si
// Coloca la nueva posicion debajo del número que se ha puesto antes
ia
jb
Fin_si
Fin_desde
Fin_procedimeinto

1. Se ejecuta el módulo principal y se llama al módulo impar ( ).
2. El módulo impar( ) verifica que el valor del orden del cuadrado mágico esta
en el rango de 3 a 13 y que sea impar.
3. Se llama al módulo mágico( ) que forma el cuadrado mágico
4. El módulo imprimirCuadrado( ) muestra en la pantalla el cuadrado mágico.
5. Finalmente se obtiene el resultado.
• Operaciones con matrices
a) Suma de matrices
Para sumar dos matrices A y B, estas deben de tener el mismo número de filas
y columnas, el resultado de la suma es una matriz C, que tendrá el mismo
número de filas y columnas de A y B. Ejemplo:
a[][] b[][] c[][]

3 6 8 8 4 5 11 10 13
7 5 1 + 1 2 7 = 8 7 8
2 4 9 6 9 3 8 13 12
3 1 2 10 2 4 13 3 6
Proceso de la suma
La primera fila, se obtiene con las siguientes operaciones
• c[0][0]  a[0][0] + b[0][0] 11 = 3 + 8
• c[0][1]  a[0][1] + b[0][1] 10 = 6 + 4
• c[0][2]  a[0][2] + b[0][2] 13 = 8 + 5
La segunda fila, se obtiene con las siguientes operaciones

• c[1][0]  a[1][0] + b[1][0] 8=7+1
• c[1][1]  a[1][1] + b[1][1] 7=5+2
• c[1][2]  a[1][2] + b[1][2] 8=1+7

La tercera fila, se obtiene con las siguientes operaciones

• c[2][0]  a[2][0] + b[2][0] 8=2+6
• c[2][1]  a[2][1] + b[2][1] 13 = 4 + 9
• c[2][2]  a[2][2] + b[2][2] 12 = 9 + 3
La cuarta fila, se obtiene con las siguientes operaciones

• c[3][0]  a[3][0] + b[3][0] 13 = 3 + 10
• c[3][1]  a[3][1] + b[3][1] 3=1+2
• c[3][2]  a[3][2] + b[3][2] 6=2+4
Ejemplo 21: Pseudocódigo para realizar la suma de dos matrices.

• Procedimiento sumaMatriz(entero a[50][50], entero t[50][50], entero
c[50][50], entero fila, entero columna), realiza la suma de las matrices a y b
obteniendo la matriz c
• Procedimiento imprimeMatriz(entero a[50][50], entero b[50][50], entero
c[50][50], entero fila, entero columna), imprime la matrices a, b y c utilizando
el módulo imprimirFila()
• Procedimiento imprimirFila(entero a[50][50], entero i, entero columna),
imprime las matrices a, b y c fila a fila.
// Variables globales
entero: i, j
Inicio
entero: fila, columna, a[50][50], b[50][50], c[50][50]
// Lectura de datos
ingresarMatriz (a, fila, columna)
ingresarMatriz (b, fila, columna)
// Proceso
sumaMatriz (a, b ,c , fila , columna)
Escribir (“ Suma de Matrices ”)
Escribir (“Matriz A Matriz B Matriz C”)
imprimirMatriz(a, b, c , fila, columna)
Fin
Procedimiento ingresarMatriz(entero a[50][50], entero &fila, entero &columna)

Leer (fila)
Leer (columna)
Desde (j  0) hasta (j< columna) con incremento 1 Hacer
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento sumaMatriz(entero a[50][50], entero b[50][50], entero

c[50][50], entero fila, entero columna)


c[i][j]  a[i][j]+ b[i][j]
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50] , entero b[50][50], entero

imprimirFila(a, i, columna)
imprimirFila(b, i, columna)
imprimirFila(c, i, columna)
Fin_desde
Fin_procedimeinto
Procedimiento imprimirFila(entero a[50][50], entero i, entero columna)

Escribir (a[i][j])
Fin_desde
Fin_procedimiento

1. Se ejecuta el módulo principal, donde se ingresa la matriz a y b, se define la
matriz c.
2. Se llama al módulo sumaMatriz (a, b, c, fila, columna) para obtener la matriz c
que es la suma de las matrices a y b
3. Se llama al módulo imprimirMatriz( a, b, c, fila, columna) para imprimir las
matrices a, b y c. Dentro de este módulo, se llama al módulo imprimirFila() tres
veces:
• La primera vez el módulo imprimirFila(a, i, columna) imprime la fila
correspondiente a la matriz a
• La segunda vez el módulo imprimirFila(b, i, columna) imprime la fila
correspondiente a la matriz b
• La tercera vez el módulo imprimirFila(c, i, columna) imprime la fila
correspondiente a la matriz c
4. Se obtiene el resultado siguiente:
Suma de Matrices
Matriz A Matriz B Matriz C
3 6 8 8 4 5 11 10 13
7 5 1 1 2 7 8 7 8
2 4 9 6 9 3 8 13 12
3 1 2 10 2 4 13 3 6
b) Multiplicación de matrices
Para multiplicar dos matrices A y B, el número de filas de A debe de ser igual al
número de columnas de B
La matriz resultante C, tendrá tanto filas como A y tantas columnas como B.
Ejemplo:
a[][] b[][] c[][]

3 2 1 1 3 2 14 16 17
5 6 7 * 4 2 5 = 50 48 47
1 4 8 3 3 1 41 35 30
Proceso de la multiplicación

La primera fila de C
• La primera celda de C, se obtiene multiplicando la primera fila de A por la
primera columna de B uno a uno con las siguientes operaciones
c[0][0] = a[0][0] * b[0][0] + a[0][1] * b[1][0] + a[0][2] * b[2][0] =
3*1+2*4+1*3 = 14
• La segunda celda de C, se obtiene multiplicando la primera fila de A por la
segunda columna de B uno a uno con las siguientes operaciones
c[0][1] = a[0][0] * b[0][1] + a[0][1] * b[1][1] + a[0][2] * b[2][1] =
3*3+2*2+1*3 = 16
• La tercera celda de C, se obtiene multiplicando la primera fila de A por la
tercera columna de B uno a uno con las siguientes operaciones
c[0][2] = a[0][0] * b[0][2] + a[0][1] * b[1][2] + a[0][2] * b[2][2] =
3*2+2*5+1*1 = 17
La Segunda fila de C
• La primera celda de la segunda fila de C, se obtiene multiplicando la
segunda fila de A por la primera columna de B uno a uno con las siguientes
operaciones
c[1][0] = a[1][0] * b[0][0] + a[1][1] * b[1][0] + a[1][2] * b[2][0] =
5*1+6*4+7*3 = 50
• La segunda celda de la segunda fila de C, se obtiene multiplicando la
segunda fila de A por la segunda columna de B uno a uno con las siguientes
operaciones
c[1][1] = a[1][0] * b[0][1] + a[1][1] * b[1][1] + a[1][2] * b[2][1] =
5*3+6*2+7*3 = 48
• La tercera celda de la tercera fila de C, se obtiene multiplicando la segunda
fila de A por la tercera columna de B uno a uno con las siguientes
operaciones
c[1][2] = a[1][0] * b[0][2] + a[1][1] * b[1][2] + a[1][2] * b[2][2] =
5*2+6*5+7*1 = 47
y así sucesivamente, se multiplica fila por columna hasta obtener la matriz c
Ejemplo 22: Pseudocódigo para calcular el producto de matrices.

• Procedimiento multiplicaMatriz(entero a[50][50], entero b[50][50], entero
c[50][50] ,entero fila, entero columna ), realiza el producto de las matrices a y
b obteniendo la matriz c.
• Procedimiento imprimeMatriz(entero a[50][50],entero b[50][50], entero
c[50][50], entero fila, entero columna), imprime la matrices a, b y c utilizando
el módulo imprimirFila( ).
• Procedimiento imprimirFila(entero a[50][50], entero i, entero columna),
imprime las matrices a, b y c fila por fila.
entero: i, j
Inicio
entero: fila, columna, a[50][50], b[50][50], c[50][50]
// Lectura de datos
// Proceso

multiplicaMatriz (a, b, c, fila, columna)

Escribir (“ Multiplicación de matrices ”)
Escribir (“Matriz A Matriz B Matriz C”)
imprimirMatriz (a, b, c, fila, columna)
Fin

Escribir (“Ingresar cantidad de filas de la matriz:")
Leer (fila)
Escribir ("Ingresar cantidad de columnas de la matriz:")
Leer (columna)
Desde (i  0) hasta (i< fila) con incremento 1 Hacer
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento multiplicaMatriz(entero a[50][50], entero b[50][50], entero

entero: t  0, k
Desde (k 0) hasta (k<columna) con incremento 1 Hacer
t  t + a[i][k]* b[k][j]
Fin_desde
c[i][j] t
t0
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50] , entero b[50][50], entero

imprimirFila(a, i, columna)
imprimirFila(b, i, columna)
imprimirFila(c, i, columna)
Fin_desde
Fin_procedimeinto
Procedimiento imprimirFila(entero a[50][50], entero i, entero columna)

Escribir (a[i][j])
Fin_desde
Fin_procedimiento

1. Se ejecuta el módulo principal, donde se ingresa la matriz a y b, se define la
matriz c.
2. Se llama al módulo multiplicaMatriz(a, b, c, fila, columna) para obtener la
matriz c que es el producto de las matrices a y b

3. Se llama al módulo imprimirMatriz(a, b, c, fil, columna) para imprimir las

matrices a, b y c. Dentro de este módulo, se llama al módulo imprimir() tres
veces:
• La primera vez el módulo imprimirFila(a, i, columna) imprime la fila
correspondiente a la matriz a
• La segunda vez el módulo imprimirFila( b, i, columna) imprime la fila
correspondiente a la matriz b
• La tercera vez el módulo imprimirFila( c, i, columna) imprime la fila
correspondiente a la matriz c
4. Se obtiene el resultado siguiente:
Multiplicacion de Matrices
Matriz A Matriz B Matriz C

3 2 1 1 3 2 14 16 17
5 6 7 4 2 5 50 48 47
1 4 8 3 3 1 41 35 30
Ejemplo 23: Pseudocódigo para intercambiar las columnas de una matriz, el

intercambio se hará entre la primera y la última columna, la segunda y la
penultima, y asi sucesivamente. Por ejemplo:
Si se tiene: Se obtiene:
1 7 9 8 10 17 17 10 8 9 7 1
a[][]= 13 2 4 25 6 22 a[][]= 22 6 25 4 2 13
4 0 5 12 15 20 20 15 12 5 0 4

• Procedimiento interCambio(entero a[50][50],entero fila, entero columna),
realiza el intercambio de las columnas correspondientes
• Procedimiento imprimirMatriz(entero a[50][50], entero fila, entero columna)
imprime el contenido de la matriz
entero: i, j
Inicio
// Lectura de datos
imprimeMatriz (a, fila, columna)
interCambio (a, fila, columna)
Fin
Procedimiento ingresarMatriz(entero a[50][50], entero &fila, entero &columna)

Leer (fila)
Leer (columna)


Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento interCambio(entero a[50][50], entero fila, entero columna)

entero: t, k  columna-1
Si (i< k) entonces
t  a[j][i]
a[j][i]  a[j][k]
a[j][k]  t
Fin_si
Fin_desde
kk-1
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero fila, entero columna)

Escribir (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero fila, entero columna)

Escribir (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 24: Pseudocódigo para ingresar números enteros a un vector de tamaño

M y a una matriz de N filas y M columnas, luego sumar los elementos
correspondientes de la fila que contengan al menor valor con los elementos del
vector y mostrar el resultado en un nuevo vector.
Por ejemplo:
7 10 5 12
15 3 13 4
a[] = 10 2 18 7 b[][] = 6 22 4 16
9 14 23 9
17 21 8 11
Menor valor de la matriz = 3 (corresponde a la fila 2)

El vector suma es :
c[] = 25 5 31 11

• Procedimiento ingresarVector(entero x[50], entero &n), permite ingresar

numeros enteros al vector.
• Función buscaPosi(entero b[50][50],entero fila, entero columna) , devuelve un
numero entero que representa la posición de la fila que contiene el elemento
menor de la matriz
• Procedimiento sumar(entero a[50], entero b[50][50], entero posi, entero
columna, entero c[50]), calcula la suma de los elementos del vector con los
elementos de la fila posi de la matriz y lo guarda en un nuevo vector c.
nrocolumnas) imprime el contenido de la matriz
• Procedimiento Procedimiento imprimirVector (entero vector[50], entero num),
imprime el contenido del vector
entero: i, j
Inicio
// definir e inicializar variables y matrices
entero: n1, posi, fila, columna, a[50], b[50][50]
imprimirVector (a, n1)
imprimeMatriz (b, fila, columna)
posi  buscaPosi (b, f ila, columna)
sumar (a, b, posi, columna, c)
imprimirVector (c, n1)
Fin
Procedimiento ingresarVector(entero x[50], entero &n)

Leer (n)
Leer (x[i])
Fin_desde
Fin_procedimiento

Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Función buscaPosi(entero b[50][50],entero fila, entero columna) : entero

entero: m, posi
m  b[0][0]


if (b[i][j] < m) entonces
m  b[i][j]
posi  i
Fin_si
Fin_desde
Fin_desde
retornar posi
Fin_función
Procedimiento sumar(entero a[50], entero b[50][50], entero posi, entero

columna, entero c[50])
// Definir variable
entero: temp
Desde (i  0) hasta (i < columna) con incremento 1 Hacer
c[i]  b[posi][i] + a[i]
Fin_desde
Fin_procedimiento
Procedimiento imprimirVector(entero vector[50], entero num)

Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero filas, entero columnas)

Desde (i  0) hasta (i < filas) con incremento 1 Hacer
Desde (j  0) hasta (j < columnas) con incremento 1 Hacer
Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 25: Pseudocódigo que permita intercambiar los elementos de una fila y
una columna determinada, de una matriz cuadrada.
Por ejemplo:
N=5
Fila = 2, columna = 2
6 12 18 4 21 6 10 18 4 21
10 7 9 14 2 12 7 16 11 3
a[][]= 13 16 20 3 17 a[][]= 13 9 20 3 17
5 11 22 1 15 5 14 22 1 15
23 3 19 8 12 23 2 19 8 12

• Procedimiento interFilaColumna(entero a[50][50],entero posiFila, entero
posiColumna, entero columna), intercambia la fila y columna de una matriz
entero: i, j

Inicio
entero: posiFila, posiColumna, fila, columna, a[50][50]
Escribir ("Ingrese fila a cambiar")
Leer (posiFila)
Escribir ("Ingrese columna cambiar")
Leer (posiColumna)
interFilaColumna(a, posiFila, posiColumna, columna)
Fin

Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento interFilaColumna(entero a[50][50],entero posiFila, entero

posiColumna, entero columna)
entero: temp
Desde (i 0) hasta (i< columna) con incremento 1 Hacer
temp  a[posiFila-1][i]
a[posiFila-1][i]  a[i][posiColumna-1]
a[i][posiColumna-1]  temp
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero filas, entero columnas)

Desde (i  0) hasta (i < filas) con incremento 1 Hacer
Desde (j  0) hasta (j < columnas) con incremento 1 Hacer
Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 26. Pseudocódigo que pasar a un vector todos los elementos de una
matriz de tamaño N * M que forman la letra O.
9 4 11 15 6
a[][]= 2 16 19 1 17
13 10 5 18 8
7 14 20 3 12
b[]= 9 4 11 15 6 2 17 13 8 7 14 20 3 12


• Procedimiento letraO(entero a[50][50], entero fila, entero columna, entero
b[50], entero &k), traslada los elementos que forman la letra O a un nuevo
vector b.
• Procedimiento imprimeMatriz(entero a[50][50], entero fila, entero columna)
imprime el contenido de la matriz.
• Procedimiento imprimeVector(entero vector[50], entero k), imprime el
entero: i, j
Inicio
entero: fila, columna, a[50][50], b[50], k 0
letraO(a, fila, columna, b, k)
imprimeVector(b, k)
Fin

Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimeMatriz(entero a[50][50], entero fila, entero columna)

Escribir (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento letraO(entero a[50][50], entero fila, entero columna, entero

b[50], entero &k)
Si ((i = 0) or (i = fila - 1))
b[k]  a[i][i]
kk+1
Sino
Si ((j = 0) or (j = columna - 1))
b[k]  a[i][i]
kk+1
Fin_si
Fin_si

Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimeVector(entero vector[50], entero k)

Desde (i  0) hasta (i < k) con incremento 1 Hacer
Fin_desde
Fin_procedimiento
Ejemplo 27. Pseudocódigo para intercambiar los contenidos del menor y el mayor
número de cada columna de una matriz de tamaño N * M.
Por ejemplo:
N=5
M=4
6 10 18 11
12 2 22 4
a[][]= 13 9 20 1
5 14 19 3
23 7 16 8
Al intercambiar el mayor elemento con el menor elemento de cada columna se

tiene:
6 10 18 1
12 14 16 4
a[][]= 13 9 20 11
23 2 19 3
5 7 22 8

• Procedimiento interMayorMenor(entero a[50][50], entero fila, entero columna),
intercambia el mayor elemento con el menor elemento de cada columna de la
matriz.
• Procedimiento imprimirMatriz(entero a[50][50], entero nfilas, entero
ncolumnas), imprime el contenido de la matriz.
entero: i, j
Inicio
interMayorMenor (a, fila, columna)
Fin

Leer (fila)
Leer (columna)


Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento interMayorMenor(entero a[50][50], entero fila, entero columna)

entero: m, n, pm, pn, temp
m  a[0][0]
n  a[0][0]
Si (a[i][j] > m) entonces
m  a[i][j]
pm  i
Fin_si
Si (a[i][j] < n) entonces
n  a[i][j]
pn  i
Fin_si
Fin_Desde
temp  a[pn][j]
a[pn][j]  a[pm][j]
a[pm][j]  temp
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero nfilas, entero ncolumnas)

Desde (i  0) hasta (i < nfilas) con incremento 1 Hacer
Desde (j  0) hasta (j < ncolumnas) con incremento 1 Hacer
Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 28. Pseudocodigo para intercambiar los elementos de la diagonal principal

y diagonal secundaria de una matriz cuadrada
Por ejemplo:
6 10 18 4 21
12 7 16 11 3
a[][]= 13 9 20 3 17
5 14 50 1 15
23 2 19 8 12
Elementos de la diagonal principal: 6, 7, 20, 1, 12

Elementos de la diagonal secundaria: 21, 11, 20, 14, 23
Al intercambiar obtenemos:
21 10 18 4 6
12 11 16 7 3
a[][]= 13 9 20 3 17
5 1 50 14 15
12 2 19 8 23


• Procedimiento cambiaDiagonal(entero a[50][50], entero fila), permite cambiar
la diagonal principal con la diagonal secundaria.
• Procedimiento imprimirMatriz(entero a[50][50], entero nfilas, entero
ncolumnas), imprime el contenido de la matriz.
entero: i, j
Inicio
cambiaDiagonal(a, fila)
Fin
Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento cambiaDiagonal(entero a[50][50], entero fila)

entero: k, temp
k  fila – 1
Desde (i  0) Hasta (i<fila) con incremento 1 Hacer
temp  a[i][i]
a[i][i]  a[i][k]
a[i][k]  temp
kk–1
fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero a[50][50], entero nfilas, entero ncolumnas)

Escribir(a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 29: Pseudocódigo permite ingresar números enteros a una matriz

cuadrada y guarda los elementos de la matriz triangular superior en un vector y los
elementos de la matriz triangular inferior en otro vector.

Por ejemplo:
1 2 3 4 5
6 7 8 9 10
a[][]= 11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
a[]= 2 3 4 5 8 9 10 14 15 20
b[]= 6 11 12 16 17 18 21 22 23 24
Recuerde que las matrices cuadradas tienen ciertas características:
• Los elementos donde el indice de la fila es igual al indice de la columna se llama

diagonal principal (parte oscura), se dice que: fila = columna
• La región determinada por los elementos situados sobre la diagonal principal se
llama matriz triangular superior, donde fila < columna.
• La región determinada por los elementos situados debajo de la diagonal
principal se llama matriz triangular inferior, donde fila > columna.
Triangular superior
Triangular inferior

• Procedimiento ingresarMatriz (entero m[50][50], entero &fila, entero
&columna), permite ingresar números enteros a la matriz.
• Procedimiento superiorInferior(entero m[][50], entero fila, entero columna,
entero a[50], entero &n1, entero b[50], entero &n2), permite encontrar el
vector triangular superior a y vector triangular inferior b
• Procedimiento imprimirMatriz(entero a[50][50], entero nfila, entero ncolumna)
vector
entero: i, j
Inicio
entero: n1  0, n2  0, fila, columna, a[50][50], b[50], c[50]
ingresarMatriz(m, fila, columna)
superiorInferior(m, fila, columna, a, n1, b, n2)
imprimeMatriz(m, fila, columna)
Escribir (“Vector superior”)
Escribir(“Vector inferior”)
Fin


Leer (fila)
Leer (columna)
Leer (a[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento superiorInferior(entero m[50][50], entero fila, entero columna,

entero a[50], entero &n1, entero b[50], entero &n2)
Desde (j  0) hasta (i < columna) con incremento 1 Hacer
Si ( i < > j) entonces
Si (i < j) entonces // Triangular superior
a[n1]  m[i][j]
n1  n1 + 1
Sino // Triangular inferior
b[n2]  m[i][j]
n2  n2 + 1
Fin_si
Fin_si
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirMatriz(entero b[50][50], entero nfilas, entero ncolumnas)

Escribir(b[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento imprimirVector(entero vector[80],entero numel)

Fin_desde
Fin_procedimiento
Ejemplo 30: Guardar en un vector los nombres de N estudiantes y en una matriz

sus 5 notas obtenidas, calcular el promedio de notas de cada estudiante eliminando
la menor nota. Asi también mostrar el nombre o los nombres de los estudiantes
que obtuvieron el mayor promedio.
Por ejemplo:
Raquel 15 9 10 12 11
Felipe 16 17 6 19 12
a[]= Carlos b[][]= 9 5 11 7 13
Maria 14 17 15 18 8
Luisa 13 8 9 17 12
Eliminando la nota más baja se obtienen los siguientes promedios:

Raquel 12
Felipe 16
a[]= Carlos c[]= 10
Maria 16
Luisa 13
Los alumnos que obtuvieron el máximo promedio son: Felipe, María.
Inicio
ingresarDatos (a, b, n)
promediar (b, n, c)
imprimirDatos (a, c, n)
mayorNota (a, c, n)
Fin
Procedimiento ingresarDatos(cadena a[50], entero b[50][50], entero &n)

Escribir (“Ingresar cantidad de estudiantes:”)
Leer (n)
Escribir (“Ingresar nombre del estudiante”)
Leer (a[i])
Desde (j  0) hasta (j < 5) con incremento 1 Hacer
Leer (b[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento promediar(entero b[50][50], entero pn, entero c[50])

entero: suma, menor
Desde (i  0) hasta (i < pn) con incremento 1 Hacer
suma  0
menor  b[i][0]
Desde (j  0) hasta (j < 5) con incremento 1 Hacer
Si (b[i][j] < menor) entonces
menor  b[i][j]
Fin_si
suma  suma + b[i][j]
Fin_desde
c[i]  (suma – menor) / 4
Fin_desde
Fin_procedimiento
Procedimiento imprimirDatos(cadena a[50], entero c[50], entero pn)

Desde (i  0) hasta (i < pn) con incremento 1 Hacer
Escribir(a[i])
Escribir(c[i])
Fin_desde
Fin_procedimiento
Procedimiento mayorNota (cadena a[50], entero c[50], entero pn)

entero: k 0
Desde (i  0) hasta (i < pn) con incremento 1 hacer
Si (c[i] > mayor) entonces
mayor  c[i]
Fin_si
Fin_desde

Desde (i  0) hasta (i < pn) con incremento 1 hacer

Si (c[i] = mayor) entonces
pos[k]  i
k  k+1
Fin_si
Fin_desde
Si (k = 1 )
Escribir (“El alumno con la mayor nota es ”, a[pos[0]])
Sino
Escribir (“Los alumnos con la mayor nota son ”, a[])
Desde (i  0) hasta (i < k) con incremento 1 hacer
Escribir (a[pos[i]])
Fin_desde
Fin_si
Fin_procedimiento
Ejemplo 31: Pseudocódigo para llenar e imprimir una matriz de orden N, en forma
de caracol.
Por ejemplo:
Si n = 3:
1 2 3
a[][]= 8 9 4
7 6 5
Si n = 5:
1 2 3 4 5
16 17 18 19 6
b[][]= 15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

• Procedimiento ingresarFilaColumna (entero &fila, entero &columna), permite
ingresar el numero de filas y columnas a la matriz
• Procedimiento avanza(entero a[50][50], entero i, entero columna, entero &k),
permite llenar las primeras filas de la matriz
• Procedimiento baja(entero a[50][50], entero i, entero columna, entero &k),
permite llenar las ultimas columas de la matriz
• Procedimiento retrocede(entero a[50][50], entero i, entero fila, entero columna,
entero &k), permite llenar la ultimas filas de la matriz
• Procedimiento sube(entero a[50][50], entero i, entero fila, entero columna,
entero &k), permite llenar las primeras columnas de la matriz.
entero: i, j
Inicio
entero: fila, columna, guardafila, nfila, r, k 1, a[50][50]
ingresarFilaColumna (fila,columna)
guardafila  fila

nfila  fila Div 2

r  fila Mod 2
Desde (i  0) hasta (i < nfila) con incremento 1 Hacer
avanza(a, i, columna, k)
baja(a, i, columna, k)
retrocede(a, i, fila, columna, k)
sube(a, i, fila, columna, k)
fila  fila – 1
columna  columna – 1
Fin_desde
Si (r = 1) entonces
avanza(a, nfila, columna, k)
Fin_si
imprimeMatriz(a,guardafila)
Fin
Procedimiento ingresarFilaColumna (entero &fila, entero &columna)

Escribir(“Ingresar cantidad de filas de la matriz:”)
Leer (fila)
Escribir(“Ingresar cantidad de columnas de la matriz:”)
Leer (columna)
Fin_procedimiento
Procedimiento avanza(entero a[50][50], entero i, entero columna, entero &k)

Desde (j  i) hasta (j < columna) con incremento 1 Hacer
a[i][j] k
kk+1
Fin_desde
Fin_procedimiento
Procedimiento baja(entero a[50][50], entero i, entero columna, entero &k)

Desde (i  i +1) hasta (i < columna) con incremento 1 Hacer
a[i][columna - 1] k
kk+1
Fin_desde
Fin_procedimiento
Procedimiento retrocede(entero a[50][50], entero i, entero fila, entero columna,

entero &k)
Desde (j  columna - 2) hasta (j >= i) con disminución 1 Hacer
a[fila - 1][j]  k
kk+1
Fin_desde
Fin_procedimiento
Procedimiento sube(entero a[50][50], entero i, entero fila, entero columna,

entero &k)
Desde (j  fila-2) hasta (j > i) con disminución 1 Hacer
a[j][i]  k
kk+1
Fin_desde
Fin_procedimiento
Procedimiento imprimeMatriz(entero a[50][50], entero fila)

Desde (j  0) hasta (j < fila) con incremento 1 Hacer
Escribir (a[i][j])

Fin_desde
Fin_desde
Fin_procedimiento
Ejemplo 32: Pseudocódigo para realizar el algoritmo del banquero para un solo
recurso.
Algoritmo del banquero para un solo recurso: El banquero de un pueblo trabaja con
cuatro clientes P, Q, R, S, cada uno tiene asignado cierto número de unidades de
crédito.
El banquero sabe que no todos los clientes necesitan el crédito máximo en forma
inmediata, por lo que solo reserva 10 unidades para darle servicio.
En la tabla se muestra lo que tiene asignado cada cliente y la línea de crédito que
podrá solicitar como máximo
Clientes ( Pi) Tiene Maximo

P 1 6
Q 1 5
R 2 4
S 4 7
Por ejemplo el cliente P tiene asignado una unidad de línea de crédito, pero podría
solicitar hasta 6 unidades. El cliente Q tiene asignado una unidad de línea de
crédito, pero podría solicitar hasta 5 unidades, y asi sucesivamente.
E = 10 son las unidades que reserva el banquero

A= 2 E - total de unidades que tienen los clientes (A = 10-(1+1+2+4))
Pasos a seguir:
Inicialmente todos los procesos se inician sin marcar.
1. Se busca un proceso no marcado Pi, para el i-esima cliente, calculando la
diferencia:
D = máximo – tiene, tal que D<= a.
2. Si se encuentra tal proceso, se suma el Tiene de la i-esima fila a A, se marca el
proceso y se regresa al paso 1.
3. Si no existe tal proceso el algoritmo termina.
Ejecutando los pasos indicados se tiene:
Cliente P, diferencia = 5, D <= A, 5 <= 2 falso, no se ejecuta cliente P.

Cliente Q, diferencia = 4, D <= A, 4 <= 2 falso, no se ejecuta cliente Q.
Cliente R, diferencia = 2, D <= A, 2 <= 2 verdadero, se ejecuta cliente R.
Cuando el cliente R termina, el valor de A se suma con el Tiene del cliente R,
obteniendo un nuevo valor de A=4, y se marca el cliente R.
Proceso ( Pi) Tiene Max Diferencia Marca

P 1 6 5
Q 1 5 4
R 2 4 2 *
S 4 7 3
Se ejecuta el cliente Q, cuando el cliente Q termina, el valor de A se suma con el
Tiene del cliente Q, obteniendo un nuevo valor de A=5, y se marca el cliente Q.

P 1 6 5
Q 1 5 4 *

R 2 4 2 *
S 4 7 3
Se ejecuta el cliente P, cuando el cliente P termina, el valor de A se suma con el

Tiene del cliente P, obteniendo un nuevo valor de A=6, y se marca el cliente P.

P 1 6 5 *
Q 1 5 4 *
R 2 4 2 *
S 4 7 3
Se ejecuta el cliente S, cuando el cliente S termina, el valor de A se suma con el

Tiene del cliente S, obteniendo un nuevo valor de A=10, y se marca el cliente S.

P 1 6 5 *
Q 1 5 4 *
R 2 4 2 *
S 4 7 3 *
Como todos los procesos se han ejecutado E = A, decimos que es un estado

seguro.

• Procedimiento ingresarVector (caracter proc[20], entero tie[20], entero max[20],
entero &n1), permite ingresar números enteros los vectores proceso, tiene y
maximo.
• Procedimiento imprimirVector (entero vector[20], entero n1), imprime el vector
original y el nuevo vector.
• Función sumaTiene(entero t[20], entero n1), devuelve la suma del vector tiene.
• Función compara entero t[20] , entero m[20], entero a, entero n1, caracter
marca[20]), devuelve la posición del proceso que se va a ejecutar
// Variable global
entero: i
Inicio
entero: n1, e 10, a, s, encontro, tiene[20], max[20]
boolean: seguro  verdadero
caracter: proceso[20], marca[20]
// Lectura de datos
ingresarVector (proceso, tiene, max, n1)
Escribir (“Imprime vector Tiene:”)
imprimirVector (tiene, n1)
Escribir (“Imprime vector Maximo:”)
imprimirVector (max, n1)
s  sumaTiene (tiene,n1)
ae–s
Mientras (seguro) Hacer
encontro  compara (tiene, max, n1, a, marca)

Si (encontro>=0) entonces
a a + tiene[encontro]
Escribir (“Se ejecuta proceso”, proceso[encontro], “a =”, a )
Sino
seguro  falso
Fin_si
Fin_mientras
Si (a = e) entonces
Escribir (“Estado seguro”)
Sino
Escribir (“Estado inseguro”)
Fin_si
Fin
Procedimiento ingresarVector(caracter proc[20], entero tie[20], entero max[20],

entero &n1)
Leer (proc[i])
Escribir (“Ingresar tiene”)
Leer (tie[i])
Escribir (“Ingresar maximo”)
Leer (max[i])
Fin_desde
Fin_procedimiento
Funcion sumaTiene(entero t[] ,entero n1) : entero

entero: s  0
i0
Mientras (i<n1) Hacer
s  s + t[i]
i i+1
Fin_mientras
retornas s
Fin_funcion
Funcion compara(entero t[20] , entero m[20], entero a, entero n1, caracter

marca[20]) : entero
entero: i  0, posi 0, sw 0, d
Mientras (i<n1 and sw=0) Hacer
d  m[i] - t[i]
Si ( d<=a and marca[i]=' ' ) entonces
posi  i
marca[i]  '*'
sw  1
Sino
posi  -1
ii+1
Fin_si
Fin_mientras
retornar posi
Fin_función
Procedimiento imprimirVector(entero vector[20], entero n1)


Escribir(a[i])
Fin_desde
Fin_procedimiento
Algoritmo del Banquero para varios Recursos:

El algoritmo del banquero se puede generalizar para el control de varios recursos.
Por ejemplo:
E[]= 9 3 6
Asi se tiene:
Matriz Tiene Matriz Maximo

1 0 0 3 2 2
6 1 2 6 1 3 A[]= 0 1 1
2 1 1 3 1 4
0 0 2 4 2 2
S[]= 9 2 5
El vector A se obtiene restando el vector E con el resultado de la suma de cada

columna de la matriz Tiene:
A = [9 3 6] - [9 2 5] = [0 1 1]
Solución:
Matriz Matriz Matriz Marca

Tiene Maximo Diferencia
1 0 0 3 2 2 2 2 2 E[]= 9 3 6
6 1 2 6 1 3 0 0 1
2 1 1 3 1 4 1 0 3 A[]= 0 1 1
0 0 2 4 2 2 4 2 0
Para que se ejecute un proceso la diferencia debe ser menor o igual que A, de esta
manera:
Proceso 1: Diferencias = [2 2 2], como la diferencia es mayor que A, no se

ejecuta el proceso P1
Proceso 2: Diferencias = [0 0 1] como la diferencia es menor que A, se ejecuta
proceso P2
Cuando el proceso 2 termina todos sus recursos, vuelven al vector de recursos
disponibles.

1 0 0 3 2 2 2 2 2 E[]= 9 3 6
6 1 2 6 1 3 0 0 1 *
2 1 1 3 1 4 1 0 3 A[]= 6 2 4
0 0 2 4 2 2 4 2 0
Proceso 1: Diferencias = [2 2 2], como la diferencia es menor que A, se ejecuta

el proceso P1
disponibles.

1 0 0 3 2 2 2 2 2 * E[]= 9 3 6

6 1 2 6 1 3 0 0 1 *
2 1 1 3 1 4 1 0 3 A[]= 7 2 3
0 0 2 4 2 2 4 2 0

el proceso P3
disponibles

1 0 0 3 2 2 2 2 2 * E[]= 9 3 6
6 1 2 6 1 3 0 0 1 *
2 1 1 3 1 4 1 0 3 * A[]= 9 3 4
0 0 2 4 2 2 4 2 0

el proceso P4

1 0 0 3 2 2 2 2 2 * E[]= 9 3 6
6 1 2 6 1 3 0 0 1 *
2 1 1 3 1 4 1 0 3 * A[]= 9 3 6
0 0 2 4 2 2 4 2 0 *
Como todos los procesos se han ejecutado y E[]=A[] decimos que el sistema es
seguro.

• Procedimiento ingresarMatriz(entero tie[20][20], entero max[20][20], entero
&f, entero &c), permite ingresar valores a las matrices c, d.
• Procedimiento calculadiferencia(entero c[20][20], entero d[20][20], entero
dif[20][20], entero fila, entero columna), devuelve la matriz diferencia dif.
• Procedimiento imprimeMatriz(entero c[20][20], entero d[20][20], entero
dif[20][20], entero fil, entero col), imprime la matrices c, d y dif utilizando el
método imprimir().
• Procedimiento imprimirMatriz(entero a[20][20], entero i, entero columna),
imprime las matrices a, b y c fila a fila.
• Funcion compara(entero t[20], entero m[20], entero a, caracter marca[]),
devuelve la posición del proceso que se va a ejecutar
• Procedimiento nuevoA(entero c[20][20], entero a[20], entero encontro, entero
columna), calcula el nuevo valor del vector a.
• Procedimiento imprimirnuevoA(entero a[20], entero encontro, entero columna),
imprime el proceso que se ejecuta y el nuevo valor del vector a.
• Funcion igual(entero e[20], entero a[20], entero columna), devuelve un valor
verdadero o falso dependiendo si el vector a es igual al vector b
entero: i, j
Inicio
// Definir e inicializar variables, vectores y matrices
entero: fila, columna, encontro  0, c[20][20], d[20][20], a[20],
dif[20][20], e[]  {9, 3, 6}
caracter: marca[]
boolean: seguro  verdadero, r  falso

//Lectura de datos
ingresarMatriz (c, d, fila, columna)
calculaDiferencia (c, d, dif, fila, columna)
imprimirMatriz (c, d, dif, fila, columna)
Mientras (seguro) Hacer
encontro  compara (dif, a, marca, fila, columna)
Si (encontro >= 0) entonces
nuevoA (c, a, encontro, columna)
imprimirnuevoA (a, encontro, columna)
Sino
seguro  falso
Fin_si
Fin_mientras
r  igual (e, a, columna)
Si (r) entonces
Escribir (“El sistema es seguro”)
Sino
Escribir (“El sistema es inseguro”)
Fin_si
Fin
Procedimiento ingresarMatriz(entero tie[20][20], entero max[20][20], entero &f,

entero &c)
Desde (i  0) hasta (i < f) con incremento 1 Hacer
Desde (j  0) hasta (j < c) con incremento 1 Hacer
Leer (proc[i][j])
Escribir (“Ingresar tiene”)
Leer (tie[i][j])
Escribir (“Ingresar maximo”)
Leer (max[i][j])
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento calculadiferencia(entero c[20][20], entero d[20][20], entero
dif[20][20], entero fila, entero columna)
dif[i][j]  d[i][j] - c[i][j]
Fin_desde
Fin_desde
Fin_procedimiento
Procedimiento nuevoA(entero c[20][20], entero a[20], int encontro, int columna)

j0
Mientras (j < columna) Hacer
a[j]  a[j] + c[encontro][j]
j  j+1
Fin_mientras
Fin_procedimiento
Procedimiento imprimirnuevoA(entero a[20], entero encontro, entero columna)

Escribir ("Se ejecuta proceso", (encontro+1)," entonces ", "A = ")
Desde (i  0) hasta (i < columna) con incremento 1 Hacer
Escribir(a[i])
Fin_desde
Fin_procedimiento

Procedimiento imprimir(entero a[20][20], entero i, entero c)

Desde (j  0) Hasta (j < c) con incremento 1 Hacer
Escribir(a[i][j])
Fin-Desde
Fin_procedimiento
Procedimiento imprimeMatriz(entero c[20][20], entero d[20][20], entero

dif[20][20], entero fil, entero col)
Escribir (“Asignacion Demanda diferencia”)
Desde i  0 hasta (i<fil) con incremento 1 Hacer
imprimir(c, i, col)
imprimir(d, i, col)
imprimir(dif, i, col)
Fin_desde
Fin_procedimiento
Función igual(entero e[20], entero a[20], entero columna) : booleano

entero: t  0
i0
Mientras (i < columna) Hacer
Si (e[i] = a[i]) entonces
t1
Fin_si
i  i+1
Fin_mientras
Si (t = 1)
retornar verdadero
Sino
retornar falso
Fin_si
Fin_función
Función compara(entero t[20], entero m[20], entero a,caracter marca[20])

entero: t  0, sw  0, posi  0
i0
Mientras (i<fila and sw = 0) Hacer
j0
Mientras(j<columna and marca[i]=' ') Hacer
Si (dif[i][j] <= a[j]) entonces
t1
Sino
j  columna //para que no siga buscando
Fin_si
j  j+1
Fin_mientras
Si (t =1 ) entonces
posi  i
sw 1
marca[i]  '*'
Sino
posi  -1
Fin_si
i  i+1
Fin_mientras

retornar posi
Fin_funcion
11. Ejercicios Propuestos
1. Calcular la cantidad de números de pares e impares que existe en un vector de

N elementos.
2. Ingresar N números enteros a un vector, pasar a otro vector todos los números
capicúas, en caso no exista ningun número capicúa mostrar un mensaje
correspondiente.
3. Guardar N números enteros en un vector, calcular el promedio entero del mayor
y el menor número y reemplazar este resultado a todos los números pares del
vector.
4. Ingresar N números a un vector A y un número X. Luego determinar los
números del vector más cercanos al número X y reemplazarlo por él.
5. Ingresar N números enteros a un vector, pasar a otro vector todos los números
perfectos, en caso no exista ningun número perfecto mostrar un mensaje
correspondiente.
6. Guardar N y M números enteros a dos vectores tal como A y B, si el vector A
tiene mas elementos que los de B, pasar todos los números impares de A al
final del vector B, caso contrario pasar todos los números impares de B al final
del vector A.
7. Guardar N números en un vector, luego reemplace el contenido del número
mayor por el acumulado de la suma de todos los números que se ubican
después de este. Por ejemplo si el mayor esta en la posición 4 sume a partir de
la posición 5 hacia la posición N - 1.
8. En una empresa se va a incrementar los sueldos de los empleados, para esto,
guarda en un vector los nombre de los N empleados y en otro vector sus
sueldos actuales, se pide calcular el nuevo sueldo sabiendo que para aquellos
empleados con un sueldo actual mayor a S/.2500.00 se le incrementa 8%, caso
contrario se le incrementa el 10%. Luego calcular el promedio de sueldos y
mostrar en un nuevo vector los nombres de los empleados con sueldos mayores
al promedio.
9. Construir un algoritmo donde se ingrese un número entero luego coloque cada
uno de sus dígitos en un vector, además muestre la posición del dígito menor.
10. Insertar un elemento en un vector después de un valor dado. Si existen varios
elementos en la fila con el mismo valor buscado, la inserción solo se realiza en
la primera ocurrencia, las otras ocurrencias no son tomadas en cuenta. La
inserción no debe realizarse sobre el mismo vector sino sobre otro vector.
• Se lee el vector original grabando el elemento leído sobre el nuevo vector,
comparamos el elemento leido con el valor a insertar, guardando este
resultado en la variable encontro, este proceso se va a realizar mientras el
índice i del vector original sea menor a la longitud del vector original y
encontro sea verdadero.
• Si encontro es verdadero se graba el valor a insertar sobre el nuevo vector
• Se continúa grabando los elementos restantes del vector original sobre el
nuevo vector.
• Finalmente se obtiene el nuevo vector con todos los elementos del vector
original más el valor insertado.
Por ejemplo:
Sea el vector a:
a[]= 1 2 13 24 26
Valor a insertar: 20
Insertar después de: 13

Se obtiene:
b[]= 1 2 13 20 24 26
11. Eliminar un elemento de un vector dando su ubicación (indice). La eliminación

no debe realizarse sobre el mismo vector sino sobre otro vector.
• Se lee el vector original grabando los elementos leídos sobre el nuevo vector,
mientras sea menor el índice i del vector original a la posición.
• Cuando alcanza el índice i del vector original a la posición se incrementa el
índice i y se continúa grabando los elementos restantes del vector original
sobre el nuevo vector.
• Finalmente se obtiene el nuevo vector con todos los elementos del vector
original menos el valor eliminado.
Por ejemplo:
Sea el vector a:
a[]= 1 2 13 24 26
Posición del valor a eliminar: 2
Se obtiene:
b[]= 1 2 24 26
12. Guardar N y M números enteros en forma ascendente (ordenada) a dos

vectores tal como A y B, luego trasladar tanto los elemento del vector A como
del vector B manteniendo el orden en un nuevo vector C.
Por ejemplo, si tenemos:
a[]= 3 7 9 11 15 18 20 24
b[]= 2 5 10 16 27
Se obtiene:
c[]= 2 3 5 7 9 10 11 15 16 18 20 24 27
13. Ingresar valores a una matriz de tamaño N * M, luego ingresar un número X.

Reemplazar el valor X por todos los números múltiplos de 5 en la matriz.
14. Multiplicar los elementos correspondientes de la diagonal principal por los
elementos de la diagonal secundaria de una matriz cuadrada y mostrar el
resultado en un vector.
15. Trasladar a un vector los elementos que forman la letra N de una matriz
cuadrada.
Por ejemplo:
5 15 25 3
a[][]= 10 18 34 9
7 30 22 85
55 35 45 105
Se obtiene:
b[]= 5 3 10 18 9 7 22 85 55 105
16. Hacer un algorítmo para mover los contenidos de las filas de una matriz una
posición hacia la derecha. El último elemento de cada fila pasará a la primera
posición de la misma. Trabajar con una matriz N x M.
17. Calcular la suma de los números pares e impares de una matriz de N filas y M
columnas.
Por ejemplo:

1 2 3
a[][]= 4 5 6
7 8 9
Suma de pares = 20
Suma de impares = 25
18. Dado una matriz de orden N girar 90 grados en el sentido de las agujas del
reloj.
Si n es de orden 3:
1 2 3
a[][]= 4 5 6
7 8 9
Entonces se obtendrá:
7 4 1
a[][]= 8 5 2
9 6 3
19. Intercambiar el mayor y menor valor de una matriz de N filas y M columnas.

Por ejemplo:
80 40 50 70
5 15 25 10
a[][]= 10 18 34 9
90 30 175 85
55 35 45 105
Mayor elemento = 175
Menor elemento = 5
Intercambiando el mayor elemento con el menor elemento, se tiene:
80 40 50 70
175 15 25 10
a[][]= 10 18 34 9
90 30 5 85
55 35 45 105
20. Ingresar valores a una matriz de tamaño N * M y pasar a un vector todos los
valores que se encuentren en columnas impares a un vector.
21. Almacenar en una fila X los cuadrados de la fila Y de una matriz de tamaño N *
M.
Por ejemplo:
1 2 3
a[][]= 4 5 6
7 8 9
Fila 1: su cuadrado: 1 4 9
Se almacene en la fila 3:
Obtenemos:
1 2 3
a[][]= 4 5 6
1 4 9
22. Sumar los datos de los elementos de cada fila de una matriz de tamaño N * M y
almacenar el resultado en una nueva fila.
Por ejemplo:
1 2 3
a[][]= 4 5 6
7 8 9
Suma fila 1: 6
Suma fila 2: 15
Suma fila 3: 24

La matriz ahora será:

1 2 3
a[][]=
4 5 6
7 8 9
6 15 24
23. Intercambiar los elementos de la diagonal principal por los elementos de la
última fila de una matriz cuadrada.
6 10 18 4 21
12 7 16 11 3
a[][]= 13 9 20 3 17
5 14 50 1 15
23 2 19 8 12
Elementos de la diagonal principal: 6, 7, 20, 1, 12

Elementos de la ultima fila : 23, 2, 19, 8, 12
Al intercambiar obtenemos:
23 10 18 4 21
12 2 16 11 3
a[][]= 13 9 19 3 17
5 14 50 8 15
6 7 20 1 12
24. Una empresa ha convocado a un concurso de un puesto de trabajo. En dicho

concurso se presentan N postulantes, cuyos nombres son guardados en un
vector, así mismo, se realiza 4 pruebas cuyos puntajes obtenidos son guardados
en una matriz. Calcular el puntaje total de cada postulante. Finalmente mostrar
el nombre del candidato con el mayor puntaje, en caso existiera mas de un
candidato con el mayor puntaje mostrar los nombres de todos estos.
25. Guardar números enteros en una matriz de tamaño N*M luego, devolver en un
vector la columna que tiene el menor promedio.
26. Guardar números enteros a dos matrices de tamaño N * M tal como A y B,
luego copiar en dos nuevas matrices tal como C y D los elementos alternos de
A y B.
2 15 25 41 5 12 10 6
a[][] = 19 13 22 4 b[][]= 7 16 38 17
23 5 9 13 37 22 12 41
2 12 25 6 5 15 10 41
c[][]= 7 13 38 4 d[][]= 19 16 22 17
23 22 9 41 37 5 12 13

Algoritmos: Un enfoque práctico - Capítulo V Franklin Arriola R. / Yuliana Jáuregui R.
Métodos de ordenación y búsqueda
La ordenación y la búsqueda son dos procesos que frecuentemente se realizan para

resolver problemas por computadora.
Ordenar, significa reorganizar un conjunto de datos en una secuencia específica.
La operación de búsqueda para recuperar información normalmente se efectúa

sobre elementos ordenados.
Formalmente se define la ordenación de la siguiente manera:

Sea A una lista de N elementos:
A0, A1, A2,……AN
Ordenar significa permutar estos elementos de tal forma que los mismos quedan de
acuerdo con una distribución preestablecida.
• Ascendentemente A0 <= A1 <= A2 <=, ... <= AN

• Descendente A0 >= A1 >= A2 >=, ... >=AN
En el procesamiento de datos, a los métodos de ordenación se les clasifica en dos

categorías:
• Ordenación interna (ordenación de vectores). En la ordenación interna los

elementos del vector se encuentran en memoria principal
• Ordenación externa (ordenación en archivos). En la ordenación externa los
elementos del vector se encuentran en archivos almacenados en dispositivos de
almacenamiento secundario como discos, cintas, etcétera.
Para nuestro caso, solo se trabajará con los métodos de ordenación interna, así
tenemos: métodos de ordenación por selección, métodos de ordenación por
comparación – intercambio y métodos de ordenación por inserción.
1. Métodos de ordenación por selección
Sea un vector por clasificar, para construir el vector final se extrae sucesivamente
los elementos del vector y se coloca adecuadamente según dos tipos de métodos:
• Método por selección de elementos

Una vez escogido una posición en el vector final, se busca el elemento que debe de
ocuparlo: método de selección simple.
• Método de selección por posición

Una vez escogido el elemento se busca que posición debe de ocupar en el vector
final: método de conteo
1.1. Método de ordenación por selección simple
Principio: Sea A el vector con N elementos a clasificar en forma ascendente, se

busca el elemento mas pequeño del vector, empezando la búsqueda desde A[0]
hasta A[N-1], sea A[j] este elemento, entonces se pone A[j] en el lugar de A[0]
y A[0] en el lugar de A[j].

Se busca después el elemento mas pequeño del vector pero se empieza la

búsqueda a partir de A[1] hasta A[N], sea A[k] este elemento, se pone A[k] en
el lugar de A[1] y A[1] y en el lugar de A[k] y así sucesivamente.
Ejemplo:
Sea A el vector a clasificar en forma ascendente.
8 40 26 12 1 18 14
0 1 2 3 4 5 6
Primera pasada: Primer elemento A[0] = 8

El menor elemento desde A[0] hasta A[6] es A[4]=1, entonces cambiamos A[0]
con A[4].
1 40 26 12 8 18 14
0 1 2 3 4 5 6
Segunda pasada: Segundo elemento A[1] = 40

El menor elemento a partir de A[1] es A[4] = 8, entonces cambiamos A[1] con
A[4].
1 8 26 12 40 18 14
0 1 2 3 4 5 6
Tercera pasada: Tercer elemento A[2] = 26

A[3].
1 8 12 26 40 18 14
0 1 2 3 4 5 6
Cuarta pasada: Cuarto elemento A[3] = 26

El menor elemento a partir de A[3] es A[6]=14, entonces cambiamos A[3] con
A[6].
1 8 12 14 40 18 26
0 1 2 3 4 5 6
Quinta pasada: Quinto elemento A[4] = 40

A[5].
1 8 12 14 18 40 26
0 1 2 3 4 5 6
Sexta pasada: Sexto elemento A[5] = 40

A[6].
1 8 12 14 18 26 40
0 1 2 3 4 5 6
El vector esta ordenado completamente en N-1 = 6 pasadas.
Algoritmo
Se tiene un vector de N elementos para clasificar, primero se escoge el menor
elemento del vector y se ubica en la posición 0.

Luego quedan N-1 elementos para clasificar de los cuales se evalúa el menor y
se pone en la posición 1 y así sucesivamente hasta que quede un solo elemento
el cual se coloca en la última posición del arreglo.

• Procedimiento ingresarVector (entero a[50], entero &n), permite ingresar
• Procedimiento sortsimple (entero a[50] , entero n) controla los limites del
vector
• Función posiminimo (entero a[50] , entero n, entero i) devuelve un valor
entero que representa la posición del índice mínimo
• Procedimiento cambio (entero a[50] , entero i, entero j) permite el
intercambio de posiciones
• Procedimiento imprimirVector (entero vector[50] , entero num) imprime el
vector ordenado
8 40 26 12 1 18 14 Cambio entre
Vector original posi
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[i] y A[posi]
Pri.Pasada i=0 1 40 26 12 8 18 14 4 A[0] y A[4]
Seg.Pasada i=1 1 8 26 12 40 18 14 4 A[1] y A[4]
Ter.Pasada i=2 1 8 12 26 40 18 14 3 A[2] y A[3]
Cut.Pasada i=3 1 8 12 14 40 18 26 6 A[3] y A[6]
Qui.Pasada i=4 1 8 12 14 18 40 26 5 A[4] y A[5]
Sex.Pasada i=5 1 8 12 14 18 26 40 6 A[5] y A[6]
Inicio
entero: n, a[50], b[50]
// Lectura de datos
ingresarVector (a, n)
// Proceso
sortsimple (a, n)
imprimirVector (a, n)
Fin

entero: i
Leer (n)
Desde (i 0) hasta (i < n) con incremento de 1 Hacer
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento sortsimple (entero a[50] , entero n)

entero: i, posi
i0
Desde (i 0) hasta ( i < n) con incremento 1 Hacer
posi posiminimo (a, n, i)
cambio (a, i, posi)
Fin_desde
Fin_procedimiento

Función posiminimo (entero a[50] , entero n, entero i)

entero: k, posi 0
ki
Si (a[i] < a[k]) entonces
k i
Fin_si
ii+1
Fin_mientras
retornar k
Fin_función
Procedimiento cambio (entero a[50] , entero i, entero j)

// Definir variable
entero: temp
temp a[i]
a[i] a[j]
a[j] temp
Fin_procedimiento

// Definir variable
entero: i
Desde (i 0) hasta (i < num) con incremento 1 Hacer
Fin_desde
Fin_procedimiento
1.2. Método de ordenación por conteo
Principio: Dado un vector A con N elementos a clasificar en forma ascendente,

inicialmente todos los contadores son nulos. Se considera primer elemento A0,
se compara A0 con A1, si A0 es mayor que A1, se suma una unidad al contador
C0 asociado a A0, sino se suma una unidad al contador C1 asociado a A1, luego
se compara A2 con A0 y A1 según el resultado de las comparaciones se
incrementan los contadores correspondientes a los elementos chequeados,
cuando todos los elementos han sido tratados de la misma manera, los
contadores indicaran el rango del elemento correspondiente.
Ejemplo:
A0 A1 A2 A3 A4 A5 A6
8 40 26 12 1 18 14
0 1 2 3 4 5 6
Contadores C0 C1 C2 C3 C4 C5 C6 Asociados
1. C0 = C1 = C2 = C3 = C4 = C5 = C6 = 0
2. Primer elemento = 8
3. Segundo elemento = 40
Comparamos 40 con todos los anteriores, le sumamos 1 al contador
asociado del elemento mayor:
8 < 40 C1 = C1 + 1 = 1 (40 es el mayor, su contador asociado es C1)
4. Tercer elemento = 26


asociado del elemento mayor:
40 > 26 C1 = C1 + 1 = 2 (40 es el mayor, su contador asociado es C1)
5. Cuarto elemento = 12
asociado del elemento mayor
6. Quinto elemento = 1
Comparamos 1 con todos los anteriores, le sumamos 1 al contador asociado
del elemento mayor
8>1 C0 = C0 + 1 = 1 (8 es el mayor, su contador asociado es C0)
7. Sexto elemento = 18
8. Séptimo elemento = 14
Se obtiene
C0 = 1
C1 = 6
C2 = 5
C3 = 2
C4 = 0
C5 = 4
C6 = 3
C0: indica un valor de 1, entonces el lugar del elemento A0 es la primera

posición.
C1: indica un valor de 6, entonces el lugar del elemento A1 es la sexta posición
Y así sucesivamente, obtenemos el archivo ordenado.
1 8 12 14 18 26 40
0 1 2 3 4 5 6

• Procedimiento inicializarVector(entero c[50], entero n), permite inicializar en
cero los elementos del vector c.

• Procedimiento conteo(entero a[50] , entero c[50] , entero n) Lleva el avance

del índice i, j.
• Procedimiento cuentac(entero a[50] , entero c[50] , entero limitei, entero j)
Compara un elemento del vector A[j] con todos los anteriores desde cero
hasta limitei, donde limitei, j los da la función conteo, se repite la misma
operación para todos sus elementos y se obtiene así el vector c
• Procedimiento posición (entero a[50] , entero c[50] , entero b[50],entero
n1) obtenemos el vector ordenado B, si el contenido de Ci indica un valor j,
el lugar del elemento Ai es la B[j] posición del vector resultante
• Procedimiento imprimirVector(entero b[50] , entero num) imprime el vector
desordenado y ordenado.
Inicio
entero: n1, a[50], b[50], c[50]
// Lectura de datos
inicializarVector (c, n)
// Proceso
conteo (a, c, n)
posición (a, c, b, n)
Escribir ("Vector desordenado ")
Escribir ("Vector ordenado)
imprimirVector (b, n)
Fin

// Definir variable
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento incializarVector (entero c[50], entero n)

entero: i
c[i] 0
Fin_desde
Fin_procedimiento
Procedimiento conteo (entero a[50] , entero c[50] , entero n)

entero : i, j
i0
Mientras (i < n-1) Hacer
ji+1
cuentac (a, c, i, j)
ii+1
Fin_mientras
Fin_procedimiento

Procedimiento cuentac (entero a[50] , entero c[50] , entero limitei, entero j)

// Definir variable
entero: i
i0
Mientras (i <= limitei) Hacer
Si (a[i] > a[j]) entonces
c[i] c[i] + 1
Sino
c[j] c[j] + 1
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Procedimiento posicion (entero a[50], entero c[50], entero b[50], entero n)

entero: i, p
i0
p c[i]
b[p] a[i]
ii+1
Fin_mientras
Fin_procedimeinto
Procedimiento imprimirVector (entero b[50], entero num)

// Definir variable
entero: i
Escribir (b[i])
Fin_desde
Fin_procedimiento
2. Métodos de ordenación por Comparación-Intercambio (C/I)
Se toman los elementos de dos en dos, se comparan y se intercambian si no están

en el orden adecuado, este proceso se repite hasta que se ha analizado todos sus
elementos y ya no hay intercambios. Entre estos algoritmos se encuentran:
• Método de burbuja
• Método de shell
• Método Par-Impar
2.1. Método de ordenación en burbuja.
Principio: Recibe este nombre por que los elementos mayores “burbujean”
gradualmente (suben) hacia la parte superior del vector.
Sea A el vector con N elementos que se desea clasificar en forma ascendente,
para cada elemento se determina el mayor elemento de A y se guarda en la
última posición, luego quedan N-1 elementos para clasificar y se guarda el
siguiente mayor en la posición N-1 y así sucesivamente hasta que quede un solo
elemento que se guarda en la posición cero.

En la primera pasada, se efectúa comparaciones a pares de elementos

adyacentes e intercambiarlos entre si hasta colocar el mayor elemento en la
ultima posición.
En la segunda pasada, se realiza de nuevo comparaciones a pares sucesivos

adyacentes A[i] y A[i+1], pero se trata el vector con solamente N-1 elementos
puesto que el ultimo ya esta en su sitio.
Al cabo de N-1 pasadas el vector ya esta ordenado.
Ejemplo:
Sea A el vector a clasificar en forma ascendente
18 40 26 15 12 9 8
0 1 2 3 4 5 6
Primera Pasada:
A0 < A1 (18 < 40) No hay intercambio
A1 > A2 (40 > 26) Si hay intercambio
A4 > A5 (40 > 9 ) Si hay intercambio
El vector queda:
18 26 15 12 9 8 40
0 1 2 3 4 5 6
Segunda Pasada:
A0 < A1 (18 < 26) No hay intercambio
El vector queda:
18 15 12 9 8 26 40
0 1 2 3 4 5 6
Tercera Pasada:
El vector queda:
15 12 9 8 18 26 40
0 1 2 3 4 5 6
Cuarta Pasada:
A0 > A 1 (15 > 12) Si hay intercambio
A1 > A 2 (15 > 9) Si hay intercambio
A2 < A 3 (15 > 8) Si hay intercambio
El vector queda:

12 9 8 15 18 26 40
0 1 2 3 4 5 6
Quinta Pasada:
El vector queda:
9 8 12 15 18 26 40
0 1 2 3 4 5 6
Sexta Pasada:
El vector queda:
8 9 12 15 18 26 40
0 1 2 3 4 5 6
Tabla que muestra las diferentes pasadas por el método de burbuja
Vector original 18 40 26 15 12 9 8
Primera pasada 18 26 15 12 9 8 40
Segunda pasada 18 15 12 9 8 26 40
Tercera pasada 15 12 9 8 18 26 40
Cuarta pasada 12 9 8 15 18 26 40
Quinta pasada 9 8 12 15 18 26 40
Sexta pasada 8 9 12 15 18 26 40

• Procedimiento burbuja (entero a[50], entero n), lleva el avance del índice
actual k donde guardamos el mayor elemento empezando desde la última
posición hasta la primera posición.
• Procedimiento desplaza (entero a[50] , entero k), halla el mayor elemento
haciendo comparaciones a pares sucesivos llevando los elementos mas
grandes hacia la derecha, empezando desde 0 hasta k, donde el índice k lo
da burbuja.
• Procedimiento imprimirVector (entero vector[50], entero num), imprime el
vector ordenado.
Inicio
entero: n, a[50]
// Lectura de datos
// Proceso
burbuja (a, n)
Fin

entero: i


Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento burbuja (entero a[50], entero n)

// Definir variable
entero: k
kn–1
Mientras (k >= 0) Hacer
desplaza (a, k)
k k-1
Fin_mientras
Fin_procedimeinto
Procedimiento desplaza (entero a[50] , entero k)

entero: i, j, temp
i0
Mientras (i < k) Hacer
ji+1
Si (a[i]>a[j]) entonces
temp a[i]
a[i] a[j]
a[j] temp
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Procedimiento imprimirVector (entero vector [50], entero num)

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
2.2. Método de ordenación shell.
Principio: Sea A el vector a clasificar en forma ascendente.

Efectuamos una serie de C/I en el vector A, de la siguiente manera:
Comparamos A[0] con A[1] si A[0] es menor que A[1], esta bien ordenado, sino
intercambiamos
Comparamos A[1] con A[2] si A[1] es menor que A[2], esta bien ordenado, sino
intercambiamos y regresamos atrás comparando A[0] con A[1], si es menor
regresamos al punto donde fue interrumpido, sino intercambiamos y
regresamos al punto de interrupción
Después de esta fase los tres primeros elementos están clasificados.
Seguimos el tratamiento efectuamos una serie de C/I, cada vez que hemos
tenido que hacer un intercambio regresamos atrás para efectuar los C/I hasta
encontrar un para ordenado.

Ejemplo:
8 40 26 12 1 18 14
0 1 2 3 4 5 6
Para i =0
8 40 26 12 1 18 14 No hay Intercambio (8<40)

Para i = 1
8 26 40 12 1 18 14 Intercambio (40 y 26) se

regresa atrás
8 26 40 12 1 18 14 No hay Intercambio (8 < 26 )
Para i = 2
8 26 12 40 1 18 14 Intercambio (40 y 12) se

regresa atrás
8 12 26 40 1 18 14 Intercambio (26 y 12) se

regresa atrás
Para i = 3
8 12 26 1 40 18 14 Intercambio (40 y 1) se
regresa atrás
8 12 1 26 40 18 14 Intercambio (26 y 1) se
regresa atrás
8 1 12 26 40 18 14 Intercambio (12 y 1) se
Regresa atrás
1 8 12 26 40 18 14 Intercambio (8 y 1) se
Regresa atrás
Para i = 4
1 8 12 26 18 40 14 Intercambio (40 y 18) se

regresa atrás
1 8 12 26 18 40 14 Intercambio (26 y 18) se

regresa atrás
Para i = 5
1 8 12 18 26 14 40 Intercambio (40 y 14) se

regresa atrás
1 8 12 18 14 26 40 Intercambio (26 y 14) se

regresa atrás

1 8 12 18 14 26 40 intercambio (18 y 14)
1 8 12 14 18 26 40 No hay intercambio (12 < 14)

• Procedimiento sortShell(entero a[50], int num) lleva el avance del índice
actual i donde comparamos cada elemento con su sucesor.
• Procedimiento permuta(entero a[50], entero i, entero j) permite el
intercambio de posiciones.
• Procedimiento retrocede(entero a[50], entero i) compara cada elemento
desde la posición inicial hasta i-1
• Procedimiento imprimirVector(entero a[50], entero num) imprime el vector
ordenado.
Inicio
entero: n, a[50]
// Lectura de datos
// Proceso
sortShell (a, n)
Fin

entero: i
Ecribir ("Ingresar cantidad de elementos del vector: ")
Leer (n)
Desde (i 0) Hasta (i < n) con incremento 1 Hacer
Escribir ("Ingresar elemento" )
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento sortShell(entero a[50] ,entero n1)

entero: i, j
i 0
Mientras (i < n - 1) Hacer
j i+1
Si (a[i] > a[j]) entonces
permuta (a, i, j)
retrocede (a, i)
Fin_si
i i+1
Fin_mientras
Fin_procedimeinto
Procedimiento permuta (entero a[50] , entero i, entero j)


entero: temp
temp a[i]
a[i] a[j]
a[j] temp
Fin_procedimiento
Procedimiento retrocede (entero a[50], entero i)

entero: k, j
k i-1
Mientras (k >= 0) Hacer
jk+1
Si (a[k] > a[j]) entonces
permute (a, k, j)
Sino
k -1
kk–1
Fin_si
Fin_mientras
Fin_procedimiento

entero: i
Fin_desde
Fin_procedimiento
2.3. Método de ordenación par - impar
Principio: En este método cada pasada sobre el vector se realiza en dos

etapas:
Primera etapa
Cada elemento de posición impar es comparado con su sucesor y se
intercambian si el sucesor fuera menor.
Segunda etapa
Cada elemento de posición par es comparado con su sucesor y se intercambia si
el sucesor fuera menor.
Las pasadas sobre el vector son repetidas hasta que en una pasada no se ha
realizado ningún intercambio.
Ejemplo:
Sea A el vector a clasificar en forma ascendente
8 40 26 12 1 18 14
0 1 2 3 4 5 6
Primera pasada:
Primera etapa: impares
A[1] > A[2] 40 > 26 intercambio (40 y 26)
A[3] > A[4] 12 > 1 intercambio (12 y 1)
A[5] > A[6] 18 > 14 intercambio (18 y 14)

El vector queda
8 26 40 1 12 14 18
0 1 2 3 4 5 6
Segunda etapa: pares

A[0] < A[1] 8 < 26 No hay intercambio
A[2] > A[3] 40 > 1 intercambio (40 y 1)
8 26 1 40 12 14 18
0 1 2 3 4 5 6
En esta primera pasada ha habido permutaciones entonces se realiza una nueva

pasada al vector
Segunda pasada:
A[1] > A[2] 26 > 1 intercambio (26 y 1)
A[3] > A[4] 40 > 12 intercambio (40 y 12)
El vector queda
8 1 26 12 40 14 18
0 1 2 3 4 5 6

A[0] > A[1] 8 >1 intercambio (8 y 1)
A[2] > A[3] 26 > 12 intercambio (26 y 12)
A[4] > A[5] 40 > 18 intercambio (40 y 12)
1 8 12 26 14 40 18
0 1 2 3 4 5 6
En esta segunda pasada ha habido permutaciones entonces se realiza una

nueva pasada al vector
Tercera pasada:
A[3] > A[4] 26 > 14 intercambio (26 y 14)
A[5] > A[6] 40 > 18 intercambio (40 y 18)
El vector queda
1 8 12 14 26 18 40
0 1 2 3 4 5 6

A[0] < A[1] 1<8 No hay intercambio
A[4] > A[5] 26 > 18 intercambio (26 y 18)
1 8 12 14 18 26 40
0 1 2 3 4 5 6

En esta tercera pasada ha habido permutaciones entonces se realiza una nueva

pasada al vector
Cuarta pasada:
A[3] > A[4] 14 < 18 No hay intercambio
El vector queda
1 8 12 14 18 26 40
0 1 2 3 4 5 6

A[0] < A[1] 1<8 No hay intercambio
1 8 12 14 18 26 40
0 1 2 3 4 5 6
En esta etapa no se ha producido ningún intercambio y el vector queda

completamente ordenado.

• Procedimiento sortParImpar (entero a[50], entero n) las pasadas en el
vector son repetidas hasta que no se realice ninguna permutación.
• Función par(entero a[50] , entero i, entero n), devuelve un valor que nos
indica si ha habido intercambio o no
• Procedimiento permuta(entero a[50] , entero i, entero j), permite el
intercambio de posiciones
• Procedimiento imprimirVector(entero a[50] , entero num), imprime el vector
ordenado
Inicio
// Definir e inicializar vectores
entero: n1 , a[50]
// Lectura de datos
// proceso
sortParImpar (a, n)
Fin

entero: i
Leer (n)
Desde (i 0) Hasta (i < n) con incremento 1 Hacer
Leer (a[i])
Fin_desde
Fin_procedimiento

Procedimiento sortParImpar (entero a[50], entero n)

entero: sw1 0, sw2 0
Mientras (sw1=0 or sw2 = 0) Hacer
sw1 par (a, 0, n)
sw2 par (a, 1, n)
Fin_mientras
Fin_procedimiento
Función par (entero a[50], entero i, entero n) : entero

entero: k, j, sw 0
ki
Mientras (k < n-1) Hacer
jk+1
Si (a[k] > a[j]) entonces
permuta (a, k, j)
sw 1
Fin_si
K k + 2
Fin_mientras
sw 0
Sino
sw 1
Fin_si
retornar sw
Fin_función
Procedimiento permuta (entero a[50] , entero i, entero j)

// Definir variable
entero: temp
temp a[i]
a[i] a[j]
a[j] temp
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
3. Métodos de ordenación por inserción
Cada elemento es insertado en la posición adecuada con respecto al resto de

elementos ya ordenados. Entre estos algoritmos se encuentran:
• Inserción con desplazamiento
• Inserción binaria
3.1. Método de ordenación por inserción con desplazamiento

Principio: Sea A el vector con N elementos a clasificar en forma ascendente,
para un elemento de posición i (i >=1) guardamos a[i] en una variable auxiliar

(aux = a[i]) , aux busca su lugar en las posiciones anteriores, cuando lo

encuentra desplaza hacia la derecha los elementos restantes y coloca aux en la
posición correspondiente.
8 40 26 12 1 18 14
0 1 2 3 4 5 6
En la primera pasada procesar 40

Guardamos 40 que es el elemento activo en una variable auxiliar, aux = 40.
Comparamos 40 con todos los anteriores.
Si A[0] < aux esta ordenado
8 < 40, el elemento 8 esta ordenado
El vector queda igual
8 40 26 12 1 18 14
0 1 2 3 4 5 6
En la segunda pasada procesar 26.

Guardamos 26 que es el elemento activo en una variable auxiliar, aux = 26
Comparamos 26 con todos los anteriores
40 > 26, entonces posición =1
Desplazamos hacia la derecha(40) y ponemos aux en la posición que le
corresponde
El vector queda:
8 26 40 12 1 18 14
0 1 2 3 4 5 6
En la tercera pasada procesar 12.

26 > 12, entonces posición = 1
corresponde
El vector queda:
8 12 26 40 1 18 14
0 1 2 3 4 5 6
En la cuarta pasada procesar 1

8 > 1, entonces posición = 0
corresponde
El vector queda:
1 8 12 26 40 18 14
0 1 2 3 4 5 6
En la quinta pasada procesar 18



26 > 18 entonces posición = 3
corresponde
El vector queda:
1 8 12 18 26 40 14
0 1 2 3 4 5 6
En la sexta pasada procesar 14

18 > 14 entonces posición = 3
corresponde
El vector queda ordenado:
1 8 12 14 18 26 40
0 1 2 3 4 5 6

• Procedimiento sortInsersion (entero a[50] , entero n), lleva el avance del
índice actual i, j.
• Función lugar(entero a[50] , entero j), se guarda en cada pasada el
elemento activo, donde comparamos A[j] con todos los anteriores desde
cero hasta j, para determinar el lugar.
• Procedimiento desplaza(entero a[50], entero j, entero i), desplaza
posiciones hacia la derecha para ubicar el elemento guardado en la posición
que le corresponde.
vector ordenado.
Inicio
entero: n1, a[50]
// Lectura de datos
// proceso
sortInsersion (a, n)
imprimirVector (a,n)
Fin

entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento

Procedimiento sortInsersion (entero a[50], entero n)

entero: i, j 0, posi 0
i0
Mientras (i < n-1) Hacer
j i+1
posi lugar(a,j)
Si (posi != j) entonces //Si posi=j, esta bien ordenado no desplaza
desplaza (a, posi, j)
Fin_si
ii+1
Fin_mientras
Fin_procedimiento
Función lugar(entero a[50] , entero j) : entero

entero: i, posi 0, sw 0, aux
aux a[j]
i 0
Mientras (i < j and sw = 0) Hacer
Si (a[i] > aux ) entonces
posi i
sw 1
Fin_si
ii+1
Fin_mientras
retornar posi
Sino
retornar j
Fin_si
Fin_función
Procedimiento desplaza (entero a[50] , entero i, entero j)

// Definir e inicializar variable
entero: aux 0
aux a[j]
Mientras ( j > i) Hacer
a[j] a[j-1]
jj–1
Fin_mientras
a[i] aux
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
3.2. Método de ordenación por inserción binaria
La búsqueda binaria consiste:

Guardamos el contenido del índice actual de i en una variable auxiliar digamos

aux, dividimos el índice actual de i en dos partes:
• Hacemos inf = 0, sup = i, tomamos la parte entera del valor medio:
medio = (inf + sup) / 2
• Comparamos aux con el contenido del valor medio.
Si aux >= a[medio] el lugar de inserción se encuentra en el extremo
derecho del intervalo para lo cual hacemos inf = medio + 1
Si aux < a[medio] el lugar de inserción se encuentra en el extremo izquierdo
del intervalo para lo cual hacemos sup = medio
• Continua la búsqueda del lugar de inserción mientras inf sea menor que sup.
• Desplazamos elementos a partir de posición de inserción.
• Colocar aux en la posición de inserción.
Entonces la búsqueda binaria consiste en localizar el lugar de inserción,

desplazamos elementos y luego insertar.
Sea A el vector a clasificar en forma ascendente:
8 40 26 12 1 18 14
0 1 2 3 4 5 6
En la primera pasada
i=0
Debemos comparar 40 con los anteriores (mientras inf < sup), para lo cual:
inf 0, sup 1, m (0 + 1) / 2 = 0
Si aux >= A[0] entonces inf = m + 1 = 1
Salimos del proceso repetitivo ya que no se cumple inf < sup (1 < 1)
No podemos desplazar ya que sup es mayor que i
El elemento 8 esta ordenado, el vector queda igual
8 40 26 12 1 18 14
0 1 2 3 4 5 6
En la segunda pasada
i=1
• inf 0, sup 2, m (0 + 2) / 2 = 1
Si aux >= A[1] (no se cumple la condición) sup = m = 1
Repetimos otra vez el proceso repetitivo ya que inf = A[0] entonces inf = m + 1 = 1
Salimos del proceso repetitivo ya que no se cumple inf < sup (1<1)
Desplazamos hacia la derecha a partir de la posición sup = 1 hasta el índice

activo (i = 2) y luego colocamos aux, en la posición correspondiente.
El vector queda:
8 26 40 12 1 18 14
0 1 2 3 4 5 6
En la tercera pasada
i=3


• inf 0, sup 3, m (0 + 3) / 2 = 1
Si aux >= A[1] (no se cumple la condición) sup = m = 1
Repetimos otra vez el proceso repetitivo ya que inf = A[0] (se cumple la condición) entonces inf = m + 1 = 1

activo (i=3) y luego colocamos aux, en la posición correspondiente.
El vector queda:
8 12 26 40 1 18 14
0 1 2 3 4 5 6
En la cuarta pasada
i=4
• inf 0, sup 4, m (0 + 4) / 2 = 2
Si aux >=A[2] (no se cumple la condición) sup = 2
• inf 0, sup 2, m (0 + 2) / 2 = 0
Si aux >=A[0] (no se cumple la condición) sup = 0

El vector queda:
1 8 12 26 40 18 14
0 1 2 3 4 5 6
En la quinta pasada
i=5
• inf 0, sup 5, m (0 + 5) / 2 = 2
Si aux >= A[2] (si cumple la condición) inf = m + 1 = 3
• inf 3, sup 5, m (3 + 5) / 2 = 4
Si aux >= A[4] (no se cumple la condición) sup = 4
• inf 3, sup 4, m (3 + 4) / 2 = 3
Si aux >= A[3] (no se cumple la condición) sup = 3

activo (i = 5) y luego colocamos aux, en la posición correspondiente.
El vector queda:
1 8 12 18 26 40 14
0 1 2 3 4 5 6
En la sexta pasada
i=6

• inf 0, sup 6, m (0 + 6) / 2 = 3
Si aux >=A[3] (no se cumple la condición) sup = m = 3
• inf 0, sup 3, m (0 + 3) / 2 = 1
Si aux >=A[1] (si se cumple la condición) inf = m + 1 = 2
• inf 2, sup 3, m (2 + 3) / 2 = 2
Si aux >= A[2] (si se cumple la condición) inf = m + 1 = 3

El vector queda:
1 8 12 14 18 26 40
0 1 2 3 4 5 6
Tabla que muestra las diferentes pasadas por el método de inserción binaria
i aux A[0] A[1] A[2] A[3] A[4] A[5] A[6]

1 40 8 40 26 12 1 18 14
2 26 8 26 40 12 1 18 14
3 12 8 12 26 40 1 18 14
4 1 1 8 12 26 40 18 14
5 18 1 8 12 18 26 40 14
6 14 1 8 12 14 18 26 40
Desplazamos hacia la derecha desde el índice activo i hasta (sup+ 1) y luego

colocamos aux, en la posición a[sup].
Inicio
entero: n, a[50]
// Lectura de datos
// Proceso
sortBinaria (a, n)
Fin

entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Procedimiento sortBinaria(entero a[50] , entero n)

entero: i, aux, j, inf, sup, m
i1

aux a[i]
inf 0
sup i
Mientras (inf < sup) Hacer
m (inf + sup) / 2
Si (aux >= a[m]) entonces
inf m + 1
Sino
sup m
Fin_si
Fin_mientras
ji
Mientras (j >= sup +1) Hacer
a[j] a[j-1];
j j - 1;
Fin_mientras
a[sup] aux
a[sup] aux
ii+1
Fin_mientras
Fin_procedimiento

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
4. Métodos de búsqueda
Vivimos en un mundo desarrollado, automatizado y acelerado donde la información

representa un elemento de vital importancia, por lo tanto buscar y recuperar
información es ahora una necesidad. En la vida cotidiana se realizan tareas
esenciales: se busca números telefónicos en un directorio, ofertas laborales en un
periódico, libros en una biblioteca, etc.
4.1. Búsqueda Secuencial
La búsqueda secuencial consiste en revisar elemento hasta encontrar el dato

buscado.
Cuando se habla de búsqueda en arreglos debe de distinguirse entre arreglos
desordenados y arreglos ordenados.
4.1.1. En arreglos desordenados
La búsqueda secuencial en arreglos desordenados consiste básicamente, en

recorrer el arreglo de izquierda a derecha hasta que encuentre el elemento
buscado. Normalmente cuando una función de búsqueda concluya con éxito,
interesa conocer si el elemento pertenece o no al vector.
Sea A el vector

5 3 10 6 19 12 80 40 26
Elemento a buscar 40
Comparamos cada elemento del vector con la clave, como encuentra la clave
devuelve verdad, ya que 40 pertenece al vector.
Algoritmo
Para cada elemento del vector, determina si es igual al elemento buscado,
esta búsqueda es realizado por la función buscaVectorDesordenado, que
devuelve verdad si elemento pertenece al vector y falso si elemento no
pertenece al vector

• Función buscaVectorDesordenado(entero a[50], entero n, entero ele),
pertenece al vector.
• Procedimiento imprimirVector(entero a[50], entero num), imprime el
vector ordenado.
Inicio
entero: n, ele, a[50]
boolean: z
// Lectura de datos
Escribir (“Ingrese elemento a buscar ”)
Leer (ele)
// Imprimir
z buscaVectorDesordenado (a, n1, ele)
Si (z) entonces
Escribir (“Elemento se encuentra en el vector”)
Sino
Escribir (“Elemento no se encuentra en el vector”)
Fin_si
Fin

entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Función buscaVectorDesordenado (entero a[50] , entero n, entero ele)

entero: i
boolean: r
i0
Mientras (a[i] != ele and i < n) Hacer
ii+1

Fin_mientras
r (a[i] = ele)
retornar r
Fin_función

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
4.1.2. En arreglos ordenados
Cuando el arreglo esta ordenado se impone la condición para controlar la

búsqueda:
A[0] <= elemento a buscar <= A[N-1]
Si es falso el elemento no esta en el rango.
Sea A el vector
3 5 6 10 12 19 26 40 80 100
Elemento a buscar 40
Comparamos cada elemento del vector con el elemento a buscar, como
encuentra el elemento a buscar devuelve verdad, ya que 40 pertenece al
vector.
Algoritmo
Para cada elemento del vector a se determina si es igual al elemento
buscado, esta búsqueda es realizado por la función buscaVectorOrdenado,
que devuelve verdad si elemento pertenece al vector y falso si elemento no
pertenece al vector

• Función buscaVectorOrdenado(entero a[50], entero n, entero ele),
pertenece al vector.
• Procedimiento imprimirVector(entero vector[50], entero num), imprime
el vector.
Inicio
boolean: z
// Lectura de datos
Escribir ("Ingrese elemento a buscar ")
Leer (ele)
// Imprimir
z buscaVectorOrdenado (a, n, ele)
Si (z) entonces

Escribir (“Elemento se encunetra en el vector”)

Sino
Escribir (“Elemento no se encunetra en el vector”)
Fin_si
Fin

entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Función buscaVectorOrdenado (entero a[50] , entero n, entero ele) :

booleano
entero: i
boolean: r
i0
Mientras (a[i] < ele and i < n) Hacer
ii+1
Fin_mientras
r (a[i] = ele)
retornar r
Fin_función

// Definir variable
entero: i
Fin_desde
Fin_procedimiento
4.2. Búsqueda binaria
Consiste en dividir el intervalo de búsqueda en dos partes, comparando el

elemento buscado con el elemento medio del vector. En caso de que el
elemento a buscar sea mayor que el elemento medio, se continua la búsqueda
en la segunda mitad del vector; si por el contrario el elemento a buscar es
menor que el elemento medio, la búsqueda continúa en la primera mitad del
vector, en ambos casos se redefinen los extremos del intervalo, disminuyendo
el espacio de búsqueda, repitiendo el proceso hasta que se encuentre el valor a
buscar o hasta que el elemento a buscar no se encuentre en el vector.
Hacemos inf = 0 y sup = n1 - 1

Para Calcular el medio:
medio = (inf + sup ) / 2
Si estamos en la primera mitad del vector hacemos sup = medio - 1
Si estamos en la segunda mitad del vector hacemos inf = medio + 1
Sea A el vector:

3 5 6 10 12 19 26 40 80 100
0 1 2 3 4 5 6 7 8 9
inf medio sup
Elemento a buscar: 80
inf = 0
sup = 9
medio = (inf + sup) / 2 = (0 + 9) / 2 = 4.5 (se toma la parte entero),
a[4] =12 se divide el vector en dos partes
3 5 6 10 12 19 26 40 80 100
0 1 2 3 5 6 7 8 9
Como elemento buscado 80 es mayor que elemento central 12, la búsqueda

continua en la segunda mitad del vector.
inf = 5
sup = 9
medio = (inf + sup) / 2 = (5 + 9) / 2 = 7, a[7] = 40, se divide el vector en dos
partes.
19 26 40 80 100
5 6 8 9
Como elemento buscado 80 es mayor que elemento central 40, la búsqueda

continua en la segunda mitad del vector
inf = 8
sup = 9
medio = (inf + sup) / 2 = (8 + 9) / 2 = 8, a[8] = 80
Como 80 = a[8] la búsqueda acaba, devolviendo verdad, ya que 80 pertenece
al vector.
Algoritmo
Para cada elemento del vector a se determina si es igual al elemento buscado,
esta búsqueda es realizado por la función binario, que devuelve verdad si
elemento pertenece al vector y falso si elemento no pertenece al vector

• Función binario(entero a[50], entero num, entero clave), devuelve un
valor booleano de verdad si elemento pertenece al vector y falso en caso
contrario
• Procedimiento imprimirVector(entero vector[50], entero num), imprime
el vector ordenado.
Inicio
boolean: z
// Lectura de datos
Escribir (“Ingrese elemento a buscar”)
Leer (ele)
// Imprimir
z buscaBinaria(a, n, ele)

Si (z) entonces
Escribir (“Elemento se encuntra en el vector”)
Sino
Escribir (“Elemento no se encunetra en el vector”)
Fin_si
Fin
entero: i
Leer (n)
Leer (a[i])
Fin_desde
Fin_procedimiento
Función buscaBinaria (entero a[50], entero n, entero ele) : booleano

entero: inf, sup, medio 0
boolean: recorre falso, p falso
inf 0
sup n - 1
Si (ele >= a[0] and ele <= a[n-1]) entonces
recorre verdad
Sino
recorre falso
Fin_si
Mientras (recorre) Hacer
medio (inf + sup) / 2
Si (ele > a[medio]) entonces
inf medio + 1
Sino
sup medio- 1
Fin_si
Si (inf <= sup and a[medio] != ele) entonces
recorre verdad
Sino
recorre falso
Fin_si
Fin_mientras
p (a[medio] = ele)
retornar p
Fin_función

entero i
Fin_desde
Fin_procedimiento

Bibliografía
Libros
• Leobardo López, R., (2003), “Programación estructurada: un enfoque
algorítmico”, 2ª. Edición, Editorial Alfaomega México.
• Cairo, Osvaldo, (2000), “Metodología de la Programación: Algoritmos,
Diagramas de Flujo y Programas”, Computec, México.
• Cairo, Osvaldo y Silvia Guardati, (2002), “Estructura de Datos”. Mc Graw-Hill,
México.
• Ceballos, Francisco, Javier, (2002), “Java 2 Curso de programación”.
Alfaomega.
• Joyanes, Luis y otros, (2002), “Java 2 Manual de programación”, Mc Graw-Hill,
México.
• Schildt, Hebert, (2002), “Fundamentos de programación”. Mc Graw Hill.
• Peterson, James y otros, (2003), “Sistemas Operativos conceptos
fundamentales”, Editorial Addison, Barcelona – España.
• Fuster Sabater, Amparo y otros, (2004), “Técnicas Criptográficas de protección
de Datos”, Alfaomega, México.
Enlaces
http://ieslospedroches.seinforma.net/moodle/file.php/5/Pseudocodigo_parte_1.pdf
http://www.unizar.es/ttm/2004-05/Algoritmos.pdf
http://ing.utalca.cl/~fmeza/cursos/2005/cyp/algoritmos2.pdf
http://www.viajayconoce.com/aulaenlinea/

Algoritmos

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Algoritmos

Загружено:

Авторское право:

Доступные форматы

Facultad de Ingeniería de Sistemas, Cómputo y

FRANKLIN ARRIOLA RAMÍREZ

2. Módulos .......................................................................................... 112

1.1. Método de ordenación por selección simple ................................ 253

Bibliografía ......................................................................................... 281

La construcción de programas de computadores es un proceso que involucra las

El presente material esta dirigido principalmente a quienes están iniciando sus

El libro esta organizado en cinco capítulos. En el primer capítulo se contempla

Un algoritmo es un conjunto finito de instrucciones para llevar a cabo una tarea

Cuando un algoritmo está asociado con el procesamiento de información, los datos

Ya en el siglo XIX, se produjo el primer algoritmo escrito para un computador. La

3. Características de los algoritmos

Todo algoritmo debe cumplir las siguientes características:

En la práctica, para evaluar un buen algoritmo se considera el tiempo que requiere

mismo problema, en este caso, se debe decidir por el mejor, considerando su

4. Herramientas para representar algoritmos

Existen varias maneras para representar algoritmos, así, podemos considerar:

4.1. Diagramas de flujo

Los diagramas de flujo, son representaciones gráficas mediante el cual se

Terminal: Indica el inicio y fin del diagrama de

Entrada/Salida: Indica la entrada y salida de

Procesos: Indica la asignación de un valor a

Decisión: Indica la decisión que se toma ante

Subrutina: Representa los subprogramas.

Conector: Representan la continuidad del

Conector: Representan la continuidad del

Impresora: Indica la salida de la información

Pantalla: Indica la salida de la información por

Teclado: se utiliza en ocasiones en lugar del

Comentario: Permite añadir anotaciones al

Flechas de dirección: Dirección en la que se

4.2. Diagramas Nassi-Schneiderman

El diagrama N-S, también conocido como diagrama de Chapin, es como un

Su representación se realiza por medio de cajas rectangulares que se encuentra

Es una mezcla de frases de un idioma nativo (español, inglés, etc.),

La ventaja del pseudocódigo es que en la planificación de un programa, el

Problemas de tipo cotidiano representado en pseudocódigo y/o diagramas de

Pseudocodigo Diagrama de flujo

Hablo con la otra persona

5. Composición de los algoritmos

Escribir ("Introduzca el radio de la circunferencia")

5.1. Sección de datos

En esta sección se encuentran los identificadores (constantes, variables, tipos

Identificador Validez Explicación

Una variable se define como un identificador que se utiliza para almacenar

Es aquel elemento que no cambia de valor durante la ejecución de un

5.1.3. Tipos de datos

El tipo de una variable, define el contenido que ésta tendrá, es decir,

Los datos se clasifican en diversas categorías, según el tipo de máquina o

5.2. Sección del Código

Las expresiones son combinaciones de variables, constantes, operadores,

Una expresión consta de operadores y operandos. Según sea el tipo de

5.2.2. Operadores y Operandos

Operando Operador Operando

Los tipos de operadores son:

Los operadores aritméticos son:

Operador Expresión Aritmética Resultado

Tabla 2. Operadores Aritméticos

Los operadores relacionales son:

Operador Expresión Relacional

< Menor que a<b false

true true true true false

5.2.2.1. Prioridad de los operadores

• Todas las expresiones entre paréntesis se evalúan primero. Las