Algoritmos: Apuntes de Clase de

Nelson Francisco
Beltrn Franco
Procedimiento completo para crear algoritmos en la programacin Nelson Francisco
de computadores y probar su funcionamiento
Beltrn Franco
Este libro se escribi para que sea estudiado y consultado, por los estudiantes de educacin tcnica,
tecnolgica y universitaria que necesiten cursar materias relacionadas con la computacin. La literatura
relacionada con los temas previos a la programacin es escasa.
Apuntes de clase de
Apuntes de clase de ALGORITMOS

Ensear a pensar es complicado, cada persona, realiza esta actividad de acuerdo a sus experiencias
vividas, al entorno en el cual fue educado y en el medio en que se ha desenvuelto, sin olvidar su herencia
ALGORITMOS
gentica. Con este trabajo slo quiero mostrarle al lector cules son los pasos que puede seguir para
definir correctamente un algoritmo, y comprobar su funcionamiento antes de traducirlo a un Lenguaje
de programacin.

Todas las personas aplican inconscientemente algoritmos en las actividades que desarrolla en su vida
cotidiana. Para cocinar, para trabajar, estudiar, hacer sus oficios, pero en el momento en que se le pide
que escriba un algoritmo, se quedan bloqueadas, no saben por donde empezar. Por ejemplo, escriba un
algoritmo para amarrarse los cordones de los zapatos.

Por esta razn, antes de empezar a codificar un algoritmo en cualquier lenguaje de programacin, se le
debe ensear al estudiante cmo escribir sus algoritmos y comprobar su funcionamiento. Y no como
acostumbran la mayora de los maestros, saltarse la parte de los algoritmos, para empezar con un
lenguaje de programacin, dejando vacos en la formacin tcnica de los estudiantes que ms adelante
se vuelven insalvables.

Para desarrollar los ejercicios resueltos y propuestos, de cada captulo se utiliz el programa SmartDFD,
Escriba sus algoritmos de una manera sencilla y efectiva
que es de distribucin gratuita y se puede descargar de la pgina de internet de los autores del Aplique 5 pasos para comprobar que sus algoritmos funcionan
programa http://wiki.freaks-unidos.net/freedfd/index

correctamente
Los ejercicios desarrollados en cada captulo, pueden ser descargados de mi pgina de internet Ensear a pensar no es fcil, pero aplicar un algoritmo para
http://www.nefrabel.net/libros/algoritmos.php. escribir algoritmos si

Para poder descargar estos ejercicios, debe utilizar la clave que aparece en la primera pgina. Esta
clave la puede usar una sola vez, es nica e irrepetible, y le sirve para recibir informacin adicional y
otros ejercicios que he desarrollado para que sean estudiados por los lectores del libro.
Ejercicios
En prensa se encuentra el libro Apuntes de clase de C++ resueltos en
lnea
Captulo 4: Arreglos vii
Nelson Francisco Beltrn Franco
Apuntes de clase de
Algoritmos
viii Apuntes de clase de algoritmos
Captulo 4: Arreglos ix
Apuntes de clase de
Algoritmos
Nelson Francisco
Beltrn Franco
x Apuntes de clase de algoritmos
Apuntes de clase de algoritmos

Prohibida la reproduccin total o parcial

de esta obra, por cualquier medio, sin la
autorizacin escrita del autor y del editor.
Derechos Reservados 2011
Internet: http://www.nefrabel.net/libros/algoritmos.php
Email: algoritmos@nefrabel.net
ISBN:
Impreso en Bogot D.C., Colombia.

Captulo 4: Arreglos xi
A Mara Teresa y Agustn, por un pronto reencuentro.
Los crditos de este trabajo indiscutiblemente slo le corresponden a

Dios, a quien le agradezco por darme cada da una nueva oportunidad.
Los errores y equivocaciones si son de mi autora.
xii Apuntes de clase de algoritmos
Captulo 4: Arreglos vii
Agradecimientos
En la realizacin de este trabajo, recib el apoyo y respaldo de varias

personas que me animaron en todo momento, para no desfallecer
cuando por cansancio o dificultades cotidianas, llegu a pensar en
abandonar este proyecto. A todos ellos les doy un agradecimiento y
reconocimiento por su solidaridad.
A mi hermana Clara, quien me colabor con las continuas y repetidas

revisiones del material escrito, por su respaldo incondicional y sincero en
el desarrollo de este proyecto, y en todas las dems actividades y
dificultades de la vida, le estoy afectuosamente agradecido. A mi
hermana Bernarda, quien con su silenciosa y sigilosa presencia, me
demostr que siempre cuento con su compaa y apoyo, le doy un
carioso agradecimiento. De la misma forma a mis otras hermanas y
hermanos con quienes siempre he contado.
Quiero agradecer especialmente a Ernesto Carrillo Mora, quien ha

estado pendiente del desarrollo del proyecto, y en los momentos en que
pareca que se complicaban las cosas, estuvo presente, animndome y
respaldndome.
vii
Captulo 4: Arreglos ix
Contenido
Introduccin ............................................................................... 1
Captulo 1: Procesos secuenciales .............................................. 5
1 Procesos secuenciales ...................................................................5
1.1 Introduccin .............................................................................5
1.2 Anlisis de la informacin .......................................................... 6
1.3 Algoritmo .................................................................................9
1.4 Seudocdigo .......................................................................... 11
1.5 Diagrama de flujo ................................................................... 11
1.6 Prueba de escritorio ................................................................ 15
1.7 Operadores aritmticos ........................................................... 16
1.8 Expresiones lgicas ................................................................ 21
1.8.1 Operadores relacionales ....................................................... 21
1.8.2 Operadores lgicos .............................................................. 23
1.9 Tablas de certeza de los operadores lgicos ............................... 26
1.10 Procesos secuenciales ........................................................... 28
EJERCICIOS DE INICIACIN ..................................................... 29
E.1.1 .......................................................................................... 29
ix
x Apuntes de clase de algoritmos
E.1.2 .........................................................................................32
E.1.3 ..........................................................................................34
E.1.4 ..........................................................................................38
E.1.5 ..........................................................................................42
1.11 Resumen ...........................................................................49
EJERCICIOS PROPUESTOS ........................................................51
EP.1.1 ........................................................................................51
EP.1.2 ........................................................................................51
EP.1.3 ........................................................................................51
EP.1.4 ........................................................................................52
EP.1.2 ........................................................................................52
EP.1.5 ........................................................................................52
EP.1.6 ........................................................................................52
EP.1.7 ........................................................................................52
EP.1.8 ........................................................................................52
EP.1.9 ........................................................................................52
Captulo 2: Procesos de decisin ...............................................53
2 Proceso de toma de decisiones ....................................................53
2.1 Proceso Si _____; haga _____ ................................................53

x
Captulo 4: Arreglos xi
EJERCICIOS DE INICIACIN ..................................................... 54
E.2.1 .......................................................................................... 54
E.2.2 .......................................................................................... 57
E.2.3 .......................................................................................... 62
E.2.4 .......................................................................................... 68
E.2.5 .......................................................................................... 74
E.2.6 .......................................................................................... 79
2.2 Proceso Si _____ ; haga _____ ; sino haga _____ .................... 83
E.2.7 .......................................................................................... 83
E.2.8 .......................................................................................... 88
E.2.9 .......................................................................................... 94
2.3 Proceso conmutar ................................................................... 98
E.2.10 ...................................................................................... 100
E.2.11 ...................................................................................... 104
E.2.12 ...................................................................................... 108
2.4 Resumen ........................................................................... 119
EJERCICIOS PROPUESTOS ...................................................... 120
EP.2.1 ...................................................................................... 120
EP.2.2 ...................................................................................... 120
xi
xii Apuntes de clase de algoritmos
EP.2.3 ...................................................................................... 120
EP.2.4 ...................................................................................... 121
EP.2.5 ...................................................................................... 121
EP.2.6 ...................................................................................... 121
EP.2.7 ...................................................................................... 121
EP.2.8 ...................................................................................... 122
EP.2.9 ...................................................................................... 122
Captulo 3: Procesos repetitivos .............................................. 123
3 Procesos repetitivos ................................................................. 122
3.1 Proceso Para ________ hasta ________ de a ________ ........... 123
E.3.1 ........................................................................................ 124
E.3.2 ........................................................................................ 130
E.3.3 ........................................................................................ 133
E.3.4 ........................................................................................ 138
E.3.5 ........................................................................................ 144
3.2 Proceso Mientras Qu __________ haga ................................. 150
E.3.6 ........................................................................................ 151
E.3.7 ........................................................................................ 156
E.3.8 ........................................................................................ 161

xii
Captulo 4: Arreglos xiii
E.3.9 ........................................................................................ 166
E.3.10 ...................................................................................... 170
3.3 Resumen ........................................................................... 174
EP.3.1 ...................................................................................... 174
EP.3.2 ...................................................................................... 175
EP.3.3 ...................................................................................... 175
EP.3.4 ...................................................................................... 176
EP.3.5 ...................................................................................... 176
EP.3.6 ...................................................................................... 176
EP.3.7 ...................................................................................... 177
EP.3.8 ...................................................................................... 177
Captulo 4: Arreglos ................................................................ 179
E.4.1 ........................................................................................ 181
E.4.2 ........................................................................................ 186
E.4.3 ........................................................................................ 192
4.2 Resumen ........................................................................... 195
xiii
xiv Apuntes de clase de algoritmos
EP.4.1 ...................................................................................... 196
EP.4.2 ...................................................................................... 196
EP.4.3 ...................................................................................... 197
EP.4.4 ...................................................................................... 198
EP.4.5 ...................................................................................... 198
EP.4.6 ...................................................................................... 199
EP.4.7 ...................................................................................... 199
EP.4.8 ...................................................................................... 199
EP.4.9 ...................................................................................... 199
EP.4.10 ..................................................................................... 200
Bibliografa ............................................................................. 201
ndice ...................................................................................... 205
xiv
Apuntes de clase de algoritmos 1
Introduccin
Este libro se escribi para que sea estudiado y consultado, por los
estudiantes de educacin tcnica, tecnolgica y universitaria que
necesiten cursar materias relacionadas con la computacin. La literatura
relacionada con los temas previos a la programacin es escasa.
Los libros que se encuentran en el mercado, abordan la programacin

en diferentes lenguajes, pero no tienen en cuenta que los estudiantes
puedan tener dudas o vacos en el desarrollo o planteamiento de un
algoritmo, para luego ser traducido a un lenguaje de programacin
especfico. Cuando estaba empezando a realizar este trabajo, algunos
estudiantes de ingeniera de sistemas y de tecnologas en sistemas,
revisaron los borradores y comentaron, si en la universidad hubiera
encontrado un libro que explicara como plantear un algoritmo tan fcil,
no habra repetido la materia y programar hubiera sido ms sencillo.
Ensear a pensar es complicado, cada persona, realiza esta actividad de

acuerdo a sus experiencias vividas, al entorno en el cual fue educado y
en el medio en que se ha desenvuelto, sin olvidar su herencia gentica.
Con este trabajo slo quiero mostrarle al lector cules son los pasos que
puede seguir para definir correctamente un algoritmo, y comprobar su
funcionamiento antes de traducirlo a un Lenguaje de programacin.
Todas las personas aplican inconscientemente algoritmos en las

actividades que desarrolla en su vida cotidiana. Para cocinar, para
trabajar, estudiar, hacer sus oficios, pero en el momento en que se le
pide que escriba un algoritmo, se quedan bloqueadas, no saben por
donde empezar.
Por esta razn, antes de empezar a codificar un algoritmo en cualquier

lenguaje de programacin, se le debe ensear al estudiante cmo
escribir sus algoritmos y comprobar su funcionamiento. Y no como
2 Apuntes de clase de algoritmos
acostumbran la mayora de los maestros, saltarse la parte de los

algoritmos, para empezar con un lenguaje de programacin, dejando
vacos en la formacin tcnica de los estudiantes que ms adelante se
vuelven insalvables.
Pensando en los estudiantes que se encentran con estos problemas en el

curso de su formacin tcnica y universitaria, se escribi este libro. El
contenido del libro, consiste en una parte terica puntual, y ejercicios
resueltos con cierto grado de dificultad, que le permiten al estudiante
observar como se aplican los conceptos que se exponen en los captulos.
El primer captulo trabaja los procesos secuenciales, y la metodologa

que se debe aplicar para resolver los problemas que se presentan
cuando se va a definir un algoritmo.
El segundo captulo contiene los procesos de decisin. Se encuentran

varios ejercicios resueltos, en todas sus etapas, que le permiten al lector
comprobar que estos pasos realmente son apropiados para llegar a una
respuesta correcta.
El captulo tercero desarrolla los procesos secuenciales, aplicando los

conceptos estudiados en los dos primeros captulos, utilizando la
metodologa de ejercicios resueltos.
El cuarto capitulo maneja los conceptos relacionados con los arreglos,

desarrollando ejercicios que le permiten al estudiante aprender a definir
algoritmos para manejar volmenes de informacin un poco ms
complicados.
Para desarrollar los ejercicios resueltos y propuestos, de cada captulo

se utiliz el programa SmartDFD, que es de distribucin gratuita y se
puede descargar de la pgina de internet de los autores del programa
http://wiki.freaks-unidos.net/freedfd/index
Los ejercicios desarrollados en cada captulo, pueden ser descargados de

mi pgina de internet http://www.nefrabel.net/libros/algoritmos.php
Para poder descargar estos ejercicios, debe utilizar la clave que aparece
en la primera pgina. Esta clave la puede usar una sola vez, es nica e
irrepetible, y le sirve para recibir informacin adicional y otros ejercicios
que he desarrollado para que sean estudiados por los lectores del libro.
Los comentarios relacionados con el contenido del libro, o los ejercicios

pueden ser enviados a la direccin de correos: algoritmos@nefrabel.net
Captulo 1: Procesos secuenciales 5
1 Procesos secuenciales
1.1 Introduccin
En el diseo de programas para computadores hay tres elementos que

es necesario tener en cuenta:
Entrada de datos.
Procesamiento de datos
Obtencin de resultados
Los datos de entrada corresponden a la informacin inicial que se tiene

de una situacin determinada, que se quiere sistematizar o modificar la
forma como est sistematizada o como est funcionando manualmente.
El procesamiento de datos consiste en el anlisis y manejo que se debe

hacer a los datos de entrada, para obtener algunos datos intermedios,
que permiten llegar a la respuesta deseada o los resultados finales.
La obtencin de resultados, es el paso final del proceso que se realiza y

que proporciona la informacin que se espera obtener despus de haber
analizado y trabajado con los datos iniciales.
Cuando se trabaja solucionando los inconvenientes que se presentan en

los programas de computadores, es necesario conocer todas las
estructuras lgicas que se pueden utilizar para hacer que el computador
pueda ejecutar de la manera ms rpida y eficiente los cdigos, sin
presentar errores que hagan que fallen los programas. Estas fallas o
errores son la consecuencia de haberse equivocado en el momento de
escribir el algoritmo que va a servir para resolver el problema, o en el
momento de escribir el cdigo en el lenguaje que se est trabajando.
Estas situaciones errneas se presentan porque el programador
desconoce o no sabe aplicar las estructuras bsicas, para hacer los
algoritmos que definen los diferentes caminos y pasos que debe seguir
el computador para ejecutar el correcto procesamiento de los datos.
En este libro se van a tratar las estructuras utilizadas para escribir

correctamente un algoritmo.
Para evitar estos inconvenientes en el momento de ejecutar un

programa, es importante conocer todos los procesos lgicos que se
utilizan para el procesamiento de la informacin, as como los pasos que
se requieren para verificar que los algoritmos escritos por el
programador estn bien utilizados y arrojan los resultados esperados.
En este primer captulo, se va a explicar el funcionamiento del proceso

secuencial y las herramientas o procedimientos que permiten probar,
que el trabajo que se est haciendo es correcto y procesa la informacin
de la manera que se est pensando.
Se aplica una metodologa que le permita al programador, seguir una

secuencia lgica adecuada para resolver los problemas que se presentan
en el momento previo a escribir el cdigo de un programa en cualquier
lenguaje; estos pasos son: el anlisis de la informacin, definir cul es el
algoritmo a aplicar, escribir el seudocdigo, realizar el diagrama de flujo
y hacer la prueba de escritorio para comprobar que el trabajo est bien
hecho y est entregando los resultados esperados.
1.2 Anlisis de la informacin
Cuando se necesita un programador de computadores, es porque se

quiere sistematizar un procedimiento que se est ejecutando
manualmente o se necesita modificar un cdigo ya existente.
Generalmente el usuario no sabe definir cul es el problema. Slo dice

quiero sistematizar esta actividad, o quiero que modifiquen este
programa, o esta pgina web, para que haga las cosas de otra forma
diferente a como las est ejecutando; pero l no define el problema en
trminos precisos que entienda el profesional o experto que va a
contratar para que realice esta tarea. Esta definicin del problema la
debe hacer el programador que est ejecutando el proyecto, de la

manera ms precisa posible, teniendo en cuenta todas las posibilidades
y requerimientos que desea el cliente.
Este proceso de analizar la informacin es muy importante y se toma

muy a la ligera, porque se debe tener bien claro qu es lo que quiere y
necesita la persona o la empresa que va a mandar hacer un programa, y
qu es lo que ha entendido quien va a hacer la programacin. Porque es
muy frecuente que cuando se termina el trabajo de la programacin y se
va a entregar el programa ya funcionando, el cliente que ha mandado
hacer la aplicacin dice, pero yo quera que hiciera esto o aqullo y no lo
est haciendo, y el programador contesta, pero eso fue lo que usted me
dijo que hiciera, o fue lo que yo le entend.
Para evitar que se presente esta situacin, es conveniente que se realice

un documento por escrito que contenga la informacin que suministra el
cliente, qu quiere que haga el programa o qu quiere que se haga con
esta informacin y por ltimo qu resultados quiere que le entregue el
programa ya terminado y funcionando.
Es al programador de computadores o desarrollador de software, a

quien le corresponde plantear el problema a solucionar, con base en
todos los datos suministrados por el cliente y los observados por l en
las diferentes visitas realizadas para hacer el levantamiento de la
informacin y procesos en el campo de trabajo.
Cuando ya se conoce cul es la situacin problema, el paso a seguir es

determinar con qu se cuenta para empezar el trabajo, esto quiere decir
qu debemos conocer, cul es la informacin inicial que se tiene para
empezar a hacer el estudio o anlisis.
Luego se debe saber cules son los procesos que hay que realizar y qu
datos intermedios se deben conocer; que no son los resultados finales,
pero son pasos o datos que van a permitir llegar a los resultados finales
que se quieren obtener.
Por ejemplo, si se quiere preparar un suculento sancocho de pescado,

no se van a introducir todos los ingredientes en el recipiente y luego
colocarlos en el fuego, porque lo que se tendra al final no sera un
sancocho de pescado y mucho menos suculento. Es claro que hay toda
una serie de pasos y procedimientos que se deben seguir para que este
plato sea el esperado. Si se alteran o se omiten, el resultado es incierto
e inesperado.
Para solucionar un problema de programacin de computadores o

escribir el cdigo de un programa, se debe seguir un procedimiento
lgico, conociendo cules pasos van primero, cules despus y qu hace
cada uno de ellos, porque no se pueden realizar de manera
desordenada debido a que el resultado es sorpresivo, y corregirlo
conlleva redisear el algoritmo y reescribir el cdigo y esto representa
tiempo y dinero que no va a asumir el cliente, sino el programador o la
empresa que est realizando el proyecto. Si estos errores son cometidos
por un programador que trabaja en una empresa, es muy probable que
pierda su empleo y, si es el dueo de la compaa, pues no va a tener
xito en su trabajo.
Si se tienen en cuenta estas indicaciones antes de empezar a escribir el

algoritmo, se puede estar seguro de que se estn contemplando las
diferentes alternativas y se est minimizando el nmero de posibilidades
de que el algoritmo est errado o presente inconsistencias.
Ejemplo
En una oficina los empleados se encuentran trabajando normalmente,

pero inesperadamente, la oficina se queda a oscuras. Una de las
personas presentes prende y apaga nuevamente el interruptor del fluido
elctrico en la oficina y puede comprobar que el bombillo no prende y, al
salir de la oficina, comprueba que las otras oficinas aledaas tienen

iluminacin.
Qu fue lo que hizo el empleado al verificar si prenda el bombillo y

comprobar si las otras oficinas contiguas estaban iluminadas?
Estaba recolectando la informacin necesaria para saber qu estaba

pasando y cules son las alternativas para solucionar el problema. En
pocas palabras estaba recolectando la informacin de campo.
Con esta informacin ya est preparado para definir el problema y saber

qu necesita para solucionarlo.
El problema es: se da la bombilla que est colocada, hay que

cambiarla por una nueva.
Qu se necesita para solucionarlo?
un bombillo.
una banca o una escalera para pararse y poder cambiar el
bombillo.
Ya se sabe qu est pasando, qu se necesita y cmo se debe hacer,

entonces ahora si se puede empezar a definir el algoritmo.
1.3 Algoritmo
El segundo paso para buscar la solucin a un problema de programacin

de computadores es realizar el algoritmo que defina los pasos finitos que
se deben ejecutar en un orden lgico establecido, despus de tener clara
la informacin que se tiene para empezar, as como qu procesos,
herramientas o datos se requieren como informacin intermedia, para
poder llegar a los resultados finales.
En pocas palabras, un algoritmo es una receta que se debe realizar con

pasos finitos, ordenados, que permiten obtener un resultado especfico,
teniendo en cuenta los ingredientes necesarios para el respectivo platillo
que indica la receta y en qu forma y momento se deben aplicar para no
llegar al final a un resultado diferente y adems inesperado, teniendo
resultados equivocados, que van a hacer que se tenga que empezar
nuevamente el trabajo, ocasionando prdida de tiempo y dinero.
Ejemplo
Continuando con el ejemplo anterior, y aplicando la definicin de

algoritmo, se deben definir los pasos que se van a ejecutar para poder
restablecer nuevamente la iluminacin de la oficina. Los pasos
necesarios a seguir, son los siguientes:
Paso 1: Buscar el bombillo de repuesto

Paso 2: Desconectar el fluido elctrico
Paso 3: Colocar una escalera, cajn o banca debajo del bombillo
Paso 4: Subirse sobre la escalera o cajn
Paso 5: Desenroscar el bombillo averiado
Paso 6: Enroscar el nuevo bombillo
Paso 7: Bajar del cajn
Paso 8: Encender el fluido elctrico
Si se siguen estos pasos en este orden, es seguro que el empleado

podr restablecer nuevamente la iluminacin de la oficina para continuar
trabajando. Este es el algoritmo que sirve para cambiar el bombillo.
Cambiar el orden de los pasos no va a permitir que se pueda lograr el
objetivo que se quiere lograr: restablecer la iluminacin de la oficina.
Todas las personas actan de acuerdo a algoritmos que se establecen en

la mente. Se tienen algoritmos para baarse, para vestirse, para
cocinar, trabajar, estudiar, para todo y se siguen inconscientemente.
1.4 Seudocdigo
El paso siguiente es realizar el seudocdigo. El seudocdigo es una

forma de expresar las instrucciones que se realizan en el algoritmo, de
la manera ms parecida a como se expresaran en un lenguaje de
programacin.
El realizar el seudocdigo permite fcilmente escribir despus o traducir

el cdigo en un lenguaje de programacin determinado, con mayor
fluidez y rapidez.
Ejemplo
Buscar el bombillo de repuesto.

Desconectar el fluido elctrico.
Colocar una escalera o cajn debajo del bombillo.
Subirse sobre la escalera o cajn.
Desenroscar el bombillo averiado.
Enroscar el nuevo bombillo.
Bajar del cajn.
Encender el fluido elctrico.
1.5 Diagrama de flujo
Si se expresan las ideas por medio de dibujos y diagramas, es ms

sencillo que sean comprendidas por las personas a las cuales se las
presentamos.
Los diagramas de flujo son representaciones grficas de los algoritmos.

Esta herramienta hace que cuando se trabaja con algoritmos
complicados, se pueda ver con ms claridad el camino a seguir y sea
fcil verificar cul es la forma como se va a comportar el flujo de la
informacin.
Como su nombre lo indica, un diagrama de flujo muestra cules son los

caminos que se deben seguir para ejecutar una actividad o un proceso.
Permite ver la seleccin de alternativas de decisin, de acuerdo a los
resultados intermedios que se van presentando a medida que se hace el
recorrido por el diagrama, y as poder verificar que se estn realizando
las instrucciones correctamente.
El realizar el diagrama de flujo cuando se est trabajando en un

proyecto de programacin de computadores, es til porque le permite al
programador encontrar nuevas alternativas que puede usar en el
algoritmo ya que es ms fcil verlas grficamente.
Existen en el mercado programas que permiten realizar los diagramas

de flujo y verificar los resultados intermedios y finales del algoritmo. Los
ejercicios que se realizaron en este libro fueron probados con el
programa Smart DFD 1.0, es un software gratuito de libre distribucin,
que se puede descargar de internet o la versin libre actualizada
FreeDFD1.1, tambin gratuita se puede descargar de http://wiki.freaks-
unidos.net/freedfd/index#c-digo-fuente. Fue realizado por estudiantes
de la Universidad del Magdalena en Santa Marta - Colombia.
Para el diseo de los diagramas de flujo se utilizan diferentes dibujos o

smbolos que sirven para indicar las operaciones que se ejecutan en un
programa de computacin. Estos dibujos le permiten al programador
identificar qu tipo de instruccin tiene que ejecutar, si se debe tomar
una decisin, realizar un ciclo repetitivo, seguir un proceso secuencial,
leer un arreglo, ejecutar una operacin, presentar un mensaje por
pantalla o realizar una impresin.
En la Tabla 1.1 se pueden ver las convenciones y smbolos utilizadas

para el diseo de los diagramas de flujo. Si se encuentra la misma
convencin en dos diagramas de flujo diferentes, sta tiene el mismo
significado y representa la misma accin.
valo Para iniciar y

terminar
Rectngulo Para realizar

clculos o procesos
Trapecio Para entrada

manual de datos
Paralelogramo Para entrada de

datos
Rombo Para toma de
decisiones
Crculo pequeo Para un conector

Polgono pequeo Para un conector
que pasa a otro
pgina
Hexgono Para un ciclo

repetitivo
Para una salida por
pantalla
Para una salida por

impresora
Flecha Para una conexin
Rectngulo Para una subrutina

o funcin
Tabla 1.1
Ejemplo
Inicio
Buscar el bombillo de
repuesto
Desconectar el fluido
elctrico
Colocar una escalera o

cajn debajo del bombillo
Subirse sobre la escalera

o cajn
Desenroscar el bombillo
averiado
Enroscar el nuevo
bombillo
Bajar del cajn
Encender el fluido
elctrico
Terminar
Figura 1.1
En la Figura 1.1 del ejemplo, se puede ver la forma como se aplican

algunos de los smbolos que se encuentran en la Tabla 1.1.
Inicio
Este smbolo se utiliza para indicar el punto de inicio del
diagrama de flujo o el final del mismo.
La flecha indica la conexin entre dos smbolos y la direccin que sigue

la informacin en el diagrama.
Bajar del
El rectngulo representa la ejecucin de una operacin o
cajn
instruccin, o la asignacin de un valor a una variable.
1.6 Prueba de escritorio
Cuando se ha realizado el anlisis del problema y se tiene claro qu

operaciones se deben hacer, qu decisiones se deben tomar, as como
qu variables intervienen y qu resultados se esperan obtener, ya se
est listo para definir el algoritmo. Teniendo creado el algoritmo, se
puede escribir el seudocdigo, realizar el diagrama de flujo y por ltimo
hacer la prueba de escritorio para comprobar su funcionamiento y
finalmente verificar los resultados que arroja.
En conclusin la prueba de escritorio es la prueba final del algoritmo,

antes de pasar al lenguaje de programacin. El trabajo realizado hasta
este momento, es previo a escribir el cdigo en cualquier lenguaje de
programacin.
En el desarrollo de los algoritmos para resolver problemas de diseo de

programas para computadoras o desarrollo de software, se van a utilizar
variables y constantes.
Una variable es un espacio temporal de memoria, donde se va a

almacenar la informacin mientras se est ejecutando el algoritmo o el
programa. Esta informacin se puede cambiar durante la ejecucin del
programa.
Una contante es un valor fijo que se guarda en un espacio de memoria

en forma temporal, mientras se est ejecutando el algoritmo o el
programa. Esta informacin no se puede cambiar durante la ejecucin
del programa.
Un programa es un conjunto de instrucciones que sigue el computador,

para poder alcanzar un resultado especfico. Los programas estn
escritos en lenguajes de programacin, que pueden ser entendidos por
el computador.
Cuando se est escribiendo un programa de computador, es necesario

utilizar diferentes estructuras para controlar el flujo de las operaciones a
realizar y de las decisiones que se deben tomar. Hay procesos que son
secuenciales, condicionales y repetitivos. La correcta aplicacin de estos
procesos se conoce como programacin estructurada. Para cada uno de
estos procesos es necesario utilizar smbolos diferentes y estructuras
lgicas diferentes, ya que en cada uno de ellos los datos se manejan de
manera completamente diferente.
1.7 Operadores aritmticos
Para realizar las operaciones matemticas es necesario utilizar los

operadores aritmticos, que permiten hacer las operaciones aritmticas
entre constantes, nmeros y variables. Cuando se realizan estas
operaciones se obtiene como resultado un nmero.
En la Tabla 1.2 se encuentran los operadores aritmticos, y se indica

qu clase de operacin se puede realizar con cada uno de ellos. Estos
operadores se utilizan en los algoritmos, seudocdigos y diagramas de
flujo.
Operadores aritmticos
Operador Operacin
** Exponenciacin
* Multiplicacin
/ Divisin
+ Suma
- Resta
Mod Mdulo (residuo)
Div Divisin entera
Tabla 1.2
Algunos ejemplos de la aplicacin de estos operadores son:
Exponenciacin: 7 ** 2 = 49
Multiplicacin: 9 * 11 = 99
Divisin: 15 / 2 = 7.5
Suma: 3 + 2.5 = 5.5
Resta: 3 - 2.5 = 0.5
Mdulo: 7 mod 2 = 1
Divisin entera: 7 div 2 = 3
El resultado que se obtiene con mod es el residuo de la divisin, en el

ejemplo anterior si 2 en 7 est 3 veces, queda 1 de residuo.
Cuando se realizan operaciones con los operadores aritmticos, se

presentan expresiones ms complicadas que estos ejemplos que se
acaban de hacer, entonces en esos casos se debe respetar la jerarqua o
prelacin en el orden de realizar las operaciones. Se puede observar la

Tabla 1.3 en donde se encuentra la prelacin de mayor a menor para
cada uno de los operadores aritmticos.
Jerarqua operadores aritmticos

Operador Operacin Jerarqua
() Parentesis Mayor
** Exponenciacin
*, /, mod, div Multiplicacin, divisin, mdulo, divisin entera
+, - Suma, resta Menor
Tabla 1.3
En una expresin la operacin que se realiza primero, es la que se

encuentran entre parntesis, luego sigue la exponenciacin porque tiene
la mayor prelacin, luego siguen la multiplicacin, divisin, mdulo,
divisin entera que tienen el mismo grado de jerarqua y por ltimo la
suma y resta que tienen la menor prioridad.
Para resolver una expresin aritmtica se deben cumplir los siguientes

puntos:
1. Primero se desarrollan las expresiones que se encuentran entre

parntesis, respetando la jerarqua de los operadores aritmticos.
Si hay operaciones que se encuentran entre parntesis que estn
anidados, entonces se empieza desde el parntesis que se
encuentra en el ltimo nivel de anidamiento.
Ejemplo:
(((4+3)/2)*5)**2
(((7)/2)*5)**2
((3.5)*5)**2
(17.5)**2
306.25
2. La jerarqua de los operadores aritmticos se aplica de izquierda a

derecha.
Ejemplo:
37+9
-4 + 9
5
Ejemplo:
3*7+9/28
21 + 9 / 2 8
21 + 4.5 8
25.5 8
25.5 - 8
17.5
Ejemplo:
4 ** 2 * 3 + 7 / 4
16 * 3 + 7 / 4
48 + 7 / 4
49.75
Ejemplo:
6 + (4 ** 2 * 3 + 7 / 4) mod 3 + 7 * 9
6 + (16 * 3 + 7 / 4) mod 3 + 7 * 9
6 + (48 + 7 / 4) mod 3 + 7 * 9
6 + (48 + 1.75) mod 3 + 7 * 9
6 + (49.75) mod 3 + 7 * 9
6 + 1.75 + 7 * 9
6 + 1.75 + 63
7.75 + 63
70.75
Ejemplo:
(6 + (4 ** (2 * 3 + 7) / 4)) div ((3 + 7) * 9)
(6 + (4 ** (6 + 7) / 4)) div ((3 + 7) * 9)
(6 + (4 ** (13) / 4)) div ((3 + 7) * 9)
(6 + (67108864 / 4)) div ((3 + 7) * 9)
(6 + (16777216)) div ((3 + 7) * 9)
(16777222) div ((3 + 7) * 9)
(16777222) div ((10) * 9)

16777222 div 90
186413
1.8 Expresiones lgicas
Las expresiones lgicas tambin conocidas como booleanas, estn

compuestas por nmeros, constantes, variables y operadores
relacionales o lgicos. Cuando se evalan estas expresiones, el
resultado que se obtiene es verdadero o falso. Se utilizan en los
procesos de decisin y en una clase de proceso repetitivo, de acuerdo al
valor que d despus de evaluar la expresin, se determina qu camino
o alternativa se sigue en el algoritmo.
1.8.1 Operadores relacionales
Esta clase de operadores se utiliza para comparar dos nmeros,

constantes, variables, expresiones alfanumricas o expresiones
aritmticas. Cuando se validan las expresiones con operadores
relacionales se obtienen solamente dos resultados verdadero o falso.
Operadores relacionales
Operador Operacin
= Igual a
<> Diferente a
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que
Tabla 1.4
Algunas expresiones como ejemplos con estos operadores son:

Ejemplo:
5 = 3; Falso
e <> E; Verdadero
5 > 3; Verdadero
5 < 3; Falso
5 >= 3; Verdadero
9 <= 3; Falso
Ejemplo:
X = -5
Y=3
(X * 9) > (-Y / 13)
-45 > -0.230769
Falso
Ejemplo:
N=5
M=2
(N * 9 + 7 * 2) / M <> (M / 3 + 4 / 6) 4 ** (0.5 + 2 * M)
(45 + 7 * 2) / M <> (M / 3 + 4 / 6) 4 ** (0.5 + 2 * M)
(45 + 14) / M <> (M / 3 + 4 / 6) 4 ** (0.5 + 2 * M)

(59) / M <> (M / 3 + 4 / 6) 4 ** (0.5 + 2 * M)
29.5 <> (M / 3 + 4 / 6) 4 ** (0.5 + 2 * M)
29.5 <> (0.666667 + 4 / 6) 4 ** (0.5 + 2 * M)
29.5 <> (0.666667 + 0.666667) 4 ** (0.5 + 2 * M)
29.5 <> (1.333333) 4 ** (0.5 + 2 * M)
29.5 <> (1.333333) 4 ** (0.5 + 4)
29.5 <> (1.333333) 4 ** 4.5
29.5 <> (1.333333) 512
29.5 <> -510.667
Verdadero
1.8.2 Operadores lgicos
Estos operadores hacen posible establecer condiciones complejas,

partiendo de expresiones sencillas. Los operadores lgicos son (Y) que
corresponde a la conjuncin, (O) a la disyuncin y (NO) a la negacin.
En la Tabla 1.5, se encuentran los operadores lgicos, la prioridad o
jerarqua que ejercen en las expresiones lgicas y qu significan.
Jerarqua operadores lgicos

Operador Operacin Jerarqua Significado
No P; No P; P Mayor No es cierto P
Y P y Q; P & Q; P Q P tambin Q
O P o Q; P Q Menor Al menos P al menos Q
Tabla 1.5
El operador No, hace las veces de trmino de enlace y niega la

proposicin, ejemplo:
Sea la proposicin P El da esta soleado. Al salir a la calle se verifica

que el cielo est nublado y est lloviendo. Entonces la proposicin no es
cierta, y se expresa de la siguiente forma:
No (El da est soleado.)
Da como resultado: El da no est soleado.
El operador No, es una negacin de la proposicin y es el trmino de

enlace, ejemplo:
La luna no est hecha de queso.
La proposicin es la luna est hecha de queso, el trmino de enlace es

no. Se tiene como resultado una negacin.
El operador y forma una conjuncin, tambin cumple la funcin de

trmino de enlace, por ejemplo si se tienen las proposiciones P el da
est soleado y la proposicin Q est haciendo calor, entonces el papel
que desempea el operador o trmino de enlace es:
P Q
P &Q
P yQ
Se puede escribir de estas tres formas y significan lo mismo. La

proposicin es:
El da est soleado y est haciendo calor.
El operador o forma una disyuncin, cumple la funcin de trmino de

enlace, por ejemplo si se tienen las proposiciones P Roco est en
Bogot y la proposicin Q no viaj el fin de semana, entonces el papel
que desempea el operador o trmino de enlace es:
P Q
PoQ
Se puede representar de estas dos formas y tienen el mismo significado.

La proposicin entonces queda:
Roco est en Bogot o no viaj el fin de semana.

1.9 Tablas de certeza de los operadores lgicos
Para poder saber si las proposiciones son ciertas o falsas, se utilizan las
tablas de certeza. A continuacin se encuentran las tablas de certeza,
para los tres operadores o trminos de enlace vistos.
Negacin
P P
Cierta Falsa
Falsa Cierta
Tabla 1.6
En el ejemplo 5 > 3 la proposicin es cierta, y al hacer la negacin

(5>3) es falsa, porque cinco es mayor que tres. Cuando la proposicin
es Falsa, 5 < 3 al hacer la negacin (5<3), pasa a ser cierta. En
conclusin la negacin de una proposicin cierta es falsa y la negacin
de una proposicin falsa es cierta.
Esta es la tabla para el caso de la conjuncin (Y).
Conjuncin (Y)
P Q P Q
Cierta Cierta Cierta
Cierta Falsa Falsa
Falsa Cierta Falsa
Falsa Falsa Falsa
Tabla 1.7
Para que la proposicin sea cierta, se requiere que las dos proposiciones
que est uniendo el operador o trmino de enlace sean ciertas. Si
alguna de las dos no es cierta, la proposicin es falsa.
En este ejemplo (3 = 9/3) 4 es divisible por dos, las dos proposiciones

son ciertas, entonces la conjuncin es cierta.
Si (3 = 9/2) 4 es divisible por dos, la primera es falsa y la segunda es

cierta, entonces la conjuncin es falsa. La conjuncin es cierta si y solo
si las dos proposiciones son ciertas.
Para la disyuncin (o) se tiene la Tabla 1.8
Conjuncin (O)
P Q P Q
Cierta Cierta Cierta
Cierta Falsa Cierta
Falsa Cierta Cierta
Falsa Falsa Falsa
Tabla 1.8
Utilizando las proposiciones del ejemplo anterior, Si (3 = 9/2) v 4 es

divisible por dos, la primera es falsa y la segunda es cierta, entonces la
conjuncin es cierta. La disyuncin de dos proposiciones es cierta si y
solo si al menos una de las dos proposiciones es cierta.
Esta informacin es importante en programacin y computacin no slo

en el diseo de algoritmos, tambin se utiliza en compuertas o circuitos
lgicos.
A continuacin est la Tabla 1.9 que contiene las prioridades o

jerarquas de los operadores aritmticos, relacionales y lgicas.
Jerarqua de los operadores

Operador Jerarqua
() Mayor
**
*, /, mod, div
+, -
=, <>, <, >, <=, >=
No
Y
O Menor
Tabla 1.9
1.10 Procesos secuenciales
La manera ms sencilla de realizar un proceso es de forma secuencial, y

esto se presenta cuando no se tienen que evaluar varias opciones o
realizar un conjunto de operaciones varias veces consecutivas. El nico
requisito de este proceso, es que las instrucciones estn debidamente
ordenadas y se realicen una a continuacin de la otra, para evitar
sorpresas desagradables en el momento de tener las respuestas o
resultados. Esta es la estructura ms sencilla que se utiliza en el
momento de estar programando. El ejemplo anterior de cambiar un
bombillo, corresponde a un proceso secuencial, porque no hubo
necesidad de evaluar ningn valor para seguir una ruta especfica dentro
del algoritmo o realizar procesos repetitivos.
Se inician los ejercicios estudiando esta clase de procesos y explicando

de forma clara y sencilla, en qu consiste cada una de las instrucciones
y qu resultados se obtienen con ellas, de la misma manera como se
aplican los operadores aritmticos, lgicos y relacionales que se van a
utilizar en el transcurso del libro.
EJERCICIOS DE INICIACIN
E.1.1 Cree un algoritmo para sumar dos nmeros.
Anlisis de la informacin
Se tienen dos nmeros que se necesita sumar y se sabe qu

operaciones se desean realizar con ellos. En este caso se conocen los
datos de entrada, qu se debe hacer con ellos y qu resultados se
espera que presente el algoritmo al final.
Algoritmo
Como se tiene claro con qu informacin se empieza a trabajar y qu se

debe hacer con ella, ya se puede escribir el algoritmo.
Paso 1: Lea el primer nmero

Paso 2: Lea el segundo nmero
Paso 3: Realice la suma del primer nmero y del segundo nmero y
gurdelo en una variable llamada suma
Paso 4: Presente el resultado de la suma de los dos nmeros guardado
en la variable suma.
Ya se tiene el algoritmo, como se puede ver es una secuencia ordenada

de pasos que se deben realizar para obtener el resultado esperado. Este
tipo de algoritmo es para un proceso secuencial.
Como ya se mencion un proceso secuencial es el que se utiliza para

ejecutar los algoritmos que realizan instrucciones que no requieren
decisiones o procesos repetitivos.
Seudocdigo
Leer primer nmero

Leer segundo nmero

Haga suma igual a primer nmero ms segundo nmero
Presentar suma
Diagrama de flujo
Para realizar el diagrama de flujo, se parte de las instrucciones escritas

en el seudocdigo, entonces:
Iniciar
Primer nmero
Segundo nmero
Suma = Primero + Segundo
Suma
Terminar
Figura 1.2
Iniciar
Con el smbolo se da comienzo al diagrama de flujo y a los
procesos que se quieren realizar con l.
Los smbolos Primer nmero y Segundo nmero se utilizan para indicar

que se estn leyendo el primer nmero y el segundo nmero.
Con Suma = Primero + Segundo se ejecuta la suma del primer nmero y el

segundo nmero y se guarda en una variable llamada suma.
Para presentar el resultado de todo el proceso que est almacenado en

la variable suma, se utiliza
Suma
Ya se realizaron todas las instrucciones establecidas en el algoritmo,

entonces para indicar que ya se termina el proceso, se utiliza
Terminar
Prueba de escritorio
Para hacer la prueba de escritorio, es necesario tomar unos valores

reales y realizar todos los pasos que indica el algoritmo.
Se va a utilizar una tabla para ir almacenando los valores de cada

variable y se realiza la prueba de escritorio con los valores 1 para el
primer nmero y 2 para el segundo nmero
Primero Segundo
1 2
Tabla 1.10
Se han ledo para la variable Primero el valor 1 y para la variable

Segundo el valor 2. Hasta ahora se han ejecutado las tres primeras
instrucciones del diagrama de flujo. Se sigue con la cuarta instruccin
que indica que se realice la suma de los dos valores que se almacenan
en las variables y se guarde en la variable Suma y da como resultado 3
Primero Segundo Suma

1 2 3
Tabla 1.11
Se contina con la ltima instruccin para presentar el resultado de la

variable Suma.
Primero Segundo Suma Presentar Suma

1 2 3 3
Tabla 1.12
Se comprob que el algoritmo si ejecuta la suma de dos nmeros y por

ltimo presenta el resultado obtenido. Esto quiere decir que si est bien
planteado el algoritmo en este caso.
E.1.2 Crear un algoritmo que calcule el rea de un crculo.
Para realizar el clculo del rea de un crculo, se necesita conocer el

radio del crculo y luego reemplazar este valor en la frmula del rea de
un crculo que es siento R el radio del crculo y = 3.141592.
Ahora ya se pueden realizar las operaciones indicadas para obtener el
valor buscado.
Algoritmo
Paso 1: Conocer el valor del radio del crculo

Paso 2: Reemplazar el valor del radio en la frmula
Paso 3: Presentar el rea del crculo
Seudocdigo
Leer valor del radio

Haga
Presentar el valor de A
Diagrama de flujo
Iniciar
Radio
A= Radio
Terminar
Figura 1.3
Iniciar
El smbolo indica que comienzan a ejecutarse las instrucciones
del algoritmo que se representan por medio del diagrama de flujo.
La primera instruccin que se ejecuta es leer el valor del radio y se

representa por medio de
Radio
Para ejecutar unas operaciones y asignar estos resultados a una

variable, se hace de la siguiente forma A = *Radio . Ac se realiza la
operacin para calcular el rea del crculo y luego se guarda el resultado
en una variable llamada A.
Una vez se tiene el valor del rea del crculo almacenado en la variable
A, el paso siguiente es presentar el resultado al usuario. Este proceso se
indica en el diagrama de flujo con el siguiente smbolo A
Por ltimo, para indicar que se termin el proceso del algoritmo, se

utiliza la siguiente figura.
Terminar
Ya se tiene creado el algoritmo, se escribi el seudocdigo, y se expres

grficamente por medio del diagrama de flujo, ahora es el momento de
probar con valores reales si este proceso arroja los valores esperados o
si se cometieron errores en el momento de crear el algoritmo.
Para el radio se toma un valor igual a 1 y para = 3.141592
Radio
1 3.141592
Tabla 1.13
El algoritmo indica que se debe reemplazar el valor del radio y de en la

formula . El producto de estas dos cantidades da como
resultado el rea del crculo que se almacena en la variable A.
Radio A
1 3.141592 3.141592
Tabla 1.14
Se ha comprobado que el algoritmo est correctamente diseado y

arroja los valores esperados.
E.1.3 Crear un algoritmo que calcule la suma de dos nmeros, del

primero reste el segundo y el producto de ellos. Por ltimo que presente
los valores contenidos en las variables Suma, Resta y Producto.
Inicialmente se necesita conocer el valor de los dos nmeros para

realizar la suma, luego del primer nmero restar el segundo, y por
ltimo multiplicar el primer nmero por el segundo. El valor de la suma
se almacena en una variable Suma, la resta en una variable llamada
Resta y el producto en una llamada Producto.
Algoritmo
Paso 1: Conocer primer nmero

Paso 2: Conocer segundo nmero
Paso 3: Sume el primer nmero al segundo nmero y almacnelo en
Suma
Paso 4: Del primer nmero reste el segundo nmero y almacnelo en
Resta
Paso 5: Multiplique el primer nmero por el segundo nmero y
almacnelo en Producto.
Paso 6: Terminar.
Seudocdigo
Lea nmero primero

Lea nmero segundo
Haga Suma = primero + segundo
Haga Resta = primero segundo
Haga Producto = primero * segundo
Presentar Suma, Resta, Producto
Terminar
Diagrama de flujo
Iniciar
Primero
Segundo
Suma = primero + segundo
Resta = primero - segundo
Producto = primero * segundo
Suma,
Resta,
Producto
Terminar
Figura 1.4
Ahora es necesario verificar que el algoritmo que se ha diseado, est

cumpliendo con las necesidades establecidas por el enunciado inicial del
ejercicio.
Para poder lograr esto, se va a realizar la prueba de escritorio, tomando

dos nmeros para cada una de las variables primero y segundo, luego
se ejecutan las instrucciones indicadas y se comprueba si los resultados

obtenidos son los esperados.
Primero Segundo
1 2
Tabla 1.15
De acuerdo con el algoritmo, se debe realizar la suma de estas dos

variables y guardar este resultado en una variable llamada Suma que es
igual a 3.
Primero Segundo Suma

1 2 3
Tabla 1.16
Se contina con la instruccin siguiente establecida en el algoritmo, que

consiste en restar del valor de la variable Primero el valor de la variable
Segundo y guardarlo en la variable Resta que es igual a -1.
Primero Segundo Suma Resta

1 2 3 -1
Tabla 1.17
La siguiente instruccin consiste en realizar el producto de los valores

almacenados en las variables Primero y Segundo. Este resultado se
almacena en la variable Producto y es igual a 2.
Primero Segundo Suma Resta Producto

1 2 3 -1 2
Tabla 1.18
Para finalizar, se debe presentar el valor de las variables Suma, Resta y

Producto.
Primero Segundo Suma Resta Producto Presentar Presentar Presentar

Suma Resta Producto
1 2 3 -1 2 3 -1 2
Tabla 1.19
De esta forma quedan ejecutadas todas las operaciones indicadas en el

algoritmo. Los valores obtenidos en cada una de las operaciones, son
congruentes con los valores esperados para este algoritmo.
E.1.4 Escriba un algoritmo que indique la manera como se prepara una

mantecada.
Para preparar una mantecada, primero se deben tener a mano todos los
ingredientes que se necesitan y luego, saber cual es la forma exacta de
preparacin.
Los ingredientes que se deben tener a mano para preparar la mantecada

son:
de libra de mantequilla o margarina o manteca de marrano.

1 libra de azcar.
copas de aguardiente.
10 huevos.
tazas rasas de fcula de maz.
taza de harina de trigo
1/8 de cucharadita de sal.
Ya se sabe cules son los materiales o ingredientes necesarios para

preparar la mantecada, ahora se necesita saber qu se debe hacer con
estos elementos, en qu forma se deben mezclar, en qu momento y a
qu temperatura se deben cocinar. Se necesitan adems los siguientes
implementos para la preparacin de la mantecada.
1 horno que pueda calentar a 350 F

1 lata o molde para poder agregar la masa antes de meterla al
horno.
1 recipiente auxiliar, para hacer el batido y mezcla de los
ingredientes.
Algoritmo
Este es el momento de indicar qu procedimiento se debe seguir con

todos estos ingredientes e implementos.
Paso 1: Caliente el horno a 350 F (moderado).

Paso 2: Engrase una lata.
Paso 3: Bata la margarina con el azcar hasta formar crema suave y
agregue los huevos.
Paso 4: Mezcle y aada poco a poco la fcula de maz.
Paso 5: Aada la harina de trigo y la sal.
Paso 6: Revuelva la mezcla.
Paso 7: Aada el aguardiente.
Paso 8: Bata hasta conseguir que se incorporen todos los ingredientes o
se consiga una mezcla lo ms homognea posible.
Paso 9: Vierta la masa en la lata engrasada y deje cocinar en el horno
calentado previamente por aproximadamente 35 minutos.
Paso 10: Ya puede sacar la lata del horno.
Seudocdigo:
Calentar el horno a 350 F (moderado).

Engrase una lata o molde.
Bata la margarina con el azcar hasta formar crema suave.
Agregue los huevos.
Mezcle y aada poco a poco la fcula de maz.
Aada la harina de trigo.
Aada la sal y revuelva.
Aada el aguardiente.
Bata hasta conseguir que se incorporen todos los ingredientes o se
consiga una mezcla los ms homognea posible.
Vierta la masa en la lata engrasada y deje cocinar en el horno
calentado previamente por aproximadamente 35 minutos.
Ya la puede sacar del horno.
Diagrama de flujo
Iniciar
Calentar horno
a 350 F
Engrasar lata o
molde
Bata la margarina
con el azcar, hasta
forma crema suave
Agregue los huevos
A
Mezcle y aada
poco a poco la
fcula de maz
Aada la harina
de trigo
Aada la sal y
revuelva
Aada el
aguardiente
Bata hasta conseguir

que se incorporen
todos los ingredientes
o se consiga una
mezcla los ms
homognea posible
Vierta la masa en la lata

engrasada y deje cocinar en el
horno calentado previamente
por aproximadamente 35
minutos
Ya la puede sacar
del horno
Terminar
Figura 1.5
A
En este ejercicio se utiliza por primera vez este smbolo, que indica
que el diagrama de flujo contina en la pgina siguiente. Es un conector,
que tiene como funcin presentar en qu punto se interrumpi el
diagrama en la pgina en que se empez a escribir y luego en la pgina
siguiente en donde contina el flujo de la informacin. En este ejercicio,
se ve muy sencillo, pero en aplicaciones ms complejas, en donde se
van a encontrar varias rutas del flujo de la informacin, se va a
comprender mejor su importancia.
El diagrama de flujo de la Figura 1.5 indica todos los pasos para

preparar una mantecada. De la misma forma se hace el algoritmo para
escribir un programa de computadores, se especifican claramente los
pasos que se deben realizar, en un orden establecido, para evitar
sorpresas y prdida de tiempo al final, porque si usted quiere, puede
cambiar los pasos para preparar la mantecada y comprobar si obtiene el
mismo resultado.
Creo que para este ejercicio la mejor prueba de escritorio es poder

probar una porcin de la suculenta mantecada.
Ya est claro cmo se utilizan los procesos secuenciales, cules son los
diferentes pasos que se deben seguir para poder realizar un algoritmo,
un seudocdigo y el diagrama de flujo; por ltimo cmo comprobar que
los resultados que se obtienen son los correctos, por medio de la prueba
de escritorio.
E.1.5 Escriba un algoritmo que lea 2 nmeros complejos y luego calcule

la suma, la diferencia del primero menos el segundo, el producto y el
cociente del primero entre el segundo.
Antes de empezar a escribir el algoritmo, es conveniente documentarse

para poder resolver este ejercicio. Los nmeros complejos son de la
forma , corresponde a la parte entera y es la parte imaginaria,
por esta razn se les llama nmeros complejos, porque tienen una parte
real y una imaginaria. Es importante saber que .
La suma de nmeros complejos se define como:
La diferencia es:
El producto es:
El cociente es:
Para poder realizar el cociente, es necesario multiplicar la fraccin por el

conjugado, esto es:
El resultado del producto de esas dos fracciones es igual a

Algoritmo
Paso 1: Conocer a
Paso 2: Guardar a en la variable A
Paso 3: Conocer b
Paso 4: Guardar b en la variable B
Paso 5: Conocer c
Paso 6: Guardar c en la variable C
Paso 7: Conocer d
Paso 8: Guardar d en la variable D
Paso 9: Guardar en la variable Suma1 la suma de A y C
Paso 10: Guardar en la variable Suma2 la suma de B y D
Paso 11: Guardar en la variable Resta1 la resta de A y C
Paso 12: Guardar en la variable Resta2 la resta de B y D
Paso 13: Guardar en la variable Producto1 la resta de A por C y B por D
Paso 14: Guardar en la variable Producto2 la suma de A por D y B por C
Paso 15: Guardar en la variable Cociente1 la suma de A por C y B por D
Paso 16: Guardar en la variable Cociente2 la resta de B por C y A por D
Paso 17: Guardar en la variable Cociente3 la suma de C2 y D2
Paso 18: Presentar La suma es , Suma1,+, Suma2,
Paso 19: Presentar La resta es , Resta1,-, Resta2,
Paso 20: Presentar El producto es , Producto1,+, Producto2,
Paso 21: Presentar El cociente es , Cociente1/Cociente3,+,
Cociente2/Cociente3,
Paso 22: Terminar
Seudocdigo
Lea a
A=a
Lea b
B=b
Lea c
C=c
Lea d
D=d
Suma1 = A+C
Suma2 = B+D
Resta1 = A-C
Resta2 = B-D
Producto1 = A*C-B*D
Producto2 = A*D+B*C
Cociente1 = A*C+B*D
Cociente2 = B*C-A*D
Cociente3 = C2+D2
Presentar La suma es , Suma1,+, Suma2,
Presentar La resta es , Resta1,-, Resta2,
Presentar El producto es , Producto1,+, Producto2,
Presentar El cociente es , Cociente1/Cociente3, +,
Cociente2/Cociente3,
Diagrama de flujo
Iniciar
A=a
B=b
H
C=c
D=d
Suma1 = A+C
Suma2 = B+D
Resta1 = A-C
Resta2 = B-D
Producto1 = A*C-B*D
Producto2 = A*D+B*C
Cociente1 = A*C+B*D
Cociente2 = B*C-A*D
2 2
Cociente3 = C +D
La suma es , Suma1,+, Suma2, ; La resta es

, Resta1,-, Resta2, ; El producto es ,
Producto1,+, Producto2, ; El cociente es ,
Cociente1/Cociente3, +, Cociente2/Cociente3,
Terminar
Figura 1.6
La prueba de escritorio se va a realizar para los siguientes nmeros

complejos:
5+3 y 2-
Entonces se leen los nmeros a, b, c y d, y se guardan en las variables

A, B, C, D respectivamente.
a b c d A B C D
5 3 2 -1 5 3 2 -1
Tabla 1.20
Se ejecutan las instrucciones indicadas y se tienen los siguientes

resultados
a b c d A B C D Suma1 Suma2 Resta1 Resta2 Producto1

5 3 2 -1 5 3 2 -1 7 2 3 4 13
Producto2 Cociente1 Cociente2 Cociente3
1 7 11 5
Mensaje
La suma es 7 + 2 ; La resta es 3 - 4 ; El producto es 13 +1 ; El cociente es (7
/ 5) +( 11 / 5)
Tabla 1.21
Este es un interesante ejercicio, que permite ver la importancia de

realizar un buen anlisis de la informacin antes de empezar a ejecutar
operaciones, sin tener la informacin completa de qu se debe hacer.
En el desarrollo de este algoritmo se realizaron algunas prcticas que

son convenientes que adquiera todo programador, por ejemplo, despus
de leer un dato, almacenarlo en una variable antes de empezar a
realizar las operaciones, porque cuando se est trabajando en un
lenguaje de programacin como C++, se debe definir el tipo de variable

y luego si almacenar el dato para poder empezar a utilizarlo en las
operaciones que se necesite realizar. Otro buen hbito de programacin
es ir guardando en variables las operaciones intermedias, para ser
utilizadas ms adelante en el mismo algoritmo.
Para la presentacin del mensaje final en el diagrama de flujo, se utiliz

un nuevo smbolo y en el seudocdigo y diagrama de flujo una nueva
manera de presentar el mensaje al usuario del programa.
La suma es , Suma1,+, Suma2, ; La resta es

, Resta1,-, Resta2, ; El producto es ,
Producto1,+, Producto2, ; El cociente es ,
Cociente1/Cociente3, +, Cociente2/Cociente3,
Figura 1.7
Este smbolo se utiliza cuando se quiere indicar que el mensaje se va a

presentar por pantalla.
La suma es , Suma1,+, Suma2, . Esta manera de presentarlo es

un poco particular. Los textos que estn escritos entre comillas dobles,
quiere decir que van a aparecer como estn escritos, la coma (,) indica
que a continuacin va otro dato. En este caso aparece Suma1, entonces
va a aparecer el valor que est almacenado en esta variable, no el
nombre de la variable, que es igual a 7. Luego aparece el signo +
porque est entre comillas, en seguida el valor de la variable Suma2 que
es igual a 2 y por ltimo la letra i que se encuentra entre comillas,
entonces el usuario ver este mensaje:
En cada ejercicio va a encontrar elementos que no necesariamente se

van a estar nombrando pero su observacin, capacidad analtica,
inductiva-deductiva y poder de sntesis, permite que al usted
descubrirlos, entren a formar parte ms pronto de su imaginario, y
pueda avanzar fcilmente en el aprendizaje del diseo de algoritmos
para la programacin de computadores y creacin de algoritmos.
1.11 Resumen
En el diseo de programas para computadores hay tres elementos

que es necesario tener en cuenta:
o Entrada de datos.
o Procesamiento de datos
o Obtencin de resultados
Se aplica una metodologa que le permita al programador, seguir una
secuencia para resolver los problemas; estos pasos son: el anlisis
de la informacin, definir el algoritmo, escribir el seudocdigo,
realizar el diagrama de flujo y hacer la prueba de escritorio.
Este proceso de analizar la informacin es importante y se toma a la
ligera, porque se debe tener bien claro qu es lo que quiere y
necesita el usuario, y qu es lo que ha entendido quien va a hacer la
programacin.
Un algoritmo es una receta que se debe realizar con pasos finitos,
ordenados, que permiten obtener un resultado especfico.
El seudocdigo es una forma de expresar las instrucciones que se
realizan en el algoritmo, de la manera ms parecida a como se
expresaran en un lenguaje de programacin.
El diagrama de flujo es la representacin grfica del algoritmo.
La prueba de escritorio es la prueba final del algoritmo, antes de
pasar al lenguaje de programacin.
Una variable es un espacio temporal de memoria, donde se va a
almacenar la informacin mientras se est ejecutando el algoritmo o
el programa. Esta informacin se puede cambiar durante la ejecucin
del programa.
Una contante es un valor fijo que se guarda en un espacio de

memoria en forma temporal, mientras se est ejecutando el
algoritmo o el programa. Esta informacin no se puede cambiar
durante la ejecucin del programa.
Un programa es un conjunto de instrucciones que sigue el
computador, para poder alcanzar un resultado especfico. Los
programas estn escritos en lenguajes de programacin, que pueden
ser entendidos o interpretados por el computador.
Hay procesos que son secuenciales, condicionales y repetitivos. La
correcta aplicacin de estos procesos se conoce como programacin
estructurada.
Para realizar las operaciones matemticas se utilizan los operadores
aritmticos, que permiten hacer las operaciones aritmticas entre
constantes, nmeros y variables. Cuando se realizan estas
operaciones se obtiene como resultado un nmero.
Para resolver una expresin aritmtica se deben cumplir los
siguientes puntos:
o Primero se desarrollan las expresiones que se encuentran
entre parntesis, respetando la jerarqua de los operadores
aritmticos. Si hay operaciones que se encuentran entre
parntesis que estn anidados, se empieza desde el parntesis
que se encuentra en el ltimo nivel de anidamiento.
o La jerarqua de los operadores aritmticos se aplica de
izquierda a derecha.
Las expresiones lgicas tambin conocidas como booleanas, estn
compuestas por nmeros, constantes, variables y operadores
relacionales o lgicos. Cuando se evalan estas expresiones, el
resultado que se obtiene es verdadero o falso. Se utilizan en los
procesos de decisin y en una clase de proceso repetitivo.
Los operadores relacionales se utilizan para comparar dos nmeros,
constantes, variables, expresiones alfanumricas o expresiones
aritmticas. Cuando se validan las expresiones con operadores
relacionales se obtienen solamente dos resultados verdadero o falso.
Estos operadores hacen posible establecer condiciones complejas,

partiendo de expresiones sencillas. Los operadores lgicos son (Y)
que corresponde a la conjuncin, (O) a la disyuncin y (NO) a la
negacin.
El operador No, hace las veces de trmino de enlace y niega la
proposicin.
El operador y forma una conjuncin, tambin cumple la funcin de
trmino de enlace. La conjuncin es verdadera, cuando las dos
proposiciones son verdaderas.
El operador o forma una disyuncin, cumple la funcin de trmino de
enlace. La disyuncin es verdadera, cuando una de las dos
proposiciones es verdadera.
El proceso secuencial es cuando no se tienen que evaluar varias
opciones o realizar un conjunto de operaciones varias veces
consecutivas. El nico requisito de este proceso, es que las
instrucciones estn debidamente ordenadas y se realicen una a
continuacin de la otra.
EJERCICIOS PROPUESTOS
EP.1.1 Escriba un algoritmo que describa el proceso que realiza para

almorzar. Realice el anlisis de la informacin, algoritmo, seudocdigo,
diagrama de flujo y prueba de escritorio.
EP.1.2 Escriba un algoritmo para calcular el volumen y la superficie de

una esfera. Realice el anlisis de la informacin, algoritmo, seudocdigo,
EP.1.3 Escriba un algoritmo para cambiar la rueda de un vehculo.

Realice el anlisis de la informacin, algoritmo, seudocdigo, diagrama
de flujo y prueba de escritorio.
EP.1.4 Escriba un algoritmo para preparar un caf con leche. Realice el

anlisis de la informacin, algoritmo, seudocdigo, diagrama de flujo y
prueba de escritorio.
EP.1.5 Escriba un algoritmo para amarrarse los cordones de los

zapatos. Realice el anlisis de la informacin, algoritmo, seudocdigo,
EP.1.6 Escriba un algoritmo para indicar todas las actividades que

realiza desde el momento en que se levanta de la cama en la maana,
hasta el momento que sale de la casa para ir a estudiar o trabajar.
EP.1.7 Escriba un algoritmo para calcular la equivalencia entre grados

Kelvin (K) y grados Celsius (C), leyendo inicialmente la temperatura en
grados K. Realice el anlisis de la informacin, algoritmo, seudocdigo,
EP.1.8 Escriba un algoritmo para calcular la equivalencia entre grados

Kelvin (K) y grados Fahrenheit (F), leyendo inicialmente la temperatura
en grados F. Realice el anlisis de la informacin, algoritmo,
seudocdigo, diagrama de flujo y prueba de escritorio.
EP.1.9 Escriba un algoritmo para calcular el volumen y la superficie de

una pirmide de base triangular y altura h. Realice el anlisis de la
informacin, algoritmo, seudocdigo, diagrama de flujo y prueba de
escritorio.
Captulo 2: Procesos de toma de decisiones 53
2 Proceso de toma de decisiones
Estos procesos se utilizan cuando es necesario tomar decisiones entre

varios resultados o alternativas, de acuerdo con expresiones lgicas que
utilizan operadores relacionales y lgicos vistos en el captulo 1. Se van
a estudiar en este captulo los procesos que tienen que optar por una
sola posibilidad, dos alternativas, como son: si o no, verdadero o falso,
uno o cero, o tambin entre dos valores establecidos, y luego se va a
estudiar el proceso conmutar que permite tomar decisiones cuando se
tienen ms de dos posibilidades. Este tipo de proceso se utiliza en casi
todos los algoritmos que se necesita desarrollar cuando se est
trabajando en programacin de computadores. Es un proceso que
proporciona fluidez y versatilidad al momento de aplicar la programacin
estructurada.
2.1 Proceso Si _____; haga _____:
Es frecuente encontrarse en situaciones que requieren que se siga una

alternativa para poder continuar con el proceso que se est realizando.
El tipo de decisin ms frecuente es: Si se presenta determinada
situacin, haga esto, de lo contrario contine.
Si
Si ____?
No
Figura 2.1
En la Figura 2.1, se puede ver con claridad cul es la forma de

representar este proceso en un diagrama de flujo. Para entenderlo
mejor, observar atentamente algunos ejemplos.
EJERCICIOS DE INICIACIN
E.2.1 Escriba un algoritmo que lea un nmero y verifique si es positivo.

Si es as, entonces que presente un mensaje al usuario El nmero es
mayor que cero. El nmero ledo debe ser almacenado en una variable
de nombre Nmero.
En este ejercicio, se va a leer un nmero y se almacena en una variable

de nombre Nmero. El contenido de esta variable, se va a comparar con
cero, y si es mayor entonces se presenta un mensaje, informando qu
clase de nmero es, luego se termina el proceso.
Algoritmo
Paso 1: Leer nmero.

Paso 2: Almacene en la variable Nmero el valor del nmero ledo.
Paso 3: Si el nmero es mayor que cero, contine, si no vaya al Paso: 5.
Paso 4: Presente El nmero es mayor que cero.
Paso 5: Terminar.
En el Paso 3 se puede ver la validacin del dato almacenado en la

variable Nmero. Si este valor es mayor que cero, se contina con el
Paso 4, si no lo es, se sigue con el Paso 5 para terminar el algoritmo.
Seudocdigo
Lea nmero
Nmero = nmero
Si Nmero > 0 haga
Presente El nmero es mayor que cero
Fin si
Terminar
En el seudocdigo anterior, se puede ver que en el proceso Si Fin si,

se realiza la comparacin de la variable Nmero para saber si es mayor
que 0, si es as, se contina con la instruccin que se encuentra
indexada a la derecha, sta es una manera de indicar que esa
instruccin pertenece al proceso Si, y si no es cierto, se contina con la
instruccin Fin si, para salir del proceso y terminar el algoritmo.
Diagrama de flujo
Iniciar
nmero
Nmero = nmero
Si
Nmero > 0
No El nmero es
mayor que cero
Terminar
Figura 2.2
Nmero Este smbolo indica que se est leyendo el valor

correspondiente al nmero que se quiere evaluar.
Nmero = nmero En esta instruccin, se est asignando o guardando el

valor que se acaba de leer, en la variable Nmero. Se debe tener en
cuenta que las asignaciones de los valores de las variables se realizan
de derecha a izquierda. El nombre de la variable debe estar en el lado
izquierdo de la asignacin.
Si
Nmero > 0
No
En este grfico, se est indicando que se compara el valor guardado en

la variable Nmero para saber si es mayor que cero. Se ve la alternativa
Si, que se ejecuta cuando se cumple con la condicin establecida y
contina para presentar el mensaje, de lo contrario se sigue con el flujo
de la informacin sin realizar ninguna instruccin.
El nmero es
mayor que cero
Este smbolo se utiliza para indicar que se va a presentar
un mensaje al usuario del programa.
Para comprobar el funcionamiento del algoritmo, se van a utilizar dos

nmero, el 1 y -1.
Se utiliza una tabla para ir registrando los datos que van apareciendo en
el algoritmo. Se inicia la primera prueba para el nmero 1.
nmero
1
Tabla 2.1
Ahora se guarda este valor que se acaba de leer en la variable Nmero.
nmero Nmero
1 1
Tabla 2.2
Se hace la comparacin de la variable Nmero con el cero. Como es

mayor que cero, entonces se presenta el mensaje al usuario.
nmero Nmero Presentar mensaje

1 1 El nmero es mayor que cero
Tabla 2.3
Se realiza entonces la prueba para el valor -1.
nmero
-1
Tabla 2.4
En la variable Nmero se almacena el valor ledo.
nmero Nmero
-1 -1
Tabla 2.5
Se hace la comparacin de la variable Nmero con el cero. Como es

menor que cero, entonces no se presenta el mensaje al usuario y se
termina el proceso. sta es la mejor manera de comprobar que el
trabajo est bien hecho, validando con datos reales y verificando que los
resultados obtenidos son los esperados. ste es un ejercicio sencillo,
pero a medida que se va avanzando en el captulo, el grado de
complejidad va aumentando.
E.2.2 Escriba un algoritmo que lea 2 nmeros. El primero se debe

guardar en una variable llamada Numerador y el segundo en una
variable llamada Denominador. Luego realice la divisin de Numerador
entre Denominador. Presentar el valor de la divisin. Si la divisin no es

posible realizarla, entonces terminar.
En este ejercicio, se van a leer dos nmeros, se guarda el primero en la

variable Numerador y el segundo en la variable Denominador. Antes de
realizar la divisin se debe comparar la variable Denominador con cero.
Este ltimo proceso no est en el enunciado del ejercicio, pero es un
proceso intermedio que se necesita realizar, para poder saber si la
divisin es posible hacerla o no, y evitar que se presente un error en el
algoritmo y luego cuando se pase a un lenguaje de programacin.
Algoritmo
Paso 1: Lea el primer nmero.

Paso 2: Numerador es igual al primer nmero.
Paso 3: Lea el segundo nmero.
Paso 4: Denominador es igual al segundo nmero.
Paso 5: Si Denominador es diferente de cero contine, si no vaya Paso
8.
Paso 6: Divisin es igual a Numerador/Denominador.
Paso 7: Presentar el valor de la divisin.
Paso 8: Terminar.
Seudocdigo
Leer primer nmero

Numerador = primer nmero
Leer segundo nmero
Denominador = segundo nmero
Si Denominador = 0 haga
Divisin = Numerador / Denominador
Fin si
Presentar Divisin
Terminar
Diagrama de flujo
Iniciar
Primero
Numerador = Primero
Segundo
Denominador = Segundo
No
Denominador = 0
Si
Divisin = Numerador/Denominador
Divisin
Terminar
Figura 2.3
Para comprobar que el algoritmo funciona correctamente, se va a probar

con dos valores, 1 y 2 luego con 1 y 0. Se empieza a comprobar con 1 y
2. Se lee el primer nmero que es igual a 1.
primero
1
Tabla 2.6
Se guarda el primer nmero en la variable Numerador.
primero Numerador
1 1
Tabla 2.7
Ahora se lee el segundo nmero que es igual a 2.
primero Numerador segundo

1 1 2
Tabla 2.8
Se guarda el segundo nmero ledo en la variable Denominador.
primero Numerador segundo Denominador

1 1 2 2
Tabla 2.9
Viene ahora la comprobacin del Denominador. El valor de la variable

Denominador es diferente de 0, entonces se realiza la divisin del
Numerador entre el Denominador y se almacena este valor en la

variable Divisin. El resultado de esta divisin es 0.5.
primero Numerador segundo Denominador Divisin

1 1 2 2 0.5
Tabla 2.10
Qued comprobado que funciona el algoritmo, para dos nmeros

diferentes de cero. Ahora se va a hacer la prueba de escritorio para dos
nmeros diferentes 1 y 0. Se lee el primer nmero que es igual a 1.
primero
1
Tabla 2.11
Se guarda el primer nmero en la variable Numerador.
primero Numerador
1 1
Tabla 2.12
Ahora se lee el segundo nmero que es igual a 0.
primero Numerador segundo

1 1 0
Tabla 2.13
Se guarda el segundo nmero ledo en la variable Denominador.

primero Numerador segundo Denominador

1 1 0 0
Tabla 2.14
A continuacin se realiza la comprobacin del Denominador. El valor de

la variable Denominador es igual a 0, entonces se termina el algoritmo.
De esta forma se evala el comportamiento del algoritmo que cumple
con las expectativas planteadas en el enunciado del ejercicio.
E.2.3 Haga un algoritmo que lea y compare 3 nmeros, que el primero

que lea lo guarde en una variable llamada Mayor, el segundo en una
variable llamada Medio y el ltimo en una llamada Menor, luego diga
cul es el mayor, cul el intermedio y cul el menor, y a medida que los
vaya leyendo que cada uno lo guarde en una variable que represente el
resultado de la comparacin, el mayor en la variable Mayor, el
intermedio en la variable Intermedio y el menor en la variable Menor y a
continuacin presente un mensaje con los nmeros ordenados.
Anlisis de la Informacin
Se van a leer tres nmeros, a medida que se leen se van guardando en

las variables Mayor, Medio Menor; luego se van comparando mayor con
medio para saber cul es el mayor, si no es as, se deben intercambiar
los valores almacenados en las variables utilizando una variable
intermedia llamada c, luego se hace la comparacin entre mayor y
menor, y si es necesario se hace el intercambio de los valores de las
variables.
Por ltimo se comparan las variables medio y menor, si es necesario se

realiza el intercambio de los valores de las variables. Este procedimiento
se conoce como el mtodo de la burbuja.
Las variables cumplen funciones de contadores o acumuladores.

Son acumuladores, cuando al valor de una variable se le suma una

cantidad, y luego el valor de esa suma se guarda en la variable inicial.
Ejemplo: Variable = Variable +5.
Son contadores, cuando al valor de una variable se le suma uno, y luego

el valor de esa suma se guarda en la variable inicial.
Ejemplo: Cont = Cont + 1.
Algoritmo
Paso 1: Conocer primer nmero

Paso 2: Guardar primer nmero en la variable Mayor
Paso 3: Conocer segundo nmero
Paso 4: Guardar segundo nmero en la variable Medio
Paso 5: Conocer tercer nmero
Paso 6: Guardar tercer nmero en la variable Menor
Paso 7: Comparar Mayor con Medio
Paso 8: Si Mayor es menor que Medio, intercambiar los valores de las
variables; de lo contrario continuar.
Paso 9: Comparar Mayor con Menor.
Paso 10: Si Mayor es menor que Menor, intercambiar los valores de las
Paso 11: Comparar Medio con Menor.
Paso 12: Si Medio es menor que Menor, intercambiar los valores de las
Paso 13: Presentar Mayor =, Mayor.
Paso 14: Presentar Medio =, Medio.
Paso 15: Presentar Menor =, Menor.
Paso 16: Terminar
Seudocdigo
Lea primero
Mayor = primero
Lea segundo
Medio = segundo
Lea tercero
Menor = tercero
Si Mayor < Medio haga
C = Mayor
Mayor = Medio
Medio = C
Fin si
Si Mayor < Menor haga
C = Mayor
Mayor = Menor
Menor = C
Fin si
Si Medio < Menor haga
C = Medio
Medio = Menor
Menor = C
Fin si
Presente Mayor =, Mayor
Presente Medio =, Medio
Presente Menor =, Menor
Terminar
Diagrama de flujo
Iniciar
primero
Mayor = primero
segundo
Medio = segundo
tercero
Menor = tercero
Si
Mayor < Medio
No C = Mayor
Mayor = Medio
Medio = C
Si
Mayor < Menor
No C = Mayor
Mayor = Menor
A Menor = C
Si
Medio < Menor
No C = Medio
Medio = Menor
Mayor,
Medio, Menor Menor = C
Termina
r
Figura 2.4
En el diagrama de flujo se ve claramente de qu forma se realiza el

intercambio de las variables. Se utiliza una variable temporal C para
guardar inicialmente el valor de la variable, porque si se almacena por
ejemplo el valor de la variable Mayor en la variable Medio sin haberse
hecho previamente una copia del valor de Medio en otra variable, se
pierde este valor, porque se sobrescribe.
Para realizar la prueba de este algoritmo, se utilizan tres nmeros

diferentes. El primer nmero ledo es 1, el segundo nmero ledo es 2 y
por ltimo el tercer nmero ledo es 3, despus estos tres valores se
almacenan en las variables Mayor, Medio y Menor respectivamente.
primero segundo tercero Mayor Medio Menor

1 2 3 1 2 3
Tabla 2.15
Ya estn ledos y almacenados en sus respectivas variables los valores

iniciales. Se hace la primera comparacin para saber si el valor de la
variable Mayor es menor que el contenido de la variable Medio. Si esto
no es cierto, se contina con la siguiente comparacin del algoritmo,
pero si es cierto, se deben intercambiar los valores. Para hacer esto, se
guarda inicialmente el valor de la variable Mayor en la variable temporal
C, luego el valor de la variable Medio se pasa a la variable Mayor y por
ltimo el valor que se guard temporalmente en la variable C, se guarda
la variable Medio, ya se hizo el intercambio de los contenidos de las
variables Mayor y Medio. La variable Menor sigue igual. La Tabla en la
que se estn registrando los resultados de las instrucciones establecidas
en el algoritmo, es la siguiente.
Mayor Medio Menor C

1 2 3
2 1 3 1
Tabla 2.16
Continuando con la siguiente comparacin, se verifica si el valor de la

variable Mayor es menor que el valor de la variable Menor. Si esto no es
cierto, se contina con la tercera comparacin del algoritmo, pero si es
cierto, entonces se debe hacer el intercambio de las variables. Se
guarda inicialmente el valor de la variable Mayor en la variable temporal
C, luego el valor de la variable Menor en la variable Mayor y por ltimo,
el valor que se guard temporalmente en la variable C, se guarda en la
variable Menor, el valor de la variable Medio sigue igual.
Mayor Medio Menor C

1 2 3
2 1 3 1
3 1 2 2
Tabla 2.17
La ltima comparacin a realizar es si el valor de la variable Medio es

menor que el valor de la variable Menor. Cuando esto no es cierto, se
contina con la siguiente instruccin, pero si es cierto se hace el ltimo
cambio de variables del algoritmo. El valor de la variable Medio se
guarda en la variable temporal C, luego el valor de la variable Menor, se
guarda en la variable Medio y finalmente el valor de la variable se
almacena en la variable Menor, el valor de la variable Mayor sigue igual.
Mayor Medio Menor C

1 2 3
2 1 3 1
3 1 2 2
3 2 1 1
Tabla 2.18
En la cuarta fila de la Tabla 2.19, se puede ver que los tres valores de
las variables, quedaron ordenados de mayor a menor y en cada una de
las variables se almacen el valor correspondiente. Como ejercicio, el
lector puede utilizar el concepto de ordenacin en burbuja, y basndose
en el ejemplo anterior para organizar los nmeros de menor a mayor,
para reforzar los conocimientos aprendidos.
Mayor Medio Menor C Presente Presente Presente

Mayor Medio menor
1 2 3
2 1 3 1
3 1 2 2
3 2 1 1 3 2 1
Tabla 2.19
E.2.4 Escriba un algoritmo que lea la magnitud de un vector, sus tres

ngulos directores y luego lo exprese en funcin de sus componentes
vectoriales en las direcciones de los vectores unitarios
Este es otro ejercicio muy chvere, porque requiere que se investigue

un poco de qu est hablando el enunciado, antes de empezar a escribir
el algoritmo.
Para empezar qu es un vector? Es todo aquello que tiene magnitud,

direccin y sentido, ejemplo, la velocidad, la fuerza, la aceleracin, etc.
Todas las cantidades que NO tienen direccin y sentido, se conocen
como escalares, por ejemplo el tiempo, la temperatura, etc. Ya se puede
ver que se va a trabajar con cantidades Fsicas.
De acuerdo al enunciado, se va a trabajar con vectores en . Entonces

adems de la magnitud, el usuario del programa debe suministrar los
tres ngulos que el vector magnitud forma con los ejes coordenados
respectivamente.
z
z1
M (x1, y1, z1)
y1
y
x1
Figura 2.5
El ngulo est formado por el vector y el eje de las x, el ngulo est

formado por el vector y el eje de las y, el ngulo est formado por el
vector y el eje z. Los vectores unitarios estn en la direccin de los
ejes x, y, z respectivamente. Entonces ya se puede calcular el valor de
las componentes vectoriales. Para poder comprobar que los ngulos son
correctos se debe cumplir la siguiente igualdad:
Cos2( Cos2( Cos2(
Si se cumple, se pueden hacer los clculos:
Componente en la direccin de = M*Cos(

Teniendo esta informacin, el vector se expresa de la siguiente forma:
M = M*Cos( M*Cos( M*Cos(
Algoritmo
Paso 1: Lea la magnitud del vector

Paso 2: Guardarla en la variable M
Paso 3: Lea el ngulo que el vector forma con el eje x
Paso 4: Guardarlo en la variable A
Paso 5: Lea el ngulo que el vector forma con el eje y
Paso 6: Guardarlo en la variable B
Paso 7: Lea el ngulo que el vector forma con el eje z
Paso 8: Guardarlo en la variable C
Paso 9: Si Cos2(A Cos2(B + Cos2(C = contine, de lo contrario vaya
el Paso 14
Paso 10: Guarde en la variable Mx la operacin M*Cos(A)
Paso 11: Guarde en la variable My la operacin M*Cos(B)
Paso 12: Guarde en la variable Mz la operacin M*Cos(C)
Paso 13: Presente M = , Mx, ", My, ", Mz,
Paso 14: Termine.
Seudocdigo
Lea magnitud
M = magnitud
Lea X
A=X
Lea Y
B=Y
Lea Z
C=Z
Si Cos2(A Cos2(B + Cos2(C = haga
Mx = M*Cos(A)
My = M*Cos(B)
Mz = M*Cos(C)
Presente M = , Mx, + ", My, + ", Mz,
Fin si
Terminar
Diagrama de flujo
Iniciar
magnitud
M = magnitud
A=X
A
B=Y
C=Z
Si
Cos2(A) + Cos2(B) + Cos2(C) = 1
Mx = M*Cos(A)
No
My = M*Cos(B)
Mz = M*Cos(C)
M = , Mx, + ", My,

+ ", Mz,
Terminar
Figura 2.6
La comprobacin del algoritmo se va a hacer con los siguientes datos:

Magnitud: 10 ul, : 64.89, : 55.54, : 44.99. Realizando una a una
las instrucciones del algoritmo se tiene:
magnitud M
10 10
Tabla 2.20
Ahora se contina leyendo los ngulos que el vector forma con los ejes
coordenados.
magnitud M X A Y B Z C
10 10 64.89 64.89 55.54 55.54 44.99 44.99
Tabla 2.21
Se contina con la validacin de los ngulos ledos, y es igual a:
Cos2(A) + Cos2(B) + Cos2(C) = 1,
Entonces Cos2(64.89) + Cos2(55.54) + Cos2(44.99) = 1.002, esto

indica que estn correctos los ngulos y corresponden al mismo vector.
Se sigue con el clculo de las componentes vectoriales.
10 10 64.89 64.89 55.54 55.54 44.99 44.99
Mx My Mz
4.24 5.66 7.10
Tabla 2.22
El mensaje presenta el vector en sus componentes vectoriales en la

direccin de los vectores unitarios i, j, k.
10 10 64.89 64.89 55.54 55.54 44.99 44.99
Mx My Mz Mensaje
4.24 5.66 7.10 M = 4.24 + 5.66 + 7.10
Tabla 2.23
Este ejercicio, muestra de una manera sencilla cmo se realiza la

comparacin para validar una operacin y poder determinar qu camino
se debe seguir, si se cumple la condicin, entonces se ejecutan ciertas
instrucciones, de lo contrario se sigue con las otras sentencias del
diagrama de flujo.
E.2.5 Realice un algoritmo que lea tres nmeros y determine si

corresponden a los lados de un tringulo, si es as, entonces clasifique el
tipo de tringulo: escaleno, issceles, equiltero.
Una vez conocidos los valores correspondientes a los tres lados, se

almacenan en tres variables llamadas Lado1, Lado2 y Lado3
respectivamente. Luego se verifica que realmente correspondan a un
tringulo haciendo que la suma de dos de los lados sea mayor que el
tercer lado. Esta comparacin se realiza para (Lado1 + Lado2) > Lado3,
luego, (Lado1 + Lado3) > Lado2 y por ltimo (Lado3 + Lado2) > Lado1,
ya te tienen todas las comparaciones posibles para saber qu tipo de
tringulo es, issceles, equiltero o escaleno. En el caso que no se
cumplan estas tres validaciones de la informacin, los lados no
corresponden a un tringulo.
Algoritmo
Paso 1: Conocer el primer nmero.

Paso 2: La variable Lado1 es igual a primer nmero.
Paso 3: Conocer el segundo nmero.
Paso 4: La variable Lado2 es igual a segundo nmero.
Paso 5: Conocer el tercer nmero.
Paso 6: La variable Lado3 es igual a tercer nmero.
Paso 7: Comparar que la suma de Lado1 ms Lado2 es mayor que
Lado3.
Paso 8: Si lo anterior no es cierto, entonces no es un tringulo, vaya al

Paso 18.
Lado2.
Paso 18.
Lado1.
Paso 18.
Paso 13: Comprobar que el Lado1 es igual a Lado2 y a Lado3.
Paso 14: Si la comprobacin fue cierta, es un tringulo equiltero
Paso 15: Si la comprobacin no fue cierta, entonces comprobar que
Lado1 es diferente de Lado2 y estos dos a su vez son diferentes de
Lado3.
Paso 16: Si la comprobacin es cierta entonces es un tringulo escaleno.
Paso 17: Si la comprobacin no es cierta, es un tringulo issceles.
Paso 18: Terminar.
Seudocdigo
Lea el nmero primero

Lado1 = primero
Lea el nmero segundo
Lado2 = segundo
Lea el nmero tercero
Lado3 = tercero
Si (Lado1 + Lado2) > Lado3 haga
Si (Lado1 = Lado2 = Lado3) haga
Presente El tringulo es equiltero
Si no
Si (Lado1 Lado2 Lado3) haga
Presente El tringulo es escaleno

Si no
Presente El tringulo es issceles
Fin si
Fin si
Si no
Presente No es un tringulo
Fin si
Si no
Presente No es tringulo
Fin si
Si no
Fin si
Terminar
Diagrama de flujo
Iniciar
primero
Lado1 = primero
segundo
Lado2 = segundo
tercero
Lado3 = tercero
A
(Lado1 + Lado2) No
> Lado3
Si
(Lado1 + Lado3) No
> Lado2
Si
(Lado2 + Lado3) No
> Lado1
Si
Si Lado1 = Lado2
= Lado3
Tringulo No
equiltero
Si Lado1 Lado2
Lado3
Tringulo No es un
No
escaleno Tringulo
Tringulo
issceles
Terminar
Figura 2.7
Para realizar la verificacin del funcionamiento de este algoritmo, se

toman tres valores y se realizan las comparaciones respectivas para
saber si corresponden a un tringulo y si es as, a qu tipo de tringulo.
primero segundo tercero Lado1 Lado2 Lado3

4 5 3 4 5 3
Tabla 2.24
Inicialmente, se leen los valores y se guardan en las tres variables

respectivas. La primera comparacin es cierta, ya que (Lado1 + Lado2)
> Lado3, entonces se debe continuar con la opcin del si, ahora (Lado2
+ Lado3) > Lado1, esta comparacin result cierta, entonces se sigue
con la opcin del si, y se tiene (Lado1 + Lado3) > Lado2, despus de
hacer estas comparaciones entre los valores de las variables, se puede
decir que corresponden a un tringulo.
Para saber qu tipo de tringulo es, se comparan los valores de las tres
variables para comprobar si son iguales o diferentes, en este caso los
tres valores son diferentes entre s, entonces el tringulo es escaleno.
Hacer ahora la prueba de escritorio para otros valores diferentes:
primero segundo tercero Lado1 Lado2 Lado3

2 4 2 2 4 2
Tabla 2.25
Inicialmente, se leen los valores y se guardan en las tres variables

respectivas. La primera comparacin es cierta, ya que (Lado1 + Lado2)
> Lado3, entonces se debe continuar con la opcin del si, ahora (Lado2
+ Lado3) > Lado1, esta comparacin result cierta, entonces se sigue
con la opcin del si, y se tiene (Lado1 + Lado3) > Lado2, que resulta
falso, entonces los lados no corresponden a un tringulo, porque 2 + 2
> 4 no es cierto, entonces se presenta el mensaje No es un tringulo y
termina el algoritmo.
E.2.6 La comisin que recibe un vendedor sobre las ventas es:
Si ventas < $ 500,000 no hay comisin.

Si $ 500,000 <= ventas <= $ 2500,000, la comisin es del 10% de
las ventas.
Si Venta > $ 2000,000 una comisin de $ 100,000 + 7% de las
ventas mayores que $ 600,000.
Escriba un algoritmo que calcule las ventas y las comisiones del

vendedor.
En este ejercicio, se debe calcular el valor de las ventas que realiza un

vendedor. En el caso de que las ventas sean mayores de $ 2000,000
pero menores o iguales a $ 2500,000, tiene derecho a las dos
comisiones del 10% y del 7%, pero si son mayores de $ 2500,000,
entonces solo tiene derecho a $ 100,000 ms el 7% de las Ventas
mayores que $ 600,000.
Algoritmo
Paso 1: Lea el valor de ventas.

Paso 2: En la variable Venta, almacene el valor ledo de ventas.
Paso 3: Si Venta es menor de $ 500,000 haga la variable Comisin igual
a 0.
Paso 4: Si Venta es mayor o igual que $ 500,000 y menor o igual que $
2500,000 haga la variable Comisin igual al 10 % de Venta.
Paso 5: Si Venta es mayor que $ 2000,000 la Comisin es igual a $

100,000 ms el 7% de Venta mayores que $ 600,000 ms Comisin.
Paso 5: Presente Ventas =, Venta
Paso 6: Presente Comisin =, Comisin
Paso 7: Terminar
Seudocdigo
Lea ventas
Venta = ventas
Si Venta < $ 500,000 haga
Comisin = 0
Fin si
Si $500,000 <= Venta Venta <= $2500,000 haga
Comisin = Venta * 0.1
Fin si
Si Venta > $ 2000,000 haga
Comisin = Comisin + $ 100,000 + (Venta - $ 600,000) *
0.07
Fin si
Presente Ventas = , Venta
Presente Comisin = , Comisin
Terminar
Diagrama de flujo
Iniciar
ventas
Venta = ventas
A
Si
Venta < $ 500,000
Comisin = 0
ventas
$500,000 <= Venta Si
Venta <= $2500,000
Comisin = Venta*0.1
Venta > $2000,000 Si
Comisin = Comisin
+ $100,000 + (Venta
- $600,000)*0.07
Ventas = , Venta
Comisiones = , Comisiones
Terminar
Figura 2.8
Tomar el valor de las ventas igual a $ 2450,000.
ventas
$ 2450,000
Tabla 2.26
Ahora se guarda el valor ledo de las ventas en la variable Ventas.
ventas Venta
$ 2450,000 $ 2450,000
Tabla 2.27
La primera validacin de la variable Venta, pide que se verifique si es

menor que $ 500,000; en este caso no es cierto, entonces se hace la
asignacin de la variable Comisin igual a cero.
ventas Venta Comisin

$ 2450,000 $ 2450,000 0
Tabla 2.28
En la segunda comparacin de la variable Venta, se comprueba que la

expresin $500,000 <= Venta Venta <= $2500,000 se cumple, el
paso a seguir es calcular la comisin, que es igual al 10% de las ventas.
ventas Venta Comisin

$ 2450,000 $ 2450,000 0
$ 245,000
Tabla 2.29
Por ltimo falta comprobar la tercera expresin Venta > $2000,000; en

este caso es verdadera. El valor de la Comisin es $229,500. La
comisin final es de $ 245,000 ms la comisin por ser las ventas
mayores de $ 2000,000 que es igual a $ 229,500. Los mensajes son
Ventas =, Venta, Comisin =, Comisin.
ventas Venta Comisin Mensaje

$ 2450,000 $ 2450,000 0
$ 245,000 Ventas =, Venta
$ 474,500 Comisin =, Comisin
Tabla 2.30
2.2 Proceso Si _____ ; haga _____ ; sino haga _____
Otra posibilidad que se presenta cuando se realiza una comparacin de

datos, variables, de los resultados de una operacin, o la comprobacin
de una expresin, se pueden presentar dos opciones o rutas lgicas en
el algoritmo. Si se cumple la condicin, haga o ejecute determinada
operacin; de lo contrario haga aquella otra. La manera de representar
este progreso grficamente es la siguiente:
No Si
Si ____?
Figura 2.9
Es un proceso sencillo, pero de mucha utilidad cuando se est

programando o escribiendo algoritmos y se est aplicando la
programacin estructurada. Para aplicar este proceso, se debe tener
cuidado de no cometer algunos errores de concepto, cuando se trabaja
con este proceso anidado dentro de otro; esto se va a encontrar en los
siguientes ejercicios.
E.2.7 Crear un algoritmo para comparar dos nmeros diferentes y decir

cul es el mayor y cul el menor. El valor del primer nmero
almacenarlo en una variable llamada Primero y el valor del segundo
nmero en una variable llamada Segundo. Al final presentar un mensaje
que diga El mayor es: y a continuacin el nmero; seguido de El

menor es: y enseguida el nmero.
Se van a leer dos nmeros, y luego se realizan las comparaciones

necesarias para determinar cul es el mayor y cul es el menor, y por
ltimo se presenta al usuario que est trabajando con el algoritmo un
mensaje indicando qu nmero es el mayor y qu nmero es el menor.
Se puede trabajar con la comparacin de que el primero sea mayor que
el segundo o que el primero sea menor que el segundo. Ambas son
vlidas.
Algoritmo
Paso 1: Conocer el primer nmero.

Paso 2: Guardarlo en la variable Primero.
Paso 3: Conocer el segundo nmero.
Paso 4: Guardarlo en la variable Segundo.
Paso 5: Si Primero es mayor que Segundo vaya al Paso 6, de lo
contrario vaya al Paso 7.
Paso 6: Decir cul es el mayor
Paso 7: Decir cul es el menor
Paso 8: Terminar
Seudocdigo
Lea primero
Primero = primero
Lea segundo
Segundo = segundo
Si (Primero > Segundo) haga
El mayor nmero es:, Primero
El menor nmero es:, Segundo
Si no
El mayor nmero es:, Segundo
El menor nmero es:, Primero
Fin si
Terminar
En el seudocdigo anterior, se ve que una parte est tabulada hacia la

derecha. Esta tabulacin se utiliza para indicar que esa fraccin del
seudocdigo est dentro del Si.
El mayor nmero es el primero

El menor nmero es el segundo
Al igual que la parte que est dentro del si no.
El mayor nmero es el segundo

El menor nmero es el primero
Es una forma de darle mayor claridad al seudocdigo en caso de que lo

lea una persona diferente a quien hizo el algoritmo. Es importante tener
presente que los cdigos o algoritmos van a ser estudiados y ledos por
otras personas diferentes a quien los escribe, entonces es una buena
costumbre de programacin, dejar todo lo que se escriba de la manera
ms fcil de entender por cualquier persona y an para el mismo
programador, porque despus de un tiempo puede ser necesario
actualizar una aplicacin o programa de computacin y, si no es claro el
algoritmo, no va a ser muy fcil realizar esta tarea, as sea el mismo
autor del cdigo quien lo va a modificar.
Diagrama de flujo
Iniciar
primero
Primero = primero
segundo
Segundo = segundo
No Si
Primero > Segundo
El mayor es: El mayor es:

Segundo; El menor Primero; El menor
es: Primero es: Segundo
Terminar
Figura 2.10
Como se puede ver, la comparacin entre la variable Primero y Segundo

se representa dentro del rombo que permite las dos alternativas en dos
de sus vrtices.
No Si
Primero > Segundo
Figura 2.11
De acuerdo con la respuesta que se reciba en el momento de hacer la

comparacin, as mismo se ejecuta una instruccin diferente,
dependiendo de que la respuesta sea Si o No. En este ejercicio se
compar Primero > Segundo, pero tambin se puede hacer Primero <
Segundo. Ambas expresiones son correctas.
Es el momento de verificar si la lgica utilizada para escribir el algoritmo

est correcta y los valores que presenta son vlidos. Se toman
inicialmente dos nmeros cualesquiera y se le asignan a las variables
primero y segundo registrndolos en una tabla. Se utilizan los nmeros -
1y2
primero
-1
Tabla 2.31
Siguiendo el orden de las instrucciones del diagrama de flujo, se

almacena ese valor en una variable de nombre Primero.
primero Primero
-1 -1
Tabla 2.32
Se repite el mismo procedimiento para leer el segundo nmero.
primero Primero segundo

-1 -1 2
Tabla 2.33
Se almacena este valor en una variable de nombre Segundo.
primero Primero segundo Segundo

-1 -1 2 2
Tabla 2.34
Ahora se hace la comparacin, el contenido de la variable Primero es

mayor que el contenido de la variable Segundo? No, entonces, se
presenta el mensaje al usuario del algoritmo.
primero Primero segundo Segundo Mensaje

-1 -1 2 2 El mayor es: 2; El menor es: -1
Tabla 2.35
Se toman los valores invertidos, para verificar la otra opcin que

permite el algoritmo.
Primero Segundo
2 -1
Tabla 2.36
El contenido de la variable Primero es mayor que el contenido de la

variable Segundo? Si, entonces
Primero Segundo Mensaje

2 -1 El mayor es: 2; El menor es: -1
Tabla 2.37
E.2.8 Escriba un algoritmo que evale todas las posibles soluciones de

una ecuacin de segundo grado, Races reales y complejas.
Para desarrollar este ejercicio correctamente, se debe hacer un anlisis

de la informacin muy riguroso. El enunciado es inofensivo, pero el
desarrollo no lo es.
Para empezar cul es la forma de una ecuacin de segundo grado?
sta es la forma general de una ecuacin de segundo grado.
Cmo se resuelve una ecuacin de segundo grado? Bueno, hay dos

formas, si es factorizable, entonces se factoriza y se despejan las races
para poder encontrar las races que son las soluciones de la ecuacin.
Si no es factorizable cmo se calculan las races?
Esta ecuacin calcula las races de la ecuacin de segundo grado,

simplemente reemplazando los coeficientes A, B y C. Qu pasa si A es
igual a cero? Hasta ahora todo va bien, pero qu pasa si el valor del
discriminante es menor que 0? Si es mayor o igual a cero, las
races estn dentro del conjunto de los reales, pero si es menor se tiene
una raz cuadrada de un nmero negativo, que corresponde al conjunto
de los imaginarios.
En el captulo anterior se realiz un ejercicio que trata de operaciones

con nmeros complejos, entonces ya se sabe que , que es un
dato importante en el momento de calcular el discriminante. Cuando se
escribe esta expresin se est indicando que se va a calcular
su valor absoluto. Entonces ya se sabe que se pueden tener races
reales y races complejas y en un caso muy particular daran races

imaginarias. En qu caso sera?
Cuando los enunciados se van complicando, es importante, hacer un

anlisis de la informacin, y no empezar a escribir un algoritmo a la
ligera que no contempla todas las posibilidades.
Algoritmo
Paso 1: Leer a.
Paso 2: Almacenar en la variable A el valor de a.
Paso 3: Leer b.
Paso 4: Almacenar en la variable B el valor de b.
Paso 5: Leer c.
Paso 6: Almacenar en la variable C el valor de c.
Paso 7: Calcular y guardar el valor en la variable Discriminante.
Paso 8: Valide si Discriminante es mayor que 0. Si es cierto contine con
el paso siguiente de lo contrario vaya al Paso 12.
Paso 9: Calcule y gurdelo en una variable X1.
Paso 10: Calcule y gurdelo en una variable X2.
Paso 11: Presente X1 =, X1; X2 =, X2. Vaya al Paso 16.
Paso 12: Calcule y guarde en la variable Discriminante1.
Paso 13: Calcule y guarde este valor en la variable Factor.
Paso 14: Presente X1 =, Factor, +, Discriminente1, .
Paso 15: Presente X2 =, Factor, -, Discriminente1, .
Paso 16: Terminar.
En el Paso 12, para poder calcular la raz cuadrada del nmero, primero
se calcula el valor absoluto de la cantidad que est dentro del radical y
luego si se calcula la raz, porque corresponde a un nmero negativo y
la raz cuadrada de los nmeros negativos no est contemplada dentro
del conjunto de los nmeros reales.
Seudocdigo
Lea A
A=A
Lea B
B=B
Lea C
C=C
Discriminante =
Si Discriminante > 0 haga
X1 =
X2 =
Presente X1 =, X1; X2 =, X2
Si no
Discriminante1 =
Factor =
Presente X1 =, Factor, +, Discriminente1, .
Presente X2 =, Factor, -, Discriminente1, .
Fin si
Terminar
Diagrama de flujo
Inicia
r
A=A
A
B=B
C=C
Discriminante =
No Si
Discriminante >0
Discriminante1 = X1 =
Factor = X1 =
X1 =, Factor, +, Discriminente1, ; X1 =, X1; X2 =, X2

X2 =, Factor, -, Discriminente1,
Terminar
Figura 2.12
Este es un ejercicio interesante, que permite ver claramente, que antes

de empezar a escribir, se debe analizar la informacin que dan en el
enunciado del ejercicio, qu se tiene que calcular antes de poder llegar a
la respuesta final y por qu mtodos. La prueba de escritorio se hace
para la ecuacin:
Se leen los tres coeficientes y se guardan en tres variables, A, B y C.
A B C
7 2 1
Tabla 2.38
La instruccin siguiente es calcular el valor del discriminante.
A B C Discriminante
7 2 1 -32
Tabla 2.39
El discriminante es menor que 0, entonces este valor est dentro del

conjunto de los imaginarios porque no se puede calcular la raz cuadrada
de un nmero dentro del conjunto de los nmeros reales. Entonces
calcular el valor de Discriminante1
A B C Discriminante Discriminante1
7 2 1 -32
Tabla 2.40
El clculo de la variable Factor es
A B C Discriminante Discriminante1 Factor

7 2 1 -32
Tabla 2.41
Los clculos ya estn todos realizados, entonces se puede presentar el

mensaje con los valores de las dos races complejas.
A B C Discriminante Discriminante1 Factor X1 X2

7 2 1 -32
Tabla 2.42
El lector puede realizar la prueba de escritorio de este ejercicio para una

ecuacin de segundo grado con races reales, por ejemplo:
E.2.9 En una universidad tienen los siguientes criterios para admitir a

los estudiantes. Clasifican los exmenes de admisin calificados de 0 a
100 de la siguiente manera:
0 <= bajo <= 65
66 <= medio <= 85
86 <= alto <= 100
Si un estudiante obtuvo un puntaje alto, tiene el cupo para la primera

opcin de carrera para la cual se inscribi. Si el puntaje es medio, tiene
el cupo para la segunda opcin de carrera que se inscribi. Si el puntaje
es bajo, no tiene el cupo para entrar a la universidad. Las becas se
otorgan nicamente a los estudiantes nuevos que tuvieron el puntaje
alto y el criterio para adjudicarlas es: Si el promedio de la secundaria es
mayor que 4.50, el aspirante tiene una beca del 100% del valor del
semestre, si su promedio fue menor o igual a 4.50, y mayor que 4.00 le
otorgan beca del 50% del valor del semestre.
Escriba un algoritmo que lea el cdigo del estudiante, el puntaje de su

examen de admisin y la nota promedio de su educacin secundaria, y
luego clasifique el puntaje, el promedio de la secundaria y le informe si

fue admitido, a que opcin inscrita y si fue becado.
En este ejercicio, hay que poner atencin a los estudiantes que obtienen
el puntaje alto, para luego hacer la validacin de la informacin del
promedio de la secundaria y poder determinar si tienen derecho a beca
y qu tipo de beca, lo dems ya se ha trabajado en los ejercicios
anteriores.
Algoritmo
Paso 1: Lea el cdigo del estudiante.

Paso 2: Guardar el cdigo en la variable Id.
Paso 3: Lea la calificacin del examen de admisin del estudiante.
Paso 4: Guardar la calificacin en la variable Puntaje.
Paso 5: Lea el promedio de la secundaria del estudiante.
Paso 6: Guardar el promedio de la secundaria en la variable Prom.
Paso 7: Si Puntaje es mayor o igual a 86 contine, sino Paso 13.
Paso 8: Si Prom es mayor que 4.5 contine, de lo contrario Paso 10.
Paso 9: Presente Id, aceptado primera opcin, Beca 100% Vaya Paso
15
Paso 10: Si Prom es mayor que 4.0 y menor o igual que 4.5 contine,
de lo contrario Paso 12.
Paso 11: Presente Id, aceptado segunda opcin. Beca 50% Vaya paso
15.
Paso 12: Presente Id, aceptado segunda opcin. Vaya paso 15.
Paso 13: Si Puntaje es mayor o igual a 66 y Puntaje menor o igual a 85
contine, de lo contrario Paso 15
Paso 14: Presente Id, aceptado segunda opcin.
Paso 15: Terminar.
Seudocdigo
Lea cdigo
Id = cdigo
Lea examen
Puntaje = examen
Lea promedio
Prom = promedio
Si Puntaje >= 86 haga
Si Prom > 4.5 haga
Presente Id, Aceptado primera opcin. Beca 100%
Sino
Si Prom > 4.0 y Prom <= 4.5
Presente Id, Aceptado primera opcin. Beca 50%
Sino
Presente Id, aceptado primera opcin
Fin si
Fin si
Sino
Si Puntaje >= 66 y Puntaje <= 85 haga
Presente Id, aceptado segunda opcin.
Fin si
Fin si
Diagrama de flujo
Iniciar
cdigo
Id = cdigo
A
examen
Puntaje = examen
promedio
Prom = promedio
No Si
Puntaje >= 86
Si
Prom > 4.5
Puntaje >= 66 Si No Id, Aceptado,
Y
primera opcin,
Puntaje <= 85
Beca 100%
Id, Aceptado,
segunda opcin
No C
Prom <= 4.5
Si
Y
Prom > 4.0
Id, Aceptado,
No primera opcin,
Beca 50%
Id, Aceptado,
primera opcin C
Terminar
Figura 2.13
Los datos que se van a utilizar para hacer la prueba de escritorio son:
cdigo = 98765, examen = 98, promedio = 4,6. Se guardan en las
variables correspondientes.
Cdigo Examen Promedio Id Puntaje Prom

98765 98 4,6 98765 98 4,6
Tabla 2.43
En la primera expresin que se valida, se comprueba que el puntaje es

mayor que 86, entonces se sigue por la alternativa del si. La siguiente
comprobacin, tambin es cierta, pues el promedio es 4,6 y la
alternativa a seguir es la del si. Entonces el mensaje que se presenta es
Id, Aceptado, primera opcin, Beca 100%.
Cdigo Examen Promedio Id Puntaje Prom

98765 98 4,6 98765 98 4,6
Mensaje
Id, Aceptado, primera opcin, Beca 100%
Tabla 2.44
2.3 Proceso conmutar
A este proceso se le llama conmutar, porque eso es lo que hace, cambia

o conmuta entre varias posibilidades que presenta la estructura,
despus de haber hecho la validacin de la informacin y luego decide
cul es la que cumple con el resultado que se obtuvo en la comparacin.
Este es el tercer proceso que se utiliza cuando hay toma de decisiones
entre tres o ms alternativas.
Este tipo de proceso tiene aplicacin cuando se presentan varios

caminos a seguir despus de que se evala una expresin, que no
necesariamente tenga como respuesta verdadero o falso, si o no. Con
los ejercicios que se desarrollan a continuacin, se aclara este concepto.
La representacin grfica de este proceso, que se utiliza en los

diagramas de flujo, es la de la Figura 2.14.
Expresin a evaluar
Si Accin a
Opcin 1
ejecutar 1
No
Si Accin a
Opcin 2
ejecutar 2
No
Si Accin a
Opcin 3
ejecutar 3
No
Si Accin a
Opcin
ejecutar
N
No N
Accin a
ejecutar por
defecto
Salir del
proceso
Figura 2.14
En este diagrama de flujo se puede ver que inicialmente se recibe una

expresin, que se debe evaluar con las diferentes posibilidades que
presenta el proceso. En el momento que cumple con alguna de estas
opciones, sigue por el camino indicado por el si, ejecuta la accin
establecida para esta alternativa y luego sale del proceso. Si no cumple

con ninguna de las opciones establecidas, entonces ejecuta la
instruccin que est establecida por defecto y luego sale del proceso. La
mejor manera de entenderlo es desarrollando unos ejercicios.
E.2.10 Cree un algoritmo que lea un nmero positivo y luego presente

un mensaje que indique cmo se llama el polgono que tiene ese nmero
de lados, siempre y cuando el nmero de lados sea menor o igual a 8
lados.
Para empezar, hay que conocer el nmero con que se va a hacer la

comparacin, despus de conocerlo, se debe tener en cuenta que no hay
polgonos de menos de tres lados, adems si el nmero de lados es
mayor a ocho lados, debe informarse al usuario que el nmero ledo es
mayor a ocho lados.
Algoritmo
Paso 1: Lea el nmero de lados

Paso 2: Almacenar en la variable Nlados.
Paso 3: Compare si Nlados es igual a uno. SI es as, presente un
mensaje que diga no hay polgonos de un lado y termine, de lo
contrario, siga con el paso siguiente
Paso 4: Compare si Nlados es igual a dos. SI es as, presente un
mensaje que diga no hay polgonos de dos lados y termine, de lo
Paso 5: Compare si Nlados es igual a tres. SI es as, presente un
mensaje que diga el polgono es un tringulo y termine, de lo
Paso 6: Compare si Nlados es igual a cuatro. SI es as, presente un
mensaje que diga el polgono es un cuadriltero y termine, de lo
Paso 7: Compare Nlados es igual a cinco. SI es as, presente un mensaje

que diga el polgono es un pentgono y termine, de lo contrario, siga
con el paso siguiente
Paso 8: Compare si Nlados es igual a seis. SI es as, presente un
mensaje que diga el polgono es un hexgono y termine, de lo
Paso 9: Compare si Nlados es igual a siete. SI es as, presente un
mensaje que diga el polgono es un heptgono y termine, de lo
Paso 10: Compare si Nlados es igual a ocho. SI es as, presente un
mensaje que diga el polgono es un octgono y termine, de lo
Paso 11: Si Nlados es mayor que ocho. Presente un mensaje que diga
el polgono es mayor de ocho lados y termine
Seudocdigo
Lea Nmero
Nlados = Nmero
Si Nlados = 1 haga
No hay polgonos de un lado
Termine
Fin si
Si Nlados = 2 haga
No hay polgonos de dos lados
Termine
Fin si
Si Nlados = 3 haga
El polgono es un tringulo
Termine
Fin si
Si Nlados = 4 haga
El polgono es un cuadriltero
Termine
Fin si
Si Nlados = 5 haga
El polgono es un pentgono
Termine
Fin si
Si Nlados o = 6 haga
El polgono es un hexgono
Termine
Fin si
Si Nlados = 7 haga
El polgono es un heptgono
Termine
Fin si
Si Nlados = 8 haga
El polgono es un octgono
Termine
Si no
El polgono es de ms de 8 lados
Fin si
Termine
Diagrama de flujo
Iniciar
Nmero
Nlados = Nmero
Si No hay polgonos
Nlados = 1 de 1 lado
B
A
A B
Si No hay polgonos
Nlados = 2 de 2 lado
Si El polgono es un
Nlados = 3 tringulo
No
Si El polgono es un
Nlados = 4 cuadriltero
No
Si El polgono es un
Nlados = 5 pentgono
No
Si El polgono es un
Nlados = 6 hexgono
No
Si El polgono es un
Nlados = 7 heptgono
No
Si El polgono es un
Nlados = 8 octgono
No
El polgono es de
ms de 8 lados
Terminar
Figura 2.15
Es el momento de probar si la lgica aplicada fue la correcta, cuando se

escribi el algoritmo. Se toma un valor de prueba para empezar, se
almacena en la variable Nlados y se registra en la Tabla, para empezar a
ejecutar las instrucciones que indica el diagrama de flujo.
Nmero Nlados
4 4
Tabla 2.45
Entonces, ya se ley el valor de la variable Nlados y se va a realizar la

primera comparacin, se quiere saber si el valor de Nlados es igual a
uno?, no, entonces se verifica la siguiente alternativa Nlados es igual a
dos?, tampoco se cumple, se contina con la siguiente, Nlados es igual
a tres?, no se cumple, la que est a continuacin, Nlados es igual a
cuatro? Esta si se cumple, entonces se sigue por la opcin del Si, en el
smbolo de decisin, y se ejecuta la instruccin indicada que es
presentar un mensaje que contenga el siguiente mensaje El polgono es
un cuadriltero.
Nmero Mensaje
4 El polgono es un cuadriltero
Tabla 2.46
La instruccin que falta por ejecutar es la de terminar el proceso. Se

comprob que el algoritmo est cumpliendo con los requerimientos
establecidos al comienzo del ejercicio y arroja los resultados esperados,
adems se comprob que el proceso conmutar es fcil de aplicar.
E.2.11 Cree un algoritmo que lea una nota y le de al estudiante su

equivalente de acuerdo con la siguiente tabla:
5 Excelente
4 Bueno
3 Regular
2 Deficiente
1 Malo
Tabla 2.47
Este es el equivalente del desempeo del estudiante durante el mes.
Este algoritmo pide que se lea una nota, este valor se debe comparar
con los valores establecidos en la tabla anterior, para poder presentar
un mensaje al usuario de cmo fue su desempeo mensual.
Algoritmo
Paso 1: Lea nmero

Paso 2: Guardar nmero en Nota
Paso 3: Si Nota es igual a 5, presente Excelente y termine el proceso,
de lo contrario contine con la comparacin siguiente
Paso 4: Si Nota igual a 4, presente Bueno y termine el proceso, de lo
contrario contine con la comparacin siguiente
Paso 5: Si Nota igual a 3, presente Regular y termine el proceso, de lo
contrario contine con la comparacin siguiente
Paso 6: Si Nota es igual a 2, presente Deficiente y termine el proceso,
de lo contrario presente Malo y termine
Seudocdigo
Lea nmero
Nota = nmero
Si Nota = 5 haga
Presente Excelente
Terminar
Fin si
Si Nota = 4 haga
Presente Bueno
Terminar
Fin si
Si Nota = 3 haga
Presente Regular
Terminar
Fin si
Si Nota = 2 haga
Presente Deficiente
Si no
Presente Malo
Fin si
Terminar
Diagrama de flujo
Iniciar
Nmero
Nota = Nmero
Si
Nota = 5 Excelente
No
Si
Nota = 4 Bueno
No B
A
A B
Si
Nota = 3 Regular
No
Si
Nota = 2 Deficiente
No
Malo
Terminar
Figura 2.16
Este es el momento de probar si el trabajo estuvo bien hecho,

realizando la prueba de escritorio. Se toma un valor para la nota que
determina cul es el desempeo correspondiente y se almacena en la
variable Nota. Esta asignacin se realiza escribindola en la siguiente
tabla.
Nmero Nota
3 3
Tabla 2.48
Como ya se tiene el valor de la variable Nota, se realiza la primera

comparacin
Si
Nota = 5
Figura 2.17
El valor de la variable Nota, no es igual a 5, es 3, entonces no se puede

optar por la opcin Si, se sigue con la comparacin siguiente.
Si
Nota = 4
Figura 2.18
En esta segunda comparacin el valor de la variable Nota, no es igual a

4, es 3, entonces no se puede optar por la opcin Si, se sigue con la
comparacin siguiente.
Si Regular
Nota = 3
Figura 2.19
Esta comparacin si cumple con la condicin de que Nota es igual a 3.

Entonces ya se puede seguir por la opcin si, para continuar con el flujo
establecido por el algoritmo. Entonces la instruccin a ejecutar es
imprimir un mensaje que dice Regular y a continuacin terminar el
proceso.
Nota Mensaje
3 Regular
Tabla 2.49
Ya se comprob que el algoritmo cumple con los requerimientos

establecidos en el enunciado.
E.2.12 Escriba un algoritmo por medio del cual se pide el da y el mes

de nacimiento y luego le dice al usuario, cul es su signo zodiacal.
El enunciado de este ejercicio es de los que dan poca informacin, pero

exigen documentarse antes de empezar a trabajar. Para empezar se
debe saber cules son los signos zodiacales, en qu da y mes empieza y
en qu da y mes termina. Los meses se identifican Enero =1,
Febrero=2, Marzo=3, Abril=4, Mayo=5, Junio=6, Julio=7, Agosto=8,
Septiembre=9, Octubre=10, Noviembre=11, Diciembre=12.
El listado de los signos zodiacales, con el da en que empieza y en que

termina es:
Capricornio: 22 Diciembre - 19 Enero

Acuario: 20 Enero 18 Febrero
Piscis: 19 Febrero 20 Marzo
Aries: 21 Marzo 19 Abril
Tauro: 20 Abril 20 Mayo
Gminis: 21 Mayo 19 Junio
Cncer: 20 Junio 22 Julio
Leo: 23 Julio 22 Agosto
Virgo: 23 Agosto 22 Septiembre
Libra: 23 Septiembre 22 Octubre
Escorpin: 23 Octubre 21 Noviembre
Sagitario: 22 Noviembre 21 Diciembre
Con esta informacin, ya se puede empezar a escribir el algoritmo que

calcula a qu signo zodiacal corresponde el usuario del programa.
Algoritmo
Paso 1: Leer cul es el da de nacimiento.

Paso 2: Guardar da en la variable Da.
Paso 3: Leer cul es el mes de nacimiento.
Paso 4: Guardar mes en la variable Mes.
Paso 5: Si Mes = 1 contine, sino ir al Paso 8

Paso 6: Si Da <= 19 hacer Signo = Capricornio, sino Signo = Acuario
Paso 7: Presentar Usted es signo , Signo, luego terminar.
Paso 9: Si Da <= 18 hacer Signo = Acuario sino Signo = Piscis
Paso 11: Mes = 3 contine, sino ir al Paso 14
Paso 12: Si Da <= 20 hacer Signo = Piscis sino Signo = Aries
Paso 15: Si Da <= 19 hacer Signo = Aries sino Signo = Tauro
Paso 18: Si Da <= 20 hacer Signo = Tauro sino Signo = Gminis
Paso 21: Si Da <= 19 hacer Signo = Gminis sino Signo = Cncer
Paso 24: Si Da <= 22 hacer Signo = Cncer sino Signo = Leo
Paso 27: Si Da <= 22 hacer Signo = Leo sino Signo = Virgo
Paso 30: Si Da <= 22 hacer Signo = Virgo sino Signo = Libra
Paso 32: Si Mes igual 10 contine, sino ir al Paso 35
Paso 33: Si Da <= 22 hacer Signo igual Libra sino Signo igual Escorpin
Paso 36: Si Da <= 21 hacer Signo = Escorpin sino Signo = Sagitario
Paso 38: Si Mes = 12 haga
Paso 39: Si Da <= 21 hacer Signo = Sagitario sino Signo = Capricornio

Paso 40: Presentar Usted es signo , Signo
Paso 41: Terminar
Seudocdigo
Leer da
Da = da
Leer mes
Mes = mes
Si Mes = 1 haga
Si Da <= 19 hacer
Signo = Capricornio
sino
Signo = Acuario
Fin si
Presentar Usted es signo , Signo
Terminar
Fin si
Si Mes = 2 haga
Si Da <= 18 hacer
Signo = Acuario
sino
Signo = Piscis
Fin si
Terminar
Fin si
Si Mes = 3 haga
Si Da <= 20 hacer
Signo = Piscis
sino
Signo = Aries
Fin si

Terminar
Fin si
Si Mes = 4 haga
Si Da <= 19 hacer
Signo = Aries
sino
Signo = Tauro
Fin si
Terminar
Fin si
Si Mes = 5 haga
Si Da <= 20 hacer
Signo = Tauro
sino
Signo = Gminis
Fin si
Terminar
Fin si
Si Mes = 6 haga
Si Da <= 19 hacer
Signo = Gminis
sino
Signo = Cncer
Fin si
Terminar
Fin si
Si Mes = 7 haga
Si Da <= 22 hacer
Signo = Cncer
sino
Signo = Leo
Fin si
Terminar
Fin si
Si Mes = 8 haga
Si Da <= 22 hacer
Signo = Leo
sino
Signo = Virgo
Fin si
Terminar
Fin si
Si Mes = 9 haga
Si Da <= 22 hacer
Signo = Virgo
sino
Signo = Libra
Fin si
Terminar
Fin si
Si Mes = 10 haga
Si Da <= 22 hacer
Signo = Libra
sino
Signo = Escorpin
Fin si
Terminar
Fin si
Si Mes = 11 haga
Si Da <= 21 hacer
Signo = Escorpin
sino
Signo = Sagitario
Fin si
Terminar
Fin si
Si Mes = 12 haga
Si Da <= 21 hacer
Signo = Sagitario
sino
Signo = Capricornio
Fin si
Fin si
Terminar
Diagrama de flujo
Iniciar
da
Da = da
mes
Mes = mes
A
Si
Mes = 1
No Si
Da <= 19
Signo = Acuario Signo = Capricornio
Usted es signo , Signo
Si
Mes = 2
No Si
Da <= 18
Signo = Piscis Signo = Acuario
Si
Mes = 3
No Si
Da <= 20
Signo = Aries Signo = Piscis
Si
Mes = 4
No Si
Da <= 19
Signo = Tauro Signo = Aries
C Usted es signo , Signo

B
C B
Si
Mes = 5
No Si
Da <= 20
Signo = Gminis Signo = Tauro
Si
Mes = 6
No Si
Da <= 19
Signo = Cncer Signo = Gminis
Si
Mes = 7
No Si
Da <= 22
Signo = Leo Signo = Cncer
Si
Mes = 8
No Si
Da <= 22
Signo = Virgo Signo = Leo

D E
D
E
Si
Mes = 9
No Si
Da <= 22
Signo = Libra Signo = Virgo
Si
Mes = 10
No Si
Da <= 22
Signo = Escorpin Signo = Libra
Si
Mes = 11
No Si
Da <= 21
Signo = Sagitario Signo = Escorpin
Si
Mes = 12
No Si
Da <= 21
Signo = Capricornio Signo = Sagitario

Terminar
Figura 2.20
Este ejercicio es representativo para entender la metodologa de cmo

se debe aplicar del proceso conmutar. Se puede observar el poder que
tiene este proceso y la cantidad de trabajo que se ahorra si se hace uso
de l apropiadamente. Los datos de prueba para validar el correcto
funcionamiento de este algoritmo son: da = 12 y mes = 28.
da Da
28 28
Tabla 2.50
Se contina con la lectura del mes y almacenamiento del valor en la

variable Mes.
da Da mes Mes
28 28 12 12
Tabla 2.51
Se realizan las doce comparaciones de acuerdo a cada uno de los meses

y se puede verificar que en cada una de ellas se contina por la opcin
del No, ya que slo coincide con la ltima que es Mes = 12. Como el da
es mayor que 21, se sigue por la ruta del No, que hace que la variable
Signo guarde el valor Capricornio.
da Da mes Mes Signo

28 28 12 12 Capricornio
Tabla 2.52
Para terminar, nicamente hace falta presentar el mensaje que le indica

al usuario cul es su signo zodiacal. En este caso es: Usted es signo ,
Signo.
da Da mes Mes Signo Mensaje

28 28 12 12 Capricornio Usted es signo, Capricornio
Tabla 2.53
2.4 Resumen
Los procesos de decisin se utilizan cuando es necesario tomar

decisiones entre varios resultados o alternativas, de acuerdo con
expresiones lgicas que utilizan operadores relacionales y lgicos.
En este captulo se ha trabajado con las tres modalidades de
procesos de decisin:
o proceso Si ____haga ____
o proceso Si ____haga ____ si no____
o proceso conmutador para ms de una posible opcin de
decisin.
Las variables cumplen funciones de contadores o acumuladores.
Son acumuladores, cuando al valor de una variable se le suma una
cantidad, y luego el valor de esa suma se guarda en la variable
inicial.
Son contadores, cuando al valor de una variable se le suma uno, y
luego el valor de esa suma se guarda en la variable inicial. Sirven
para controlar el lmite de un proceso.
El proceso Si _____ haga _____, es de seleccin simple, y permite
que el flujo del algoritmo siga por una ruta especfica si cumple con
las condiciones evaluadas.
El proceso Si _____ haga _____ sino _____, es de seleccin doble, y
permite que el flujo del algoritmo siga por cualquiera de las dos rutas
especificadas, si cumple con las condiciones evaluadas. Si despus
de hacer la evaluacin, sta resulta cierta, entonces sigue un camino,

si resulta falsa, sigue por el otro camino establecido.
El proceso conmutar, porque eso es lo que hace, cambia o conmuta
entre varias posibilidades que presenta la estructura, permite que el
algoritmo despus de haber hecho la validacin de la informacin
siga por el camino que corresponde segn la opcin obtenida.
EP.2.1 Escriba un algoritmo para un supermercado que da a sus

clientes los siguientes descuentos de acuerdo al valor de su compra.
0 <= Compra <= $ 10,000, no hay descuento

$ 10,000 < Compra <= $ 25,000, 4% de descuento
$ 100,000 < Compra, 11% de descuento

de flujo y prueba de escritorio. (Utilice el proceso conmutar).
EP.2.2 Escriba un algoritmo que lea el valor de la temperatura en

cualesquiera de los tres sistemas de grados, F, C y K. Luego debe
hacer los clculos para encontrar los valores en los otros dos sistemas
de temperatura. Al final debe presentar al usuario los tres valores en los
tres sistemas de temperatura existentes. Realice el anlisis de la
escritorio.
EP.2.3 Escriba un algoritmo que lea la longitud de los lados de un

tringulo. Se debe averiguar si corresponden a un tringulo rectngulo,
si corresponden, entonces debe calcular, el rea, el permetro y las tres
alturas del tringulo. Si las tres longitudes ledas no corresponden a un
tringulo, debe informar al usuario y terminar. Realice el anlisis de la

escritorio.
EP.2.4 Escriba un algoritmo que lea el da, el mes y el pas de ubicacin

del usuario. Con base en esta informacin, debe informarle al usuario en
que estacin del ao se encuentra; slo para los pases de Amrica que
tienen las cuatro estaciones. Se debe tener en cuenta que mientras en
el hemisferio norte estn en verano, en el hemisferio sur estn en
invierno. Realice el anlisis de la informacin, algoritmo, seudocdigo,
EP.2.5 Escriba un algoritmo que calcule con 4 lugares decimales la

serie:

EP.2.6 En una cuenta de banco se consiga $ 1250,000 el primero de

Julio de 1,999 y se retira en el 30 de Junio de 2,011. El banco paga un
inters compuesto anual de 6.5%. Escriba un algoritmo que realice el
clculo para cada ao y presente al usuario esta informacin, de la
siguiente forma Ao: ______, Capital: ______ hasta llegar al ltimo
ao. Realice el anlisis de la informacin, algoritmo, seudocdigo,
EP.2.7 Se tiene un listado de 15 nmeros, se necesita saber cuntos

nmeros pares hay en el listado y en qu ubicacin dentro del listado se
encuentran, tambin se requiere conocer la sumatoria de todos los
nmeros impares y por ltimo, se debe decir si dentro del listado est el
cero y en qu posicin se encuentra. Realice el anlisis de la

escritorio.
EP.2.8 Se tiene la ecuacin . Hallar los

puntos mximos y mnimos dentro del intervalo -5 <= x <= 5, con
incrementos de 0,25. Al finalizar, solamente debe presentar las parejas
correspondientes a los puntos mximos y mnimos de la forma ( x, y).
EP.2.9 En una empresa hay empleados con tres sueldos bsicos

mensuales diferentes.
1. $ 580,000
2. $ 890,000
3. $ 1400,000
Al sueldo 1, le dan un auxilio de $ 80,000. El suelto 2 tiene una

bonificacin de $ 90,000. Las horas extras se pagan mensualmente,
siendo al doble de las horas ordinarias. Para salud les descuentan el
11% del sueldo bsico. Realice un algoritmo que le pregunte al
empleado qu clase de sueldo tiene y cuntas horas extras trabaj en el
mes. Luego le informe a cunto corresponde el sueldo del mes. Realice
el anlisis de la informacin, algoritmo, seudocdigo, diagrama de flujo
y prueba de escritorio.
Captulo 3: Procesos repetitivos 123
3 Procesos repetitivos
Los procesos repetitivos son los que permiten repetir un proceso un

determinado nmero de veces o mientras se est cumpliendo una
condicin determinada. Estos procesos tienen una aplicacin muy
importante cuando se est trabajando con listados, arreglos o tablas.
Existen dos clases, los procesos para y los procesos mientras que.
3.1 Proceso Para ________ hasta ________ de a ________;
En el diseo de algoritmos en programacin de computadores, es

necesario realizar procesos repetitivos un nmero determinado de veces
y luego de que estas iteraciones se cumplen, continuar con las
instrucciones siguientes del algoritmo. Este tipo de proceso se denomina
Proceso Para y se representa en un diagrama de flujo de la siguiente
forma:
Para I=n hasta m de a

p
Proceso a realizar
m veces
Figura 3.1
La instruccin Para I=n hasta m de a p, quiere decir: para I igual a n

hasta m, incrementando de a p, realice las instrucciones que estn
dentro del proceso. Por ejemplo: I = 1 hasta 5 de a 1. Esta instruccin
indica que el ciclo empieza desde el momento que la variable I tenga un
valor igual a 1, y se va incrementando en 1 cada vez que realiza las
instrucciones que estn dentro del ciclo, hasta llegar al valor mximo
igual a 5 y luego de hacer el ltimo ciclo, se termina el proceso.
Esto es muy fcil de entender haciendo ejercicios, entonces empezar.
E.3.1 Realice un algoritmo que escriba los nmero de 1 a 10
Se sabe desde qu nmero se van a realizar las iteraciones. Empiezan

desde 1, se van incrementando en 1, hasta llegar a un valor final igual a
10.
Algoritmo
Paso 1: Lea el valor inicial para el ciclo.

Paso 2: Guarde el valor inicial en una variable llamada N.
Paso 3: Lea el valor final para el ciclo.
Paso 4: Guarde el valor final en una variable llamada M.
Paso 5: Lea el valor de incremento para el ciclo.
Paso 6: Guarde el valor incremento en una variable llamada J.
Paso 7: Para I = N hasta M, de a J. Cuando I > 10 vaya al Paso 9.
Paso 8: Presente I.
Paso 9: Terminar
Seudocdigo
Lea inicial
N = inicial
Lea final
M = final
Lea incremento
J = incremento
Para I=N hasta M de a J
Presente I
Fin para
Termine
Diagrama de flujo
Iniciar
inicial
N = inicial
final
M = final
increme
nto
incremento
J = incremento
Para I=N hasta M de a J
Terminar
Figura 3.2
Para I=N hasta M de a J Este smbolo en el diagrama de flujo

sirve para indicar cules son los lmites inferiores y superiores de las
veces que se van a realizar las iteraciones, tambin indica en qu valor
se van incrementando y dnde empieza el proceso Para.
I
Este smbolo es la instruccin que se va a ejecutar 10 veces y
presenta al usuario los diez valores que se van almacenando en la
variable I.
I El crculo es el smbolo que indica que en este punto se termina la

repeticin del ciclo y se contina con la instruccin siguiente del
diagrama de flujo.
Antes de iniciar el ciclo, se almacenan los valores de los lmites inferior y

superior del ciclo, as como el valor en que se va incrementando. El
enunciado del ejercicio, dice que las iteraciones empiezan desde 1 hasta
10, y se van incrementando de a 1, entonces se crea la tabla para ir
llevando los registros de la prueba.
inicial N final M incremento J I

1 1 10 10 1 1 1
Tabla 3.1
En la variable I ya se almacen el valor inicial para empezar a realizar

las iteraciones, la variable M guarda el valor hasta el cual van a llegar
los incrementos, y el incremento se guarda en J que va a ser el valor
que se va sumando a la variable I despus de ejecutar el ciclo. Entonces
para la primera iteracin se tienen estos valores y el mensaje que se
presenta al usuario es 1
inicial N final M incremento J I Mensaje

1 1 10 10 1 1 1 1
Tabla 3.2
Para la segunda iteracin se tienen estos valores


1 1 10 10 1 1 1 1
2 2
Tabla 3.3
En esta tabla se observa que el valor inicial de la variable I, se va

incrementando automticamente en 1 y la estructura del Para lo va
guardando en la variable I nuevamente. Este proceso se repite en todas
las iteraciones hasta que el valor almacenado en la variable I llega a ser
igual al lmite mximo.
Entonces para la tercera iteracin se tienen los valores registrados.

1 1 10 10 1 1 1 1
2 2
3 3
Tabla 3.4
Para la cuarta iteracin se tienen estos valores

1 1 10 10 1 1 1 1
2 2
3 3
4 4
Tabla 3.5
En la quinta iteracin se tienen estos valores


1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
Tabla 3.6
La sexta iteracin es

1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
6 6
Tabla 3.7
Entonces para la sptima iteracin se tienen estos valores

1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
6 6
7 7
Tabla 3.8
En la octava iteracin se tienen estos valores

1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
Tabla 3.9
Entonces para la novena iteracin se tienen estos valores

1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
Tabla 3.10
Esta es la ltima iteracin, los valores finales para las variables son los
que aparecen en el ltimo rengln de la tabla

1 1 10 10 1 1 1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
Tabla 3.11
Con esta prueba de escritorio queda claro como es el funcionamiento de

la estructura de procesos de repeticin Para.
E.3.2 Realice un algoritmo, que lea un nmero y presente al usuario la

tabla de multiplicar correspondiente del 1 al 10.
Se necesita que el usuario que va a utilizar el algoritmo diga para qu

nmero quiere calcular la tabla de multiplicar y el algoritmo la calcula
desde 1 hasta 10. Conociendo este nmero, se utiliza el Proceso Para
que ejecuta los clculos y presenta el resultado al usuario.
Algoritmo
Paso 1: Para qu nmero quiere calcular las tablas de multiplicar.

Paso 3: Guardar el nmero en la variable Producto.
Paso 2: Para la variable I = 1 hasta 10, incrementando de a 1. Cuando I
> 10 vaya al Paso 4.
Paso 3: Presente la multiplicacin de producto por la variable I.

Paso 4: Terminar.
Seudocdigo
Leer nmero
Producto = nmero
Para I=1 hasta 10, incremente en 1
Presente Producto,*,I,= Producto*I
Fin para
En este seudocdigo en la lnea Presente Producto,*,I,= Producto*I,

la parte que est entre comillas significa que el usuario va a ver el valor
que est almacenado en la variable Producto, seguido del signo de
multiplicacin y luego el valor guardado en I, seguido del signo = por
ltimo el valor de la multiplicacin de la variable Producto * por el valor
de la variable I.
Por ejemplo 5 * 4 = 20, si fuera 5 el valor de la variable Producto y 4 el

valor de la variable I. El valor del producto de estas dos variables es
igual a 20
Diagrama de flujo
Iniciar
nmero
Producto = nmero
R
Para I=1 hasta m=10 de a 1
Producto,*,I,
=, Producto*I
Terminar
Figura 3.3
La prueba de escritorio de este algoritmo es similar a la del ejercicio

anterior. La nica diferencia es que el contenido de la variable Producto
se multiplica por el contenido de la variable I, y en cada una de las
iteraciones se presenta el resultado en el mensaje correspondiente,
hasta que I llegue al valor lmite igual a 10. El valor ledo nmero es 1.
nmero Producto I m Incremento Mensaje

1 1 10 1 1*1=1
1 2 10 1 1*2=2
1 3 10 1 1*3=3
1 4 10 1 1*4=4
1 5 10 1 1*5=5
1 6 10 1 1*6=6
1 7 10 1 1*7=7
1 8 10 1 1*8=8
1 9 10 1 1*9=9
1 10 10 1 1 * 10 = 10
Tabla 3.12
E.3.3 Escriba el algoritmo que calcule el factorial de un nmero,

teniendo en cuenta las caractersticas especiales de este tipo de
nmeros.
Los nmeros naturales son 0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, etc., El

factorial est definido para los nmeros naturales. No existe factorial de
nmeros negativos, slo de nmeros naturales. Por definicin, se asume
que cero factorial es 0! = 1, uno factorial es 1! = 1.
0! = 1
1! = 1
2! = 1*2 = 2
3! = 1*2*3 = 6
4! = 1*2*3*4 = 24
5! = 1*2*3*4*5 = 120
6! = 1*2*3*4*5*6 = 720
7! = 1*2*3*4*5*6*7 = 5040
.
.
.
Con base en esta informacin ya se puede empezar a escribir el

algoritmo que calcula N factorial (N!).
Este es un ejercicio interesante que le da al lector la oportunidad de

aplicar los conceptos estudiados hasta el momento, tambin puede ver
que a medida que aumenta el tema estudiado, los ejercicios empiezan a
aumentar en complejidad, pero esto es mejor porque permite
desarrollar destrezas en el anlisis y planteamiento de los problemas y
le permita aprender y afianzar los conocimientos que ya pasee.
Algoritmo
Paso 1: El valor de factorial es igual a 1.

Paso 2: Cul es el valor de N?
Paso 3: Si N es igual a cero, entonces N! es igual a 1. Terminar.
Paso 4: Si N no es igual a cero entonces, verificar.
Paso 5: Si N es menor que cero, entonces presentar N no tiene
factorial y terminar; pero Si no es as, contine.
Paso 6: Si N es un nmero entero contine con el paso siguiente, sino
presentar N no tiene factorial y terminar.
Paso 7: Para la variable I = 1 hasta N, incrementando de a 1, realice los
procesos siguientes. Multiplicar cada vez Factorial por I y asignar el
resultado a Factorial, hasta que terminen las iteraciones.
Paso 8: Al terminar las iteraciones, informar N! es igual al valor de
Factorial.
Paso 9: Terminar.
Seudocdigo
Haga Factorial=1
Lea N
Si N = 0 haga
Presente N, ! = 1
Si no
Si N < 0 haga
Presente N no tiene factorial
Si no
Si (Nmod1)=0 haga
Para I=1; N; 1
Factorial = Factorial * I
Fin para
Presente N, ! =, Factorial
Si no
Presente N no tiene factorial
Fin si
Fin si
Fin si
Terminar
Diagrama de flujo
Iniciar
Factorial = 1
No Si
N=0
No Si
N, ! = 1
N<0
No Si N no tiene
(Nmod1) = 0
factorial
N no tiene Para I=1; N; 1

factorial
Factorial=Factorial *I
I A
A
N, ! = Factorial
Terminar
Figura 3.4
Para I=1; N; 1
Esta es otra forma simplificada de escribir la
informacin correspondiente del Para, que significa Para I = 1 hasta N,
incrementando de a 1.
A , indica que el flujo de la informacin contina en otro punto del
diagrama de flujo, pero no indica que se pasa a otra pgina.
Es el momento de comprobar el funcionamiento de este algoritmo, si

satisface las condiciones establecidas en el enunciado y en la definicin
de Factorial. Inicialmente se va a tomar N = 0.
N Factorial
0 1
Tabla 3.13
Cuando se hace la primera comparacin N = 0?, se comprueba que es

cierto, entonces se sigue por la alternativa del Si y se ejecuta la
siguiente instruccin que dice N, ! = 1, y significa 0! = 1.
N Factorial Mensaje
0 1 0! = 1
Tabla 3.14
Ahora se toma N = -2
N Factorial
-2 1
Tabla 3.15
En la primera comparacin N = 0?, se puede determinar que no es

cierta, entonces el flujo contina por la opcin del No. Se hace la
pregunta N < 0? y en este caso es cierto, ahora se sigue por la
alternativa del Si, y se contina con la ejecucin de la siguiente
instruccin que presenta el mensaje N no tiene factorial.
N Factorial Mensaje
-2 1 N no tiene factorial
Tabla 3.16
Para terminar la verificacin, se toma N = 2.
N Factorial
2 1
Tabla 3.17
La primera comparacin no es cierta, entonces se contina por la opcin

del no, la segunda comparacin no es cierta, de la misma forma se
contina por la opcin del no, al realizar la tercera comparacin, se
comprueba que el residuo de (2mod1) es igual a 0, entonces se realiza
el proceso que est comprendido entre el Para haciendo I=1, N=2, y se
va incrementando de a 1. Por qu (2mod1) es igual a 0?
N Factorial I Incremento
2 1 1 1
Tabla 3.18
Se ejecuta la instruccin que indica Factorial = Factorial*I y se realiza el

incremento de la variable I.
N Factorial I Incremento
2 1 1 1
2 1 2 1
Tabla 3.19
Se ejecuta la instruccin que indica Factorial = Factorial*I y se realiza el

incremento de la variable I que ya es igual a N. Ya es hora de salir del
proceso repetitivo Para y continuar con la siguiente instruccin que es
presentar el mensaje 2! = 2.
N Factorial I Incremento Mensaje

2 1 1 1
2 2 2 1 2! = 2
Tabla 3.20
Ya est comprobado que el algoritmo desarrollado si cumple con los

requisitos del enunciado y valida los datos de entrada para entregar el
factorial de un nmero entero.
E.3.4 Escriba un algoritmo, que calcule la expansin de Taylor:
Realizando N iteraciones.
Para realizar este ejercicio, ya se cuenta con toda la informacin. Se

sabe como calcular el factorial de un nmero y se utiliza el proceso
repetitivo Para. Se debe pedir que el usuario suministre el valor de x al
iniciar el algoritmo.
Para la expansin de Taylor, se debe calcular primero cul es el trmino

ensimo.
Todos los trminos estn divididos por el factorial de un nmero y en

cada uno de los trminos el exponente de la variable x, es el mismo
nmero del denominador al cual se le est calculando el factorial.
Como ya se conoce el ensimo trmino de esta sucesin, se puede

empezar a escribir el algoritmo.
Algoritmo
Paso 1: Lea x
Paso 2: Guarde x en la variable X
Paso 3: Lea n
Paso 4: Guarde n en la variable N
Paso 5: Guarde 1 en la variable Factor
Paso 6: Guarde 1 en la variable Serie
Paso 7: Para I = 1 hasta (N-1) incrementando de a 1
Paso 8: Factor = Factor * I
Paso 9: Serie = Serie + (X**I) / Factor
Paso 10:Fin Para
Paso 11: Presente ex = , serie
Paso 12: Terminar
Seudocdigo
Leer x
X=x
Leer n
N =n
Factor = 1
Serie = 1
Para I = 1; (N-1); 1
Factor = Factor * I
Serie = Serie + (X**I) / Factor
Fin Para
Presente ex = , serie
Terminar
Diagrama de flujo
Iniciar
X=x
N=N
Factor = 1
Serie = 1
Para I = 1; (N-1); 1
Factor = 1
Serie = 1
x
e = , serie Terminar
Figura 3.5
Para comprobar la eficiencia de este algoritmo, se va a realizar la

comprobacin para e1 = 2.71828. Entonces x es igual a 1 y se realizan 8
iteraciones, n = 8, para verificar la precisin del clculo del algoritmo.
Los datos iniciales son los almacenados en la Tabla 3.21
x X n N Factor Serie
2 2 8 8 1 1
Tabla 3.21
AL realizar la primera iteracin se tiene:
x X n N Factor Serie I
2 2 8 8 1 1
1 2 1
Tabla 3.22
La segunda iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
Tabla 3.23
La tercera iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66 3
Tabla 3.24
La cuarta iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66667 3
24 2.70833 4
Tabla 3.25
La quinta iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66667 3
24 2.70833 4
120 2.71667 5
Tabla 3.26
La sexta iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66667 3
24 2.70833 4
120 2.71667 5
720 2.71806 6
Tabla 3.27
La sptima iteracin es:
2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66667 3
24 2.70833 4
120 2.71667 5
720 2.71806 6
5040 2.71825 7
Tabla 3.28
La sptima iteracin es:
x X n N Factor Serie I Mensaje

2 2 8 8 1 1
1 2 1
2 2.5 2
6 2.66667 3
24 2.70833 4
120 2.71667 5
720 2.71806 6
5040 2.71825 7
40320 2.71828 8 ex = , Serie
Tabla 3.29
El algoritmo est realizando los clculos con muy buena exactitud,

porque en la 8 iteracin, da seis cifras significativas que coinciden con
el valor calculado por una calculadora de funciones, o con las tablas de
libros de anlisis numrico.
E.3.5 Escriba un algoritmo, que calcule el promedio para cada

estudiante de un grupo de N estudiantes. Por estudiante va a leer,
cdigo, primera nota, segunda nota y examen. La primera y segunda
notas, tienen cada una un valor de 30% y el examen 40%. Debe
presentar al final cul es el promedio ms alto y a qu estudiante le
corresponde.
Para poder hacer el clculo del promedio ms alto de todos los

estudiantes, se debe tener un valor como punto de referencia. Se crea
una variable def que va a contener el valor igual a cero y cada vez que
se calcula el promedio de cada estudiante se va comparando con esta
variable, cuando sea mayor el valor calculado, entonces se va
almacenando el nuevo valor en la variable def y al final de todos los
clculos de los promedios de los estudiantes tendr el mximo valor del
promedio en la variable def.
Algoritmo
Paso 1: Lea qu cantidad de estudiantes tiene el curso

Paso 2: Guarde cantidad en la variable N
Paso 3: Guarde 0 en la variable id
Paso 4: Guarde 0 en la variable n1
Paso 5: Guarde 0 en la variable n2
Paso 6: Guarde 0 en la variable ex
Paso 7: Guarde 0 en la variable def
Paso 8: Para I = 1 hasta N, incrementando de a 1, haga
Paso 9: Lea el cdigo del estudiante
Paso 10: Guarde cdigo en la variable ID

Paso 11: Lea primera nota
Paso 12: Guarde primera nota en la variable N1
Paso 13: Lea segunda nota
Paso 14: Guarde primera nota en la variable N2
Paso 15: Lea nota examen
Paso 16: Guarde nota examen en la variable EX
Paso 17: DEF = N1*0.3+N2*03+EX0.4
Paso 18: Si DEF > def vaya al Paso siguiente, de lo contrario al Paso 24
Paso 19: Guarde ID en la variable id
Paso 20: Guarde N1 en la variable n1
Paso 21: Guarde N2 en la variable n2
Paso 22: Guarde EX en la variable ex
Paso 23: Guarde DEF en la variable def
Paso 24: Final del para
Paso 25 Presente id, n1, n2, ex, def
Paso 26 Termine
Seudocdigo
Leer cantidad
N = cantidad
id = 0
n1 = 0
n2 = 0
ex = 0
def = 0
Para I = 1; N; 1 haga
Leer cdigo
ID = cdigo
Leer = nota1
N1 = nota1
Leer = nota2
N2 = nota2
Leer examen
EX = examen
DEF = N1*0.3+N2*03+EX0.4
Si DEF > def
id = ID
n1 = N1
n2 = N2
ex = EX
def = DEF
Fin si
Fin para
Presente id, n1, n2, ex, def
Termine
Diagrama de flujo
Iniciar
cantidad
N = cantidad
id = 0
n1 = 0
n2 = 0
ex = 0
def = 0
W
Para i = 1; N;1
cdigo
ID = cdigo
nota1
N1 = nota1
nota2
N2 = nota2
examen
EX = examen
DEF = N1*03+N2*0.3+EX*0.4
Si
DEF > Def
id = ID
No
n1 = N1
n2= N2
I ex = EX
def = DEF
id, n1, n2,
ex, def
Terminar
Figura 3.6
En este caso se va a comprobar el algoritmo para 2 estudiantes

solamente. La informacin del primer estudiante es ID = 1, nota1 = 3.2,
nota2 = 3.6, ex = 3.0 y para el segundo estudiante ID = 2, nota1 =
3.2, nota2 = 3.0, ex = 3.6. Entonces, se lee la cantidad de estudiantes y
se inicializan las primeras variables.
cantidad id n1 n2 ex
2 0 0 0 0
Tabla 3.30
Se contina con el Para.
cantidad id n1 n2 ex def I N
2 0 0 0 0 0 1 2
Tabla 3.31
La informacin del primer estudiante es leda y almacenada en las

respectivas variables.
cantidad id n1 n2 ex def I N ID nota1 nota2 examen DEF

2 0 0 0 0 0 1 2 1 3.2 3.6 3.0 3.24
Tabla 3.32
La siguiente instruccin a ejecutar es la validacin de si la variable DEF

es mayor que la variable def, esto es cierto, entonces la instruccin
siguiente es almacenar estos valores en las variables iniciales id, n1, n2,
ex y def.

2 0 0 0 0 0 1 2 1 3.2 3.6 3.0 3.24
1 3.2 3.6 3.0 3.24
Tabla 3.33
Para el segundo estudiante los datos son los siguientes y el clculo de la

nota definitiva.

2 0 0 0 0 0 1 2 1 3.2 3.6 3.0 3.24
1 3.2 3.6 3.0 3.24 1 2 2 3.2 3.0 3.6 3.3
Tabla 3.34
Se puede comprobar fcilmente que estas notas corresponden a la

definitiva ms alta, entonces se almacena en las variables iniciales.

2 0 0 0 0 0 1 2 1 3.2 3.6 3.0 3.24
1 3.2 3.6 3.0 3.24 1 2 2 3.2 3.0 3.6 3.3
2 3.2 3.0 3.6 3.3
Tabla 3.35
El mensaje que se muestra al usuario es el contenido en estas variables,

que es:

2 0 0 0 0 0 1 2 1 3.2 3.6 3.0 3.24
1 3.2 3.6 3.0 3.24 1 2 2 3.2 3.0 3.6 3.3
2 3.2 3.0 3.6 3.3 Mensaje
ID: 2, Nota1: 3.2, Nota2: 3.0, Ex: 3.6, Def: 3.3
Tabla 3.36
3.2 Proceso Mientras Qu __________ haga
En la programacin suelen presentarse procesos que se deben repetir,

pero no se sabe a ciencia cierta cuntas veces, slo se sabe que se
repiten mientras se cumpla una condicin especfica, y en el momento
que se deja de cumplir esta condicin, se sale del ciclo repetitivo. En
este tipo de casos no es conveniente utilizar el proceso Para, porque no
satisface este requisito, ya que se repite un nmero fijo de veces, sin
tener en cuenta que se cumpla alguna condicin.
Mientras que _____
Proceso a realizar
Figura 3.7
Mientras que _____

La instruccin es la que controla el ciclo.
Este ciclo se realiza mientras que la condicin sea verdadera, si es falsa,
entonces se contina con las instrucciones que estn a continuacin del
ciclo. Se repite siempre que se cumpla esta condicin sin importar el
nmero de veces que sea necesario, lo nico que lo detiene es que la
condicin sea falsa.
Proceso a realizar
Este smbolo representa las instrucciones que se van a
realizar dentro del ciclo que se est ejecutando, se realiza tantas veces
como la condicin del proceso Mientras Que, sea verdadera.
M
Este smbolo indica en qu parte termina el proceso Mientras Que.
Cuando el flujo del algoritmo llega a este punto, se hace la validacin de
la instruccin que se encuentra en el Mientras Que, si es cierta se repite
nuevamente el ciclo, de lo contrario, se sale del proceso y se contina

con el algoritmo.
E.3.6 Escriba un algoritmo, que lea un nmero y luego le informe al

usuario si es un nmero primo.
El algoritmo debe leer un nmero. Despus de que ya se conoce este

valor, hay que hacer la correspondiente consulta para saber si se ajusta
a la definicin de nmero primo.
Un nmero primo es aquel que es divisible por si mismo y por la unidad,

exceptuando el uno. Adems los nmeros primos son enteros, no hay
nmeros primos decimales. En pocas palabras, los nmeros primos
pertenecen al conjunto de los nmeros naturales. Cules son los
nmeros naturales?
Algoritmo
Paso 1: Cul es el nmero para evaluar?

Paso 2: Verifique si este nmero es un entero. Si no es, Presente No es
nmero primo y termine. Si es entero contine.
Paso 3: Verifique si este nmero es mayor que 1. Si no es, Presente No
es nmero primo y termine. Si es mayor contine.
Paso 4: Calcule la y smele 1, ese va a ser el valor de la variable A.
Paso 5: Guarde 2 en la variable I.
Paso 6: Mientras que el valor de la variable I sea menor que el valor de
la variable A, contine; de lo contrario termine.
Paso 7: Si el residuo de N dividido entre I es igual a cero, contine, de
lo contrario vaya al Paso 10.
Paso 8: Verifique si N es igual a 2, si es cierto, Presente N es primo, si
no es cierto Presente N no es primo.
Paso 9: Asigne a la variable I el valor que tiene ms el valor de la

variable A y vuelva al Paso 6.
Paso 10: En la variable I guarde el valor de I ms 1 y luego verifique si
el valor de la variable I es mayor o igual que el valor de la variable A. Si
es cierto, Presente N es primo y vuelva al Paso 6.
Seudocdigo
Lea N
Si (Nmod1)=0
Si N>1
A = 1+
I=2
M. Q. I < A
Si (NmodI)=0
Si N = 2
Presente N es primo
Si no
Presente N no es primo
Fin si
I=I+A
Si no
I=I+1
Si I >= A
Presente N es primo
Fin si
Fin si
Fin M.Q.
Si no
Fin si
Si no
Fin si
Diagrama de flujo
Iniciar
No Si
N mod 1 = 0
No Si
N>1
No es primo A=1+
I=2
M.Q. I < A
No Si
N mod I = 0
Si
I=I+1 N=2
No
Si No es Es primo
I>=A
primo
No
Es primo
I=I+A
Fin M.Q.
Terminar
Figura 3.8
Para realizar la prueba de escritorio de este ejercicio, se va a trabajar

con tres valores diferentes, pero se espera que el lector haga esta
misma verificacin para muchos otros valores que le permitan
desarrollar la destreza en la comprobacin de los algoritmos; se inicia
con un valor negativo -2.
N
-2
Tabla 3.37
Ya se conoce el valor de N, ahora se realiza la verificacin de si el

residuo de la divisin -2/1 es igual a 0. En este caso es cierto, entonces
se contina con la siguiente instruccin que comprueba que si N es
mayor que 1, esto no es cierto, entonces, se sigue por la opcin que
corresponde al no, y presenta el mensaje N no es primo.
N Mensaje
-2 N no es primo
Tabla 3.38
Se va a realizar la verificacin del algoritmo, con 5.7.
N
5.7
Tabla 3.39
Conociendo el valor de N, se realiza la verificacin de si 5.7mod1 es

igual a 0. En este caso es falso, ya que el residuo es igual a 0.7,
entonces se presenta el mensaje N no es primo.
N Mensaje
5.7 N no es primo
Tabla 3.40
Falta comprobar el algoritmo con un nmero que sea entero y mayor

que 1 para saber si es primo o no. Se va a hacer esta verificacin con 2.
N
2
Tabla 3.41
La comprobacin de si 2mod1 es cero es verdadera, entonces al ejecutar

la instruccin siguiente 2 > 1 se encuentra que tambin es cierta.
Entonces se asigna a la variable A, el valor de 1+ . Este valor es el
lmite de las iteraciones que se deben realizar en el M.Q., ya que si se
hacen por encima de este valor, se est perdiendo el tiempo porque si
existe algn divisor, se encuentra comprendido en 0 < A < (1+ ).
N A
2 2.41421
Tabla 3.42
La instruccin siguiente asigna a la variable I el valor inicial igual a 2.
N A I
2 2.41421 2
Tabla 3.43
La estructura de repeticin Mientras Que, es la que va a controlar que se

cumpla que cada nmero que se lea, sea evaluado para saber si es
primo o no. Como se cumple la condicin de que el valor de la variable I

es menor que el de la variable A, entonces se contina con el proceso
siguiente, que es validar si la divisin de N entre I tenga residuo igual a
0; esta verificacin result verdadera.
Entonces se contina con la siguiente instruccin que pide validar si N es

igual a 2, esto es cierto, entonces se debe presentar el mensaje N es
primo.
N A I Mensaje
2 2.41421 2 N es primo
Tabla 3.44
La siguiente instruccin pide que se sume el valor de A y de I, y luego

se guarde en la variable I.
N A I Mensaje
2 2.41421 2 N es primo
2 2.41421 4.41421
Tabla 3.45
Ahora se comprueba si se cumple la condicin del M.Q., que se ve que

no es cierto, porque 4.41421 no es menor que 2.41421, ya se sale del
M.Q. y se termina el proceso.
E.3.7 Escriba un algoritmo, que calcule el rea de un tringulo,

conociendo el valor de los tres lados, cuando termine, debe preguntar si
desea realizar el clculo para otro tringulo o si desea terminar.
Este ejercicio requiere que se validen los valores ledos para saber si
corresponden a un tringulo. El enunciado del ejercicio es claro
solicitando que se calcule el rea de un tringulo, pero no hace
referencia si es un tringulo rectngulo o no, entonces para evitar
equivocaciones en el rea, se va a utilizar la frmula de Hern que sirve
para calcular el rea de cualquier tringulo, independiente de que sea
rectngulo o no.
La frmula de Hern es: donde s es igual al

semipermetro:
a
c
Figura 3.9
Teniendo ya claridad de qu se pide en el ejercicio y qu se necesita

para realizar el clculo correctamente, se puede realizar el algoritmo.
Algoritmo
Paso 1: Pregunte si el usuario desea realizar el clculo.

Paso 2: Mientras que desee realizar el clculo, contine, de lo contrario
termine.
Paso 3: Pregunte los valores de los lados a, b, y c.
Paso 4: Verifique que a + b es menor que c. Si es cierto contine, de lo

contrario Presente No es un tringulo y termine.
Paso 5: Verifique que b + c es menor que a. Si es cierto contine, de lo
contrario Presente No es un tringulo y termine.
Paso 6: Verifique que a + c es menor que b. Si es cierto contine, de lo
contario Presente No es un tringulo y termine.
Paso 7: Calcule el semipermetro del tringulo .
Paso 8: Calcule el rea del tringulo .
Paso 9: Informe al usuario cul es el valor del rea.
Paso 10: Pregunte si va a realizar otro clculo y vaya al paso 2.
Seudocdigo
Leer calcular
M.Q. calcular = si
Leer a, b, c
Si a + b < c
Fin si
Si b + c < a
Fin si
Si a + c < b
Fin si
Presente El rea es igual a A

Leer si desea calcular nuevamente
Fin M.Q.
Termine
Diagrama de flujo
Iniciar
Calcular
M.Q. Calcular = si
Si
a+b<c
No
Si
b+c<a
No
Si
a+c<b
No
No es tringulo
A=
El rea del triangulo es A

tringulo
Calcular
Fin M.Q.
Terminar
Figura 3.10
Para verificar el funcionamiento de este algoritmo, se van a tomar los

valores 3, 4, 5, para cada uno de los lados respectivamente y se asume
que el usuario dijo que si va a realizar el clculo.
Consultar a b C
Si 3 4 5
Tabla 3.46
Al hacer la primera verificacin, se comprueba que a + b es mayor que

c, entonces se contina con la siguiente instruccin que compara que b
+ c es mayor que a. La siguiente instruccin dice que a + c es mayor
que a, entonces se sigue con el flujo del algoritmo y se debe calcular el
semipermetro S, que es igual a la suma de los tres lados, a + b + c y
se divide por 2 que es igual a 6.
Consultar a b c S
si 3 4 5 6
Tabla 3.47
Se contina con el clculo del rea, que se encuentra remplazando en la

forma especificada anteriormente.
Consultar a b c S A
si 3 4 5 6 6
Tabla 3.48
Ahora se presenta un mensaje al usuario informndole cul es el valor

del rea calculada.
Consultar a b c S A Mensaje
Si 3 4 5 6 6 El valor del rea es 6
Tabla 3.49
Ya est verificado el funcionamiento del algoritmo, ahora, se comprueba

si el usuario va a realizar otro clculo, si fuera as, se repite el proceso
del M.Q. de lo contrario, se sale de la ejecucin del M.Q. y se finaliza el
proceso.
E.3.8 Escriba un algoritmo, que genere los N primeros elementos de la

serie de Fibonacci, empezando desde el 0.
La serie de Fibonacci, comienza con 0 1, luego el siguiente trmino es

igual a la suma de los dos anteriores, 0 1 1 2 3 5 8 13 21 34 55 89 En
ese ejercicio, el usuario debe decir cuntos trminos quiere calcular y
luego se empieza a generar y presentar el resultado.
Algoritmo
Paso 1: Cuntos trminos de la serie quiere generar?

Paso 2: Asigne a la variable A el valor de 2.
Paso 3: Asigne a la variable B el valor de 0.
Paso 4: Asigne a la variable C el valor de 1.
Paso 5: Presente el valor de la variable B.
Paso 6: Presente el valor de la variable C.
Paso 7: Mientras que el valor de la variable A sea menor N, contine, de
lo contrario termine.
Paso 8: Asigne a la variable D el valor de la suma de las variables C y B.
Paso 9: Presente el valor de la variable D.
Paso 10: Asigne a la variable B el valor de la variable C.
Paso 11: Asigne a la variable C el valor de la variable D.
Paso 12: Asigne a la variable A el valor actual de A incrementado en 1.

Paso 13. Ejecute nuevamente el paso 7
Seudocdigo
Lea N
A=2
B=0
C=1
Presente B
Presente C
M.Q. A < N haga
D=C+B
Presente D
B=C
C=D
A=A+1
Fin M.Q.
Diagrama de flujo
Iniciar
A=2
B=0
C=1
A
M.Q. A < N
D=C+B
B=C
C=D
A=A+1
Fin M.Q.
Termina
r
Figura 3.11
En esta aplicacin del Mientras que, se va a hacer la prueba de escritorio

hasta el 5 elemento de la serie.
N
5
Tabla 3.50
A continuacin de inicializan las variables A = 2, B= 0, y C = 1, para

poder empezar a presentar los mensajes de los primeros elementos que
conforman la serie de Fibonacci.
N A B C
5 2 0 1
Tabla 3.51
Ahora se presentan al usuario los valores contenidos en las variables B y

C, que son los dos primeros trminos de la serie.
N A B C Mensaje B Mensaje C
5 2 0 1 0 1
Tabla 3.52
Se hace la verificacin de la condicin del M.Q., y se verifica que es

cierta, entonces se ejecutan las instrucciones que estn contenidas en el
M.Q.
N A B C Mensaje B Mensaje C D
5 2 0 1 0 1 1
Tabla 3.53
Presente ahora el valor del siguiente trmino.
N A B C Mensaje B Mensaje C D Mensaje D

5 2 0 1 0 1 1 1
Tabla 3.54
Continuar con las instrucciones que asignan nuevos valores a las

variables
5 2 0 1 0 1 1 1
5 3 1 1
Tabla 3.55
Hay que verificar el contenido del M.Q., en este caso es cierto.

5 2 0 1 0 1 1 1
5 3 1 1 2
Tabla 3.56
Se presenta el siguiente trmino de la serie y se actualizan los valores

de las variables.
5 2 0 1 0 1 1 1
5 3 1 1 2 2
5 4 1 2
Tabla 3.57
Hay que verificar el contenido del M.Q., en este caso es cierto ya que 4
es menor que 5, entonces se ejecuta la actualizacin de las variables y
se presente el ltimo elemento de la serie que se quera generar.

5 2 0 1 0 1 1 1
5 3 1 1 2 2
5 4 1 2 3 3
5 5 2 3
Tabla 3.58
Al realizar la verificacin de la condicin del mientras que, se ve que el

valor de la variable A es igual al valor de la variable N, entonces, se sale
del M.Q., y se termina el proceso. Ya se generaron los 5 primeros
elementos de la serie de Fibonacci que son: 0 1 1 2 3.
E.3.9 Disee un algoritmo que genere la serie de N nmeros

triangulares. Los nmeros triangulares son 1 3 6 10 15 21 28 36 45 55
Estos nmeros fueron estudiados por los Pitagricos. Los nmeros

triangulares son aquellos que forman un tringulo, ejemplo:
Figura 3.12
El primero es el nmero 1, el segundo es el nmero 3, el tercero es el

nmero 6, el cuarto es el nmero 10, el quinto es el nmero 15, y as
sigue esta sucesin de nmeros.
Esta serie se pude generar tambin de otra forma, calculando la frmula

o trmino ensimo.
Este ejercicio se va a desarrollar de otra manera. Se va a tener en

cuenta la posicin del nmero dentro de los nmeros naturales y
sumando el valor de esa posicin empezando desde cero.
P V P+V
1 0 1
2 1 3
3 3 6
4 6 10
5 10 15
6 15 21
7 21 28
8 28 36
9 36 45
10 45 55
Tabla 3.59
Con el contenido de esta Tabla, queda muy claro el algoritmo que se va

a utilizar. ste funciona para cualquier cantidad de nmeros
triangulares. La columna P+V, contiene el resultado de los primeros 10
nmeros triangulares, siendo P la posicin y V el valor del nmero
anterior.
Algoritmo
Paso 1: Leer cuntos nmeros va a generar

Paso 2: Guarde en la variable N cuntos nmeros va a generar
Paso 3: Guarde 1 en la variable M
Paso 4: Guarde 1 en la variable P
Paso 5: Guarde 0 en la variable V
Paso 6: Mientras Que M <= N haga
Paso 7: En la variable V guarde la suma de P + V
Paso 8: Presente V
Paso 9: Guarde en la variable P el valor de P + 1
Paso 10: Guarde en la variable M el valor de M + 1
Paso 11: Fin Mientras que
Paso 12: Terminar
Seudocdigo
Leer nmeros
N = nmeros
M=1
P=1
V=0
M.Q. M <= N haga
V=P+V
Presente V
P=P+1
M=M+1
Fin M.Q.
Terminar
Diagrama de flujo
Iniciar
nmeros
N = nmeros
M= 1
P= 1
V= 0
M.Q. M <= N
V= V+P
P=1+P
S R
S R
M=1+M
Fin M.Q.
Terminar
Figura 3.13
La prueba de escritorio consiste en generar los 4 primeros nmeros

triangulares, entonces N es igual a 4, se inicializan las variables M con
uno, P con 1 y V con 0.
N M P V
4 1 1 0
Tabla 3.60
La instruccin siguiente es M.Q. M <= N realice las instrucciones que se

encuentran dentro del proceso, que son V = V+P, Presentar V, P = P +
1, M = M +1 y volver a validar el M.Q.
N M P V Mensaje
4 1 1 0
2 2 1 1
Tabla 3.61
La segunda iteracin presenta los siguientes resultados.
N M P V Mensaje
4 1 1 0
2 2 1 1
3 3 3 3
Tabla 3.62
La tercera iteracin tiene los siguientes resultados.
N M P V Mensaje
4 1 1 0
2 2 1 1
3 3 3 3
4 4 6 6
Tabla 3.63
La ltima iteracin es.
N M P V Mensaje
4 1 1 0
2 2 1 1
3 3 3 3
4 4 6 6
5 5 5 10
Tabla 3.64
Despus de realizar la cuarta iteracin, se presenta el resultado de la

variable V y luego se incrementa la variable M en 1, entonces al verificar
el M.Q., se sale del proceso, porque no se cumple con la condicin de
que M <= N.
E.3.10 Suponga que en un banco se deposita un capital de dinero en un

CDT el primer da hbil de enero. El banco paga el 7.5 % de inters
compuesto anual. Si se consign el dinero en el ao inicial y se retira en
el ao final, en el ltimo da hbil del mes de diciembre, cunto dinero
se recibe?, adems se quiere saber cunto se liquid por cada ao.

Realice un algoritmo que haga estos clculos y presente los resultados
por ao, y luego el capital total. El algoritmo debe servir para hacer el
clculo para cualquier ao de consignacin, as como para el ao del
retiro y para cualquier capital.
En este algoritmo se conoce el ao en que se realiz la consignacin del

dinero, entonces la condicin del M.Q., es debe ejecutar hasta que se
cumpla el ao de retiro del dinero, la liquidacin se va haciendo
anualmente.
Algoritmo
Paso 1: Lea el ao en que se realiza la consignacin

Paso 2: Guarde en la variable AOINI en ao en que se realiz la
consignacin.
Paso 3: Lea el ao en que se retira el capital
Paso 4: Guarde en la variable AOFIN en ao en que se retir el dinero
Paso 5: Lea el capital a consignar
Paso 6: Guarde en la variable CAPIT el capital inicial
Paso 7: M.Q. AOINI <= AOFIN contine, de lo contrario termine
Paso 8: CAPIT igual a CAPIT ms el 7.5%
Paso 9: AOINI incremntelo en 1
Paso 10: Presente CAPIT, AOINI y vuelva al Paso 7
Seudocdigo
Leer aoinicio
AOINI = aoinicio
Leer aoretiro
AOFIN = aoretiro
Leer capital
CAPIT = capital
M.Q. AOINI <= AOFIN haga
CAPIT = CAPIT + CAPIT*0.075
AOINI = AOINI + 1
Presente CAPIT, AOINI
Fin M.Q.
Terminar
Diagrama de flujo
Iniciar
aoinicio
AOINI = aoinicio
aoretiro
AOFIN = aoretiro
capital
CAPIT = capital
M.Q. AOINI <= AOFIN
CAPIT = CAPIT + CAPIT*0.075
AOINI = AOINI + 1
CAPIT, AOINI
Fin M.Q.
Terminar
Figura 3.14
Se realiza la prueba de escritorio con un capital inicial de $ 3000,000, el

ao de consignacin del dinero fue en 2008 y se retiro en el 2010. Con
esta informacin se empieza a realizar la verificacin del algoritmo.
aoinicio AOINI Aoretiro AOFIN capital CAPIT

2005 2008 2010 2010 3000,000 3000,000
Tabla 3.65
Para el primer ao, se tienen los siguientes resultados:

2005 2008 2010 2010 3000,000 3000,000
2009 3225,000
Tabla 3.66
Para el segundo ao, se tienen los siguientes resultados:

2005 2008 2010 2010 3000,000 3000,000
2009 3225,000
2010 3466,875
Tabla 3.67
En este captulo, se han realizado ejercicios que le permiten al lector

conocer y comprender, cmo se utilizan los procesos repetitivos en
conjunto con los procesos de decisin y los procesos secuenciales. El uso
adecuado de los procesos estudiados hasta este momento, le dan la
capacidad al lector de realizar una programacin estructurada, y est
habilitado para realizar algoritmos, seudocdigos y diagramas de flujo,
un poco ms complicados que los ejemplos desarrollados en cada

captulo, que han sido ilustrativos y de fcil comprensin por la manera
como fueron resueltos.
3.3 Resumen
Los procesos repetitivos son los que permiten repetir un proceso un

determinado nmero de veces, o mientras se est cumpliendo una
condicin determinada.
Es necesario realizar procesos repetitivos un nmero determinado de
veces y, luego de que estas iteraciones se cumplen, continuar con las
instrucciones siguientes del algoritmo. Este tipo de proceso se
denomina Proceso Para.
Los procesos que se deben repetir, pero no se sabe a ciencia cierta
cuntas veces, slo se sabe que se repiten mientras se cumpla una
condicin especfica, y en el momento que se deja de cumplir esta
condicin, se sale del ciclo repetitivo, se llaman Procesos Mientras
que.
EP.3.1 Realice un algoritmo que genere las tablas de multiplicar desde

un nmero inicial hasta otro final. El algoritmo pregunta al usuario
desde qu nmero quiere realizar el clculo y hasta qu nmero, por
ltimo que se presente al usuario la informacin de la siguiente forma:
Si el nmero inicial es 3 y el nmero final es cuatro, debe mostrarse en

pantalla la siguiente informacin:
3*1=3
3*2=6
3*3=9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 24
3 * 9 = 27
3 * 10 = 30
4*1=4
4*2=8
4 * 3 = 12
4 * 4 = 16
4 * 5 = 20
4 * 6 = 24
4 * 7 = 28
4 * 8 = 32
4 * 9 = 36
4 * 10 = 40
Realice, anlisis de la informacin, algoritmo, seudocdigo, diagrama de

flujo y prueba de escritorio.
EP.3.2 Haga un algoritmo que escriba los primeros 100 nmeros

enteros, y le informe al usuario, cules son positivos, cules son
negativos, cules son pares y cules son impares, y cuntos pares,
impares, positivos y negativos hay en el listado. Realice, anlisis de la
escritorio.
EP.3.3 Escriba un algoritmo que calcule con 6 lugares decimales las

siguientes series, siendo n un entero positivo.
1.
2.
3.

EP.3.4 Escriba un algoritmo que calcule con los 10 primeros trminos

de la sucesin lugares decimales, las siguientes series, siendo n un
entero positivo.
1.
2.
3.

EP.3.5 Haga un algoritmo, que lea 5 nmeros y les

calcule:
La suma = .
La suma al cuadrado = .
La media .

La varianza .
La desviacin estndar .
EP.3.6 Escriba un algoritmo que calcule para el polinomio

, los valores de , para valores de -5 <= <= 5, con
incrementos de 0.25, y vaya presentando al usuario la pareja .
EP.3.7 Escriba un algoritmo que genere la pareja de temperaturas,

Fahrenheit y Celsius equivalentes y las presente al usuario, entre 0 C y
100 C, incrementando de a 10 C. Realice, anlisis de la informacin,
algoritmo, seudocdigo, diagrama de flujo y prueba de escritorio.
EP.3.8 Escriba un algoritmo, que realice todas las posibles

combinaciones de las letras a, b y c. Realice, anlisis de la informacin,
algoritmo, seudocdigo, diagrama de flujo y prueba de escritorio.
Captulo 4: Arreglos 179
4 Arreglos
Los arreglos se asemejan a las matrices que se trabajan en las

matemticas o en lgebra lineal, y son tiles cuando se necesita
manejar listados o bases de datos para recuperarlos ms adelante.
Una matriz es un arreglo rectangular de nmeros dispuestos en filas y

columnas.
Figura 4.1
sta es la matriz A cuadrada de 4x4. Este tipo de matriz se conoce como

de dos dimensiones. En cada una de las posiciones se ve con dos
nmeros. Estos nmeros son los subndices que indican en que lugar de
la matriz se encuentra cada uno de los elementos, el primero, que
corresponde a la letra i indica en qu fila se encuentra el elemento y la j
indica en qu columna est ubicado el elemento, la notacin utilizada es
A [I,J]. Por ejemplo.
Figura 4.2
Este trmino se encuentra en la fila 2 y en la columna 3. Las matrices o

arreglos pueden contener nmeros y letras, como se puede ver en el
ejemplo de la matriz C:
Figura 4.3
Existen matrices de una sola fila o de una sola columna, que son muy
tiles en la programacin y se les conoce como vector fila o vector
columna, o matriz de una sola dimensin.
Figura 4.4
Figura 4.5
En programacin el concepto de matriz es muy til porque hace ms

entendible el manejo de la informacin con los arreglos, ya que
permiten guardar informacin que se puede recuperar ms adelante o
modificar, porque se conoce la ubicacin en la cual se guard. La mejor
manera de entender la utilidad de estas herramientas es con ejercicios,
entonces, manos a la obra.
Para el manejo de los arreglos, es necesario aplicar los procesos vistos

en los tres primeros captulos, y de esta forma aplicar la programacin
estructurada en cada uno de los ejercicios.
E.4.1 Escriba un algoritmo que almacene un listado que contiene N

nombres de estudiantes con sus respectivos cdigos, se debe diferenciar
entre el nombre y el apellido.
Para realizar este ejercicio, se va a trabajar con arreglos o matrices, ya

se explic la utilidad del concepto de las matrices para aplicarlo al
diseo de los algoritmos que trabajan con arreglos.
En este caso se va a trabajar con una matriz de Nx3, que significa que
va a tener N filas y 3 columnas, porque se tiene mayor nmero de
estudiantes que es desconocido y la informacin por estudiante es la
misma.
Algoritmo
Paso 1: Cuntos estudiantes hay en el arreglo?

Paso 2: El arreglo L tiene N filas y 3 columnas.
Paso 3: Para I = 1 hasta N, incremente de a 1, contine, de lo contrario
termine.
Paso 4: Informe al usuario que va a digitar informacin del estudiante I
Paso 5: Para J = 1 hasta 3, incremente de a 1, contine, de lo contrario
termine.
Paso 6: Informe al usuario que tipo de dato le corresponde digitar.
Paso 7: Lea el Dato a digitar
Paso 8: Almacene en el arreglo L, en la posicin [I, J] el Dato que digita
el usuario
Paso 9: Vaya al paso 5 y verifique las iteraciones, si faltan contine, de
lo contrario termine
Paso 10: Vaya al paso 3 y verifique iteraciones, si faltan contine, de lo
contrario termine
Seudocdigo
Lea N
L[N,3]
Para I=1; N; 1 haga
Presente Estudiante, I
Para J=1; 3; 1 haga
Presente 1 Cdigo
Presente 2 Apellido
Presente 3 Nombre
Presente Digite el Dato, J
Lea Dato
L[I,J] = Dato
Fin para
Fin para
En este seudocdigo, se est trabajando con nuevos conceptos. L[N,3],

indica que se est inicializando un arreglo de nombre L y de tamao N
filas y 3 columnas y se debe inicializar el espacio en memoria. L[I,J] =
Dato, indica que en el espacio correspondiente del arreglo L, est
almacenando el valor de la variable Dato.
Diagrama de flujo
Iniciar
L [N, 3]
Q
Para I = 1; N; 1
Estudiante N, I
Para J = 1; 3; 1
1 Cdigo
2 Apellido
3 Nombre
Digite el dato, J
Dato
L [I, J] = Dato
Terminar
Figura 4.6
Esta verificacin del algoritmo se va a realizar con 2 datos.
N
2
Tabla 4.1
La instruccin siguiente dimensiona el arreglo o la matriz asignndole un

espacio en memoria L [N, 2], que es igual a L [3, 2].
N L[F,G]
2 L[3,2]
Tabla 4.2
Ahora se inicia el primer Para con las variables I = 1 hasta N,

incrementando de a 1.
N L[F,G] I
2 L[3,2] 1
Tabla 4.3
Se presenta el mensaje al usuario indicndole que va a empezar a

digitar la informacin correspondiente al primer estudiante.
N L[F,G] I Mensaje
2 L[3,2] 1 Estudiante, I
Tabla 4.4
Ahora se inicia el segundo Para que est anidado, con las variables J = 1
hasta 3, incrementando de a 1.
N L[F,G] I Mensaje J
2 L[3,3] 1 Estudiante, I 1
Tabla 4.5
Se le informa al usuario por medio de un mensaje, que tipo de datos va

a digitar relacionada con cada estudiante, y tambin en que dato va.
N L[F,G] I Mensaje J Mensaje Mensaje

2 L[3,3] 1 Estudiante, I 1 1 Cdigo Digite el dato, J
2 Apellido
3 Nombre
Tabla 4.6
Sigue es leer el Dato y luego almacenarlo en la matriz.
N L[F,G] I Mensaje J Mensaje Mensaje Dato L[I,J]

2 L[3,3] 1 Estudiante I 1 1 Cdigo Digite el 123 123
2 Apellido dato, J
3 Nombre
2 L[3,3] 1 Estudiante I 2 1 Cdigo Digite el Arias Arias
2 Apellido dato, J
3 Nombre
2 L[3,3] 1 Estudiante I 3 1 Cdigo Digite el Marcos Marcos
2 Apellido dato, J
3 Nombre
2 L[3,3] 2 Estudiante I 1 1 Cdigo Digite el 312 312
2 Apellido dato J
3 Nombre
2 L[3,3] 2 Estudiante I 2 1 Cdigo Digite el dato Luna Luna
2 Apellido J
3 Nombre
2 L[3,3] 2 Estudiante I 3 1 Cdigo Digite el dato Stella Stella
2 Apellido J
3 Nombre
Tabla 4.7
En la Tabla 4.7, se presenta todo el proceso que realizan los ciclos Para
anidados y se puede apreciar claramente el incremento de cada una de
las variables y las instrucciones que se van ejecutando para almacenar
la informacin de cada estudiante. Cuando ya se llega al ltimo valor del
para exterior, entonces ya se termina el proceso, y se encuentran en la
matriz almacenados los datos digitados.
E.4.2 Escriba un algoritmo que almacene en un arreglo, un listado de N

nmeros y los ordene de menor a mayor, luego que presente al usuario
el listado ordenado.
En el desarrollo de este ejercicio, se debe almacenar en un arreglo o

vector el listado de los N nmeros que se quieren ordenar. Luego se
comparan todos los elementos de la lista, para ir haciendo el
intercambio del valor almacenado en cada campo del arreglo, aplicando
el mtodo de la burbuja, utilizado en ejercicios anteriores. Una vez est
realizado el ordenamiento de los nmeros, se debe presentar al usuario
el listado de todos los nmeros que se encuentran en el arreglo.
Algoritmo
Paso 1: Lea que cantidad N de nmeros a almacenar

Paso 2: Separe el espacio de memoria requerido para este arreglo A[N]
Paso 3: Para I=1 hasta N, incremente de a 1 haga
Paso 4: Lea el Dato que va a guardar en el arreglo
Paso 5: En A [I], guarde el valor Dato.
Paso 6: Cuando I sea mayor que N, contine con el paso siguiente, de lo
contrario, vaya al paso 3.
Paso 7: Para I=1 hasta (N-1), incremente de a 1 haga
Paso 8: Para J=I+1 hasta N, incremente de a 1 haga
Paso 9: Si A [I] = A [J] haga
Paso 10: Guarde C = A [I].
Paso 11: Guarde A [I] = A [J].
Paso 12: Guarde A [J] = C.
Paso 13: Cuando J sea mayor que N, contine, de lo contrario, vaya al
Paso 8.
Paso 14: Cuando I sea mayor que N-1, contine, de lo contrario, vaya al
paso 7.
Paso 15: Para I=1 hasta N, incrementando de a 1 haga

Paso 16: Presente A[I], es el nmero, I
Paso 17: Cuando I sea mayor que N, contine, de lo contrario, vaya al
Paso 15.
Paso 18: Terminar.
Seudocdigo
Lea N
Reserve el espacio en memoria para el arreglo A[N]
Para I=1; N; 1 haga
Lea Dato
A[I] = Dato
Fin para
Para I=1;(N-1);1 haga
Para J=i+1;N;1 haga
Si A[I] > A[J] haga
C = A[I]
A[I] = A[J]
A[J] = C
Fin Si
Fin para J
Fin para I
Para I=1;N;1 haga
Presente A[I] es el nmero I
Fin para I
Terminar
Diagrama de flujo
Iniciar
A [N]
Para I=1;N;1
Dato
A [I] = Dato
Para I=1; (N-1);1
Para J=I+1; N;1
Si
A[I] > A[J]
C = A[I] No
A[I] = A[J] o
A[J] = C
A
Para I=1; N; 1
A[I], es el nmero , I
Terminar
Figura 4.7
Esta comprobacin se va a hacer con 4 nmeros, -1, 11, -7 y 5. El

primer paso es dimensionar la matriz en la cul se van a almacenar los
nmeros.
N A [N]
4 4
Tabla 4.8
Luego se almacenan los 4 nmeros.
N A [N] I Dato
4 4 1 -1
2 11
3 -7
4 5
Tabla 4.9
Ya estn los cuatro nmeros dentro del vector A. El paso siguiente es

hacer las respectivas comparaciones para ir reubicando los nmeros.
N A [N] I Dato A I J A [I] A [J] C

4 4 1 -1 A [1]=-1 1 2 A [1]=-1 A [2]=11
2 11 A [2]=11 3 A [1]=-1 A [3]=-7
3 -7 A [3]=-7 4 A [1]=-7 A [3]=-1 -1
4 5 A [4]=5 A [1]=-7 A [4]=5
Tabla 4.10
En esta verificacin, se compar inicialmente si A [1]=-1 > A [2]=11,

esto no es cierto, entonces se contina si A [1]=-1 > A [3]=-7, en este
caso es cierto, se procede a hacer el intercambio de variables. C = A
[1]=-1, A [1]=A [3] y A [3]=C. Se toma A [1]=-7 > A [4]=5, que no es
cierto.
Ahora se toma el segundo valor del vector A[I], cuando I=2 y se

compara con los valores almacenados en las posiciones 3 y 4,

4 4 1 -1 A [1]=-1 1 2 A [1]=-1 A [2]=11
2 11 A [2]=11 3 A [1]=-1 A [3]=-7
3 -7 A [3]=-7 4 A [1]=-7 A [3]=-1 -1
4 5 A [4]=5 A [1]=-7 A [4]=5
A [1]=-7 2 3 A [2]=11 A [3]=-1
A [2]=11 4 A [2]=-1 A [3]=11 11
A [3]=-1 A [2]=-1 A [4]=5
A [4]=5
Tabla 4.11
Se realizar para I=3 que es la ltima comparacin que se hacer para el

vector A

4 4 1 -1 A [1]=-1 1 2 A [1]=-1 A [2]=11
2 11 A [2]=11 3 A [1]=-1 A [3]=-7
3 -7 A [3]=-7 4 A [1]=-7 A [3]=-1 -1
4 5 A [4]=5 A [1]=-7 A [4]=5
A [1]=-7 2 3 A [2]=11 A [3]=-1
A [2]=11 4 A [2]=-1 A [3]=11 11
A [3]=-1 A [2]=-1 A [4]=5
A [4]=5
A [1]=-7 3 4 A [3]=11 A [4]=5
A [2]=-1 A [3]=5 A [4]=11 11
A [3]=11
A [4]=5
Tabla 4.12
Ya quedaron ordenados de menor a mayor, los nmeros que estn

almacenados en el vector A.

4 4 1 -1 A [1]=-1 1 2 A [1]=-1 A [2]=11
2 11 A [2]=11 3 A [1]=-1 A [3]=-7
3 -7 A [3]=-7 4 A [1]=-7 A [3]=-1 -1
4 5 A [4]=5 A [1]=-7 A [4]=5
A [1]=-7 2 3 A [2]=11 A [3]=-1
A [2]=11 4 A [2]=-1 A [3]=11 11
A [3]=-1 A [2]=-1 A [4]=5
A [4]=5
A [1]=-7 3 4 A [3]=11 A [4]=5
A [2]=-1 A [3]=5 A [4]=11 11
A [3]=11
A [4]=5
A [1]=-7
A [2]=-1
A [3]=5
A [4]=11
Tabla 4.13
Por ltimo, presentar al usuario los nmeros ordenados de menor a

mayor como se encuentran almacenados en la matriz A.
E.4.3 Se tienen 3 listas con las notas de los 2 parciales y el examen de

50 estudiantes. Cada parcial vale el 30% de la nota y el examen el 40%.
Se necesita almacenar el cdigo y las notas en una matriz llamada
Notas, la definitiva se debe almacenar en la ltima columna de la
matriz.
La matriz Notas tiene dos dimensiones. Cuenta con 5 columnas y con 50

filas. Esto se escribe de la siguiente forma: Notas [50,5]
Cdigo Nota1 Nota2 Examen Definitiva
Tabla 4.14
En la Tabla 4.14, se puede observar como es la forma de la matriz

Notas, las 50 filas hacia abajo que van a tener almacenadas las notas y
el cdigo y las 5 columnas que identifican la informacin.
Algoritmo
Paso 1: Defina la matriz Notas[50,5]

Paso 2: Para I =1 hasta 50 incrementando de a 1, contine, si no Paso
12
Paso 3: Para J =1 hasta 5 incrementando de a 1, contine, si no Paso 11
Paso 4: Si J < 5 haga, sino, vaya al Paso 9
Paso 5: Presente 1 Cdigo, 2 Nota1, 3 Nota2, 4 Examen

Paso 6: Presente Dato ,J
Paso 7: Lea el valor del dato
Paso 8: Guarde el Dato en Notas[I, J]. vaya Paso 13
Paso 9: Guarde Notas[I,J] = Notas[I,2]*0.3 + Notas[I,3]*0.3 +
Notas[I,4]*0.4
Paso 10: Presente Notas [I,J], Notas [I,5]
Paso 11: Fin Para J
Paso 12: Fin Para I
Paso 13: Terminar
Seudocdigo
Notas[50,5]
Para I =1; 50; 1
Para J =1; 5; 1
Si J < 5 haga
Presente 1 Cdigo, 2 Nota1, 3 Nota2, 4 Examen
Presente Dato ,J
Leer Dato
Notas[I, J] = Dato
Sino
Notas[I, J] = Notas[I, 2]*0.3 + Notas[I, 3]*0.3 + Notas[I,
4]*0.4
Presente Notas [I, J], Notas[I, 5]
Fin si
Fin Para J
Fin Para I
Terminar
Seudocdigo
Iniciar
Notas[50,5]
Para I=1; 50; 1
Para J=1; 5; 1
No Si
J<5
Notas[I,J] = Notas[I,2]*0.3+ 1 Cdigo

Notas[I,3]*0.3+ Notas[I,4]*0.4 2 Nota 1
3 Nota 2
Notas[I,1], 4 Examen
Notas[I,J]
Dato
Notas[I,J] = Dato
Iniciar
Figura 4.8
La verificacin del algoritmo se realizar con 2 registros. Estos son:

Cdigo Nota1 Nota2 Examen

2 3.5 4.0 3.8
1 4.0 3.8 4.0
Tabla 4.15
Inicialmente se dimensiona la matriz, en este caso es Notas[2,5], con

dos filas, porque solo se va a trabajar con 2 registro. A continuacin se
inicializan las variables I y J, de los dos procesos paras.
Notas[2,5] I J
1 1
Tabla 4.16
En el S, se puede comprobar que la variable J es igual a 1, entonces es

menor que 5, se sigue por el camino definido por el Si, y se presenta al
usuario el men con las opciones para almacenar los datos de cada
estudiante. Para informar al usuario en que dato va, se presenta el valor
de J, y a continuacin se van digitando, el cdigo, nota1, nota2 y
examen.
Cuando el valor de J llega a 5, por los incrementos que se realizan en el

Para interno, en el momento de hacer la validacin de J < 5, se sigue
por la opcin del No. Se realiza el clculo de la nota definitiva de cada
estudiante y luego se presenta el Cdigo seguido de la nota final. Este
proceso se repite para poder almacenar la informacin que corresponde
al segundo estudiante, cuando I se hace igual a 2.
4.2 Resumen
Una matriz es un arreglo rectangular de nmeros dispuestos en filas

y columnas.
Hay arreglos de una dimensin llamados vector fila o vector columna,

de dos dimensiones y multidimensionales.
Un arreglo se denota de la forma A[I,J], siendo I las filas y J las
columnas.
Los arreglos se utilizan cuando se manejan grandes volmenes de
informacin y se requiere recuperarla ms adelante para poderlas
procesar.
En los arreglos se pueden guardar datos numricos o alfanumricos.
EP.4.1 Hay una cadena de almacenes de ropa que tiene varias

sucursales y en cada una de ellas varios vendedores. La gerencia solicita
al programador de la empresa, que realice un algoritmo para que calcule
por sucursal, las ventas por empleado y qu comisin le corresponde
siendo del 8 % sobre las ventas realizadas. Esto se debe hacer por
sucursal, identificando cada sucursal con su cdigo respectivo. De cada
empleado se debe almacenar la siguiente informacin: cdigo, nombres,
apellidos, fecha en que se realiz la venta, sucursal, ventas realizadas,
comisin, sueldo. Esta informacin debe quedar almacenada en un
arreglo, de mayor a menor segn el cdigo de las sucursales y luego por
las ventas realizadas, empezando por la sucursal. Al final debe dar un
reporte informando qu sucursal tuvo la mayor venta diaria y luego que
empleado la realiz. Realice, anlisis de la informacin, algoritmo,
EP.4.2 En una universidad acomodan a los estudiantes para las

evaluaciones formando un arreglo de 6x5 y cuando les entregan los
temas para el examen les indican cul es su ubicacin en el aula. El
reporte de notas que debe entregar el profesor es: promedio de los
estudiantes por fila, mayor nota por fila y menor nota por fila. Realice
un algoritmo que guarde esta informacin en un arreglo. Primero
almacene el cdigo del estudiante segn la ubicacin en un arreglo
llamado Posicin, luego debe almacenar las notas en un arreglo Notas,
de tal forma que coincida con la ubicacin del arreglo Posicin. Por
ltimo debe calcular el promedio por fila y guardarlo en el arreglo Notas,
y presentar un reporte que diga de quin y cul es la mxima nota por
fila y de quin y cul el la mnima nota por fila. Realice, anlisis de la
escritorio.
EP.4.3 Se tiene un arreglo de nmeros, de cuatro filas y cuatro

columnas. La suma de los nmeros que estn en cada fila debe dar 34,
igual pasa con los elementos que estn en las columnas. Este cuadrado
se conoce como el cuadrado mgico de Durero.
4 15 14 1 n= 34
9 6 7 12 n= 34
5 10 11 8 n= 34
16 3 2 13 n= 34
n= n= n= n=
34 34 34 34
Figura 4.9
Realice un algoritmo que lea los nmeros y los guarde en un arreglo,

para luego calcular la suma de los elementos por fila y los elementos por
columna. Si el usuario acert, lo felicita, dicindole, Felicidades,
acertaste con todos los nmeros, si se equivoca porque todas las
sumas no dan 34, debe decirle Lo siento, debes intentar nuevamente.
EP.4.4 Crear un algoritmo, aplicando el mtodo de Sieve, para dejar en

un arreglo nicamente los nmeros primos menores de 100.
El procedimiento a seguir segn Sieve es:
Almacene en un arreglo lineal o vector los 100 primeros nmeros

naturales de la siguiente forma:
P[1] 1
P[2] 2
P[3] 3
P[4] 4
P[5] 5
P[6] 6
P[7] 7
Tabla 4.17
En la posicin 1 del arreglo, se guarda el nmero 1, en la posicin 2 el

nmero 2 y as hasta llegar a la posicin 100, con el nmero 100.
Haga todos los mltiplos de 2 iguales a 0.

Haga todos los mltiplos de 3, iguales a 0.
Siga con el paso anterior, haciendo iguales a cero todos los mltiplos
de los nmeros enteros <= que que quedan en el arreglo.
Luego imprima todos los nmeros que quedaron en el arreglo
diferentes de 0, que son los nmeros primos menores de 100.

EP.4.5 Escriba un algoritmo que lea 50 nmeros y los guarde en un

vector, luego presente un reporte con la siguiente informacin:
Que parejas de nmeros al sumarlos dan 20.

El segundo y tercer nmeros ms grandes.
El segundo y tercer nmeros ms pequeos
El nmero que est en la mitad del listado, no del arreglo.
El nmero que est en la mitad del arreglo.
Cuntos pares hay en el listado?
Cuntos impares hay en el listado?

EP.4.6 Se tienen dos vectores con 20 nmeros cada uno. Escriba un

algoritmo que averige cules nmeros estn en los dos arreglos
lineales, y luego los almacene en un tercer arreglo y los presente al
usuario. Realice, anlisis de la informacin, algoritmo, seudocdigo,
EP.4.7 Escriba un algoritmo, que sume dos matrices cuadradas de 3x3.

EP.4.8 Escriba un algoritmo, que multiplique dos matrices de tamao

mxn y nxp. (Por qu razn no se pueden multiplicar dos matrices de
tamaos nxp y mxn?). Realice, anlisis de la informacin, algoritmo,
EP.4.9 Escriba un algoritmo, que lea el resultado de los estudiantes que

presentan el examen de admisin de una facultad. Debe pedir el cdigo
y el puntaje obtenido por el estudiante, luego almacenarlo en un
arreglo. El puntaje del examen esta entre 0 y 100. Se debe reportar la
siguiente informacin:
Qu estudiantes, pasaron el examen con 80 <= puntaje <=100?

Qu estudiantes, pasaron el examen con 60 <= puntaje <80?
Qu estudiantes, perdieron el examen con 40 <= puntaje <60?


EP.4.10 Escriba un algoritmo, que lea 10 fuerzas expresadas en sus

componentes vectoriales, las almacene en un arreglo, luego reporte cul
es el vector suma en expresado en sus componentes vectoriales, calcule
su magnitud y d sus ngulos directores. Realice, anlisis de la
escritorio.
Bibliografa
1. CAIR, Osvaldo. Metodologa de la programacin: Algoritmos,
diagramas de flujo y programas. 3 ed. Bogot D.C.: Alfaomega
Grupo Editor S.A. de C.V., 2005. 464 p. ISBN 978-958-682-749-2
2. DEITEL, Harvey M. and DEITEL, Paul J., C++ Cmo programar. 2 ed.
Mxico: Prentice Hall, 1999. 1184 p. ISBN 970-17-0254-9
3. LIBERTY, Jesse and HORVATH, David B. Aprendiendo C++ para Linux
en 21 das. 1 ed. Mxico: Pearson Educacin, 2001. 1144 p. ISBN
970-26-0012-X
4. LIPSCHUTZ, Seymour and POE, Arthur. Programacin con FORTRAN:
Incluye Fortran Estructurado. Bogot D.C.: Editorial McGraw-Hill
Latinoamericana, S.A., 1980. 314 p. ISBN 968-451-017-9
5. LIPSCHUTZ, Martin M. and LIPSCHUTZ, Seymour. Procesamiento de
datos: Serie Compendios Schaum. Bogot D.C.: Mc Graw-Hill, 1982.
218 p. ISBN 968-451-412-3
6. SANCHEZ C., Rubn E. y VELASCO M., Antonio. Curso bsico de
ALGEBRA LINEAL. 3 ed. Bogot D.C.: Compaa Editorial Comex
S.A., 1981. 213 p.
7. SCHEID, Francis. Introduccin a la ciencia de las computadoras. 2
ed. Bogot D.C.: Editorial McGraw-Hill Latinoamericana S.A., 1983.
402 p. ISBN 968-451-399-2
8. SPIEGEL, Murray R. Mathematical Handbook of formulas and tables.
1 ed. New York: Schaums Online Series, McGraw-Hill Book
Company, 1968. 272 p.
9. SUPPES, Patrick and HILL, Shirley. Introduccin a la lgica
matemtica. Bogot D.C.: Editorial Revert S.A., 1988. 285 p. ISBN
84-291-5150-8
10.ULLMAN, Larry. PHP for the world wide web. 2 ed. Berkeley, CA.:
Peachpit Press, 2004. 450 p. ISBN 0-321-24565-2
ndice analtico
Smbolos
operador **, 17, 18, 28 informacin, 6, 29, 32, 35,
operador *, 17, 18, 28 38, 43, 54, 58, 62, 69, 74,
operador /, 17, 18, 28 79, 84, 89, 95, 100, 105,
operador +, 17, 18, 28 109, 124, 130, 133, 138,
operador -, 17, 18, 28 144, 151, 157, 161, 166,
operador Mod, 17, 18, 28 171, 181, 186, 192
operador Div, 17, 18, 28 ngulos
operador (),18, 28 directores, 68
operador =, 21, 28 rea
operador <>, 21, 28 crculo, 32
operador <, 21, 28 aritmticos, 16
operador >, 21, 28 arreglos, 179
operador <=, 21, 28
operador >=, 21, 28 B
operador Y, 23, 28 Booleanas, 21
operador O, 23, 28 burbuja, 186
operador NO, 23, 28
operador , 24, 28 C
operador , 24, 28 Celsius, 52, 120, 177
operador , 24, 28 componentes
operador &, 24, 28 Vectoriales, 68
operador , 24, 28 conjuncin, 23, 26, 27
constante, 16
convenciones, 12, 13
A
cuadrado
algoritmo, 9, 10, 29, 32, 35, 39, mgico
44, 54, 58, 63, 70, 74, 79, 84, Duron, 197
90, 95, 100, 105, 109, 124, 130,
134, 139, 144, 151, 157, 161, D
167, 171, 181, 186, 192 datos, 5, 7
anlisis derecha, 19
descargar, 12 E.2.10, 100

desviacin E.2.11, 105
estndar, 176 E.2.12, 108
diagrama E.3.1, 124
flujo, 11, 12, 13, 30, 33, E.3.2, 130
36, 40, 45, 55, 59, 65, 71, E.3.3, 133
76, 80, 86, 91, 96, 102, E.3.4, 138
106, 114, 125, 131, 135, E.3.5, 144
140, 146, 153, 159, 162, E.3.6, 151
168, 172, 182, 188, 194 E.3.7, 156
disyuncin, 23, 27 E.3.8, 161
divisin, 17, 18 E.3.9, 163
entera, 17, 18 E.3.10, 170
Duron, 197
E.4.1, 181
E.4.2, 186
E
E.4.3, 192
ecuacin, 122
propuestos, 51, 120, 174,
segundo grado, 88
196
ejercicios
EP.1.1, 51
iniciacin, 29, 54, 124
EP.1.2, 51
E.1.1, 29
EP.1.3, 51
E.1.2, 32
EP.1.4, 52
E.1.3, 34
EP.1.5, 52
E.1.4, 38
EP.1.6, 52
E.1.5, 42
EP.1.7, 52
E.2.1, 54
EP.1.8, 52
E.2.2, 57
EP.1.9, 52
E.2.3, 63
EP.2.1, 120
E.2.4, 68
EP.2.2, 120
E.2.5, 74
EP.2.3, 120
E.2.6, 79
EP.2.4, 121
E.2.7, 83
EP.2.5, 121
E.2.8, 88
EP.2.6, 121
E.2.9, 94
EP.2.7, 122
EP.2.8, 122 Hern, 157

EP.2.9, 122 Fibonacci
EP.3.1, 174 serie, 161
EP.3.2, 175
G
EP.3.3, 175
grficas, 5
EP.3.4, 176
EP.3.5, 176
H
EP.3.6, 176
Hern, 157
EP.3.7, 177
EP.3.8, 177
I
EP.4.1, 196
izquierda, 19
EP.4.1, 196
EP.4.2, 196
J
EP.4.3, 197
jerarqua, 18, 19
EP.4.4, 198 aritmticos, 18
EP.4.5, 198 operadores, 18
EP.4.6, 199
EP.4.7, 199 K
EP.4.8, 199 Kelvin, 52, 120
EP.4.9, 199
EP.4.10, 200 L
escritorio, 15 listado, 181
estaciones, 121 lgicos, 23
exponenciacin, 17, 18
expresin M
aritmtica, 18 mantecada, 38
expresiones, matriz, 179, 199
lgicas, 21 media, 176
mtodo
F burbuja, 62, 186
factorial, 133 mdulo, 17, 18
Fahrenheit, 52, 120, 177 multiplicacin, 17, 18
FreeDFD1.1, 12
formular
N escritorio, 15, 31, 34, 36,

negacin, 23, 26 42, 47, 56, 60, 66, 72, 78,
nmeros, 124 81, 87, 92, 98, 104, 107,
118, 126, 132, 136, 141,
complejos, 42, 89
148, 154, 160, 163, 169,
imaginarios, 42, 89 173, 183, 189, 194
primos
Sieve, 198 R
triangulares, 166 relacionales, 21
repetitivo, 21
O residuo, 17
operacin, 16 resta, 17, 18
operadores, 16, 18, 21, 23 resumen, 49, 119, 174, 195
P S
parntesis, 18 series, 121, 175
polgono, 100 seudocdigo, 11, 29, 32, 35, 40,
polinomio, 176 44, 54, 58, 64, 71, 75, 80, 84,
programa, 16 91, 96, 101, 105, 111, 124, 131,
programador, 7 134, 139, 145, 152, 158, 162,
problema, 6, 7, 8
167, 171, 182, 187, 193
proceso
conmutar, 98 signo
mientras que ____ haga, zodiacal, 108
150 smbolos, 12, 13
para ____ hasta ____ de Smart DFD 1.0, 12
a ____, 123 suma, 17, 18
si ____ haga ____, 53
si ____ haga ____ sino T
____, 83
tabla
toma decisiones, 53
procesos multiplicar, 130
decisin, 21 tablas
repetitivos, 123 certeza, 26
secuenciales, 28 multiplicar, 174
proposicin, 24 Taylor
prueba expansin, 138
temperaturas, 52, 177

tringulo
equiltero, 74
escaleno, 74
issceles, 74
V
variable, 15
varianza, 176
vector, 68, 180, 198, 199, 200
vectores
unitarios, 68

Algoritmos: Apuntes de Clase de

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algoritmos: Apuntes de Clase de

Uploaded by

Copyright:

Available Formats

Nelson Francisco

Apuntes de clase de ALGORITMOS

Apuntes de clase de algoritmos

Prohibida la reproduccin total o parcial

Derechos Reservados 2011

Impreso en Bogot D.C., Colombia.

A Mara Teresa y Agustn, por un pronto reencuentro.

Los crditos de este trabajo indiscutiblemente slo le corresponden a

En la realizacin de este trabajo, recib el apoyo y respaldo de varias

A mi hermana Clara, quien me colabor con las continuas y repetidas

Quiero agradecer especialmente a Ernesto Carrillo Mora, quien ha

1.4 Seudocdigo .......................................................................... 11

1.5 Diagrama de flujo ................................................................... 11

1.6 Prueba de escritorio ................................................................ 15

1.7 Operadores aritmticos ........................................................... 16

1.8 Expresiones lgicas ................................................................ 21

1.8.1 Operadores relacionales ....................................................... 21

1.8.2 Operadores lgicos .............................................................. 23

1.9 Tablas de certeza de los operadores lgicos ............................... 26

1.10 Procesos secuenciales ........................................................... 28

EJERCICIOS DE INICIACIN ..................................................... 29

1.11 Resumen ...........................................................................49

EJERCICIOS PROPUESTOS ........................................................51

Captulo 2: Procesos de decisin ...............................................53

2 Proceso de toma de decisiones ....................................................53

2.1 Proceso Si _____; haga _____ ................................................53

EJERCICIOS DE INICIACIN ..................................................... 54

2.2 Proceso Si _____ ; haga _____ ; sino haga _____ .................... 83

2.3 Proceso conmutar ................................................................... 98

E.2.10 ...................................................................................... 100

E.2.11 ...................................................................................... 104

E.2.12 ...................................................................................... 108

2.4 Resumen ........................................................................... 119

EJERCICIOS PROPUESTOS ...................................................... 120

EP.2.1 ...................................................................................... 120

EP.2.2 ...................................................................................... 120

EP.2.3 ...................................................................................... 120

EP.2.4 ...................................................................................... 121

EP.2.5 ...................................................................................... 121

EP.2.6 ...................................................................................... 121

EP.2.7 ...................................................................................... 121

EP.2.8 ...................................................................................... 122

EP.2.9 ...................................................................................... 122

Captulo 3: Procesos repetitivos .............................................. 123

3 Procesos repetitivos ................................................................. 122

3.1 Proceso Para ________ hasta ________ de a ________ ........... 123

E.3.1 ........................................................................................ 124

E.3.2 ........................................................................................ 130

E.3.3 ........................................................................................ 133

E.3.4 ........................................................................................ 138

E.3.5 ........................................................................................ 144

3.2 Proceso Mientras Qu __________ haga ................................. 150

E.3.6 ........................................................................................ 151

E.3.7 ........................................................................................ 156

E.3.8 ........................................................................................ 161

E.3.9 ........................................................................................ 166

E.3.10 ...................................................................................... 170

3.3 Resumen ........................................................................... 174

EJERCICIOS PROPUESTOS ...................................................... 174

EP.3.1 ...................................................................................... 174

EP.3.2 ...................................................................................... 175

EP.3.3 ...................................................................................... 175

EP.3.4 ...................................................................................... 176

2.1 Proceso Si _; haga _ ................................................53

2.2 Proceso Si ___ ; haga _ ; sino haga ___ .................... 83

3.1 Proceso Para hasta de a ........... 123