Fundamentos de Programación - Un Enfoque Práctico

FUNDAMENTOS
DE
PROGRAMACIÓN
Un enfoque práctico
2021
AUTORES:
Eder Nicanor Figueroa Piscoya
Italo Maldonado Ramirez
Roberto Carlos Santa Cruz Acosta
FUNDAMENTOS DE PROGRAMACIÓN.
Un enfoque práctico.
Hecho el Depósito Legal en la Biblioteca Nacional del Perú N° 2021-06111.
Autores:
Eder Nicanor Figueroa Piscoya
Italo Maldonado Ramirez
Roberto Carlos Santa Cruz Acosta
Editor:
Eder Nicanor Figueroa Piscoya.
CORREO: eder.figueroa@untrm.edu.pe
ORCID: https://orcid.org/0000-0001-7970-434X
GOOGLE SCHOLAR: https://scholar.google.com/citations?user=-W8IvJAAAAAJ
DIRECCIÓN: Calle Los Geranios N° 197, Lambayeque, Perú.
TELÉFONO: (+51) 971 456 140
Bagua – Perú
Primera Edición
Junio, 2021
ÍNDICE
Introducción ....................................................................................................... 1
CAPÍTULO I: Introducción a los Fundamentos de Programación y Algoritmia. .... 2
Tema 1. Introducción a los Algoritmos y Programas. ...................................... 3
Algoritmos .................................................................................................. 3
Programas (Software) ................................................................................. 6
Algoritmo vs. Programa .............................................................................. 6
Etapas para la resolución de problemas ..................................................... 6
Tema 2. Conceptos básicos dentro de la Programación. ................................ 7
Dato ........................................................................................................... 7
Tipo de dato ............................................................................................... 7
Identificador ............................................................................................... 7
Constante ................................................................................................... 8
Variable ...................................................................................................... 8
Operadores ................................................................................................ 8
Expresiones ................................................................................................ 9
Tema 3. Diseño de Algoritmos. ..................................................................... 12
Estructura general de un algoritmo .......................................................... 12
Instruciones y sus tipos ............................................................................ 12
Pseudocódigo ........................................................................................... 12
Diagrama de flujo ..................................................................................... 16
Tema 4. Estructura de Control Secuencial. ................................................... 19
CAPÍTULO II: Estructuras de Control Selectivas y Repetitivas. .......................... 24
Tema 5. Estructuras de Control Selectiva Simple y Doble. ............................ 25
Estructura de Control Selectiva o Condicional Simple............................... 25
Estructura de Control Selectiva o Condicional Doble ................................ 30
Tema 6. Estructuras de Control Selectiva Múltiple y Anidada....................... 34
Estructura de Control Selectiva o Conidicional Múltple ............................ 34
Estructura de Control Selectiva o Condicional Anidada ............................ 39
Tema 7. Estructuras de Control Repetitiva “Mientras” y “Desde”/“Para”. ... 46
Contador .................................................................................................. 46
Acumulador .............................................................................................. 46
Estructura de Control Repetitiva o Iterativa “Mientras” ........................... 47
Estructura de Control Repetitiva o Iterativa “Desde” o “Para” ................. 50
Tema 8. Estructuras de Control Repetitiva “Hacer-Mientras” y Anidadas. ... 54
Estructura de Control Repetitiva o Iterativa “Hacer–Mientras” ................ 54
Estructura de Control Repetitiva o Iterativa Anidada ............................... 57
CAPÍTULO III: Sub-algortimos y Estructuras de Datos. ...................................... 60
Tema 9. Sub-Algoritmos. .............................................................................. 61
Funciones ................................................................................................. 62
Procedimientos ........................................................................................ 69
Tema 10. Estructuras de Datos I: Arreglos o Arrays. ..................................... 75
Arreglos Unidimensionales o Vectores ..................................................... 75
Arreglos Bidimensionales o Matrices........................................................ 80
Tema 11. Estructuras de Datos II: Registros.................................................. 84
Tema 12. Arreglos de Registros. ................................................................... 88
Conclusiones y Recomendaciones .................................................................... 95
Bibliografía ....................................................................................................... 96
Introducción
Las principales actividades, donde debe obtener destreza un estudiante que desea
adentrarse en el área de la programación, son la utilización de su ingenio y el desarrollo su
lógica, para lograr resolver problemas de toda índole aplicando la tecnología.
Todo problema se puede resolver haciendo uso de una serie de pasos, incluso si el
problema resulta demasiado grande, pues existen técnicas que nos permitirán abordarlo y
resolverlo sin dificultad. Es por este motivo, que el presente documento, tiene por finalidad
presentar los temas básicos correspondientes a la asignatura de “Fundamento de
programación”, entre los que tenemos: “Algoritmos” como el método indispensable para
resolver problemas; “Pseudocódigo y diagramas de flujos” como las formas de diseñar
algoritmos utilizando las tres Estructuras de control básicas (secuencial, selectiva y repetitiva);
“División del problema y Modularización (Sub-algoritmos)”; y finalmente “Estructuras de
datos: Arreglos y Registros”.
Para el proceso de inducción del estudiante, se tendrá como punto de partida problemas
de índole matemático, ya que, por su educación básica regular, son con los que están más
familiarizados. Así, según como se avance en el desarrollo de los temas, los ejercicios tendrán
directa relación con su desenvolvimiento en activididades cotidianas o de negocios, llegando
a establecer una estructura en la resolución de los mismos.
Cada uno de los temas se abordarán de manera práctica, brindado a los alumnos, la
teoría necesaria y una serie de ejercicios resueltos de modo didáctico para el fácil
entendimiento de los estudiantes. Ahora bien, para el cumplimiento de todo lo antes
mencionado, se tomará en cuenta el pseudocódigo que se plantea en el libro “Fundamentos
de Programación. Algoritmos, estrucuturas de datos y objetos. 4ª Edición” del autor Luis
Joyanes Aguilar (Joyanes, 2008).
El documento está estructurado en 03 Capítulos y cada uno en 04 temas: El primer

capítulo aborda la definición de Algoritmos y sus diferencias con los programas (Software);
definición de términos básicos como identificadores, variables, operadores y expresiones;
diseño de algoritmos con Pseudocódigo y Diagrama de Flujo; y la primera Estructura de
Control: Secuencial. El segundo capítulo comprende: Estructuras de Control: Selectiva y
Repetitiva, cada una de estas con sus diferentes formas. El tercer capítulo aborda el
planteamiento de soluciones con Sub-algoritmos: Funciones y Procedimientos; y el uso de
Estructuras de Datos: Arreglos y Registros.
1
CAPÍTULO I: Introducción a los
Fundamentos de Programación y
Algoritmia.
CONTENIDO
Tema 1. Introducción a los Fundamentos de Programación.

Tema 2. Conceptos básicos dentro de la Programación.
Tema 3. Diseño de Algoritmos.
Tema 4. Estructura de Control Secuencial.
2
Tema 1. Introducción a los Algoritmos y Programas.
ALGORITMOS
Es un método para resolver un problema, conformado por una secuencia finita de pasos
ordenados de manera lógica que se deben seguir para resolver un problema.
Un algoritmo cumple con las siguientes características:
• Preciso: Indicar el orden de cada paso de manera clara y sin ambigüedades.
• Definido: Se debe obtener el mismo resultado cada vez que se ejecute el algoritmo.
• Finito: Debe terminar en algún momento.
Los algoritmos se pueden presentar no solamente ante problemas matemáticos complejos,
sino también con problemas cotidianos, por ejemplo supongamos que queremos ir a ver la
nueva película de Marvel, entonces nos planteamos la siguiente pregunta:
¿Qué hacer para ver la nueva película de superhéroes de Marvel?
La respuesta es muy sencilla y puede ser descrita de la siguiente forma:
Ir al cine.
Comprar una entrada (o ticket).
Ver la película.
Regresar a casa.
Esto representa claramente un algoritmo que consta de cuatro acciones básicas, cada una de
las cuales debe ser ejecutada antes de realizar la siguiente.
La forma en que se respondió a la pregunta anterior se llama Algoritmo en Lenguaje Natural
y como su nombre lo indica se puede redactar en el idioma que más domine el estudiante (en
este caso Español). Pero además le agregaremos una numeración correlativa iniciando en el
paso cero (0. Inicio) y terminando siempre con el paso n (n. Fin), donde n corresponde
al último orden de la numeración. De esta manera el algoritmo anterior queda de la siguiente
manera:
0. Inicio
1. Ir al cine.
2. Comprar una entrada (o ticket).
3. Ver la película.
4. Regresar a casa.
5. Fin
Pero esta no es la única forma de responder a la pregunta, es decir, pueden existir diferentes
formas de resolver el mismo problema, es allí donde el ingenio y la experiencia del estudiante
toman gran importancia. Recuerda que mientras más detallado y preciso sea tu algoritmo,
será mucho mejor la solución.
De esta manera, en el mismo ejemplo de ir al cine podrían haber surgido diferentes
escenarios, como que todas las salas donde transmiten esa película ya están llenas lo cual
requerirá tomar otras acciones, o al comprar una entrada, verificar si hay cola, sino optar por
una compra en línea por medio de la página web del cine o por su aplicación móvil, etc.
Para poder reforzar todo lo antes mencionado se mostrarán problemas resueltos utilizando
Algoritmos en Lenguaje Natural.
3
Ejemplo 1.1
Algoritmo para: Freír un huevo.
0. Inicio.
1. Conseguir sal, aceite, huevo, sartén.
2. Encender una hornilla de la cocina.
3. Colocar la sartén sobre la hornilla encendida.
4. Colocar aceite en la sartén.
5. Esperar a que el aceite se caliente.
6. Quebrar el cascarón del huevo.
7. Colocar el contenido del huevo en la sartén.
8. Colocar sal al gusto.
9. Dejar freír el huevo.
10. Cuando esté listo colocarlo en un plato.
11. Apagar la hornilla de la cocina.
12. Fin.
Ejemplo 1.2
Cambiar el vidrio roto de una ventana.
0. Inicio.
1. Retirar los tozos del vidrio roto.
2. Tomar las medidas del ancho y lago de la ventana.
3. Comprar el vidrio con las respectivas medidas tomadas.
4. Dirigirse a la ventana que será reparada.
5. Colocar el vidrio nuevo en el marco de la ventana.
6. Adherir con pegamento el vidrio al marco de la ventana.
7. Esperar unos minutos a que el pegamento seque.
8. Fin.
Ejemplo 1.3
Preparar palomitas de maíz (pop-corn).
0. Inicio.
1. Colocar una olla sobre el fuego.
2. Agregar aceite.
3. Agregar maíz perla.
4. Agregar sal al gusto.
5. Tapar la olla.
6. Esperar unos minutos hasta que empiece a reventar el maíz.
7. Mover la olla sin abrir la tapa.
8. Apagar el fuego.
4
9. Destapar la olla.
10. Servir.
11. Fin.
Ejemplo 1.4
Subir una foto de la galería del Smartphone como estado a WhatsApp.
0. Inicio.
1. Desbloquear el celular.
2. Abrir la aplicación de WhatsApp.
3. Deslizar hacia la opción Estados.
4. Presionar el botón con el ícono de una cámara.
5. Deslizar hacia arriba para mostrar todas las imágenes.
6. Seleccionar una imagen.
7. Presionar el botón de enviar.
8. Fin.
Ejemplo 1.5
Calcular el valor de la hipotenusa en un triángulo rectángulo, a partir de sus catetos.
0. Inicio.
1. Pedir el valor del cateto 1.
2. Pedir el valor del cateto 2.
3. Calcular la hipotenusa, sacando raíz cuadrada a la suma del
cuadrado de los catetos 1 y 2.
4. Mostrar el resultado de la hipotenusa obtenido.
5. Fin.
Ejemplo 1.6
Calcular el vuelto (o cambio) que un vendedor le debe dar al cliente, a partir del precio del
artículo que se está vendiendo y la cantidad de dinero que el cliente está entregando,
suponiendo que paga con billete mayor al precio del artículo.
0. Inicio.
1. Obtener el precio del artículo.
2. Obtener la cantidad de dinero con la que el cliente está
pagando.
3. Calcular el cambio que es igual a la cantidad de dinero
entregada por el cliente menos el precio del artículo.
4. Entregar la cantidad de dinero equivalente al vuelto calculado.
5. Fin.
5
PROGRAMAS (SOFTWARE)
Es conocida como la parte blanda que indica las tareas que debe realizar un dispositivo
electrónico como una computadora. Estos programas controlan y dirigen a la computadora
para que realice un conjunto de acciones (instrucciones) especificadas por personas
especializadas, llamadas programadores de computadoras.
ALGORITMO vs. PROGRAMA
Un algoritmo no es lo mismo que un programa (software). Un algoritmo es el método para

resolver un problema, mientras que el programa es la implementación del algoritmo bajo
cierto lenguaje de programación (como C++, Java u otro) y ejecutado en una computadora.
Escritura
en C++ Compilación
Problema Algoritmo Algoritmo en C++ Programa

Código máquina
(código fuente) (software)
Figura 1.1. Proceso por el cual un algoritmo llega a convertirse en un progrma (software).
ETAPAS PARA LA RESOLUCIÓN DE PROBLEMAS
El proceso para la resolución de un problema por un computador sigue una serie de fases o
pasos comunes que generalmente deben seguir todos los programadores. Estas son:
1. Análisis del problema, identifica datos de entrada, salida, pasos a seguir y restricciones
o requerimientos adicionales.
2. Diseño del algoritmo, determina cómo hace el programa la tarea solicitada. Aquí se
utilizarán dos herramientas para diseñar algoritmos: Pseudocódigo y Diagramas de
Flujo.
3. Codificación, traduce el algoritmo diseñado a código de lenguaje de programación
(código fuente) y lo convierte en un programa.
4. Compilación y ejecución, comprueba el funcionamiento del programa.
5. Verificación y depuración, se eliminan los errores de compilación, ejecución y lógicos
que existan en el código fuente.
6. Documentación y mantenimiento, evidenciar todo lo trabajado en un documento
detallado de manera que se sepa cómo se elaboró el programa y cómo puede
modificarse o corregirse en el tiempo.
6
Tema 2. Conceptos básicos dentro de la Programación.
DATO
Cifra, letra o palabra que se suministra a la computadora como entrada y la máquina almacena
en un determinado formato. Un dato es una representación simbólica (numérica, alfabética,
algorítmica, espacial, etc.) de un atributo o variable cuantitativa o cualitativa.
Ejemplo 2.1
Son ejemplos de datos los siguientes:
▪ Bruce ▪ Wayne ▪ 27 de mayo de 1970
▪ Gotham City ▪ 1,88 metros ▪ 991 231 078
TIPO DE DATO
Es un atributo de los datos que indica al ordenador sobre la clase de datos que se va a manejar.
La mayoría de las computadoras pueden trabajar con varios tipos de datos:
• Numérico Entero: 5; -15; 20; 1340; 6; 0; -3500; -17;…
• Numérico Real: 0.08; 3.752; 15.01; -8.12; -52.321; 3.0; 3.69×10−18; 0.00003034;…
• Lógico o Booleano: 1 (encendido, verdadero o true); 0 (apagado, falso, o false).
• Carácter y Cadena: Caracteres Alfabéticos (A, B, C, …, Z) (a, b, c, …, z). Caracteres
Numéricos (0, 1, 2, 3, …, 9). Caracteres Especiales (+, -, *, /, ^, ñ, . , é, ; , <, >, $, Ñ, Ä...).
La combinación de los caracteres forma una Cadena.
Ejemplo 2.2
Son los Tipos de datos de cada Dato del Ejemplo 2.1:
Dato Tipo de Dato

“Bruce Wayne” Cadena
“27 de mayo de 1970” Cadena
“Gotham City” Cadena
13 431 Numérico Entero
1,88 Numérico Real
True Lógico
IDENTIFICADOR
Es una secuencia de caracteres, letras, dígitos y subguiones que sirven para nombrar variables
y constantes. Para escribir correctamente un identificador se deben seguir estas reglas:
• Siempre debe comenzar por una letra o subguión. No debe empezar con número.
• No debe tener Espacios en Blanco.
• No debe tener caracteres especiales (#, $, %,…).
• No debe tener letras con Virgulilla (Ñ, ñ), Acento agudo (Á, é, í…), Diéresis (ü, ë, …),
Cedilla, Apóstrofo, etc.
7
Ejemplo 2.3
Son ejemplo de identificadores los siguientes:
nombre apellidos un_identificador

miVariable01 X _cantidad
Ejemplo 2.4
¿Cuáles de los siguientes identificadores no son válidos?
a) XRayo b) X_Rayo c) R2D2

d) X e) 45 f) N14
g) ZZZ h) 3µ i) año
Respuesta: No son válidos e, h, i.
CONSTANTE
Los programas de computadora contienen ciertos valores que no deben cambiar durante la
ejecución del programa. Tales valores se llaman constantes.
Una constante es un dato que permanece sin cambios durante todo el desarrollo del algoritmo
o durante la ejecución del programa. Se les da nombre mediante Identificadores.
Pueden ser de cualquiera de los Tipos de Datos antes mencionados.
VARIABLE
Es un objeto cuyo valor puede cambiar durante el desarrollo del algoritmo o ejecución del
programa. Una variable es un espacio de memoria donde se puede guardar un dato y pueden
ser de cualquiera de los Tipos de Datos antes mencionados.
Para ubicar y trabajar mejor con estos espacios de memoria, se les da un nombre de manera
que el programador pueda diferenciar una variable de otra. Esto se hace mediante
Identificadores, como en el Ejemplo 2.3.
En Programación, todo Dato debe estar contenido en una variable.
OPERADORES
Operadores Aritméticos Símbolo
Suma +
Resta -
Multiplicación *
División /
División Entera DIV
Módulo (Resto de la división) MOD %
Potencia ^ **
Figura 2.1. Operadores aritméticos y su simbología en programación
8
Operadores Relacionales Símbolo
Mayor que >
Menor que <
Mayor o igual que >=
Menor o Igual que <=
Igual que ==
Distinto que != <>
Figura 2.2. Operadores relacionales y su simbología en programación
Operadores Lógicos Símbolo

Conjunción AND &&
Disyunción OR ||
Negación NOT !
Figura 2.3. Operadores lógicos y su simbología en programación
Operador de asignación 
Figura 2.4. Operador de asignación.
PRIORIDAD DE OPERADORES
Prioridad Operador
1 Paréntesis (que, en realidad, no es un operador, pero sirve para dar
prioridad a las operaciones determinadas dentro de una expresión
que contenga varias operaciones)
2 NOT (Operador lógico)
3 * / DIV MOD (Operadores multiplicativos)
4 + - (Operadores aditivos)
5 < <= > >= (Operadores de relación)
6 == != (Operadores de relación)
7 AND (Operador lógico)
8 OR (Operador lógico)
Figura 2.5. Prioridad de los operadores aritméticos, relacionales y lógicos.
EXPRESIONES
Combinación de operadores y operandos. Los operandos pueden ser variables, constantes
(números) y llamadas a funciones.
Las reglas de evaluación de expresiones pueden resumirse en las siguientes:
• Un operando situado entre dos operadores de diferente prioridad se liga al operador
de mayor prioridad. Ej.: 1+2*3 = 1+6 = 7
• Un operando situado entre dos operadores de igual prioridad se liga al operador de la
izquierda. Ej.: 1-2+3 = -1+3 = 2
• Las expresiones entre paréntesis se evalúan primero para ser tratadas como operandos
simples. Ej.: 1*(2+3) = 1*5 = 5
9
Ejemplo 2.5
Evaluar la siguiente expresión, para A=2 y B=5:
3*A–4*B/A^2
Solución:
3 * 2 – 4 * 5 / 2 ^ 2
6 – 20 / 4
6 – 5
1
Respuesta: 1
Ejemplo 2.6
Evaluar la siguiente expresión:
4/2*3/6 + 6 /2/1/5^2/4*2
Solución:
2*3/6 + 3/1 /25 / 4 * 2
6/6 + 3/25 /4 * 2
1 + 0.12/4 * 2
1 + 0.03*2
1 + 0.06
1.06
Respuesta: 1.06
Ejemplo 2.6
Obtener el valor de cada una de las siguientes expresiones:
Expresión Respuesta
7 DIV 2 3
7 / 2 3.5
7 MOD 2 1
12 DIV 3 4
12 MOD 3 0
0 MOD 5 0
15 MOD 5 0
7 * 10 – 50 MOD 3 * 4 + 9 70 – 2*4 + 9 = 71
(7 * -40 MOD 3) * 4 + 9
(-280 MOD 3) * 4 + 9
(7 * (10 – 50) MOD 3) * 4 + 9
2 * 4 + 9
17
10
EXPRESIONES POR COMPUTADORA
Muchas de las expresiones matemáticas que conocemos utilizan símbolos que no se
pueden escribir en un lenguaje de programación como la raíz cuadrada (√‾) o los
exponentes en la potenciación en forma de superíndices (x5). Es por este motivo que
debemo saber como convertir una expresión aritmética o algebraica a una expresión
por computador utilizando unicamente los operadores antes mencionados.
Ejemplo 2.7
Escribir las siguientes expresiones algebraicas como expresiones por computadora:
Expresión algebraica Expresión por computadora
√𝒃𝟐 − 𝟒 𝒂𝒄 (b^2)^(1/2) – 4*a*c
𝒙 𝟐 + 𝒚𝟐
(x^2 + y^2)/z^2
𝒛𝟐
𝟑𝒙 + 𝟐𝒚
(3*x + 2*y)/(2*z)
𝟐𝒛
𝒂+𝒃
(a+b)/(c+d)
𝒄+𝒅
𝟒𝒙𝟐 − 𝟐𝒙 + 𝟕 4*x^2 − 2*x + 7
𝒙 + 𝒚 𝟑𝒙
− (x+y)/x − 3*x/5
𝒙 𝟓
𝒂 𝒙
( ) (a/(b*c))^x
𝒃𝒄
𝒙𝒚𝒛 x * y * z
(𝒚𝟐 – 𝒚𝟏)
(y2–y1)/(x2−x1)
𝒙𝟐 – 𝒙𝟏
𝟐𝝅𝒓 2 * PI * r
𝟒
𝝅𝒓𝟑 4/3 * PI * r^3
𝟑
( 𝒙 𝟐 − 𝒙 𝟏 ) 𝟐 + ( 𝒚 𝟐 − 𝒚𝟏 ) 𝟐 (x2−x1)^2 + (y2-y1)^2
Como se puede apreciar en el Ejemplo 2.7, en ciertas expresiones por computadora

aparecen paréntesis para agrupar expresiones de manera que tenga el mismo sentido
de la expresión algebraica original.
En las expresiones por computadora solamente se usan paréntesis para agrupar
expresiones. No se utilizan corchetes ( [ ] ) ni llaves ( { } ).
11
Tema 3. Diseño de Algoritmos.
El proceso de diseñar algoritmos (para su posterior codificación) consiste en definir las
acciones o instrucciones que resuelven el problema.
ESTRUCTURA GENERAL DE UN ALGORITMO

Conceptualmente un programa se podría visualizar como una caja negra a donde llegan
entradas (datos) y se obtienen salidas (resultados).
Programa
Entrada Salida
(Algoritmo de resolución)
Figura 3.1. Bloques estructurales de un programa
El algoritmo aparte de tener las instrucciones propias que solucionan el problema tambien
deben contar con instrucciones para recepcionar correctamente las Entradas (proporcionadas
por el usuario del programa) y también para presentar las Salidas o los resultados
(generalmente en una pantalla). Todas estas las veremos a continuación.
INSTRUCIONES Y SUS TIPOS

Las instrucciones que se escriben en un algoritmo (y luego en un lenguaje de programación)
son:
• Instrucciones de inicio/fin: delimitan un bloque de instrucciones.
• Instrucciones de asignación: usadas para guardar datos o expresiones en varibles o en
constantes haciendo uso del operador de asignación (ver Figura 2.4).
• Instrucciones de lectura: sirven para capturar los datos de entrada.
• Instrucciones de escritura: sirven para mostrar los datos de salida.
• Instrucciones declarativas: toda variable o constante debe ser reconocida antes de
usarse en el algoritmo, a este acción se le llama Declaración de variables o constantes.
Las instrucciones de un algoritmo pueden plantearse utilizando Lenguaje Natural (como en los
Ejemplo 1.1 – Ejemplo 1.6) de modo que cada persona formule su solución como mejor crea
conveniente pero esto ocasiona una falta de estandarización. Para lograr un entendimiento
entre programadores se han creado diversas herramientas para plantear un algoritmo, dos de
ellas veremos a continuación: Pseudocódigo y Diagrama de Flujo.
PSEUDOCÓDIGO
Son una serie de instrucciones escritas bajo cierta estructura y reglas que inducirán al alumno
a adecuarse y hacer el paso más fácil hacia los lenguajes de programación.
La estructura de todo pseudocódigo luce de la siguiente forma:
12
algoritmo nombre_del_algoritmo
const
lista de constantes
var
lista de variables
inicio
…instrucciones…
…instrucciones…
fin
Figura 3.2. Estructura básica de un Pseudocódigo
En la Figura 3.2 ya se empiezan a notar ciertas reglas que hay que seguir: las letras en negrita
siempre serán en minúsculas, se exige siempre la identación (tabulación o sangría en el
margen izquierdo), el algoritmo estará dividido en diversas secciones que se verán a
continuación.
NOMBRE DEL ALGORITMO
Todo algoritmo escrito en Pseudocódigo comienza con esta línea, y consta de dos partes,
la palabra algoritmo y el identificador que le da nombre al algoritmo (siguiendo las
reglas descritas en el Tema 2 – Identificadores).
algoritmo mi_primer_algoritmo
Figura 3.3. Nombre del algoritmo en Pseudocódigo
DECLARACIÓN DE CONSTANTES
En ciertas ocasiones un algoritmo necesitará de algunas constantes las cuales se deben
declarar antes de ser usadas. Para hacerlo se debe escribir la abreviatura const y en la
siguiente línea, con identación, la lista de constantes con su respectivo valor.
const
PI = 3.1415
HORAS = 24
Figura 3.4. Declaración de dos variables numéricas en Pseudocódigo
La declaración de constantes es opcional ya que va a depender mucho del tipo de

problema que se está resolviendo.
DECLARACIÓN DE VARIABLES
La declaración de variables, al igual que las constantes, es opcional, pero generalmente
los algoritmos hacen uso de variables para ir guardando datos o resultados de las
operaciones por lo que resulta muy necesario escribir esta sección del Pseudocódigo.
Para declarar variables se escribe la abreviatura var y en la siguiente línea, con
identación, la lista de variables especificando qué tipo de dato guardará cada una.
13
var
entero: numero, x, y, z;
real: altura, peso, decimal;
caracter: letra;
booleano: compuerta;
Figura 3.5. Declaración de cinco variables en Pseudocódigo.
Se puede observar en la Figura 3.5 que para cada variable se debe especificar el tipo de
dato que guardará. Además el nombre de las variables deben seguir las reglas de un
Identificador. Si se desean declarar dos o más variables de un mismo tipo de dato (como
altura, decimal y peso) se pueden escribir una tras otra separadas por una coma.
Al finalizar cada línea se debe escribir un punto y coma (;) que indica el fin de la
instrucción declarativa.
INSTRUCCIONES
Las instrucciones del algoritmo deben estar comprendidas entre las instrucciones de
inicio y fin. Las instrucciones intermedias serán de escritura, lectura, asignación.
inicio
x  10;
y  25;
z  x + y;
fin
Figura 3.6. Instrucciones en Pseudocódigo
La Figura 3.6, muestra las instrucciones de inicio/fin que contienen a tres instrucciones
de asignación. Es esta junto con las instrucciones de lectura y escritura las que deben
terminar siempre en punto y coma (;) que indica el fin de la instrucción.
• Asignación: la variable que guarda el dato va al lado izquierdo; el operador de

asignación () en el medio y el dato, variable o expresión, del lado derecho
z  x + y;
Figura 3.7. Sintaxis de una Instrucción de asignación en Pseudocódigo
• Lectura: instrucción que permite capturar un dato de entrada y guardarlo en una

variable previamente declarada.
leer(x);
Figura 3.8. Sintaxis de una Instrucción de lectura en Pseudocódigo
14
• Escritura: instrucción que permite mostrar los datos obtenidos en la pantalla.
escribir(z);
Figura 3.9. Sintaxis de una Instrucción de escritura en Pseudocódigo
A continuación se muestran unos ejemplos de diseño de algoritmo utilizando Pseudocódigo.
Ejemplo 3.1
Realizar un algoritmo para operar la suma de dos números enteros.
algoritmo sumarNumeros
var
entero: num1, num2, suma;
inicio
leer(num1);
leer(num2);
suma  num1 + num2;
escribir(suma);
fin
Ejemplo 3.2
Calcular y visualizar la longitud de la circunferencia y el área de un círculo de radio dado.
algoritmo longitud_area_circunferencia
const
PI=3.1415
var
real: radio, longitud, area;
inicio
leer(radio);
longitud  2 * PI * radio;
area  PI * radio ^ 2;
escribir(“La longitud de la circunferencia es:”, longitud);
escribir(“El área de la circunferencia es:”, radio);
fin
Ejemplo 3.3
Calcular y mostrar la superficie de un triángulo en función de la base y la altura.
algoritmo superficie_triangulo
var
real: base, altura, area;
inicio
leer(base);
leer(altura);
area  (base * altura) / 2;
escribir (“La superficie del triángulo es:”, area);
fin
15
DIAGRAMA DE FLUJO
Es la herramienta para diseñar algoritmos más antigua y solía ser la más utilizada; su empleo
ha disminuido consideralemente desde la aparición de los lenguajes de programación
estructurados.
Un diagrama de flujo utiliza símbolos y describen las instrucciones que debe seguir el
algoritmo.
Símbolo Nombre Descripción

Representa el comienzo: “inicio”; y el final:
“fin” de un programa. Puede representar
Terminal también una parada o interrupción
programada que sea necesario realizar en un
programa.
Cualquier tipo de introducción de datos en la
memoria desde los periféricos, “entrada”, o
Entrada/Salida
registro de la información procesada en un
periférico, “salida”.
Cualquier tipo de operación que pueda
originar cambio de valor, formato o posición
Proceso
de la información almacenada en memoria,
operación aritméticas, de transferencia, etc.
Indicador de dirección Indica el sentido de ejecución de las
o línea de flujo operaciones.
Indica operaciones lógicas o de comparación
entre datos – normalmente dos – y en
función del resultado de la misma determina
NO Decisión
SI cuál de los distintos caminos alternativos del
programa que se debe seguir, normalmente
tiene 2 salidas: SI, NO.
sirve para enlazar dos partes cualesquiera de
un ordinograma a través de un conector en
Conector la salida y otro conector en la entrada. Se
refiere a la conexión en la misma página del
diagrama.
Conexión entre dos puntos del ordinograma

Conector
situado en páginas diferentes.
Una subrutina es un módulo independiente

del programa principal, que recibe una
Llamada a subrutina entrada procedente de dicho programa,
realiza una tarea determinada y al terminar
regresa al programa principal.
Figura 3.10. Símbolos más usados en Diagramas de Flujo.
Los Ejemplos 3.1, 3.2 y 3.3, serán desarrollados a continuación utilizando Diagramas de Flujo.
16
Ejemplo 3.4
Realizar un algoritmo para operar la suma de dos números enteros.
Inicio
Leer num1
Leer num2
suma  num1 + num2
Mostrar suma
Fin
Ejemplo 3.5
Calcular y visualizar la longitud de la circunferencia y el área de un círculo de radio dado.
Inicio
Leer radio
longitud  2 * PI * radio
area  PI * radio ^ 2
Mostrar longitud
Mostrar area
Fin
17
Ejemplo 3.6
Calcular y mostrar la superficie de un triángulo en función de la base y la altura.
Inicio
Pedir base
Pedir altura
area  (base * altura) / 2
Presentar area
Fin
18
Tema 4. Estructura de Control Secuencial.
A finales de los años 1960 surgió una nueva forma de programar que no solamente daba lugar
a programas fiables y eficientes, sino que además estaban escritos de manera que facilitaba
su comprensión posterior. Estas Estructuras de Control son:
• Estructura de Control Secuencial.
• Estructura de Control Selectiva o Condicional.
• Estructura de Control Repetitiva o Iterativa.
ESTRUCTURA SECUENCIAL
Es aquella en donde las instrucciones se ejecutan una tras otra, a modo de secuencia lineal,
es decir que una instrucción no se ejecuta hasta que finaliza la anterior, ni se bifurca el flujo
del programa.
La estructura de control secuencial ya se ha venido trabajando en los ejercicios del Tema 3, en
donde se puede observar que las instrucciones suceden una tras otra, desde el inicio hasta
el fin.
acción 1
acción 2
acción 3
Figura 4.1. Diagrama de Flujo de la Estructura Secuencial
inicio
acción 1;
acción 2;
acción 3;
fin
Figura 4.2. Pseudocódigo de la Estructura Secuencial
19
Ejemplo 4.1
Escribir un programa que lea un número entero y a continuación, visualice su doble y su triple.
Inicio
Pedir numero
algoritmo doble_triple
var
entero: numero, doble, triple;
doble  numero*2 inicio
leer(numero);
doble  numero*2;
triple  numero*3 triple  numero*3 ;
escribir (doble, triple);
fin
Mostrar doble,
triple
Fin
Ejemplo 4.2
La famosa ecuación de Einstein para la conversión de una masa en energía viene dada por la
fórmula: 𝐸 = 𝑚𝑐 2 , donde c es la velocidad de la luz (𝑐 = 2.997925 × 1010 𝑚/𝑠𝑒𝑔). Escriba un
programa que lea la masa en gramos y obtenga la cantidad de energía producida cuando la
masa se convierte en energía. Nota: si la masa se da en gramos, la fórmula produce la energía
en ergios.
Inicio
algoritmo formula_einstein
const
Pedir m C=2.997925 * 10^10
var
real: m, e;
inicio
e  m*c^2 leer(m);
e  m*C^2;
escribir(“La energía de la masa es: ”,
Mostrar e e, “ Ergios”);
fin
Fin
20
Ejemplo 4.3
Escriba un programa que lea las masas m1 y m2 de dos cuerpos separados entre ellos por la
distancia (d) y obtenga la fuerza gravitacional (F) entre ella.
𝐺 ∙ 𝑚1 ∙ 𝑚2
𝐹=
𝑑2
𝑐𝑚3
Constante de gravitación universal 𝐺 = 6.673 × 10−8 𝑠𝑒𝑔2. La salida debe ser en dinas;
𝑔𝑟
𝑐𝑚
una dina es igual a 𝑔𝑟. 𝑠𝑒𝑔2 .
Inicio
Pedir m1 algoritmo fuerza_gravitacional

const
G= 6.673*10^-8
Pedir m2 var
real: m1, m2, d, f;
inicio
Pedir d leer(m1);
leer(m2);
leer(d);
f(G*m1*m2)/d^2;
F(G*m1*m2)/d^2 escribir(f);
fin
Mostrar F
Fin
Ejemplo 4.4
Escribir un programa para convertir una medida dada en pies a sus equivalentes en: a) yardas;
b) pulgadas; c) centímetros; y d) metro. (1 pie: 12 pulgadas, 1 yarda= 3 pies, 1 pulgada= 2.54
cm, 1 metro= 100 cm). Leer el número de pies e imprimir el número de yardas, pies, pulgadas,
centímetros y metros.
algoritmo fuerza_gravitacional
var
real: pie, yr, pg, cm, mt;
inicio
leer(pie);
yr  pie/3;
pg  pie*12;
cm  pg*2.54;
mt  cm/100;
escribir(pie, yr, pg, cm, mt);
fin
21
Inicio
Pedir pie
yr  pie/3
pg  pie*12
cm  pg*2.54
mt  cm/100
Mostrar pie, yr,

pg, cm, mt
Fin
Ejemplo 4.5
Escribir un programa que solicite al usuario una cantidad de Soles y divida la cantidad entre
billetes y monedas de curso legal (cambio óptimo) de Perú.
algoritmo billetes_monedas
var
real: soles;
entero: b200, cb100, b50, b20, b10;
real: m5, m2, m1, c050, c020, c010, c005;
inicio
leer(soles);
//conversión de billetes entre 200 a 10:

b200  soles DIV 200;
soles  soles MOD 200;
b10  soles MOD 10;
soles  soles DIV 10;
22
//Conversión en monedas entre 5 a 1:
m5  soles DIV 5;
m2  soles DIV 2;
m1  soles DIV 1;
//Conversión en céntimos entre 0.50 a 0.05:

soles  soles * 100;
c050  soles DIV 50;
escribir(“Cant. Billetes de 200: ”, b200);

escribir(“Cant. Monedas de 5: ”, m5);
escribir(“Cant. Céntimos de 0.50: ”, c050);
fin
23
CAPÍTULO II: Estructuras de Control
Selectivas y Repetitivas.
CONTENIDO
Tema 5. Estructuras de Control Selectiva Simple y Doble.

Tema 6. Estructuras de Control Selectiva Múltiple y Anidada.
Tema 7. Estructuras de Control Repetitiva “Mientras” y “Desde”/“Para”.
Tema 8. Estructuras de Control Repetitiva “Hacer-Mientras” y Anidadas.
24
Tema 5. Estructuras de Control Selectiva Simple y Doble.
La estructura de control Selectiva o Condicional se usa cuando existen un número de posibles
alternativas resultantes de la evaluación de una determinada condición. En la estructura
selectiva se evalúa una condición y en función de este resultado se realiza una operación u
otra.
La condición no es más que una expresión lógica, es decir, se deben utilizar operadores
relacionales y operadores lógicos (vistos en el Tema 2).
Existen tres formas básicas de estructuras de control (E.C.) selectivas y una última que es la
combinación de estas tres:
• E.C. Selectiva Simple.
• E.C. Selectiva Doble.
• E.C. Selectiva Múltiple.
• E.C. Selectiva Anidada.
ESTRUCTURA DE CONTROL SELECTIVA O CONDICIONAL SIMPLE

La estructura condicional simple evalúa una condición y:
• Si la condición es verdadera, entonces ejecuta la acción S1 (y las que siguen).
• Si la condición es falsa, entonces no hacer nada.
FALSO
condición
VERDADERO
acción S1
Figura 5.1. Diagrama de Flujo de la Estructura Selectiva Simple
si (<condición>) entonces
<acción S1>;
<acción S2>;
...
fin_si
Figura 5.2. Pseudocódigo de la Estructura Selectiva Simple
25
Ejemplo 5.1
Leer una temperatura en grados centígrados e indicar si es superior a 100 mostrar el mensaje
“por encima del punto de ebullición”.
Inicio algoritmo punto_ebullicion

var
real: g;
inicio
Leer g leer (g);
si (g > 100) entonces
escribir(“Por encima del punto
FALSO de ebullición”);
g>=100 fin_si
fin
VERDAD
Mostrar “Por
encima del punto
de ebullición”
Fin
Ejemplo 5.2
Leer un número entero mostrar un mensaje si es que este es impar.
Inicio algoritmo numero_impar

var
entero: num;
inicio
Leer num
leer (num);
si (num MOD 2 == 0) entonces
escribir(“Es impar”);
FALSO fin_si
num MOD 2 == 1
fin
VERDAD
Mostrar “Es impar”
Fin
26
Ejemplo 5.3
Leer un ángulo en grados centesimales y mostrar un mensaje si el ángulo es recto; si es agudo
o si es obtuso.
Inicio algoritmo angulo_centesimal

var
real: gc;
inicio
Pedir gc
leer(gc);
si ((gc > 0) AND (gc < 100)) entonces
escribir(“Es un ángulo agudo”);
FALSO fin_si
(gc>0) AND (gc<100)
si (gc == 100) entonces
VERDAD escribir(“Es un ángulo recto”);
fin_si
Mostrar “Es un
ángulo agudo” si ((gc > 100) AND (gc < 200)) entonces
escribir(“Es un ángulo obtuso”);
fin_si
fin
FALSO
gc==100
VERDAD
Mostrar “Es un
ángulo recto”
FALSO
(gc>100) AND (gc<200)
VERDAD
Mostrar “Es un
ángulo obtuso”
Fin
27
Ejemplo 5.4
Solicitar por teclado dos números. Si el primero es mayor que el segundo, mostrar el mensaje
“El primer número es el mayor”. Si el primero es menor que el segundo, mostrar el mensaje “El
primer número es el más pequeño”. Considerar el caso que ambos sean iguales e imprimir el
mensaje correspondiente.
Inicio
algoritmo mayor_menor_igual
var
Pedir num1, num2 real: num1, num2;
inicio
leer (num1, num2);
si (num1 > num2) entonces
F escribir(“El primer número es
num1>num2 mayor”);
fin_si
V
si (num1 < num2) entonces
Mostrar “El primer escribir(“El primer es más
número es mayor” pequeño”);
fin_si
si (num1==num2) entonces
escribir(“Ambos números son
iguales”);
F fin_si
num1<num2 fin
V
Mostrar “El primer
es más pequeño”
F
num1==num2
V
Mostrar “Ambos
números son iguales”
Fin
28
Ejemplo 5.5
Dados tres números decimales mostrar el promedio y si este promedio es mayor o igual que
12, mostrar el mensaje “Nota aprobatoria”.
Inicio algoritmo promedio_aprobado

var
real: num1, num2, num3, p;
Pedir num1, inicio
num2, num3 leer(num1, num2, num3);
p  (num1 + num2 + num3)/3;
si (p >= 12) entonces
p  (num1 + num2 + num3)/3 escribir(“Nota aprobatoria”);
fin_si
escribir(p);
F fin
p >= 12
V
Mostrar “Nota
aprobatoria”
Mostrar p
Fin
29
ESTRUCTURA DE CONTROL SELECTIVA O CONDICIONAL DOBLE
La estructura anterior (condicional simple) es muy limitada y normalmente se necesitará una
estructura que permita elegir entre dos opciones o alternativas posibles, en función del
cumplimiento o no de una determinada condición.
• Si la condición es verdadera, se ejecuta la acción S1.
• Si es falsa, se ejecuta la acción S2.
La acción S1 y S2, representan tanto a una acción individual o a múltiples acciones (lectura,
escritura, asignación, etc.).
VERDADERO FALSO
condición
acciones S1 acciones S2
Figura 5.3. Diagrama de Flujo de la Estructura Condicional Doble
si (<condición>) entonces
<acción S11>;
<acción S12>;
...
si_no
<acción S21>;
<acción S22>;
...
fin_si
Figura 5.4. Pseudocódigo de la Estructura Condicional Doble
30
Ejemplo 5.6
Leer un ángulo en grados sexagesimales y verificar si el ángulo es recto o no lo es.
Inicio
algoritmo angulo_recto
var
Leer gs entero: gs;
inicio
leer(gs);
V F si (gs == 90) entonces
gs == 90
escribir(“Ángulo recto”);
si_no
escribir(“Ángulo no
Mostrar Mostrar
recto”);
“Angulo “Angulo
fin_si
recto” no recto”
fin
Fin
Ejemplo 5.7
Solicitar dos números y mostrar el promedio verificando si el promedio es mayor o igual a 13,
el mensaje “Aprobado” y si no lo es, mostrar “Desaprobado”.
Inicio
Pedir num1, num2
P ← (num1 + num2)/2
V F
P>=13
Mostrar Mostrar
“Aprobado” “Desaprobado”
”
Mostrar P
Fin
31
algoritmo aprobado_desaprobado
var
real: num1, num2, P;
inicio
leer(num1, num2);
P ← (num1 + num2)/2;
si (p>=13) entonces
escribir(“Aprobado”);
si_no
escribir(“Desaprobado”);
fin_si
escribir(P);
fin
Ejemplo 5.8
Solicitar un número entero por teclado y verificar si es par o impar.
Inicio
algoritmo par_impar
var
entero: num, r;
Pedir num inicio
leer (num);
V F escribir(“Par”);
num MOD 2 == 0
si_no
escribir(“Impar”);
fin_si
Mostrar Mostrar fin
“Par” “Impar”
Fin
Ejemplo 5.9
Dado como dato el sueldo de un trabajador (en S/), considera un aumento del 45% si su sueldo
es inferior a S/.1000, de lo contrario realiza un descuento del 10%. Finalmente mostrar el
sueldo con el aumento o el descuento efectuado.
algoritmo sueldo_trabajador
var
real: sueldo, sueldo_final, aumento,
descuento;
inicio
leer(sueldo);
si (sueldo < 1000) entonces
aumento  sueldo * 0.45;
sueldo_final  sueldo + aumento;
32
si_no
descuento  sueldo * 0.10;
sueldo_final  sueldo – descuento;
fin_si
escribir(“Sueldo a pagar: ”, sueldo_final);
fin
Inicio
Pedir sueldo
V F
sueldo<1000
aumento ← sueldo*0.45 descuento ← sueldo*0.1
sueldo_final ← sueldo+aumento sueldo_final ← sueldo-descuento
Mostrar sueldo_final
Fin
Ejemplo 5.10
Leer dos números enteros y visualice el menor de los dos.
Inicio
algoritmo numero_menor
Leer num1, num2 var
entero: num1, num2;
inicio
leer(num1, num2);
V F
num1<num2 si (num1<num2) entonces
escribir(num1, “ es el
menor”);
si_no
Mostrar Mostrar escribir(num2, “ es el
num1 “es num2 “es menor”);
el menor” el menor” fin_si
fin
Fin
33
Tema 6. Estructuras de Control Selectiva Múltiple y Anidada.
ESTRUCTURA DE CONTROL SELECTIVA O CONIDICIONAL MÚLTPLE
Con frecuencia —en la práctica— es necesario que existan más de dos elecciones posibles; si
el número de alternativas es grande puede plantear serios problemas de escritura del
algoritmo y naturalmente de legibilidad.
La estructura de decisión múltiple evaluará una expresión que podrá tomar n valores distintos,
1, 2, 3, 4, ..., n. Según se elija uno de estos valores en la condición, se realizará una de las n
acciones, o lo que es igual, el flujo del algoritmo seguirá un determinado camino entre los n
posibles.
Solo en la estructura condicional múltiple, la condición será representada por una expresión
aritmética (o por una variable de tipo numérica). Es decir, que a diferencia de las anteriores
estructuras de control condicionales donde el resultado de evaluar una condición tomaba solo
dos valores: verdadero o falso, ahora en la E.C. Condicional Múltiple la expresión (o variable)
dará como resultado un valor numérico el cual representará a un caso en particular de los n
que existan.
expresión
1 2 3 4 n
acciones S1 acciones S2 acciones S3 acciones S4 . . . acciones Sn
Figura 5.5. Diagrama de flujo de la Estructura Condicional Múltiple.
segun_sea (<expresión ó variable>) hacer

caso 1: <acción S11>;
<acción S12>;
...
caso 2: <acción S21>;
<acción S22>;
...
...
caso n: <acción Sn1>;
<acción Sn2>;
...
fin_segun
Figura 5.6. Pseudocódigo de la Estructura Condicional Múltiple.
34
Ejemplo 6.1
Se desea diseñar un algoritmo que escriba los nombres de los días de la semana en función del
valor de una variable DIA introducida por teclado.
Inicio
Leer dia
dia
1 2 3 4 5 6 7 si_no
Mostrar Mostrar Mostrar Mostrar

“Lunes” “Miércoles” “Viernes “Domingo
” ”
Mostrar Mostrar Mostrar Mostrar

“Martes “Jueves “Sábado” “ERROR”
” ”
Fin
algoritmo dia_semana
var
entero: dia;
inicio
escribir(“Ingrese día: ”);
leer(dia);
segun_sea (dia) hacer
caso 1: escribir(“Lunes”);
caso 2: escribir(“Martes”);
caso 3: escribir(“Miércoles”);
caso 4: escribir(“Jueves”);
caso 5: escribir(“Viernes”);
caso 6: escribir(“Sábado”);
caso 7: escribir(“Domingo”);
si_no : escribir(“ERROR: Día no válido.”);
fin_segun
fin
35
Ejemplo 6.2
Se desea diseñar un algoritmo que escriba los nombres de los meses del año en función del
valor de una variable MES introducida por teclado.
Inicio
Leer mes
mes
1
2 3 4 5 6 7 8 9
Mostrar
Mostrar Mostrar Mostrar
“Enero” “Julio” “Octubre”
“Abril”
Mostrar
Mostrar Mostrar Mostrar
“Mayo” “Noviembre”
“Febrero” “Agosto”
Mostrar
Mostrar Mostrar
Mostrar “Diciembre”
“Junio” “Septiembre”
“Marzo”
Fin
algoritmo mes_del_anio
var
entero: mes;
inicio
leer(mes);
segun_sea (mes) hacer
caso 1: escribir(“Enero”);
caso 2: escribir(“Febrero”);
caso 3: escribir(“Marzo”);
caso 4: escribir(“Abril”);
caso 5: escribir(“Mayo”);
caso 6: escribir(“Junio”);
caso 7: escribir(“Julio”);
caso 8: escribir(“Agosto”);
caso 9: escribir(“Septiembre”);
caso 10: escribir(“Octubre”);
caso 11: escribir(“Noviembre”);
caso 12: escribir(“Diciembre”);
fin_segun
fin
36
Ejemplo 6.3
Leer dos números decimales y uno entero. Si el número entero ingresado es 1, se visualiza la
suma de los dos números decimales; si es 2, se visualiza la diferencia; si es 3, se visualiza el
producto; si es 4 se visualiza el cociente (validando el denominador mayor a cero); y finalmente
si es 5 se visualiza el resto.
Inicio
Leer num1, num2
Leer opcion
opcion
1 2 3 4 5 si_no
result ← num1 + num2 result ← num1 * num2 num2!=0 F
result ← num1 MOD num2
num2!=0
result ← num1 - num2 F
result ← num1 / num2
Mostrar
“Error”
Mostrar result
Fin
37
algoritmo operaciones_numeros
real: num1, num2, result;
entero: opcion;
inicio
leer(num1, num2);
leer(opcion)
segun_sea (opcion) hacer
caso 1: result ← num1 + num2;
caso 2: result ← num1 – num2;
caso 3: result ← num1 * num2;
caso 4:
si (num2 != 0) entonces
result ← num1 / num2;
fin_si
caso 5:
si (num2 != 0) entonces
result ← num1 MOD num2;
fin_si
si_no: escribir(“Error: opción no válida”);
fin_segun
escribir(result);
fin
38
ESTRUCTURA DE CONTROL SELECTIVA O CONDICIONAL ANIDADA
También llamada Estructura Condicional en Cascada. Encontramos numerosos casos en el
desarrollo de la solución de problemas en el que luego de tomar una decisión y marcar el
camino correspondiente a seguir, es necesario tomar otra decisión. Se señala, luego de evaluar
las condiciones, la rama correspondiente a seguir, y nuevamente podemos tener que tomar
otra decisión.
A continuación se muestran algunos ejemplos de las formas en que se pueden combinar y
anidar las diferentes estructuras de control selectivas.
F
condición 1
si(<condición 1>) entonces

V si(<condición 2>) entonces
acción S211;
acción S212;
V condición 2 F ...
si_no
acciones S22 acción S221;
acciones S21
acción S222;
...
fin_si
fin_si
Figura 5.7. Diagrama de flujo y Pseudocódigo de una E.C. Selectiva Anidada: Simple - Doble.
si(<condición 1>)entonces
acción S211;
V F
condición 1 acción S212;
...
si_no
condición 3 acción S221;
condición 2 F acción S222;
V F
...
V
acciones S21 acciones S22 fin_si
si_no
acciones S31
acción S311;
acción S312;
...
fin_si
fin_si
Figura 5.8. Diagrama de flujo y Pseudocódigo de una E.C. Selectiva Anidada: Doble - Doble - Simple.
39
Ejemplo 6.4
Diseñar un algoritmo que lea tres números enteros y visualice en pantalla el valor del más
grande. Se supone que los tres valores son diferentes.
Inicio
Leer n1, n2, n3
V n1>n2 F
n1>n3 n2>n3
V F V F
mayor  n1 mayor  n3 mayor  n2 mayor  n3
Mostrar mayor
Fin
algoritmo numero_mayor_de_tres
entero: n1, n2, n3, mayor;
inicio
leer(n1, n2, n3);
si (n1 > n2) entonces
mayor  n1;
si_no
mayor  n3;
fin_si
si_no
mayor  n2;
si_no
mayor  n3;
fin_si
fin_si
escribir(“El número mayor es: ”, mayor);
fin
40
Ejemplo 6.5
Resolver una ecuación de segundo grado, que tiene la siguiente forma: 𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0
−𝑏±√𝑏2 −4𝑎𝑐
Se pide hallar los dos posibles valores para x usando la fórmula cuadrática: 𝑥 = 2𝑎
Considerar el caso que x llegue a obtener números imaginarios deberá mostrarlos como
corresponde, por ejemplo: 2 + 3i ; -4 + 5i.
algoritmo numero_mayor_de_tres
real: a, b, c, x1, x2, det, valor, coef_i;
inicio
escribir(“Ingrese los coeficientes: ”);
leer(a, b, c);
si (a != 0) entonces
det  b^2 - 4*a*c;
si (det < 0) entonces
det  det * (-1);
valor  (-1)*b / (2*a);
coef_i  det ^(1/2) / (2*a);
escribir(“x1 = ”, valor, “+”, coef_i, “i”);
escribir(“x2 = ”, valor, “-”, coef_i, “i”);
si_no
si (det > 0) entonces
x1  ((-1)*b + det ^(1/2)) / (2*a);
x2  ((-1)*b - det ^(1/2)) / (2*a);
escribir(“x1 = ”, x1);
escribir(“x2 = ”, x2);
si_no
x1  (-1)*b / (2*a);
escribir(“x1 = x2 = ”, x1);
fin_si
fin_si
fin_si
fin
Inicio
Leer a, b, c
F
a!=0
det  b^2 - 4*a*c
Pág.42 Pág.42
(A) (B)
41
Pág.41 Pág.41
(A) (B)
V F
det<0
V F
det  det*(-1) det>0
valor  (-1)*b/(2*a)
x1((-1)*b+det^(1/2))/(2*a)
x1(-1)*b/(2*a)
coef_i  (det^(1/2))/(2*a) x2((-1)*b-det^(1/2))/(2*a)
Mostrar “x1=”, valor, Mostrar “x1=”,x1 Mostrar “x1=x2=”,x1

“+”, coef_i, “i”
Mostrar “x2=”,x2
Mostrar “x2=”, valor,
“-”, coef_i, “i”
Fin
Ejemplo 6.6
Cuatro números enteros comprendidos entre 0 y 100 representan las calificaciones de un
estudiante del curso de Fundamentos de Programación. Desarrollar un algoritmo para
encontrar el promedio de estas calificaciones, luego se debe mostrar este promedio y la escala
que obtuvo, según la siguiente tabla:
42
Inicio
Leer num1, num2, num3, num4
(0<=num1 AND num1<=100) AND

F (0<=num2 AND num2<=100) AND
(0<=num3 AND num3<=100) AND
(0<=num4 AND num4<=100)
prom(num1+num2+num3+num4)/4
V
prom>=0 AND prom<60 Mostrar “E”
F
V
prom<70 Mostrar “D”
F
V
prom<80 Mostrar “C”
F
V
prom<90 Mostrar “B”
Mostrar “A”
Fin
43
algoritmo promedio_rango
entero: num1, num2, num3, num4;
real: prom;
inicio
leer(num1, num2, num3, num4);
si((0<=num1 AND num1<=100) AND (0<=num2 AND num2<=100) AND (0<=num3
AND num3<=100) AND (0<=num4 AND num4<=100))entonces
prom  (num1 + num2 + num3 + num4)/4;
si(prom>=0 AND prom<60)entonces
escribir(“E”);
si_no
si(prom<70)entonces
escribir(“D”);
si_no
si(prom<80)entonces
escribir(“C”);
si_no
si(prom<90)entonces
escribir(“B”);
si_no
escribir(“A”);
fin_si
fin_si
fin_si
fin_si
fin_si
fin
Ejemplo 6.7
Diseñe un algoritmo utilizando pseudocódigo para determinar el signo zodiacal de una persona
de acuerdo a su día y mes de nacimiento. (Considerar siempre a Febrero con 28 días).
algoritmo dia_mes_zodiaco
entero: dia, mes;
inicio
leer (dia, mes);
segun_sea (mes) hacer
caso 1:si (dia>=1 AND dia<=31) entonces
si (dia>=1 AND dia<=20) entonces
escribir (“Tu signo zodiacal es Capricornio);
si_no
escribir (“Tu signo zodiacal es Acuario”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Acuario”);
si_no
escribir (“Tu signo zodiacal es Piscis”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Picis”);
si_no
escribir(“Tu signo zodiacal es Aries”);
fin_si
fin_si
44
escribir (“Tu signo zodiacal es Aries”);
si_no
escribir (“Tu signo zodiacal es Tauro”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Tauro”);
si_no
escribir (“Tu signo zodiacal es Geminis”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Geminis”);
si_no
escribir (“Tu signo zodiacal es Cancer”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Cancer”);
si_no
escribir (“Tu signo zodiacal es Leo”)
fin_si
fin_si
escribir (“Tu signo zodiacal es Leo”);
si_no
escribir (“Tu signo zodiacal es Virgo”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Virgo”);
si_no
escribir (“Tu signo zodiacal es Libra”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Libra”);
si_no
escribir (“Tu signo zodiacal es Escorpio”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Escorpio”);
si_no
escribir (“Tu signo zodiacal es Sagitario”);
fin_si
fin_si
escribir (“Tu signo zodiacal es Sagitario”);
si_no
escribir (“Tu signo zodiacal es Capricornio”);
fin_si
fin_si
si_no: escribir (“Error”);
fin_segun
fin
45
Tema 7. Estructuras de Control Repetitiva “Mientras” y
“Desde”/“Para”.
Las computadoras están diseñadas para ejecutar procesos en los cuales una operación o
conjunto de ellas debe repetirse muchas veces. Por ejemplo: un programa que lea una lista de
números para cierto propósito o registrar múltiples datos a un sistema.
Las estructuras que repiten una secuencia de instrucciones un número determinado de veces
se denomina bucle. Al hecho de repetir la ejecución de esta secuencia de instrucciones se le
llama iteración, de donde viene el otro nombre de estas estructuras: Iterativas.
Existen tres formas básicas de estructuras de control (E.C.) repetitivas y una última que es la
combinación de estas tres:
• E.C. Repetitiva “Mientras”.
• E.C. Repetitiva “Desde” o “Para”.
• E.C. Repetitiva “Hacer-Mientras”.
• E.C. Repetitiva Anidada.
Para poder utilizar estas estructuras de control, es necesario conocer qué es y cómo funciona
un contador y un acumulador.
CONTADOR
Es una variable que se incrementa en 1 unidad cada vez que se ejecuta un proceso. Es
utilizado para llevar la cuenta de determinadas acciones que se pueden solicitar durante la
resolución de un problema.
La variable se inicializa generalmente en cero (0) y se le agrega 1 después de los procesos que
creamos convenientes.
Sintaxis:
contador  contador + constante;
Ejemplo:
persona  persona + 1; cantidad  cantidad + 1;
x  x + 2; stock  stock - 3;
ACUMULADOR
Es una variable cuya misión es almacenar cantidades que pueden variar. Se usa para efectuar
sumas sucesivas.
La principal diferencia con el contador es que el incremento o decremento de cada suma es
variable y no contante (como en el caso del contador: de 1 en 1).
Sintaxis:
acumulador  acumulador + variable;
Ejemplo:
suma  suma + edad; pago  pago + monto;
total  total – descuento;
46
ESTRUCTURA DE CONTROL REPETITIVA O ITERATIVA “MIENTRAS”
Estructura adecuada para utilizar en un bucle cuando no sabemos el número de veces que
éste se ha de repetir.
Cuando se ejecuta la instrucción mientras la primera cosa que sucede es que se evalúa la
condición (expresión lógica):
• Si la condición es verdadera, se ejecuta el cuerpo del bucle, después de lo cual se evalúa
de nuevo la expresión lógica.
• Si la condición es falsa, no se toma ninguna acción y el programa prosigue a la siguiente
instrucción después del bucle.
...
F
condición
mientras (<condición>) hacer
acción S11;
V
acción S12;
...
acción S1 fin_mientras
...
Figura 7.1. Diagrama de Flujo y Pseudocódigo de E.C. Repetitiva “Mientras”.
Ejemplo 7.1
Contar los números positivos introducidos por teclado. Se consideran dos variables enteras
número y contador. Se supone que se leen positivos y se detiene el bucle cuando se lee un
número negativo o cero
algoritmo cuenta_enteros_positivos
entero: numero, contador;
inicio
contador  0;
leer (numero);
mientras (numero > 0) hacer
contador  contador + 1;
leer(numero);
fin_mientras
escribir(“Cantidad de números positivos: ”, contador);
fin
47
Inicio
contador  0
Leer numero
numero > 0 F
contador  contador + 1
Leer numero
Mostrar contador
Fin
Ejemplo 7.2
Leer una cantidad ilimitada de números y por cada uno que es leído mostrar si es par o impar.
Solo si el valor leído es cero (00) detener la lectura de datos y terminar el programa.
Inicio
Leer num
F
num != 0
V F
num
num MOD
MOD 22 ==
== 00
Mostrar “Es par” Mostrar “Es impar”
Leer num
Fin
48
algoritmo par_impar
var
entero: num;
inicio
leer (num);
mientras (num != 0) hacer
escribir (“Es par”);
si_no
escribir (“Es impar”);
fin_si
leer (num);
fin_mientras
fin
Ejemplo 7.3
Mostrar el número mayor de una serie de números ingresados por teclado. Salir del bucle sólo
cuando se ingresa un número negativo.
Inicio
mayor  0
algoritmo numero_mayor
Leer num var
entero: num, mayor;
inicio
mayor  0;
num >= 0
F leer (num);
V mientras (num >= 0) hacer
si (num > mayor) entonces
num > mayor mayor  num;
F fin_si
V
leer (num);
mayor  num fin_mientras
escribir(“Número Mayor: ”, mayor);
fin
Leer num
Mostrar mayor
Fin
49
ESTRUCTURA DE CONTROL REPETITIVA O ITERATIVA “DESDE” O “PARA”
Estructura algorítmica adecuada para utilizar en un bucle que se ejecutará un número definido
de veces, es decir, se conoce de antemano la cantidad de iteraciones.
La estructura desde o para consta de 03 partes:
1. La inicialización del contador de iteraciones, con el valor inicial del bucle.
2. Una condición (en función del contador), que limita el número de iteraciones que
tendrá el bucle.
3. El incremento (o decremento) en el contador de iteraciones. También llamado Paso.
...
iniciar contador
F
condición
acción S1
paso
...
Figura 7.2. Diagrama de Flujo de E.C. Repetitiva “Desde” o “Para”
desde (iniciador) hasta (condición) [inc|dec paso] hacer

<acción 1>;
...
<acción N>;
fin_desde
para (iniciador) hasta (condición) [inc|dec paso] hacer

<acción 1>;
...
<acción N>;
fin_para
Figura 7.3. Pseudocódigo de E.C. Repetitiva “Desde” o “Para”
50
Ejemplo 7.4
Mostrar en pantalla los números del 1 al 50.
Inicio
algoritmo lista_numeros
contador←1 var
entero: cont;
inicio
desde(cont1)hasta(cont<=50) inc 1 hacer
contador <= 50 escribir(cont);
F fin_desde
V fin
Mostrar contador
contador ← contador + 1
Fin
Ejemplo 7.5
Mostrar en pantalla la suma de las siguientes sumas sucesivas: 1/2 + 1/3 + 1/4 + 1/5 +...+ 1/50.
Inicio
suma  0
algoritmo sumar_numeros
var
n  2
entero: n;
real: suma;
inicio
n <= 50 desde(n2)hasta(n<=50) inc 1 hacer
F
V suma  suma + 1/n;
fin_desde
escribir(suma);
suma  suma + 1/n fin
Mostrar suma
n  n + 1
Fin
51
Ejemplo 7.6
Ingresar un número comprendido entre 10 a 20 y guardarlo en una variable N. Luego imprimir
de manera decreciente la serie de todos los números desde N hasta cero (00) y además mostrar
la suma de todos estos números de la serie. Ejemplo: Se ingresa el número 11, entonces en
pantalla mostrar: “11, 10, 9, 8, …. ,0” y luego mostrar el resultado de la suma de
11+10+9+8+...+0=66.
Inicio
Leer N
algoritmo sum_numeros_consecutivos
F N>=10 AND N<=20 var
V entero: N, suma, i;
inicio
suma  0 leer (N);
si (N>=10 AND N<=20) entonces
suma  0;
i  N
desde (iN) hasta (i >= 0) dec 1 hacer
escribir(i);
suma  suma + i;
i >= 0 fin_desde
F
escribir (suma);
V
fin_si
Mostrar i fin
suma  suma + i
i  i – 1
Mostrar suma
Fin
Ejemplo 7.7
Obtener la factorial de un número ingresado por teclado. La factorial de un número “N", es la
multiplicación de todos los números enteros desde el 1 hasta N.
Ejemplo: Factorial de 10: 10! = 10*9*8*...*3*2*1 = 3 628 800.
52
Inicio
Leer N
N > 0 algoritmo factorial

F
var
V entero: N, fact, i;
fact  1 inicio
leer(N);
si (N > 0) entonces
i  1 fact  1;
desde (i1) hasta (i<=N) inc 1 hacer
fact  fact * i ;
i <= N fin_desde
F escribir(fact);
V fin_si
fin
fact  fact * i
i  i + 1
Mostrar fact
Fin
53
Tema 8. Estructuras de Control Repetitiva “Hacer-Mientras” y
Anidadas.
ESTRUCTURA DE CONTROL REPETITIVA O ITERATIVA “HACER–MIENTRAS”
En numerosas ocasiones se necesita que el conjunto de sentencias que componen el cuerpo
se ejecuten al menos una vez sea cual sea el valor de la expresión o condición evaluada. Estos
bucles se denominan post-test (a diferencia de las E.C.R. “Mientras” y “Desde/Para” que
evalúan la expresión al comienzo de bucle de repetición y por lo cual se les llaman bucles pre-
test).
El bucle Hacer-Mientras es análogo al bucle Mientras donde el cuerpo del bucle se ejecuta una
y otra vez mientras la condición sea verdadera; excepto que en bucle Hacer-Mientras el
cuerpo del bucle se ejecuta siempre al menos una vez.
En la práctica, la E.C.R. “Hacer-Mientras” se puede utilizar para validar los datos ingresados
por teclado, haciendo que el programa pida el mismo dato hasta que el usuario ingrese un
dato válido. También se puede utilizar para repetir todo el programa después de responder
afirmativamente al mensaje “¿Desea volver a empezar? Si/No”.
Como se aprecia en la Figura 8.2, esta es la única estructura de control que termina en punto
y coma.
...
acciones
V
condición
...
Figura 8.1. Diagrama de Flujo de E.C. Repetitiva “Hacer–Mientras”
hacer
<acción 1>;
<acción 2>;
<acción 3>;
...
<acción N>;
mientras(<condición>);
Figura 8.2. Pseudocódigo de E.C. Repetitiva “Hacer–Mientras”
54
Ejemplo 8.1
Mostrar los números pares del 2 al 50, usando estructura repetitiva “Hacer-Mientras”.
Inicio
i  2 algoritmo contar_par
var
entero: i;
Mostrar i inicio
i  1;
hacer
i ← i + 2 escribir(i);
i  i + 2;
mientras(i <= 50);
V fin
i <= 50
Fin
Ejemplo 8.2
Leer una cantidad ilimitada de caracteres (letras) y detenerse cuando se lea la primera vocal
que se ingrese por teclado. Luego presentar la primera vocal leída.
Inicio
algoritmo letra_vocal
Leer L var
caracter: L;
inicio
hacer
L!="a" AND V leer(L);
L!="e" AND L!="i" AND L!="o" mientras(L!="a" AND L!="e" AND
AND L!="u" L!="i" AND L!="o" AND
L!="u");
F
escribir(L);
Mostrar L fin
Fin
55
Ejemplo 8.3
Realizar la división de dos números enteros, validar el denominador diferente de cero con el
bucle Hacer-Mientras.
Inicio
algoritmo division_validada
Leer numerador var
entero: cociente, numerador,
denominador;
Leer denominador inicio
leer(numerador);
hacer
V leer(denominador);
denominador == 0
mientras(denominador == 0);
F cociente  numerador/denominador;
escribir(cociente);
cociente  numerador/denominador fin
Mostrar cociente
Fin
Ejemplo 8.4
Ejecutar un programa (cualquiera) y repetirlo hasta que el usuario escriba la palabra “salir”.
(*) El programa elegido será el Ejemplo 4.2.
Inicio
algoritmo ejemplo_en_bucle
const
Pedir m C = 2.997925 * 10^10
var
entero: m, e;
e  m*C^2
cadena: rspta;
inicio
Mostrar e hacer
leer(m);
e  m*C^2;
Leer rspta
escribir(e);
escribir(“Escriba SALIR para terminar el
V programa...”);
rspta != “salir”
leer(rspta);
F mientras(rspta != “salir”);
fin
Fin
56
ESTRUCTURA DE CONTROL REPETITIVA O ITERATIVA ANIDADA
De igual forma que se pueden anidar o encajar estructuras de selección, es posible insertar un
bucle dentro de otro.
Figura 8.3. Bucles anidados: a) y b), correctos; c) y d) incorrectos.
mientras (<condición 1>) hacer

desde (<iniciar>) hasta (<condición 2>) inc|dec <paso> hacer
...
...
...
fin_desde
fin_mientras
Figura 8.4. Pseudocódigo de E.C.R. Anidada: “Mientras” – “Desde/Para”.
hacer
mientras (<condición 1>) hacer
...
...
...
fin_mientras
desde (<iniciar>) hasta (<condición 2>) inc|dec <paso> hacer
...
...
...
fin_desde
mientras(<condición 3>);
Figura 8.4. Pseudocódigo de E.C.R. Anidada: “Hacer-Mientras” – “Mientras” – “Desde/Para”.
57
Ejemplo 8.5
Leer las temperaturas horarias de cada uno de los días del año.
Inicio algoritmo temperatura_horaria

var
entero: dias, horas;
dias  1 real: temperatura;
inicio
dias  1;
mientras(dias <= 365) hacer
dias<=365 horas  1;
F
mientras(horas <= 24) hacer
V leer(temperatura);
horas  horas + 1;
horas  1 fin_mientras
dias  dias + 1;
fin_mientras
fin
horas<=24
F
Leer temperatura algoritmo temperatura_horaria

var
entero: dias, horas;
horas  horas + 1 real: temperatura;
inicio
desde(dias1)hasta(dias<=365)inc 1 hacer
dias  dias + 1 desde(horas1)hasta(horas<=24)inc 1 hacer
leer(temperatura);
fin_desde
fin_desde
Fin fin
Ejemplo 8.6
Leer un número entero N y calcular la factorial de todos los número de 1 hasta N. Ejemplo: si
lee el número 5, deberá mostrar el resultado de los factoriales 1!=1; 2!=2; 3!=6; 4!=24; 5!=120.
algoritmo factorial_numero
var
entero: n, i, j, fact;
inicio
hacer
escribir(“Ingrese un número mayor a 0:”);
leer (n);
mientras (n <= 0);
desde (i←1) hasta (i <= n) inc 1 hacer
fact ← 1;
desde (j←1) hasta (j <= i) inc 1 hacer
fact ← fact * j;
fin_desde
escribir (i, “! =”, fact);
fin_desde
fin
58
Inicio
Leer n
V
n<=0
i ← 1
i<=n
F
fact ← 1
j ← 1
j<=i
F
V
fact ← fact * j
j ← j+1
Mostrar i, “! =”, fact
i ← i+1
Fin
59
CAPÍTULO III: Sub-algortimos y
Estructuras de Datos.
CONTENIDO
Tema 9. Sub-Algoritmos.
Tema 10. Estructuras de Datos I: Arreglos.
Tema 11. Estructuras de Datos II: Registros.
Tema 12. Arreglos de Registros.
60
Tema 9. Sub-Algoritmos.
La resolución de problemas complejos se facilita considerablemente si se dividen en
problemas más pequeños (subproblemas). La solución de estos subproblemas se realiza con
subalgoritmos.
Los subalgoritmos pueden ser de dos tipos:
• Funciones.
• Procedimientos.
Las funciones y procedimientos pueden ser llamados desde el algoritmo principal. El algoritmo
principal es donde se ha venido trabajando en los temas anteriores y cuando un subalgoritmo
es llamado, el flujo del algoritmo principal se pausa y empieza a ejecutarse el subalgoritmo.
Cuando el subalgoritmo llegue a ejecutarse hasta el final, se retorna al algortimo principal y
retoma su ejecución desde la instrucción donde fue pausado y continuará ejecutandose hasta
el final.
Un subalgoritmo puede llamarse múltiples veces según como sea requerido. Un subalgoritmo
puede llamar a otro subalgoritmo e incluso puede llamarse a sí mismo, a estos se le llaman
subalgoritmos recursivos.
Algoritmo principal
Subalgoritmo
Figura 9.1. Llamada y Retorno entre Algortimo principal y Subalgoritmo.
Algoritmo principal Subalgoritmo 1 Subalgoritmo 2
Retorno 1
Subalgoritmo 3
Retorno 3
Figura 9.2. Llamada y Retorno entre Algortimo principal y Subalgoritmo; y entre Subalgoritmos.
61
FUNCIONES
Una función es un subalgoritmo que cuando termina de ejecutarse debe retornar un valor
hacia el algoritmo donde fue llamado.
La sintaxis de una función es similar a la de los algoritmos vistos en temas anteriores, pero
ahora la zona del nombre del algoritmo será reemplazado por el encabezado (o cabecera) de
la función y luego seguirá el cuerpo que contiene las instrucciones de la función.
<tipo_retorno> funcion <nombre_funcion> (<lista de parámetros>)

[declaraciones locales]
inicio
<acción 1>;
<acción 2>;
...
<acción N>;
devolver(<expresión o variable>);
fin_funcion
Figura 9.3. Pseudocódigo de una Función.
CABECERA DE LA FUNCIÓN
• <tipo_retorno>: tipo de dato que retornará la función: entero, real, etc.
• funcion: palabra que indica que el subalgoritmo es una función.
• <nombre_funcion>: identificador válido que da nombre a la función.
• <lista de parámetros>: listado de todos los argumentos o parámetros
formales que pueden ser de la siguiente forma:
o Entrada (E): parámetro que llega desde el algoritmo principal como una
copia del valor original, de esta manera se podrán hacer cambios sobre este
valor dentro del subalgoritmo y al terminar de ejecutarse, estos cambios no
se verán reflejados en el algoritmo principal.
E tipo_dato: parametro_1, parametro_2,...
o Salida (S): parámetro que llega desde el algoritmo principal no como una
copia, sino más bien como la misma variable que se envía desde el algoritmo
principal, de esta manera, cuando termine de ejecutarse el subalgoritmo,
todos los cambios que han ocurrido sobre el valor, se verán reflejados
también en el algoritmo principal.
S tipo_dato: parametro_1, parametro_2,...
o Entrada/Salida (E/S): parámetro que llega como dato de entrada y que será
modificado dentro del subalgoritmo para que cuando se retorne al algoritmo
principal, este valor también haya cambiado.
E/S tipo_dato: parametro_1, parametro_2,...
62
CUERPO
• [declaraciones locales]: declaración de variables y/o constantes,
adicionales a los parámetros, que se necesiten dentro del subalgoritmo.
• inicio: determina el inicio de las instrucciones del subalgoritmo.
• fin_funcion: indica el final de instrucciones del subalgoritmo.
• <acción>: instrucciones que pueden ser de entrada, salida, asignación y
estructuras de control.
• devolver: instrucción obligatoria en las funciones que retorna un valor dentro
a través de una variable o expresión. Debe ser del mismo tipo de dato que se
indica en la cabecera.
Ejemplo 9.1
Escribir un algoritmo que realice la conversión de pulgadas a centímetros utilizando una
función. El factor de conversión es 1 pulgada= 2.54 cm.
Inicio
Funcion pulg_a_cm
Leer pulg
E: pulgadas
centimtr  pulg_a_cm(pulg)
Devolver
pulgadas*2.54
Mostrar “En
cm:”, centimtr
Fin_Funcion
Fin
algoritmo conversion
var
real: pulg, centimtr;
inicio
leer(pulg);
centimtr  pulg_a_cm(pulg);
escribir(“En cm:”, centimtr );
fin
real funcion pulg_a_cm(E real: pulgadas)

inicio
devolver(pulgadas * 2.54);
fin_funcion
63
Ejemplo 9.2
Escribir un algoritmo que lea un número entero n mayor a cero y luego llame a una función
que calcule la sumatoria de los n primeros números enteros.
Funcion sumatoria
Inicio
E: num
Leer n
suma  0
V
n<=0
i  1
F
result  sumatoria(n) F
i<=n
V
Mostrar result Devolver
suma  suma + i suma
Fin i  i+1
Fin_Funcion
algoritmo suma_de_numeros
var
entero: n, result;
inicio
hacer
leer(n);
mientras(n<=0);
result  sumatoria(n);
escribir(result);
fin
entero funcion sumatoria(E entero: num)

var
entero: i, suma;
inicio
suma  0;
desde(i1) hasta(i<=n) inc 1 hacer
suma  suma + i;
fin_desde
devolver(suma);
fin_funcion
64
Ejemplo 9.3
Diseñar una función que permita devolver el valor absoluto de un número. Probar la función
con tres variables diferentes.
Inicio
Funcion abs
Leer n1, n2, n3
E: num
abs_n1  abs(n1)
num<0
abs_n2  abs(n2) F
V
num  num * (-1)

abs_n3  abs(n3)
Mostrar “Valores
absolutos:”, abs_n1,
abs_n2, abs_n3 Devolver num
Fin Fin_Funcion
algoritmo valor_absoluto
var
entero: n1, n2, n3, abs_n1, abs_n2, abs_n3;
inicio
leer(n1, n2, n3);
abs_n1  abs(n1);
abs_n1  abs(n1);
abs_n1  abs(n1);
escribir(“Valores absolutos”, abs_n1, abs_n2, abs_n3);
fin
entero funcion abs(E entero: num)

inicio
si (num < 0) entonces
num  num * (-1);
fin_si
devolver(num);
fin_funcion
65
Ejemplo 9.4
Escribir una función booleana Digito que determine si un carácter es uno de los dígitos 0 al 9.
Funcion digito
Inicio
E: c
Leer letra
rspta  falso
Mostrar “Está
entre 0-9:”,
digito(letra) c>=‘0’ AND c<=‘9’
F
V
Fin rspta  verdadero
Devolver num
Fin_Funcion
algoritmo letra_digito
var
caracter: letra;
inicio
leer(letra);
escribir(“Está entre 0-9: ”, digito(letra));
fin
booleno funcion digito(E caracter: c)

var
booleano: rspta;
inicio
rspta  falso;
si (c>=‘0’ AND c<=‘9’) entonces
rspta  verdadero;
fin_si
devolver(rspta);
fin_funcion
66
Ejemplo 9.5
Diseñar un algoritmo que transforme un número introducido por teclado en notación decimal
a notación romana. El número será entero positivo y no excederá de 3.000.
algoritmo decimal_a_romano
var
entero: numero;
cadena: nro_romano;
inicio
hacer
leer(numero);
mientras(numero<=0 AND numero>3000);
nro_romano  romano(numero);
escribir(numero, “en romano es:”, nro_romano);
fin
cadena funcion romano(E entero: num)

var
cadena: mill, cent, dece, unid;
inicio
mill  mill_romano(num);
cent  cent_romano(num);
dece  dec_romano(num);
unid  unid_romano(num);
devolver(mill, cent, dece, unid);
fin_funcion
cadena funcion mill_romano(E/S entero: num)

var
entero: digito_mill;
cadena: m;
inicio
digito_mill  num DIV 1000;
num  num MOD 1000; //cuando termine esta función,
num se habrá modificado;
por ser de E/S.
segun_sea(digito_mill) hacer
caso 1: m  “M”;
caso 2: m  “MM”;
caso 3: m  “MMM”;
si_no: m  “ ”;
fin_segun
devolver(m);
fin_funcion
cadena funcion cent_romano(E/S entero: num)

var
entero: digito_cent;
cadena: c;
inicio
digito_cent  num DIV 100;
num  num MOD 100; //regresará modificado
67
segun_sea(digito_cent) hacer
caso 1: c  “C”;
caso 2: c  “CC”;
caso 3: c  “CCC”;
caso 4: c  “CD”;
caso 5: c  “D”;
caso 6: c  “DC”;
caso 7: c  “DCC”;
caso 8: c  “DCCC”;
caso 9: c  “CM”;
si_no: c  “ ”;
fin_segun
devolver(c);
fin_funcion
cadena funcion dec_romano(E/S entero: num)

var
entero: digito_dec;
cadena: d;
inicio
digito_dec  num DIV 10;
num  num MOD 10; //regresará modificado
segun_sea(digito_dec) hacer
caso 1: d  “X”;
caso 2: d  “XX”;
caso 3: d  “XXX”;
caso 4: d  “XL”;
caso 5: d  “L”;
caso 6: d  “LX”;
caso 7: d  “LXX”;
caso 8: d  “LXXX”;
caso 9: d  “XC”;
si_no: d  “ ”;
fin_segun
devolver(d);
fin_funcion
cadena funcion unid_romano(E/S entero: num)

var
cadena: u;
inicio
//Finalmente en num solo quedan las unidades.
segun_sea(num) hacer
caso 1: u  “I”;
caso 2: u  “II”;
caso 3: u  “III”;
caso 4: u  “IV”;
caso 5: u  “V”;
caso 6: u  “VI”;
caso 7: u  “VII”;
caso 8: u  “VIII”;
caso 9: u  “IX”;
si_no: u  “ ”;
fin_segun
devolver(u);
fin_funcion
68
PROCEDIMIENTOS
Aunque las funciones son herramientas de programación muy útiles para la resolución de
problemas, su alcance está muy limitado. Con frecuencia se requieren subalgoritmos que
calculen varios resultados en vez de uno solo, o que realicen la ordenación de una serie de
números, etc. En estas situaciones la función no es apropiada y se necesita disponer del otro
tipo de subalgoritmo: el procedimiento o subrutina.
La sintaxis de los procedimientos es muy similar a la de las funciones. Las variación más
resaltante está en la forma como devuelven valores. Los procedimientos no devuelven un
valor, por lo tanto no se debe utilizar la instrucción devolver. La forma en que un
procedimiento retorna 0, 1, 2 o n valores es a través de sus parámetros (de Salida o de
Entrada/Salida).
procedimiento <nombre_procedimiento> (<lista de parámetros>)

[declaraciones locales]
inicio
<acción 1>;
<acción 2>;
...
<acción N>;
fin_procedimiento
Figura 9.4. Pseudocódigo de un procedimiento.
nombre_procedimiento(argumentos)
Figura 9.5. Diagrama de flujo para realizar una llamada a un procedimiento.
69
Ejemplo 9.6
Crear un procedimiento que intercambie los valores de dos variables.
Procedimiento intercambiar
Inicio
E/S: n1, n2
Leer A, B
aux  n1
intercambiar(A,B)
n1  n2
Mostrar “Ahora
A=”, A, “y B=”, B n2  aux
Fin Fin_Procedimiento
algoritmo intercambio_numeros
var
entero: A, B;
inicio
leer(A, B);
intercambiar(A,B);
escribir(“Ahora A=”, A, “y B=”, B);
fin
procedimiento intercambiar(E/S entero: n1, n2)

var
entero: aux;
inicio
aux  n1;
n1  n2;
n2  aux;
fin_procedimiento
Ejemplo 9.7
Diseñar un procedimiento que acepte un número de mes, un número de día y un número de
año y los visualice en el formato dd/mm/aa. La fecha debes ser válida.
Por ejemplo lo valores 19, 09, 1987 se visualizará como 19/9/87.
70
algoritmo convertir_fecha
var
entero: dia, mes, anio;
booleano: es_bisiesto;
inicio
leer_entero(anio, 1900, 2020);
leer_entero(mes, 1, 12);
si (mes==2) entonces
es_bisiesto  bisiesto(anio);
si (es_bisiesto == verdadero) entonces
leer_entero(dia, 1, 29);
si_no
fin_si
fin_si
si (mes==1 AND mes==3 AND mes==5 AND mes==7 AND mes==8 AND mes==10 AND
mes==12) entonces
fin_si
si (mes==4 AND mes==6 AND mes==9 AND mes==11) entonces

fin_si
mostrar_fecha(dia, mes, anio);

fin
procedimiento leer_entero(E/S entero: nro; E entero: min, max)

inicio
hacer
leer(nro);
mientras(nro<min OR nro>max);
fin_procedimiento
booleano funcion bisiesto(E entero: anio)

inicio
si ((anio MOD 4==0) AND (anio MOD 100!=0) OR (anio MOD 400==0)) entonces
devolver(verdadero);
fin_si
devolver(falso);
fin_funcion
procedimiento mostrar_fecha(E entero: d, m, a)

inicio
a  a MOD 100;
escribir(d,“/”, m, “/”, a);
fin_procedimiento
71
Inicio
leer_entero(anio, 1900, 2020)
leer_entero(mes, 1, 12)
mes==2
F
V
es_bisiesto  bisiesto(anio)
es_bisiesto==verdadero F
V
leer_entero(dia, leer_entero(dia,
1, 29) 1, 28)
mes==1 AND mes==3

AND mes==5 AND mes==7 AND mes==8
AND mes==10 AND mes==12 F
leer_entero(dia, 1, 31)
mes==4
AND mes==6 AND mes==9 AND
F
mes==11
V
leer_entero(dia, 1, 30)
mostrar_fecha(dia, mes, anio)
Fin
72
Funcion bisiesto
Procedimiento leer_entero
E: anio
E/S: nro
(anio MOD 4==0)

E: min, max
AND (anio MOD 100!=0) OR
F
(anio MOD 400==0)
Leer nro
V
V Devolver verdadero
nro<min OR nro>max
Fin_Procedimiento
Devolver falso
Fin_Funcion
Procedimiento mostrar_fecha
E: d, m, a
a  a MOD 100
Mostrar
d,“/”,m,“/”,a
Fin_Procedimiento
Ejemplo 9.8
Realizar un procedimiento que obtenga la división entera y el resto de la misma utilizando
únicamente los operadores suma y resta.
algoritmo division_con_sumas_restas
var
entero: dividendo, divisor, cociente, resto;
inicio
leer(dividendo, divisor);
division(dividendo, divisor, cociente, resto);
escribir(“Cociente=”, cociente, “y el resto=”, resto);
fin
73
procedimiento division(E entero: dividendo, divisor; S entero: cociente, resto)
inicio
si (dividendo>0 AND divisor>0) entonces
cociente  0;
resto  dividendo;
mientras (resto>=divisor) hacer
resto  resto – divisor;
cociente  cociente + 1;
fin_mientras
si_no
escribir(“Ambos números deben ser mayores a cero”);
fin_si
fin_procedimiento
Inicio
Leer dividendo,
divisor
division(dividendo, Procedimiento division

divisor, cociente, resto)
E: dividendo, divisor
Mostrar
“Cociente=”, cociente,
“y el resto=”, resto S: cociente, resto
Fin
dividendo>0
V AND divisor>0 F
cociente  0
Mostrar “Ambos
resto  dividendo números deben ser
mayores a cero”
resto>=divisor
F
V
resto  resto – divisor
cociente  cociente + 1
Fin_Procedimiento
74
Tema 10. Estructuras de Datos I: Arreglos o Arrays.
En los temas anteriores se ha venido trabajando con datos simples (enteros, reales,
caracteres, booleanos, etc.), sin embargo en muchas situaciones será encesario el uso de una
colección de datos que están relacionados entre sí, como por ejemplo: una lista de
calificaciones, una serie de temperaturas medidas a lo largo de un mes, etc.
Debido a esta necesidad surgen los Arreglos (o arrays en inglés) que pueden guardar varios
datos del mismo tipo y estos pueden ser:
• Arreglos unidimensionales, también llamados Vectores.
• Arreglos multidimensionales, que a su vez pueden ser:
o Arreglos bidimensionales, también llamados Matrices.
o Arreglos tridimensionales, tambien llamados Cubos.
Los arreglos pueden ser incluso mayores a tres dimensiones, pero en este tema se
profundizará solamente en el uso de dos tipos: vectores y matrices.
ARREGLOS UNIDIMENSIONALES O VECTORES

Es un conjunto finito y ordenado de elementos homogéneos. La propiedad “ordenado”
significa que el elemento primero, segundo, tercero,..., n-ésimo de un array puede ser
identificado mientras que la propiedad “homogéneos” se refiere a que son del mismo tipo de
datos.
Vector[n] ...
[0] [1] [2] [3] [4] [5] [n-1]
Figura 10.1. Representación de un arreglo unidimensional de nombre Vector y de tamaño n.
Como se puede apreciar en la Figura 10.1, el vector es ordenado ya que se puede identificar a
cada elemento con un número, al cual llamaremos índice. El primer elemento siempre tiene
el índice cero, así un vector de 3 elementos tendrá los índices: 0, 1, 2. Un vector de 7
elementos, tendrán los índices: 0, 1, 2, 3, 4, 5, 6. Por lo tanto en un vector de n elementos, el
último índice será (n-1).
OPEARCIONES CON VECTORES

• Declaración, puede ser de cualquiera de los tipos conocidos:
var
<tipo_dato>: <nombre_arreglo>[<cant_elementos>];
Ejemplo:
real: promedios[30]; //guardará los promedios de 30 alumnos.
cadena: nombres[100]; //almacenar los nombres de 100 personas.
75
• Asignación, se debe asignar un valor, indicando el índice.
<nombre_arreglo>[<índice>]  <valor o expresión>;
De esta manera, si se quisiera asignar valores a todos los elementos del vector, se
deberá utilizar un bucle, así:
desde (i0) hasta (i<= <cant_elementos>-1) inc 1 hacer
<nombre_arreglo>[i]  <valor o expresión>;
fin_desde
Ejemplo:
promedios[21]  14.5; //guardo 14.5 en la celda [21] del vector.
promedios[8]  (12 + 15 + 14)/3;
nombres[10]  “Bruce”;
• Lectura, se debe leer un valor, indicando el índice donde queremos guardarlo.

leer(<nombre_arreglo>[<índice>]);
De esta manera, si se quiere leer valores para todos los elementos del vector, se deberá
utilizar un bucle, así:
leer(<nombre_arreglo>[i]);
fin_desde
Ejemplo:
leer(promedios[29]); //leer un valor para el último elemento.
leer(promedios[18]);
leer(nombres[0]);
• Escritura, se debe mostrar el valor de un elemento, indicando su índice.

escribir(<nombre_arreglo>[<índice>]);
De esta manera, si se quiere mostrar los valores de todos los elementos del vector, se
deberá utilizar un bucle, así:
escribir(<nombre_arreglo>[i]);
fin_desde
Ejemplo:
escribir(promedios[20]); //muestra el valor del elemento [20].
escribir(promedios[18]);
escribir(nombres[10]);
76
Ejemplo 10.1
Hacer un array unidimensional que muestre el promedio del sueldo de los trabajadores de una
empresa que tienen 20 trabajadores.
INICIO
algoritmo promedio_sueldo
suma  0 var
real: sueldo[20], suma, prom;
entero: i;
i  0 inicio
suma  0;
desde (i0) hasta (i<=19) inc 1 hacer
i <= 19 leer(sueldo[i]);
F suma  suma + sueldo[i];
fin_desde
V prom  suma/4;
escribir(“El promedio de sueldos es:”, prom);
leer sueldo[i] fin
suma  suma + sueldo[i]
i  i + 1
prom  suma/4
Mostrar “El promedio

de sueldo es:”, prom
FIN
Ejemplo 10.2
Crea un array o arreglo unidimensional con un tamaño de 5, asígnale los valores numéricos
manualmente (los que tú quieras) y muéstralos por pantalla.
algoritmo arreglos
var
entero: num[5], i;
inicio
num[0]  2;
num[0]  -5;
num[0]  13;
num[0]  8;
num[0]  215;
escribir(num[i]);
fin_desde
fin
77
INICIO
num[0]  2
num[1]  -5
num[2]  13
num[3]  8
num[4]  215
i  0
i <= 4
F
V
Mostrar num[i]
i  i + 1
FIN
Ejemplo 10.3
Crear dos arreglos uno que almacene 20 nombres y otro que almacene 30 números. Utilice
procedimientos para leer y mostrar los datos.
algoritmo arreglos_con_procedimientos
const
MAX_NUM = 30
MAX_NOMB = 20
var
entero: numeros[MAX_NUM];
cadena: nombres[MAX_NOMB];
inicio
leer_numeros(numeros, MAX_NUM);
leer_nombres(nombres, MAX_NOMB);
mostrar_numeros(numeros, MAX_NUM);
mostrar_nombres(nombres, MAX_NOMB);
fin
78
procedimiento leer_numeros(S entero: nums[], E entero: cant_elem)
var
entero: i;
inicio
desde (i0) hasta (i <= cant_elem-1) inc 1 hacer
leer(nums[i]);
fin_desde
fin_procedimiento
procedimiento leer_nombres(S entero: nombs[], E entero: cant_elem)

var
entero: i;
inicio
leer(nombs[i]);
fin_desde
fin_procedimiento
procedimiento mostrar_numeros(E entero: nums[], cant_elem)

var
entero: i;
inicio
escribir(nums[i]);
fin_desde
fin_procedimiento
procedimiento mostrar_nombres(E entero: nombs[], cant_elem)

var
entero: i;
inicio
escribir(nombs[i]);
fin_desde
fin_procedimiento
79
ARREGLOS BIDIMENSIONALES O MATRICES
Es un conjunto de elementos del mismo tipo de dato, en el cual el orden de los componentes
fila y columna es importante. Debido a esto, ahora es necesario indicar dos índices para poder
identificar cada elemento del array.
Matriz[m][n]
[0] [1] [2] [n-1]
[0] ...
[1]
[2]
. . .
. . .
. . .
[m-1] ...
Figura 10.2. Representación de un arreglo bidimensional de m Filas y n Columnas (m×n).
Al igual que los vectores, el primer elemento toma como índices al cero ([0][0]), de esta
manera se sigue cumpliendo que el último elemento de una matriz de tamaño (m × n), será
[m-1][n-1].
Ejemplo 10.4
Visualizar la matriz transpuesta de una matriz M de 5×6 elementos.
algoritmo transpuesta_de_matriz
var
entero: M[5][6], MT[6][5];
entero: i, j;
inicio
desde (i←0) hasta (i<=4) inc 1 hacer
desde (j←0) hasta (j<=5) inc 1 hacer
leer( M[i][j] );
MT[j][i] ← M[i][j];
fin_desde
fin_desde
escribir( MT[i][j] );
fin_desde
fin_desde
fin
80
INICIO
i←0
i<=4
F
V i←0
j←0
i<=5
F
j<=5
F V
V j←0
Leer M[i][j]
j<=4
MT[j][i] ← M[i][j] F
V
j←j+1 Mostrar MT[i][j]
i←i+1 j←j+1
i←i+1
Fin
Ejemplo 10.5
Rellenar una matriz identidad de 10 por 10 elementos.
algoritmo matriz_identidad
var
entero: matriz[10][10], i, j;
inicio
si (i==j) entonces
matriz[i][j] ← 1;
si_no
matriz[i][j] ← 0;
fin_si
fin_desde
fin_desde
fin
81
INICIO
i←0
i<=9
F
V
j←0
j<=9
F
V
V F
i==j
matriz[i][j]←1 matriz[i][j]←0
j ← j+1
i ← i+1
FIN
Ejemplo 10.6
Escribir un algoritmo que permita sumar los elementos positivos y negativos de una tabla de
una tabla de 5 filas y 4 columnas.
algoritmo suma_elem_matriz
var
entero: matriz[5][4], i, j, sum_posit, sum_negat;
inicio
sum_posit  0;
sum_negat  0;
si (matriz[i][j]>0) entonces
sum_posit  sum_posit + matriz[i][j];
si_no
sum_negat  sum_negat + matriz[i][j];
fin_si
fin_desde
fin_desde
escribir(sum_posit, sum_negat);
fin
82
INICIO
sum_posit  0
sum_negat  0
i0
i<=4 F
V
j←0
j<=3
F
V
matriz[i][j]>0
V F
sum_positsum_posit+matriz[i][j] sum_negatsum_negat+matriz[i][j]
j ← j + 1
i ← i + 1
Mostrar sum_posit, sum_negat
Fin
83
Tema 11. Estructuras de Datos II: Registros.
Un array permite el acceso una lista o tabla de una gran cantidad de datos, todos del mismo
tipo. Sin embargo, hay ocasiones donde se desea guardar datos de diferentes tipos, tales como
un nombre (cadena), una edad (entero), talla (real) juntos en única estructura. A este tipo de
elemento se les llama registro.
Un registro es una estructura con datos heterogéneos y que en la práctica se le puede utilizar
como un nuevo tipo de dato definido por el programador. De esta manera se pueden crear
variables del tipo de dato Registro.
En el pseudocódigo, se deberá incluir el apartado tipo (después del apartado const y antes
de var); dentro del cual se puede declarar los nuevos tipos de datos (registros) iniciando con
la palabra estructura o registro y terminando con su respectivo fin_estructura o
fin_registro respectivamente, tal como lo indica la Figura 11.1.
algoritmo <nombre_algoritmo> algoritmo <nombre_algoritmo>

const const
... ...
tipo tipo
registro <Nombre_registro> estructura <Nombre_registro>
<tipo_dato>: <nombre_var>; <tipo_dato>: <nombre_var>;
<tipo_dato>: <nombre_var>; <tipo_dato>: <nombre_var>;
... ...
fin_registro fin_estructura
var var
... ...
Figura 11.1. Pseudocódigo para declarar un nuevo Registro.
Para poder declarar una variable del tipo registro se deberá hacer del modo que se ha venido
trabajando en los temas anteriores, ver Figura 11.2.
var
<Nombre_registro>: <nombre_variable_registro>;
Figura 11.2. Pseudocódigo para declarar una variable de tipo Registro.
Para poder completar los datos de un variable registro se deberá acceder a ellos mediante el
uso del operador de acceso, representado por un punto (.), tal como se muestra en la Figura
11.3.
<nombre_variable_registro>.<nombre_var>;
Figura 11.3. Pseudocódigo para acceder a los datos de la variable de tipo Registro.
Esto se verá con más claridad en los siguientes ejemplos.
84
Ejemplo 11.1
Diseñe un algoritmo que permita registrar los datos de un alumno que tiene nombre, apellidos,
edad, código; haciendo uso de estructuras.
algoritmo registrar_alumno
tipo
Inicio registro Alumno
entero: codigo;
cadena: nombres;
Pedir alum.nombres cadena: apellidos;
entero: edad;
fin_registro
var
Pedir alum.apellidos Alumno: alum;
inicio
escribir(“Ingrese nombres del alumno:”);
Pedir alum.edad leer(alum.nombres);
escribir(“Ingrese apellidos del alumno:”);

Pedir alum.codigo leer(alum.apellidos);
escribir(“Ingrese edad del alumno:”);

leer(alum.edad);
Fin
escribir(“Ingrese codigo del alumno:”);
leer(alum.codigo);
fin
Ejemplo 11.2
En un pueblo pequeño han llegado 03 empresas y el municipio de ese pueblo desea conocer la
razón social de la empresa, su RUC y la cantidad de trabajadores que tiene. Diseñe el algoritmo
para llevar el registro de estas 03 empresas.
algoritmo empresas_nuevas
tipo
registro Empresa
entero: ruc;
cadena: razon_social;
entero: cant_trabajadores;
fin_registro
var
Empresa: emp1, emp2, emp3;
inicio
leer(emp1.ruc);
leer(emp1.razon_social);
leer(emp1.cant_trabajadores);
leer(emp2.ruc);
leer(emp3.ruc);
fin
85
Inicio
Pedir emp1.ruc
Pedir emp1.razon_social
Pedir emp1.cant_trabajadores
Pedir emp2.ruc
Pedir emp3.ruc
Fin
Ejemplo 11.3
Escriba un programa que en una estructura se lleve el control de ventas en una tienda de
videojuegos. Asegúrese que la estructura incluya el título del videojuego, el precio y la fecha
en la que se vendió. La fecha debe ser otro registro que guarde día, mes y año. Simule una
venta llenando los datos manualmente y otra pidiendo los datos al usuario. Finalmente
mostrar ambos videojuegos vendidos utilizando procedimientos.
algoritmo tienda_videojuegos
tipo
registro Fecha
entero: dia, mes, anio;
fin_registro
registro Videojuego
cadena: titulo;
real: precio;
Fecha: f_venta;
fin_registro
var
Videojuego: v1, v2;
86
inicio
Inicio
v1.titulo  “FIFA 20”;
v1.precio  199.90;
v2.titulo  “FIFA 20” v1.f_venta.dia  08;
v1.f_venta.mes  09;
v1.f_venta.anio  2020;
v1.precio  199.90
leer(v2.titulo);
leer(v2.precio);
v1.f_venta.dia  08 leer(v2.f_venta.dia);
leer(v2.f_venta.mes);
leer(v2.f_venta.anio);
v1.f_venta.mes  09
mostrar_reg(v1);
v1.f_venta.anio  2020 mostrar_reg(v2);
fin
Pedir v2.titulo
procedimiento mostrar_reg(E Videojuego: v)

Pedir v2.precio
escribir(v.titulo);
escribir(v.precio);
Pedir v2.f_venta.dia escribir(v.f_venta.dia);
escribir(v.f_venta.mes);
escribir(v.f_venta.anio);
Pedir v2.f_venta.mes fin
Pedir v2.f_venta.anio
mostrar_reg(v1)
mostrar_reg(v2)
Procedimiento mostrar_reg
Fin
E: v
Mostrar v.titulo
Mostrar v.precio
Mostrar v.f_venta.dia
Mostrar v.f_venta.mes
Mostrar v.f_venta.anio
Fin_Procedimiento
87
Tema 12. Arreglos de Registros.
La potencia de un registro se manifiesta en toda su expresión cuando el mismo registro se
utiliza para listas de datos (arreglos). De esta se pueden guardar miles de datos del mismo tipo
de registro.
En pseudocódigo, un arreglo de registros se declara en el apartado de las variables (var)
siguiendo las reglas vistas en los temas 10 y 11.
algoritmo <nombre_algoritmo>
const
...
tipo
registro <Nombre_registro>
...
...
fin_registro
var
<Nombre_registro>: <nombre_arreglo>[<cant. elementos>];
Figura 12.1. Pseudocódigo para declarar un arreglo de registros.
Para poder completar los datos de un variable registro dentro del arreglo se deberá acceder a
ellos mediante el uso del índice del elemento del array y el operador de acceso (.), tal como
se muestra en la Figura 12.2.
<nombre_arreglo>[<índice>].<nombre_var>;
Figura 12.2. Pseudocódigo para acceder a los datos de un elemento del arreglo de tipo Registro.
Las operaciones que se pueden realizar con los arreglos de registros son los mismos vistos en
el Tema 10: arreglos unidimensionales.
Para poder entender mejor este tema veamos los siguientes ejemplos.
Ejemplo 12.1
Una empresa desea estructurar los siguientes registros de sus empleados utilizando un arreglo.
Diseñe el algoritmo que ayude a la empresa a gestionar esta información.
88
Inicio algoritmo empleados_empresa
tipo
registro Empleado
i  0
entero: numero;
cadena: nombre;
real: salario;
i<=9 fin_registro
F
V var
Empleado: arr_emp[10];
leer_reg(arr_emp[i]) entero: i;
) inicio
i  i + 1 leer_reg(arr_emp[i]);
fin_desde
fin
Fin
procedimiento leer_reg(S Empleado: emp)

Procedimiento leer_reg inicio
leer(emp.numero);
leer(emp.nombre);
S: emp leer(emp.salario);
fin_procedimiento
Pedir emp.numero
Pedir emp.nombre
Pedir emp.salario
Fin_Procedimiento
Ejemplo 12.2
Desarrolle una estructura que guarde los datos de los 30 alumnos de la materia programación,
y los muestre por pantalla, la estructura debe tener DNI, nombre completo, edad, correo,
teléfono, lugar de nacimiento, dirección y promedio. Mostrar la cantidad de aprobados y
desaprobados.
algoritmo alumnos_curso
tipo
registro Alumno
entero: dni, edad;
cadena: nombre_compl, correo, telefono;
cadena: lugar_nac, direccion;
real: promedio;
fin_registro
var
Alumno: arr_alums[30];
entero: cant_aprob, cant_desap;
89
inicio
lectura_data(arr_alums, 30);
contar_aprob_desap(arr_alums, 30, cant_aprob, cant_desap);
escribir(“Hay: ”, cant_aprob, “ aprobados.”);
escribir(“Hay: ”, cant_desap, “ desaprobados.”);
fin
procedimiento lectura_data(S Alumno: arreglo[]; E entero: cant)

var
entero: i;
inicio
desde (i0) hasta (i<=cant-1) inc 1 hacer
leer_elem(arreglo[i]);
fin_desde
fin_procedimieto
procedimiento leer_elem(S Alumno: alum)

inicio
leer(alum.dni);
leer(alum.nombre_compl);
leer(alum.edad);
leer(alum.correo);
leer(alum.telefono);
leer(alum.lugar_nac);
leer(alum.direccion);
leer(alum.promedio);
fin_procedimiento
procedimiento contar_aprob_desap(E Alumno: arr[]; E entero: cant; S entero: apr, des)

var
entero: i;
inicio
si (arr[i].promedio >= 12) entonces
apr  apr + 1;
si_no
des  des + 1;
fin_si
fin_desde
fin_procedimiento
Ejemplo 12.3
Establecer un listado de suscriptores de una revista a través de una estructura, cuyos datos de
entrada serán los datos de cada suscriptor: nombre, DNI, mes de inscripción, año de
inscripción. Mostrar la cantidad de suscriptores registrados en el año 2020 y también por mes
del mismo año.
90
algoritmo suscripcion_revista
tipo
registro Fecha
entero: mes, anio;
fin_registro
registro Suscriptor
entero: dni;
cadena: nombre;
Fecha: f_suscripcion;
fin_registro
var
entero: N, cant_susc_2020;
Suscriptor: arr_susc[N];
inicio
escribir(“Cuantos elementos desea registrar”);
leer(N); //una vez leído N, ya no se podrá modificar el tamaño del
arreglo
llenar_arreglo(arr_susc, N);
cant_susc_2020  contar_suscrip_2020(arr_susc, N);
escribir(“Este año se han suscrito: ”, cant_susc_2020, “
personas.”);
mostrar_por_mes(arr_susc, N);
fin
procedimiento llenar_arreglo(S Suscriptor: arreglo; E entero: cant)

var
entero: i;
inicio
leer(arreglo[i].dni);
leer(arreglo[i].nombre);
leer(arreglo[i].f_suscripcion.mes);
leer(arreglo[i].f_suscripcion.anio);
fin_desde
fin_procedimiento
entero funcion contar_suscrip_2020(E Suscriptor: arr[]; E entero: cant)

var
entero: i, cont;
inicio
desde (i0) hasta (i<=cant-1) hacer 1 inc
si (arr[i].f_suscripcion.anio==2020) entonces
cont  cont + 1;
fin_si
fin_desde
devolver(cont);
fin_funcion
procedimiento mostrar_por_mes(E Suscriptor: arr[]; E entero: cant)

var
entero: i, cont_mes[12];
inicio
desde (i0) hasta (i<=cant-1) hacer 1 inc
91
si (arr[i].f_suscripcion.anio==2020) entonces
segun_sea (arr[i].f_suscripcion.mes) hacer
caso 1: cont_mes[0]  cont_mes[0]+1;
fin_segun
fin_si
fin_desde
escribir(“CANT. SUSCRIPTORES DEL 2020:”);
escribir(“Enero: ”, cont_mes[0]);
escribir(“Febrero: ”, cont_mes[1]);
escribir(“Marzo: ”, cont_mes[2]);
escribir(“Abril: ”, cont_mes[3]);
escribir(“Mayo: ”, cont_mes[4]);
escribir(“Junio: ”, cont_mes[5]);
escribir(“Julio: ”, cont_mes[6]);
escribir(“Agosto: ”, cont_mes[7]);
escribir(“Septiembre: ”, cont_mes[8]);
escribir(“Octubre: ”, cont_mes[9]);
escribir(“Noviembre: ”, cont_mes[10]);
escribir(“Diciembre: ”, cont_mes[11]);
fin_procedimiento
Ejemplo 12.4
Una tienda de automóviles desea llevar el control de los autos que disponen en su almacén.
Para lo cual debes crear un arreglo de registros que almacene los siguientes datos de los
automóviles: marca, modelo, precio, año y si es nuevo o no.
Se recomienda crear un arreglo con el suficiente espacio para guardar auto que puedan venir
en un futuro. Crear un menú con estas opciones: agregar automóviles (siempre que se agregue
un nuevo automóvil debe preguntar si desea agregar otro), listar automóviles.
algoritmo tienda_autos
const
MAX = 1000
tipo
registro Automovil
cadena: marca, modelo;
real: precio;
entero: anio
booleano: es_nuevo;
fin_registro
var
Automovil: arr_autos[MAX];
entero: cant;
92
inicio
cant  0;
hacer
escribir(“MENU DE OPCIONES:”);
escribir(“ (1) Registrar”);
escribir(“ (2) Listar”);
escribir(“ (3) Salir”);
escribir(“Ingrese opción: ”);
leer(opc);
segun_sea (opc) hacer

caso 1: registrar(arr_autos, cant, MAX);
caso 2: listar(arr_autos, cant);
fin_segun
mientras(opc!=3);
fin
procedimiento registrar(E/S Automovil: arr[]; E/S entero: cant_reg; E entero: max)

var
caracter: rspta;
inicio
hacer
leer(arr[cant_reg].marca);
leer(arr[cant_reg].modelo);
leer(arr[cant_reg].precio);
leer(arr[cant_reg].anio);
leer(arr[cant_reg].es_nuevo);
cant_reg  cant_reg + 1;
escribir(“Desea seguir registrando? (S/N)”);
leer(rspta);
mientras(rspta==‘S’ AND cant_reg<=max-1);
fin_promedio
procedimiento listar(E Automovil: arr[]; E entero: cant_reg)

var
entero: i;
inicio
desde (i0) hasta (i<=cant_reg-1) inc 1 hacer
escribir(“AUTOMOVIL N° ”, i+1);
escribir(“Marca: ”, arr[i].marca);
escribir(“Modelo: ”, arr[i].modelo);
escribir(“Precio: ”, arr[i].precio);
escribir(“Año: ”, arr[i].anio);
escribir(“Es nuevo: ”, arr[i].es_nuevo);
fin_desde
fin_promedio
93
Ejemplo 12.5
Se desea registrar los datos de los docentes de la Universidad: nombre, edad, correo, DNI, título
profesional, teléfono, sueldo.
algoritmo docentes_universitarios
tipo
registro Docente
cadena: dni, nombre, correo, titulo, telef;
entero: edad;
real: sueldo;
fin_registro
var
entero: N;
Docente: arr_doc[N];
inicio
escribir(“Ingrese cantidad de docentes:”);
leer(N);
llenar_arreglo(arr_doc, N);
fin
procedimiento llenar_arreglo(S Docente: arr[]; E entero: cant)

var
entero: i;
inicio
leer(arr[i].dni);
leer(arr[i].nombre);
leer(arr[i].correo);
leer(arr[i].titulo);
leer(arr[i].telef);
leer(arr[i].edad);
leer(arr[i].sueldo);
fin_desde
fin_promedio
94
Conclusiones y Recomendaciones
Después de haber hecho un repaso teórico y práctico por todos los temas básicos de la
programación es necesario recalcar la gradualidad en que estos se desarrollan. Al igual que las
matemáticas en donde primero se debe aprender a sumar, para luego restar y luego aprender
a multiplicar y dividir, así mismo la programación tiene un aprendizaje escalonado donde
primero se debe aprender los conceptos básicos como qué es un algoritmo, datos, tipos de
datos, variables; posteriormente a analizar los problemas y luego diseñarlos utilizando las
herramientas de pseudocódigo y diagramas de flujo aplicando las estructuras de control.
Después de haber aprendido los Capítulos I y II, en el Capítulo III se enfoca más en cómo
estructura los datos; siendo este un punto importante en la programación, ya que, en el
campo laboral se suele trabajar con miles o millones de datos y es necesario conocer a
profundidad cómo modelar y estructurar todas esta información de manera que resulte fácil
manipularlos para nuestro beneficio.
Se recomienda al estudiante aprender un lenguaje de programación básico (como C++)
para poner en práctica todo lo aprendido acerca de los fundamentos de la programación; de
esta manera estaría entrando a la 3ª etapa para la resolución de problemas por computador:
la codificación; y con esta nos llevará a las siguientes: 4ª compilación y ejecución y 5ª
verificación y depuración. Así, el alumno desarrollará mucho mejor su lógica y su experiencia,
útil para continuar con su carrera profesional y en el ámbito laboral.
95
Bibliografía
Fuenlabrada Velázquez, S. (2015). Manejo de técnicas de programación (Primera ed.).
México: Pearson Educación.
Joyanes Aguilar, L. (2008). Fundamentos de Programación. Algoritmos, estrucuturas de datos
y objetos (Cuarta ed.). Madrid, España: McGraw-Hill.
Joyanes Aguilar, L., & Sánchez García, L. (2006). Programación en C++. Un enfoque práctico.
Serie Schaum (Primera ed.). Madrid, España: McGraw-Hill.
96

Fundamentos de Programación - Un Enfoque Práctico

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fundamentos de Programación - Un Enfoque Práctico

Cargado por

Copyright:

Formatos disponibles

FUNDAMENTOS

Hecho el Depósito Legal en la Biblioteca Nacional del Perú N° 2021-06111.

El documento está estructurado en 03 Capítulos y cada uno en 04 temas: El primer

Tema 1. Introducción a los Fundamentos de Programación.

ALGORITMO vs. PROGRAMA

Un algoritmo no es lo mismo que un programa (software). Un algoritmo es el método para

Problema Algoritmo Algoritmo en C++ Programa

ETAPAS PARA LA RESOLUCIÓN DE PROBLEMAS

Dato Tipo de Dato

nombre apellidos un_identificador

a) XRayo b) X_Rayo c) R2D2

Operadores Lógicos Símbolo

Como se puede apreciar en el Ejemplo 2.7, en ciertas expresiones por computadora

ESTRUCTURA GENERAL DE UN ALGORITMO

Figura 3.1. Bloques estructurales de un programa

INSTRUCIONES Y SUS TIPOS

Figura 3.2. Estructura básica de un Pseudocódigo

La declaración de constantes es opcional ya que va a depender mucho del tipo de

Figura 3.5. Declaración de cinco variables en Pseudocódigo.

Figura 3.6. Instrucciones en Pseudocódigo

• Asignación: la variable que guarda el dato va al lado izquierdo; el operador de

Figura 3.7. Sintaxis de una Instrucción de asignación en Pseudocódigo

• Lectura: instrucción que permite capturar un dato de entrada y guardarlo en una

Figura 3.8. Sintaxis de una Instrucción de lectura en Pseudocódigo

Figura 3.9. Sintaxis de una Instrucción de escritura en Pseudocódigo

A continuación se muestran unos ejemplos de diseño de algoritmo utilizando Pseudocódigo.

Símbolo Nombre Descripción

Conexión entre dos puntos del ordinograma

Una subrutina es un módulo independiente

suma  num1 + num2

area  (base * altura) / 2

Figura 4.1. Diagrama de Flujo de la Estructura Secuencial

Figura 4.2. Pseudocódigo de la Estructura Secuencial

Pedir m1 algoritmo fuerza_gravitacional

Mostrar pie, yr,

//conversión de billetes entre 200 a 10:

//Conversión en céntimos entre 0.50 a 0.05:

escribir(“Cant. Billetes de 200: ”, b200);

Tema 5. Estructuras de Control Selectiva Simple y Doble.

ESTRUCTURA DE CONTROL SELECTIVA O CONDICIONAL SIMPLE

Figura 5.1. Diagrama de Flujo de la Estructura Selectiva Simple

Figura 5.2. Pseudocódigo de la Estructura Selectiva Simple

Inicio algoritmo punto_ebullicion

Inicio algoritmo numero_impar

Inicio algoritmo angulo_centesimal

Inicio algoritmo promedio_aprobado

Figura 5.3. Diagrama de Flujo de la Estructura Condicional Doble

Figura 5.4. Pseudocódigo de la Estructura Condicional Doble

Pedir num1, num2

aumento ← sueldo*0.45 descuento ← sueldo*0.1

sueldo_final ← sueldo+aumento sueldo_final ← sueldo-descuento

acciones S1 acciones S2 acciones S3 acciones S4 . . . acciones Sn

Figura 5.5. Diagrama de flujo de la Estructura Condicional Múltiple.

segun_sea (<expresión ó variable>) hacer

Figura 5.6. Pseudocódigo de la Estructura Condicional Múltiple.

Mostrar Mostrar Mostrar Mostrar

Mostrar Mostrar Mostrar Mostrar

Leer num1, num2

result ← num1 + num2 result ← num1 * num2 num2!=0 F

result ← num1 MOD num2

result ← num1 / num2

si(<condición 1>) entonces

Leer n1, n2, n3

aumento ← sueldo0.45 descuento ← sueldo0.1

det  b^2 - 4ac