Trabajofinalpropedeutico-completo V2.pdf

UNIVERSIDAD DE PANAMÁ FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN CURSO PROPEDÉUTICO

ASIGNATURA: LÓGICA DE PROGRAMACIÓN

MÓDULOS TEMA 1. CONCEPTOS BÁSICOS TEMA 2. ALGORITMO TEMA 3. DIAGRAMA DE FLUJO

NOMBRE DEL ESTUDIANTE _________________________________________

1

PREPARADO POR LOS PROFESORES

ISIS DE LOS RÍOS CALET JIMÉNEZ ÁNGEL ÁVILA CINDY ESQUIVEL LILY 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 ............................................................................................... 8 Capítulo 1: CONCEPTOS BÁSICOS PARA EL DESARROLLO DE ALGORITMOS ............................................................................................................ 9 1.1. Algoritmo............................................................................................................. 9 1.2. Datos y Tipos de Datos .................................................................................... 9 1.2.1. Datos Numéricos .................................................................................................. 10 1.2.2. Datos Booleanos .................................................................................................. 10 1.2.3 Datos Alfanuméricos ............................................................................................. 10

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

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

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

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

6

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

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

2.2. Estructura de Datos (Arreglos). ..................................................................... 46 2.2.1. Arreglos Unidimensionales. ...................................................................................................... 46 2.2.2. Arreglos Bidimensionales. ........................................................................................................ 51

PROBLEMAS .MODULO 2. CAPITULO 2 ......................................................................... 58 Problemas resueltos ........................................................................................................... 58 Problemas Propuestos ........................................................................................................ 62

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 .................................................................................... 79 3.5.1 Repetitiva Mientras ..................................................................................................................... 80 3.5.2 Repetitiva hacer mientras .......................................................................................................... 82 3.5.3 Repetitiva Repetir hasta ............................................................................................................. 84 3.5.4 Repetitiva Repetir Desde/Para ................................................................................................. 85

VENTAJAS DE USAR FLUJOGRAMAS ........................................................................ 88 DESVENTAJAS DE LOS FLUJOGRAMAS ................................................................... 88

Problemas Propuestos ........................................................................................... 89 BIBLIOGRAFIA......................................................................................................... 92

7

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.

8

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: son números, letras o símbolos que describen objetos, condiciones o situaciones. El computador los procesa para generar información. Según sea la información que guardemos en los datos, los clasificaremos en los siguientes tipos: Numéricos, Booleanos, Alfanuméricos.

9

1.2.1. Datos Numéricos Son números 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. - Caracteres 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: alfa-2, 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

10

esa 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” 11

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”

12

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

13

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

O

AND

Y

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. 14

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

15

*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)).

16

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 <= (x + 2) ………………. z < 4 ………………………… (2 + x) != y ………………. z != 4 ………………………. x >= 9 ………………………. x <= (y * 2) ……………..

Problemas resueltos: 1. El siguiente ejemplo declara dos variables numéricas; una para almacenar el número de ruedas de un vehículo, en una variable entera y otra para guardad el precio de un producto en una variable real. Numéricas: Entera: N_ruedas= 12 Real: Precio_Prod = 23.45 2. El siguiente ejemplo declara dos variables alfanuméricas; una para almacenar el C , que corresponde al valor de una respuesta en una variable de carácter y otra para guardad el nombre de su mascota en una variable de cadena. Alfanumerica: Caracter: Respuesta = ‘C’ Cadena: Nom_mascota =” Sultan”

17

3. El siguiente ejemplo declara unas constantes alfanuméricas de cadena que corresponde al nombre de un continente. Constante: Alfanumerica: Continente=”Europa” 4. El resultado final de las siguientes expresiones aritméticas: Si a es 3, b es 1 y c es 4. a) a+ b-c =

0

b) (a*b +1) /2

=2

c) (a*c+3) MOD 2 d) (a-b) DIV 2

=1

=0

5. Suponiendo que x es 1, y es 2, y z es 3, indicar con la T o la F si cada una de las siguientes expresiones relacionales son verdaderas o falsas: A) ( x == 3)And (z==3) …….…..F B) 5 <= (x * 2) …………………..F C) z < 7 …………………………T D) (1 + x) != y …………………..T

18

CAPÍTULO 2. DESARROLLO DE ALGORITMOS CON EL USO DE PSEUDOCÓDIGO. 2.1. Enunciados para el Desarrollo de Algoritmos. Cuando utilizamos la técnica conocida como “Pseudocódigo” para desarrollar

nuestros

algoritmos,

planteamos

enunciados

muy

parecidos a nuestro lenguaje de comunicación. Es aquí donde radica la gran ventaja de realizar nuestros algoritmos haciendo uso del Pseudocódigo, ya que pasar del algoritmo al código de programación en cualquier lenguaje de programación es bastante sencillo. La verdadera importancia de los pseudocódigos estriba en la facilidad de describir y representar claramente en un lenguaje no formal las instrucciones del algoritmo, el cual posteriormente, dependiendo del lenguaje que vamos a utilizar, servirá como base para el código o programa fuente. 2.1.1. Enunciado de Asignación. Un enunciado de asignación es una acción o proceso por el cual se le asigna un valor (constante o variable) o el resultado de una operación (expresión) a una variable. El enunciado de asignación es la herramienta que utilizaremos para modificar el contenido de una variable, o para definir inicialmente una constante o una variable. Para esto, utilizaremos una flecha (

).

Definir una variable o constante consiste en asignarle un valor por primera vez, esto es, un valor inicial.

Esto puede ser realizado

mediante una lectura de datos o empleando un enunciado de asignación. Abajo presentamos ejemplos de asignación de valores a variables utilizando enunciados de asignación:

19

Forma de Asignación Variable

Ejemplo

Variable

Precio

Monto

Variable

Expresión

Precio

(Monto * 0.05) + 2

Variable

Constante

Precio

4.3

Debe notarse que la “parte izquierda” de un enunciado de asignación siempre es una variable; salvo el caso en el cual queremos dar un valor inicial a una constante. La flecha que observamos en los ejemplos indica que se está efectuando una asignación de valor, y la dirección en la cual se efectúa esta asignación. Lo que presentamos del lado izquierdo de la asignación tomará el valor de la variable, constante o expresión que está ubicada del lado derecho de este enunciado.

En el primer

ejemplo, podemos apreciar que el valor que tiene la variable Monto, se le asigna a la variable Precio; si Monto vale 6 en ese momento, entonces Precio tomará el valor de 6. Si vamos al segundo ejemplo, notaremos que Precio tomará el valor de 2.3, asumiendo que Monto vale 6 igual que en el ejemplo anterior, y resolviendo la expresión de ese caso. Y en el último caso se le asigna el valor constante de 4.3. La parte derecha de un enunciado de asignación puede ser una variable, constante o expresión. Generalmente, en el desarrollo de

20

algoritmos con pseudocódigo, se utiliza una flecha para representar la asignación. 2.1.1.1. Reglas para la construcción de enunciados de asignación. 1. Las variables o constantes que aparezcan del lado derecho de un enunciado de asignación deben estar definidas previamente en la parte inicial del algoritmo. Esto es, no podemos utilizar variables o constantes en la parte derecha de un enunciado de asignación que no existan en el algoritmo, o que sean definidas posterior a su utilización, o que no tengan un valor definido. 2. La variable que se presenta en la izquierda de un enunciado de asignación es la única que cambia de valor. 3. Las variables o constantes que aparecen en la parte derecha de los enunciados de asignación conservan su valor, después de ejecutarse dicha sentencia. 4. Si la variable de la parte izquierda del enunciado se encuentra también del lado derecho (Valor = Valor + 1), esta variable cambia de valor por aparecer a la izquierda. 2.1.2. Enunciados de Lectura de datos. A través de los enunciados de lectura de datos, podemos asignar valores a una variable; estos enunciados nos permiten introducir datos, que van a ser utilizados en la resolución del problema.

La

diferencia de éstos con los enunciados de asignación, es que los enunciados de lectura de datos permiten al usuario introducir sus propios datos al programa o algoritmo en ejecución; los mismos no son fijados en el algoritmo, son solicitados al usuario para que éste los 21

ingrese, y pueden ser diferentes entre una ejecución y otra.

Este

enunciado consta de la palabra LEER, seguida de las variables que vamos a solicitar al usuario, separadas por coma. Ejemplo: Leer Precio, Descuento, Cantidad Leer Edad Leer Nombre, Edad, Dirección 2.1.3. Enunciado de Escritura. El enunciado de escritura es una forma de interactuar con el usuario, y se utilizan para presentar los resultados o datos de salida que se esperaban obtener con la ejecución del algoritmo. Éstos constan de la palabra ESCRIBIR seguida de la lista de variables que deseamos visualizar separadas por comas.

Además de las variables, en el

enunciado Escribir también se puede escribir texto entre comillas simples (‘ ‘), para indicarle al usuario que dato se está mostrando. Ejemplo: Escribir Pago_Total, Descuento_Total Escribir ‘La edad Promedio es ‘, Edad 2.1.4. Enunciado de Inicio y Terminación. Todo algoritmo debe empezar con la palabra INICIO y finalizar con la palabra FIN, las cuales sólo deben presentarse una vez.

Es

importante que el programador siga esta serie de instrucciones para que el resultado sea un algoritmo que resuelva el problema para el cual fue diseñado y que, a su vez, sea entendible para otras personas desde su inicio hasta su fin. 22

Ejemplo: Inicio Leer Precio, Descuento, Cantidad Pago_total  Precio * Cantidad . . Escribir Pago_Total, Descuento_total Fin 2.1.5. Adición de Comentarios. Cuando diseñamos algoritmos en pseudocódigo, se nos puede presentar la necesidad de hacer alguna aclaración o dejar plasmado un comentario acerca de una situación en particular de nuestro algoritmo, es por razones como esta que hacemos uso de los comentarios.

El propósito de añadir comentarios es para aclarar

cualquier situación que pueda ser confusa a aquellas personas que revisen o analicen nuestro algoritmo. Sintaxis de los comentarios: /*Entre estos dos símbolos se adiciona cualquier tipo de comentario.*/ En cualquier punto del algoritmo, los diseñadores de algoritmos podemos utilizar los símbolos /* y */, para dejar plasmados cualquier comentario o aclaración que nos parezca importante acerca del algoritmo.

Todo aquello que se encuentre encerrado entre los

símbolos de comentarios no será revisado para efectos del algoritmo, sólo debe ser tomado como una aclaración.

23

Ejemplo: /*Algoritmo que muestra en pantalla el número 1000. */ Inicio Escribir 1000 Fin 2.1.6. Declaración de Variables y Constantes. Todas las constantes y variables que utilicemos en nuestros algoritmos deben ser definidas luego de la instrucción Inicio. Se utiliza el enunciado Variables o Constantes, dado el caso, y a continuación se listan todas las variables y constantes, cada una en su sección, que utilicemos en nuestro algoritmo, siempre indicando el tipo de dato que almacenarán. Inicio Constantes Nombre_de_Constante

Valor_de_Constante

Variables variable, variables: enteros variable, variable: caracter /*Inicia ejecución del algoritmo*/ ………… ………… Fin

24

Ejemplo: /*Algoritmo que solicita un número al usuario y lo almacena en una variable. Luego presenta como salida el valor de la variable, y el valor de la constante. */ Inicio Constantes Const

12

Variables: Num: entero /*Inicia ejecución del algoritmo*/ Leer Num Escribir Num Escribir Const Fin 2.1.7. Enunciados de selección. El diseño de algoritmos tiene una gran utilidad cuando el algoritmo que vamos a realizar requiere algo más que una lista sencilla de instrucciones. Esto sucede cuando el flujo del programa puede variar debido al resultado de la evaluación de una determinada condición. Las estructuras de selección, como su nombre lo indica, seleccionan el camino de acción que va a seguir el programa debido a cierta condición.

Éstas se utilizan cuando necesitamos tomar decisiones

lógicas; de ahí que se suelan denominar también estructuras de decisión o alternativas. En éstas se evalúa una condición y en función del resultado de esta condición se realiza una opción u otra.

Las 25

condiciones

se especifican usando expresiones

lógicas.

La

representación de un enunciado de selección se hace con palabras en pseudocódigo (si, entonces, sino). Las estructuras selectivas o de decisión pueden ser:  Simples  Dobles  Múltiples

2.1.7.1. Selectiva simple (si-entonces). La estructura selectiva simple si-entonces efectúa cierta acción cuando se cumple una determinada condición o se verifica la veracidad (si es cierto) de esta condición. Se evalúa la condición que está después del si, de resultar verdadera o cierta se ejecutan las acciones que están después de la estructura si hasta que se encuentra el fin_si; si la condición resulta falsa, se salta estas líneas de código, y el control del programa se ubica después del fin_si. Pseudocódigo en español si entonces fin_si Ejemplo: /*Algoritmo que muestra la palabra Aprobado si la nota de un alumno es mayor a 60. */

26

Inicio Variables: Nota  80: entero /*Inicia ejecución del algoritmo*/ Si (nota > 60) entonces Escribir ("Aprobado") Fin_si Fin

Es importante que el lector analice cómo se pueden utilizar los operadores lógicos en la estructura de selección simple si-entonces (los operadores lógicos son 3: no, y, o vistos en el capítulo anterior).

2.1.7.2. Selectiva doble (si–entonces-sino). La

estructura

simple

si-entonces

es

demasiado

limitada

y,

generalmente, necesitaremos estructuras más complejas que nos permitan elegir entre dos o más alternativas dado el cumplimiento o no de una determinada condición. Pseudocódigo: Si entonces Sino fin_si

27

El pseudocódigo que acabamos de presentar, es mucho más flexible que la estructura simple si-entonces. En ésta, se nos permite efectuar una acción si es cierta, igual que la estructura si-entonces; sin embargo, en caso de que sea falsa, se efectúa la acción que está después de la sentencia Sino. Pseudocódigo compuesto: Si entonces Sino fin_si El pseudocódigo compuesto que mostramos arriba es similar al primer caso. La diferencia radica en que si es cierta se podrán definir varias acciones, al igual que si es falsa. Ejemplo: /*Algoritmo que muestra la palabra Aprobado si la nota es mayor a 60, y No Aprobado si ocurre lo contrario. */ Inicio

28

Variables: Nota  80: entero /*Inicia ejecución del algoritmo*/ Si (nota > 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 <= 60) y (nota >= 30) entonces Escribir ("No Aprobado") Sino Escribir ("Deficiente") Fin_si Fin_si Fin

29

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 <expresión_1>, la misma se compara con , , , etc.

Si <expresión_1> 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 <expresión_1> hacer : acción a1 : acción a2 : acción a3 : acción sx fin_según

30

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

31

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

32

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

33

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.

34

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.

35

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:

36

/*Algoritmo que calcula el promedio de las notas de un estudiante. El programa termina cuando la nota ingresada es -99 */ 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

37

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 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.*/ 38

Cant_Tot  0: entero /*Cantidad de galones totales que compraron todos los clientes.*/ /*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.

39

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 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 40

Sentencia 2 Sentencia 3 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:

41

 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. 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).

42

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 43

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

44

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

45

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:

46

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 47

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

48

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: 49

/*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

50

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

Burgos

89

100

90

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

51

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 Burgos

89

Parcial 2

Parcial 3

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 52

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.

53

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

54

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:

55

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

56

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

57

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

58

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“

59

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

60

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

61

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.

62

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. 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.

63

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). INICIO Edad: Entero ESCRIBA “cuál es tu edad?” Lea Edad SI Edad >=18 entonces ESCRIBA “Eres mayor de Edad” FINSI ESCRIBA “fin del algoritmo” FIN

64

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

si

Decisión (indica operaciones lógicas o de comparación entre datos –normalmente dosy en función del resultado de la misma determina cuál de los distintos caminos alternativos de programa se debe seguir; normalmente 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.

70

Diseñe un diagrama de flujo que lea la edad de un estudiante e imprima si el ESTUDIANTE MAYOR DE EDAD. 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 <=7)) NO

SI

72

Ejemplo1. Diseñe un diagrama de flujo que lea la edad de un estudiante e imprima si su edad es mayor a 18 años el ESTUDIANTE MAYOR DE EDAD y puede ir hacer el trámite de CEDULA y si no es MENOR DE EDAD.

Solución: Inicio

ENTERO : Edad

Imprimir
introduzca la edad DEL Estudiante Leer( Edad)

SI

Edad >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 <= 2.000, libre de impuestos, — las siguientes 220 dólares al 20 por 100, — el resto, al 30 por 100. Solución: Vamos a resolver este ejemplos en las dos técnicas A. SEUDOCODIGO algoritmo Nómina //Declaración de variables var cadena : nombre real : horas, impuestos, sbruto, sneto inicio leer(nombre, horas, tarifa) si horas <= 35 entonces sbruto ← horas * tarifa si_no sbruto ← 35 * tarifa + (horas - 35) * 1.5 * tarifa fin_si 75

si sbruto <= 2.000 entonces impuestos ← 0 si_no si (sbruto > 2.000) y (sbruto <= 2.220) entonces impuestos ← (sbruto - 2.000) * 0.20 si_no impuestos ← (220 * 0.20) + (sbruto - 2.220) fin_si fin_si sneto ← sbruto - impuestos escribir(nombre, sbruto, impuestos, neto) fin

B. DIAGRAMA DE FLUJO

76

Ejemplo 3 Se desea escribir un algoritmo que pida la altura de una persona, si la altura es menor o igual a 150 cm envíe el mensaje: Persona de altura baja si la altura está entre 151 y 170 escriba el mensaje: Persona de altura media y si la altura es mayor al 171 escriba el mensaje: Persona alta. Diseñe el diagrama de flujos. INICIO

FIN

77

3.4.5 Selectivas múltiples La estructura selectiva múltiple es similar a la selectiva anidada, salvo que las condiciones deben ser de alguno de los tipos enteros o de tipo carácter La estructura selectiva si múltiple permite que el flujo del diagrama se bifurque por varias ramas en el punto de la toma de decisión(es), esto en función del valor que tome la selección . Si él toma el valor N se realizará la acción N, y si toma un valor distinto de los valores comprendidos entre 1 y N, sale de la selección fuera de rango. Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema se podría resolver por estructuras selectivas simples o dobles, anidadas o en cascada, pero si el número de alternativas es grande puede plantear serios problemas de escritura y de legibilidad. Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n valores distintos, 1, 2 , 3, ....,n y según que elija uno de estos valores en la condición, se realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un determinado camino entre los n posibles. Su notación en diagrama de flujo es

Ejemplo 1 Dado un numero entre 1 y 7 escriba su correspondiente día de la semana así: 1- Lunes 2- Martes 3- Miércoles 4- Jueves 5- Viernes 6- Sábado 7Domingo

78

3.5 Estructuras Repetitivas Las computadoras están especialmente diseñadas para todas aquellas aplicaciones en las cuales una operación o conjunto de ellas deben repetirse muchas veces. Un tipo muy importante de estructura es el algoritmo necesario para repetir una o varias acciones un número determinado de veces. Un programa que lee una lista de números puede repetir la misma secuencia de mensajes al usuario e instrucciones de lectura hasta que todos los números de un fichero se 79

lean. Las estructuras que repiten una secuencia de instrucciones un número determinado de veces se denominan bucles y se denomina iteración al hecho de repetir la ejecución de una secuencia de acciones. Un ejemplo aclarará la cuestión. Supongamos que se desea sumar una lista de números escritos desde teclado. Los bucles son segmento de un algoritmo o programa, cuya instrucciones se repiten un número determinado de veces mientras se cumple una determinada condición (existe o es verdadera la condición). SE debe establecer un mecanismo para determinar las tareas repetitivas. Este mecanismo es una condición que puede ser verdadera o falsa y que se comprueba una vez a cada paso o iteración del bucle (total de instrucciones que se repiten en el bucle). 3.5.1 Repetitiva Mientras La estructura repetitiva mientras (en inglés while o dowhile: hacer mientras) es aquella en que el cuerpo del bucle se repite mientras se cumple una determinada condición. Cuando se ejecuta la instrucción mientras, la primera cosa que sucede es que se evalúa la condición (una expresión booleana). Si se evalúa falsa, no se toma ninguna acción y el programa prosigue en la siguiente instrucción del bucle. Si la expresión booleana es verdadera, entonces se ejecuta el cuerpo del bucle, después de lo cual se evalúa de nuevo la expresión booleana. Este proceso se repite una y otra vez mientras la expresión booleana (condición) sea verdadera. Tal como se muestra en la siguiente figura.

80

Ejemplo 1. Diseñe un diagrama de flujo que lea la edad de diez estudiantes del cuso de lógica de programación e imprima cuantos son estudiantes son mayores de 18 años y cuantos son menores de 18 años. Utilice la Estructura Repetitiva mientras. Solución: Inicio

ENTERO : Edad,CANT0, CME 0,CMA0

NO

CANT<10

SI Imprimir
LA CANTIDAD ESTUDIANTE ES MAYOR DE EDAD ES: CMA) Imprimir LA CANTIDAD ESTUDIANTE ES MENOR DE EDAD ES: CME)

Imprimir
introduzca la edad DEL Estudiante Leer( Edad)

SI

Edad >18

CMECME+1

FIN NO

CMECME+1

CANTCANT+1

81

3.5.2 Repetitiva hacer mientras El bucle mientras al igual que el bucle desde que se verá con posterioridad evalúan la expresión al comienzo del bucle de repetición; siempre se utilizan para crear bucle pre-test. Los bucles pre-test se denominan también bucles controlados por la entrada. En numerosas ocasiones se necesita que el conjunto de sentencias que componen el cuerpo del bucle se ejecuten al menos una vez sea cual sea el valor de la expresión o condición de evaluación. Estos bucles se denominan bucles post-test o bucles controlados por la salida. Un caso típico es el bucle hacer-mientras (do-while) existente en lenguajes como C/C++, Java o C#. El bucle hacer-mientras es análogo al bucle mientras y el cuerpo del bucle se ejecuta una y otra vez mientras la condición (expresión booleana) sea verdadera. Existe, sin embargo, una gran diferencia y es que el cuerpo del bucle está encerrado entre las palabras reservadas hacer y mientras, de modo que las sentencias de dicho cuerpo se ejecutan, al menos una vez, antes de que se evalúe la expresión booleana. En otras palabras, el cuerpo del bucle siempre se ejecuta, al menos una vez, incluso aunque la expresión booleana sea falsa.

82

Regla El bucle hacer-mientras se termina de ejecutar cuando el valor de la condición es falsa. La elección entre un bucle mientras y un bucle hacer-mientras depende del problema de cómputo a resolver. En la mayoría de los casos, la condición de entrada del bucle mientras es la elección correcta. Por ejemplo, si el bucle se utiliza para recorrer una lista de números (o una lista de cualquier tipo de objetos), la lista puede estar vacía, en cuyo caso las sentencias del bucle nunca se ejecutarán. Su notación en diagrama de flujo es como se muestra en la siguiente figura.

Ejemplo 1 Imprima la potencia de los de 10 de los números comprendido entre 1 a 1000 e imprima el total de dicha potencia.

83

Inicio

Entero : POT1, TOT0

Imprimir
LA POTENCIA DE ES: POT)

SI POT POT*10 TOTTOT+POT

POT<1000

NO Imprimir
LA POTENCIA ES POT) Imprimir EL TOTAL DE LA POTENCIA DE DIEZ ES: TOT)

FIN

3.5.3 Repetitiva Repetir hasta Existen muchas situaciones en las que se desea que un bucle se ejecute al menos una vez antes de comprobar la condición de repetición. En la estructura mientras si el valor de la expresión booleana es inicialmente falso, el cuerpo del bucle no se ejecutará; por ello, se necesitan otros tipos de estructuras repetitivas. La estructura repetir (repeat) se ejecuta hasta que se cumpla una condición determinada que se comprueba al final del bucle figura. El bucle repetir-hasta_que se repite mientras el valor de la expresión booleana de la condición sea falsa, justo la opuesta de la sentencia mientras.

84

Ejemplo1 Diseñe un diagrama de flujo que realice el calculo del factorial de un numero usando la sentencias repetitivas repetir hasta. Solución: Inicio ENTERO: FACT1, I1,num

Imprimir
INTRODUZCA EL NUMERO: LEER(num)

num >1

SI

NO FACT1

FACT1

I 1 SI

Imprimir
EL FACTORIAL DEL NUMERO num ES ,FACT)

FACTFACT*I I I+1

I = num

NO Imprimir
EL FACTORIAL DEL NUMERO num ES ,FACT)

FIN

3.5.4 Repetitiva Repetir Desde/Para En muchas ocasiones se conoce de antemano el número de veces que se desean ejecutar las acciones de un bucle. En estos casos, en el que el número de iteraciones es fijo, se debe usar la estructura desde o para (for, en inglés). La estructura desde ejecuta las acciones del cuerpo del bucle un número especificado de veces y de modo

85

automático controla el número de iteraciones o pasos a través del cuerpo del bucle. Las herramientas de programación de la estructura desde o para se muestran en la Figura .

86

Ejemplo 1 Diseñe un diagrama de flujo que realice el cálculo del factorial de un numero usando la sentencias repetitivas desde hasta.

Inicio ENTERO: FACT1, I1,num

Imprimir
INTRODUZCA EL NUMERO: LEER(num)

num >1

NO FACT1

SI I1 I < num-1 NO

II+1

FACTFACT*I

Imprimir
EL FACTORIAL DEL NUMERO num ES ,FACT)

SI Imprimir
EL FACTORIAL DEL NUMERO num ES ,FACT)

FIN

87

VENTAJAS DE USAR FLUJOGRAMAS  Rápida comprensión de las relaciones  Análisis efectivo de las diferentes secciones del programa  Pueden usarse como modelos de trabajo en el diseño de nuevos programas o sistemas  Comunicación con el usuario  Documentación adecuada de los programas  Codificación eficaz de los programas  Depuración y pruebas ordenadas de programas

DESVENTAJAS DE LOS FLUJOGRAMAS  Diagramas complejos y detallados suelen ser laboriosos en su planteamiento y diseño  Acciones a seguir tras la salida de un símbolo de decisión, pueden ser difíciles de seguir si existen

diferentes caminos

 No existen normas fijas para la elaboración de los diagramas de flujo que permitan incluir todos los detalles que el usuario desee introducir.

88

Problemas Propuestos 1. Escribe un algoritmo que pida tres números y luego escriba el promedio. 2. Escribe un algoritmo que calcule el área de un círculo de cualquier radio. 3. Escribe un algoritmo que lea una cantidad depositada en un banco y que calcule la cantidad final después de aplicarle un 20% de interés. 4. Diseñar un algoritmo que lea un valor en dólares y lo convierta a centavos 5. Leer dos números y encontrar la suma del doble del primero más el cuadrado del segundo. 6. Escribir un programa que solicite ingresar 10 notas de alumnos y nos informe cuántos tienen notas mayores o iguales a 7 y cuántos menores. 7. Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la altura promedio de las personas. 8. En una empresa trabajan n empleados cuyos sueldos oscilan entre $100 y $500, realizar un programa que lea los sueldos que cobra cada empleado e informe cuántos empleados cobran entre $100 y $300 y cuántos cobran más de $300. Además, el programa deberá informar el importe que gasta la empresa en sueldos al personal. 9. Realizar un programa que imprima 25 términos de la serie 11 22 - 33 - 44, etc. (No se ingresan valores por teclado)

89

10.

Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en

pantalla 8 - 16 - 24, etc. 11.

Realizar un programa que permita cargar dos listas de 15 valores

cada una. Informar con un mensaje cuál de las dos listas tiene un valor acumulado mayor (mensajes "Lista 1 mayor", "Lista 2 mayor", "Listas

iguales")

Tener en cuenta que puede haber dos o más estructuras repetitivas en un algoritmo. 12.

Hacer un programa que sume los 10 pares que le siguen al 24

13.

Hacer un programa que sume los 10 impares que le siguen al

número n 14.

Hacer un programa que sume los pares comprendidos entre 100

y 200 sin considerar el rango de números comprendidos entre 50 y 76 15.

Hacer un programa que sume los 10 primeros números pares,

luego que sume los 10 primeros Impares y muestre la diferencia de ambos resultados. 16.

Hacer un programa que sume los 10 números pares que le

siguen a N, luego que sume los 10 Impares que le siguen a M y muestre la diferencia de ambos resultados.

90

PROBLEMAS RESUELTOS Diagrama de Flujo para calcular el área del triángulo dada la base= 4.5 y h= 7.2 Pseudocódigo: Esun lenguaje de especificaciones de algoritmos, de uso fácil y sintaxis similar al lenguaje de programación. Para escribir un pseudocódigo hay que cumplir algunos requisitos: 1. Asignar un nombre: se debe poner un Título al algoritmo que referencia a su contenido o función. 2.

Declarar

variables:

es

haga

necesario

especificar los nombres de las variables y el tipo de dato que van a almacenar. 3. Delimitar estructuras: deben delimitarse el inicio y un fin. 4. Identificar mensajes: los mensajes que deseas que se muestren al usuario deberán escribirse entre comillas. Algoritmo en Pseudocódigo: Algoritmo AREA Inicio b, h, a: reales Escriba “la base es:” Leer b Escriba “la altura es” Leer h a= 1/2*b*h Escribir “área es:“ ,a Fin

91

BIBLIOGRAFIA Aguilar, L. J. (2003). Fundamentos de programación. España: McGRAW-HILL. Garcia, R. (2003). Técnicas de Programación. Panamá: Mc Graw-Hill. ricardo Castellanos; Cortés, Gonzalo. (2006). Informatica activa 1. Panamá: AlfaOmega. José Alfredo Jiménez, José Alfredo Jiménez Murillo Fundamentos de programación, Alfaomega, 418 páginas

(2015).

Urbaez, W. (26 de Octubre de 2005). Estructuras condicionales. Obtenido de Estructuras condicionales: http://www.desarrolloweb.com/articulos/2225.php

92