APUNTES DE CLASE DE ALGORITMOS

NELSON FRANCISCO BELTRÁN FRANCO

ALGORITMOS

ISBN 978-958-44-8987-6

9 789584 489876

El capítulo 5 de c++ se descarga de la página web, con la clave que se suministra en el momento de la compra del libro. al igual que los códigos de DFD y de Devc++

Apuntes de clase de Algoritmos

Apuntes de clase de Algoritmos Nelson Francisco Beltrán Franco

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Derechos Reservados © 2011 por Nelson Francisco Beltrán Franco Esta obra es propiedad intelectual de su autor y el editor de la publicación. Prohibida su reproducción parcial o total por cualquier medio sin permiso escrito del propietario de los derechos del copyright. Nota importante: La información contenida en esta obra tiene un fin exclusivamente didáctico, no está prevista su utilización a nivel profesional o industrial. Las indicaciones técnicas y programas incluidos, han sido elaborador con atención y cuidado por el autor y reproducidos bajo estrictas normas de control. Nelson Francisco Beltrán Franco, no será jurídicamente responsable por errores u omisiones; daños y perjuicios que se puedan atribuir al uso de la información comprendida en este libro, ni por el uso indebido que se le dé.

Internet: http://www.nefrabel.net/libros/algoritmos.php Email: [email protected]

ISBN: 978-958-44-8987-6

9 789584 489876

Se imprimieron 1000 ejemplares en el mes de Julio de 2011

Impreso en Bogotá D.C., Colombia por Nelson Francisco Beltrán Franco.

A María Teresa y Agustín, por un pronto reencuentro.

Los créditos de este trabajo indiscutiblemente sólo le corresponden a Dios, a quien le agradezco por darme cada día una nueva oportunidad. Los errores y equivocaciones si son de mi autoría.

Capítulo 4: Arreglos Nelson Francisco Beltrán Franco

Agradecimientos En la realización 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 demás 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 compañía y apoyo, le doy un cariñoso 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 parecía que se complicaban las cosas, estuvo presente, animándome y respaldándome.

vii

vii

Capítulo 4: Arreglos Nelson Francisco Beltrán Franco

Contenido Introducción .......................................................................... 1

Capítulo 1: Procesos secuenciales ......................................... 5 1 Procesos secuenciales ............................................................ 5 1.1 Introducción ....................................................................... 5 1.2 Análisis de la información .................................................... 6 1.3 Algoritmo ........................................................................... 9 1.4 Seudocódigo .................................................................... 10 1.5 Diagrama de flujo ............................................................ 11 1.6 Prueba de escritorio ......................................................... 14 1.7 Operadores aritméticos ..................................................... 16 1.8 Expresiones lógicas .......................................................... 20 1.8.1 Operadores relacionales ................................................. 20 1.8.2 Operadores lógicos ........................................................ 22 1.9 Tablas de certeza de los operadores lógicos ......................... 24 1.10 Procesos secuenciales ..................................................... 26 EJERCICIOS DE INICIACIÓN ............................................... 27 E.1.1 .................................................................................... 27 E.1.2 ................................................................................... 30

ix

ix

x

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco E.1.3 .................................................................................... 32 E.1.4 .................................................................................... 35 E.1.5 .................................................................................... 39 1.11 Resumen ..................................................................... 46 EJERCICIOS PROPUESTOS .................................................. 49 EP.1.1 .................................................................................. 49 EP.1.2 .................................................................................. 49 EP.1.3 .................................................................................. 49 EP.1.4 .................................................................................. 49 EP.1.5 .................................................................................. 49 EP.1.6 .................................................................................. 49 EP.1.7 .................................................................................. 50 EP.1.8 .................................................................................. 50 EP.1.9 .................................................................................. 50 EP.1.10 ................................................................................ 50

Capítulo 2: Procesos de decisión ......................................... 51 2 Proceso de toma de decisiones ............................................. 51 2.1 Proceso Si _____; haga _____ .......................................... 51 EJERCICIOS DE INICIACIÓN ............................................... 52 E.2.1 .................................................................................... 52

x

Capítulo 4: Arreglos Nelson Francisco Beltrán Franco E.2.2 .................................................................................... 55 E.2.3 .................................................................................... 59 E.2.4 .................................................................................... 65 E.2.5 .................................................................................... 70 E.2.6 .................................................................................... 75 2.2 Proceso Si _____ ; haga _____ ; sino haga _____ .............. 79 E.2.7 .................................................................................... 79 E.2.8 .................................................................................... 84 E.2.9 .................................................................................... 89 2.3 Proceso de selección múltiple ............................................ 93 E.2.10 .................................................................................. 95 E.2.11 .................................................................................. 99 E.2.12 ................................................................................. 103 2.4 Resumen ...................................................................... 113 EJERCICIOS PROPUESTOS ................................................. 115 EP.2.1 ................................................................................. 115 EP.2.2 ................................................................................. 115 EP.2.3 ................................................................................. 115 EP.2.4 ................................................................................. 115 EP.2.5 ................................................................................. 116 EP.2.6 ................................................................................. 116

xi

xi

xii

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco EP.2.7 ................................................................................ 116 EP.2.8 ................................................................................ 116 EP.2.9 ................................................................................ 117

Capítulo 3: Procesos repetitivos ........................................ 119 3 Procesos repetitivos ........................................................... 119 3.1 Proceso Para ________ hasta ________ de a ________ ..... 119 E.3.1 .................................................................................. 120 E.3.2 .................................................................................. 126 E.3.3 .................................................................................. 128 E.3.4 .................................................................................. 133 E.3.5 .................................................................................. 138 3.2 Proceso Mientras Qué __________ haga ........................... 144 E.3.6 .................................................................................. 145 E.3.7 .................................................................................. 150 E.3.8 .................................................................................. 155 E.3.9 .................................................................................. 160 E.3.10 ................................................................................ 164 3.3 Resumen ..................................................................... 168 EJERCICIOS PROPUESTOS ................................................ 169 EP.3.1 ................................................................................ 169

xii

Capítulo 4: Arreglos Nelson Francisco Beltrán Franco EP.3.2 ................................................................................. 169 EP.3.3 ................................................................................. 170 EP.3.4 ................................................................................. 170 EP.3.5 ................................................................................. 170 EP.3.6 ................................................................................. 171 EP.3.7 ................................................................................. 171 EP.3.8 ................................................................................. 171

Capítulo 4: Arreglos ........................................................... 173 E.4.1 ................................................................................... 175 E.4.2 ................................................................................... 180 E.4.3 ................................................................................... 185 4.2 Resumen ...................................................................... 189 EJERCICIOS PROPUESTOS ................................................. 190 EP.4.1 ................................................................................. 190 EP.4.2 ................................................................................. 190 EP.4.3 ................................................................................. 190 EP.4.4 ................................................................................. 191 EP.4.5 ................................................................................. 192 EP.4.6 ................................................................................. 192 EP.4.7 ................................................................................. 193

xiii

xiii

xiv

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco EP.4.8 ................................................................................ 193 EP.4.9 ................................................................................ 193 EP.4.10 .............................................................................. 193

Capítulo 5: C++ ................................................................. 195 5.1 Estudio de un programa en C++ ...................................... 195 E.5.1 .................................................................................. 195 5.2 Comentarios .................................................................. 196 5.3 Caracteres de impresión especiales .................................. 199

Bibliografía ....................................................................... 201 Índice ............................................................................... 205

xiv

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco

Introducción Este libro se escribió para que sea estudiado y consultado, por los estudiantes de educación técnica, tecnológica y universitaria que necesiten cursar materias relacionadas con la computación o la definición de algoritmos. La literatura relacionada con los temas previos a la programación es escasa. Los libros que se encuentran en el mercado, abordan la programación en diferentes lenguajes, pero no tienen en cuenta que los estudiantes puedan tener dudas o vacíos en el desarrollo o planteamiento de un algoritmo, para luego ser traducido a un lenguaje de programación específico. Cuando estaba empezando a realizar este trabajo, algunos estudiantes de ingeniería de sistemas y de tecnologías en sistemas, revisaron los borradores y comentaron, “si en la universidad hubiera encontrado un libro que explicara como plantear un algoritmo tan fácil, no habría repetido la materia y aprender a programar hubiera sido más sencillo.” Enseñar 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 genética. Con este trabajo sólo quiero mostrarle al lector cuáles son los pasos que puede seguir para definir correctamente un algoritmo, y comprobar su funcionamiento antes de traducirlo a un lenguaje de programación. 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 razón, antes de empezar a codificar un algoritmo en cualquier lenguaje de programación, se le debe enseñar al estudiante cómo escribir sus algoritmos y comprobar su funcionamiento. Y no como acostumbran la mayoría de los

1

2

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco maestros, saltarse la parte de los algoritmos, para empezar con un lenguaje de programación, dejando vacíos en la formación técnica de los estudiantes que más adelante se vuelven insalvables. Pensando en los estudiantes que se encuentran con estos problemas en el curso de su formación técnica y universitaria, se escribió este libro. El contenido del libro, consiste en una parte teórica 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 capítulos. El primer capítulo trabaja los procesos secuenciales, y la metodología que se debe aplicar para resolver los problemas que se presentan cuando se va a definir un algoritmo. El segundo capítulo contiene los procesos de decisión. 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 capítulo tercero desarrolla los procesos secuenciales, aplicando los conceptos estudiados en los dos primeros capítulos, utilizando la metodología de ejercicios resueltos. El cuarto capítulo maneja los conceptos relacionados con los arreglos, desarrollando ejercicios que le permiten al estudiante aprender a definir algoritmos para manejar volúmenes de información un poco más complicados. El quinto capítulo trata los temas relacionados con C++. En este capítulo se van a aplicar los conocimientos adquiridos en los cuatro primeros, para aprender a manejar este lenguaje. Se va a tratar hasta programación orientada a objetos. Puede ser descargado en formato PDF, de la página web del autor. Para desarrollar los ejercicios resueltos y propuestos, de cada capítulo se utilizó el programa SmartDFD, que es de distribución

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco gratuita y se puede descargar de la página de internet de los autores del programa http://wiki.freaks-unidos.net/freedfd/index Los ejercicios desarrollados en cada capítulo, pueden ser descargados de http://www.nefrabel.net/libros/algoritmos.php, allí también encuentra la opción de hacer consultas en línea de los temas del libro. Los ejercicios realizados en el capítulo 5, funcionan con cualquier compilador de C++, pero cuando se escribió este libro, se utilizó Dev-C++ versión 4.9.9.2. Este software es de distribución gratuita y la última versión se puede descargar de la página de los autores http://www.bloodshed.net/ Para poder descargar estos ejercicios, debe utilizar la clave que aparece en la primera página. Esta clave la puede usar una sola vez, es única e irrepetible, y le sirve para recibir información 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 al correo [email protected].

3

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco

1 Procesos secuenciales 1.1 Introducción En el diseño de programas para computadores hay tres elementos que es necesario tener en cuenta: Entrada de datos. Procesamiento de datos Obtención de resultados Los datos de entrada corresponden a la información inicial que se tiene de una situación determinada, que se quiere automatizar o modificar la forma como está sistematizada o como funciona manualmente. El procesamiento de datos consiste en el análisis y manejo que se debe hacer a los datos de entrada, para obtener algunos resultados intermedios, que permiten llegar a la respuesta deseada o producto final. La obtención de resultados, es el paso final del proceso que se realiza y proporciona la información que se espera obtener después 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 lógicas que se pueden utilizar para hacer que el computador ejecute de la manera más rápida y eficiente los códigos, sin presentar errores que hagan fallar 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 código en el lenguaje que se está trabajando. Estas situaciones erróneas se presentan porque el programador desconoce o no sabe aplicar las estructuras básicas, para hacer los algoritmos que definen los diferentes caminos y pasos que debe seguir el computador para ejecutar el correcto procesamiento de los datos.

5

6

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco 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 lógicos que se utilizan para el procesamiento de la información, así como los pasos que se requieren para verificar que los algoritmos escritos por el programador están bien utilizados y arrojan los resultados esperados. En este primer capítulo, 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 información de la manera que se está pensando. Se aplica una metodología que le permita al programador, seguir una secuencia lógica adecuada para resolver los problemas que se presentan en el momento previo a escribir el código de un programa en cualquier lenguaje; estos pasos son: el análisis de la información, definir cuál es el algoritmo a aplicar, escribir el seudocódigo, 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 Análisis de la información Cuando se necesita un programador de computadores, es porque se quiere sistematizar un procedimiento que se está ejecutando manualmente o se necesita modificar un código ya existente. Generalmente el usuario no sabe definir cuál es el problema. Sólo dice quiero sistematizar esta actividad, o quiero que modifiquen este programa, o esta página web, para que haga las cosas de otra forma diferente a como las está ejecutando; pero él no define el problema en términos precisos que entienda el profesional o experto que va a contratar para que realice esta tarea. Esta definición del problema la debe hacer el programador que está ejecutando el

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco proyecto, de la manera más precisa posible, teniendo en cuenta todas las posibilidades y requerimientos que desea el cliente. Este proceso de analizar la información 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 programación. Porque es muy frecuente que cuando se termina el trabajo de la programación y se va a entregar el programa ya funcionando, el cliente que ha mandado hacer la aplicación dice, pero yo quería que hiciera esto o aquéllo 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 situación, es conveniente que se realice un documento por escrito que contenga la información que suministra el cliente, qué quiere que haga el programa o qué quiere que se haga con esta información 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 información y procesos en el campo de trabajo. Cuando ya se conoce cuál es la situación problema, el paso a seguir es determinar con qué se cuenta para empezar el trabajo, esto quiere decir qué debemos conocer, cuál es la información inicial que se tiene para empezar a hacer el estudio o análisis. Luego se debe saber cuáles 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

7

8

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco recipiente y luego colocarlos en el fuego, porque lo que se tendría al final no sería 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 programación de computadores o escribir el código de un programa, se debe seguir un procedimiento lógico, conociendo cuáles pasos van primero, cuáles después 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 rediseñar el algoritmo y reescribir el código 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 dueño de la compañía, 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 están contemplando las diferentes alternativas y se está minimizando el número 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 eléctrico en la oficina y puede comprobar que el bombillo no prende y, al salir de la oficina, comprueba que las otras oficinas aledañas tienen iluminación. ¿Qué fue lo que hizo el empleado al verificar si prendía el bombillo y comprobar si las otras oficinas contiguas estaban iluminadas?

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco Estaba recolectando la información necesaria para saber qué estaba pasando y cuáles son las alternativas para solucionar el problema. En pocas palabras estaba recolectando la información de campo. Con esta información 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 cómo se debe hacer, entonces ahora si se puede empezar a definir el algoritmo. 1.3 Algoritmo El segundo paso para buscar la solución a un problema de programación de computadores es realizar el algoritmo que defina los pasos finitos que se deben ejecutar en un orden lógico establecido, después de tener clara la información que se tiene para empezar, así como qué procesos, herramientas o datos se requieren como información 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 específico, 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 además inesperado, teniendo resultados equivocados, que van a hacer que se tenga que empezar nuevamente el trabajo, ocasionando pérdida de tiempo y dinero.

9

10

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Ejemplo Continuando con el ejemplo anterior, y aplicando la definición de algoritmo, se deben definir los pasos que se van a ejecutar para poder restablecer nuevamente la iluminación de la oficina. Los pasos necesarios a seguir, son los siguientes: Paso Paso Paso Paso Paso Paso Paso Paso

1: 2: 3: 4: 5: 6: 7: 8:

Buscar el bombillo de repuesto Desconectar el fluido eléctrico Colocar una escalera, cajón o banca debajo del bombillo Pararse sobre la escalera, cajón o banca Desenroscar el bombillo averiado Enroscar el nuevo bombillo Bajar de la escalera, cajón o banca Encender el fluido eléctrico

Si se siguen estos pasos en este orden, es seguro que el empleado podrá restablecer nuevamente la iluminación 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 iluminación de la oficina. Todas las personas actúan de acuerdo a algoritmos que se establecen en la mente. Se tienen algoritmos para bañarse, para vestirse, para cocinar, trabajar, estudiar, para todo y se siguen inconscientemente. 1.4 Seudocódigo El paso siguiente es realizar el seudocódigo. El seudocódigo es una forma de expresar las instrucciones que se realizan en el algoritmo, de la manera más parecida a como se expresarían en un lenguaje de programación.

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco El realizar el seudocódigo permite fácilmente escribir después o traducir el código en un lenguaje de programación determinado, con mayor fluidez y rapidez. Ejemplo Buscar el bombillo de repuesto. Desconectar el fluido eléctrico. Colocar una escalera, cajón o banca debajo del bombillo. Pararse sobre la escalera, cajón o banca. Desenroscar el bombillo averiado. Enroscar el nuevo bombillo. Bajar de la escalera, cajón o banca. Encender el fluido eléctrico. 1.5 Diagrama de flujo Si se expresan las ideas por medio de dibujos y diagramas, es más sencillo que sean comprendidas por las personas a las cuales se las presentamos. Los diagramas de flujo son representaciones gráficas de los algoritmos. Esta herramienta hace que cuando se trabaja con algoritmos complicados, se pueda ver con más claridad el camino a seguir y sea fácil verificar cuál es la forma como se va a comportar el flujo de la información. Como su nombre lo indica, un diagrama de flujo muestra cuáles son los caminos que se deben seguir para ejecutar una actividad o un proceso. Permite ver la selección de alternativas de decisión, 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 están realizando las instrucciones correctamente. El realizar el diagrama de flujo cuando se está trabajando en un proyecto de programación de computadores, es útil porque le permite al programador encontrar nuevas alternativas que puede usar en el algoritmo ya que es más fácil verlas gráficamente.

11

12

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco 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 distribución, que se puede descargar de internet o la versión libre actualizada FreeDFD1.1, también 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 diseño de los diagramas de flujo se utilizan diferentes dibujos o símbolos que sirven para indicar las operaciones que se ejecutan en un programa de computación. Estos dibujos le permiten al programador identificar qué tipo de instrucción tiene que ejecutar, si se debe tomar una decisión, realizar un ciclo repetitivo, seguir un proceso secuencial, leer un arreglo, ejecutar una operación, presentar un mensaje por pantalla o realizar una impresión. En la Tabla 1.1 se pueden ver las convenciones y símbolos utilizados para el diseño de los diagramas de flujo. Si se encuentra la misma convención en dos diagramas de flujo diferentes, ésta tiene el mismo significado y representa la misma acción. Óvalo

Para iniciar y terminar

Rectángulo

Para realizar cálculos o procesos

Trapecio

Para entrada manual de datos

Paralelogramo

Para entrada de datos

14

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco A Subirse sobre la escalera o cajón Desenroscar el bombillo averiado Enroscar el nuevo bombillo Bajar del cajón Encender el fluido eléctrico Terminar Figura 1.1 En la Figura 1.1 del ejemplo, se puede ver la forma como se aplican algunos de los símbolos que se encuentran en la Tabla 1.1. Inicio

Este símbolo se utiliza para indicar el punto de inicio del diagrama de flujo o el final del mismo. La flecha indica la conexión entre dos símbolos y la dirección que sigue la información en el diagrama. Bajar del cajón

El rectángulo representa la ejecución de una operación, instrucción o la asignación de un valor a una variable. 1.6 Prueba de escritorio Cuando se ha realizado el análisis 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

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco obtener, ya se está listo para definir el algoritmo. Teniendo creado el algoritmo, se puede escribir el seudocódigo, 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 conclusión la prueba de escritorio es la prueba final del algoritmo, antes de pasar al lenguaje de programación. El trabajo realizado hasta este momento, es previo a escribir el código en cualquier lenguaje de programación. En el desarrollo de los algoritmos para resolver problemas de diseño 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 información mientras se esté ejecutando el algoritmo o el programa. Esta información se puede cambiar durante la ejecución 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 información no se puede cambiar durante la ejecución del programa. Un programa es un conjunto de instrucciones que sigue el computador, para poder alcanzar un resultado específico. Los programas están escritos en lenguajes de programación, 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 aplicación de estos procesos se conoce como programación estructurada. Para cada uno de estos procesos es necesario utilizar símbolos diferentes y estructuras lógicas diferentes, ya que en cada uno de ellos los datos se manejan de manera completamente diferente.

15

16

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco 1.7 Operadores aritméticos Para realizar las operaciones matemáticas es necesario utilizar los operadores aritméticos, que permiten hacer las operaciones aritméticas entre constantes, números y variables. Cuando se realizan estas operaciones se obtiene como resultado un número. En la Tabla 1.2 se encuentran los operadores aritméticos, y se indica qué clase de operación se puede realizar con cada uno de ellos. Estos operadores se utilizan en los algoritmos, seudocódigos y diagramas de flujo. Operadores aritméticos Operador Operación ** Exponenciación * Multiplicación / División + Suma Resta Mod Módulo (residuo) Div División entera Tabla 1.2 Algunos ejemplos de la aplicación de estos operadores son: Exponenciación: 7 ** 2 = 49 Multiplicación: 9 * 11 = 99 División: 15 / 2 = 7.5 Suma: 3 + 2.5 = 5.5 Resta: 3 - 2.5 = 0.5 Módulo: 7 mod 2 = 1

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco División entera: 7 div 2 = 3 El resultado que se obtiene con mod es el residuo de la división, en el ejemplo anterior si 2 en 7 está 3 veces, queda 1 de residuo. Cuando se realizan operaciones con los operadores aritméticos, presentan expresiones más complicadas que estos ejemplos que acaban de hacer, entonces en esos casos se debe respetar jerarquía o prelación en el orden de realizar las operaciones. puede observar la Tabla 1.3 en donde se encuentra la prelación mayor a menor para cada uno de los operadores aritméticos.

Operador () ** *, /, mod, div +, -

Jerarquía operadores aritméticos Operación Parentesis Exponenciación Multiplicación, división, módulo, división entera Suma, resta

se se la Se de

Jerarquía Mayor

Menor

Tabla 1.3 En una expresión la operación que se realiza primero, es la que se encuentran entre paréntesis, luego sigue la exponenciación porque tiene la mayor prelación, luego siguen la multiplicación, división, módulo, división entera que tienen el mismo grado de jerarquía y por último la suma y resta que tienen la menor prioridad. Para resolver una expresión aritmética se deben cumplir los siguientes puntos: 1. Primero se desarrollan las expresiones que se encuentran entre paréntesis, respetando la jerarquía de los operadores aritméticos. Si hay operaciones que se encuentran entre paréntesis que están anidados, entonces se empieza desde el paréntesis que se encuentra en el último nivel de anidamiento.

17

18

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Ejemplo: (((4+3)/2)*5)**2 (((7)/2)*5)**2 ((3.5)*5)**2 (17.5)**2 306.25 2. La jerarquía de los operadores aritméticos se aplica de izquierda a derecha. Ejemplo: 3–7+9 -4 + 9 5 Ejemplo: 3*7+9/2–8 21 + 9 / 2 – 8 21 + 4.5 – 8 25.5 – 8 25.5 - 8 17.5

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco 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)

19

20

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco (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 lógicas Las expresiones lógicas también conocidas como booleanas, están compuestas por números, constantes, variables y operadores relacionales o lógicos. Cuando se evalúan estas expresiones, el resultado que se obtiene es verdadero o falso. Se utilizan en los procesos de decisión y en una clase de proceso repetitivo, de acuerdo al valor que dé después de evaluar la expresión, 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 números, constantes, variables, expresiones alfanuméricas o expresiones aritméticas. Cuando se validan las expresiones con operadores relacionales se obtienen solamente dos resultados verdadero o falso. Operadores relacionales Operador Operación = Igual a Diferente a < Menor que > Mayor que = Mayor o igual que Tabla 1.4

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco 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 (-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)

21

22

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco (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 lógicos Estos operadores hacen posible establecer condiciones complejas, partiendo de expresiones sencillas. Los operadores lógicos son (Y) que corresponde a la conjunción, (O) a la disyunción y (NO) a la negación. En la Tabla 1.5, se encuentran los operadores lógicos, la prioridad o jerarquía que ejercen en las expresiones lógicas y qué significan.

Operador No Y O

Jerarquía operadores lógicos Operación Jerarquía Significado P; No P; P Mayor No es cierto P P y Q; P & Q; P Q P también Q P o Q; P Q Menor Al menos P al menos Q Tabla 1.5

Capítulo 1: Procesos secuenciales Nelson Francisco Beltrán Franco El operador No, hace las veces de término de enlace y niega la proposición. Ejemplo: Sea la proposición P “El día esta soleado”. Al salir a la calle se verifica que el cielo está nublado y está lloviendo. Entonces la proposición no es cierta, y se expresa de la siguiente forma: No (El día está soleado.) P P Da como resultado: El día no está soleado. El operador No, es una negación de la proposición y es el término de enlace. Ejemplo: La luna no está hecha de queso. La proposición es “la luna está hecha de queso”, el término de enlace es no. Se tiene como resultado una negación. El operador Y forma una conjunción, también cumple la función de término de enlace, por ejemplo si se tienen las proposiciones P “el día está soleado” y la proposición Q “está haciendo calor”, entonces el papel que desempeña el operador o término de enlace es: P

Q

P&Q PyQ

23

24

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Se puede escribir de estas tres formas y significan lo mismo. La proposición es: El día está soleado y está haciendo calor. El operador O forma una disyunción, cumple la función de término de enlace, por ejemplo si se tienen las proposiciones P “Rocío está en Bogotá” y la proposición Q “no viajó el fin de semana”, entonces el papel que desempeña el operador o término de enlace es: P

Q

PoQ Se puede representar de estas dos formas y tienen el mismo significado. La proposición entonces queda: Rocío está en Bogotá o no viajó el fin de semana. 1.9 Tablas de certeza de los operadores lógicos Para poder saber si las proposiciones son ciertas o falsas, se utilizan las tablas de certeza. A continuación se encuentran las tablas de certeza, para los tres operadores o términos de enlace vistos. Negación P P Cierta Falsa Falsa Cierta Tabla 1.6 En el ejemplo 5 > 3 la proposición es cierta, y al hacer la negación (5>3) es falsa, porque cinco es mayor que tres. Cuando la proposición es Falsa, 5 < 3 al hacer la negación (5 0 haga Presente “El número es mayor que cero” Fin si Terminar

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco En el seudocódigo anterior, se puede ver que en el proceso Si – Fin si, se realiza la comparación de la variable Número para saber si es mayor que 0, si es así, se continúa con la instrucción que se encuentra indexada a la derecha, ésta es una manera de indicar que esa instrucción pertenece al proceso Si, y si no es cierto, se continúa con la instrucción Fin si, para salir del proceso y terminar el algoritmo. Diagrama de flujo Iniciar

número Número = número Si

Número > 0 No

El número es mayor que cero

Terminar Figura 2.2 Número Este símbolo indica que se está leyendo correspondiente al número que se quiere evaluar. Número = número

el

valor

En esta instrucción, se está asignando o guardando el valor que se acaba de leer, en la variable Número. 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 asignación.

53

54

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Si

Número > 0 No

En este gráfico, se está indicando que se compara el valor guardado en la variable Número para saber si es mayor que cero. Se ve la alternativa Si, que se ejecuta cuando se cumple con la condición establecida y continúa para presentar el mensaje, de lo contrario se sigue con el flujo de la información sin realizar ninguna instrucción. El número es mayor que cero

Este símbolo se utiliza para indicar que se va a presentar un mensaje al usuario del programa. Prueba de escritorio Para comprobar el funcionamiento del algoritmo, se van a utilizar dos número, 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 número 1. número 1 Tabla 2.1 Ahora se guarda este valor que se acaba de leer en la variable Número. número 1

Número 1

Tabla 2.2 Se hace la comparación de la variable Número con el cero. Como es mayor que cero, entonces se presenta el mensaje al usuario.

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco número 1

Número 1

Presentar mensaje El número es mayor que cero Tabla 2.3

Se realiza entonces la prueba para el valor -1. número -1 Tabla 2.4 En la variable Número se almacena el valor leído. número -1

Número -1

Tabla 2.5 Se hace la comparación de la variable Número 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 capítulo, el grado de complejidad va aumentando. E.2.2 Escriba un algoritmo que lea 2 números. El primero se debe guardar en una variable llamada Numerador y el segundo en una variable llamada Denominador. Luego realice la división de Numerador entre Denominador. Presentar el valor de la división. Si la división no es posible realizarla, entonces terminar. Análisis de la información En este ejercicio, se van a leer dos números, se guarda el primero en la variable Numerador y el segundo en la variable Denominador. Antes de realizar la división se debe comparar la variable

55

56

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco 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 división es posible hacerla o no, y evitar que se presente un error en el algoritmo cuando se pase a un lenguaje de programación. Algoritmo Paso Paso Paso Paso Paso Paso Paso Paso Paso

1: Lea el primer número. 2: Numerador es igual al primer número. 3: Lea el segundo número. 4: Denominador es igual al segundo número. 5: Si Denominador es diferente de cero continúe, si no vaya 8. 6: División es igual a Numerador/Denominador. 7: Presentar el valor de la división. 8: Terminar.

Seudocódigo Leer primer número Numerador = primer número Leer segundo número Denominador = segundo número Si Denominador 0 haga División = Numerador / Denominador Fin si Presentar División Terminar

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco Diagrama de flujo

Iniciar Primero Numerador = Primero SI USTED ESTÁ INTERESADO EN SEGUIR CONSULTANDO ESTE LIBRO, LO Segundo PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la cuenta de correo [email protected]

Denominador = Segundo

No

Denominador0 Si

División = Numerador/Denominador

División

Terminar Figura 2.3 Prueba de escritorio 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 número que es igual a 1. primero 1 Tabla 2.6

57

58

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Se guarda el primer número en la variable Numerador. primero 1

Numerador 1

Tabla 2.7 Ahora se lee el segundo número que es igual a 2. primero 1

Numerador 1

segundo 2

Tabla 2.8 Se guarda el segundo número leído en la variable Denominador. primero 1

Numerador 1

segundo 2

Denominador 2

Tabla 2.9 Viene ahora la comprobación del Denominador. El valor de la variable Denominador es diferente de 0, entonces se realiza la división del Numerador entre el Denominador y se almacena este valor en la variable División. El resultado de esta división es 0.5. primero 1

Numerador 1

segundo 2

Denominador 2

División 0.5

Tabla 2.10 Quedó comprobado que funciona el algoritmo, para dos números diferentes de cero. Ahora se va a hacer la prueba de escritorio para dos números diferentes 1 y 0. Se lee el primer número que es igual a 1.

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco primero 1 Tabla 2.11 Se guarda el primer número en la variable Numerador. primero 1

Numerador 1

Tabla 2.12 Ahora se lee el segundo número que es igual a 0. primero 1

Numerador 1

segundo 0

Tabla 2.13 Se guarda el segundo número leído en la variable Denominador.

primero 1

Numerador 1

segundo 0

Denominador 0

Tabla 2.14 A continuación se realiza la comprobación del Denominador. El valor de la variable Denominador es igual a 0, entonces se termina el algoritmo. De esta forma se evalúa 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 números, 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 cuál es el mayor, cuál el intermedio y cuál el menor, y a medida que los vaya leyendo que cada uno lo guarde en

59

60

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco una variable que represente el resultado de la comparación, el mayor en la variable Mayor, el intermedio en la variable Intermedio y el menor en la variable Menor y a continuación presente un mensaje con los números ordenados. Análisis de la Información Se van a leer tres números, a medida que se leen se van guardando en las variables Mayor, Medio Menor; luego se van comparando mayor con medio para saber cuál 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 comparación 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 método 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 Paso Paso Paso

1: 2: 3: 4:

Conocer Guardar Conocer Guardar

primer número primer número en la variable Mayor segundo número segundo número en la variable Medio

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco Paso 5: Conocer tercer número Paso 6: Guardar tercer número 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 variables; de lo contrario continuar. Paso 11: Comparar Medio con Menor. Paso 12: Si Medio es menor que Menor, intercambiar los valores de las variables; de lo contrario continuar. Paso 13: Presentar “Mayor =”, Mayor. Paso 14: Presentar “Medio =”, Medio. Paso 15: Presentar “Menor =”, Menor. Paso 16: Terminar Seudocódigo 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

61

62

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Fin si Presente “Mayor =”, Mayor Presente “Medio =”, Medio Presente “Menor =”, Menor Terminar Diagrama de flujo Iniciar primero Mayor = primero segundo Medio = segundo tercero SI USTED ESTÁ INTERESADO EN SEGUIR CONSULTANDO ESTE LIBRO, LO = tercero PUEDE COMPRAR ENMenor LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la cuenta de correo [email protected]

Mayor < Medio

Si C = Mayor

No

Mayor = Medio Medio = C Si Mayor < Menor C = Mayor

No

Mayor = Menor

A

Menor = C

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco A Si

Medio < Menor

C = Medio

No

Medio = Menor SI USTED ESTÁ INTERESADO ENMayor, SEGUIR CONSULTANDO ESTE LIBRO, LO Menor = C al autor en la PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar Medio, Menor cuenta de correo [email protected]

Terminar 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. Prueba de escritorio Para realizar la prueba de este algoritmo, se utilizan tres números diferentes. El primer número leído es 1, el segundo número leído es 2 y por último el tercer número leído es 3, después estos tres valores se almacenan en las variables Mayor, Medio y Menor respectivamente. primero 1

segundo 2

tercero 3

Mayor 1

Medio 2

Menor 3

Tabla 2.15 Ya están leídos y almacenados en sus respectivas variables los valores iniciales. Se hace la primera comparación para saber si el valor de la variable Mayor es menor que el contenido de la variable

63

64

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Medio. Si esto no es cierto, se continúa con la siguiente comparación 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 están registrando los resultados de las instrucciones establecidas en el algoritmo, es la siguiente. Mayor 1 2

Medio 2 1

Menor 3 3

C 1

Tabla 2.16 Continuando con la siguiente comparación, se verifica si el valor de la variable Mayor es menor que el valor de la variable Menor. Si esto no es cierto, se continúa con la tercera comparación 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 1 2 3

Medio 2 1 1

Menor 3 3 2

C 1 2

Tabla 2.17 La última comparación 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 continúa con la siguiente instrucción, 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

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco 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 1 2 3 3

Medio 2 1 1 2

Menor 3 3 2 1

C 1 2 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 ordenación en burbuja, y basándose en el ejemplo anterior para organizar los números de menor a mayor, para reforzar los conocimientos aprendidos. Mayor

Medio

Menor

C

1 2 3 3

2 1 1 2

3 3 2 1

1 2 1

Presente Mayor

Presente Medio

Presente menor

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 función de sus componentes vectoriales en las direcciones de los vectores unitarios

Análisis de la información Este es otro ejercicio muy interesante, porque requiere que se investigue un poco de qué está hablando el enunciado, antes de empezar a escribir el algoritmo.

65

66

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Para empezar ¿qué es un vector? Es todo aquello que tiene magnitud, dirección y sentido, ejemplo, la velocidad, la fuerza, la aceleración, etc. Todas las cantidades que NO tienen dirección y sentido, se conocen como escalares, por ejemplo el tiempo, la temperatura, etc. Ya se puede ver que se va a trabajar con cantidades Físicas. De acuerdo al enunciado, se va a trabajar con vectores en . Entonces además 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 x El ángulo

Figura 2.5

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 están en la dirección 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 cálculos: Componente en la dirección de

= M*Cos(

)

Componente en la dirección de

= M*Cos(

)

1

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco Componente en la dirección de

= M*Cos(

)

Teniendo esta información, 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 SI USTED INTERESADO ENvariable SEGUIR CONSULTANDO ESTE LIBRO, LO Paso ESTÁ 8: Guardarlo en la C

PUEDE COMPRAR EN2LA PÁGINA 2WWW.NEFRABEL.NET o contactar al autor en la Paso 9: [email protected] Cos (A) Cos (B) Cos2(C) 1 continúe, de lo contrario cuenta de correo

vaya Paso Paso Paso Paso Paso

el Paso 14 10: Guarde en la variable Mx la operación M*Cos(A) 11: Guarde en la variable My la operación M*Cos(B) 12: Guarde en la variable Mz la operación M*Cos(C) 13: Presente “M = “, Mx, “ + ", My, “ +", Mz, “ ” 14: Termine.

Seudocódigo Lea magnitud M = magnitud Lea X A=X Lea Y B=Y Lea Z C=Z Si Cos2(A)

Cos2(B)

Mx = M*Cos(A) My = M*Cos(B) Mz = M*Cos(C)

Cos2(C)

1 haga

67

68

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Presente “M = “, Mx, “ Fin si Terminar

+ ", My, “ + ", Mz, “

Diagrama de flujo Iniciar magnitud M = magnitud X A=X Y B=Y Z C=Z

SI USTED ESTÁ INTERESADO EN SEGUIR CONSULTANDO ESTE LIBRO, LO PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la 2 2 cuenta de correo [email protected] Cos (A) + Cos (B) +

Si

2

Cos (C) = 1

Mx = M*Cos(A) No

My = M*Cos(B) Mz = M*Cos(C) “M = “, Mx, “ “ + ", Mz, “

Terminar Figura 2.6

+ ", My,

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco Prueba de escritorio La comprobación 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 10

M 10

Tabla 2.20 Ahora se continúa leyendo los ángulos que el vector forma con los ejes coordenados. magnitud 10

M 10

X 64.89º

A 64.89º

Y 55.54º

B 55.54º

Z 44.99º

C 44.99º

Tabla 2.21 Se continúa con la validación de los ángulos leídos, 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 están correctos los ángulos y corresponden al mismo vector. Se sigue con el cálculo de las componentes vectoriales. magnitud 10

M 10

X 64.89º Mx 4.24

A 64.89º My 5.66

Y 55.54º Mz 7.10

B 55.54º

Z 44.99º

C 44.99º

Tabla 2.22 El mensaje presenta el vector en sus componentes vectoriales en la dirección de los vectores unitarios i, j, k. magnitud 10

M 10

X 64.89º Mx

A 64.89º My

Y 55.54º Mz

B 55.54º

Z 44.99º Mensaje

C 44.99º

69

70

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco 4.24

5.66

7.10

M = 4.24

+ 5.66

+ 7.10

Tabla 2.23 Este ejercicio, muestra de una manera sencilla cómo se realiza la comparación para validar una operación y poder determinar qué camino se debe seguir, si se cumple la condición, 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 números y determine si corresponden a los lados de un triángulo, si es así, entonces clasifique el tipo de triángulo: escaleno, isósceles, equilátero. Análisis de la información 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 triángulo haciendo que la suma de dos de los lados sea mayor que el tercer lado. Esta comparación se realiza para (Lado1 + Lado2) > Lado3, luego, (Lado1 + Lado3) > Lado2 y por último SI USTED ESTÁ INTERESADO CONSULTANDO LIBRO, LO (Lado3 + Lado2) > Lado1, EN ya SEGUIR te tienen todas las ESTE comparaciones PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en posibles para saber qué tipo de triángulo es, isósceles, equilátero o la cuenta de correo [email protected] escaleno. En el caso que no se cumplan estas tres validaciones de la información, los lados no corresponden a un triángulo. Algoritmo Paso 1: Conocer el primer número. Paso 2: La variable Lado1 es igual a primer número. Paso 3: Conocer el segundo número. Paso 4: La variable Lado2 es igual a segundo número. Paso 5: Conocer el tercer número. Paso 6: La variable Lado3 es igual a tercer número. Paso 7: Comparar que la suma de Lado1 más Lado2 es mayor que Lado3.

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco Paso 8: Si lo anterior no es cierto, entonces no es un triángulo, vaya al Paso 18. Paso 9: Comparar que la suma de Lado1 más Lado3 es mayor que Lado2. Paso 10: Si lo anterior no es cierto, entonces no es un triángulo, vaya al Paso 18. Paso 11: Comparar que la suma de Lado2 más Lado3 es mayor que Lado1. Paso 12: Si lo anterior no es cierto, entonces no es un triángulo, vaya al Paso 18. Paso 13: Comprobar que el Lado1 es igual a Lado2 y a Lado3. Paso 14: Si la comprobación fue cierta, es un triángulo equilátero Paso 15: Si la comprobación 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 comprobación es cierta entonces es un triángulo escaleno. Paso 17: Si la comprobación no es cierta, es un triángulo isósceles. Paso 18: Terminar. Seudocódigo Lea el número primero Lado1 = primero Lea el número segundo Lado2 = segundo Lea el número tercero Lado3 = tercero Si (Lado1 + Lado2) > Lado3 haga Si (Lado2 + Lado3) > Lado1 haga Si (Lado1 + Lado3) > Lado2 haga Si (Lado1 = Lado2 = Lado3) haga Presente “El triángulo es equilátero” Si no Si (Lado1 ≠ Lado2 ≠ Lado3) haga Presente “El triángulo es escaleno” Si no

71

72

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Presente “El triángulo es isósceles” Fin si Fin si Si no Presente “No es un triángulo” Fin si Si no Presente “No es triángulo” Fin si Si no Presente “No es un triángulo” Fin si Terminar Diagrama de flujo

Iniciar primeroCONSULTANDO ESTE LIBRO, LO SI USTED ESTÁ INTERESADO EN SEGUIR PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la cuenta de correo [email protected] Lado1 = primero segundo Lado2 = segundo tercero Lado3 = tercero A

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco A

(Lado1 + Lado2) > Lado3

No

Si (Lado1 + Lado3) > Lado2

No

Si (Lado2 + Lado3) > Lado1

No

SI USTED ESTÁ INTERESADO EN SEGUIR CONSULTANDO ESTE LIBRO, LO PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la Si cuenta de correo [email protected]

Si Triángulo equilátero Si Triángulo escaleno

Lado1 = Lado2 = Lado3 No Lado1 ≠ Lado2 ≠ Lado3 No Triángulo isósceles

Terminar Figura 2.7

No es un Triángulo

73

74

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Prueba de escritorio Para realizar la verificación del funcionamiento de este algoritmo, se toman tres valores y se realizan las comparaciones respectivas para saber si corresponden a un triángulo y si es así, a qué tipo de triángulo. primero 4

segundo 5

tercero 3

Lado1 4

Lado2 5

Lado3 3

Tabla 2.24 Inicialmente, se leen los valores y se guardan en las tres variables respectivas. La primera comparación es cierta, ya que (Lado1 + Lado2) > Lado3, entonces se debe continuar con la opción del si, ahora (Lado2 + Lado3) > Lado1, esta comparación resultó cierta, entonces se sigue con la opción del si, y se tiene (Lado1 + Lado3) > Lado2, después de hacer estas comparaciones entre los valores de las variables, se puede decir que corresponden a un triángulo. Para saber qué tipo de triángulo 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 triángulo es escaleno. Hacer ahora la prueba de escritorio para otros valores diferentes: primero 2

segundo 4

tercero 2

Lado1 2

Lado2 4

Lado3 2

Tabla 2.25 Inicialmente, se leen los valores y se guardan en las tres variables respectivas. La primera comparación es cierta, ya que (Lado1 + Lado2) > Lado3, entonces se debe continuar con la opción del si, ahora (Lado2 + Lado3) > Lado1, esta comparación resultó cierta, entonces se sigue con la opción del si, y se tiene (Lado1 + Lado3) > Lado2, que resulta falso, entonces los lados no corresponden a un

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco triángulo, porque 2 + 2 > 4 no es cierto, entonces se presenta el mensaje “No es un triángulo” y termina el algoritmo. E.2.6 La comisión que recibe un vendedor sobre las ventas es: Si ventas < $ 500,000 no hay comisión. Si $ 500,000 Segundo, pero también se puede hacer Primero < Segundo. Ambas expresiones son correctas. Prueba de escritorio Es el momento de verificar si la lógica utilizada para escribir el algoritmo está correcta y los valores que presenta son válidos. Se toman inicialmente dos números cualesquiera y se le asignan a las variables primero y segundo registrándolos en una tabla. Se utilizan los números -1 y 2 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 -1

Primero -1

Tabla 2.32 Se repite el mismo procedimiento para leer el segundo número.

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco primero -1

Primero -1

segundo 2

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

Primero -1

segundo 2

Segundo 2

Tabla 2.34 Ahora se hace la comparación, ¿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 -1

Primero -1

segundo 2

Segundo 2

Mensaje El mayor es: 2; El menor es: -1

Tabla 2.35 Se toman los valores invertidos, para verificar la otra opción que permite el algoritmo. Primero 2

Segundo -1

Tabla 2.36 ¿El contenido de la variable Primero es mayor que el contenido de la variable Segundo? Si, entonces Primero 2

Segundo -1

Mensaje El mayor es: 2; El menor es: -1 Tabla 2.37

83

84

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco E.2.8 Escriba un algoritmo que evalúe todas las posibles soluciones de una ecuación de segundo grado, Raíces reales y complejas. Análisis de la información Para desarrollar este ejercicio correctamente, se debe hacer un análisis de la información muy riguroso. El enunciado es inofensivo, pero el desarrollo no lo es. Para empezar ¿cuál es la forma de una ecuación de segundo grado?

Ésta es la forma general de una ecuación de segundo grado. ¿Cómo se resuelve una ecuación de segundo grado? Bueno, hay dos formas, si es factorizable, entonces se factoriza y se despejan las raíces para poder encontrar las raíces que son las soluciones de la ecuación. Si no es factorizable ¿cómo se calculan las raíces?

Esta ecuación calcula las raíces de la ecuación 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 raíces están dentro del conjunto de los reales, pero si es menor se tiene una raíz cuadrada de un número negativo, que corresponde al conjunto de los imaginarios. En el capítulo anterior se realizó un ejercicio que trata de operaciones con números complejos, entonces ya se sabe que , que es un dato importante en el momento de calcular el discriminante. Cuando se escribe esta expresión se está indicando que se va a calcular su valor absoluto. Entonces ya se

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco sabe que se pueden tener raíces reales y raíces complejas y en un caso muy particular darían raíces imaginarias. ¿En qué caso sería? Cuando los enunciados se van complicando, es importante, hacer un análisis de la información, 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 continúe con el paso siguiente de lo contrario vaya al Paso 12. Paso 9: Calcule

y guárdelo en una variable X1.

Paso 10: Calcule y guárdelo 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 raíz cuadrada del número, primero se calcula el valor absoluto de la cantidad que está dentro del radical y luego si se calcula la raíz, porque corresponde a un número negativo y la raíz cuadrada de los números negativos no está contemplada dentro del conjunto de los números reales.

85

86

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco Seudocódigo 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 SI USTED ESTÁ INTERESADO Discriminante1 = EN SEGUIR CONSULTANDO ESTE LIBRO, LO PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la Factor = cuenta de correo [email protected]

Presente “X1 =”, Factor, ”+”, Discriminente1, ” ”. Presente “X2 =”, Factor, ”-”, Discriminente1, ” ”.

Fin si Terminar Diagrama de flujo Inicia r A A=A B B=B C A

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco A C=C Discriminante = SI USTED ESTÁ INTERESADO EN SEGUIR CONSULTANDO ESTE LIBRO, LO No Si PUEDE COMPRAR EN LA PÁGINA WWW.NEFRABEL.NET o contactar al autor en la Discriminante >0 cuenta de correo [email protected]

X1 =

Discriminante1 = Factor =

X1 =

“X1 =”, Factor, ”+”, Discriminente1, ” ”; “X2 =”, Factor, ”-”, Discriminente1, ” ”

“X1 =”, X1; “X2 =”, X2

Terminar Figura 2.12 Prueba de escritorio Este es un ejercicio interesante, que permite ver claramente, que antes de empezar a escribir, se debe analizar la información que dan en el enunciado del ejercicio, qué se tiene que calcular antes de poder llegar a la respuesta final y por qué métodos. La prueba de escritorio se hace para la ecuación:

Se leen los tres coeficientes y se guardan en tres variables, A, B y C.

87

88

Apuntes de clase de algoritmos Nelson Francisco Beltrán Franco A 7

B 2

C 1

Tabla 2.38 La instrucción siguiente es calcular el valor del discriminante. A 7

B 2

C 1

Discriminante -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 raíz cuadrada de un número dentro del conjunto de los números reales. Entonces calcular el valor de Discriminante1 A 7

B 2

C 1

Discriminante -32

Discriminante1

Tabla 2.40 El cálculo de la variable Factor es A 7

B 2

C 1

Discriminante -32

Discriminante1

Factor

Tabla 2.41 Los cálculos ya están todos realizados, entonces se puede presentar el mensaje con los valores de las dos raíces complejas. A 7

B 2

C 1

Discriminante -32

Discriminante1

Tabla 2.42

Factor

X1

X2

Capítulo 2: Procesos de toma de decisiones Nelson Francisco Beltrán Franco El lector puede realizar la prueba de escritorio de este ejercicio para una ecuación de segundo grado con raíces reales, por ejemplo:

E.2.9 En una universidad tienen los siguientes criterios para admitir a los estudiantes. Clasifican los exámenes de admisión calificados de 0 a 100 de la siguiente manera: 0