Algoritmos i

ESCUELA DE CIENCIAS BÁSICAS E INGENIERÍA
ASIGNATURA: Algoritmos I

CORPORACIÓN UNIVERSITARIA REMINGTON
DIRECCIÓN PEDAGÓGICA

Este material es propiedad de la Corporación Universitaria Remington (CUR), para los estudiantes de la CUR
en todo el país.

2011

Corporación Universitaria Remington – Dirección Pedagógica
Algoritmos I Pág. 5

CRÉDITOS

El módulo de estudio de la asignatura Algoritmos I es propiedad de la Corporación Universitaria Remington. Las
imágenes fueron tomadas de diferentes fuentes que se relacionan en los derechos de autor y las citas en la bibliografía.
El contenido del módulo está protegido por las leyes de derechos de autor que rigen al país.

Este material tiene fines educativos y no puede usarse con propósitos económicos o comerciales.

AUTOR
José Antonio Polo
Ingeniero de sistemas de la Universidad de Antioquia Especialista en finanzas de la Corporación Universitaria Remington
Participación del tercer Congreso Colombiano de Computación – 3CCC de la universidad EAFIT Participación del primer
simposio en Inteligencia Artificial de la Corporación Universitaria Remington Participación del IV Congreso Internacional
de Software Libre GNU/Linux, Universidad de Manizales Participación del 5º Congreso Nacional de Redes y Telemática,
Redes de Servicios Móviles Integrados, Centro de Construcción de Conocimiento Evento CCC Docente de cátedra del
politécnico Jaime Isaza Cadavid Docente de cátedra del Tecnológico de Antioquia Participación del proyecto de la
articulación de la media técnica del Tecnológico de Antioquia Docente de la Corporación Universitaria Remington
barra5111@yahoo.es

Nota: el autor certificó (de manera verbal o escrita) No haber incurrido en fraude científico, plagio o vicios de autoría; en
caso contrario eximió de toda responsabilidad a la Corporación Universitaria Remington, y se declaró como el único
responsable.

RESPONSABLES
Dr. Mauricio Sepúlveda
Director de la Escuela Ciencias Básicas e Ingeniería
Director Pedagógico
Octavio Toro Chica
dirpedagogica.director@remington.edu.co
Coordinadora de Medios y Mediaciones
Angélica Ricaurte Avendaño
mediaciones.coordinador01@remington.edu.co

GRUPO DE APOYO
Personal de la Unidad de Medios y Mediaciones
EDICIÓN Y MONTAJE
Primera versión. Febrero de 2011.
Derechos Reservados

Esta obra es publicada bajo la licencia CreativeCommons. Reconocimiento-No Comercial-Compartir Igual 2.5 Colombia.

Corporación Universitaria Remington - Calle 51 51-27 Conmutador 5111000 Ext. 2701 Fax: 5137892. Edificio Remington
Página Web: www.remington.edu.co - Medellín - Colombia


TABLA DE CONTENIDO

1. MAPA DE LA ASIGNATURA ............................................................................................. 7
2. EL COMPUTADOR: SUS COMPONENTES, PROBLEMAS Y SOLUCIONES .............................. 8
2.1. Esquema General de un Computador ............................................................................... 10
2.2. Problemas, Soluciones y Programas.................................................................................. 11
2.2.1. Elementos para la Construcción de un Algoritmo ............................................................. 13
2.3. Algoritmos, Representación y Estructuras Básicas ............................................................ 14
2.3.1. Forma General de un Algoritmo....................................................................................... 15
3. OPERADORES Y EXPRESIONES ...................................................................................... 19
3.1. Operadores ...................................................................................................................... 20
3.1.1. Operadores Aritméticos................................................................................................... 20
3.2. Expresiones Aritméticas, Relacionales y Booleanas ........................................................... 24
3.2.1. Conversión de una Expresión Algebraica a Expresión Lineal de Computador .................... 26
3.2.2. Conversión de una Expresión Lineal de Computador a Expresión Algebraica .................... 27
4. ESTRUCTURAS DE DECISIÓN ......................................................................................... 33
4.1. Estructuras de Decisión Simple y Compuestas .................................................................. 34
4.2. Estructura Caso o Selector Múltiple .................................................................................. 43
5. ESTRUCTURAS REPETITIVAS ......................................................................................... 49
5.1. Estructuras Repetitivas ..................................................................................................... 50
5.1.1. Funcionamiento y Componentes de las Diferentes Estructuras Repetitivas ...................... 50
5.1.2. Ciclo Automático o Ciclo Para .......................................................................................... 51
5.1.3. Esquema Cuantitativo...................................................................................................... 59
5.2. Estructuras Repetitivas Anidadas ...................................................................................... 70
5.3. Estructura de Rompimiento de Control............................................................................. 76
6. PISTAS DE APRENDIZAJE .............................................................................................. 81
7. GLOSARIO ................................................................................................................... 83
8. REFERENCIAS BIBLIOGRÁFICAS..................................................................................... 84



1. MAPA DE LA ASIGNATURA

ALGORITMOS I

PROPÓSITO GENERAL DEL MÓDULO
Proporcionar a los estudiantes las herramientas básicas para la solución de problemas mediante un proceso de
secuencias lógicas.

OBJETIVO GENERAL
Dar al estudiante las herramientas básicas para el desarrollo de algoritmos aplicables en cualquier disciplina, que
permitan la generación de una capacidad analítica y creativa en la solución e implementación de problemas
propuestos.

OBJETIVOS ESPECÍFICOS
Presentar las herramientas básicas para la construcción de soluciones utilizando el computador. Además la
identificación de los pasos necesarios que se necesitan para la construcción de un buen algoritmo, y la
aplicación de las instrucciones de lectura y escritura
Capacitar al estudiante para la manipulación de los diferentes operadores aritméticos y lógicos, a nivel
relacional y a nivel lógico.
Reconocer como se maneja una estructura de decisión identificando cuando y como se utiliza una pregunta.
Además la aplicación de la estructura caso en problemas complejos.
Reconocer en un problema cuando se utiliza un ciclo para, un ciclo mientras que, y la aplicación de los
conceptos de contadores, acumuladores, promedios y porcentajes, además la manipulación del concepto de
ciclos anidados y rompimiento de control.

UNIDAD 1 UNIDAD 2 UNIDAD 3 UNIDAD 4

El COMPUTADOR: EXPRESIONES ESTRUCTURAS DE ESTRUCTURAS
SUS COMPONENTES, Habilidad para DECISIÓN REPETITIVAS
PROBLEMAS Y diferenciar Capacidad para Habilidad para
SOLUCIONES expresiones comprender el manejar procesos
Capacidad para aritméticas de concepto de repetitivos en
identificar los expresiones lógicas estructuras de formato cualitativo y
componentes de un relacionales y decisión simple y cuantitativo,
computador, y la booleanas compuesta, así como manejar
forma de solucionar el de selector contadores,
problemas que múltiple. acumuladores,
requieran el uso de promedios y
éstos.
porcentajes.



2. EL COMPUTADOR: SUS COMPONENTES, PROBLEMAS Y SOLUCIONES

http://www.youtube.com/watch?v=FasDEqui4FU
http://www.youtube.com/watch?v=YnMMy8Nnj_I&feature=related

OBJETIVO GENERAL

Presentar las herramientas básicas para la construcción de soluciones utilizando el
computador. Además la identificación de los pasos necesarios para la construcción de un
buen algoritmo, y la aplicación de las instrucciones de lectura y escritura


Conocer el esquema general de una computadora y la relación entre los diferentes
componentes.
Analizar el proceso global de un problema y las diferentes etapas en las que este
transcurre.
Identificar los diferentes pasos para la elaboración de un buen algoritmo, así como las
diferentes estructuras para su construcción.



Prueba Inicial

1. Realizar el siguiente sudoku:

Para resolver un sudoku se tiene que completar todas las casillas existentes con los números del 1
al 9, teniendo en cuenta que no pueden coincidir dos números iguales en la misma fila, en la
misma columna o en el mismo cuadro de 3x3.

2 Un hombre tiene 4 baldes: A, B, C y D; todos ellos de diferente capacidad como muestra la
figura:

El balde con capacidad de 24 Lts. está lleno de leche, la cual desea repartir en cantidades iguales a
sus tres hijos. Los baldes no tienen marcas adicionales que puedan ayudar con las medidas; las



únicas dos formas de trasladar la leche de un recipiente a otro es llenando completamente el
balde al que se desea pasar la leche o vaciando totalmente el balde del que se sacará la leche.
Escriba paso a paso las instrucciones que ejecutará para repartir la leche en tres cantidades
iguales.

Ejemplo:
D C (del recipiente D paso al C)
C B (del recipiente C paso al B)

2.1. Esquema General de un Computador

Todas las partes de un sistema de computación operan bajo el control de una de ellas: La unidad
de control. Veámoslo en la siguiente figura:

Teclado y Pantalla Mouse

RAM
Unidad aritmética y
lógica
BUS Memoria
auxiliar
Registros de trabajo DE
Puertos
CONTROL
seriales
Control interno
Puertos
CPU USB

Veamos cada uno de los componentes de un computador:
(Haga clic en el término para obtener información)
CPU (Central Processing Unit).
Unidad aritmética y lógica.
Registros de trabajo.
Control interno.
Bus de control.
Memoria Principal (RAM).
Memoria auxiliar.


Puertos seriales.
Puertos USB.

EJERCICIOS

1. Cuál es la función de la memoria RAM?
2. Qué diferencia hay entre memoria principal y memoria auxiliar en un computador?
3. Describa las funciones de cada uno de los componentes de la CPU de un computador.

2.2. Problemas, Soluciones y Programas

Cuando se va a desarrollar una aplicación usando el computador como herramienta se tiene
establecida cierta metodología para garantizar que la aplicación desarrollada sea de buena calidad.
Los pasos que establece dicha metodología son:

1. Análisis del problema.
2. Diseño de la solución.
3. Implementación de la solución planteada.
3.1. Elaboración de algoritmos.
3.1.1. Análisis del problema.
3.1.2. Diseño de la solución.
3.1.3. Construcción del algoritmo.
3.1.4. Prueba de escritorio.
3.2. Codificación en algún lenguaje de programación.
3.3. Compilación.
3.4. Pruebas del algoritmo.
4. Pruebas del sistema.
5. Puesta en marcha.

Nuestro curso se centra en lo correspondiente al numeral 3.1.

Los pasos que se siguen en la construcción de un algoritmo, como ya habíamos mencionado, son:

1. Análisis del problema.
2. Diseño de la solución.
3. Construcción del algoritmo.
4. Prueba de escritorio.



El análisis del problema consiste en determinar exactamente cuáles son los datos de entrada que
se requieren, cuál es la información que se desea producir y cuál es el proceso que se debe
efectuar sobre los datos de entrada para producir la información requerida. Se debe indagar por
todas las situaciones especiales que se puedan presentar para tenerlas en cuenta en el diseño.

Con base en el análisis se elabora el diseño del algoritmo: se asignan nombres a las variables, se
define el tipo de cada una de ellas, se definen las operaciones y subprocesos que hay que efectuar
y el método para resolver cada uno de ellos.

Los elementos para la construcción de un algoritmo son: datos, estructuras e instrucciones.

La prueba de escritorio consiste en asumir la posición del computador y ejecutar el algoritmo que
se ha elaborado para ver cómo es su funcionamiento. Esta parte es muy importante puesto que
permite detectar errores de lógica sin haber hecho aún uso del computador. Aunque no garantiza
que el algoritmo está bueno 100%, ayuda mucho en la elaboración de algoritmos correctos.

Habiendo superado los pasos anteriores, se elige un lenguaje de programación (algunos de los más
utilizados en la actualidad son: Java, C, C++, PHP, entre otros), se codifica el algoritmo en dicho
lenguaje y se pone en ejecución en el computador disponible.

PASOS PARA LA SOLUCIÓN DE UN PROBLEMA

Veamos la forma gráfica para representar un problema en la siguiente figura:



En la primera sección nos concentramos en la definición del problema, en la segunda, en el
proceso de construcción de la solución y, en la tercera, en el contenido y estructura de la solución
misma.

Ahora veamos los pasos que debemos seguir para solucionar el problema en un computador:

Paso 1: Una persona u organización, denominada el cliente, tiene un problema y necesita
la construcción de un programa para resolverlo. Para esto contacta una empresa de
desarrollo de software que pone a su disposición un programador.
Paso 2: El programador sigue un conjunto de etapas, denominadas el proceso, para
entender el problema del cliente y construir de manera organizada una solución de buena
calidad, de la cual formará parte un programa.
Paso 3: El programador instala el programa que resuelve el problema en un computador y
deja que el usuario lo utilice para resolver el problema. Fíjese que no es necesario que el
cliente y el usuario sean la misma persona. Piense por ejemplo que el cliente puede ser el
gerente de producción de una fábrica y, el usuario, un operario de la misma.

2.2.1. Elementos para la Construcción de un Algoritmo

Los elementos con los cuales se construye un algoritmo son las estructuras lógicas y los datos.
Miremos los datos.

Para efectos de representación de datos en un computador, estos se clasifican en numéricos y no
numéricos, y los datos numéricos se clasifican en enteros y reales.

En términos de computación se denomina tipo, y se habla entonces de datos de tipo entero, de
tipo real, de tipo no numérico, etc.

Cuando se trabajan datos numéricos en un computador es muy importante considerar si el tipo es
entero o real, puesto que, dependiendo de ello, los resultados que se obtienen al efectuar
operaciones aritméticas pueden variar sustancialmente.

2.2.1.1 Representación de Datos en un Computador
(Haga clic en el término para obtener información)

La unidad básica de representación de datos es el bit.
La siguiente unidad se denomina byte.
La siguiente unidad de representación es el campo.



La siguiente unidad de representación es el registro.
La siguiente unidad de representación es el archivo.
La siguiente unidad de representación es la base de datos.

EJERCICIOS

1. Cuántos bits se requiere para representar la palabra ALGORITMOS?
2. Describa los conceptos de bit, byte, campo, registro, archivo y base de datos.
3. Cuáles son los pasos que se siguen para elaborar soluciones utilizando el computador
como herramienta?

2.3. Algoritmos, Representación y Estructuras Básicas

Las estructuras lógicas para la construcción de algoritmos son:

1. Estructura secuencia
2. Estructura decisión
3. Estructura ciclo

La estructura básica en la construcción de un algoritmo es la estructura de secuencia. Esta
estructura consiste en que las instrucciones se ejecutan exactamente en el orden en que han sido
escritas: primero se ejecuta la primera instrucción, luego la segunda instrucción, luego la tercera
instrucción y por último la última instrucción.

Nota: El orden en el cual se escriben las instrucciones es fundamental para el correcto
funcionamiento de un algoritmo.

Cada estructura consta de un conjunto de instrucciones.

Las instrucciones correspondientes a la estructura secuencia son:

1. Instrucciones de lectura.
2. Instrucciones de escritura.
3. Instrucciones de asignación.
4. Las instrucciones correspondientes a la estructura decisión.
5. Las instrucciones correspondientes a la estructura ciclo.



Las instrucciones correspondientes a la estructura decisión son:

1. La instrucción SI y su componente opcional SINO.
2. La instrucción CASOS.

Las instrucciones correspondientes a la estructura ciclo son:

1. La instrucción MIENTRAS QUE.
2. La instrucción PARA.
3. La instrucción HAGA MIENTRAS QUE.

2.3.1. Forma General de un Algoritmo

La forma general de nuestros algoritmos será:

1. ALGORITMO NOMBRE_DEL_ALGORITMO
2. DEFINICIÓN DE VARIABLES
3. INICIO
4. INSTRUCCIONES DEL ALGORITMO
5. FININICIO
6. FINALGORITMO

INSTRUCCIÓN DE LECTURA

Para que el computador pueda procesar datos, éstos deben estar en la memoria principal (RAM).
La instrucción de lectura consiste en llevar los datos con los cuales se desea trabajar, desde un
medio externo hacia la memoria principal.

Los medios externos en los cuales pueden residir los datos son: disco duro, discos removibles, CD,
dispositivos USB, etc.; los datos también pueden entrarse directamente a través del teclado.

La forma general de la instrucción de lectura es:
LEA (lista de variables, separadas por comas)



INSTRUCCIÓN DE IMPRESIÓN

La instrucción de impresión consiste en llevar los datos desde la memoria hacia un medio externo,
el cual puede ser disco duro, cinta, impresora, etc.

La forma general de la instrucción de impresión es:

IMPRIMA (lista de variables y/o mensajes, separados por comas)

Los mensajes son para instruir al usuario acerca de los datos que se le están presentando. Si el
dato que se imprime es el nombre de una persona, es conveniente que dicho dato esté precedido
por un mensaje que diga: nombre. Si el dato que se está presentando es una edad, es conveniente
que dicho dato está precedido por un mensaje que diga: edad. Y así sucesivamente.

Cuando vayamos a escribir un mensaje en una instrucción de impresión, dicho, mensaje lo
escribiremos encerrado entre comillas.

Vamos a hacer nuestro primer algoritmo utilizando solo las instrucciones de lectura y de escritura.

1. ALGORITMO PRIMERO
2. VARIABLES: NOM (CARACTER)
3. TEL (NUMÉRICO)
4. INICIO
5. IMPRIMA (“Este es mi primer programa”)
6. IMPRIMA (“Escriba el nombre”)
7. LEA (NOM)
8. IMPRIMA (“Escriba el teléfono”)
9. LEA (TEL)
10. IMPRIMA (“Su nombre es:”, NOM, “y su teléfono es:”, TEL)
11. IMPRIMA (“Esto es genial”)
12. FININICIO
13. FIN

En la instrucción 1, estamos definiendo el nombre del algoritmo: lo llamamos PRIMERO.
En la instrucción 2, estamos definiendo las variables que vamos a utilizar en nuestro
algoritmo. Ponemos el título VARIABLES y definimos la variable NOM, que podrá
almacenar datos alfanuméricos y, en la instrucción 3, definimos la variable TEL, que podrá
almacenar datos numéricos.
En la instrucción 4, ponemos nuestra palabra clave INICIO, la cual indica que a partir de ahí
están las instrucciones de nuestro algoritmo.
En la instrucción 5, ponemos el título de nuestro algoritmo, el cual saldrá en pantalla.


En la instrucción 6, ponemos nuestra instrucción de impresión la cual imprime el mensaje
“Escriba el nombre” instruyendo al usuario acerca de la información que debe introducir.
En la instrucción 7, ponemos nuestra instrucción de lectura, en la cual el dato escrito por el
usuario se almacenarán en la posición de memoria que el computador identificará con el
nombre NOM.
En la instrucción 8, ponemos nuestra instrucción de impresión la cual imprime el mensaje
“Escriba el teléfono” instruyendo al usuario acerca de la información que debe introducir.
En la instrucción 9, ponemos nuestra instrucción de lectura, en la cual el dato escrito por el
usuario se almacenarán en la posición de memoria que el computador identificará con el
nombre TEL.
En la instrucción 10, ponemos la instrucción de impresión con la cual se imprimen los
datos escritos por el usuario, cada uno con su respectivo título.
En la introducción 11, imprimimos un mensaje para luego finalizar nuestro algoritmo.
La instrucción 12, es nuestra palabra clave FININICIO, que cierra el inicio de las
instrucciones del algoritmo y, en la instrucción 13, ponemos el fin del algoritmo.

INSTRUCCIÓN DE ASIGNACIÓN

La instrucción de asignación consiste en llevar algún dato a una posición de memoria, la cual está
identificada con el nombre de una variable.

La forma general de una instrucción de asignación es:
(Haga clic en VARIABLE para obtener información sobre los tipos de variables)

Constante numérica entera
Constante numérica real
VARIABLE
Variable
Mensaje
Expresión
Por ejemplo:

1. a = 425
2. b = 3.46
3. c = “Bienvenido”
4. d=a
5. e=a+b*d

En los ejemplos 1 y 2, a las variables a y b les estamos asignando una constante numérica:
entera en el primer ejemplo, real en el segundo.
En el ejemplo 3, a la variable c le estamos asignando un mensaje.
En el ejemplo 4, a la variable d le estamos asignando el contenido de otra variable.


En el ejemplo 5, a la variable e le estamos asignando el resultado de evaluar una
expresión.

EJERCICIOS

1. Elaborar un algoritmo que imprima el siguiente mensaje: “Que buenos son los algoritmos
y la computación”.
2. Cuáles son las instrucciones correspondientes a la estructura ciclo?
3. Cómo se diferencia la escritura de mensajes de la escritura de datos de una instrucción de
lectura?
4. Detecte y describa los errores que hay en el siguiente algoritmo:
1. ALGORITMO ERRORES
2. VARIALBES: X, Y (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Digite los datos para X y Y:”)
5. IMPRIMA (dato X:, “X”, dato Y:, “Y”)
6. LEA (X, Y)
7. IMPRIMA (Hasta pronto)
8. FININICIO
9. FIN



3. OPERADORES Y EXPRESIONES

http://www.youtube.com/watch?v=fpUAP3lMJUs&feature=related
http://www.youtube.com/watch?v=nS_AiOEWa2I

OBJETIVO GENERAL

Capacitar al estudiante para manipular los diferentes operadores aritméticos y lógicos, a nivel
relacional y a nivel lógico.


Conocer los diferentes tipos de operadores utilizados a nivel de programación, y las
diferentes operaciones entre ellos; además de las prioridades de cada uno de ellos.
Identificar las expresiones aritméticas, relacionales y booleanas, y sus resultados lógicos.



Prueba Inicial

1. ¿En qué consiste una instrucción de asignación?
2. ¿Cómo se evalúa una expresión aritmética?
3. ¿En qué consiste la asociatividad de un operador?
4. ¿Para qué se utilizan los paréntesis en expresiones de computador?
5. ¿Qué es una expresión relacional?
6. ¿Cuáles son los operadores relacionales?
7. ¿Qué es una expresión lógica?
8. ¿Cuáles son los operadores lógicos?

OPERADORES Y EXPRESIONES

Una expresión es una sucesión de operandos y operadores, la cual puede ser de tres clases:

1. Expresión aritmética.
2. Expresión relacional.
3. Expresión lógica.

3.1. Operadores
Los operadores son símbolos con los que se ordena la ejecución de ciertas operaciones, se dividen
en dos clases; Aritméticos y Lógicos.

3.1.1. Operadores Aritméticos
Sirven para efectuar cálculos aritméticos. Ellos son:

Símbolo Operación
+ Suma
- Resta
* Multiplicación
/ (slash) División
% Módulo (Toma el residuo de una división)
**, ^ Ambos potenciación y radicación (Se debe expresar la raíz como una
potencia fraccionaria)



1Prioridades de los operadores:

Símbolo Prioridad
+, - Tienen la misma prioridad
*, /, % Tienen la misma prioridad, pero mayor que la suma y la resta
**, ^ Tienen mayor prioridad que todos los anteriores

Si dos o más operadores consecutivos tienen la misma prioridad, las operaciones se ejecutarán en
las instrucciones de izquierda a derecha.

Ejemplo: Si se tiene la expresión:
A ** 2/5 * B -5 y los valores almacenados en A y B son 5 y 20 respectivamente, la evaluación de
acuerdo al orden de prioridad será:
5 ** 2 = 25
25 / 5 * 20 = 100
100 – 5 = 95

Si se tiene una expresión con dos o más potencias consecutivas estas se realizan de derecha a
izquierda. Por ejemplo:
11 % 3 + 10 / 5 * 2 ^ 2 ^ 3
De acuerdo al orden de prioridad, el resultado sería:
2^3=8
2 ^ 8 = 256
Habiendo resuelto las potencias tendremos:
11 % 3 + 10 / 5 * 256
2 + 512 = 214

Si se requiere que una o más operaciones se realicen primero que otras, entonces estas se
encierran entre paréntesis y dentro de estos se conserva la jerarquía de los operadores.

Ejemplo:

La operación: debe representarse como: (a + b) / (c + a) + 20

1
Oviedo Efraín


La operación: se representa como: a/b - c/(a^(d + e)*20)

Operadores Lógicos

Sirven para determinar el valor de verdad de proposiciones Lógicas simples o compuestas. Su
aplicación se encuentra en los procesos de comparación los cuales sirven para tomar decisiones.
Se dividen en: Lógicos relacionales y lógicos booleanos.

Operadores Lógicos Relacionales

Sirven para hallar el valor de verdad de una proposición Lógica simple. Se define una proposición
Lógica simple (PLS) como la comparación entre contenido de un campo variable y un valor
constante o la comparación entre los contenidos de dos campos variables. Ellos son:

Símbolo Función
== Igual
<>, != Diferente
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que

Nota aclaratoria: Estos operadores pueden variar dependiendo el Lenguaje de Programación que
se utilice. Para los procesos de comparación es bueno anotar que sólo son válidos si los campos
variables a comparar han sido previamente asignados.

Ejemplos:

CARLOS >= 6
Esto es una PLS, en la cual se compara el contenido del campo variable CARLOS con el valor
numérico 6, esta puede ser verdadera o falsa dependiendo del contenido del campo CARLOS.
Otros ejemplos:
Nombre <> "*"
B == C
SALARIO <= 98700
EDAD > 100.



Operadores Lógicos Booleanos

Sirven para hallar el valor de verdad de una proposición lógica compuesta (PLC), entendiéndola
como la conexión de dos o más PLS. En términos de Lógica matemática son los llamados
conectivos lógicos. Ellos son:

Símbolos Símbolos Nombre Valor de Verdad o Definición
Matemáticos utilizados en
programación
^ && Conjunción, se lee Se define como verdadera cuando
AND Y las PLS que conectan son todas
verdaderas
V || Disyunción, se lee Se define como falsa cuando las
OR O PLS que conectan son todas falsas.

~ ! Negación, se lee No es un conectivo Iógico. Su
NOT NO función es alterar el valor de
verdad de las proposiciones
lógicas.

Prioridad de los operadores lógicos booleanos

1. Negación !
2. Conjunción &&
3. Disyunción ||

Las variables lógicas son variables que sólo pueden tomar dos valores: verdadero o falso.

En general, una variable lógica, en el ámbito de los computadores, es una variable de un solo bit,
el cual puede ser 0 ó 1. Por convención se ha adoptado que el 0 representa falso y el 1 verdadero.

Se establece por convención que para formar una PLC, las PLS deben estar encerradas entre
paréntesis y para hallar el valor de verdad de una PLC primero se evalúa el valor de verdad de cada
PLS por separado y el valor de verdad de la PLC estará en función del operador lógico booleano
usado para la conexión.



Ejemplo:
Sean: A = 1; B = 3; C = 0. Hallar el valor de verdad de la siguiente PLC

(A < B) ^ (B < C)

V F Se halló el valor de verdad de cada PLS
V ^ F Se aplicó la definición del operador lógico booleano conjunción

F La PLC es falsa

EJERCICIOS

Dada la siguiente definición de variables con su respectivo tipo y contenido
Numéricos enteros Numéricos reales
a=4 y = 3.5
b=7 x = 2.0
c=3 z = 5.0
d=2 w = 1.5
Determine el resultado de evaluar cada una de las siguientes expresiones:
a*b/2+1
c/y^2
a / ((b + c) / (d + 1) * (a + b) – b) ^ b ^ a + z
z / x + b * w * (c – b) / a

3.2. Expresiones Aritméticas, Relacionales y Booleanas

Cuando se trata de evaluar expresiones lógicas primero se evalúan las expresiones aritméticas,
luego las expresiones relacionales y por último las expresiones lógicas, las cuales también tienen
cierta prioridad en el momento de efectuar la evaluación, como mencionamos anteriormente.

Ejemplos:
1. a && b
2. a > b || c < d
3. radio >= a ^ 2 || (b – c) == (3.1 + c) && (c + d) * 2 <=1



En el ejemplo 1, si a y b tienen estado de verdad, el resultado de evaluar la expresión es
verdadero; de lo contrario es falso.

En el ejemplo 2, si a es mayor que b, o c es menor que d, el resultado de evaluar la expresión es
verdadero; de lo contrario es falso.

En el ejemplo 3, primero se evalúan las expresiones aritméticas:

Llamaremos r1 el resultado de multiplicar 3.14 por el valor almacenado en la variable
radio.
Llamaremos r2 el resultado de elevar el contenido de la variable a al cuadrado.
Llamaremos r3 el resultado de restarle a b lo que hay almacenado en c.
Llamaremos r4 el resultado de sumar 3.1 con el contenido de c.
Llamaremos r5 el resultado de multiplicar por 2 la suma de c con d.

Nuestra expresión quedará:

r1 >= r2 || r3 == r4 && r5 <= 1

Llamaremos r6 el resultado lógico obtenido de comparar r1 con r2.
Llamaremos r7 el resultado de comparar r3 con r4.
Llamaremos r8 el resultado de comparar r5 con 1.

Nuestra expresión queda:

r6 || r7 && r8

Luego evalúa r7 && r8.

Llamaremos r9 a este resultado: Sí r7 y r8 son verdaderos, entonces r9 será verdadero; de
lo contrario r9 será falso.
Nuestra expresión queda:

r6 || r9

En la cual, con uno de los dos operandos que sea verdadero, el resultado de evaluar la expresión
será verdad.



3.2.1. Conversión de una Expresión Algebraica a Expresión Lineal de Computador

Cuando se elabora un algoritmo es muy común tener que escribir expresiones, sobre todo si se
trata de algoritmos de carácter científico o matemático.

Para escribir expresiones de computador, según el tema anterior, es necesario tener en cuenta la
forma como el computador evalúa dichas expresiones.

Veamos cómo convertir una expresión algebraica en expresión de computador.

Ejemplo:

Si queremos escribir esta expresión algebraica como expresión de computador, tenemos varias
formas de hacerlo:

1. a / b * c
2. a / b / c
3. a / (b * c)

La primera forma es incorrecta, porque de acuerdo a lo visto en el tema anterior, primero ejecuta
la división del valor de a entre el valor de b, y el resultado lo multiplica por el valor de c. Osea que
si a vale 36, b vale 6 y c vale 2el resultado de evaluar dicha expresión es 12, lo cual es erróneo.

La segunda y tercera forma son correctas: en la segunda forma, primero ejecuta la división del
valor de a por el valor de b y el resultado lo divide por el valor de c, obteniendo como resultado 3.
En la tercera forma primero multiplica el valor de b por el valor de c y el resultado divide al valor
de a, obteniendo como resultado también 3.

Es supremamente importante entender este primer ejemplo.

En la tercera forma hemos utilizado paréntesis para alterar el orden de ejecución de las
operaciones; sin embargo, en la segunda forma no lo hemos utilizado y el resultado también es
correcto.

Veamos algunos ejemplos en los que se exige el uso del paréntesis.
1. Consideremos la siguiente expresión algebraica:



La expresión de computador correcta puede ser:

1. (a + d / e + c) / (b * c) ó
2. (a + d / e + c) / b / c

2. Consideremos esta otra expresión algebraica:

La forma correcta de escribir esta expresión algebraica como expresión de computador es:

A ^ b ^ (c + 1)

3.2.2. Conversión de una Expresión Lineal de Computador a Expresión Algebraica
Pasemos ahora a considerar el caso contrario: dada una expresión de computador, escribir la
expresión algebraica correspondiente.

Consideremos los siguientes ejemplos:

1. a + b * c / d – e ^ f

La expresión algebraica es:

2. (a + b) * c / (d – e) ^ f




3. a – b / c + (b – c / d) / e


Ejemplos Y Aplicaciones De Uso

Elaborar un algoritmo que lea un dato correspondiente al lado de un cuadrado y que calcule e
imprima el área de dicho cuadrado.

Análisis
Datos de entrada: Lado del cuadrado (lado).
Cálculos: Determinar el área del cuadrado.
Datos de salida: Área del cuadrado (área).

Nuestro algoritmo queda:

1. ALGORITMO AREA_DEL_CUADRADO
2. VARIABLES: lado, área (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Ingrese el tamaño del lado del cuadrado en cms.”)
5. LEA (lado)
6. área = lado ^ 2
7. IMPRIMA (“Lado:”, lado, “Área:”, área)
8. FININICIO
9. FIN

En la instrucción 1, definimos el nombre del algoritmo.

En la instrucción 2, definimos las variables que vamos a utilizar, con su correspondiente tipo.

En la instrucción 3, ponemos nuestra palabra clave de inicio de las instrucciones ejecutables.

En la instrucción 4, imprimimos un mensaje que oriente al usuario de que dato debe ingresar.
En la instrucción 5, leemos el valor del lado.


En la instrucción 6, determinamos el área del cuadrado y la guardamos en la variable area.

En la instrucción 7, imprimimos el lado leído y el área calculada, con sus respectivos mensajes.

En la instrucción 8, ponemos nuestra palabra clave de fin de las instrucciones ejecutables.

En la instrucción 9, indicamos el fin del algoritmo.

Entonces, si el lado leído en la instrucción 5 tiene un valor de 10, al ejecutar la instrucción 6 se
almacena en la posición de memoria identificada con el nombre de área el valor de 100.
Luego, al ejecutar la instrucción 7, imprimirá
Lado: 10, Área: 100

Veamos otro ejemplo:

Elaborar un algoritmo que lea el salario actual de dos empleados y el porcentaje de aumento de
cada uno de ellos y que calcule e imprima el salario actual, el aumento y el nuevo salario de cada
uno de ellos.

Análisis:
Datos de entrada:
Salario actual del empleado uno (se1)
Salario actual del empleado dos (se2)
Porcentaje aumento del empleado uno (pe1)
Porcentaje aumento del empleado uno (pe2)

Cálculos:
El aumento de cada empleado se obtiene multiplicando el salario actual por el porcentaje
de aumento leído, y el nuevo salario se obtiene sumando el aumento al salario actual
Datos de salida:
Aumento del empleado uno (au1)
Aumento del empleado dos (au2)
Nuevo salario del empleado uno (nse1)
Nuevo salario del empleado dos (nse2)

Con base a lo anterior, nuestro algoritmo queda:



1. ALGORITMO AUMENTOS
2. VARIABLES: se1, se2, pe1, pe2, au1, au2, nse1, nse2 (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Ingrese el salario del empleado uno”)
5. LEA (se1)
6. IMPRIMA (“Ingrese el porcentaje de aumento del empleado uno”)
7. LEA (pe1)
8. IMPRIMA (“Ingrese el salario del empleado dos”)
9. LEA (se2)
10. IMPRIMA (“Ingrese el porcentaje de aumento del empleado dos”)
11. LEA (pe2)
12. au1 = se1 + pe1
13. au2 = se2 + pe2
14. nse1 = se1 + au1
15. nse2 = se2 + au2
16. IMPRIMA (“Empleado uno:”)
17. IMPRIMA (“Salario actual:”, se1, “Aumento:”, au1, “Nuevo salario:”, nse1)
18. IMPRIMA (“Empleado dos:”)
19. IMPRIMA (“Salario actual:”, se2, “Aumento:”, au2, “Nuevo salario:”, nse2)
20. FININICIO
21. FIN

En la instrucción 1, definimos el nombre de nuestro algoritmo.

En la instrucción 2, definimos las variables que utilizaremos en nuestro algoritmo, con su
respectivo tipo.

En la instrucción 3, ponemos nuestra palabra clave de inicio de las instrucciones ejecutables.

En las instrucciones 4 a 11 leemos los datos correspondientes al salario de cada empleado y al
porcentaje de aumento, con sus respectivos mensajes.

En las instrucciones 12 y 13, calculamos el aumento de cada uno de los empleados. Dichos
aumentos los almacenamos en las variables au1 y au2.

En las instrucciones 14 y 15, calculamos el nuevo salario de cada empleado.

En la instrucción 16, imprimimos el título para los datos del empleado uno.



En la instrucción 17, imprimimos los datos correspondientes al empleado uno: salario actual,
aumento y nuevo salario.
En la instrucción 18, imprimimos el título para los datos del empleado dos.

En la instrucción 19, imprimimos los datos correspondientes al empleado dos: salario actual,
aumento y nuevo salario.

EJERCICIOS

1. Si el valor de A = 4, B = 5, C = 1, L = Verdadero (TRUE); muestre cuales son los valores
impresos en el siguiente algoritmo:

1. ALGORITMO OPERADORES_Y_EXPRESIONES
2. VARIABLES: A, B, C, X, Y, Z (NUMÉRICAS)
3. L: (BOOLEANAS)
4. INICIO
5. A=4
6. B=5
7. C=1
8. L = TRUE
9. X=B*A–B^2/4*C
10. Y=A*B/3^2
11. Z = (((B + C) / 2 * A + 10) * 3 * B) – 6
12. IMPRIMA (X, Y, Z)
13. FININICIO
14. FIN

2. Usando los valores de A, B, C y L del punto anterior, calcule el valor almacenado en las
siguientes variables:
X = (B <= 100) && ! (A > C) && (C == 1)
Y = (B == 5) || (C == 30) && ! L
Z = ((B + 20) > (C – 1)) || ((A + 5) <= 50)

3. Convierta la siguiente expresión algebraica en expresión de computador



4. Convierta la siguiente expresión de computador a expresión algebraica

a / (b + c / (d + 1) * (a + b) – a) ^ b ^ a + c

5. Elaborar un algoritmo que lea el nombre de una persona y que imprima el mensaje
“Bienvenido(a)”, seguido del nombre de la persona leída.

6. Elaborar un algoritmo que lea dos datos enteros correspondientes a los catetos de un
triángulo rectángulo y que calcule e imprima el valor de la hipotenusa de dicho triángulo.

7. Elabore un algoritmo que lea el código de un artículo, el precio unitario del artículo y la
cantidad vendida. Su algoritmo debe calcular e imprimir: el total de la venta, el IVA y el
total a pagar; sabiendo que el impuesto es del 16%.

8. Elabore un algoritmo que lea dos números enteros y que muestre como salida la suma,
resta, multiplicación, división y módulo del primero por el segundo.

9. Elaborar un algoritmo que lea una temperatura en grados Fahrenheit y la convierta e
imprima en grados centígrados. Los grados Fahrenheit se convierte a grados centígrados
restándoles 32 y multiplicando por cinco novenos.



4. ESTRUCTURAS DE DECISIÓN

http://www.youtube.com/watch?v=0EhP86HvCHk

OBJETIVO GENERAL

Reconocer como se maneja una estructura de decisión identificando cuando y como se
utiliza una pregunta. Además la aplicación de la estructura caso en problemas complejos.


Conocer cuándo utilizar una estructura de decisión simple y cuándo una estructura de
decisión compuesta.
Identificar cuándo remplazar la estructura de decisión SI por un selector múltiple, o
estructura CASO.



Prueba Inicial

1. ¿Cuál es la forma general de la instrucción SI?
2. ¿Cuándo es necesario utilizar el componente SINO en una instrucción SI?
3. ¿Qué es mejor y porqué: La instrucción SI simple o instrucciones SI anidadas?
4. ¿Cuándo se aplica una instrucción CASO?
5. ¿Una instrucción SI puede remplazar una instrucción CASO?

ESTRUCTURAS DE DECISIÓN

Las instrucciones correspondientes a la estructura decisión son:

La instrucción SI y su componente opcional SINO.
La instrucción CASOS.

4.1. Estructuras de Decisión Simple y Compuestas

La estructura de decisión permita instruir al computador para que ejecute ciertas acciones
(instrucciones) según alguna condición.

La forma general de la instrucción SI es:

SI (condición)
Instrucciones que se ejecutan cuando la condición sea verdadera.
SINO
Instrucciones que se ejecutan cuando la condición es fala.
FINSI

Ejemplo:
Elaborar un algoritmo que lea el salario actual de un empleado y que calcule e imprima el nuevo
salario de acuerdo a la siguiente condición: si el salario es menor que 1000 pesos, aumentar el
10%; sino no hacer el aumento.

Análisis:
Datos de entrada: salario actual (SALACT).
Cálculos: determinar el aumento según la condición planteada.
Datos de salida: aumento (AU), nuevo salario (NUESAL).


Nuestro algoritmo es:

1. ALGORITMO AUMENTO_CONDICIONAL
2. VARIABLES: SALACT, AU, NUESAL (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Ingrese salario”)
5. LEA (SALACT)
6. SI (SALACT < 1000)
7. AU = SALACT * 0.1
8. SINO
9. AU = 0
10. FINSI
11. NUESAL = SALACT + AU
12. IMPRIMA (“Nuevo salario:”, NUESAL)
13. FININICIO
14. FIN

En la instrucción 2, se definen las variables con las cuales vamos a trabajar.
En la instrucción 5, se lee el salario actual.
En la instrucción 6, se compara el salario leído con el dato de referencia planteado en el
enunciado.
Si la condición de la instrucción 6 es verdadera, se ejecuta la instrucción 7; sino se
efectuará la instrucción 9.
En la instrucción 7, se determina el aumento, el cual es el diez por ciento del salario actual,
mientras que en la instrucción 9 se asigna cero al aumento.
La instrucción 10, delimita el alcance de la instrucción SI.
En la instrucción 11, se calcula el nuevo salario, y en la instrucción 12 se imprime el nuevo
salario.

El anterior algoritmo se puede escribir sin utilizar el componente SINO, el cual, como habíamos
dicho, es opcional.

Veamos nuestro nuevo algoritmo:



1. ALGORITMO AUMENTO_CONDICIONAL (2)
2. VARIABLES: SALACT, AU, NUESAL (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Ingrese salario”)
5. LEA (SALACT)
6. AU = 0
7. SI (SALACT < 1000)
8. AU = SALACT * 0.1
9. FINSI
10. NUESAL = SALACT + AU
11. IMPRIMA (“Nuevo salario: ”, NUESAL)
12. FININICIO
13. FIN

La diferencia de este segundo algoritmo con el primero es que al aumento inicialmente se le
asigna el valor de cero en la instrucción 6.

Cuando se compara el salario actual con el valor de referencia (1000), se modificará el aumento
sólo si el salario actual es menor que el valor de referencia; en caso contrario el aumento
permanecerá en cero.

INSTRUCCIONES

En la práctica se presentan hechos en los cuales es necesario controlar situaciones dentro de
situaciones ya controladas, es decir, comprobar condiciones dentro de condiciones, o comprobar
varias condiciones a la vez. Estos acontecimientos implican el uso de la instrucción SI de una forma
más compleja.

Ejemplo:

Elabore un algoritmo que lea tres datos numéricos y que los imprima ordenados
ascendentemente.

Análisis:
Datos de entrada: tres datos numéricos (a, b, c).
Cálculos: determinar el menor de los tres datos para imprimirlo de primero, luego determinar el
menor de los dos restantes para imprimirlo de segundo y luego imprimir el tercer dato.
Datos de salida: los mismos tres datos de entrada en orden ascendente.



Una primera forma de escribir este algoritmo es siendo exhaustivos en la comparación de los
datos.

Realmente, las diferentes situaciones que se pueden presentar para escribir los tres datos son:
La primera, cuando a es menor que b y b es menor que c.
La segunda, cuando a es menor que c y c es menor que b.
La tercera, cuando b es menor que a y a es menor que c,
Y así sucesivamente.

A cada situación le corresponde una relación de orden diferente.

1. a, b, c
2. a, c, b
3. b, a, c
4. b, c, a
5. c, a, b
6. c, b, a

Un algoritmo para efectuar esta tarea es:



1. ALGORITMO ORDENAR_3_DATOS (1)
2. VARIABLES: a, b, c (NUMÉRICAS)
3. INICIO
4. IMPRIMA (“Ingrese tres números”)
5. LEA (a, b, c)
6. SI (a < b) && (b < c)
7. IMPRIMA (a, b, c)
8. FINSI
9. SI (a < c) && (c < b)
10. IMPRIMA (a, c, b)
11. FINSI
12. SI (b < a) && (a < c)
13. IMPRIMA (b, a, c)
14. FINSI
15. SI (b < c) && (c < a)
16. IMPRIMA (b, c, a)
17. FINSI
18. SI (c < a) && (a < b)
19. IMPRIMA (c, a, b)
20. FINSI
21. SI (c < b) && (b < a)
22. IMPRIMA (c, b, a)
23. FINSI
24. FININICIO
25. FIN

Las instrucciones 6 a 8 consideran la primera situación; las instrucciones 9 a 11 consideran la
segunda situación; las instrucciones 12 a 14 consideran la tercera situación; las instrucciones 15 a
17 consideran la cuarta situación; las instrucciones 18 a 20 consideran la quinta situación; y las
instrucciones 21 a 23 consideran la sexta situación.

Este algoritmo tiene el inconveniente de que cuando una situación sea verdadera, continúa
preguntando por las demás, lo cual genera ineficiencia. Para evitar esta ineficiencia utilizamos la
parte opcional SINO.

Veamos cómo queda nuestro algoritmo:



3. INICIO
5. LEA (a, b, c)
6. SI (a < b) && (b < c)
8. SINO
9. SI (a < c) && (c < b)
11. SINO
12. SI (b < a) && (a < c)
14. SINO
15. SI (b < c) && (c < a)
17. SINO
18. SI (c < a) && (a < b)
20. SINO
22. FINSI
23. FINSI
24. FINSI
25. FINSI
26. FINSI
27. FININICIO
28. FIN

De esta manera, cuando encuentre que una condición (situación) es verdadera, procede a
imprimir los datos en forma ordenada y no sigue preguntando por las demás condiciones.

Una tercera forma en que podemos elaborar el algoritmo es la siguiente:

Comparamos a con b.

Pueden suceder dos cosas: una, que a sea menor que b, y dos, que b sea menor que a.



1. Si a es menor que b, implica que habrá que escribir el dato a antes que el dato b; por lo
tanto las posibles formas de escribir los tres datos son:

1. a, b, c
2. a, c, b
3. c, a, b

Si b es menor que c, imprimimos la primera posibilidad: a, b, c; de lo contrario, debemos comparar
a con c.

Si a es menor que c, imprimimos la segunda posibilidad: a, c, b; en caso contrario, imprimimos la
tercera posibilidad: c, a, b.

2 Si b es menor que a implica que habrá que escribir el dato b antes que el dato a; por lo
tanto las posibles formas de escribir los tres datos son:

1. b, a, c
2. b, c, a
3. c, b, a

Si a es menor que c, imprimimos la primera posibilidad: b, a, c; de lo contrario, debemos comparar
b con c.

Si b es menor que c, imprimimos la segunda probabilidad: b, c, a; sino, imprimimos la tercera
probabilidad: c, b, a.

Con base en el anterior análisis nuestro algoritmo queda:



3. INICIO
5. LEA (a, b, c)
6. SI (a < b)
7. SI (b < c)
9. SINO //c es menor que b
10. SI (a < c)
12. SINO //c es menor que a
14. FINSI
15. FINSI
16. SINO //b es menor que a
17. SI (a < c)
19. SINO //c es menor que a
20. SI (b < c)
22. SINO //c es menor que b
24. FINSI
25. FINSI
26. FINSI
27. FININICIO
28. FIN



EJERCICIOS

1. Elabore un algoritmo que lea el nombre de un empleado, su salario básico por hora y el
número de horas trabajadas en el mes; imprima su nombre y salario mensual si éste es
mayor de 450.000 pesos, de lo contrario imprima sólo en nombre.

2 Se tienen tres esferas (A, B, C) de diferente peso. Elaborar un algoritmo que determine cuál es
la esfera de mayor peso.

3 Elaborar un algoritmo que determine la suma del valor menor y mayor en un grupo de 4 datos.

4 Elaborar un algoritmo que lea la ordenada (Y) y abscisa (X) de un punto de un plano cartesiano y
determine si pertenece o no a la recta Y = 3X + 5.

5 Un almacén de escritorios hace los siguientes descuentos: si el cliente compra menos
de 5 unidades, se le da un descuento del 10% sobre la compra; si el número de unidades
es mayor o igual a 5 pero menos de 10 se le otorga un 20%; y si son 10 o más unidades, se
le da un 40%. Elaborar un algoritmo que determine cuánto debe pagar un cliente si el
valor de cada escritorio es de 800.000 pesos.

6 Una frutería ofrece las manzanas con descuento según la siguiente tabla:

No. de manzanas % descuento
0–2 0%
3–5 10%
6 – 10 15%
11 en adelante 20%
Elaborar un algoritmo que determine cuánto pagará una persona que compre manzanas en esa
frutería.

Cierta universidad tiene un programa para estimular a los estudiantes con buen rendimiento
académico. Si el promedio es de 4.5 o más y el alumno es de pregrado, entonces cursará 28
créditos y se le hará un descuento de 25%; si el promedio es mayor o igual a 4.0 pero menor que
4.5 y el alumno es de pregrado, entonces cursará 25 créditos y se le hará un 10% de descuento; si
el promedio es mayor o igual que 3.5 y menor que 4.0 y es de pregrado, cursará 20 créditos y no
tendrá descuento; si el promedio es mayor o igual que 2.5 y menor que 3.5 y es de pregrado,
cursará 15 créditos y no tendrá descuento; si el promedio es menor que 2.5 y es de pregrado, no
podrá matricularse; si el promedio es mayor o igual a 4.5 y es de posgrado, cursará 20 créditos y
se le hará un 20% de descuento; si el promedio es menor de 4.5 y es de posgrado, cursará 10



créditos y no tendrá descuento.
Elaborar un algoritmo que determine cuánto debe pagar un estudiante y cuántos créditos registra
si el valor de cada crédito es de 50.000 pesos para pregrado y 300.000 pesos para posgrado.

8 Un proveedor de computadores ofrece descuento del 10%, si cuesta 1.000.000 de pesos o más.
Además, independientemente, ofrece el 5% de descuento si la marca es ABACO. Elaborar un
algoritmo que determine cuánto pagará, con IVA incluido, un cliente cualquiera por la compra de
un computador.

4.2. Estructura Caso o Selector Múltiple

El selector múltiple sirve para reemplazar una serie lógica. Su estructura corresponde a la de un
bloque de decisión múltiple, es decir, ofrece más de dos caminos a seguir simultáneamente. Para
usar un selector múltiple se debe considerar:

La presencia de una variable que contenga más de dos valores que sean enteros (1, 2, 3,...
N) y dependiendo de ese valor se ejecute ciertas instrucciones según el camino Lógico
determinado.

No tiene sentido usar un selector para una variable como por ejemplo sexo (1; hombre, 2: Mujer),
en este caso es más óptimo y eficiente un bloque de decisión pero para una variable como
programa (1: Sistemas, 2: Electrónica. 3: Secretariado, 4: Gestión Administrativa, 5: Contaduría) se
debe usar un selector.

EI selector múltiple se puede usar cuantas veces se requiera.
En el selector se debe colocar todos los valores de la variable.
El selector tiene la siguiente estructura:



CASOS
CASO (VARIABLE==1)
Grupo de instrucciones a ejecutar cuando la variable sea igual a 1
SALTO
CASO (VARIABLE==2)
SALTO
CASO (VARIABLE==3)
SALTO

CASO (VARIABLE==N)
Grupo de instrucciones a ejecutar cuando la variable sea igual a N
SALTO
OTRO_CASO
Grupo de instrucciones a ejecutar cuando la variable sea diferente a las anteriores
SALTO
FINCASOS

Después de ejecutar las instrucciones que se encuentran dentro de un caso específico la expresión
SALTO nos remitirá hasta el fin de los casos.

Ejemplo:
Elaborar un algoritmo que lea el nombre de una persona y su estado civil.

El estado civil está codificado con un dígito con los siguientes significados:
1: Soltero
2: Casado
3: Separado
4: Viudo
5: Unión libre

El algoritmo debe imprimir el nombre leído y la descripción correspondiente al estado civil.



Análisis:
Datos de entrada: nombre (NOM), estado civil (EC).
Cálculos: Comparar el estado civil según el código establecido e imprimir la descripción
correspondiente.
Datos de salida: nombre (NOM), estado civil (EC).

1. ALGORITMO ESTADO_CIVIL (1)
3. EC (NUMÉRICA)
4. INICIO
5. IMPRIMA (“Ingrese nombre”)
6. LEA (NOM)
7. IMPRIMA (“Ingrese estado civil”)
8. LEA (EC)
9. CASOS
10. CASO (EC == 1)
11. IMPRIMA (NOM, “Soltero”)
12. SALTO
13. CASO (EC == 2)
14. IMPRIMA (NOM, “Casado”)
15. SALTO
16. CASO (EC == 3)
17. IMPRIMA (NOM, “Separado”)
18. SALTO
19. CASO (EC == 4)
20. IMPRIMA (NOM, “Viudo”)
21. SALTO
22. CASO (EC == 5)
23. IMPRIMA (NOM, “Unión libre)
24. SALTO
25. OTRO_CASO
26. IMPRIMA (EC, “Estado civil no válido”)
27. SALTO
28. FINCASOS
29. FININICIO
30. FIN

Dentro de la instrucción CASOS cuando escribimos CASO (EC == 1): la máquina compara EC con 1,
si EC es igual a 1 ejecuta las instrucciones correspondientes a ese caso.



Un algoritmo equivalente al anterior, utilizando la instrucción SI, es el siguiente:

1. ALGORITMO ESTADO_CIVIL (2)
3. EC (NUMÉRICA)
4. INICIO
5. IMPRIMA (“Ingrese nombre”)
6. LEA (NOM)
8. LEA (EC)
9. SI (EC == 1)
10. IMPRIMA (NOM, “Soltero”)
11. SINO
12. SI (EC == 2)
13. IMPRIMA (NOM, “Casado”)
14. SINO
15. SI (EC == 3)
16. IMPRIMA (NOM, “Separado”)
17. SINO
18. SI (EC == 4)
19. IMPRIMA (NOM, “Viudo”)
20. SINO
21. SI (EC == 5)
22. IMPRIMA (NOM, “Unión libre)
23. SINO
24. IMPRIMA (EC, “Estado civil no válido”)
25. FINSI
26. FINSI
27. FINISI
28. FINSI
29. FINSI
30. FININICIO
31. FIN

Un punto importante que se debe considerar en este sitio es: ¿cuándo utilizar la instrucción SI, y
cuándo utilizar la instrucción CASOS?
La respuesta es sencilla:

Cuando el resultado de una comparación sólo da dos alternativas, se utiliza la instrucción
SI.



Cuando el resultado de una comparación da más de dos alternativas, se utiliza la
instrucción CASOS.

EJERCICIOS

1. Elabore un algoritmo que lea el nombre de un estudiante y su promedio acumulado de la
carrera. El algoritmo debe imprimir el nombre del estudiante y alguno de los siguientes
mensajes: “pésimo”, “malo”, “regular”, “bueno” o “excelente”. El estudiante se considera
pésimo, si el promedio acumulado es menor o igual que 1; malo, si el promedio es mayor
que 1 y menor que 3; regular, si el promedio es mayor o igual que 3 y menor que 4;
bueno, si el promedio es mayor o igual que 4 y menor que 4.5; y excelente, si el promedio
es mayor o igual que 4.5.

2 Elabore un algoritmo que lea un número menor que 32768 y que efectúe lo siguiente:
si es múltiplo de 4, imprimir el número dividido por 4; si es múltiplo de 5, imprimir la
quinta parte del número elevada al cuadrado; si es múltiplo de 7, imprimir el número
dividido por 8; y si no es múltiplo de ninguno de los anteriores, imprimir el mensaje
“número extraño”.

3 Elabore un algoritmo que lea: nombre de un empleado, estado civil, edad y salario actual. Para
el empleado leído determine el nuevo salario con base en las siguientes políticas:

Soltero menor de 30 años se le aumenta el 10% de su salario actual.
Soltero mayor o igual de 30 años se le aumenta el 12% de su salario actual.
Casado menor de 25 años se le aumenta el 12% de su salario actual.
Casado mayor o igual de 25 años se le aumenta el 15% de su salario actual.
Separado menor de 20 años se le aumenta el 8% de su salario actual.
Separado mayor o igual de 20 años se le aumenta el 10% de su salario actual.
Viudo menor de 30 años se le aumenta el 15% de su salario actual.
Viudo mayor o igual de 30 años se le aumenta el 12% de su salario actual.
Empleado en unión libre que devengue menos de 1000 pesos se le aumenta el 20% de su
salario actual.
Empleado en unión libre que devengue 1000 pesos o más se le aumenta el 12% de su
salario actual.
El algoritmo deberá determinar el aumento del empleado leído e imprimir: nombre, estado civil,
edad, salario actual, porcentaje de aumento, aumento y nuevo salario.

4 La empresa de productos de belleza “El acné” otorga descuento a sus clientes según la siguiente
clasificación: si es mayorista, tiene una antigüedad de más de dos años y el valor de la compra es
mayor que 2.000.000 de pesos le da un descuento del 25%; si es mayorista, tiene una antigüedad



menor o igual a dos años y el valor de la compra está entre 1.500.000 y 2.000.000 de pesos le da
un descuento del 20%; si es minoritario, tiene una antigüedad superior a cinco años y el valor de
la compra es superior a 2.000.000 de pesos le da un descuento del 18%; si es ocasional y el valor
de la compra es superior a 2.000.000 de pesos le da un descuento de 10%; en cualquier otro caso,
la compañía no da ningún descuento. Elabore un algoritmo que lea la clase de cliente, la
antigüedad y el valor de la compra y determine el valor a pagar por la compra.
Los códigos de clasificación del cliente son:
1. Mayorista.
2. Minorista.
3. Ocasional.



5. ESTRUCTURAS REPETITIVAS

http://www.youtube.com/watch?v=0EhP86HvCHk

OBJETIVO GENERAL

Reconocer en un problema cuando se utiliza un ciclo para, un ciclo mientras que, y la
aplicación de los conceptos de contadores, acumuladores, promedios y porcentajes, además
la manipulación del concepto de ciclos anidados y rompimiento de control.


Conocer las diferentes instrucciones que se utilizan para que el computador ejecute más de
una vez cierto conjunto de instrucciones.
Analizar las estructuras repetitivas anidadas y su orden de secuencia dentro del algoritmo.
Identificar la estructura de rompimiento de control y cuando se hace necesario su uso dentro
de un ciclo.



Prueba Inicial

En los siguientes enunciados seleccione la respuesta correcta

1. Un proceso repetitivo me permite:

a. Repetir una instrucción más de una vez
b. Repetir una instrucción solo una vez
c. No repetir instrucciones
d. Repetir una instrucción infinitamente

2. En un ciclo Para se debe conocer:

a. Límite inferior
b. Límite superior
c. El incremento
d. Todas las anteriores

3. En un ciclo Mientras Que se pueden trabajar procesos que pueden ser:

a. Formato cuantitativo
b. Formato cualitativo
c. Formato cuantitativo y cualitativo
d. Ninguna de las anteriores

5.1. Estructuras Repetitivas

Se puede decir que estos procesos son aquellos en los cuales se repite o se itera un proceso
determinado cierto número de veces. Se les llama también proceso iterativo o simplemente ciclos.
La construcción de un ciclo se puede hacer de la siguiente manera:

Elaborar el algoritmo pensando solamente en una iteración.
Luego de tener listo lo anterior hay varias maneras de repetir un proceso las cuales
básicamente dependen de si se conoce o no el número de iteraciones o repeticiones, y según
esto los ciclos se dividen en: Ciclo automático o ciclo para; ciclo mientras que.

5.1.1. Funcionamiento y Componentes de las Diferentes Estructuras Repetitivas



Una estructura repetitiva, o ciclo, está conformada por instrucciones que permiten al
programados instruir la máquina para que se ejecute varias veces un grupo de instrucciones según
alguna condición.
Las instrucciones que pertenecen a esta estructura son: PARA, MIENTRAS QUE y HAGA MIENTRAS
QUE.

5.1.2. Ciclo Automático o Ciclo Para

Estos procesos cíclicos se caracterizan por el uso de una variable de iteración la cual tiene tres
características: Esta inicializada, controlada e incrementada (en algunos casos disminuye en vez de
incrementar), es decir, tiene límite inferior, límite superior e incremento (o decremento).

Estas características se dan a manera de instrucciones ubicadas espacialmente en el algoritmo en
distintas posiciones, esto es lo que define un ciclo automático y una manera muy cómoda de
representarlo es agrupando las tres características de la variable de iteración en una sola
instrucción, seguida del proceso a iterar y terminando con la instrucción FINPARA.

La instrucción en donde están agrupadas las 3 características, se llama el encabezamiento del
ciclo, esquemáticamente es:

PARA (I= LINF, LSUP, INC)
Proceso a iterar
FINPARA

En donde I es la variable de iteración o variable controladora del ciclo, LINF es el límite inferior o
valor inicial de la variable de iteración, LSUP es el límite superior o control de la variable de
iteración, INC es el valor del incremento.

La instrucción PARA sólo se usa cuando se conocen el límite inferior (LINF) y límite superior (LSUP)
de la variable controladora del ciclo.

NOTA: En algunos algoritmos, disminuiremos la variable de iteración en lugar de incrementarla,
para estos algoritmos el esquema es:

PARA (I= LSUP, LINF, DEC)
Proceso a iterar



FINPARA

En donde empezaremos en el límite superior (LSUP) y realizaremos el proceso a iterar hasta que
nuestra variable controladora de ciclo (I) llegue al límite inferior (LINF); disminuyendo la variable
de iteración como lo indique el decremento (DEC).

Ejemplo: Elaborar un algoritmo que lea edad, estado civil (1: Soltero, 2: Casado), estatura y sexo
(1: Hombre, 2: Mujer) de 500 personas. Calcular e imprimir: Cuantas personas cumplen
simultáneamente ser mayor de edad, soltero, hombre y alto (estatura > 1.70), el porcentaje de
esas personas con respecto a total de personas (500) y el promedio de edad y el promedio de
estatura de esas personas.

Solución:

Datos de entrada: Se debe Leer edad, estatura, estado civil y sexo de 500 personas, notemos que
al leer el campo sexo se debe almacenar en él un numero 1 o un numero 2, si el campo sexo
contiene el número 1 se entiende que es un hombre; de lo contrario el único valor posible es un 2
y se entiende que es una mujer. Este análisis es válido para el campo estado civil.
Cálculos: Se debe utilizar un ciclo, es decir, una variable de iteración; Se debe usar un bloque y una
PLC para encontrar aquellas personas que cumplen simultáneamente la condición planteada. Se
deben contar estas personas, lo cual sugiere el uso de un contador y como nos piden calcular
promedios debemos usar un acumulador de edad y un acumulador de estatura, con el contador es
suficiente para calcular los porcentajes requeridos.
Datos de salida: Imprimir el contador, el promedio y el porcentaje. El algoritmo quedaría así:

1. ALGORITMO CICLO_PARA
2. VARIABLES: I, EDAD, EC, EST, SX, CONT, ACUMEDAD, ACUMEST, PROMEDAD, PROMEST,
PORC (TIPO NUMÉRICO)
3. INICIO
4. CONT = 0
5. ACUMEDAD = 0
6. ACUMEST = 0
7. PARA (I=1, 500, 1)
8. IMPRIMA (“Ingrese edad”)
9. LEA (EDAD)
11. LEA (EC)
12. IMPRIMA (“Ingrese estatura”)
13. LEA (EST)
14. IMPRIMA (“Ingrese el sexo: 1.Hombre, 2.Mujer”)


15. LEA (SX)
16. SI (EDAD>=18) ^ (EC==1) ^ (EST>=1.70) ^ (SX==1)
17. CONT = CONT + 1
18. ACUMEDAD = ADUMEDAD + EDAD
19. ACUMEST = ECUMEST + EST
20. FINSI
21. FINPARA
22. PROMEDAD = ECUMEDAD / CONT
23. PROMEST = ACUMEST / CONT
24. PORC = CONT * 100 / 500
25. IMPRIMA (“Personas mayores de edad, soltero, hombre y alto”, CONT)
26. IMPRIMA (“Porcentaje”, PORC)
27. IMPRIMA (“Promedio de edad, PROMEDAD)
28. IMPRIMA (“Promedio de estatura”, PROMEST)
29. FININICIO
30. FIN
Note que Ia PLC del bloque de decisión es verdadera, si todas las PLS que la conforman son
verdaderas.

(EDAD >= 18) nos garantiza ser mayor de edad cuando es verdadera.
(EC = 1), en donde Ia variable EC contiene el estado civil, si el contenido del campo EC es igual a 1
significa que es soltero.
(SX = 1), en donde la variable SX contiene el Sexo. Si el contenido del campo SX es igual a 1 esta
PLS es verdadera y significa ser hombre.
(Est > 1.70), en donde la variable EST contiene la estatura. Según el problema si esta PLS es
verdadera es una persona alta.
El campo CONT está contando las personas que cumplen la condición buscada, el campo
ACUMEDAD está sumando las edades de esas personas, el campo ACUMEST esta sumando las
estaturas de esas personas; por Último note que los promedios de edad (PROMEDAD), de estatura
(PROMEST) y el porcentaje (PORC) se calculan por fuera del ciclo. Efectuemos una prueba de
escritorio para los siguientes datos (Aunque pudieron ser otros).

EDAD EC SX EST
18 1 1 1.80
20 1 1 1.60
22 1 1 1.75
22 2 2 1.70
26 1 1 1.80



EDAD EC SX EST CONT ACUMEDAD ACUMEST
0 0 0
18 1 1 1.80 1 18 1.80
20 1 1 1.60 1 18 1.80
22 1 1 1.75 2 40 3.55
22 2 2 1.70 2 40 3.55
26 1 1 1.80 3 66 5.35

Con los valores de ACUMEDAD, ACUMEST y CONT, calculemos los promedios y el porcentaje:
PROMEDAD = 66/3 => PROMEDAD = 22
PROMEST = 5.35/3 => PROMEST = 1.78
PORC = 3 * 100/ 5 => PORC = 60

Por último se imprime: 3, 22, 1.78,60

Veamos otros ejemplos:
En una empresa se tiene 1000 empleados, por empleado lee la edad. Calcular e imprimir la
cantidad de empleados que tienen edad mayores a 21 años y menores de 30 años.

1. ALGORITMO EMPLEADOS
2. VARIABLES: CONT, C, EDAD (TIPO NUMÉRICO)
3. INICIO
4. CONT = 0
5. PARA (C = 1, 1000, 1)
6. IMPRIMA (“Ingrese la edad”)
7. LEA (EDAD)
8. SI (EDAD>21) ^ (EDAD<30)
9. CONT = CONT + 1
10. FINSI
11. FINPARA
12. IMPRIMA (“Personas con edad entre 21 y 30 años”, CONT)
13. FININICIO
14. FIN

En el ejemplo anterior se usó la estructura cíclica automática o ciclo para y se ha dicho que esta
estructura se utiliza cuando se conoce el número de iteraciones, en este caso (1000), el número de
iteraciones se ha controlado usando un bloque de decisión en el cual por medio de una PLS se



compara el contenido actual de la variable de iteración con un valor constante, una manera de
generalizar estos ciclos es comparar el contenido de la variable de iteración con el contenido de
un campo el cual se ha leído previamente antes y por fuera del ciclo.

Este campo se conoce con el nombre de REGISTRO IDENTIFICADOR.

El problema anterior es para 1000 personas pero lo podemos generalizar para un número N
conocido de personas así:

1. ALGORITMO EMPLEADOS_N
2. VARIABLES: N, CONT, C, EDAD (TIPO NUMÉRICO)
3. INICIO
4. IMPRIMA (“Ingrese el número de empleados”)
5. LEA (N)
6. CONT = 0
7. PARA ( C = 1, N, 1)
9. LEA (EDAD)
10. SI (EDAD>21) ^ (EDAD<30)
11. CONT = CONT + 1
12. FINSI
13. FINPARA
14. IMPRIMA (“Personas con edad entre 21 y 30 años”, CONT)
15. FININICIO
16. FIN

Note que el ciclo va hasta N iteraciones pero N ha sido leído previamente, es decir, el ciclo se
puede hacer para 5, 100, 1000, 2000, Personas porque por medio de la lectura se le da el valor al
campo N, se determina cuantas veces quiere repetir el proceso. La variable N se llama registro
identificador.

CICLO MIENTRAS QUE

La forma general de la instrucción MIENTRAS QUE es:
MQ (condición)
Instrucciones que se ejecutan mientras que la condición sea verdadera
FINMQ



La condición puede ser una expresión relacional o una expresión lógica. En la condición, por lo
general, se evalúa el valor de una variable. Esta variable, que se debe modificar en cada iteración,
es la variable controladora del ciclo.

2
Esquema Cualitativo:
Son estructuras repetitivas que se pueden utilizar cuando no se conoce el número de iteraciones a
ejecutar ejemplo cuando se hace una encuesta, el número de datos totales a precisar no es
concreto, en este caso es más precedente usar un ciclo "mientras que", que un ciclo “para”, otros
ejemplos serian calcular los salarios en una empresa que cambia constantemente el número de
trabajadores, o las definitivas de una escuela en donde se pueden retirar alumnos o ingresar
alumnos extemporáneamente; estos ciclos tienen las siguientes características:

El encabezamiento está formado por la frase MIENTRAS_QUE (o de forma abreviada: MQ),
seguida de una proposición lógica simple o compuesta encerrada entre paréntesis. Esta
proposición deberá estar integrada al menos por un campo variable que posibilite la
alteración de su contenido dentro del ciclo, de manera que el proceso repetitivo se
interrumpa en un momento predeterminado.
El ciclo se ejecuta, si y Sólo si, la proposición lógica es verdadera, cuando se vuelva falsa, se
sale automáticamente del ciclo.
EI control de las iteraciones Io tiene el usuario, es decir, el usuario determina cuando quiere
interrumpir la ejecución del ciclo puesto que bastara dar un valor tal que Ia expresión lógica
se vuelva falsa.

La proposición Lógica se puede formar de dos maneras:
Usando una variable adicional a las variables del programa la cual puede ser un switche o una
variable llamada control.
Usando una de las variables que contienen Ia información a procesar (nombre, edad, sexo,
estado civil, etc.), En este caso se dice que el ciclo está controlado por un campo centinela.
En ambos casos (usando un control, un switche o un centinela) se debe hacer Io siguiente:
Leer antes del encabezamiento del ciclo el campo control, el switche o el campo centinela
teniendo en cuenta que el valor asignado sea tal que vuelva verdadera la proposición Iógica si
se quiere entrar al ciclo.
Hacer una segunda lectura del campo (control, switche o centinela) dentro del ciclo y antes
de llegar a Ia Línea de cierre del mismo teniendo en cuenta que como en ese punto se retorna
al encabezamiento del ciclo, si se quiere iterar nuevamente el valor debe ser tal que la
proposición lógica se vuelva verdadera; si se quiere salir del ciclo se asignara un valor que la
vuelva falsa, en este sentido es que se dice que el usuario tiene el control del ciclo y del
número de iteraciones.
Ejemplo:

2
Oviedo Efraín


Se está realizando una encuesta en la ciudad (no se conoce el número de encuestados) se va
elaborando un archivo de datos y por cada registro tenemos: Edad, Estado civil (1: Soltero, 2:
Casado), ingresos mensuales y conforme con el gobierno (1: si, 2: no).
Calcular e imprimir:
a. Qué porcentaje de personas están de acuerdo con el gobierno.
b. Promedio de edad de las personas inconformes con el gobierno.
c. Cuantas personas conformes con el gobierno, ganan menos de $150.000 mensuales y son
casadas.
d. Promedio de ingresos de todas las personas.
Solución:
Necesitamos variables para almacenar los datos de entrada:
ED: Para la edad.
EC: Para el estado civil.
ING: Para el ingreso mensual.
CONFGOB: Conforme con el gobierno.
PORCONF: Porcentaje de personas de acuerdo con el gobierno; para este cálculo se necesita
contar a todas las personas encuestadas, porque no se conoce cuantas veces se va a procesar la
información, si fuera un ciclo para, no habría la necesidad de este conteo porque el total de
iteraciones está determinado por el registro identificador N, para este conteo se usará el contador
llamado CONTOT (Contador total de personas encuestadas), adicionalmente se necesita contar a
las personas que están de acuerdo con el gobierno y se hará con el campo CONCONF.
PORMIN: Promedio de ingresos de todas las personas. Se necesita acumular los ingresos de todos
y se hará en el campo acumulador llamado ACUING.
PROMED: Promedio de edad de las personas en contra del gobierno. Se necesita acumular las
edades de estas personas y para ello se usará acumulador ACUMEDAD y contar las personas
inconformes y se hará con el contador CNCONF.
CONTCAS: Contador de personas conformes con el gobierno que ganan menos de $150.000 y son
casadas.

Solución con una variable adicional llamada control:

1. ALGORITMO MQ_CUALITATIVO
2. VARIABLES: ED, EC, ING, CONFGOB, CONTOT, CONCONF, CNOCONF, CONTCAS, ACUMING,
ACUMEDAD, PORCONF, PROMIN, PROMED (TIPO NUMÉRICO)
3. INICIO
4. CONTOT = 0
5. CONCONF = 0
6. CNOCONF = 0
7. CONTCAS = 0
8. ACUMING = 0


9. ACUMEDAD = 0
10. IMPRIMA (“Ingresar encuesta: 1.Si, 0.No”)
11. LEA (CONTROL)
12. MQ (CONTROL > 0)
14. LEA (ED)
15. IMPRIMA (“Ingrese el estado civil”)
16. LEA (EC)
17. IMPRIMA (“Cuál es su ingreso mensual”)
18. LEA (ING)
19. IMPRIMA (“Está conforme con el gobierno: 1.Si, 0.No”)
20. LEA (CONFGOB)
21. CONTOT = CONTOT + 1
22. ACUMING = ACUMING + ING
23. SI (CONFGOB==1)
24. CONCONF = CONCONF + 1
25. SI (ING<150000) ^ (EC==2)
26. CONTCAS = CONTCAS + 1
27. FINSI
28. SINO
29. CNOCONF = CNOCONF + 1
30. ACUMEDAD = ACUMEDAD + ED
31. FINSI
32. IMPRIMA(“Ingresar otra encuesta: 1.Si, 0.No”)
33. LEA (CONTROL)
34. FINMQ
35. PORCONF = CONCONF * 100 / CONTOT
36. PROMIN = ACUMING / CONTOT
37. PROMED = ACUMEDAD / CNOCONF
38. IMPRIMA (“Porcentaje de personas conformes con el gobierno”, PORCONF)
39. IMPRIMA (“Promedio de edad de las personas inconformes con el gobierno”,
PROMED)
40. IMPRIMA (“Personas conformes con el gobierno, casadas que ganan menos de
$150.000 mensuales”, CONTCAS)
41. IMPRIMA (“Promedio de ingresos de todas las personas”, PROMIN)
42. FININICIO
43. FIN

En la solución anterior se uso una variable adicional que se llama control, su contenido se lee antes
del ciclo y el encabezamiento se construyó con la PLS control > 0, aunque se debe aclarar que


pudo haber sido cualquier otra, esto significa que para poder entrar al ciclo se le debe dar el
control al valor positivo (usted pudo construir otra PLS como por ejemplo: Control < 0, control = 0,
control <> 1, control < 10, etc., la que se quiera pero teniendo en cuenta que al leer control, el
valor asignado debe ser tal que la PLS sea verdadera). Además el control se vuelve a leer antes de
retornar al encabezamiento del ciclo y si se quiere volver a iterar el valor leído debe ser tal que la
PLS sea verdadera.
Por lo general la manera más usada de formar un ciclo mientras que, es usando variables centinela
porque en un programa el uso de menos variables lo hace más óptimo, sin embargo, se presentan
las otras dos opciones con el fin que se escoja la que más cómoda le parezca.

5.1.3. Esquema Cuantitativo
El esquema cuantitativo es utilizado cuando se conoce el número de veces que debe repetirse un
ciclo determinado, antes de activarse la estructura repetitiva.
El número de iteraciones o cantidad de registro puede ser un valor constante o, generalmente,
una variable de entrada cuyo valor es proporcionado al algoritmo antes de activarse el ciclo. Para
explicar este esquema se realizará el siguiente ejemplo:

Hacer un algoritmo que encuentre la suma de los primeros N números naturales.

Análisis:
Datos de entrada: La cantidad de números a tener en cuenta en la suma
Cálculos: Primero se debe conocer la cantidad de números naturales a sumar y luego generar y
sumar la cantidad de números comprendidos entre 1 y esa cantidad.
Datos de salida: La suma de los primeros N números naturales.

Definición de Variables:
N: Cantidad de números naturales a sumar
NUM: Contador que genera los números entre 1 y N y que a su vez controla el ciclo.
SUMA: Suma de los números entre 1 y N

1. ALGORITMO MQ_CUANTITATIVO
2. VARIABLES: N, SUMA, NUM (TIPO NUMÉRICO)
3. INICIO
4. SUMA = 0
5. NUM = 1
6. IMPRIMA (“Ingrese cuántos números desea sumar”)
7. LEA (N)
8. MQ (NUM <= N)
9. SUMA = SUMA + NUM


10. NUM = NUM + 1
11. FINMQ
12. IMPRIMA (“La suma desde 1 hasta”, N, “es”, SUMA)
13. FININICIO
14. FIN



Prueba de escritorio:
Si el valor de N es 7.

N NUM SUMA
7 + 0
2 +
3 3
4 6
5 10
6 15
7 21
8 28

Salida: La suma es: 28

5.1.3.1 Uso del Mq Teniendo un Archivo ya Creado

Para elaborar un algoritmo con ciclos con el fin de determinar el aumento y el nuevo salario de
todos los empleados de una empresa, primero debemos definir cómo entrar los datos al
algoritmo. Una forma es a través del teclado y otra es leyendo los datos de cada empleado desde
un archivo previamente almacenado en el computador.

Elaboremos un algoritmo leyendo los datos desde un archivo.

Como habíamos visto, un archivo es una colección de registros, en la cual en cada registro se
almacenan los datos correspondientes a un empleado.

Cuando se procesa un archivo, el computador debe identificar el nombre del archivo y cuándo
terminó de procesar el archivo. Para identificar esta segunda situación, cada archivo tiene al final
un registro especial que indica que ya no hay más registros. Este registro especial contiene lo que
se conoce como marca de fin de archivo. Llamaremos a esta marca EOF, de las iniciales de las
palabras en inglés End Of File (fin de archivo).

Por ejemplo, un archivo con cinco registros llamado “nómina”, en el cual cada registro contiene el
nombre y el salario actual de un empleado, tiene la siguiente conformación:



Archivo “nómina”
Nº de registro Nombre Salario actual
1 Sara 2000
2 Pedro 3000
3 María 1500
4 Juan 500
5 Elena 2800
6 EOF

Cuando se está procesando un archivo y se ejecuta la instrucción de lectura LEA, la máquina lee los
datos de un registro y se posiciona para leer los datos del siguiente registro. Por consiguiente, para
procesar el anterior archivo debemos ejecutar la instrucción LEA cinco veces.

Además, para procesar un archivo necesitamos ponerlo a disposición del programa que lo va a
procesar. Esto se logra con la instrucción ABRA (nombre del archivo). También incluiremos una
pequeña modificación en la instrucción de lectura para señalas cuál es el archivo que se va a leer, y
una instrucción que cierre el archivo cuando se termina de procesar. La instrucción que
utilizaremos para cerrar un archivo será: CIERRE (nombre del archivo).

La instrucción de lectura queda:

LEA (nombre del archivo: lista de variables, separadas por comas)

Considerando estas características, nuestro algoritmo queda:



1. ALGORITMO AUMENTO_EN_ARCHIVO
2. VARIABLES: sa, au, ns (NUMÉRICAS)
3. nom (CARACTERES)
4. INICIO
5. ABRA (nómina)
6. MQ (!= EOF(nómina))
7. IMPRIMA (“Ingrese nombre y salario actual”)
8. LEA (nómina: nom, sa)
9. au = 0
10. SI (sa < 1000)
11. au = sa * 0.1
12. FINSI
13. ns = sa + au
14. IMPRIMA (“Nombre:”, nom)
15. IMPRIMA (“Salario actual:”, sa)
16. IMPRIMA (“Aumento:”, au)
17. IMPRIMA (“Nuevo salario:”, ns)
18. FINMQ
19. CIERRE (nómina)
20. FININICIO
21. FIN

Al ejecutar la instrucción 5, el dispositivo de lectura se posiciona para leer el primer registro del
archivo “nómina”.

La instrucción 6 pregunta si el registro disponible para ser leído tiene la marca de fin de archivo; de
ser así, la ejecución continuará en la instrucción 19.

Si el registro disponible para ser leído no es la marca de fin de archivo, la ejecución continúa con la
instrucción 7.

La instrucción 8 lee nombre y salario, y los almacena en las variables nom y sa, respectivamente:
en la variable nom queda almacenado Sara y en la variable sa queda almacenado 2000.

Además de cargar las variables nom y sa con los datos leídos, la instrucción de lectura deja
posicionado el dispositivo de lectura para que lea el siguiente registro.

En la instrucción 9, se le asigna 0 al aumento.



La instrucción 10 compara el salario leído con 1000. Si el salario leído es menor que 1000 ejecuta
la instrucción 11, la cual calcula el aumento como el diez por ciento del salario leído (au = sa * 0.1).
Si el salario leído no es menor que 1000, el aumento se queda en cero.

En la instrucción 13 se calcula el nuevo salario, y en las instrucciones 14 a 17 se imprimen el
nombre del empleado, el salario actual, el aumento y el nuevo salario.

La instrucción 18, que es el fin de la instrucción MIENTRAS QUE (MQ), hace que el algoritmo
retorne a la instrucción 6 en la cual va a controlar que el registro para leer no tenga la marca de fin
de archivo.

Al ejecutar por segunda vez la instrucción LEA, las variables nom y sa quedan con los datos Pedro y
3000, respectivamente.

Nuevamente se le asigna cero al valor del aumento, ya que si no hiciéramos esto en la variable au
quedará el aumento que se le hizo al anterior empleado.

Al procesar el archivo “nómina” en su totalidad, los resultados obtenidos serán:

nom sa au ns
Sara 2000 0 2000
Pedro 3000 0 3000
María 1500 0 1500
Juan 500 50 550
Elena 2800 0 2800

5.1.3.2 Ciclo Haga Mientras Que

Esta instrucción de ciclo tiene la característica de que se ejecuta mínimo una vez, ya que la
condición se evalúa después de que se han ejecutado las instrucciones del ciclo.

La forma general de la instrucción HAGA MIENTRAS QUE es:

HAGA
Instrucciones que se ejecutan mientras la condición sea verdadera
MQ (Condición)



Cuando se elaboran algoritmos es necesario, en algunas ocasiones, poder ejecutar primero las
instrucciones correspondientes a un ciclo y luego evaluar las condiciones que determinan si se
vuelven a ejecutar las instrucciones del ciclo. Una de las situaciones en las que es pertinente
utilizar la instrucción HAGA MIENTRAS QUE es la elaboración de un menú, en el cual el usuario
debe elegir una opción, ya que primero se deben presentar las posibles opciones para que el
usuario escoja una, y luego evaluar la escogencia del usuario.

Ejemplo:
Elaborar un algoritmo que presente un menú en pantalla con las siguientes opciones:
1. Leer número.
2. Calcular factorial.
3. Determinar si es par.
4. Terminar.

El usuario elige una opción y el programa opera de acuerdo a la opción que él eligió.

Veamos cómo es el algoritmo:



1. ALGORITMO MENÚ (1)
2. VARIABLES: n, f, i, op (TIPO NUMÉRICAS)
3. INICIO
4. HAGA
5. IMPRIMA (“Elija una opción del Menú:”)
6. IMPRIMA (“1. Leer número”)
7. IMPRIMA (“2. Calcular factorial”)
8. IMPRIMA (“3. Determinar si es par”)
9. IMPRIMA (“4. Terminar”)
10. LEA (op)
11. CASOS
12. CASO (op == 1)
13. LEA (n)
14. SALTO
15. CASO (op == 2)
16. f=1
17. PARA (i= 1, n, 1)
18. f=f*i
19. FINPARA
20. IMPRIMA (f, “es el factorial de”, n)
21. SALTO
22. CASO (op == 3)
23. SI ((n % 2) == 0)
24. IMPRIMA (n, “es par”)
25. SINO
26. IMPRIMA (n, “es impar”)
27. FINSI
28. SALTO
29. CASO (op == 4)
30. SALTO
31. OTRO_CASO
32. IMPRIMA (“Elija una opción válida”)
33. SALTO
34. FINCASOS
35. MQ (op != 4)
36. FININICIO
37. FIN



En la instrucción 2, definimos las variables con las que vamos a trabajar: n el número leído, f para
almacenar el factorial, i para efectuar las operaciones de cálculo del factorial y op para almacenar
la opción elegida por el usuario.

En la instrucción 4, hemos colocado la instrucción HAGA, la cual significa que todas las
instrucciones que hay desde la instrucción 5 hasta la 34 se van a repetir mientras la condición
escrita en la instrucción 35 sea verdadera, es decir, mientras que la opción (op) sea diferente de 4.

En las instrucciones 5 a 9, escribimos los mensajes de las diferentes opciones que tiene el usuario.

En la instrucción 10, se lee la opción elegida por el usuario y se almacena en la variable op.

En la instrucción 11, planteamos la instrucción CASOS, ya que necesitamos comparar el contenido
de la variable op con varios valores: si op vale 1, simplemente se leerá un valor para n; si op vale 2,
se calcula el factorial de n y se imprime dicho resultado; si op vale 3, averiguamos si n es par e
imprimimos el mensaje adecuado; si op vale 4, simplemente instruimos a la máquina para que no
ejecute ninguna operación y vaya a la instrucción 35 para evaluar la condición de terminación del
ciclo; y finalmente, si el valor de op no es ninguno de los anteriores, imprimimos el mensaje de
que la opción elegida por el usuario no es válida. En las instrucciones correspondientes a cada una
de las operaciones hemos colocado la instrucción SALTO, la cual hace que vaya a la instrucción 35
para evaluar la condición del ciclo.

En la instrucción 35, se evalúa la condición. Si op vale 4, la condición es falsa y la ejecución
continúa en la instrucción 36; cualquier otro valor diferente de 4 significa que la condición es
verdadera y por consiguiente regresa a la instrucción 4 para volver a ejecutar las instrucciones del
ciclo.

Conversión de la instrucción HAGA MIENTRAS QUE en instrucción MIENTRAS QUE

En general, cualquier ciclo elaborado con la instrucción HAGA MIENTRAS QUE se puede construir
usando la instrucción MIENTRAS QUE, aunque para ello se necesita una variable adicional.
Llamaremos a esta variable adicional sw, con la cual controlaremos el ciclo MIENTRAS QUE.
Inicialmente a esta variable le asignamos el valor de cero y planteamos el ciclo MIENTRAS QUE
para que se ejecute mientras sw sea igual a cero. El valor del sw sólo lo pondremos en 1 cuando la
opción elegida por el usuario sea 4.

Veamos cómo queda nuestro algoritmo utilizando la instrucción MIENTRAS QUE en lugar de
utilizar la instrucción HAGA MIENTRAS QUE:



1. ALGORITMO MENÚ (2)
2. VARIABLES: n, f, i, op, sw (TIPO NUMÉRICAS)
3. INICIO
4. sw = 0
5. MQ (sw == 0)
6. IMPRIMA (“Elija una opción del Menú:”)
7. IMPRIMA (“1. Leer número”)
8. IMPRIMA (“2. Calcular factorial”)
9. IMPRIMA (“3. Determinar si es par”)
10. IMPRIMA (“4. Terminar”)
11. LEA (op)
12. CASOS
13. CASO (op == 1)
14. LEA (n)
15. SALTO
16. CASO (op == 2)
17. f=1
18. PARA (i= 1, n, 1)
19. f=f*i
20. FINPARA
21. IMPRIMA (f, “es el factorial de”, n)
22. SALTO
23. CASO (op == 3)
24. SI ((n % 2) == 0)
25. IMPRIMA (n, “es par”)
26. SINO
27. IMPRIMA (n, “es impar”)
28. FINSI
29. SALTO
30. CASO (op == 4)
31. sw = 1
32. SALTO
33. OTRO_CASO
34. IMPRIMA (“Elija una opción válida”)
35. SALTO
36. FINCASOS
37. FINMQ
38. FININICIO
39. FIN



EJERCICIOS

1. Elabore un algoritmo que lea 200 números enteros y calcule e imprima: Cuántos son
positivos, cuántos son negativos y cuántos son iguales a cero.

2. Elaborar un algoritmo que lea el salario neto de 2000 trabajadores y calcule e imprima: el
promedio de salarios y el porcentaje de aquellos trabajadores que ganen más del salario
mínimo vigente, el promedio de salarios y el porcentaje de aquellos trabajadores que
ganen menos del salario mínimo vigente.

3. Elaborar un algoritmo que lea el carné, nombre, edad, sexo (1: Hombre, 2: Mujer),
programa (1: Programación, 2: Contaduría, 3: Gestión administrativa, 4: Secretariado, 5:
Electrónica) para un número N conocido de personas. Calcular e imprimir:
a. Cuántas personas estudian en cada uno de los distintos programas.
b. Cuántas mujeres, mayores de edad, estudian secretariado.
c. Promedio de edad de los hombres que estudian programación.
d. Cuántas mujeres, mayores de edad, estudiantes de gestión administrativa se llaman
“LAURA”.
e. Porcentaje de estudiantes mujeres de electrónica.

4. Elabore un algoritmo que lea un número N y que genere e imprima todos los números
primos desde 1 hasta N.

5. Elabore un algoritmo que lea dos enteros positivos m y n, y que calcule e imprima el
resultado de multiplicar m por n utilizando únicamente la operación de suma.

6. Elabore un algoritmo que lea dos enteros positivos m y n, y que calcule e imprima el
resultado de elevar m a la potencia n utilizando únicamente la operación de suma.

7. Elabore un algoritmo que imprima los enteros desde 1 hasta N de la siguiente manera:
1 22 333 4444 55555 …

8. Una empresa utiliza la siguiente fórmula para calcular el sueldo de sus empleados:
Sueldo=(100+edad+(1+2+3+…+años en la compañía))/años en la compañía
Elabore un algoritmo que permita imprimir el sueldo y el nombre de cada uno de los 40
empleados de la compañía, así como el total acumulado de sueldos y el nombre del empleado
que gana más y del que gana menos.

9. Una empresa cuenta con X empleados. Se tiene un archivo de datos y por cada registro se
tiene: nombre, sexo (1: Hombre, 2: Mujer), edad, estado civil (1: Soltero, 2: Casado) y
cargo (1: Obrero, 2: Secretaria, 3: Supervisor). Calcular e imprimir:
a. Cuántas secretarias se llaman “María”.



b. Cuántas secretarias se llaman “María” y son solteras.
c. Cuántas secretarias se llaman “María” y son solteras menores de 25 años.
d. Promedio de edad de los supervisores casados.
e. Cuántos obreros son hombres.
f. Determine si hay al menos un hombre obrero llamado “Juan”.
Elabore la prueba de escritorio para el siguiente archivo de datos:

ESTADO
X NOMBRE SEXO EDAD CARGO
CIVIL
10 MARÍA 2 18 1 2
CARLOS 1 24 2 3
JOHN 1 22 2 3
JOSÉ 1 26 1 1
CLAUDIA 2 25 2 1
MARÍA 2 20 2 2
JUAN 1 19 1 1
JORGE 1 25 2 3
ELÍAS 1 30 1 1
MARÍA 2 28 2 2

10. Se tiene un archivo de datos con un número desconocido de registros, por registro se
tiene: edad, estado civil (1: Soltero, 2: Casado), nivel de estudio (1: Primaria, 2:
Secundaria, 3: Universidad) y sección del periódico que prefiere (1: Internacional, 2: Local,
3: Económica, 4: Cultural). Elaborar un algoritmo que calcule e imprima:
a. Promedio de edad de los que prefieren la sección internacional.
b. Porcentaje que representan los que prefieren la sección social.
c. Porcentaje de los casados que prefieren la sección económica.
d. Cuántos universitarios prefieren la sección cultural.

5.2. Estructuras Repetitivas Anidadas

Los ciclos anidados o nido de ciclos ocurren cuando dentro de un ciclo existe otro u otros ciclos. En
estos casos el ciclo más interno se activa tantas veces como el ciclo externo permita entrar en el
grupo de instrucciones.

Veamos que hace el siguiente algoritmo:



1. ALGORITMO CICLOS_ANIDADOS
2. VARIABLES: I, J (TIPO NUMÉRICO)
3. INICIO
4. PARA (I=1, 3, 1)
5. PARA (J=5, 7, 1)
6. IMPRIMA (I, J)
7. FINPARA
8. FINPARA
9. FININICIO
10. FIN

Note que la variable I toma los valores 1, 2 y 3, por cada uno de estos valores la Variable J toma los
valores 5, 6 y 7, es decir que el ciclo interno se activa 3 veces.

Veamos el seguimiento:

I J SE IMPRIME
1 5 1 5
1 6 1 6
1 7 1 7

AI terminar las iteraciones del ciclo interno (el de la J), se retorna nuevamente al ciclo externo (el
de la I) y la variable de iteración I toma el valor de dos (I = 2) lo cual obliga a entrar nuevamente al
ciclo anidado (la I no ha terminado sus iteraciones) y esto implica que la variable J inicie
nuevamente desde el comenzó, es decir, desde el valor de cinco.
El proceso se repite nuevamente, se sale del ciclo interno al ciclo externo y la variable I toma su
último valor que es tres y se efectúa la última iteración, esto es:

I J SE IMPRIME
2 5 2 5
2 6 2 6
2 7 2 7
3 5 3 5
3 6 3 6
3 7 3 7

En este momento se sale del ciclo de la J y se procede a incrementar la I, pero cuando esta ya
tomó todos sus valores. Se sigue con la instrucción siguiente a este ciclo (el de Ia I) que es
Terminar el proceso.
Nótese que por cada valor del ciclo más externo, el ciclo interno toma todos sus valores.


Ejemplo 1: Elaborar un algoritmo que imprima las tablas de multiplicar del 1 al 10, se debe
imprimir el multiplicando, el multiplicador y el producto.

Análisis:

5 * 4 = 20

Multiplicando Multiplicador Producto

1*1=1 2*1=2 ... 9*1=9 10 * 1 = 1O
1*2=2 2*2=4 ... 9 * 2 = 18 10 * 2 = 2O
1*3=3 2*3=6 ... 9 * 3 = 27 10 * 3 = 3O

1*9=9 2 * 9 = 18 ... 9 * 9 = 81 10 * 9 = 9O
1 * 10 = 10 2 * 10 = 2O ... 9 * 10 = 9O 10 * 10 = 100

Nótese que el multiplicando toma valores del 1 al 10, lo mismo que el multiplicador, pero el
multiplicando permanece en un valor mientras que el multiplicador toma todos sus valores, Io que
lleva a un nido de ciclos de los cuales el más externo generará el multiplicando y el mas interno el
multiplicador.


I: Índice del ciclo que generará el multiplicando
J: Índice del ciclo que generará el multiplicador
PROD: Producto del multiplicando y el multiplicador



1. ALGORITMO MULTIPLICACION
2. VARIABLES: I, J, PROD
3. INICIO
4. PARA (I= 1, 10, 1)
5. PARA (J= 1, 10, 1)
6. PROD = I * J
7. IMPRIMA (I, “*”, J, “=”, PROD)
8. FINPARA
9. FINPARA
10. FININICIO
11. FIN

Ejemplo 2: Elaborar un algoritmo que imprima la siguiente serie de números:
5 - 1 - 10
5 - 1 - 20
5 - 3 - 10
5 - 3 - 20
6 - 1 - 10
6 - 1 - 20
6 - 3 - 10
6 - 3 - 20

Análisis:

Aquí se encuentran tres variables distintas, la primera toma valores de 5 y 6, la segunda de 1 y 3, y
la tercera de 10 y 20.
Por simple inspección el ciclo más externo será el que genere el 5 y el 6 (no cambia de valores
mientras los otros si); luego irá el ciclo que genere el 1 y el 3 (no cambia mientras el último sí) y
por último, el más interno, será el que genere el 10 y el 20.


K: Índice del ciclo que generará el 5 y el 6
M: Índice del ciclo que generará el 1 y el 3
N: Índice del ciclo que generará el 10 y el 20



1. ALGORITMO SERIE
2. VARIABLES: K, M, N (TIPO NUMÉRICO)
3. INICIO
4. PARA (K= 5, 6, 1)
5. PARA (M= 1, 3, 2)
6. PARA (N= 10, 20, 10)
7. IMPRIMA (K, M, N)
8. FINPARA
9. FINPARA
10. FINPARA
11. FININICIO
12. FIN

Ejemplo 3:
Una empresa produce canecas, para ello cuenta con una máquina que produce Ios discos de la
parte inferior y otra que produce los cilindros de los lados. La máquina que produce los discos
inferiores puede elaborarlos de 5 tamaños diferentes con radios de 30, 40, 50, 60 y 70 cms. La que
produce los cilindros los puede hacer de alturas de 45, 60, 75, 90 cms.
Elabore un algoritmo que encuentre e imprima todos los posibles Volúmenes de las canecas que
puede producir la empresa.

Análisis:

Es un nido de ciclos, ya que por cada tipo de discos de la base se tienen diferentes alturas de
cilindros.
Volumen = Área de la Base * Altura
Área de la base = 3.1416 * R ** 2


R = Índice del ciclo que generará los radios
A = Índice del ciclo que generará las alturas de los cilindros
ÁREA = Campo variable que contendré las áreas de los discos
VOL = Campo variable que contendrá los volúmenes



1. ALGORITMO CANECAS
2. VARIABLES: R, AREA, A, VOL
3. INICIO
4. PARA (R= 30, 70, 10)
5. AREA = 3.1416 * (R ^2)
6. PARA (A= 45, 90, 15)
7. VOL = ÁREA * A
8. IMPRIMA (“Volumen”, VOL)
9. FINPARA
10. FINPARA
11. FININICIO
12. FIN

EJERCICIOS

Un almacén cuenta con 5 vendedores, cada vendedor vende 4 tipos de artículos, al final de la
semana por cada vendedor y por cada artículo se elabora un registro con la siguiente información
Código del vendedor.
Código del artículo.
Valor por unidad.
Número de unidades vendidas.
Elabore un algoritmo que imprima cuánto vendió cada vendedor, y el total vendido por el
almacén.
NOTA: Los registros se disponen de la siguiente forma:
Las cuatro primeras corresponden al primer vendedor, las cuatro siguientes al segundo vendedor,
y así sucesivamente.

Elaborar un algoritmo que genera e imprima un calendario, partiendo de este año. La impresión
debe hacerse así:
Año, mes, día, hora, minutos, segundos.
Debe tenerse en cuenta que hay meses con diferentes días y que hay años bisiestos.

En un edificio se quiere sistematizar la deuda de sus habitantes. El edificio tiene 35 pisos, por
cada piso se lee para cada apartamento la deuda de cada persona, no se conoce el número de
apartamentos ni el número de deudores por apartamento. Deberá existir una posibilidad de que
hallan personas que no deban. Elaborar un algoritmo que calcule e imprima:
Si la deuda no existe, un mensaje que diga “Persona no deudora”.
Si la deuda existe, la deuda del piso y la deuda total del edificio.


Promedio de deuda por piso.
Promedio de deuda total del edificio.

Elaborar un algoritmo que genere e imprima el siguiente grupo de números:

1, 1, 1
1, 4, 1
1, 9, 1
1, 16, 1
2, 1, 1
2, 4, 1
2, 9, 1
2, 16, 1
3, 1, 1
3, 4, 1
3, 9, 1
3, 16, 1

5.3. Estructura de Rompimiento de Control

Ciertas veces cuando se tiene un proceso establecido (ciclo), se necesita ejecutar una o varias
instrucciones que están por fuera del ciclo, se dice que esto es un rompimiento de control y se
implementa mediante un enunciado de decisión.

Ejemplo 1:
En un almacén cada que un vendedor realiza una venta, se elabora un registro con el código del
vendedor y la suma por la cual se realizó la venta; al final de la semana se clasifican estos registros
por el código del vendedor o sea que los registros correspondientes a un vendedor se colocan
juntos, luego las del otro vendedor y así sucesivamente.
No se conoce el número de ventas de cada vendedor. A cada vendedor le corresponde el 2.5% de
las ventas que realizo.
Elabore un algoritmo que imprima el código de cada vendedor y lo que se le debe pagar, también
se debe imprimir el total vendido por el almacén.

Análisis:

Para procesar estos registros se necesita un nido de ciclos, pero como no se conoce el número de
registros debemos utilizar ciclos mientras. Se necesita una suma parcial por cada vendedor, el cual
se debe inicializar en cero cada vez que cambie el código del vendedor.




Cod = Contendrá el código de los vendedores
Datos de entrada:
Vta = Contendrá el valor de la venta

SUMTOL = Suma total de las ventas

SUMVEN = Suma de las ventas de cada vendedor

PAGO = Lo que se debe pagar a cada vendedor

CODACT = Código actual, cuando Codact sea diferente de Cod implica que acabaron los registros
correspondientes a un vendedor, por lo tanto se debe calcular el pago.



1. ALGORITMO VENTAS
2. VARIABLES: SUMTOT, COD, VTA, CODACT, SUMVEN, PAGO (TIPO NUMÉRICO)
3. INICIO
4. SUMTOT = 0
5. IMPRIMA (“Ingrese el código del vendedor (Ingrese 0 para salir)”)
6. LEA (COD)
7. IMPRIMA (“Ingrese la venta”)
8. LEA (VTA)
9. MQ (COD<> 0)
10. CODACT= COD
11. SUMVEN=0
12. MQ (COD == CODACT)
13. SUMVEN = SUMVEN + VTA
14. IMPRIMA (“Ingrese el código del vendedor (Ingrese 0 para salir)”)
15. LEA (COD)
16. IMPRIMA (“Ingrese la venta”)
17. LEA (VTA)
18. FINMQ
19. PAGO = SUMVEN * 2.5 / 100
20. IMPRIMA (“Al vendedor”, CODACT, “se le pagará”, PAGO)
21. SUMTOT = SUMTOT + SUMVEN
22. FINMQ
23. IMPRIMA (“Total en ventas”, SUMTOT)
24. FININICIO
25. FIN

Ejemplo 2:
En una entidad educativa por cada estudiante se elaboró un registro con:

Código del Grupo.
Nombre del Estudiante.
Edad del Estudiante.
Estatura del Estudiante.

Los registros están ordenados por Grupo, no se conoce el número de registros. Elabore un
algoritmo que imprima los códigos de los grupos y su respectivo promedio de edad. Además se
debe imprimir el nombre dela persona más alta del grupo y su estatura.



Análisis:
Este es un ejercicio de rompimiento de control ya que cada que cambie el código del salón se debe
calcular el promedio de edad e imprimirlo.


Codgru = Contendrá el código del grupo
Datos de Nom = Contendrá el nombre de los estudiantes
entrada: Ed = Contendrá la edad de los estudiantes
Est = Contendrá la estatura de tos estudiantes

Sumed = Acumulador, contendrá la suma de las edades de las edades de los grupos
Cgru = Contador de los estudiantes de cada grupo
Promed = Promedio de Edad de cada grupo
Mayest = Contendrá la mayor estatura del colegio
Nommay = Contendrá el nombre de la persona más alta
Codact = Contendrá el código del Grupo con que se esté trabajando, cuando el código leído sea
diferente a este, se habrá cambiado de grupo.

1. ALGORITMO ENTIDAD_EDUCATIVA
2. VARIABLES: CODGRU, ED, EST, CODACT, MAYEST, NOMMAY, SUMED, CGRU, PROMED
(TIPO NUMÉRICO)
3. NOM (TIPO CARACTER)
4. INICIO
5. IMPRIMA (“Ingrese el código del grupo”)
6. LEA (CODGRU)
7. IMPRIMA (“Ingrese el nombre del estudiante”)
8. LEA (NOM)
9. IMPRIMA (“Ingrese la edad del estudiante”)
10. LEA (ED)
11. IMPRIMA (“Ingrese la estatura del estudiante”)
12. LEA (EST)
13. MQ (ED <> -1)
14. CODACT = CODGRU
15. MAYEST=0; SUMED=0; CGRU=0
16. MQ (CODACT == CODGRU)
17. CGRU = CGRU + 1
18. SUMEDA = SUMED + ED
19. SI (EST > MAYEST)
20. MAYEST = EST
21. NOMMAY = NOM


22. FINSI
23. IMPRIMA (“Ingrese el código del grupo”)
24. LEA (CODGRU)
25. IMPRIMA (“Ingrese el nombre del estudiante”)
26. LEA (NOM)
27. IMPRIMA (“Ingrese la edad del estudiante”)
28. LEA (ED)
29. IMPRIMA (“Ingrese la estatura del estudiante”)
30. LEA (EST)
31. FINMQ
32. PROMED = SUMED / CGRU
33. IMPRIMA (“Código del grupo”, CODACT, “Promedio”, PROMED)
34. FINMQ
35. IMPRIMA (“Persona más alta del colegio:”, NOMMAY, “mide”, MAYEST)
36. FININICIO
37. FIN

EJERCICIOS

1. Elaborar un algoritmo que produzca un reporte con los sueldos de una compañía, dando
subtotales por sucursal y total general de todas las sucursales, sabiendo que se lee por
registro:
Código del empleado.
Código de la sucursal.
Sueldo mensual.
La información está ordenada por sucursales. No se conoce el número de empleados. Se debe
imprimir:
Código de la sucursal y total pagado en esa sucursal.
Total pagado por la empresa.



6. PISTAS DE APRENDIZAJE

Recuerde que una división de un número entero por otro entero da como
resultado un número entero.

Recuerde que una división de un número real por un número entero da
como resultado un número real.

Recuerde que una división de un número real por otro real da como
resultado un número real.

Tenga en cuenta que, en una expresión de computador, debe escribir una
raíz en forma de potencia. Por ejemplo la raíz cuadrada de 9 sería:
9 ^ (1/2)

No olvide que un contador es una variable que se utiliza, como su
nombre lo indica, para contar las ocurrencias de algún evento. Esta se
debe inicializar en 0 y se debe incrementar en 1 antes de cerrar el ciclo.

No olvide que un acumulador es una variable que se encarga de guardar
el total de realizar una operación entre la variable acumulador y la
variable a acumular; y esta debe inicializarse en 0 antes de iniciar el ciclo.
Por ejemplo se quiere saber el salario total de una empresa:

totsal = 0
PARA (i = 1, n, 1)
LEA (sal)
totsal = totsal + sal
FINPARA
IMPRIMA (totsal)

Recuerde que un promedio es el resultado de dividir un acumulador
entre un contador. Por ejemplo un promedio de edades:

ac = 0
cont = 0
sw = 1
MQ (sw == 1)
cont = cont + 1
LEA (edad)


ac = ac + edad
LEA (sw)
FINMQ
prom = ac / cont
IMPRIMA (prom)

Recuerde que un porcentaje es el resultado de multiplicar un contador
específico por cien y dividirlo por un contador general. Por ejemplo
calcular el porcentaje de personas mayores de edad:

contgen = 0
contesp = 0
sw = 1
MQ (sw == 1)
contgen = contgen + 1
LEA (edad)
SI (edad >= 18)
contesp =contesp + 1
FINSI
LEA (sw)
FINMQ
porc = contesp * 100 / contgen
IMPRIMA (porc)

Recuerde que los contadores y acumuladores deben inicializarse en 0 y
deben incrementar dentro del ciclo.

Recuerde que los promedios y porcentajes se deben calcular por fuera
del ciclo.



7. GLOSARIO

Algoritmo. Lista de instrucciones para resolver un problema abstracto, es decir, que un número finito de
pasos convierten los datos de un problema (entrada) en una solución (salida).

Aplicación. Es un programa informático diseñado como herramienta para permitir a un usuario realizar uno
o diversos tipos de trabajo.

Booleano. Es un tipo de dato lógico que puede representar valores de lógica binaria; es decir, valores que
representen falso o verdadero.

Ciclo o bucle. Es una instrucción que se ejecuta repetidas veces dentro de un algoritmo, hasta que la
condición asignada a dicho ciclo deje de cumplirse.

Condición. Es una instrucción o grupo de instrucciones que determinan si se realizará la siguiente
instrucción o no.

Decremento. Es una disminución que se le realiza a una determinada variable.

Factorial. Se llama factorial de n al producto de todos los números naturales desde 1 hasta n.

Incremento. Es el aumento que sufre una determinada variable.

Instrucción. Es un conjunto de datos insertados en una secuencia estructurada o específica que el
procesador interpreta y ejecuta.

Iteración. Es la repetición de una serie de instrucciones dentro de un algoritmo.

Límite inferior. Es el máximo valor que puede tomar una variable dentro de un ciclo PARA.

Límite superior. Es el mínimo valor que puede tomar una variable dentro de un ciclo PARA.

Secuencia. Es una serie de pasos lógicos que tienen coherencia y un orden determinado.

Switch o switche. Generalmente, se utiliza en la condición de un ciclo MIENTRAS QUE o de un ciclo HAGA
MIENTRAS QUE. Si la condición se cumple, se ejecutan las instrucciones que hay dentro de dicho ciclo; de lo
contrario, salta hasta el final del ciclo. También suele usarse como condición en las estructuras de decisión.

Variables. Son espacios reservados en la memoria que, como su nombre indica, pueden cambiar de
contenido a lo largo de la ejecución de un programa.



8. REFERENCIAS BIBLIOGRÁFICAS

Castro, C. A., & Londoño Ciro, L. (1996). La experiencia de prácticas docentes de un curso de lógica
de programación. Medellín.

Joyanes Aguilar, L. (1996). Fundamentos de programación: Algoritmos y estructura de datos.
McGraw Hill/Interamericana de España S.A.

Oviedo Regino, E. M. (2004). Lógica de programación, segunda edición. ECOE ediciones: Bogotá.

Rios Castrillon, F. (1982). Apuntes sobre diagramación primera parte. Edición No. 4. Medellín.

Vásquez L., G. (1985). Lógica para programación de computadores. Medellín.

Villalobos S., J. A., & Casallas G., R. (2006). Fundamentos de programación, aprendizaje activo
basado en casos primera edición. Bogotá: Pearson educación de México S.A. de C.V.

Desarrollo Web. (s.f.). Recuperado el 8 de Abril de 2011, de
http://www.desarrolloweb.com/manuales/67/

Dr. Cruañas Sospreda, J., & Dr. Expósito Ricardo, C. (s.f.). Universidad Pedagógica Enrique José
Verona. Recuperado el 8 de Abril de 2011, de
http://www.varona.rimed.cu/revista_orbita/index.php?option=com_content&task=view&id=612
&Itemid=677

La Web del Programador. (s.f.). Recuperado el 8 de Abril de 2011, de
http://www.lawebdelprogramador.com/cursos/algoritmos/basico.php

Programación. (s.f.). Recuperado el 8 de Abril de 2011, de
http://www.programacion.com/articulo/introduccion_a_la_programacion_205

Universidad Nacional de Colombia sede Bogotá. (s.f.). Recuperado el 8 de Abril de 2011, de
http://www.virtual.unal.edu.co/cursos/ingenieria/2001839/docs_curso/contenido.html


Algoritmos i

Más contenido relacionado

Destacado (13)

Similar a Algoritmos i (20)

Más de cgviviana (20)

Algoritmos i