Contenido

1. Introducción al desarrollo de algoritmos.................................................................... 1

1.1. Conceptos de algoritmos ............................................................................................................... 1
1.2. Partes de un algoritmo.................................................................................................................... 1
1.3. Ejemplos de algoritmos .................................................................................................................. 2
1.4. Tipos de Datos.................................................................................................................................... 3
1.5. Identificadores, variables y constantes ..................................................................................... 4
1.6. Ejercicios de algoritmos .................................................................................................................. 5
2. Conceptos básicos de pseudocódigo........................................................................... 6
2.1. Concepto de pseudocódigo.......................................................................................................... 6
2.2. Sintaxis................................................................................................................................................... 6
2.3. Uso de palabras reservadas........................................................................................................... 7
2.4. Pruebas de escritorio ....................................................................................................................... 8
2.5. Ejemplos de pseudocódigo ........................................................................................................... 9
2.5.1. Solución de problemas secuenciales ................................................................................ 9
2.5.2. Solución de problemas con estructuras selectivas .................................................... 10
2.6. Ejercicios de pseudocódigo......................................................................................................... 12
3. Expresiones .................................................................................................................. 13
3.1. Operadores aritméticos, relacionales y lógicos ................................................................... 13
3.1.1. Operadores aritméticos ....................................................................................................... 13
3.1.2. Operadores relacionales ...................................................................................................... 15
3.1.3. Operadores lógicos ............................................................................................................... 16
3.2. Ejemplos del uso de operadores ............................................................................................... 18
3.3. Ejercicios de expresiones .............................................................................................................. 19
4. Introducción al desarrollo de diagramas de flujo .................................................... 20
4.1. Ejemplos del uso de diagramas de flujo ................................................................................ 22
4.2. Ejercicios de diagramas de flujo ................................................................................................ 25
5. Estructuras Selectivas .................................................................................................. 26
5.1. Estructuras Selectivas Simples .................................................................................................... 26
5.1.1. Ejemplos del uso de estructuras selectivas simples .................................................. 26
5.2. Estructuras Selectivas Múltiples ................................................................................................. 29
5.2.1. Ejemplos del uso de estructuras selectivas múltiples............................................... 29
 5.3. Ejercicios de estructuras selectivas ........................................................................................... 34
6. Estructura repetitiva Mientras ................................................................................... 35
6.1. Ejemplos del uso de la estructura repetitiva ......................................................................... 35
6.2. Ejercicios ............................................................................................................................................. 38
7. Ejercicios del curso ...................................................................................................... 39

Bibliografía
 Introducción
El presente curso ha sido desarrollado con el propósito de atender las necesidades
de los aspirantes provenientes del nivel medio superior, poniendo énfasis en reafirmar
conceptos básicos del área de lógica de programación. Por consiguiente, en este espacio se
te proporcionarán los conocimientos mínimos necesarios para poder iniciar tu carrera de
Técnico Superior Universitario (TSU) en Tecnologías de la Información (TI) dentro de la UTEZ.

Conforme vayas avanzando en el curso, aprenderás temas relacionados con los

algoritmos, pseudocódigo y diagramas de flujo, que en su conjunto te ayudarán a desarrollar
habilidades de lógica de programación y a tener un mejor desempeño durante tu trayectoria
académica dentro de la Universidad.

Este curso está diseñado para que lo tomes en dos semanas de forma consecutiva,
proporcionándote los conocimientos y herramientas que se vayan requiriendo. Al finalizar
el curso, habrá una evaluación final que determinará los conocimientos que hayas adquirido
durante este curso.

¡Bienvenido y mucho éxito!

 1. Introducción al desarrollo
de algoritmos
1.1. Conceptos de algoritmos

Serie de pasos a realizar para resolver un determinado problema. Se

Algoritmo considera como una herramienta efectiva para la solución de problemas,
tanto técnicos como de la vida cotidiana.

¿Qué prefieres? ¿Primero diseñar una solución al problema para posteriormente

codificarla en un lenguaje de programación o pasar directamente a la computadora e
intentar solucionar el problema una y otra vez hasta que finalmente logres resolverlo?

Aunque se piense que realizar un análisis previo del problema y diseño del algoritmo
es una pérdida de tiempo, resulta un buen hábito para los desarrolladores aplicar la
metodología de la programación sin importar si se trata de problemas complejos o sencillos.
Un algoritmo puede ser considerado como un “plan”, pues indica qué se va a hacer y cómo
se va a hacer. Por ejemplo:

• La suma de dos números.

• La obtención de información de una base de datos.
• Retirar efectivo de un cajero.
• La elaboración de un platillo para la comida.

Las características de un algoritmo son:

• Preciso: El algoritmo debe ser claro al indicar el orden en el que se deben

realizar los pasos.
• Definido: El resultado del algoritmo no debe cambiar bajo las mismas
condiciones. Ejemplo al sumar 2 + 3, siempre deberá dar como resultado 5,
nunca un resultado diferente, de lo contrario no sería un algoritmo definido.
• Finito: No se deben repetir pasos de forma innecesaria. El algoritmo debe
tener un INICIO y un FIN.

1.2. Partes de un algoritmo

Todo algoritmo debe contar con un conjunto de componentes, mostrados en la

Figura 1.1, que integran su estructura básica. Entre ellos se encuentran:

• Entrada: Datos que el programador necesita conocer para resolver el

problema (tipo y valor). Puede ser proporcionada por el usuario o tener
valores por defecto.

1
 • Proceso: Pasos o acciones que se deben realizar para dar solución al
problema (orden lógico).
• Salida: Resultado que se obtiene al realizar el proceso (tipo y valor).

Figura 1.1
Representación
gráfica de un
algoritmo. ¿Qué recibo? ¿Qué hago? ¿Qué obtengo?

1.3. Ejemplos de algoritmos

Ejemplo 1. Escriba un algoritmo que permita hacer agua de limón.

Inicio.
Vaciar el agua en un recipiente.
Agregar azúcar al gusto
Mezclar el agua hasta disolver el azúcar
Vaciar el jugo de limón en el recipiente que contiene el agua.
Mezclar el agua y el jugo de limón.
Fin.
Con este algoritmo es posible notar una situación de la vida cotidiana, donde por
medio de cinco pasos se obtiene un resultado: un vitrolero lleno de agua de limón.

Ejemplo 2. Escriba un algoritmo que permita retirar efectivo de un cajero.

Inicio.
Insertar la tarjeta en el cajero.
Ingresar el NIP.
Elegir la opción “retirar efectivo”.
Escoger el monto a retirar.
Confirmar transacción.
Retirar tarjeta.
Tomar el efectivo.
Finalizar transacción.
Fin.

Con este algoritmo es posible notar que tenemos una entrada, esta es la tarjeta que
se está insertando en el cajero y el NIP, posteriormente, se selecciona el monto a retirar y

2
termina la transacción. Por último, se retira la tarjeta y la salida es el efectivo que está
retirando la persona que usó el cajero.

El lenguaje algorítmico debe ser independiente de cualquier lenguaje de

programación particular, pero fácilmente traducible a cada uno de ellos. Alcanzar estos
objetivos conducirá al empleo de métodos normalizados para la representación de
algoritmos, tales como los diagramas de flujo o pseudocódigo, comentados más adelante.

Una vez que se ha terminado de escribir un algoritmo es necesario comprobar que

realiza las tareas para las que se ha diseñado produciendo el resultado correcto y esperado.
El modo más normal de comprobar un algoritmo es mediante su ejecución manual, usando
datos significativos que abarquen todo el posible rango de valores y anotando en una hoja
de papel las modificaciones que se producen en las diferentes fases hasta la obtención de
los resultados. Este proceso se conoce como prueba del algoritmo (prueba de escritorio).

1.4. Tipos de Datos

Tipos de Conjunto de valores que una variable o constante puede tomar durante
datos la codificación y ejecución de un programa.

Figura 1.2
Clasificación
general de los
tipos de datos.

3
 Los tipos de datos restringen los valores que podemos almacenar dentro de una
variable o constante. Por consiguiente, también limitan las operaciones que podemos
realizar con ellos.

Cada lenguaje de programación tipado trabaja con sus respectivos tipos de datos.
No obstante, todos ellos se clasifican en dos categorías: los primeros conocidos como tipos
de datos simples o primitivos y los tipos de datos compuestos o complejos. De igual forma,
los tipos de datos simples o compuestos presentan algunas subclasificaciones, como se
muestra en la Figura 1.2.

1.5. Identificadores, variables y constantes

Nombre que se asigna a cualquier clase, método, función, constante,

Identificador
variable u objeto.

Para asignar nombre a los identificadores es necesario considerar las siguientes

reglas:

× No se debe utilizar una palabra reservada como identificador. Para ello, es

necesario revisar la lista de las palabras reservadas del lenguaje en el que se
esté desarrollando. Por ejemplo, si se está escribiendo código en Java, no se
pueden utilizar como identificadores las palabras for, break, while, switch, etc.
× Un número (1, 2, 3…) no puede ser un identificador, ya que estos funcionan
como operando dentro del programa.
× El nombre del identificador no debe contener espacios en blanco. Por
ejemplo: “precio producto”. En este caso, es viable sustituir el espacio en
blanco por un guión bajo “precio_producto”, de lo contrario sería incorrecto
el nombre del identificador.
× El nombre del identificador no debe contener caracteres especiales (ñ, #, $,
&, %, @...). Sin embargo, en algunos lenguajes de programación se utilizan
caracteres especiales como prefijo para las variables. Por ejemplo, en PHP se
coloca $ antes del identificador, mientras que en Microsoft SQL Server se
utiliza un @.
× Un identificador no debe comenzar con un número.

✓ El nombre asignado al identificador puede estar compuesto de letras (A-Z)

mayúsculas y/o minúsculas.
✓ Un identificador puede ser una combinación de letras y números, respetando
que no debe comenzar con un número.
✓ Al momento de asignar el nombre al identificador, opta por la inicial de la
variable o alguna palabra clave que le permita ser identificada fácilmente.

4
1.6. Ejercicios de algoritmos

1.1. Escriba un algoritmo que permita calcular el total a pagar de una

prenda que tiene un porcentaje de descuento.
1.2. Escriba un algoritmo que permita obtener el área de un círculo.
1.3. Escriba un algoritmo para calcular la suma de dos números ingresados
desde el teclado por el usuario.
1.4. Declare un identificador para cada uno de los casos mostrados e
inicialícelos. Además, especifique su tipo de dato y si se trata de una
variable o constante. Utilice la siguiente tabla.

Tipo de Valor Tipo de

Dato por guardar Identificador
dato inicial identificador
Nombre de una persona Cadena NOMBRE_PER “Juan” Constante

Número de meses Entero NUM_MESES 12 Constante

Promedio de un alumno Real prom 9.6 Variable

Precio de un producto

Velocidad de la luz

Estatura de una persona

El resultado de una
suma
CURP de una persona
Cantidad de estudiantes
en un grupo
NIP de una tarjeta
bancaria
Número de metros en
una hectárea
Resultado de una
comparación de valores
Matrícula de un
estudiante
Edad de una persona

Salario de un trabajador

Talla de ropa
Total de artículos
vendidos en una tienda

5
 2. Conceptos básicos de
pseudocódigo
2.1. Concepto de pseudocódigo

Herramienta de programación en la que las instrucciones se escriben en

Pseudocódigo palabras similares al inglés o español, que facilitan tanto la escritura como
la lectura de programas

En esencia, el pseudocódigo se puede definir como un lenguaje de especificaciones

de algoritmos. Dicho en forma sencilla, el pseudocódigo o pseudolenguaje, son una serie de
instrucciones en nuestro lenguaje natural (español, inglés, etc.) y expresiones que
representan cada uno de los pasos que resuelven un problema específico (algoritmo).

2.2. Sintaxis

Aunque no existen reglas para la escritura del pseudocódigo en español, se ha

adoptado una notación estándar que se usa en distintas fuentes bibliográficas de
programación en español. El pseudocódigo utiliza palabras que indican el proceso a realizar.
Por todo lo anterior, es una técnica NO GRÁFICA.

Proceso NombreDelPseudocodigo
Definir [variables] como [tipo de dato]
Instrucciones Parámetros;
FinProceso

La sección de variables es opcional. Esto se debe a que habrá ocasiones en las

que NO será necesario utilizar variables para resolver el problema.

El pseudocódigo original utiliza, para representar las acciones sucesivas, palabras

reservadas en inglés similares a sus homónimas en los lenguajes de programación. Entre
ellas se encuentran: Process, EndProcess, If-Then-Else, While-End, Repeat-Until y otras más.
Ahora bien, en este manual se utilizarán sus equivalentes en español. Por ejemplo, en lugar
de usar Process se utilizará Proceso. La escritura de pseudocódigo exige normalmente la
indentación (sangría en el margen izquierdo) para las diferentes líneas.

El pseudocódigo DespliegaMensaje describe un ejemplo básico que muestra el

mensaje “¡Hola mundo!” en pantalla.

6
Pseudocódigo DespliegaMensaje
1 //Pseudocódigo que imprime un mensaje
2 Proceso ImprimeMensaje
3 Escribir “¡Hola mundo!”;
4 FinProceso

El pseudocódigo AreaTriangulo muestra cómo se realiza el cálculo del área de un

triángulo tomando en cuenta la base y la altura proporcionadas por el usuario.

Pseudocódigo AreaTriangulo
1 //Pseudocódigo que solicita la base y altura de un triángulo para calcular su área
2 Proceso AreaTriangulo
3 Definir base, altura como Entero;
4 Definir area como Real;
5 base ← 0;
6 altura ← 0;
7 area ← 0.0;
8 Escribir “Introduce la base: ";
9 Leer base;
10 Escribir ”Introduce la altura: ";
11 Leer altura;
12 area ← base * altura / 2;
13 Escribir “El área del triángulo es ”, area;
14 FinProceso

Los identificadores no se acentúan. Por ejemplo, se escribe area en lugar de

área.

2.3. Uso de palabras reservadas

Para entender por completo el pseudocódigo AreaTriangulo, debemos conocer el

significado de las palabras reservadas, como:

• Proceso, FinProceso. Indica el comienzo y término del algoritmo.

• Escribir. Muestra mensajes e información en el monitor.
• Leer. Almacena un dato que es capturado desde el teclado en una
variable.

7
 • Si ... Entonces. Es una pregunta para una estructura de selección, donde
si la respuesta es verdad se realizan unas tareas específicas y cuando es
falso se pueden realizar otras.
• SiNo. Indica el comienzo de las instrucciones a realizar cuando la
respuesta a la pregunta Si...Entonces es falsa.
• FinSi. Indica el término de la estructura condicional Si...Entonces.

En el pseudocódigo se escribirán las palabras reservadas en negrita y los

identificadores en cursiva.

2.4. Pruebas de escritorio

Prueba de
Comprobación lógica de un algoritmo (pseudocódigo o programa).
escritorio

Con este tipo de prueba podemos saber 1) si el programa hace lo que debería hacer
y 2) si NO hace lo que debería hacer. La prueba de escritorio permite detectar errores como:

• Paso o instrucción que no está en el orden correcto.

• Si falta algo y/o algún paso.
• Si las instrucciones están en un orden apropiado.
• Otros errores que pueden presentarse.

Es muy importante saber elegir los datos apropiados para realizar la prueba de
escritorio. La prueba de escritorio consiste en efectuar un proceso de simulación con el
algoritmo desarrollado (conocer que haría la computadora). Este trabajo se realiza con base
en una tabla, la cual tiene como encabezado las variables que se usan en el pseudocódigo.
Debajo de cada variable se colocan los valores que adoptan al seguir el flujo de ejecución
del algoritmo hasta llegar al final.

Usaremos el pseudocódigo AreaTriangulo para realizar una prueba de escritorio. La

prueba de escritorio requiere hacer una tabla con las variables, como son: base, altura, area.
Además, se ha colocado una columna a la izquierda que lleva cuenta de los cambios de valor
que han tenido las variables.

#asignación base altura area

1 0
2 0
3 0.0
4 3
5 5
6 7.5

8
 Las líneas 1, 2 y 3, realizan la inicialización (asignar un valor inicial) de las variables
base, altura y area respectivamente. Para este ejemplo, no es necesario realizar su
inicialización, puesto que a estas variables se les asignará un valor especificado por el usuario
antes de ser utilizadas para realizar una operación.

2.5. Ejemplos de pseudocódigo

Sin importar la herramienta o técnica que se utilice para la solución de un problema

dado, ésta tendrá una estructura que se refiere a la secuencia en que se realizan las
operaciones o acciones para resolver el problema. Dichas estructuras pueden ser:
secuenciales, de decisión y de ciclo o repetición.

En el punto 2.5.1 se resolverán problemas mediante pseudocódigo. Al analizar cada

problema identifique que datos debe suministrar el usuario (entrada), qué pasos se deben
realizar para solucionar el problema (proceso) y qué resultados se deben mostrar (salida).

2.5.1. Solución de problemas secuenciales

Comenzaremos resolviendo problemas que tienen una estructura secuencial, es decir,

aquellos que las instrucciones se realizan o se ejecutan una después de la otra y solo se tiene
un camino de ejecución. Por lo general, se espera que se proporcione uno o varios datos,
los cuales son asignados a variables para que con ellos se produzcan los resultados que
representen la solución del problema que se planteó.

Ejemplo 1. Realice el pseudocódigo que muestre, en pesos, el total a pagar y el

descuento por adquirir una prenda que tiene el 15% de descuento.

Pseudocódigo ProductoDescuento
1 //Pseudocódigo que muestra el descuento y total a pagar por una prenda
2 Proceso ProductoDescuento
3 Definir costo, descuento, total como Real;
4 Escribir ”Ingresa el costo de la prenda: “;
5 Leer costo;
6 descuento ← costo * 0.15;
7 total ← costo – descuento;
8 Escribir “El descuento es: “, descuento;
9 Escribir “El total a pagar es: “, total;
10 FinProceso

9
Ejemplo 2. Elabore un pseudocódigo que solicite el nombre, edad y dirección al usuario y
después muestre la siguiente salida en pantalla: “Hola <<nombre>>, tienes <<edad>> años
y vives en <<dirección>>”.

Pseudocódigo DatosPersonales
1 //Pseudocódigo que solicita al usuario sus datos personales
2 Proceso DatosPersonales
3 Definir nombre, direccion como Cadena;
4 Definir edad como Entero;
5 Escribir “Ingresa tu nombre: ";
6 Leer nombre;
7 Escribir “Ingresa tu edad: “;
8 Leer edad;
9 Escribir ”Ingresa tu dirección: “;
10 Leer direccion;
11 Escribir "Hola ", nombre,", tienes ", edad," años y vives en ", direccion;
12 FinProceso

La línea 11 realiza tanto el proceso y la salida esperada por el pseudocódigo. En

ocasiones NO será necesario aplicar una formula (cálculos) usando los datos de entrada para
obtener el resultado que se desea mostrar al usuario.

2.5.2. Solución de problemas con estructuras selectivas

Habrá ocasiones en las que la solución de un problema implique seguir o no un

determinado flujo de ejecución. Por ejemplo, si un alumno tiene una calificación aprobatoria
entonces imprimir “Promovido”, en caso contrario, imprimir “No promovido”. En estos casos,
el pseudocódigo deberá incluir una o más preguntas de selección usando la sintaxis:

Si comparación_verdadera Entonces
accion1
SiNo
accion2
FinSi

Observa que la sección “si no” es opcional, esto permitirá ejecutar acciones
cuando solamente se cumpla una condición y NO se requiere realizar otra
acción en caso contrario.

10
Ejemplo 3. Realice un pseudocódigo que solicite el nombre y la edad del usuario e indique
si es menor o mayor de edad. El mensaje para mostrar en caso de ser menor de edad es
“Hola <<nombre>>, eres menor de edad”, y en caso contrario “Hola <<nombre>>, eres
mayor de edad”.

Pseudocódigo MenorMayorEdad
1 //Pseudocódigo que determina si una persona es mayor de edad
2 Proceso MenorMayorEdad
3 Definir nombre Como Caracter;
4 Definir edad Como Entero;
5 Escribir “Ingresa tu nombre: “;
6 Leer nombre;
7 Escribir “Ingresa tu edad: ";
8 Leer edad;
9 Si edad < 18 Entonces
10 Escribir “Hola “, nombre, “ eres menor de edad”;
11 SiNo
12 Escribir “Hola “, nombre, “ eres mayor de edad”;
13 FinSi
14 FinProceso

Ejemplo 4. Se requiere determinar cuál de tres números proporcionados es el mayor. Para

ello, realice el pseudocódigo que informe la siguiente salida: “Dados los números:
<<num1>>, <<num2>> y <<num3>>, el mayor de ellos es el <<mayor>>.

Pseudocódigo NumeroMayor
1 //Pseudocódigo que determina el número mayor de tres números ingresados
2 Proceso NumeroMayor
3 Definir num1, num2, num3, mayor como Real;
4 Escribir “Ingresa primer número: ";
5 Leer num1;
6 Escribir “Ingresa segundo número: “;
7 Leer num2;
8 Escribir “Ingresa tercer número: “;
9 Leer num3;
10 Si num1 > num2 Entonces
11 Si num1 > num3 Entonces
12 mayor ← num1;
13 SiNo
14 mayor ← num3
15 FinSi
11
16 SiNo
17 Si num2 > num3 Entonces
18 mayor ← num2
19 SiNo
20 mayor ← num3
21 FinSi
22 FinSi
23 Escribir “Dados los números: “, num1, “, ”, num2, " y ", num3, " el mayor es el ",
24 mayor
FinProceso

Para que este pseudocódigo muestre un mensaje de salida coherente, los números
proporcionados deben tener diferentes valores.

2.6. Ejercicios de pseudocódigo

2.1 Elabore un pseudocódigo que permita convertir una cantidad ingresada

en grados Celsius a grados Fahrenheit. El formato de salida es:
<<celsius>> °C = <<Fahrenheit>> °F
2.2 Realice el pseudocódigo que resuelva el cálculo de los salarios
mensuales de los empleados de una empresa, sabiendo que éstos se
calculan con base en las horas semanales trabajadas y de acuerdo con
un precio especificado por horas. Si se exceden las cuarenta horas
semanales, las horas extraordinarias se pagarán a razón de 1.5 veces la
hora ordinaria.

12
 3. Expresiones
Las expresiones son una parte fundamental de la programación ya que sirven para
realizar una o varias operaciones sobre un dato o un conjunto de datos, obteniéndose otro
dato como resultado. Los operadores definen las operaciones que pueden realizarse dentro
de una expresión.

Una expresión está formada por operandos y operadores. Los datos u operandos
pueden ser constantes, variables y llamadas a funciones. Además, dentro de una expresión
pueden encontrarse expresiones internas encerradas entre paréntesis. Por ejemplo, la
expresión algebraica:
𝑢3 + (𝑣 − 5)2 ∙ 𝜋

Cuando se ejecuta una sentencia de código que contiene una expresión, ésta se
evalúa tomando en cuenta el valor o valores asignados previamente a las variables y/o
constantes, los operadores, las funciones utilizadas y la secuencia de la ejecución de las
operaciones correspondientes. El valor resultante de la evaluación de la expresión será de
un determinado tipo de dato. Por ejemplo, de un tipo numérico entero, de un tipo real o de
un tipo lógico o booleano.

La expresión algebraica 𝑢3 + (𝑣 − 5)2 ∙ 𝜋 debe ser convertida a expresión

aritmética algorítmica para que pueda ser evaluada por un computador. Por
ejemplo, la expresión anterior debe ser escrita como u^3 + (v - 5)^2 * PI; para
ser evaluada en PSeInt.

3.1. Operadores aritméticos, relacionales y lógicos

Se utilizan para elaborar una expresión o fórmula en una sola línea de código,
utilizando operadores, operandos y unos criterios de ejecución llamados reglas de
precedencia. Se puede dividir el conjunto de todos los operadores en tres grupos:

• Operadores Aritméticos
• Operadores Relacionales
• Operadores Lógicos

3.1.1. Operadores aritméticos

Permiten realizar cualquier operación aritmética como suma, resta, multiplicación,

división, módulo y asignación. Los operadores aritméticos operan sobre valores de tipo
entero o real. En la Figura 3.1 se muestran los operadores aritméticos y un ejemplo de cada
uno.

13
Figura 3.1
Operaciones y
operadores
aritméticos.

Los operadores aritméticos son del tipo binario; es decir, necesitamos de dos
operandos, uno a la izquierda y otro a la derecha para realizar una operación.

El operador % (MOD) arroja como resultado el resto de la división "entera", y

por ello los operandos deben ser números enteros. En PSeInt los operandos
también podrían ser números reales (con punto decimal), pero su valor debe
ser una cifra que pueda convertirse a entero sin pérdida de datos (conversión
implícita), por ejemplo, el resultado de la expresión r ← 5.0 % 2.0; es 1

Las expresiones aritméticas se deben escribir en una línea continua, considerando las
reglas de precedencia de operadores mostradas en la Figura 3.2. Estas reglas son guías de
acción que permiten calcular las expresiones en el orden correcto y son:

• Si en la expresión se encuentran paréntesis, esto indica que lo que está

dentro de ellos se debe resolver antes que cualquier cosa siguiendo las
reglas de precedencia mencionadas en los siguientes puntos. Los
paréntesis son utilizados para obligar a la computadora a evaluar primero
ciertas expresiones. En caso de existir paréntesis anidados se evalúa el par
más interno.
• Calcular la operación de potenciación.
• Calcular las operaciones de multiplicación, división y módulo, los cuales
tienen el mismo nivel de precedencia. Si existen varios de estos en una
expresión se comienzan a calcular de izquierda a derecha.
• Calcular las operaciones de suma y de resta, los cuales tienen el mismo
nivel de precedencia. Si la expresión contiene varias de estas se realizan
de izquierda a derecha.
• Por último, se realiza la asignación, la cual significa que el valor de la
derecha es asignado al identificador de la izquierda.

14
Figura 3.2
Precedencia de
operadores
aritméticos.

En la comparación r ← 'a' ≠ 'A'; PSeInt compara el valor que corresponde a cada

carácter de acuerdo con el código ASCII, en este caso, 'a' equivale a 97 y 'A'
equivale a 65, por lo tanto, al evaluar r ← 97 ≠ 65; el resultado es VERDADERO.

3.1.2. Operadores relacionales

Son operadores binarios en los que los operandos son enteros, reales o de cadena.
Todos ellos dan lugar a resultados de tipo booleano (falso o verdadero). Los operadores
relacionales se resumen en la Figura 3.3.

Figura 3.3
Operadores
relacionales.

En la comparación r ← 'a' ≠ 'A'; PSeInt compara el valor que corresponde a cada

carácter de acuerdo con el código ASCII, en este caso, 'a' equivale a 97 y 'A'
equivale a 65, por lo tanto, al evaluar r ← 97 ≠ 65; el resultado es VERDADERO.

No todos los operadores relacionales están al mismo nivel de precedencia entre ellos.
Los operadores <, <=, >, >=, tienen mayor precedencia que los operadores de == y !=. En
la Figura 3.4 se muestra el nivel de precedencia de los operadores relacionales.

Figura 3.4
Precedencia de
operadores
relacionales.

15
 En las expresiones, se pueden omitir el uso de paréntesis y proceder a resolverla de
acuerdo con las reglas de precedencia. Por ejemplo, considere evaluar la expresión:

n <- 2 <= 4 == 6 >= 4;

Figura 3.5
Evaluación de la
expresión.

Si bien en ocasiones se puede omitir el uso de paréntesis para establecer orden

de prioridad de forma explícita, se recomienda su uso para que la expresión
sea más legible, de hecho, si evaluáramos esta expresión en PSeInt, se
produciría un error, por lo tanto, lo recomendable es escribir la expresión como
n <- (2 <= 4) == (4 >= 6);

3.1.3. Operadores lógicos

Los operadores lógicos o booleanos realizan operaciones con operandos de tipo

lógico o booleano y tiene como resultado un dato también del mismo tipo. Los operadores
booleanos definidos se resumen en la Figura 3.6.

Figura 3.6
Operadores
lógicos.

En PSeInt los operadores lógicos son Y, O y NO. Para efectos de hacer las
expresiones más legibles, en este manual se usará AND, OR y NOT para
referirse a Y, O y NO correspondientemente.

Estos operadores son utilizados para soportar las operaciones básicas lógicas AND
(Y), OR (O) y NOT (NO) con datos verdaderos y falsos, de acuerdo con la Figura 3.7, Figura
3.8 y Figura 3.9.

Figura 3.7
Tabla de verdad
AND (Y).

16
Figura 3.8
Tabla de verdad
OR (O).

Figura 3.9
Tabla de verdad
NOT (NO).

Los operadores lógicos no están al mismo nivel de precedencia entre ellos. El

operador NOT (NO) es el de mayor precedencia, posteriormente se encuentra el AND (Y) y
por último el OR (O). En la Figura 3.10 se muestra el nivel de precedencia de los operadores
lógicos.

Figura 3.10
Precedencia de
operadores
lógicos.

En la Figura 3.11 se muestra el nivel de precedencia de los 3 tipos de operadores

(jerarquía de operadores).

Figura 3.11
Precedencia de
los tipos de
operadores:
aritméticos,
relacionales y
lógicos.

17
3.2. Ejemplos del uso de operadores

Los siguientes ejemplos evalúan expresiones que resaltan la operación que se realiza
de acuerdo con el orden de precedencia.

Ejemplo 1. Dada la expresión: r ← -6 * 7 + 2 ^ 4 / 2 - 5, obtén el valor que genera

como resultado.

Ejemplo 2. Dada la expresión: z ← 4 <= 2 == 8 > 10, obtén el valor que genera
como resultado.

Ejemplo 3. Dada la expresión: z ← 7 * (5 + 3) > 4 == 2 % 3 * 4 > 9 OR 2 != 8 + 5,

obtén el valor que genera como resultado.

18
3.3. Ejercicios de expresiones

3.1 Resuelva las siguientes expresiones.

a. x ← 4 * 2 / 5;
b. x ← 3 + 5 * (10 - (2 + 4));
c. x ← 3.5 + 6.09 - 14.0 / 40;

3.2 Resuelva las siguientes expresiones, considerando los valores

mostrados para cada una de las variables:

a. a ← 10, b ← 12, c← 13, d ← 1;

x ← ((a > b) OR (a < c)) AND ((a == c) OR (a >=b));
x ← ((a > b) OR (b < c)) OR ((a == b) OR (a >=c));

b. w ← 4, r← 3, u ← 5, z ← 2;
x ← (u + w) * z / w == u * r - 4 / 2 ;
x ← NOT(( u * u + w - u ) * z / w >= u * r + 12 / 3) ;

c. w ← 9, r ← 2, u ← 5, z ← 8;
x ← w >= r == u > 6 AND NOT(z != r AND z > 20);
x ← r <= w == (u*3) > 12 AND z * r * 2 != r AND z < 11;

19
 4. Introducción al desarrollo de
diagramas de flujo
Es una representación gráfica mediante símbolos especiales, de los
Diagrama de
pasos o procedimientos de manera secuencial y lógica que se deben
flujo
realizar para solucionar un problema.

Los diagramas de flujo son una herramienta que permite representar visualmente
qué operaciones se requieren y en qué secuencia se deben efectuar para solucionar un
problema dado. Desempeñan un papel vital en la programación de un problema, puesto
que facilitan la comprensión de problemas complejos y sobre todo aquellos en que sus
procesos son muy largos; generalmente, los diagramas de flujo se dibujan antes de
comenzar a programar el código fuente, que se ingresará posteriormente a la computadora.

De igual forma, los diagramas de flujo facilitan la comunicación entre los

programadores y los usuarios, además de que permiten de una manera más rápida detectar
los posibles errores de lógica que se presenten al implementar el algoritmo. En la siguiente
tabla se muestran algunos de los principales símbolos utilizados para construir un diagrama
de flujo.

Símbolo Significado

Inicio / Final
Se utiliza para indicar el inicio y el final de un
diagrama. Del inicio sólo puede salir una línea
de flujo y al final sólo una línea debe llegar.

Definición de datos
Representa el material o la información que
entra o sale (variables y constantes) del sistema.
Entrada Manual
Corresponde a la entrada de datos por teclado.
Indica que la computadora se queda a la espera
de que el usuario ingrese un dato que se
guardara en una variable o constante
Operación
Corresponde al procesamiento de información.
Indica cualquier operación o acción que se debe
realizar.

20
 Símbolo Significado

Decisión
Indica la comparación de información y
dependiendo del resultado lógico (falso
o verdadero) se tomará un camino del
diagrama u otro.

Decisión múltiple
Indica la comparación de información,
dependiendo del resultado o caso se
tomará solo un camino del diagrama.

Imprimir en pantalla
Se utiliza para representar la salida de
datos en pantalla.

Flujo de datos
Indica el sentido de la ejecución de las
operaciones

Tabla 4.1
Símbolos
utilizados en la
construcción de
diagramas de
flujo.

21
4.1. Ejemplos del uso de diagramas de flujo

Ejemplo 1. Mediante un diagrama de flujo, resuelva la suma de dos números.

Inicio del diagrama de flujo.

Se declaran las variables a utilizar.

Se imprime en pantalla el mensaje

para ingresar el primer número y
se lee la entrada manual.

Se imprime en pantalla el mensaje

para ingresar el segundo número y
se lee la entrada manual.

Se realiza la suma de los números.

Se imprime en pantalla el mensaje

del resultado y el valor de la suma.

Fin del diagrama de flujo.

22
 Ejemplo 2. Se desea encontrar la solución para determinar el volumen de un cubo
de dimensiones A, B y C, utilizando un diagrama de flujo.

C
B

Inicio del diagrama de flujo.

Se declaran las variables a utilizar.

Se imprime en pantalla el mensaje

para ingresar la dimensión A y se
lee la entrada manual.

Se imprime en pantalla el mensaje

para ingresar la dimensión B y se
lee la entrada manual.

Se imprime en pantalla el mensaje

para ingresar la dimensión C y se
lee la entrada manual.

Se realiza el cálculo del volumen.

Se imprime en pantalla el mensaje

del resultado y el valor del
volumen.

Fin del diagrama de flujo.

23
 Ejemplo 3. Se desea saber si una persona es mayor de edad. Cree el diagrama de
flujo correspondiente.

Inicio del diagrama de flujo.

Se declaran las
variables a
utilizar.

Se imprime en pantalla el
mensaje para ingresar la
edad y se lee la entrada. Si es verdadero se
imprime “Eres mayor
de edad”.

Si es falso se imprime Fin del diagrama de flujo.

“Aún eres menor de
edad”.

24
4.2. Ejercicios de diagramas de flujo

4.1. Resuelva los siguientes problemas realizando un diagrama de flujo.

a. Solicite un número y determina si es un número positivo o

negativo.
b. Solicite dos números al usuario para realizar una de las
siguientes operaciones (indicada por el usuario): Suma, Resta,
Multiplicación o División.
c. Solicite los datos necesarios para realizar el cálculo del
perímetro de un círculo.

25
 5. Estructuras Selectivas
Las estructuras selectivas sirven para representar la toma de decisiones. En este tipo
de estructura se evalúa una condición y, en función del resultado, se realiza la ejecución de
uno o varios bloques de código. Existen dos tipos básicos de estructuras condicionales:
simples y múltiples.

5.1. Estructuras Selectivas Simples

Las estructuras selectivas simples o condicionales están compuestas únicamente de

una sola condición. Si esta es verdadera, se ejecutará la instrucción o instrucciones que estén
definidas. Si la condición es falsa, no se realizará nada.

Sintaxis:

Si <expresion_logica> Entonces
// acciones_por_verdadero
FinSi

Existe una variante para la estructura, en la cual existen dos opciones posibles, pero
únicamente se realiza una de ellas. Si la condición evaluada es verdadera, se ejecutará la
instrucción o instrucciones para la condición verdadera y si la condición es falsa, se
ejecutarán las instrucciones para la condición falsa.

Sintaxis:

Si <expresion_logica> Entonces
// instrucciones_por_verdadero
SiNo
// instrucciones_por_falso
FinSi

5.1.1. Ejemplos del uso de estructuras selectivas simples

Ejemplo 1. Se necesita un sistema para un supermercado, el cual dará un 10% de

descuento a las personas que compren más de $1000 pesos. Se debe mostrar el total a pagar
con el descuento aplicado.

26
Proceso Supermercado
Definir total, subtotal, descuento Como Real;
Escribir "Introduce la cantidad gastada: ";
Leer subtotal;
Si subtotal > 1000 Entonces
descuento <- subtotal * 0.10;
total <- subtotal - descuento;
SiNo
total <- subtotal;
FinSi
Escribir "El total a pagar es: ", total;
FinProceso

27
 Ejemplo 2. Se requiere un sistema que reciba tres calificaciones parciales de un
alumno y posteriormente genere su promedio. Se debe tener en cuenta que, si el promedio
es menor a 8, se le indicará que está reprobado. En caso contrario, el mensaje será que está
aprobado.

Proceso PromedioAlumno
Definir promedio, cal1, cal2, cal3 Como Real;
Escribir “Dame la calificación del primer parcial: ”;
Leer cal1;
Escribir “Dame la calificación del segundo parcial: ”;
Leer cal2;
Escribir “Dame la calificación del tercer parcial: ”;
Leer cal3;
promedio <- (cal1 + cal2 + cal3) / 3;
Si promedio < 8 Entonces
Escribir “Estás reprobado”;
SiNo
Escribir “Estás aprobado”;
FinSi
FinProceso

28
5.2. Estructuras Selectivas Múltiples

Las estructuras selectivas múltiples son aquellas en las que únicamente se permite
elegir una de n opciones posibles. Al seleccionar una opción, se ejecutarán las instrucciones
que se encuentren dentro de ella.

Sintaxis:

Segun <variable_numerica> Hacer

<opcion_1>:
// secuencia_de_acciones_1
<opcion_2>:
// secuencia_de_acciones_2
<opcion_3>:
// secuencia_de_acciones_3
De Otro Modo:
// secuencia_de_acciones_dom
FinSegun

5.2.1. Ejemplos del uso de estructuras selectivas múltiples

Ejemplo 1. Se necesita un sistema que tenga tres opciones. Si se selecciona la primera,

se calcula el perímetro de un cuadrado. Si la opción es la segunda, se calcula el perímetro
de un triángulo equilátero. Cuando se elija la tercera, se calculará el perímetro de un círculo.
Adicionalmente, el sistema debe mandar un mensaje de error en caso de presionar cualquier
otro número.

29
Proceso MenuPerimetros
Definir perimetro, lado Como Real;
Definir opcion Como Entero;
Escribir "Menú de perímetros, selecciona una opción:";
Escribir "1.- Cuadrado, 2.- Triángulo, 3.- Círculo";
Leer opcion;
Segun opcion Hacer
1:
Escribir "Dame el valor de un lado del cuadrado: ";
Leer lado;
perimetro <- lado * 4;
2:
Escribir "Dame el valor de un lado del triángulo: ";
Leer lado;
perimetro <- lado * 3;
3:
Escribir "Dame el valor del diámetro del círculo: ";
Leer lado;
perimetro <- lado * (2* 3.1416);
De Otro Modo:
Escribir "Opción no válida";
FinSegun
Escribir "El perímetro es: ", perimetro;
FinProceso

30
31
 Ejemplo 2. Una tienda de videojuegos realiza una tómbola solo con aquellos clientes
que realizaron una compra superior a $2000 pesos. De esta tómbola se debe obtener una
bolita que tiene un número grabado en ella. Dependiendo del número que se tome, los
premios otorgados son:

No. Bolita Premio

1 Gorra de Mario Bros
2 Termo de Halo 3
3 Juego de FIFA 20
4 Funko pop: Groot

Proceso TiendaVideoJuegos
Definir compra Como Real;
Definir noBolita Como Entero;
Escribir "Ingresa tu compra ";
Leer compra;
Si compra > 2000 Entonces
Escribir "Ingresa el número de tu bolita";
Leer noBolita;
Segun noBolita Hacer
1:
Escribir "Ganaste: Gorra de Mario Bros";
2:
Escribir "Ganaste: Termo de Halo 3";
3:
Escribir "Ganaste: Juego de FIFA 20";
4:
Escribir "Ganaste: Funko pop : Groot";
De Otro Modo:
Escribir "Opción no valida";
FinSegun
SiNo
Escribir "Lo siento no alcanza tu compra";
FinSi
FinProceso

32
33
5.3. Ejercicios de estructuras selectivas

5.1 Una empresa automotriz necesita un sistema que ayude al cliente a

seleccionar un tipo de vehículo: auto, camioneta o vagoneta. La
opción se deberá seleccionar de un menú. Una vez seleccionado el
tipo de auto, se presentará un nuevo menú donde se solicitará el color
que se desee: negro, blanco, verde, rojo, azul. Al final, se desplegará
el siguiente mensaje “Usted ha seleccionado el tipo de carro
<tipo_carro> de color <color_carro>”.
5.2 Se desea saber si un código, encontrado en la caja de cereal, es
acreedor a una consola XBOX ONE de premio. Para ello, el código
deberá ser “A1B2C3Z”. Muestre los mensajes pertinentes si es que el
usuario ganó o no el premio.
5.3 Se necesita un sistema para clasificar a las personas según su edad.
Las clasificaciones son: niño 3 a 12 años, adolescente 13 a 17 años,
adulto 18 a 49 y adulto mayor de 50 hasta 120. El sistema deberá
arrojar un mensaje indicando a qué categoría pertenece.
5.4 Se requiere un sistema que permita ingresar dos cantidades y
seleccione cuál es mayor y cuál es menor.
5.5 La tienda de videojuegos “Retro” requiere un sistema para la
realización de una tómbola para aquellos clientes que hayan realizado
una compra de $ 2,000 pesos o más, como también considerar el
género del cliente, ya que los hombres y mujeres tienen su propia
canasta para elegir su premio. Los premios se dan según la siguiente
tabla:

No. Bolita Premio (Hombres)

1 Super Mario World
2 Mario Kart
3 Super Street Figther 2

No. Bolita Premio (Mujeres)

1 Tetris Attack
2 Super Mario World 2: Yoshi’s Island
3 Megaman X

34
 6. Estructura repetitiva Mientras
La estructura repetitiva Mientras (o hacer mientras) es una estructura que indica que
un conjunto de instrucciones se debe repetir mientras que la expresión revisada sea
verdadera. Este tipo de estructura necesita evaluar una expresión booleana, mientras ésta
sea cierta, se repetirá el bloque de código que tiene de manera interna. Debido a su
estructura, es muy posible que nunca se ejecute el ciclo debido a varias circunstancias:

• La condición que se evalúa contiene valores que no fueron inicializados.

• Los valores evaluados en la condición resultan no tener un resultado
verdadero.

Se puede representar la estructura tanto en pseudocódigo como en diagrama de

flujo de la siguiente manera:

Sintaxis:

Mientras <condición> Hacer

//Bloque de código a ejecutar
FinMientras

6.1. Ejemplos del uso de la estructura repetitiva

Ejemplo 1. Realice la sumatoria de calificaciones de un alumno para obtener su

promedio de la materia de matemáticas. La materia tiene un total de 5 parciales.

Proceso CalcularPromedio
Definir promedio, calificacion Como Real;
Definir continuar Como Entero;
promedio <- 0;
continuar <- 1;
Mientras contador <= 5 Hacer
Escribir "Introduce calificación: ";
Leer calificacion;
promedio <- promedio + calificacion;
continuar <- continuar + 1;
FinMientras
Escribir "Tu promedio es: ", (promedio/5);
FinProceso

35
36
 Ejemplo 2. Realice un programa que solicite nombres de personas hasta que se
ingrese el nombre Bruce Willis. Cuando termine la ejecución del programa se mostrará un
listado con 3 películas del actor.

Proceso NombreActor
Definir nombre Como Caracter;
Mientras nombre <> "Bruce Willis" Hacer
Escribir "Ingresa un nombre";
Leer nombre;
FinMientras
Escribir "Armageddon, Duro de matar, Sin City";
FinProceso

37
6.2. Ejercicios

6.1 Realice un programa que calcule el factorial de un número introducido

por el usuario.
6.2 Karina necesita ahorrar dinero para ir al concierto de Luis Miguel, por
lo que decide ahorrar dinero hasta que tenga el suficiente para poder
asistir. El boleto cuesta 5000 pesos; el programa solicitará el dinero que
ahorrará Karina y dejará de hacerlo hasta juntar la cantidad necesaria.
Se debe mostrar un mensaje que haga saber a Karina que ha ahorrado
el dinero suficiente.
6.3 Realice un programa que calcule el promedio del cuatrimestre de
Joaquín. El estudiante tiene 5 materias y cada materia tiene 5 parciales.
Solicitar al inicio el nombre de las materias. Al finalizar el programa, se
mostrará el nombre de cada materia, su promedio y el promedio del
cuatrimestre.

38
 7. Ejercicios del curso
E.1 Realice un pseudocódigo y diagrama de flujo para leer las
calificaciones de 30 alumnos y determine el número de aprobados y
reprobados, sabiendo que la calificación mínima aprobatoria es de
80. Realice el pseudocódigo y diagrama de flujo correspondientes al
algoritmo.
E.2 Realice el diagrama de flujo y pseudocódigo para representar el
algoritmo encargado de realizar el corte de caja en una tienda
departamental, donde se conoce el número de billetes (20, 50, 100,
200, 500 y 1000) y monedas (1, 2, 5, 10).
E.3 Los directivos de una primaria requieren determinar cuál es la edad
promedio de cada uno de los 10 salones (donde cada salón contiene
20 estudiantes) y de toda la escuela. Realice un algoritmo que
determine estos promedios y represente la solución mediante
pseudocódigo y un diagrama de flujo.
E.4 Realice un algoritmo que determine el sueldo semanal de 150
trabajadores de una empresa privada, considerando que se les
descuenta 5% de su sueldo si ganan entre 0 y 150 pesos. Se les
descuenta 7% si ganan más de 150 pero menos de 300, y 9% si ganan
más de 300 pero menos de 450. Los datos son horas trabajadas,
sueldo por hora y nombre de cada trabajador. Represéntelo mediante
pseudocódigo y un diagrama de flujo.
E.5 El gerente de una compañía automotriz desea determinar el impuesto
que va a pagar por cada uno de los 100 automóviles que posee en su
resguardo, además del total que va a pagar por cada categoría y por
todos los vehículos, basándose en la siguiente clasificación:

• Los vehículos con clave 1 pagan 10% de su valor.

• Los vehículos con clave 2 pagan 7% de su valor.
• Los vehículos con clave 3 pagan 5% de su valor.

Realice un algoritmo para obtener la información y represéntelo

mediante pseudocódigo y un diagrama de flujo. Los datos son la clave
y costo de cada vehículo.

39
 Bibliografía
Joyanes Aguilar, L. (2008). Fundamentos de programación: algoritmos, estructura de datos y
objetos. Madrid: McGrawHill.
López García, J. (2009). Algoritmos y programación. eduteka.org.

40