• Author / Uploaded
• LarissaItzelE

Citation preview

FACULTAD DE INFORMÁTICA, ELECTRÓNICA CURSO PROPEDEUTICO

ASIGNATURA: LOGICA DE PROGRAMACIÓN MÓDULO: TEMA 1. CONCEPTOS BÁSICOS TEMA 2. ALGORITMO TEMA 3. DIAGRAMA DE FLUJO

NOMBRE DEL ESTUDIANTE _________________________________________

1

PREPARADO POR LOS PROFESORES

ISIS DE LOS RIOS CALET JIMENEZ ANGEL AVILA CINDY ESQUIVEL LILLY VON CHONG SAULO AISPRUA NELSON MONTILLA

2

Los algoritmos han consistido en simples secuencias de instrucciones (estructuras secuenciales); sin embargo, existen tareas más complejas que no pueden ser resueltas empleando un esquema tan sencillo, en ocasiones es necesario repetir una misma acción un número determinado de veces o evaluar una expresión y realizar acciones diferentes en base al resultado de dicha evaluación. Para resolver estas situaciones existen las denominadas estructuras de control que poseen las siguientes características: Una estructura de control tiene un único punto de entrada y un único punto de salida. Una estructura de control se compone de sentencias o de otras estructuras de control. Tales características permiten desarrollar de forma muy flexible todo tipo de algoritmos aun cuando sólo existen tres tipos fundamentales de estructuras de control en programación: Secuencial. Alternativa. Repetitiva. En este módulo el estudiante enfocará sus aprendizaje en las “CONCEPTOS BASICOS PARA EL DESARROLLO DE ALGORITMOS, ALGORITMOS, DIAGRAMA DE FLUJO”, complementando a través de la investigación de definiciones, ejemplos de aplicación y resolución de problemas, que le permitirá desarrollar las actividades de aprendizajes que se presentan en cada tema distribuidos en:

3

TEMA 1. CONCEPTOS BÁSICOS TEMA 2. ALGORITMO TEMA 3. DIAGRAMA DE FLUJO Les sugerimos leer, analizar y sintetizar el material de lectura y luego desarrollar las actividades complementándolo con su propia investigación de diferentes definiciones y ejemplos que se apliquen a la temática para su mayor comprensión. Saludos,

4

Responda las siguientes preguntas referentes al tema 1. Estructuras de decisión o alternativa: 1. ¿Defina qué es un algoritmo? ______________________________________________________________________________________ ______________________________________________________________________________________ ______________________________________________________________________________________ 2.

¿Qué es lógica de programación?

______________________________________________________________________________________ ______________________________________________________________________________________ ______________________________________________________________________________________ 3. ¿Cuáles son las técnicas que se utilizan para la lógica de programación? _______________________________________________________________________________________ _______________________________________________________________________________________ _______________________________________________________________________________________

5

INDICE Objetivos de aprendizaje ............................................................................................... 9 Capítulo 1: CONCEPTOS BÁSICOS PARA EL DESARROLLO DE ALGORITMOS .......................................................................................................... 10 1.1. Algoritmo........................................................................................................... 10 1.2. Datos y Tipos de Datos .................................................................................. 10 1.2.1. Datos Numéricos .................................................................................................. 11 1.2.2. Datos Booleanos .................................................................................................. 11 1.2.3 Datos Alfanuméricos ............................................................................................. 11

1.3. Variables............................................................................................................ 11 1.4. Constantes ........................................................................................................ 13 1.5. Expresiones Aritméticas ................................................................................. 14 1.5.1. Operadores Aritméticos....................................................................................... 14 1.5.2. Precedencia de Operadores ................................................................................ 14

1.6. Expresiones Relacionales .............................................................................. 15 1.7. Operadores Lógicos o Booleanos ................................................................. 15 1.8. Pasos a seguir en el diseño de un algoritmo .............................................. 16 1.9. Representación de Algoritmos ...................................................................... 16 PROBLEMAS.MODULO 1. Capítulo 1. .................................................................. 17 Ejercicios Propuestos .................................................................................................... 17 Problemas resueltos: ..................................................................................................... 18

CAPÍTULO 2. DESARROLLO DE ALGORITMOS CON EL USO DE PSEUDOCÓDIGO..................................................................................................... 20 2.1. Enunciados para el Desarrollo de Algoritmos. ............................................ 20 2.1.1. Enunciado de Asignación. .................................................................................. 20 2.1.1.1. Reglas para la construcción de enunciados de asignación. ............................................ 22

2.1.2. Enunciados de Lectura de datos. ....................................................................... 22 2.1.3. Enunciado de Escritura. ...................................................................................... 23 2.1.4. Enunciado de Inicio y Terminación. .................................................................. 23 2.1.5. Adición de Comentarios. ..................................................................................... 24

6

2.1.6. Declaración de Variables y Constantes. ............................................................ 25 2.1.7. Enunciados de selección. ......................................................................................................... 26

2. 1.8 Enunciados de Repetición.......................................................................... 34 2.1.8.1. Contadores y Acumuladores................................................................................................. 35 2.1.8.2. Estructura Repetitiva Mientras..hacer. ................................................................................ 36 2.1.8.3. Estructura Para..hacer. .......................................................................................................... 40

2.2. Estructura de Datos (Arreglos). ..................................................................... 47 2.2.1. Arreglos Unidimensionales. ...................................................................................................... 47 2.2.2. Arreglos Bidimensionales. ........................................................................................................ 52

PROBLEMAS .MODULO 2. CAPITULO 2 ......................................................................... 59 Problemas resueltos ........................................................................................................... 59 Problemas Propuestos ........................................................................................................ 63

CAPITULO 3. DESARROLLO DE ALGORITMOS CON EL USO DE DIAGRAMAS DE FLUJO. ........................................................................................ 63 3.1. Diagrama de Flujo / FlowChart. ...................................................................... 63 3.2. Simbología utilizada en el diseño de Representación de Diagramas de Flujo .......................................................................................................................... 64 3.2.1 Reglas para la creación de Diagramas de flujo ................................................. 67

3.3 Sentencias Secuencial ..................................................................................... 67 3.4 Sentencias Selectivas ...................................................................................... 69 3.4.1 3.4.2 3.4.3 3.4.5

Selectivas Simples ..................................................................................................................... 70 Selectivas Doble ........................................................................................................................ 71 Selectivas Anidadas .................................................................................................................. 73 Selectivas múltiples ................................................................................................................... 78

3.5 Estructuras Repetitivas .................................................................................... 80 3.5.1 Repetitiva Mientras ..................................................................................................................... 81 3.5.2 Repetitiva hacer mientras .......................................................................................................... 83 3.5.3 Repetitiva Repetir hasta ............................................................................................................. 85 3.5.4 Repetitiva Repetir Desde/Para ................................................................................................. 86

VENTAJAS DE USAR FLUJOGRAMAS ........................................................................ 89 DESVENTAJAS DE LOS FLUJOGRAMAS ................................................................... 89

Problemas Propuestos ........................................................................................... 90 BIBLIOGRAFIA......................................................................................................... 93

7

8

Objetivos de aprendizaje

 Emplea las técnicas de pseudocódigo y diagrama de flujo para representar algoritmos.  Maneja estructuras básicas para analizar problemas, diseñar, implementar algoritmos y depurar los resultados.

9

Capítulo 1: CONCEPTOS BÁSICOS PARA EL DESARROLLO DE ALGORITMOS 1.1. Algoritmo La palabra algoritmo significa “método de resolución de un problema en un número finito de pasos”.

Algoritmo no significa la resolución de un problema particular para unos datos particulares, sino la resolución de todos los problemas del mismo tipo, sean cuales los datos de que se parta, y previendo las alternativas de actuación convenientes según los distintos tipos de datos y situaciones que se nos pueda presentar. Un algoritmo es un método general de resolución de todos los problemas del mismo tipo. Todo lo que se ha de hacer debe estar de forma detallada, paso a paso. A cada uno de estos pasos de un algoritmo se le llama sentencia o instrucción. Una instrucción es una combinación de palabras, variables, constantes y símbolos que obedeciendo a la sintaxis propia del lenguaje son utilizados por el ordenador para realizar una determinada acción. Cada instrucción se escribe en una línea diferente. Un programa es la expresión de un algoritmo en un lenguaje de programación entendible por el ordenador. No existe un lenguaje único y universal para la descripción de los algoritmos. Ejemplo: Basic, Cobol, Pascal, C, Clipper, etc. 1.2. Datos y Tipos de Datos Dato: es la materia prima de la información. Según sea la información que guardemos en los datos, los clasificaremos en los siguientes tipos: Numéricos, Booleanos, Alfanuméricos.

10

1.2.1. Datos Numéricos Almacenan números en las variables y con ellos podremos realizar operaciones aritméticas. A su vez, pueden ser: - Enteros: son todos los números positivos o negativos. Ejemplo: 734, -123, 0, -1. - Reales: son los números decimales. Ejemplo: -0.123, 67.8, 32.02. 1.2.2. Datos Booleanos Sólo pueden tener dos valores: verdad o falso. Estos datos no pueden leerse como datos, pero pueden imprimirse. Se forman a partir de los operadores relacionales y lógicos. 1.2.3 Datos Alfanuméricos Almacena caracteres alfanuméricos. Pueden ser: - Letras: A-Z. -Caract-eres especiales: guiones, paréntesis, signos de puntuación, etc. -Números: con ellos no se pueden realizar operaciones aritméticas. - Una mezcla de letras, caracteres especiales y números. Ejemplo: alfa2, res34. 1.3. Variables Se considera variable a una zona de memoria referenciada por un nombre de variable, donde se puede almacenar el valor de un dato, que puede cambiarse cuando lo deseemos. El nombre de la variable es elegido por el usuario. Una variable no es un dato, sino un área de memoria que contendrá un dato. El ordenador asigna a cada variable una dirección de memoria. Cuando hagamos referencia a esa variable, el ordenador siempre irá a esa

11

dirección. Es como si pudiéramos poner sólo los nombres en nuestras cartas y la oficina de correos mirara la dirección. Al hablar de la memoria central del ordenador teníamos la siguiente figura: 101

102

103

104

55

109

110

111

112

Para leer el número 55 o cambiarlo, le teníamos que decir al ordenador que se fuera a la dirección de memoria 103. Tipos de variables: -Numéricas: las escribimos Nombre de variable = numero

Ejemplo: a=1, numero=55, contador=675, etc.

-Alfanuméricas: las podemos escribir de dos formas: Nombre de variable =“comentario”

Ejemplo: B = “hola” Apellido = “Fernández” Nombre = “José Luis” 12

Res = “ “ (un espacio en blanco)

El comentario siempre va entre comillas. contenido.

Las comillas no las almacena, sólo su

Nombre-variable= espacios (numero)

Ejemplo: Alfa = espacios(5) Apellido = espacios(30) - Booleanas: cuando almacena datos booleanos; por ejemplo: z = VERDAD. La forma de almacenarlas en el ordenador es utilizando un único bit (unidad mínima de información, que pueden ser un 0 o un 1), 1 para verdad y 0 para falso. Algunas veces puede utilizarse 1111 1111 para verdad y 0000 0000 para falso, 1 byte por cada valor (un byte es un conjunto de 8 bits).

1.4. Constantes Se llama constante a toda posición de memoria, referenciada por un nombre de constante, donde se almacena un valor que no puede cambiarse o permanece invariable a los largo del proceso. Las constantes pueden ser: - Enteras: números con valor entero ya sea positivo o negativo. Ejemplo: an_recto = 90. - Reales: números con punto decimal. Ejemplo: pi= 3.1416 - De caracteres o alfanuméricas: contienen una serie de caracteres tales como letras mayúsculas, minúsculas, dígitos, signos de puntuación y otros símbolos especiales. Ejemplo: Ciudad = “Madrid” Teléfono = “91-45-6758”

13

1.5. Expresiones Aritméticas 1.5.1. Operadores Aritméticos Para tratar los números se utilizan los operadores aritméticos, que, junto con las variables numéricas forman expresiones aritméticas. La Tabla 1 . Resumen de los operadores aritméticos. Signo + * ^ / DIV MOD

Significado Suma Resta Multiplicación Potenciación División real División entera Resto de la división

Los operadores DIV y MOD son los de menor prioridad. Ejemplo: Expresión Resultado 12 * 12 144 12 ^ 2 144 123 DIV 4 30 12 MOD 5 2

1.5.2. Precedencia de Operadores La prioridad a la hora de evaluar los operadores en cualquier expresión es: -Paréntesis (empezando por los más internos) -Potencias -Productos y divisiones -Sumas y restas

14

1.6. Expresiones Relacionales 1.6.1. Operadores Relacionales Se utilizan para formar expresiones booleanas, es decir, expresiones que al ser evaluadas producen un valor booleano; verdad o falso. Tabla 2. Se reúnen los distintos operadores relacionales Signo < = > =

Significado Menor que Igual que Mayor que Menor o igual que Mayor o igual que Distinto

Ejemplos> Comparación Resultado 25 < = 25 Verdad 25 < > 25 Falso 25 < > 4 Verdad 1.7. Operadores Lógicos o Booleanos Combinan sus operandos de acuerdo con las reglas del algebra de Boole con el fin de producir un nuevo valor que se convierta en el valor de la expresión. La Tabla 3. Define los operadores lógicos Signo

Significado

OR

Suma lógica

AND

Producto lógico

NOT

Negación

-OR u O: es un operador binario, afecta a dos operadores. La expresión que forma es cierta cuando al menos uno de sus operandos es cierto. Es el operador lógico de disyunción Ejemplo: estudiamos informática o nos vamos al cine. 15

-AND o Y: es un operador binario. La expresión formada es cierta cuando ambos operandos son ciertos al mismo tiempo. Es el operador lógico de conjunción. Ejemplo: es de día y hace sol. -NOT o NO: es un operador unario. Afecta a la expresión cambiando su estado lógico: si era verdad lo transforma en falso; y al revés. Ejemplo: no es de día El orden de prioridad a la hora de ejecutarse estos operadores lógicos es: NOT, le sigue AND y por último OR. Ejemplos: Expresión

Resultado

Verdad AND Falso

Falso

NOT Falso

Verdad

Verdad OR Falso

Verdad

1.8. Pasos a seguir en el diseño de un algoritmo Para su realización, los vamos a considerar divididos en tres partes: -Inicial: en ella *inicializaremos las variables que posteriormente vamos a utilizar -Proceso: es el cuerpo del programa. Se realizan los procesos repetitivos o de comparación. Realización de operaciones aritméticas/lógicas. -Final: en ella *incluiremos la impresión de los resultados finales que resultan del proceso 1.9. Representación de Algoritmos Entre los distintos tipos de algoritmos se encuentran: -Diagramas de flujo u ordinogramas: utiliza símbolos gráficos para su resolución: Presentan los siguientes inconvenientes: *Cualquier mínima modificación en el diagrama nos obliga a reorganizarlo de nuevo *Utiliza la técnica lineal, en desuso hoy en día

16

*El proceso de recorrer el diagrama desde el principio al final puede resultar complejo y propicia la omisión de una cierta combinación poco frecuente, pero posible de condiciones bajo las cuales el algoritmo se comporta mal. -Tablas de decisión: tabulan todas las posibles situaciones que se pueden presentar en el problema y las correspondientes acciones a tomar para cada una de ellas. -Pseudocódigo: describe un algoritmo utilizando una mezcla de frases en lenguaje común, instrucciones de lenguaje de programación y palabras clave que definen las estructuras básicas. PROBLEMAS.MODULO 1. Capítulo 1. Ejercicios Propuestos

1. Declarar dos variables numéricas; una para almacenar su edad cumplida, en una variable entera y otra para guardad la distancia en kilómetros entre dos ciudades en una variable real. 2. Declarar dos variables alfanuméricas de cadena: la primera guardará el nombre de una ciudad y la segunda el nombre de la carrera que usted seguirá en la universidad. 3. Declarar dos contantes una de carácter que almacena el género “F/M” de un individuo y la otra numérica real almacenara 60.5, correspondiente a la velocidad en que se deslaza un automóvil. 4. Indicar el resultado final de las siguientes expresiones aritméticas: Si a es 6, b es 2 y c es 3. a) b) c) d) e)

a-b-c a*b/c (a*c) MOD 2 (a+b) DIV c MOD (a*b*c/(b+c)).

17

5. Suponiendo que x es 5, y es 6, y z es 8, indicar con la T o la F si cada una de las siguientes expresiones relacionales son verdaderas o falsas: A) B) C) D) E) F) G)

x == 5 ………………………. 7 = 9 ………………………. x 60) entonces Escribir ("Aprobado") Sino Escribir ("No Aprobado") Fin_si Fin Ejemplo: /*Algoritmo que muestra la palabra Aprobado si la nota es mayor a 60, No Aprobado si la nota está entre 30 y 60, y Deficiente, si la nota es menor a 30*/ Inicio Variables: Nota: entero /*Inicia ejecución del algoritmo*/ Leer Nota Si (Nota > 60) entonces Escribir ("Aprobado") Sino Si (nota = 30) entonces Escribir ("No Aprobado") Sino Escribir ("Deficiente") Fin_si Fin_si Fin

30

2.1.7.3 Alternativa Múltiple Según_sea. Con frecuencia, necesitaremos estructuras que nos permitan escoger entre más de dos caminos de acción.

Este tipo de casos se puede

resolver con las alternativas simples o dobles anidadas (unas dentro de otras) expuestas anteriormente; sin embargo, diseñar el algoritmo de esta forma nos puede acarrear serios problemas de escritura del algoritmo y legibilidad. Las estructuras de selección múltiple evalúan una expresión que puede tomar n valores distintos. Dependiendo de cuál condición sea la que se cumpla, así mismo se ejecutará la acción correspondiente; en otras palabras, el flujo del algoritmo seguirá uno de los n caminos posibles. En el pseudocódigo que a continuación se presentan, la expresión que se evalúa es , la misma se compara con , , , etc. Si es igual a alguna de nuestras opciones, se ejecuta la acción correspondiente. Si ninguna de estas acciones se cumple, se ejecuta el código que sigue a . Pseudocódigo: Según_sea hacer : acción a1 : acción a2 : acción a3 : acción sx fin_según

31

Ejemplo: /*Algoritmo que lee un número que representa el día de la semana, y como resultado presenta el nombre del día correspondiente. */

Inicio Variables: DIA: entero /*Inicia ejecución del algoritmo*/ Escribir ‘Ingrese un número del 1 al 7, que represente un día de la semana.’ Leer DIA Según_sea DIA hacer 1: Escribir ‘Lunes’ 2: Escribir ‘Martes’ 3: Escribir ‘Miércoles’ 4: Escribir ‘Jueves’ 5: Escribir ‘Viernes’ 6: Escribir ‘Sábado’ 7: Escribir ‘Domingo’ Otro: Escribir ‘Día Incorrecto’ Fin_según Fin

32

Ejemplo: /*Algoritmo que solicita dos números al usuario, y una de las cuatro operaciones aritméticas. Con éstos datos se realizará la operación aritmética escogida sobre los números ingresados por el usuario. */ Inicio Variables: N1, N2, ope: entero /*Inicia ejecución del algoritmo*/ Escribir ‘Ingrese el número que corresponda a la operación aritmética que desea realizar.’ Escribir ‘1  Suma.’ Escribir ‘2  Resta.’ Escribir ‘3  Multiplicación.’ Escribir ‘4  División.’ Leer ope Escribir ‘Ingrese el primer número.’ Leer N1 Escribir ‘Ingrese el segundo número.’ Leer N2 Según_sea ope hacer 1: Escribir ‘El resultado de la operación es ’, N1 + N2 2: Escribir ‘El resultado de la operación es ’, N1 - N2 3: Escribir ‘El resultado de la operación es ’, N1 * N2 4: Escribir ‘El resultado de la operación es ’, N1 / N2 Otro: Escribir ‘Operación Incorrecta.’ Fin_según Fin

33

2. 1.8 Enunciados de Repetición. Una de las grandes ventajas de realizar nuestros procesos apoyados por el computador es la facilidad que éste nos brinda de realizar un grupo de acciones tantas veces como sea necesario.

Es en este

momento, donde debemos trabajar con enunciados de repetición. Los enunciados de repetición (Ciclos Repetitivos) son aquéllos que nos permiten que una sentencia o grupo de sentencias se repitan muchas veces. Definimos un enunciado de repetición, y dentro de los límites de este enunciado plasmamos lo que se denomina “Cuerpo del bucle” o “Cuerpo del Ciclo Repetitivo”. El “Cuerpo del Bucle” es el grupo de sentencias o instrucciones que se repetirán tantas veces como el usuario las necesite. Cada vez que se efectúan o realizan las sentencias que forman parte del cuerpo del bucle, decimos que se ha efectuado una “iteración”; si el cuerpo del bucle es ejecutado 5 veces, se han efectuado 5 iteraciones. Antes de entrar a trabajar de lleno con los enunciados de repetición, es recomendable que el lector conozca el uso e importancia de los contadores y acumuladores, y así lograr familiarizarse con estos conceptos. Éstos nos ayudan a controlar el correcto manejo de las iteraciones. Ejemplo: Enunciado de repetición Sentencia 1 Sentencia 2

Cuerpo del Bucle

34

Sentencia 3 Sentencia 4 Fin del enunciado de repetición Recordar que una iteración se da, cada vez que se ejecuta el cuerpo del Bucle.

2.1.8.1. Contadores y Acumuladores. A continuación analizaremos los

conceptos

Contadores

y

acumuladores, los cuales están íntimamente relacionados a los enunciados de repetición. 2.1.8.1.1. Contadores. Un contador es una variable cuyo valor se incrementa (aumenta su valor) o decrementa (disminuye su valor) en una cantidad igual o constante en cada iteración. Es necesario, en todo momento de la ejecución del ciclo repetitivo, conocer la cantidad de veces que se ha efectuado el cuerpo del ciclo; en otras palabras, cuantas iteraciones se han realizado. Esta información es importante para conocer cuántas iteraciones faltan para finalizar el ciclo repetitivo. Los contadores son representados por instrucciones similares a C  C + 1, donde C es la variable contadora que se incrementa o decrementa siempre en una cantidad constante, en este caso en 1.

35

2.1.8.1.2 Acumuladores. Un acumulador es una variable que tiene como propósito almacenar cantidades variables, sobre sí misma, resultantes de sumas sucesivas. Los acumuladores realizan una función similar a la de los contadores, con la diferencia de que el incremento o decremento de cada suma es variable en lugar de constante como en el caso del contador. Podemos representar los acumuladores mediante la instrucción A  A + J, donde A es la variable acumuladora, que suma su mismo valor más el valor de J; J es una variable y no una constante como en el caso de los contadores. Más adelante analizaremos el funcionamiento de los contadores y los acumuladores. En este punto, era importante que el lector conociera ambos conceptos.

2.1.8.2. Estructura Repetitiva Mientras..hacer. La estructura repetitiva Mientras..hacer nos permite ejecutar un número específico de sentencias (cuerpo del ciclo) tantas veces como necesite el usuario. Un aspecto importante de esta estructura es que no conocemos de antemano la cantidad de veces que se va a repetir el cuerpo del ciclo repetitivo; ya que este tipo de estructura se efectúa mientras (condición) sea verdadera o cierta. En el momento en que (condición) es falso, no se efectuarán más las sentencias incluidas en el ciclo repetitivo o cuerpo del bucle, y se procede a ejecutar las sentencias posteriores, al fin del ciclo. A este tipo de bucle, se le conoce como bucle condicional.

36

La sintaxis es la siguiente: Mientras (condición) hacer Sentencia 1 Sentencia 2 Sentencia 3 fin_mientras Antes de ejecutar el ciclo repetitivo Mientras, se verifica si (condición) es verdadero o falso. De ser cierta o verdadera esta condición, se inicia la ejecución del ciclo.

En este momento, se procede a realizar

Sentencia 1, Sentencia 2 y Sentencia 3. fin_mientras indica donde termina el ciclo repetitivo; sin embargo, al ser esta una estructura repetitiva, el control del programa regresa nuevamente al ciclo repetitivo Mientras. En este momento, se verifica nuevamente si (condición) es cierta; de ser cierta se ejecutan nuevamente Sentencia 1, Sentencia 2 y Sentencia 3, y así sucesivamente, hasta que la condición resulte falsa. Si la condición resulta ser falsa, se salta el cuerpo del bucle, y se ejecutan las líneas de código posteriores a fin_mientras; ocurre lo mismo si en la primera evaluación de (condición) resulta falsa. Ejemplo: /*Algoritmo que calcula el promedio de las notas de un estudiante. El programa termina cuando la nota ingresada es -99 */ 37

Inicio Variables: Acum, Prom, Nota, Cont: enteros /*Inicia ejecución del algoritmo*/ Acum  0 Prom  0 Cont  0 Escribir ‘Programa que calcula el promedio de las notas.’ Escribir ‘El programa finaliza cuando la nota es -99.’ Escribir ‘Ingrese una Nota.’ Leer Nota Mientras (Nota -99) hacer Acum  Acum + Nota Cont  Cont + 1 Escribir ‘Ingrese una Nota.’ Leer Nota Fin_mientras Escribir ‘El promedio es ‘, Acum /Cont Fin En el ejemplo anterior, podemos apreciar que la condición del ciclo repetitivo es planteada de otra forma, ya que no se utiliza el contador en la condición. Aquí el ciclo repetitivo finaliza cuando la nota ingresada por el usuario es -99; esto se utiliza para que el usuario no tenga que especificar la cantidad de datos que va a ingresar; sobretodo, cuando este dato no se conoce antes. La variable Acum acumula las notas ingresadas por el usuario. Cont nuevamente trabaja como contador, contando la cantidad de notas ingresadas por el usuario. Después de finalizado el ciclo repetitivo se procede a mostrar la salida del algoritmo 38

con la sentencia Escribir ‘El promedio es ‘, Acum /Cont, la cual utiliza las variables acum (suma de todas las notas ingresadas), y Cont (cantidad de notas ingresadas) para mostrar el promedio de las notas ingresadas al algoritmo. Ejemplo: Elabore un algoritmo que calcule el ingreso de la gasolinera Texeso, para N cantidad de compradores de gasolina en un día normal de consumo. La gasolinera Texeso sólo vende gasolina de 95 octanos, cuyo precio es de B/. 3.15 por galón, y los clientes pueden comprar tantos galones como necesiten.

La gasolinera Texeso compra la

gasolina de 95 octanos a B/. 1.90 por galón. /*Algoritmo que calcula el ingreso de la gasolinera Texeso*/ Inicio Constantes: PrecioGalon95  3.15 CostoGalon95  1.90 Variables: N  0: entero /*Cantidad de Cliente que compraron gasolina.*/ IngresoBruto: entero /*Ingreso Bruto de la Gasolinera Texeso.*/ IngresoFinal: entero /*Ingresos, luego de deducir los costos.*/ resp  ‘s’: char Cant: entero /*Almacena la cantidad de galones que compró un cliente.*/ Cant_Tot  0: entero /*Cantidad de galones totales que compraron todos los clientes.*/ 39

/*Inicia ejecución del algoritmo*/ Mientras (resp=’s’) hacer Escribir ‘Ingrese la cantidad de galones de gasolina que compró este cliente’ Leer Cant NN+1 Cant_Tot  Cant_Tot + Cant Escribir ‘Faltan datos de otro cliente (s / n)’ Leer resp Fin_mientras IngresoBruto  Cant_Tot * PrecioGalon95 IngresoFinal  IngresoBruto – (Cant_Tot * CostoGalon95) Escribir ‘Este día fueron ’, N, ‘ Clientes a comprar gasolina’ Escribir ‘Los Ingresos Totales de la gasolinera Texeso fueron de ‘, IngresoFinal Fin Notar como trabaja la estructura repetitiva Mientras..hacer. Sólo se podrá ingresar al ciclo repetitivo si la condición (resp=’s’) es cierta. En el ejemplo 4.18, le asignamos un valor s en la inicialización de la variable para que en todos los casos entre al menos una vez, luego de esto, en cada iteración, debemos preguntar si existen más clientes que compraron gasolina, y solamente si existen más datos de cliente se repetirá el ciclo.

2.1.8.3. Estructura Para..hacer. A diferencia de la estructura mientras..hacer, que trabaja mientras una condición sea verdadera, la estructura para..hacer debe tener definida

40

la cantidad de veces que se repetirá el ciclo o bucle. Esta estructura consta de tres partes: a. La estructura Para..hacer inicia con la palabra Para, seguida por una variable, cuyos valores empiezan en valor_inicial y van incrementándose hasta llegar a valor_final.

Como cont va

incrementándose hasta valor_final, cuando cont es igual a valor_final se interrumpe el ciclo, y se continúa con las sentencias posteriores a fin_para.

Adicional a esto, se puede definir el

incremento que tendrá la variable cont después de cada iteración con las palabras “con incremento de k”. Si k vale 1, es decir, que el incremento de cont en cada iteración será de 1, podemos obviar o pasar por alto esta parte; el algoritmo asume que si esto no está definido es porque el incremento es de 1, y la línea finaliza con la palabra hacer. b. En la segunda parte de la estructura repetitiva Para..hacer, se definen las líneas de código o sentencias que se repetirán en cada iteración, en este caso, Sentencia 1, Sentencia 2, Sentencia 3 y Sentencia 4. c. Y en la última parte se indica la finalización del ciclo repetitivo con las palabras fin_para. La sintaxis es como sigue: Para cont  valor_inicial hasta valor_final con incremento de k hacer Sentencia 1 Sentencia 2 Sentencia 3 41

fin_para Cuando se ejecuta la sentencia Para..hacer por primera vez, valor_inicial se asigna a la variable cont, conocida como variable de control, y se procede a ejecutar las sentencias del interior del ciclo (Sentencia 1, Sentencia 2, etc.). Cuando se finaliza el ciclo se verifica si cont llegó hasta el límite superior, esto es, si ya cont tomó el valor de valor_final; en caso negativo se incrementa el valor de la variable cont en uno, o en k (si este fue definido), y se vuelve a ejecutar el cuerpo del bucle, hasta que la variable de control, en este caso cont, sea mayor que valor_final, en cuyo momento se termina el ciclo o bucle. Ejemplo: /* Algoritmo que muestra los números del 1 a 15 */ Para a  1 hasta 15 hacer Escribir a fin_para En pantalla, este sería el resultado: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Reglas:  Las variables de control, valor_inicial y valor_final deben ser del mismo tipo de dato. Valor_inicial y valor_final pueden ser expresiones o constantes.  No se debe modificar el valor de las variables de control, valor_inicial y valor_final dentro del ciclo repetitivo.

42

En el ejemplo anterior, podemos observar cómo trabaja la estructura Para..hacer, de una forma bastante clara y sencilla. Primero se define la estructura Para, definiendo a su vez, el contador o variable de control (en este caso es a), se le asignan los límites, o sea, valor_inicial y valor_final, que varían de 1 a 15 incrementándose de 1 en 1 (aspecto que no se define en el algoritmo, ya que cuando el incremento es de 1 puede obviarse esta parte del algoritmo). Luego de esto, vemos que el algoritmo envía como salida la variable a, que a su vez, es la variable de control o contador.

El algoritmo inicia cuando a es 1, en ese

momento envía a la pantalla su valor (1); luego, la variable a se incrementa en 1 (a valía 1, y al sumarle o incrementarle 1 queda en 2) y se envía el valor 2 a la pantalla, y así sucesivamente, hasta que a es 15. Cuando el algoritmo detecta que la variable a está por sobrepasar su límite máximo, termina el ciclo repetitivo y el programa sigue con el resto del algoritmo (fuera del ciclo repetitivo).

43

Ejemplo: /*Algoritmo que presenta la suma de un grupo de números enteros ingresados por el usuario. */ Inicio /*Algoritmo que ilustra el uso de la estructura repetitiva Para..hacer*/ Variables: num, suma, a, N: enteros /*Inicia ejecución del algoritmo*/ Escribir ’Este programa muestra la suma de números enteros’ Escribir ‘Cuantos números desea ingresar’ Leer N Escribir ‘Ingrese los números:’ suma  0 Para a  1 hasta N hacer Leer num suma  suma + num fin_para Escribir ‘La suma de los’, N,’números es’,suma Fin En el ejemplo anterior, solicitamos al usuario que ingrese la cantidad de números que desea sumar, y este dato se almacena en la variable N. Luego, utilizando la estructura repetitiva Para..hacer, solicitamos al usuario que ingrese los N números enteros. Notar que, en este caso, el contador está inmerso en la estructura Para.hacer, a través de la variable a y, no está separado como en la estructura Mientras..hacer. Por otro lado, igual que en la estructura Mientras..hacer, tenemos una variable acumuladora suma, que va sumando o acumulando los 44

números enteros que va ingresando el usuario. Al final muestra como salida, la suma de todos los números enteros ingresados, los cuales fueron acumulados en la variable acumuladora suma. Es importante que el lector preste atención en que la variable acumuladora suma, antes de acumular el valor de num, en la sentencia suma  suma + num, toma el valor 0 en la sentencia suma  0; esto se realiza con el propósito de evitar errores, ya que sumar un número (en la variable num) y una variable nula (como sería el caso de suma si no se le hubiese asignado el valor de 0) presenta un error que no se puede manipular en el algoritmo, y menos aún, cuando este algoritmo se lleve a código de programación. Ejemplo: /*Algoritmo que calcula el promedio de N números introducidos por el usuario*/ Inicio Variables: num, suma, k, N: enteros /*Inicia ejecución del algoritmo*/ Escribir ’Este programa muestra el promedio de N números’ Escribir ‘Cuantos números desea ingresar’ Leer N Escribir ‘Ingrese los números:’ suma  0 Para k  1 hasta N hacer Leer num suma  suma + num

45

fin_para prom  suma / N Escribir ‘El promedio de los ’, N,’números es’,prom Fin

Ejemplo: /*Algoritmo que determina el mayor de un grupo de números ingresados por el usuario.*/ Inicio Variables: N: entero

/*Cantidad de números que se van a ingresar.*/

Mayor  0: entero /*Número mayor ingresado por el usuario.*/ a, numero:

entero

/*Inicia ejecución del algoritmo*/ Escribir ‘¿Cuántos números desea ingresar? ’ Leer N Para a  1 hasta N hacer Escribir ‘Ingrese un número ‘ Leer numero Si (numero > Mayor) entonces Mayor  numero Fin_si fin_para Escribir ‘El mayor de los números ingresados por el usuario es ’, Mayor Fin

46

2.2. Estructura de Datos (Arreglos). Hasta el momento hemos trabajado con variables simples, las cuales nos permiten manipular un solo dato a la vez; ejemplo de esto es: la nota de un estudiante, el precio de un producto, o el salario bruto de un empleado. Sin embargo, en algunas ocasiones no es sólo deseable, sino indispensable, utilizar estructuras que soporten una cantidad amplia de datos de un mismo tipo; ejemplo de estos datos sería: la nota final del grupo de Programación I, donde posiblemente tengamos 30 ó 40 estudiantes, el salario bruto de los empleados de la empresa x, que probablemente son más de 50. Es por estas razones, que existe la estructura de datos conocida como Arreglos.

Podemos definir un

arreglo como un conjunto de datos homogéneos que por sus cualidades o características se comportan de forma idéntica o deben ser tratados en forma similar. Los arreglos al igual que las variables y las constantes deben tener un nombre que identifique al conjunto total de datos, y deben estar asociados a uno de los tipos de datos definidos para tal propósito. Cada dato que forma parte de un arreglo se le denomina elemento. En el presente documento, trabajaremos con los tipos de arreglos unidimensionales y bidimensionales.

2.2.1. Arreglos Unidimensionales. Los arreglos unidimensionales son un conjunto de datos del mismo tipo de datos organizados en forma de lista; éstos tienen una sola dimensión. Los valores que presentamos a continuación forman parte de un arreglo unidimensional de datos:

47

115, 200, 34, 598, 189, 70, 600, 54 Los elementos de este arreglo pueden representar las cantidades que un supermercado debe comprar semanalmente de cierto grupo de productos para abastecer su despensa. Si a este grupo de datos o elementos le asignáramos un nombre, por ejemplo Cantidades (representa el nombre del arreglo), se puede hacer referencia a cada elemento del arreglo adicionando al nombre Cantidades un subíndice que indique la posición del elemento en la lista. Así, Cantidades [2] hace referencia al valor 200, Cantidades [5] tiene el valor 189 y Cantidades [8] tiene el valor 54. De esta forma, se puede hacer referencia a cada elemento del arreglo, utilizando el nombre de éste y el índice que indica la posición del mismo en la lista. Es importante recordar que cuando trabajamos con arreglos, los elementos que lo conforman deben ser del mismo tipo de datos; en el caso del arreglo Cantidades todos sus elementos eran enteros. Se tiene la siguiente lista de notas para un grupo de primer año, en la materia Informática Básica.

98

76

80

90

100

56

88

49

Este grupo de notas pueden ser los miembros de un arreglo unidimensional y asignarle el nombre Notas.

La referencia a los

elementos del arreglo Notas sería de la siguiente forma: Notas [1] = 98 Notas [2] = 76 48

Notas [3] = 80 Notas [4] = 90 Notas [5] = 100 Notas [6] =56 Notas [7] = 88 Notas [8] = 49

2.2.1.1. Lectura y escritura de Arreglos Unidimensionales. Para escribir datos en un arreglo o para leer los datos que éste contiene, se suele utilizar la estructura repetitiva Para..hacer, ya que la sintaxis de esta estructura es más adecuada en la manipulación de los elementos del arreglo. Para ilustrar como leer y escribir en un arreglo unidimensional, presentaremos los siguientes ejemplos: Ejemplo: /*Algoritmo que lee 20 enteros, asignándolos a un arreglos unidimensional Notas de 20 elementos, y luego los escribe. */ Inicio Variables: a, b, Notas[20]: enteros /*Inicia ejecución del algoritmo*/ Para a  1 Hasta 20 hacer Leer Notas [a] Fin_Para

49

Para b  1 Hasta 20 hacer Escribir Notas [b] Fin_Para Fin En el ejemplo, al igual que en ejemplos anteriores, debemos definir inicialmente las variables con las que va a trabajar el algoritmo. Se definen las variables a y b como enteros, al igual que el arreglo Notas [20]. El arreglo se define como cualquier otra variable, asociándolo a un tipo de datos de los definidos anteriormente, con la diferencia de que justo al lado del nombre Notas se escribe un número entre paréntesis, el cual indica la cantidad de elementos que va a manipular dicho arreglo; es esto, lo que realmente hace la diferencia entre una variable ordinaria y un arreglo al momento de su definición. Posterior a la definición de las variables se inicia el programa, se define una estructura Para..hacer, que va de 1 hasta 20, y se leen los 20 datos del arreglo Notas (notar que la variable a varía de 1 a 20, y esa misma variable es la que se usa como índice del arreglo). El primer dato que es leído se asigna al arreglo Notas en su posición 1 (posición definida por la variable a), misma que va cambiando o variando a medida que se va ejecutando la estructura repetitiva Para..hacer, y así sucesivamente, hasta que llegamos a Notas [20]. En el momento en que se efectúa cada Leer, automáticamente se van llenando los 20 elementos del arreglo.

La segunda estructura

Para..hacer, trabaja de forma similar enviando el contenido del arreglo Notas como salida del algoritmo. Ejemplo:

50

/*Algoritmo que lee 10 datos enteros y los asigna a un arreglo unidimensional; luego suma los 10 elementos del arreglo y, por último, imprime los elementos del arreglo en pantalla y la suma de esos 10 elementos.*/ Inicio Variables: Suma, a, b, c: entero/*Variable donde se almacena la suma del arreglo (acumulador).*/ Numeros[10]: entero

/*Arreglo unidimensional donde se

almacenan los elementos que se van a sumar.*/ /*Inicia ejecución del algoritmo*/ Suma  0

/*Se inicializa en 0 para evitar un error en una

operación posterior.*/ Para a  1 hasta 10 hacer /*Se ingresan los 10 números al arreglo.*/ Leer Numeros[a] Fin_Para Para b  1 hasta 10 hacer /*Se acumulan en la variable Suma los valores de los 10 números.*/ Suma  Suma + Numeros[b] Fin_Para Para c  1 hasta 10 hacer /*Se escribe en la pantalla los 10 números del arreglo.*/ Escribir Numeros[c] Fin_Para Escribir “La suma resultante es: “, Suma

/*Se escribe en pantalla

el resultado de la suma.*/ Fin

51

2.2.2. Arreglos Bidimensionales. Un Arreglo Bidimensional es un conjunto de datos, de un mismo tipo de datos, organizados en filas y columnas (también llamados Matriz). La diferencia entre los arreglos unidimensionales y los bidimensionales radica en que los primeros son tan sólo una lista de datos (una sola dimensión o fila), y los arreglos bidimensionales manipulan dos dimensiones; es decir, varias filas y da la posibilidad de manipular varias columnas. Los valores que se presentan a continuación son las 3 notas parciales (3 columnas) de un grupo de estudiantes de primer año (4 filas), en la materia Informática Básica.

A la vez, estos datos pueden ser

considerados como los elementos de un arreglo bidimensional (nos referimos a las notas de los estudiantes, no a los apellidos de éstos, ya que los datos de un arreglo deben ser del mismo tipo de datos, en este caso, enteros): Parcial 1

Parcial 2

Parcial 3 90

Burgos

89

100

Durán

79

56

70

Méndez

67

80

45

Quintero

89

60

97

Cada elemento representa la nota de un estudiante. Si a este grupo de datos organizados en cuatro filas y tres columnas le asignáramos un nombre, por ejemplo Notas_Parciales, podemos hacer referencia a cualquier elemento del arreglo bidimensional agregando al nombre Notas_Parciales dos números separados por una coma y encerrados 52

entre paréntesis (índices). El primer número del paréntesis indica la fila a la cual se hace referencia, y el segundo indica la columna a la que queremos hacer referencia, de la siguiente forma:  Notas_Parciales [1, 2] se refiere a la nota 100, que está en la fila 1, columna 2.  Notas_Parciales [3, 3] se refiere a la nota 45, el cual está en la fila 3, columna 3. De forma similar, podemos hacer referencia a cada elemento que compone el arreglo. Ejemplo: Utilizando el mismo arreglo bidimensional visto anteriormente. Parcial 1

Parcial 2

Parcial 3

Burgos

89

100

90

Durán

79

56

70

Méndez

67

80

45

Quintero

89

60

97

Ya sabemos que el arreglo se llama Notas_Parciales. Para hacer referencia a sus elementos procedemos de la siguiente forma: Notas_Parciales[1,1] = 89 Notas_Parciales[1,3] = 90 Notas_Parciales[2,1] = 79 Notas_Parciales[2,2] = 56 Notas_Parciales[3,2] = 80 53

Notas_Parciales[3,3] = 45 Notas_Parciales[4,2] = 60 Los índices pueden ser representados utilizando constantes y variables o una combinación de éstas, de la siguiente forma: V

Solamente una variable.

C

Solamente una constante.

V+ó–C

Expresión aritmética.

C* ó+V

Expresión aritmética.

C*V+ó–C

Expresión aritmética.

Ejemplo: A[ i ]

Recurso [L, N - 5]

Notas[10]

Depositos[ Z + 2, 3]

Periodo [C + 2]

F[4,1]

Libros [A, B]

Facturas [5 * 2, 4 * M - 1]

Cuentas [A * 5, B + 2]

Z [10 * A + 3]

Esta sintaxis aplica tanto para arreglos unidimensionales, como para arreglos bidimensionales. Aspecto muy importante al definir el índice en un arreglo unidimensional, o los índices en los arreglos bidimensionales, es que éstos no pueden contener otro índice. Libros [X [3]] no es permitido. Los índices siempre deben ser valores positivos.

54

2.2.2.1. Lectura y Escritura de Arreglos Bidimensionales. Ya que los arreglos bidimensionales tienen dos índices, uno que indica la fila y otro que indica la columna, los mismos deben ser manipulados utilizando dos estructuras Para..hacer, una dentro de la otra. En el presente texto, trabajaremos los arreglos leyendo por filas. Esto es, el Para..hacer más externo controlará la fila en la que nos ubicaremos, y el Para..hacer interno controlará las columnas. Sí, al definir las dos estructuras Para..hacer, se establece que la más interna es la que controla las filas, entonces se está leyendo el arreglo por columnas. Sin embargo, preferimos trabajar con arreglos leyendo por filas. Ejemplo: /*Extracto de un algoritmo que lee un arreglo bidimensional de 12 filas y 5 columnas. */ Para a  1 hasta 12 hacer Para b  1 hasta 5 hacer Leer Precios [a, b] Fin_Para Fin_Para En el ejemplo, los datos del arreglo son leídos por filas. Esto sucede, porque el índice que corresponde a las columnas varía más rápido por estar controlado con el Para..Hacer interno. Primero, se ejecuta el Para..hacer externo (Para a  1 hasta 12 hacer). La variable a toma el valor 1 y se procede con la siguiente instrucción, que coincide con el Para..hacer interno (Para b  1 hasta 5 hacer). En este punto, b toma

55

el valor 1, y cuando se ejecuta la sentencia Leer Precios [a, b] a vale 1 y b vale 1, ingresando de esta forma el primer elemento del arreglo en la fila 1, columna 1. Cuando nos encontramos con el Fin_para del Para..hacer interno, y como el mismo no ha concluido, nuevamente se ejecuta el Para..hacer interno, ahora b toma el valor 2, y se ingresa el segundo dato de nuestro arreglo bidimensional en la fila 1, columna 2; así sucesivamente, hasta que se leen los 5 elementos que corresponden a la fila 1.

Posterior a la lectura de los datos del

Para..hacer interno, el cual fue interrumpido porque llego hasta su tope que era 5, se procede a leer nuevamente el Para..hacer externo, con lo cual a toma el valor 2, y se procede a leer los datos de la fila 2. Al ejecutar la siguiente instrucción que es el Para..hacer interno por segunda vez, los valores de b empiezan nuevamente en 1; en este caso, se ingresan los datos de la fila 2, columna 1, luego fila 2, columna 2; y así sucesivamente, hasta llegar a la columna 5, con lo cual se han ingresado todos los datos de la fila 2. Este proceso se repite hasta llegar al tope del Para..hacer externo que es 12, con lo cual hemos ingresado todos los datos del arreglo bidimensional. Ejemplo: /*Algoritmo que solicita al usuario para 4 estudiantes de la asignatura Base de Datos sus 3 notas parciales (4 filas, 3 columnas  arreglo de 4 X 3), almacena estos datos en un arreglo bidimensional de 4 filas y 3 columnas, y luego crea un arreglo unidimensional de 4 elementos con el promedio de cada estudiante.*/ Inicio Variables:

56

Parciales [4,3]: entero /*Arreglo bidimensional que almacena las 3 notas parciales de 4 estudiantes.*/ Prom[4]: entero /*Arreglo

unidimensional

que

resulta

del

promedio de las tres columnas de cada fila.*/ a, b, c: entero

/*Inicia ejecución del algoritmo*/ Para a  1 hasta 4 hacer Para b  1 hasta 3 hacer Leer Parciales [a, b] Fin_Para Fin_Para Para c  1 hasta 4 hacer

/*Se obtiene el promedio de las 3

notas para cada estudiante del arreglo Parciales, y se asignan al arreglo Prom.*/ Prom[c]  (Parciales [c, 1] + Parciales [c, 2] + Parciales [c, 3]) / 3 Fin_Para Fin

57

A continuación, podemos observar un ejemplo de cómo se comportarían los arreglos en realidad: Se ingresan las 3 notas Se saca el promedio de las de los 4 estudiantes

notas y se asignan al arreglo Prom

Parciales

Prom

89

100 90

93

79

56

70

68

67

80

45

64

89

60

97

82

58

PROBLEMAS .MODULO 2. CAPITULO 2 Problemas resueltos Ejemplo 1:

/*Algoritmo que solicita al usuario su nombre y año de nacimiento y año actual, luego los almacena en sus respectivas variables. Calcula la edad y presenta como salida el valor de la variable nombre, y el valor de la variable edad */ Variables: edad: entero a_nacim: entero a_actual: entero nombre: alfanumerico Inicio Leer nombre Leer a_nacim Leer a_actual Edad a_actual - a_nacim Escribir nombre Escribir edad Fin Ejemplo 2: /*Algoritmo que calcula el importe a pagar por un vacacionista en una habitación de hotel y ofrece un descuento del 15% (uno o dos días) o 30% (más de dos días) sobre el importe a pagar. Imprime importe total a pagar luego del descuento*/ Variables: Tarifa: entero Cant_dias: real Subtotal: real Total: real Descuento: real

59

Inicio Leer Tarifa Leer Cant_dias Subtotal  Tarifa* Cant_dias Si (Cant_dias > 2) entonces Descuento Subtotal*0.30 Sino Descuento Subtotal*0.15 Fin_si Total Subtotal- Descuento Escribir Total Fin

Ejemplo 3: /*Algoritmo que solicita al usuario que ingrese un número dentro del rango de 1 a 10. Use una instrucción Según_sea para mostrar la versión en romanos de ese número. Validación de entrada: No acepte un número menor que 1 o mayor que 10 */ Variables numero Inicio Escribir “Ingrese un número dentro del rango de 1 a 10.” Leer numero Según_sea numero hacer 1: Escribir “la versión en romanos de ese número es I“ 2: Escribir “la versión en romanos de ese número es II“ 3: Escribir “la versión en romanos de ese número es III“ 4: Escribir “la versión en romanos de ese número es IV“ 5: Escribir “la versión en romanos de ese número es V“ 6: Escribir “la versión en romanos de ese número es VI“ 7: Escribir “la versión en romanos de ese número es VII“ 8: Escribir “la versión en romanos de ese número es VIII“ 9: Escribir “la versión en romanos de ese número es IX“

60

10: Escribir “la versión en romanos de ese número es X“ Otro: Escribir “Numero fuera de rango” Fin_según Fin Ejemplo 4: /*Algoritmo que nos asiste en el encendido del aire acondicionado de una habitación cuando la temperatura del lugar es suprior a una temperatura máxima */ Constante: Tem_Max 25 Variables temperatura: enteros Inicio Escribir” Ingrese la temperatura actual de la habitación” Leer temperatura Mientras (temperatura> Tem_Max ) hacer Escribir” La temperatura es muy alta” Escribir” Encienda el aire acondicionado por 20min” Escribir” pasado los 20 minutos ingrese nuevamente la temperatura” Leer temperatura Fin_mientras Escribir” La temperatura es agradable” Fin

61

Ejemplo 5: /*Algoritmo que lee 30 datos correspondiente a las edades de los alumnos en valores enteros y los asigna a un arreglo unidimensional; luego imprime los elementos del arreglo en pantalla finalmente busca e imprime en pantalla la edad más pequeña en el grupo. Si asume que todas las edades son diferentes y no iguales*/ Variables: Menor: entero

/*Variable donde se almacena la menor encontrada. */

Edades(30): entero /*Arreglo unidimensional donde se almacenan las edades.*/ Inicio Para a 1 hasta 30 hacer /*Se ingresan las 30 edades al arreglo. */ Leer edades(a) Fin_Para Para c 1 hasta 30 hacer /*Se escribe en la pantalla las 30 edades del arreglo. */ Escribir edades(c) Fin_Para Menoredades (1) /*Se asume que la menor edad es la primera. */ Para i  2 hasta 30 hacer /*Se compara y ubica la menor edad en el arreglo edades.*/ Si ( Menor>edaddes(i)) entonces Menoredades(i) Fin_sii Fin_Para Escribir “La menor edada es: “, Menor arreglo.*/

/*Se escribe en pantalla la menor edad en el

Fin

62

Problemas Propuestos 1. Desarrolle un algoritmo que solicita al usuario el nombre de un empleado, cantidad de horas trabajadas al mes y pago por cada hora laborada. luego los almacena en sus respectivas variables. Calcula el sueldo bruto y presentar como salida el valor de la variable nombre del empleado, y el valor de la variable sueldo bruto. 2. Al algoritmo anterior realice un cargo de impuesto del 10% si el ingreso en concepto de sueldo bruto es inferior al 100 balboa y 25% si es superior. 3. Desarrolle un algoritmo que solicita al usuario ingresar un carácter determinar si es una vocal y que vocal es o si es una consonante. 4. Desarrolle un algoritmo que ingresa en un arreglo unidimensional 20 valores enteros. Recorrer el arreglo y determinar la cantidad de valores pares ingresados en el arreglo e imprimir por pantalla la cantidad de estos palores pares. 5. Desarrolle un algoritmo que ingresa en un arreglo dimensional 5 x 5 valores enteros. Imprimir el arreglo bidimensional por pantalla. Intercambiar las diagonales principal y secundaria. Nuevamente imprimir el arreglo después del intercambio.

CAPITULO 3. DESARROLLO DE ALGORITMOS CON EL USO DE DIAGRAMAS DE FLUJO. 3.1. Diagrama de Flujo / FlowChart. El diagrama de flujo (DF), Flowchart o también diagrama de actividades es una manera de representar gráficamente un algoritmo o un proceso, a través de una serie de pasos estructurados y vinculados que permiten su revisión como un todo. La representación gráfica de estos procesos emplea, en los diagramas de flujo, una serie determinada de figuras geométricas que representan cada paso puntual del proceso que está siendo evaluado. Estas formas definidas de antemano se conectan entre sí a través de flechas y líneas que marcan la dirección del flujo y establecen el recorrido del proceso, como si de un mapa se tratara.

63

Hay cuatro tipos de diagrama de flujo en base al modo de su representación:  Horizontal. Va de derecha a izquierda, según el orden de la lectura.  Vertical. Va de arriba hacia abajo, como una lista ordenada.  Panorámico. Permiten ver el proceso entero en una sola hoja, usando el modelo vertical y el horizontal.  Arquitectónico. Representa un itinerario de trabajo o un área de trabajo. Los diagramas de flujo son un mecanismo de control y descripción de procesos, que permiten una mayor organización, evaluación o replanteamiento de secuencias de actividades y procesos de distinta índole, dado que son versátiles y sencillos. Son empleados a menudo en disciplinas como la programación, la informática, la economía, las finanzas, los procesos industriales e incluso la psicología cognitiva.

3.2. Simbología utilizada en el diseño de Representación de Diagramas de Flujo  Gráfico: Es la representación gráfica de las operaciones que realiza un algoritmo (diagrama de flujo).

 No Gráfico: Representa en forma descriptiva las operaciones que debe realizar un algoritmo (pseudocódigo).

64

INICIO Edad: ESCRIBA “cuál es Lea SI Edad >=18 ESCRIBA “Eres mayor FINSI ESCRIBA “fin del algoritmo”

tu de

Entero edad?” Edad entonces Edad”

FIN Nombre Símbolo Inicio / Final

Entrada / salida Proceso

Decisión

Conecto r Misma Página Indicado r de direcció n o línea de flujo Salida

Función Representa el inicio y fin de un programa. También puede representar una parada o interrupción programada que sea necesaria realizar en un programa. Cualquier tipo de introducción de datos en la memoria desde los periféricos o registro de información procesada en un periférico. Cualquier tipo de operación que pueda originar cambio de valor, formato o posición de la información almacenada en memoria, operaciones aritméticas, de transformaciones, etc. Indica operaciones lógicas o de comparación entre datos (normalmente dos) y en función del resultado de la misma determina (normalmente si y no) cual de los distintos caminos alternativos del programa se debe seguir Sirve para enlazar dos partes cualesquiera de un diagrama a través de un conector en la salida y otro conector en la entrada. Se refiere a la conexión en la misma página del diagrama Indica el sentido de la ejecución de las operaciones

Se utiliza en ocasiones en lugar del símbolo de salida. El dibujo representa un pedazo de hoja. Es usado para mostrar datos o resultados. 65

no

Decisión (indica operaciones lógicas o de comparación entre datos –normalmente dos- y en función del resultado de la misma determina cuál de los distintos caminos alternativos de programa se debe seguir; normalmente

si

si tiene dos salidas – respuestas SI o NO-, pero puede tener tres o más, según los casos). Decisión múltiple (en función del resultado de la comparación se seguirá uno de los diferentes caminos de acuerdo con dicho resultado).

66

3.2.1 Reglas para la creación de Diagramas de flujo 1. Los Diagramas de flujo deben escribirse de arriba hacia abajo, y/o de izquierda a derecha. 2. Los símbolos se unen con líneas, las cuales tienen en la punta una flecha que indica la dirección que fluye la información procesos, se deben de utilizar solamente líneas de flujo horizontal o verticales (nunca diagonales). 3. Se debe evitar el cruce de líneas, para lo cual se quisiera separar el flujo del diagrama a un sitio distinto, se pudiera realizar utilizando los conectores. Se debe tener en cuenta que solo se van a utilizar conectores cuando sea estrictamente necesario. 4. No deben quedar líneas de flujo sin conectar 5. Todo texto escrito dentro de un símbolo debe ser legible, preciso, evitando el uso de muchas palabras. 6. Todos los símbolos pueden tener más de una línea de entrada, a excepción del símbolo final. 7. Solo los símbolos de decisión pueden y deben tener más de una línea de flujo de salida. 3.3 Sentencias Secuencial La estructura secuencial es aquella en la que una acción sigue a otra en secuencia. Las operaciones se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso. La asignación de esto consiste, en el paso de valores o resultados a una zona de la memoria Ejemplo 1. Diseñe un diagrama de flujo que lea 4 números que imprima el producto, la suma y la media.

67

Ejemplo 2. Diseñe un diagrama de flujo que lea dos edades de dos estudiantes e imprima el promedio sus edades. Solución: Inicio

Eprom o Esum o Imprimir introduzca la edad1 Leer( Edad1) Imprimir introduzca la edad2 Leer( Edad2)

Esum Edad1+Edad2 Eprom Esum/2

Imprimir La edad Promedio es: Eprom)

FIN

68

Ejemplo 3 Se trata de calcular el salario neto de un trabajador en función del número de horas trabajadas, precio de la hora de trabajo y, considerando unos descuentos fijos, el sueldo bruto en concepto de impuestos (20 por 100). Solución:

3.4 Sentencias Selectivas Las estructuras de control Selectivas permiten "seleccionar" una ruta alterna a la solución del problema, según el resultado de evaluar una expresión relacional y/o lógica. Si se considera un ejemplo de la vida diaria, podría ser semejante a las decisiones que se toman para realizar acciones específicas: Si llueve (expresión lógica), llevar paraguas;

69

Si tengo suficiente dinero (condición relacional), comprar recuerdos; sino No comprar. Estas decisiones que se toman diariamente están reflejadas en programación como estructuras selectivas 3.4.1 Selectivas Simples Funciona de la siguiente manera: se evalúa una condición, de ser cierta efectúa una acción, de lo contrario, continúa con la ejecución normal del programa. Condición: Es una expresión lógica que es evaluada por el compilador. En la Figura de abajo se muestra su notación.

Ejemplo1. Diseñe un diagrama de flujo que lea la edad de un estudiante e imprima si el ESTUDIANTE MAYOR DE EDAD. 70

Inicio

ENTERO : Edad

Imprimir introduzca la edad DEL Estudiante Leer( Edad)

Edad >18 SI

Imprimir EL ESTUDIANTE ES MAYOR DE EDAD

NO

FIN

3.4.2 Selectivas Doble Esta estructura, se caracteriza por el hecho que ofrece dos caminos a seguir, dependiendo si al evaluar la condición resulta cierta o falsa. Su Sintaxis o notación en seria como se muestra en figura siguientes

71

Funciona, de la siguiente manera si condición, al evaluarla resulta cierta, realiza la Intruccion1. de lo contrario, es decir; si al evaluar la condición resulta falsa, realiza la Instrucción A . Se debe tener en cuenta la condición puede ser compuesta, es decir haciendo uso de los operadores && y || ( Y lógico y No lógico), además que cuando tenemos más de una sentencia por ejecutar ya sea del lado del cierto o del falso, estas van dentro de llaves. Esta representación de una sentencias compuesta es como se muestra en la siguiente figura

((A >3)y (B< 3))O((C>4) Y(D 18

Imprimir EL ESTUDIANTE ES MAYOR DE EDAD Imprimir PUEDE REALIZAR EL TRAMITE DE CEDULA

NO

Imprimir EL ESTUDIANTE ES MENOR DE EDAD

FIN

3.4.3 Selectivas Anidadas Las estructuras selectivas simples y dobles implican la selección de una de dos alternativas. Es posible utilizar la instrucción si para diseñar estructuras de selección que contengan más de dos alternativas

73

Ejemplo 1. Diseñe un algoritmo que lea tres números enteros e imprima el mayor de ellos.

74

Ejemplo 2 Se desea obtener la nómina semanal —salario neto— de los empleados de una empresa cuyo trabajo se paga por horas y del modo siguiente: • las horas inferiores o iguales a 35 horas (normales) se pagan a una tarifa determinada que se debe introducir por teclado al igual que el número de horas y el nombre del trabajador, • las horas superiores a 35 se pagarán como extras a un promedio de 1,5 horas normales, • los impuestos a deducir a los trabajadores varían en función de su sueldo mensual: — sueldo