asignatura: computación carrera: ingeniería en...

Universidad Nacional de Luján Departamento de Ciencias Básicas

División Estadística y Sistemas

Universidad Nacional de Luján Departamento de Ciencias Básicas

División Estadística y Sistemas

Asignatura: Computación Carrera: Ingeniería en Alimentos – 11964 Lic. En Ciencias Biológicas - 11964

Módulo: Metodología de la programación

Autores:

Jorge Peri Carlos Rodriguez Jorge Scucimarri Fernando Bordignon Claudia Perroud Patricia Felice

- Marzo 2005 –

Universidad Nacional de Luján Metodología de la Programación Depto. de Ciencias Básicas División Estadística y Sistemas

Página 2 de 89

Acerca de este documento Este cuaderno de estudio está dirigido a estudiantes de la Universidad Nacional de Luján, que cursen una asignatura inicial relacionada con la programación de computadoras. El objetivo de este módulo es dotar al alumno de conocimientos básicos, brindando una aproximación introductoria al campo de la especialidad, aportando elementos iniciales mínimos e indispensables como base para una posterior profundización en la temática. Atención: Estos apuntes deben ser usados como refer encia de los temas vistos en clase. No son, ni intentan ser un texto d e estudio. El contenido de estos apuntes no alcanza para la aprobación de l a asignatura, ya que sólo enumeran los temas vistos. Para estudiar la as ignatura, por favor referirse a la bibliografía del curso.


Página 3 de 89

Contenidos

1 CONCEPTOS BÁSICOS ............................... ............................................. 5

1.1 Introducción ................................................................................................................................. 5

1.2 Algoritmos..................................................................................................................................... 6

1.3 Programas ..................................................................................................................................... 8

1.4 Lenguajes de Programación ........................................................................................................ 8 1.4.1 Lenguaje de Máquina ........................................................................................................... 9 1.4.2 Lenguaje Ensamblador ......................................................................................................... 9 1.4.3 Lenguajes de Alto Nivel ....................................................................................................... 9

1.4.3.1 Intérprete ........................................................................................................................ 10 1.4.3.2 Compilador .................................................................................................................... 10 1.4.3.3 Ventajas de los Lenguajes de Alto Nivel ....................................................................... 10 1.4.3.4 Desventajas de los Lenguajes de Alto Nivel .................................................................. 11

1.5 Paradigmas de Programación ................................................................................................... 11 1.5.1 Paradigma Imperativo ......................................................................................................... 11 1.5.2 Paradigma Lógico ............................................................................................................... 11 1.5.3 Paradigma Funcional .......................................................................................................... 13

1.6 Metodología de la Programación .............................................................................................. 13

1.7 Ingeniería de Software ............................................................................................................... 14

1.8 Ciclo de Vida del Software ........................................................................................................ 15

2 INTRODUCCIÓN A LA PROGRAMACIÓN ................. ............................ 16

2.1 Datos ............................................................................................................................................ 16 2.1.1 Tipos de Datos Primitivos .................................................................................................. 17

2.1.1.1 Entero ............................................................................................................................. 17 2.1.1.2 Real ................................................................................................................................ 17 2.1.1.3 Caracter .......................................................................................................................... 18 2.1.1.4 Lógico ............................................................................................................................ 18

2.1.2 Variables ............................................................................................................................. 18 2.1.3 Declaración de Constantes y Variables .............................................................................. 18 2.1.4 Expresiones y Operadores .................................................................................................. 20

2.1.4.1 Operadores Aritméticos ................................................................................................. 20 2.1.4.2 Operadores Relacionales ................................................................................................ 21 2.1.4.3 Operadores sobre Cadenas ............................................................................................. 21 2.1.4.4 Operadores Lógicos ....................................................................................................... 22 2.1.4.5 Orden de Prioridad de las operaciones ........................................................................... 23 2.1.4.6 Orden de Evaluación de los Operadores ........................................................................ 23

2.1.5 Funciones del Lenguaje ...................................................................................................... 24

3 PROGRAMACIÓN ESTRUCTURADA ....................... .............................. 26

3.1 Estructuras de Control .............................................................................................................. 26 3.1.1 Secuencia ............................................................................................................................ 28 3.1.2 Selección............................................................................................................................. 28 3.1.3 Iteración .............................................................................................................................. 28


Página 4 de 89

3.2 Estructogramas o Diagramas Chapín ...................................................................................... 29 3.2.1 Escritura de Programas ....................................................................................................... 31

3.2.1.1 Normas de Identación .................................................................................................... 31 3.2.2 Entrada y Salida de Información ........................................................................................ 32

3.2.2.1 Ejemplo: ......................................................................................................................... 33

3.3 Estructura Secuencial ................................................................................................................ 35 3.3.1 Ejemplo 1............................................................................................................................ 35 3.3.2 Ejemplo 2............................................................................................................................ 35

3.4 Estructura de Selección ............................................................................................................. 37 3.4.1 Decisiones........................................................................................................................... 37 3.4.2 Estructura Condicional Simple ........................................................................................... 38

3.4.2.1 Ejemplo .......................................................................................................................... 39 3.4.3 Estructura de Selección Compuesta .................................................................................... 40

3.4.3.1 Ejemplo 1 ....................................................................................................................... 40 3.4.3.2 Ejemplo 2 ....................................................................................................................... 42

3.4.4 Selecciones Anidadas ......................................................................................................... 44 3.4.4.1 Ejemplo .......................................................................................................................... 45

3.4.5 Menú de Opciones .............................................................................................................. 47 3.4.6 Estructura de Selección Múltiple ........................................................................................ 50

3.5 Estructura Repetitiva o Iterativa .............................................................................................. 53 3.5.1 Estructura Mientras............................................................................................................. 54 3.5.2 Estructura Repetir ............................................................................................................... 56 3.5.3 Estructura Repetir - Hasta ................................................................................................... 58 3.5.4 Estructura Para .................................................................................................................... 59 3.5.5 Ejemplos de Uso de Estructuras Repetitivas ...................................................................... 61

3.5.5.1 Búsqueda del Extremo ................................................................................................... 62 3.5.5.2 Validación de Datos ....................................................................................................... 63

3.5.5.2.1 Ejemplo de validación .............................................................................................. 63

4 ARREGLOS Y ARCHIVOS SECUENCIALES ................ .......................... 65

4.1 Arreglos ....................................................................................................................................... 65 4.1.1 ....................................................................................................................................................... 71 4.1.2 Ordenamiento de Vectores ................................................................................................. 71

4.1.2.1 Ordenamiento por Inserción .......................................................................................... 75 4.1.3 Búsqueda en Vectores ........................................................................................................ 76

4.2 Archivos Secuenciales ................................................................................................................ 77 4.2.1 Operaciones Básicas sobre Archivos .................................................................................. 79

4.2.1.1 Grabación de Datos ........................................................................................................ 80 4.2.1.2 Recuperación de Datos Grabados .................................................................................. 83

4.2.2 Organización Secuencial .................................................................................................... 84 4.2.3 Acceso ................................................................................................................................ 85

4.2.3.1 Acceso Secuencial ......................................................................................................... 85 4.2.4 Modificaciones de Datos Sobre Archivos Secuenciales ..................................................... 86

4.2.4.1.1 Altas ......................................................................................................................... 86 4.2.4.1.2 Bajas ......................................................................................................................... 87 4.2.4.1.3 Modificaciones ......................................................................................................... 88


Página 5 de 89

1 Conceptos Básicos

1.1 Introducci ón El computador por sí solo es incapaz de procesar información. Lo que se denomina sencillamente "procesamiento de la información" constituye una actividad por lo general muy compleja, mientras que la máquina puede ejecutar solamente tareas elementales, como hacer cuentas, comparaciones, imprimir, almacenar datos, etc. Veamos un ejemplo típico y relativamente sencillo: Ejemplo 1 Liquidación de haberes: Se desea hacer un recibo de sueldo de un determinado empleado de una empresa, ello requiere una serie de datos de entrada, que podrían ser los siguientes:

a) Nombre y apellido del empleado. b) Número de legajo. c) Categoría d) Antigüedad e) Estado civil f) Cantidad de hijos g) Obra social h) Premios i) Sindicato etc.

En función de toda esta información la computadora deberá realizar los

cálculos necesarios y producir las siguientes salidas:

a) Recibo de sueldo b) Cheque c) Descuento para la caja de jubilación d) Aporte a la obra social e) Aporte al sindicato etc.

En un caso real este proceso se efectúa para muchos empleados, con lo

cual los descuentos y aportes se imprimen en forma de listados. Para poder producir la salida requerida en función de los datos de entrada, la computadora deberá ejecutar una cantidad de tareas como las siguientes:

a) En función de la categoría, consultar en una tabla cuál es el sueldo básico. b) En función de la antigüedad, calcular el adicional por ese concepto. c) Calcular los adicionales por esposa, hijos y escolaridad. d) Calcular los aportes a la caja de jubilación, obra social y sindicato. e) Calcular el neto a cobrar etc.


Página 6 de 89

Como se ve, el procesamiento necesario para producir una liquidación de haberes, es el resultado de la ejecución de una serie de tareas básicas, las cuales pueden descomponerse en otras aún más elementales.

Para que estas tareas básicas conduzcan al resultado que se pretende deben ser ejecutadas en un cierto orden, y tanto la definición de las tareas como el orden deben estar definidos previamente al momento de la ejecución. La definición de las tareas se efectúa mediante lo que denominamos "instrucciones", que son órdenes que la computadora puede identificar y ejecutar. 1.2 Algoritmos

Un algoritmo es la especificación rigurosa de una secuencia de pasos para alcanzar un resultado deseado en un tiempo finito. En su acepción más general, el término algoritmo puede aplicarse a casi cualquier actividad de la vida diaria, son algoritmos las recetas de cocina, los programas de actos, las instrucciones de uso de un aparato, etc.

En todos estos casos existen dos características vinculadas con el concepto de algoritmo, por un lado se trata de tareas (batir un huevo, ejecutar una nota musical, etc.), y por el otro hay un orden cronológico en el cuál deben ser ejecutadas.

Si se examina una de estas tareas o instrucciones, se observa que su ejecución implica a su vez la ejecución ordenada de otras tareas más elementales, por ejemplo para batir un huevo se requiere tomar un recipiente, tomar un batidor, cascar los huevos, colocarlos dentro del recipiente, etc. A su vez, cada una de estas tareas puede describirse en función de otras más elementales aún, y así sucesivamente.

Con este concepto, podemos decir que un algoritmo es un conjunto finito de algoritmos para producir un proceso determinado, esto es lo que denominamos "definición recursiva". Para que esta definición no conduzca a una sucesión infinita, sería necesario definir aquellas instrucciones elementales que no pueden definirse como algoritmos.

Algoritmos comunes

° Ver una película

1. Buscar la película

2. Si el televisor y la reproductora de vídeo se hallan apagados, encenderlos

3. Sacar la película del estuche


Página 7 de 89

4. Introducirla en la videocasetera

5. Tomar el control remoto

6. Sentarse en un sillón

7. Iniciar la reproducción y ajustar controles de imagen y sonido

8. Ver la película

° Algoritmo para cambiar una rueda a un automóvil.

1. Inicio.

2. Traer gato y llanta repuesto.

3. Aflojar tornillos de las llantas.

4. Levantar el coche con el gato.

5. Sacar los tornillos de las llantas.

6. Quitar la llanta.

7. Insertar la llanta de repuesto.

8. Colocar los tornillos.

9. Ajustar los tornillos.

10. Bajar el gato.

11. Guardar la llanta y el gato

12. Fin

° Determinar el mayor de tres números enteros.

Pasos del algoritmo :

1. Comparar el primero y el segundo entero, deduciendo cuál es el mayor.

2. Comparar el mayor anterior con el tercero y deducir cuál es el mayor. Este será el resultado.

Los pasos anteriores se pueden especificar con mayor detalle, es decir realizar un refinamiento del algoritmo.

1.- Solicitar el primer número (N1)

2.- Solicitar el segundo número (N2)

3.- Comparar N1 con N2 y determinar el mayor y llamarlo MAYOR; si los números son iguales, seleccionar N1 y llamarlo MAYOR.

4.- Solicitar el tercer número (N3)

5.- Comparar MAYOR con N3 y seleccionar el mayor y llamarlo MAYOR; si los dos números son


Página 8 de 89

iguales, seleccionar a MAYOR.

6.- Mostrar el valor MAYOR.

7.- Fin

1.3 Programas

La computadora es una herramienta para la resolución de problemas, más potente será cuanto mayor sea su capacidad de modelar soluciones adecuadas para cada problema.

Llamamos programación a la tarea de construir programas que efectúen el procesamiento de la información que nos proponemos. Un esquema de procesamiento de la información puede describirse como sigue:

a) Análisis del Problema . Permite dar como resultado un modelo preciso del ambiente del problema. b) Diseño de una solución . Teniendo en cuenta los datos de entrada y de salida. c) Especificación de algoritmos . Es decir, cuál es la secuencia lógica de instrucciones que la computadora debe ejecutar para producir los datos de salida a partir de los datos de entrada, teniendo en cuenta que una transformación sobre los mismos datos puede resolverse con una utilización de recursos diferentes. d) Escritura de programas . El algoritmo debe expresarse en un lenguaje de programación concreto y acorde a las características del problema, que la máquina pueda interpretar y ejecutar. e) Verificar . Una vez escrito el programa en un lenguaje determinado se debe verificar que su ejecución conduce al resultado deseado con datos representativos del problema real.

Una de las ventajas fundamentales del procesamiento electrónico es que los tareas descriptas arriba se efectúan una sola vez, y el programa queda disponible para ejecutarse cuantas veces se desee. En el ejemplo de la liquidación de haberes, una vez construido el programa, será ejecutado todos los meses para que produzca la liquidación, cambiando únicamente los datos de entrada, debido a aumentos, cambios de antigüedad, etc.

1.4 Lenguajes de Programación

En toda computadora, las instrucciones deben darse en un lenguaje de programación que ella pueda decodificar. En las primeras computadoras, la programación era una tarea difícil y laboriosa ya que llaves tipo on-off de válvulas de vacío debían configurarse a mano. Programar tareas tan sencillas


Página 9 de 89

como ordenar una lista de nombres requería varios días de trabajo de equipos de programadores. Desde entonces se han desarrollado varios lenguajes informáticos, algunos orientados hacia funciones específicas y otros centrados en la facilidad de uso. 1.4.1 Lenguaje de Máquina

Es el lenguaje propio de cada computadora, está construido en base a instrucciones y estructuras de datos que el procesador directamente -sin traducción alguna- puede interpretar y ejecutar. La programación se realiza en código binario, y es por ello que es bastante difícil construir programas en este lenguaje. En general, los programadores evitan construir programas basándose en lenguaje de máquina, prefieren utilizar un lenguaje de mayor nivel que les brinde un grado más alto de abstracción. 1.4.2 Lenguaje Ensamblador

Es una herramienta "más amigable" que permite reducir y simplificar la tarea de construir programas. Se basa en asignar un código mnemotécnico a cada orden en lenguaje máquina, por lo cual la escritura deja de estar exclusivamente en sistema binario. Una vez que el programador construyó un programa fuente, se utiliza un programa auxiliar denominado "ensamblador" cuya función es traducir el código fuente a lenguaje de máquina (a veces llamado código objeto).

Debido a la dependencia existente entre el lenguaje propio de la computadora y el lenguaje ensamblador, los programas realizados son dependientes exclusivamente del tipo de procesador de la computadora donde se desarrollaron.

Ejemplo de instrucciones

mov ax,0002 ; instancia el valor 0002 en el registro ax mov bx,0004 ; instancia el valor 0004 en el registro bx add ax,bx ; le suma al contenido de ax el contenido de bx

1.4.3 Lenguajes de Alto Nivel

Los lenguajes de alto nivel proveen un método por el cual en base a instrucciones redactadas en lenguaje natural, los programadores pueden construir programas de forma más sencilla y en menos tiempo. Otra característica importante que poseen los lenguajes de alto nivel, es la independencia de sus instrucciones con respecto al lenguaje de máquina, esto hace que un mismo programa fuente pueda llevarse a distintas computadoras, con distintos tipos de procesadores, y funcionar correctamente. La característica enunciada se denomina portabilidad.

Una vez que un programa construido en lenguaje de alto nivel está finalizado, hay que traducirlo al lenguaje de máquina de la computadora donde


Página 10 de 89

se desea ejecutarlo. Para ello se utilizan programas traductores, y son de dos tipos: intérpretes y compiladores.

1.4.3.1 Intérprete

Es un programa traductor que toma un programa fuente, lo traduce a

lenguaje de máquina y lo ejecuta línea a línea. Ejemplo: Basic, Prolog, Perl.

ProgramaFuente

Traducción yejecución

simultáneaIntérprete

Dado que existe un proceso continuo de traducción de instrucciones, los programas que se ejecutan de forma interpretada corren de forma más lenta que los compilados (están traducidos a código de máquina).

1.4.3.2 Compilador

Es un programa que traduce los programas fuentes escritos en

lenguajes de alto nivel a lenguaje de máquina, produciendo un programa objeto que posteriormente puede ser ejecutado.

ProgramaFuente

ProgramaObjeto

Compilador

1.4.3.3 Ventajas de los Lenguajes de Alto Nivel

° El tiempo de educación de programadores es menor, comparado con los

programadores de lenguajes de bajo nivel. ° Portabilidad de programas fuentes. ° Permiten escribir programas en términos orientados al problema ° La escritura de programas se basa en lenguaje natural. ° Las modificaciones y ajustes de los programas son simples. ° Es posible lograr una importante producción en el desarrollo de

programas. ° No se necesita que el programador conozca detalles sobre el hardware

donde se ejecutará el programa.


Página 11 de 89

1.4.3.4 Desventajas de los Lenguajes de Alto Nivel

° No se aprovechan en profundidad los recursos internos de la máquina.

Se explotan de mejor manera utilizando lenguajes de bajo nivel. ° Los programas ejecutables, en general, necesitan más recursos en su

corrida. ° En general, los programadores no disponen de librerías de ayuda

específica a los problemas que necesitan resolver. 1.5 Paradigmas de Programación

Un paradigma de programación es un modelo básico de diseño y desarrollo de programas. Los llamados paradigmas de programación son conceptualizaciones genéricas, que agrupan bajo un nombre a distintos lenguajes de programación. 1.5.1 Paradigma Imperativo

Esta basado en el modelo Von Neumann, en donde un conjunto de operaciones primitivas realizan una ejecución secuencial. Se utiliza esencialmente la instrucción de asignación como constructor básico, sobre el cual se construyen las instrucciones de control secuencial, alternativo e iterativo.

Los lenguajes imperativos son orientados a instrucciones y por

ello se consideran conducidos por comandos. Los programas escritos en ellos se basan en la idea de secuencia de instrucciones que se tienen que llevar a cabo como una receta, son la transcripción de un algoritmo. La unidad de trabajo es la instrucción. Un programa consta de una secuencia de sentencias, y la ejecución de cada sentencia obliga al intérprete o compilador a cambiar el valor de una o más localizaciones en su memoria.

PROGRAM intercambio;

VAR x,y, tmp; BEGIN

tmp := x; x := y; y := tmp;

END. Algunos de los lenguajes de este tipo son Pascal, Ada y C.

1.5.2 Paradigma Lógico


Página 12 de 89

Trata de representar conocimiento mediante relaciones (predicados) entre objetos (datos). Un programa lógico consiste en un conjunto de relaciones, y su ejecución vendrá a demostrar que una nueva relación se sigue de las que constituían el programa. Las relaciones serán especificadas con reglas y hechos. La ejecución de programas lógicos consiste en la demostración de hechos sobre las relaciones por medio de consultas. Así, el hecho de programar consistirá en proporcionar a la computadora un universo finito en forma de hechos y reglas (base de conocimientos), dotándolo de los medios para realizar inferencias de un hecho a otro. Si posteriormente se le hacen las preguntas adecuadas, Prolog buscará las respuestas en dicho universo y nos las mostrará en pantalla.

La programación lógica trata con relaciones en lugar de con funciones, lo que nos proporciona mayor flexibilidad, ya que las relaciones no tienen sentido de la dirección y tratan uniformemente argumentos y resultados (no hay distinción entre parámetros de entrada y de salida).

La idea central de todo esto se la puede expresar utilizando la ecuación de Kowalski “algoritmo = lógica + control”, de manera que el control (estrategia para encontrar la solución) se la deja en manos de la computadora, y sólo se debe atender la lógica (información acerca del problema).

En programación lógica las expresiones pueden ser hechos, reglas o preguntas: Socrates es hombre (hecho) Alguien es mortal si alguien es hombre (regla) =>¿Socrates es mortal? (pregunta)

=>SI (respuesta)

Aquí el intérprete obtuvo la respuesta sobre un dato que no se le había dado en forma explícita. El silogismo anterior escrito en el lenguaje Prolog quedaría como: Los hechos: hombre(Socrates)

La regla: mortal(x) :- hombre(x) La pregunta : ? mortal(Socrates) La repuesta: YES Ejemplo en lenguaje Prolog, cálculo del factorial de un número

/* factorial(N,F) <- F es el factorial de N */ factorial(0,1). factorial(N,F) :- N1 is N-1,

factorial(N1,F1),


Página 13 de 89

F is N*F1.

1.5.3 Paradigma Funcional

El Programa es una Función (o un grupo de funciones). Usualmente compuesto de Funciones más simples. La relaciones entre las funciones son muy simples:

Una Función puede llamar a otra Función, o el resultado de una Función puede ser usado como el argumento de otra Función. Las variables, comandos y efectos laterales son exclusivos. Los programas son escritos enteramente dentro del lenguaje de expresiones, funciones y declaraciones.

Un "programa¨ funcional es un encadenamiento de funciones que se invocan y se pasan datos unas a otras. Ejemplo de programa en Common Lisp, cálculo del factorial de un número:

( DEFUN FACTORIAL (N) ( IF (= N 0) 1 (* N (FACTORIAL (- N 1))) ) )

Dos de estos lenguajes son Scheme y ML.

1.6 Metodología de la Programación Las siguientes son etapas que deben cumplirse a los efectos de resolver un problema mediante un programa informático:

1) Definición del problema

Se debe partir de un enunciado de problema claro y completo. 2) Análisis del problema

A partir de comprender claramente cual es el problema, se procede a analizar alternativas de solución, como ser:

• Resultados que se esperan. • Datos de entrada se brindan. • Posibles métodos a utilizar para obtener la salida deseada.

3) Construcción de un algoritmo

Por medio de un lenguaje de especificación (puede ser gráfico o un seudolenguaje) se procede a construir un algoritmo que resuelva el problema en estudio. En esta etapa, una vez construido el algoritmo, se


Página 14 de 89

sugiere que el diseñador realice una prueba de escritorio -someter el algoritmo a diversas ejecuciones, variando los datos de entrada y verificar su funcionamiento- a los efectos de determinar si el método elegido funciona correctamente. 4) Codificación

Utilizando un lenguaje de computadora se traduce el algoritmo a

un programa fuente que una máquina sea capaz de entender y ejecutar. Se recomienda que el técnico que realice esta tarea -el programador- inserte comentarios junto a las líneas de código a los efectos de facilitar la lectura del programa (documentación interna) en instancias superiores de validación o mantenimiento. 5) Compilación

Si el lenguaje utilizado en el proceso de codificación requiere de una traducción a lenguaje de máquina se utiliza un programa compilador a los efectos de generar un programa objeto. Es importante destacar que una de las funciones de todo compilador es el análisis sintáctico del programa fuente a los efectos de detectar errores de sintaxis ocasionados por errores de codificación. El compilador no analiza semántica, es decir que las fallas de lógica que pueda existir en el programa fuente no son detectadas por el compilador. 6) Prueba

Se ejecutar el programa con distintos juegos de datos de entrada y se corrigen los errores que se puedan presentar. Al final se obtiene un programa depurado. 7) Documentación Etapa final en la cual se realiza la documentación externa en la cual se explica lo que el programa hace y cuales son los datos de entrada y salida. parte de esta documentación es requerida por usuarios y por programadores encargados del mantenimiento del software.

1.7 Ingeniería de Software

La Ingeniería de Software es un área de las Ciencias de la Computación, que ofrece métodos y técnicas para desarrollar y mantener software de calidad que resuelven problemas de información. Comprende el uso de metodologías, herramientas y técnicas para resolver problemas prácticos que se presentan en la construcción, desarrollo, soporte y evolución del software.

Las incumbencias propias de un ingeniero de software son variadas, comprenden el desarrollo de software de base -módulos de sistemas operativos, compiladores e intérpretes-, el desarrollo de software para


Página 15 de 89

sistemas distribuidos y la construcción de software de aplicación de la más diversa gama. 1.8 Ciclo de Vida del Software

Se ha definido un modelo denominado ciclo de vida de software, el cual

es una forma de plantear el desarrollo de proyectos de software. Las fases que lo comprenden son:

Análisis de requerimientos

Estadio en el cual, en base a un mandato, se reconoce el problema a resolver. Se estudia el sistema objeto, se hace una evaluación y un diagnóstico. Finalmente se especifican todos los requerimientos. Diseño

Como objetivo de la etapa, atendiendo los requerimientos del cliente, se modela un sistema que satisfaga las especificaciones derivadas del análisis de requerimientos. Desarrollo de requerimientos

Se traduce el diseño a programas computables. Prueba

Por un lado se valida al sistema informático propuesto ejecutando pruebas intensas de verificación de comportamiento, y por otro lado se analiza si el modelo a prueba satisface plenamente las especificaciones de requerimientos.

Implementación

En esta etapa se implementa el nuevo sistema informático a los efectos de que la organización demandante lo comience a utilizar.

Mantenimiento

Etapa final que tiene por objetivo ajustar el sistema a nuevos requerimientos y a cambios en el sistema objeto.


Página 16 de 89

2 Introducción a la Programación

2.1 Datos

Todo algoritmo utiliza datos. Los datos representan una abstracción de la realidad. Por ejemplo, para calcular el sueldo de un empleado se necesita realizar una abstracción de la información relativa al problema en estudio, tal como: función o cargo, antigüedad, cantidad de hijos, estudios cursados, días trabajados, etc.

Los datos son unidades atómicas de información, almacenadas en memoria, a partir de las cuales se realizan las operaciones determinadas por los programas. Todo dato presenta una serie de atributos que lo caracterizan. Por ejemplo, un dato que sea el sueldo percibido el último mes por una persona X tendrá los siguientes atributos:

• Nombre. Es un identificador, y es un nombre simbólico que se refiere a un dato determinado, es decir, un nombre para referirse a variables, funciones y cualquier otro objeto definido por el usuario en un programa. El dato del ejemplo podría tener por nombre "sueldo_último_mes" a los efectos de identificar a ese objeto concreto.

• Tipo. El tipo de una variable se refiere a la naturaleza de la información

que contiene. Determina la característica del contenido del objeto, es decir, la información que va a poder contener. En el ejemplo, el tipo del dato llamado "sueldo_último_mes" es numérico, porque así se expresa un número real.

Un tipo de dato se caracteriza por:

• Un dominio de posibles valores • Un modo común de representación de sus valores • Un conjunto de operadores asociados

• Valor. Es el contenido en sí del objeto, y está acorde al tipo definido. En

el ejemplo del sueldo será un valor concreto, tal como 345.78.


Página 17 de 89

345.78 22

Ana Gomez

Sueldo_ultimo_mestipo numérico

porcentaje_aumentotipo numérico

nombre-empleadotipo caracter

Extracto de una memoria de trabajo

2.1.1 Tipos de Datos Primitivos

2.1.1.1 Entero

Cualquier valor que pertenezca al conjunto de los números enteros Z { ...,-3, -2, -1, 0,1, 2, 3,...} y que este en un rango que el lenguaje pueda aceptar.

Ejemplo temperatura <- -2 humedad <- 78

2.1.1.2 Real

Cualquier valor perteneciente al conjunto de los números reales R {..., -7, ..., -2.2, ..., 0, ..., 14.4,..., 33, ...} y que este en un rango que el lenguaje pueda aceptar.

Ejemplo salario <- 178.23 saldo <- -55.98

La siguiente tabla muestra las características de los tipos de datos más comunes:

Tipo Tamaño Rango de valores booleano 1 bit falso, verdadero


Página 18 de 89

byte 8 bits -128...127 / 0..255 short 16 bits -32768 ... 32767 char 16 bits \u0000 ... \uffff int 32 bits -2147483648 ... 2147483647 long 64 bits -9,22E18 ... 9,22E18 float 32 bits reales de 32 bits double 64 bits reales de 64 bits

2.1.1.3 Caracter

Un caracter es un símbolo válido proveniente de un alfabeto. La concatenación de caracteres da por resultado una cadena o string.

Ejemplo apellido <- "Diaz Martinez" animal_peligroso <- "león de Kenia"

2.1.1.4 Lógico

Posibilitan la representación de dos estados posibles: F) falso y V) verdadero.

Ejemplo

vacío <- V asistirá <- F

2.1.2 Variables

Una variable es una identificación, asignada por el programador, a una dirección de memoria, donde se aloja un dato. Ejemplo Pi <- 3.14 IVA <- 21 institución <- "Universidad Nacional de Luján"

Una constante es un dato almacenado en una variable cuyo contenido no puede ser modificado durante la ejecución de un programa. 2.1.3 Declaración de Constantes y Variables

La declaración de una constante o una variable implica la asignación de un espacio de memoria de trabajo que estará asociado a ella. El tamaño dependerá del tipo de dato y lenguaje de programación con el que se trabaje.


Página 19 de 89

Al declarar una variable o una constante se liga al dato con un nombre o identificador, por el cual se accederá a tal posición de memoria de allí en más. El tipo de dato y el identificador de una variable son dos atributos asociados a ella.

Ciertos lenguajes de programación, junto con la buena práctica del oficio, exigen que todas las variables y constantes de un programa sean previamente declaradas antes de ser utilizadas.

Cuando se desea inicializar o modificar el valor de una variable se realiza una operación de asignación. Se la simboliza con los caracteres "<-". Asignar significa asociar un valor determinado a un identificador. Ejemplo vacio <- V saldo <- saldo_anterior + 500 frase <- "Hola" + " " + "Mundo !!!" resultado <- ((producción - fallados) ^2) - 678

Existe otro objeto denominado literal y es la forma como se escriben los valores de cada tipo. Ejemplo 26, 789, -9 son literales numéricos, y "hola mundo", "o" y "zeta" son literales de caracteres.

La asignación es una instrucción donde se asocia un valor a una variable. Del lado izquierdo siempre habrá una variable, mientras que del lado derecho de la asignación podrá haber un literal, otra variable ó una expresión.

Ejemplos cantidad_de_vehículos <- (6+8) / 2

Donde se evalúa 6 +8 y a lo obtenido se lo divide por 2. Finalmente al resultado se lo almacena en la variable cuyo identificador es cantidad_de_vehículos.

Las variables A, B, y C son de tipo lógico. A <- 12 < 5 En A se almacena el valor de verdad

falso B <- (7 <= 12) En B se almacena el valor de verdad

verdadero C <- 7 >= 7 En C se almacena el valor de verdad

verdadero

Con variables de tipo caracter empleado <- "Carlos Gomez" cantidad_empleados <- "veinte"


Página 20 de 89

2.1.4 Expresiones y Operadores

Una expresión es una combinación de elementos del lenguaje que al ser evaluados dan por resultado un valor. Este valor puede ser un número, un caracter, una cadena o cualquier otro tipo de dato. El tipo de una expresión está determinado por los tipos de las partes que la componen y la semántica de sus operadores.

A los efectos de realizar cálculos y operaciones sobre los datos es necesario contar con alguna forma de combinación que indique la acción a realizar. Se utiliza una simbología de operadores para formalizar tales cálculos y operaciones.

Un operador es un símbolo que transforma una variable o la combina de alguna otra manera con otra variable o literal. Por ejemplo, la siguiente expresión tiene dos operadores, '*' producto y '/' división:

(costo * 1.22)/desvio_mes;

2.1.4.1 Operadores Aritméticos

Son operadores que se aplican sobre datos numéricos y devuelven

igualmente un dato numérico.

Un operador es unario cuando solo tiene un operando, como por ejemplo los signos de los números (-7, +7, etc.) Un operador es binario cuando necesita dos operandos, como por ejemplo la suma (8 + 2). Todos los operandos son binarios excepto la notación de signos, que son unarios.

Ejemplos

Expresión Comentario 7 / 5 = 3.5 División real

7 div 2 = 3 División entera 7 mod 2 = 1 Resto de división entera

Operador Significado ** Potenciación + Signo más (unario) - Cambio de signo (unario) * Multiplicación / ó div División real y entera % ó mod resto de división (reales y enteros) + Suma - Resta


Página 21 de 89

2.1.4.2 Operadores Relacionales

Permiten realizar comparaciones de valores de tipo numérico o carácter.

Estos operadores sirven para expresar las condiciones en los algoritmos. Proporcionan resultados lógicos.

Operador Significado < Menor que > Mayor que = Igual que

<= Menor o igual que >= Mayor o igual que <> Distinto de

La sintaxis de las operaciones de comparación es:

expresión1 operador de relación expresión2

Una vez evaluada la expresión, se obtendrá un resultado que será Verdadero o Falso.

Dado X <- 12 y Y <- 5

Expresión Resultado X > Y Es Verdadero

(X-3) < (Y-2) Es Falso (X-4) >= (Y+3) Es verdadero

"A" > "B" Es verdadero "z" > "Z" Es verdadero

"uno" = "unos" Es falso "uno" < "unos" Es verdadero

2.1.4.3 Operadores sobre Cadenas

Los operadores tradicionales sobre cadenas son:

• Concatenación (+), operador que une dos cadenas para formar una nueva. Por ejemplo "hola" + " mundo" devolverá una nueva cadena que contenga "hola mundo".

• Multiplicación (*), operador que copia una cadena un número

determinado de veces. Por ejemplo "ba"'*2 nos devolverá la cadena "baba", '8'*3 devolverá "888".


Página 22 de 89

2.1.4.4 Operadores Lógicos

Son aquéllos que permiten la combinación de valores de verdad en una

expresión, que al ser evaluada devuelve un valor de verdad.

El resultado de las operaciones lógicas se determina a través de tablas de verdad correspondientes a cada operador.

Tabla de Verdad del Operador NOT

A NOT A V F F V

Donde A es una expresión booleana Tabla de Verdad del Operador de Conjunción AND

A B A AND B F F F F V F V F F V V V

Donde A y B son expresiones booleanas

Tabla de Verdad del Operador de Disyunción OR

A B A OR B F F F F V V V F V V V V


Tabla de Verdad del Operador de Disyunción Exclusiv a XOR

A B A XOR B F F F F V V V F V V V F


Ejemplos

Expresión Resultado


Página 23 de 89

(3 = 4) AND ( 6 < 7) Falso NOT (4 < 6) Falso

(3=4) EQV (5=6) Verdadero

2.1.4.5 Orden de Prioridad de las operaciones

Todas las subexpresiones entre paréntesis se evalúan primero. Las subexpresiones con paréntesis anidados se evalúan desde el centro hacia los extremos. Dentro de una expresión, los operadores se evalúan de la siguiente manera:

° Se analiza la expresión de izquierda a derecha.

° Si en la expresión existen paréntesis, lo que se encuentra dentro de estos se evalúan de izquierda a derecha según orden de prioridad de los mismos.

° Si en la expresión se encuentran más de un par de paréntesis, la evaluación se realiza comenzando con el paréntesis que se encuentra más a la izquierda en la expresión hasta llegar al par de paréntesis que se encuentra más a la derecha de la expresión.

2.1.4.6 Orden de Evaluación de los Operadores

Los operadores de una expresión se evalúan según el siguiente orden:

Tipo de Operador Significado Prioridad Exponenciación 1 Negación 2

Aritméticos Multiplicación/División 3 División entera 4 Módulo 5 Suma/Resta 6 Mayor 7 Mayor igual 7 Menor 7

De relación Menor igual 7 Igual 7


Página 24 de 89

Distinto 7 Complemento (NO- NOT) 8 Conjunción (Y -AND) 9

Lógicos Disyunción (O - OR) 10 Disyunción exclusiva (XOR) 11

De forma tradicional, la evaluación de operadores de igual orden se realiza siempre de izquierda a derecha. Ejemplo de evaluación - A ((4 + 2)^2 - 14) / 2 * 5

(6^2 - 14) / 2 * 5 (36 - 14) / 2 * 5

22 / 2 * 5 11 * 5

Resultado 55

Ejemplo de evaluación - B:

Siendo a = 10, b = 12, c = 13 y d =10

((a > b)or(a < c)) and ((a = c) or (a > = b)) F T F F

T F Resultado F

Ejemplo de evaluación - C

5 - 2 > 4 and not 0.5 = 1 / 2 5 - 2 > 4 and not 0.5 = 0.5

3 > 4 and not 0.5 = 0.5 falso and not 0.5 = 0.5

falso and not cierto falso and falso

Resultado FALSO 2.1.5 Funciones del Lenguaje

Una función es un conjunto de declaraciones, definiciones, expresiones y sentencias que realizan una tarea específica. Cada función tiene la misión de realizar un algoritmo determinado a partir de datos de entrada, llamados parámetros o argumentos, obteniendo un resultado o valor de retorno.

En los lenguajes de programación, sus diseñadores incorporan varias funciones predefinidas. Los programadores pueden hacer uso de tales funciones del lenguaje e incorporarlas a sus programas. Existen distintas


Página 25 de 89

categorías de funciones: matemáticas, de cadenas de caracteres, de fecha, de entrada y salida, etc.

La sintaxis general de una función es:

nombre_función(argumento1,..., argumenton).

Ejemplos de funciones del lenguaje sobre tipos numéricos:

Nombre Significado Ejemplos

abs Calcula el valor absoluto abs(-5) abs(x)

int Devuelve la parte entera de un número real

int(-2.8) int(12.1)

rnd Genera un número aleatorio (mayor a 0 y menor a 1)

round Redondea un dato a un número determinado de cifras

round(2.1) round(7.125, 2)

cos Calcula el coseno del ángulo n (en radianes)

cos(n)

sin Calcula el seno del ángulo n (en radianes)

sin(n)

sqrt Calcula la raíz cuadrada de n sqrt(n) Ejemplos de funciones del lenguaje que operan sobre cadenas:

Nombre Significado Ejemplos Resultados length Calcula el largo de una cadena. length("Hola mundo") 10

substr Extrae una subcadena de una cadena de caracteres.

substr(cadena,2,3) substr(("malandro”,2,3)

ala

chr Retorna el caracter ASCII equivalente al número decimal brindado como argumento

chr(65) A

lower Devuelve en minúsculas todas las letras de una cadena

lower(cadena) lower("MaLANdro")

Malandro

upper Devuelve en mayúsculas todas las letras de una cadena

upper(cadena) upper("malandro”)

MALANDRO

Nota: Las funciones detalladas anteriormente son a título informativo. El nombre exacto y la sintaxis de cada función dependerá del lenguaje de programación a utilizar. Se aconseja verificar en el manual del lenguaje las características de una función predefinida a utilizar.


Página 26 de 89

Tercera Parte

3 Programación Estructurada

3.1 Estructuras de Control Los programas para computadoras deben estar escritos con un alto grado

de estructuración, lo cual les permite ser fácilmente comprensibles en actividades tales como pruebas, mantenimiento y modificación de los mismos. Mediante la programación estructurada todas las bifurcaciones de control de un programa se encuentran estandarizadas, de forma tal que es posible leerlos desde su inicio hasta su final en forma continua, sin tener que saltar de un lugar a otro del programa siguiendo el rastro de la lógica establecida por el programador.

Los lenguajes de programación tienen un conjunto mínimo de instrucciones que permiten especificar un algoritmo, y son:

1. Secuencia : Sucesión simple de dos o mas operaciones. 2. Selección : Bifurcación condicional de una o más operaciones 3. Iteracción : Repetición de un conjunto de instrucciones mientras se

cumpla una condición.

Estos tres tipos de estructuras lógicas de control pueden ser combinadas para producir programas que manejen cualquier tarea de procesamiento de información.

Un programa estructurado está compuesto de segmentos o bloques , los cuales pueden estar constituidos por unas pocas instrucciones o por una página o más de codificación. Cada segmento tiene solamente una entrada y una salida, estos segmentos, asumiendo que no poseen lazos infinitos y no tienen instrucciones que jamás se ejecuten, se denominan programas propios. Cuando varios programas propios se combinan utilizando las tres estructuras básicas de control mencionadas anteriormente, el resultado es también un programa propio.

La programación estructurada esta basada en el Teorema de la Estructura, el cual establece que cualquier programa propio (un programa con una entrada y una salida exclusivamente) es equivalente a un programa que contiene solamente las estructuras lógicas mencionadas anteriormente.

Una característica importante en un programa estructurado es que puede ser leído en secuencia, desde el comienzo hasta el final sin perder la continuidad de la tarea que cumple el programa, lo contrario de lo que ocurre con otros estilos de programación. Esto es importante debido a que, es mucho más fácil comprender completamente el trabajo que realiza una función determinada, si todas las instrucciones que influyen en su acción están físicamente contiguas y


Página 27 de 89

encerradas por un bloque. La facilidad de lectura, de comienzo a fin, es una consecuencia de utilizar solamente tres estructuras de control y de eliminar la instrucción de desvío de flujo de control, excepto en circunstancias muy especiales tales como la simulación de una estructura lógica de control en un lenguaje de programación que no la posea.

Como ventajas del uso de la programación estructurada se pueden citar los siguientes ítems:

° Un programa escrito de acuerdo a las reglas de la programación estructurada no solamente tendrá una estructura, sino también una excelente presentación.

° Un programa escrito de esta forma tiende a ser mucho más fácil de comprender que programas escritos en otros estilos. La facilidad de comprensión del contenido de un programa puede facilitar el chequeo de la codificación y reducir el tiempo de prueba y depuración de programas. Esto último es cierto parcialmente, debido a que la programación estructurada concentra los errores en uno de los factores más generador de fallas en programación: la lógica.

° Un programa que es fácil para leer y el cual está compuesto de segmentos bien definidos tiende a ser simple, rápido y menos expuesto a mantenimiento. Estos beneficios derivan en parte del hecho que, aunque el programa tenga una extensión significativa, en documentación tiende siempre a estar al día, esto no suele suceder con los métodos convencionales de programación.

El teorema de la estructura establece que un programa propio puede ser

escrito utilizando solamente las siguientes estructuras lógicas de control: secuencia, selección e iteración.

Un programa se define como propio si cumple con los dos requerimientos siguientes:

° Tiene exactamente una entrada y una salida para control del programa. ° Existen caminos seguibles desde la entrada hasta la salida que

conducen por cada parte del programa, es decir, no existen lazos infinitos ni instrucciones que no se ejecutan.

Las tres estructuras lógicas de control básicas, se definen de la siguiente

forma:


Página 28 de 89

3.1.1 Secuencia Es la estructura de control más simple y representa una lista ó secuencia de instrucciones. En términos de diagrama la secuencia es representada por una instrucción después de la otra, como se muestra a continuación.

Inicio

Leer num1, num2

suma <- num1 + num2

dif <- num1 - num2

Escribir("SUMA: ", suma)

Escribir("DIFERENCIA: ", dif)

Fin

3.1.2 Selección

Se basa en ejecutar una de dos acciones tomando la decisión en base al resultado de evaluar una condición. Esta estructura de control es denominada usualmente condicional.. La representación en forma de diagrama de flujo de esta estructura lógica de control se muestra a continuación:

V FCondición

Instrucción 1

....

Instrucción n

Instrucción 1

....

Instrucción n

Donde V y F son bloques a ejecutar en caso de que la evaluación de la condición sea verdadero o falso.

3.1.3 Iteración Esta estructura es utilizada a los efectos que se repita la ejecución de un conjunto de instrucciones mientras se cumpla una condición. Generalmente a esta estructura se le conoce como Mientras-Hacer y su representación se muestra a continuación:


Página 29 de 89

Mientras <condición> hacer

Instrucciones

donde el resultado de la condición a evaluar determinará si se ejecuta el bloque de instrucciones (en caso de resultar verdadero) o se continua con la siguiente línea de programa.

3.2 Estructogramas o Diagramas Chapín

Los diagramas de Chapin (también conocidas como diagramas de Nassi-Schneiderman) describen los procedimientos usados para recibir, procesar, y transmitir información. Los diagramas proporcionan toda la lógica necesaria para que programadores puedan escribir programas estructurados en cualquier lenguaje de programación o a los efectos de documentar procedimientos específicos.

El modelo de diagramas fue desarrollado por Isaac Nassi y Ben Shneiderman, publicándose en el año 1973. Corresponden a las normas DIN 66261 e ISO/IEC 8631:1989. Dado que muestran las estructuras de un programa, también se denominan "estructogramas".

El concepto es simple: cada bloque (o secuencia de acciones) se

representa dentro de un rectángulo; cada estructura utiliza una forma de representación particular, pudiendo a su vez encerrar otros bloques.

En los diagramas NS existen seis estructuras: Secuencial, Decisión (si

condicional), Selección, Para, Mientras y Repetir.


Página 30 de 89

seccion = 1

V F

Escribir("Elnúmero es impar")

antiguedad <-sueldo*10/100

años < 5

V F

sueldo <- basico + 250antiguedad = 0


Leer seccion, años

basico <- 800

sueldo <- basico + 120

total <- sueldo + antiguedad

escribir("El monto a abonar es ", total)

Inicio

Fin

Ejemplo de diagrama de Chapín


Página 31 de 89

3.2.1 Escritura de Programas La utilización de la identación es importante debido a que, cuando se es consistente en su utilización, facilita la lectura de los programas al mostrar en una forma ordenada las relaciones existentes entre las distintas instrucciones. A continuación pueden observarse dos programas, los cuales realizan la misma función, pero el de la derecha es más fácil de comprender.

Sin identación Con identación PRINT "Ingrese seccion del empleado: "; INPUT seccion PRINT "Ingrese anios de antiguedad : "; INPUT anios basico = 800 IF seccion = 1 THEN sueldo = basico + 120 IF anios < 5 THEN antiguedad = sueldo * 10 / 100 ELSE antiguedad = sueldo * 20 / 100 END IF ELSE sueldo = basico + 250 antiguedad = 0 END IF total = sueldo + antiguedad PRINT "El monto a abonar es : "; total END.

PRINT "Ingrese seccion del empleado: "; INPUT seccion PRINT "Ingrese anios de antiguedad : "; INPUT anios basico = 800 IF seccion = 1 THEN sueldo = basico + 120 IF anios < 5 THEN antiguedad = sueldo * 10 / 100 ELSE antiguedad = sueldo * 20 / 100 END IF ELSE sueldo = basico + 250 antiguedad = 0 END IF total = sueldo + antigüedad PRINT "El monto a abonar es : "; total END.

Adicionalmente se recomienda la inserción de comentarios en los programas. Tales citas ayudan a los programadores a identificar fácilmente la misión de las partes con la finalidad de facilitar su mantenimiento.

3.2.1.1 Normas de Identación

Las siguientes son sugerencias para el desarrollo de una política de

identación en un programa:


Página 32 de 89

a) Se obtiene consistencia si todas las instrucciones de un mismo nivel

comienzan en una misma columna. b) En los lenguajes en que se hagan declaraciones sobre las variables a

utilizar, la información quedará mas claramente representada si los atributos declarados se alinean en forma vertical.

c) El uso de líneas vacías ayuda a mostrar con mas claridad las relaciones existentes entre distintos ítems agrupados en las declaraciones

d) Las instrucciones son mucho mas fáciles de localizar y de cambiar si no se escribe mas de una instrucción por línea.

e) La visión de control de las estructuras lógicas o de los bloques se clarifica si las instrucciones controladas son identadas por alguna cantidad constante de espacios. Se sugiere una identación de tres espacios.

3.2.2 Entrada y Salida de Información

Toda operación que realice una computadora va a estar incluida en una de las siguientes categorías:

° Recibir entradas . Aceptar información proveniente del mundo exterior.

° Generar salidas . brindar información al mundo exterior.

° Procesar información . Realizar operaciones sobre los datos.

° Almacenar información . En cualquier dispositivo con que opere.

En base a las cuatro operaciones básicas enunciadas, las computadoras realizan todas sus funciones.

Las operaciones de entrada permiten leer determinados datos -generalmente ingresados por teclado- y asignarlos a determinadas variables definidas por el programador. La operación de entrada se conoce como operación de Lectura o read.

La salida de información es soportada por dispositivos de salida (monitor, impresora, etc). La operación de salida se denomina escritura o Write.

Generalmente, en la escritura de algoritmos las acciones de lectura y escritura se representan de la siguiente manera:

° leer ( Nom_variable )

° escribir (lista de variables de salida)


Página 33 de 89

Ejemplo de ingreso y salida de datos en una especificación de cálculo de liquidación de horas extras, detallada en pseudocódigo:

Inicio Leer(horas trabajadas) Leer(valor_de_la_hora_extra) liquidación <- horas:trabajadas * valor_de_la_hora_extra Escribir(liquidación) Fin

Opcionalmente, en el ingreso de datos por teclado puede definirse una lista de variables como parámetro de la orden leer.

Leer (dato1, dato2, dato3)

3.2.2.1 Ejemplo:

Ingresando dos números, mostrar por pantalla su suma y su diferencia.

Pseudocódigo

Inicio Leer(num1, num2) suma <- num1 + num2 dif <- num1 - num2 Escribir("SUMA: ", suma) Escribir("DIFERENCIA: ", dif) Fin

Diagrama NS

Inicio

Leer num1, num2

suma <- num1 + num2

dif <- num1 - num2

Escribir("SUMA: ", suma)

Escribir("DIFERENCIA: ", dif)

Fin


Página 34 de 89

Ejercitación en Lenguaje Qbasic

Se utiliza la instrucción print cuando se quiere enviar un mensaje a la salida estándar (generalmente el monitor).

Print "Esto es un mensaje"; En el ejemplo, se muestra la cadena "Esto es un mensaje" por pantalla.

Alfa = 345.2 beta = 8 resultado = alfa * beta print "El resultado de multiplicar alfa por beta es "; resultado

Aquí el mensaje contiene términos y variables de memoria (alfa, beta y resultado). En el siguiente ejemplo se solicitará al operador que ingrese un dato. El ingreso se solicita con la instrucción input , y se almacena el dato en la variable d.

print "Ingrese una distancia en centimetros: "; input d r = d / 2.54; print d; “centímetros equivalen a “;r; “pulgadas"


Página 35 de 89

3.3 Estructura Secuencial

La estructura secuencial corresponde a un conjunto de instrucciones que se ejecutan en una secuencia predeterminada y fija, de arriba hacía abajo.

El diagrama Chapin o NS (Nassi-Schneiderman) de la estructura secuencial

es:

Instrucción 1

Instrucción 2

Instrucción 3

...

Instrucción n

3.3.1 Ejemplo 1

Construir un algoritmo para pasar una temperatura dada en grados centígrados a grados Fahrenheit. La fórmula para hacer la conversión es: F = ( 9 * C ) / 5 + 32; donde C es el valor en grados centígrados y F en grados Fahrenheit.

Inicio

Leer temperatura en grados centígrados y almacenarlo en TC TF <- ( 9 * TC ) / 5 + 32;

Escribir("La temperatura equivalente en grados Fahrenheit es:",TF) Fin Representación del pseudocódigo en un diagrama NS

Inicio

Leer temperatura en grados centígrados y almacenarlo en TC

TF <- ( 9 * TC ) / 5 + 32;

Escribir("La temperatura equivalente en grados Fahrenheit es:",TF)

Fin

3.3.2 Ejemplo 2


Página 36 de 89

Introducir dos números a y b, con partes decimales, luego obtener la suma de las partes decimales. Por ejemplo : a=16.12 y b=7.33 entonces deberá obtener s = 0.12 + 0.33 = 0.45

Diagrama NS

Inicio

Fin

Leer pn, sn

r = (pn - int(pn)) + (sn - int(sn))

Escribir("El resultado es", r)


print "Ingrese el primer número : "; input pn print "Ingrese el segundo número: "; input sn r = (pn - int(pn)) + (sn - int(sn)); print "La suma de las partes decimales de”;pn;“y”;sn;“es”;r


Página 37 de 89

3.4 Estructura de Selección 3.4.1 Decisiones

Hasta ahora se han visto algoritmos en los cuales se ingresan ciertos datos, luego se hacen algunas operaciones aritméticas y finalmente se muestran los resultados por la pantalla o la impresora. En realidad, esta es una utilización muy pobre de la computadora, como si solamente se tratara de una calculadora una poco más sofisticada, con la única ventaja de permitirnos construir un programa una vez y posteriormente, utilizarlo todas las veces que sea necesario con distintos grupos de datos.

Como se vio anteriormente, una característica importante que distingue a una computadora de otras máquinas es la posibilidad de ejecutar operaciones lógicas, es decir que puede evaluar expresiones del tipo: 1) total > 50 2) alfa < mo 3) be4 <- jota + 6 4) pepe - 4 = alfa + beta

De la evaluación de este tipo de operaciones se pueden obtener dos resultados posibles: verdadero (V) o falso (F).

En el primer ejemplo, la computadora va a ir a buscar el número que esté almacenado en la variable total y va a verificar si ese dato es mayor que 50, en cuyo caso el resultado de la expresión será verdadera; de otra manera, si el número es igual a 50 o menor, el resultado de la expresión será falso. En el segundo ejemplo la computadora consultará los contenidos de las variables alfa y mo, y verificará si se cumple o no que el número almacenado en alfa es menor que el almacenado en mo.

Los ejemplos tres y cuatro involucran operaciones aritméticas, en estos casos la computadora consultará los contenidos de las variables en juego, efectuará las operaciones aritméticas que correspondan y luego comparará los resultados, verificando si cumplen o no la condición indicada.

Es posible también hacer que la computadora evalúe expresiones más complejas, por ejemplo, podemos desear verificar si el contenido de la variable samo es mayor que 45 pero menor que 70, lo que podemos expresar matemáticamente como 45 < samo < 70, pero en realidad esta forma de expresarlo está encubriendo otro operador lógico. En informática escribiremos esta expresión como:


Página 38 de 89

samo > 45 AND samo < 70 en la que el símbolo AND representa al operador lógico "y" (conjunción). ¿Cómo se evaluará esta expresión?. Primero la computadora obtendrá los resultados a ambos lados del AND; luego operará con esos dos valores para obtener el valor de verdad de AND. De forma similar se puede trabajar con el operador lógico OR (disyunción). Por lo general se dispone también de las operaciones de negación, disyunción exclusiva, implicación y equivalencia. Esta capacidad de evaluar expresiones lógicas se utiliza para hacer que la computadora tome decisiones de las instrucciones a ejecutar en base al resultado obtenido. 3.4.2 Estructura Condicional Simple

En el caso mas sencillo, se le indica a la computadora que ejecute un cierto grupo de instrucciones si se cumple una cierta condición:

Si (condición) entonces hacer

(instrucciones) Fin Si

Llamaremos "estructura de decisión" o "estructura condicional simple" a este bloque de instrucciones, la computadora verificará si se cumple la condición indicada, en cuyo caso pasará a ejecutar las instrucciones que se detallaron, en cambio si la condición no se cumple no las ejecutará y pasará a las instrucciones que siguen en el algoritmo. A este caso podemos describirlo con la frase "hacer si se cumple". El diagrama Chapin para representar a una estructura condicional simple es el siguiente:

V FCondición

Instrucción 1

....

Instrucción n

Ejemplo en pseudocódigo

Si (gama > 22) entonces hacer gama <- gama /3; Fin Si


Página 39 de 89

V Fgama > 22

gama <- gama / 3

....

.....

3.4.2.1 Ejemplo

Suponga que se vende un artículo cuyo precio unitario es de $1235.-, se

desea un algoritmo al cual se le dé la cantidad vendida e imprima el monto de la venta, teniendo en cuenta que si se venden más de 12 unidades se efectúa un descuento de $1700.-; la estructura de decisión debe resolver una situación que puede describirse como sigue: "comprobar si se vendieron mas de 12 unidades, en ese caso, descontarle al monto $1700.-", : Si cantidad > 12 entonces hacer monto <- monto – 1700 Fin Si Agregando las instrucciones de entrada, salida y cálculo, obtenemos el algoritmo completo que resuelve el problema:

Inicio Leer(cantidad) monto <- cantidad * 1235 Si cantidad > 12 entonces hacer

monto <- monto - 1700 Fin Si Escribir(monto) Fin


La instrucción de decisión se expresa con el término if, seguido de una condición y finalmente un bloque a ejecutar en caso de que la evaluación de la condición de verdadero. El bloque puede contener n instrucciones y termina con la expresión endif. print "Ingrese cantidad a adquirir: "; input c monto = c * 1235; if c > 12 then


Página 40 de 89

monto = monto – 1700 endif print "El monto es” ; monto

3.4.3 Estructura de Selección Compuesta

En el caso más general, se le indicará a la computadora que ejecute un determinado grupo de instrucciones si el resultado de una evaluación es V, u otro grupo si el resultado es F. Si (condición) entonces hacer (instrucciones) de lo contrario hacer (instrucciones) Fin Si

En diagrama chapín la estructura condicional compuesta se representa:

V FCondición

Instrucción 1

....

Instrucción n

Instrucción 1

....

Instrucción n

Si (gama > 22) entonces hacer gama = gama /3; de lo contrario hacer

escribir("gama no es mayor a 22")

Fin Si

3.4.3.1 Ejemplo 1

Supongamos que una empresa vende un cierto producto a un precio de $215.- la unidad, pero si el cliente compra mas de 100 unidades, el precio se rebaja a $197.- la unidad:


Página 41 de 89

Si (C > 100) entonces hacer P <- 197 de lo contrario hacer P <- 215 Fin Si

Si se desea un programa completo al cual se le ingrese la cantidad vendida e imprima el monto de la misma, falta agregar las instrucciones correspondientes a la entrada, salida y cálculos:

Inicio Leer(cantidad)

Si (cantidad > 100) entonces hacer precio <- 197 de lo contrario precio <- 215 Fin Si monto <- cantidad * precio Escribir(monto) Fin

En diagrama NS

V Fcantidad > 100

precio <- 197

....

.....

Leer cantidad

precio <- 215

monto <- cantidad * precio

escribir monto

inicio

Fin


En el presente ejemplo se utiliza una estructura condicional compuesta. La alternativa "de lo contrario" se expresa utilizando el término else seguido de un bloque de instrucciones a ejecutar. print "Ingrese cantidad : " input c


Página 42 de 89

if c > 100 precio = 197 else precio = 215 monto = c * precio print "El monto es” ;monto End.

3.4.3.2 Ejemplo 2

Supongamos que se nos presenta el siguiente problema: "Ingresar un

número entero N y mostrar por pantalla un cartel indicando si es par o impar". Para saber si un número N es par es suficiente comprobar si es divisible por dos, o lo que es lo mismo, que el cociente N / 2 produzca como resultado un número entero. Para ello podemos usar la función "parte entera" que está disponible en la mayoría de los lenguajes de computación, esta función, la indicaremos: variable1 <- int(variable2)

Permite almacenar en variable1 la parte entera del número guardado en variable2, o sea que si en variable2 hay un 23.456 en variable1 quedará almacenado un 23.

Por otra parte, se observa que si se almacena en una variable cociente el resultado de la división entre número y 2, y en otra llamada entero la parte entera de cociente , tendremos que si número es divisible por 2, el contenido de entero será igual al de cociente . Teniendo en cuenta ello, proponemos la siguiente solución para el problema planteado:


Página 43 de 89

Inicio

Fin

Leer numero

cociente = numero / 2

entero = int(cociente)

entero = cociente

V F

Escribir("Elnúmero es par")


también puede hacerse:

Inicio

Fin

Leer numero

cociente = numero / 2

entero = int(cociente)

fraccion = 0

V F



fraccion = cociente - entero

o también :


Página 44 de 89

Inicio

Fin

Leer numero

numero/2 = int(numero/2)

V F



3.4.4 Selecciones Anidadas

Frecuentemente es necesario efectuar un proceso de decisión dentro de otro, es decir, según la salida que tenga la primera condición, se debe efectuar una segunda instrucción de decisión, en forma general, esto puede presentarse como sigue:

Si (condición 1) entonces hacer (I) (instrucciones) de lo contrario (instrucciones)

Si (condición 2) entonces hacer (II) (instrucciones) de lo contrario (instrucciones) Fin Si

Fin Si

Llamamos "selecciones anidadas", a esta estructura. Esta disposición de instrucciones puede ser mucho mas compleja, dado que las instrucciones Si marcadas con (I) y (II) pueden contener a su vez otras estructuras de selección dentro de sus respectivas salidas por verdadero y falso. Decisiones anidadas graficadas en un diagrama NS


Página 45 de 89

Condicion 1

V F


Instrucciones

Condición 2

V FInstrucciones

Instrucciones

3.4.4.1 Ejemplo

Si se nos presenta el siguiente problema: "Una empresa de USA paga a sus

empleados un sueldo básico de U$S 800.-, más un adicional que se calcula de la siguiente manera:

-Los que trabajan en la sección 1 cobran $ 120.- más, y sobre el total un adicional por antigüedad del 10 % si tienen menos de 5 años, y del 20 % si tienen 5 años o más. -Los que trabajan en la sección 2 cobran $ 250.- más, pero no cobran adicional por antigüedad.

Preparar un algoritmo para ingresarle el número de sección y la antigüedad,

y que muestre por pantalla cuanto cobra el empleado.

En este caso la pregunta por la antigüedad depende de la sección en que trabaje, una posible solución podría ser:


Página 46 de 89

seccion = 1

V F



años < 5

V F

sueldo <- basico + 250antiguedad = 0


Leer seccion, años

basico <- 800

sueldo <- basico + 120

total <- sueldo + antiguedad

escribir("El monto a abonar es ", total)

Inicio

Fin

Ejercitación en Lenguaje Qbasic print "Ingrese seccion del empleado: "; input seccion print "Ingrese años de antiguedad : "; input anios basico = 800; if seccion = 1 then sueldo = basico + 120 if($anios < 5)


Página 47 de 89

antiguedad = sueldo*10/100 else antiguedad = sueldo*20/100 endif else sueldo = basico + 250 antiguedad = 0 endif total = sueldo + antiguedad print "El monto a abonar es”;total End

3.4.5 Menú de Opciones

Un mismo algoritmo puede ejecutar distintos procesos alternativos, de tal forma que el usuario al ejecutarlo decida cuál de esas tareas es la que necesita en ese momento. En este caso el programa debe mostrar al usuario cual es el listado de tareas que puede hacer, y debe permitir que el operador opte por una de ellas; a este listado se lo denomina "menú". En el método más sencillo las opciones se presentan numeradas, de forma que el usuario pueda indicarlas por el número, éste se ingresa y se almacena en una variable, ejecutándose las instrucciones que correspondan, en síntesis, la secuencia de tareas es la siguiente: 1) Mostrar por pantalla el menú de opciones. 2) Ingresar el número de opción digitado por el usuario. 3) Según sea el número ingresado, ejecutar el procedimiento correspondiente.

Ejemplo

Supongamos que se desea un algoritmo para obtener las superficies de

distintas figuras geométricas, para simplificar consideraremos solo tres: triángulo, rectángulo y círculo. Las fórmulas respectivas son:

stT <- (base * altura) /2 srR <- base * altura sc <- 3.1416 * radio ^2

Cuando ejecute el programa, el operador tiene que poder elegir que superficie calcular, para ello el programa muestra el menú de opciones:

Escribir(" Elija una opción")


Página 48 de 89

Escribir(" 1. Triángulo") Escribir(" 2. Rectángulo") Escribir(" 3. Círculo")

Cuando aparezca este menú en la pantalla, el operador digitará un número, que puede ser 1, 2 ó 3, cualquiera sea la respuesta, el programa la almacenará en una variable:

Ingresar una opción

Una vez ingresado el número, el algoritmo ejecutará el procedimiento que corresponda al número ingresado, para ello deberá ejecutar instrucciones de decisión en las cuales compare el número almacenado dentro de la variable Opción:

Si opción = 1 entonces hacer Ejecutar TRIANGULO Fin Si Si opción = 2 entonces hacer

Ejecutar RECTANGULO Fin Si Si opción = 3 entonces hacer Ejecutar CIRCULO Fin Si

Donde cada uno de estos procedimientos ingresa los datos necesarios, y

efectúa los cálculos; el siguiente es un listado con el algoritmo completo:

Principio

Escribir(" Elija una opción") Escribir(" 1. Triángulo") Escribir(" 2. Rectángulo") Escribir(" 3. Círculo") Leer(opcion) Si opción = 1 entonces hacer Ejecutar TRIANGULO Fin Si Si opción = 2 entonces hacer Ejecutar RECTANGULO Fin Si Si opción = 3 entonces hacer


Página 49 de 89

Ejecutar CIRCULO Fin Si

Escribir("Superficie":, superficie)

Fin

Procedimiento TRIANGULO Leer(base, altura) superficie <- base * altura /2

Fin TRIANGULO Procedimiento RECTANGULO

Leer(base, altura) superficie <- base * altura

Fin RECTANGULO Procedimiento CIRCULO

Leer(radio) superficie <- 3.1416 * radio ^2

Fin CIRCULO

Obsérvese que en este algoritmo, si el usuario por error digita un número mayor que 3, no se ejecutará ningún procedimiento, y al final se pretenderá mostrar el contenido de la variable superficie, en la cual no hay nada almacenado. Esta situación puede salvarse si se agrega una decisión como la siguiente:

Si opcion > 3 entonces hacer Ejecutar CIRCULO Fin Si


DECLARE SUB circulo (superficie!) DECLARE SUB rectangulo (superficie!) DECLARE SUB triangulo (superficie!) opcion = 0: superficie = 0 PRINT "Elija una opcion" PRINT "1. Triangulo" PRINT "2. Rectangulo" PRINT "3. Circulo" INPUT opcion IF opcion = 1 THEN CALL triangulo(superficie) END IF IF opcion = 2 THEN


Página 50 de 89

CALL rectangulo(superficie) END IF IF opcion = 3 THEN CALL circulo(superficie) END IF PRINT "La superficie es"; superficie SUB circulo (superficie) PRINT "Ingrese radio :"; INPUT radio superficie = 3.1416 * (radio ^ 2) END SUB SUB rectangulo (superficie) PRINT "Ingrese base :"; INPUT base1 PRINT "Ingrese altura :"; INPUT altura superficie = base1 * altura END SUB SUB triangulo (superficie) PRINT " Ingrese la altura :"; INPUT altura PRINT " Ingrese la base :"; INPUT base1 Superficie = base1 * altura / 2 END SUB

3.4.6 Estructura de Selección Múltiple

Esta forma es útil cuando se tiene que elegir entre más de dos opciones, se denomina de selección múltiple. En esta estructura, una variable de control puede tomar distintos valores. Según el caso, se ejecutan distintas acciones.


Página 51 de 89

Alternativa 1

Alternativa 2 y 3

Alternativa n

De locontrario

Evaluar Selector

Instrucciones Instrucciones Instrucciones Instrucciones

Reglas:

1. La expresión <selector> se evalúa y se compara con las constantes que expresan cada caso posible; las constantes son listas de uno o más valores de <selector>. Ejecutadas la(s) <instrucciones>, el control se pasa a la primera instrucción a continuación del Fin del selector.

2. La alternativa "de lo contrario" es opcional. 3. Si el valor de <selector> no está comprendido en ninguna lista de

constantes y no existe la alternativa "de lo contrario", se sigue con el flujo del programa. En caso de existir la cláusula "de lo contrario" se ejecutan las instrucciones correspondientes a tal bloque.

Diagrama NS del cuerpo principal del programa menú utilizando una

estructura de selección múltiple.

Fin

Inicio

Escribir("Elija una opcion"; "1. Triangulo";

"2. Rectangulo";"3. Circulo";)

Leer(opcion)

Evaluar opcion

Ejecutar(triangulo)

Alternativa 1

Ejecutar(rectangulo)

Escribir("La superficie es ",superficie")

Alternativa 2

Ejecutar(circulo)

Alternativa 3

De locontrario


Página 52 de 89


Página 53 de 89

3.5 Estructura Repetitiva o Iterativa La estructura repetitiva es utilizada cuando se necesita que un conjunto de instrucciones (bloque) se ejecuten un cierto número finito de veces. Un bucle, lazo o ciclo, forma básica de una estructura iterativa, se compone de dos partes: a) una condición, y b) un cuerpo o bloque.

Mientras x sea distinto de 3 hacer <- condición{

instrucción 1instrucción 2 <- bloque.......................instrucción n

}Fin Mientras

Estructura

de control

Básicamente existen dos tipos de estructuras repetitivas o iterativas: a) donde el número de ciclos a ejecutar el bloque está perfectamente establecido, y b) donde el número de ciclos que se ejecutará el bloque se determina por la evaluación de una cierta condición.

Ejemplo de número de ciclos preestablecidos Para n igual 0 hasta n igual 10 -incremento 1- hacer

Mostrar n^n N= n + 1 Fin Para Ejemplo de número de ciclos dependientes de una condición suma <- 0 contador <- 0 n <- 1 Mientras n sea mayor a 0 hacer Ingrese un número ( 0 finaliza):, número_ingresado Si número_ingresado es menor o igual a 0 hacer promedio <- suma / contador mostrar promedio De lo contrario hacer suma <- suma + número_ingresado contador= contador + 1 Fin Si Fin Mientras Las estructuras iterativas más populares son

° Mientras ° Repetir


Página 54 de 89

° Repetir - Hasta ° Para

3.5.1 Estructura Mientras

La estructura repetitiva Mientras es aquella en la que el número de iteraciones no se conoce por anticipado y el cuerpo del ciclo o bloque se ejecuta repetidamente mientras que una condición sea verdadera .

Su sintaxis es : Mientras <condición> hacer instrucción 1 instrucción 2

....................... instrucción n Fin Mientras El diagrama Chapin o NS (Nassi-Schneiderman) de la estructura Mientras es:


Instrucciones

Explicación del modo de funcionamiento :

° La expresión que conforma la condición se evalúa antes y después de cada ejecución de las instrucciones comprendidas por el bloque. Si la condición da por resultado verdadero, se ejecuta el bloque, y si es falsa, el control pasa a la instrucción siguiente al bloque

° Si al evaluar la condición por primera vez, se determina que el

resultado es falso, entonces no se ingresa al bloque y el control pasa a la instrucción siguiente al bloque. Es decir que el bloque no se ejecutará nunca.


Página 55 de 89

° Si alguno de los elementos que componen la expresión de evaluación no se modificase, y la expresión hubiese arrojado -previamente- verdadero en su evaluación. Se ha ingresado en un ciclo infinito, del cual nunca se saldrá. Tales ciclos deben evitarse.

Ejemplo:

Construir un algoritmo para calcular e imprimir la suma de los números enteros comprendidos entre -27 y 34, ambos inclusive.

Mientras numero <= 34 hacer

suma <- suma + número

numero <- numero + 1

Escribir(suma)

Fin

suma <- 0

numero <- -27

Inicio

Ejercitación en Lenguaje Qbasic Nótese que la orden mientras se codifica con el término while. Al bloque se lo delimita con el término wend. Programa que muestra el menor número natural ingresado por teclado. i = 0 iterar = 1 mayor = 0 WHILE iterar = 1 PRINT "Ingrese un numero natural (0 es fin):"; INPUT i


Página 56 de 89

IF i <= 0 THEN iterar = 0 PRINT "El mayor numero ingresado es "; mayor ELSE IF i > mayor THEN mayor = i PRINT "Fin del programa" END IF END IF WEND END

3.5.2 Estructura Repetir

La instrucción Repetir permite que se ejecute un bloque de instrucciones y luego se evalúe una condición a los efectos de ejecutar nuevamente el bloque -en caso de resultar verdadera- o continuar con la próxima instrucción siguiente al bloque

Su sintaxis es :

Hacer instrucción 1 instrucción 2

....................... instrucción n Repetir Mientras <condición>

El diagrama Chapin de la estructura Repetir es:


Página 57 de 89


Instrucciones


° La condición se evalúa al final del bloque, después de ejecutarse todas las instrucciones contenidas.

° Si o si siempre se ejecuta al menos una vez el bloque. ° Si el resultado de la evaluación de la condición da verdadero, se

continua iterando, de lo contrario se continua con la próxima instrucción de programa.

Ejercitación en Lenguaje Qbasic Se utiliza el término do para indicar el comienzo de una estructura Repetir, a continuación se inserta el bloque de instrucciones. Al final del bloque se inserta la instrucción de evaluación que corresponde al término Loop while . Programa que .. i = 0 iterar = 1 do if i = 0 then iterar = 0 print I End if Loop while iterar = o


Página 58 de 89

3.5.3 Estructura Repetir - Hasta

La instrucción Repetir-Hasta permite iterar por un bloque de instrucciones hasta que la evaluación de una condición da verdadero.

Su sintaxis es :

Haga instrucción 1 instrucción 2

....................... instrucción n Repetir Hasta <condición>

El diagrama de la estructura Repetir-Hasta es:

Repetir Hasta <condición> hacer

Instrucciones


° La condición se evalúa al final del bloque, después de ejecutarse todas las instrucciones contenidas.

° Si o si siempre se ejecuta al menos una vez el bloque. ° Si el resultado de la evaluación de la condición da verdadero, se sale

del ciclo, de lo contrario se continúa iterando.

Ejercitación en Lenguaje Qbasic Se utiliza el término do para indicar el comienzo de una estructura Repetir, a continuación se inserta el bloque de instrucciones, utilizando los delimitadores. Al final del bloque se inserta la


Página 59 de 89

instrucción de evaluación que corresponde al término until. Programa que .. i = 0 iterar = 0 do if i = 0 then iterar = 1 print i endif Loop until iterar = 1

3.5.4 Estructura Para

Estructura que se utiliza para iterar en aquellos casos que de antemano se conoce la cantidad de ciclos a realizar. Por ejemplo: ingresar 10 notas de un alumno y calcular su promedio y desvío estandar.

Al ejecutarse la orden Para primera vez, a la variable de control se le asigna un valor inicial (expresion1). Inmediatamente se ejecutan las instrucciones del bloque asociado y luego se verifica si el valor final (expresión2) es mayor que el valor inicial (expresión); en caso de no ser así se incrementa o decrementa automáticamente el contenido de la variable de control en uno y se vuelve a ejecutar el bloque de instrucciones, hasta que la variable de control sea mayor / menor que el valor final referido en la expresión2, situación en la que se finaliza la estructura Para y se continua con la próxima instrucción que continua al bloque antedicho. Su sintaxis es :

Para <variable_de_control> <- <expresión1> hasta <expresion2> hacer

instrucción 1 instrucción 2

....................... instrucción n Fin Para

El diagrama de la estructura Repetir-Hasta es:


Página 60 de 89

Para <variable_control> <- <expresión1> .hasta <expresion2> hacer .

Instrucciones


° La variable de control se inicializa una sola vez, al inicio de la primera iteración.

° La condición se evalúa en cada iteración. ° El incremento o decremento se realiza antes de cada evaluación. ° Hay lenguajes en los cuales la condición de finalización está implícita

en la misma estructura. Tal como el caso del lenguaje Pascal donde la forma de la instrucción Para es: FOR variable: valor_inicial TO valor_final.

° Al finalizar la ejecución de una estructura de control Para, la variable

de control está instanciada con el valor de expresión2 más un incremento o decremento, según corresponda.

Ejercitación en Lenguaje Qbasic Se utiliza el término for para indicar el comienzo de una estructura Para, a continuación se inserta el bloque de instrucciones. Programa que .. for n=1 to 9 step 1 print "iteración número:";n next n print "n contiene al salir del la estructura ";n


Página 61 de 89

Salida Ejecutar (F5) iteración número:1 iteración número:2 iteración número:3 iteración número:4 iteración número:5 iteración número:6 iteración número:7 iteración número:8 iteración número:9 n contiene 10 al salir del la estructura Para

3.5.5 Ejemplos de Uso de Estructuras Repetitivas

Se ingresan por teclado las notas de los alumnos en una determinada asignatura, o un 99 si el alumno estuvo ausente. Preparar un algoritmo para calcular e imprimir la nota promedio, recordando que el alumno ausente no se promedia. Luego de la última nota se ingresa un valor negativo. Principio suma <-- 0 cantidad <-- 0 Leer(nota) Mientras nota >= 0 hacer Si nota <> 99 entonces hacer: suma <-- suma + nota

cantidad <-- cantidad + 1 Fin Si Ingresar nota Fin mientras promedio <-- suma / cantidad Escribir("Promedio: "; promedio) Fin

Se ingresan por teclado 100 números enteros. Preparar un algoritmo que cuente y muestre por pantalla la cantidad de negativos, positivos y ceros que se ingresaron. Principio sumaneg <-- 0 sumapos <-- 0


Página 62 de 89

sumacer <-- 0 Para contador = 1 hasta 100 hacer: Leer(número) Si número < 0 entonces hacer: sumaneg <-- sumaneg + 1 sino hacer: Si número > 0 entonces hacer: sumapos <-- sumapos + 1 sino hacer: sumacer <-- sumacer + 1 Fin Si Fin Si

Fin Para Escribir("Negativos: "; sumaneg) Escribir("Positivos: "; sumapos) Escribir("Ceros : "; sumacer) Fin

3.5.5.1 Búsqueda del Extremo

Un problema típico es el de encontrar el valor extremo entre una serie de

valores, es decir el máximo o el mínimo.

Tomemos el caso más trivial: encontrar y mostrar el mayor de un grupo de números ingresados por el teclado. La forma simple de pensar el problema es comparar cada nuevo número que ingresa con el mayor de los que ingresaron hasta el momento, si el nuevo es mayor lo tomaremos como tal de aquí en más, sino lo descartamos y comparamos el que sigue: Ingresar número Si número > mayor entonces hacer mayor <-- número Fin Si

De esta manera, en la variable mayor, siempre estará almacenado el mayor de los números ingresados, ya que cada vez que ingresa uno mayor se reemplaza el valor anterior por el nuevo. Para ello, cuando ingreso el primero, obviamente es el mayor por ser el único. El algoritmo completo queda como sigue: Principio Leer(n) Leer(número) mayor <-- número


Página 63 de 89

Para C = 2 hasta N hacer: Leer(número) Si número > mayor entonces hacer: mayor <-- número Fin Si Fin Para Escribir(mayor) Fin

Obsérvese que C comienza valiendo 2, porque cuando se ingresa en el ciclo ya se ingresó el primer número.

3.5.5.2 Validación de Datos

Un refrán utilizado entre los programadores dice: "si ingresa basura, sale

basura", lo que quiere decir que, independientemente de la excelencia del algoritmo, si se le ingresan datos erróneos producirá resultados también erróneos. La casi totalidad de los errores se produce en el ingreso de los datos por parte del operador. Si bien es imposible prever todos los errores que se pueden cometer, un buen programa debe estar preparado para evitar todos los que sea posible. Llamamos "validación" a este control de los datos que ingresan.

La técnica básica parte de la premisa de que hay valores imposibles para ciertos datos: en una fecha, el día no puede ser mayor que 31 o el mes mayor de 12, la altura de una persona no puede ser 8 metros, el cónyuge no puede ser más que 1(?), etc.

La mayoría de los datos posee un rango de valores posibles, y cada valor que ingresa debe estar necesariamente dentro de ese rango. La validación consiste en verificar que cada dato que ingresa se encuentre dentro del rango, si no es así, se le indica al operador que ingrese el dato nuevamente: Leer(variable) Mientras (variable fuera de rango) hacer: Escribir(mensaje al operador) Leer(variable) Fin mientras 3.5.5.2.1 Ejemplo de validación

Supongamos que en una fecha se ingresa el día, entonces comprobamos que no sea menor que 1 ni mayor que 31: Ingresar día


Página 64 de 89

Mientras día <1 ó día > 31 hacer Escribir("dato erróneo, ingrese nuevamente") Leer(día) Fin mientras

Obsérvese que no es posible asegurar que este algoritmo va a evitar todos los errores, por ejemplo no detectará si el operador ingresa un 16 en lugar de un 15, en cambio sí funcionará en la mayoría de las inversiones, es decir si el operador ingresa un 72 en lugar de un 27, el cual es un error muy común cuando se digitan números rápidamente.


Página 65 de 89

4 Arreglos y Archivos Secuenciales

4.1 Arreglos En algunos casos a resolver por medio de programas, se puede hallar la

dificultad de tener que almacenar en memoria una gran cantidad de datos de un mismo tipo.

Supongamos, por ejemplo, que necesitamos hacer un programa que

ordene de forma alfabética cuatro nombres que se ingresan por teclado, con lo visto hasta este capítulo la solución sería almacenar cada nombre en una variable y luego ir encontrando en base a decisiones el orden requerido:

Leer(nombre1)Leer(nombre2)Leer(nombre3)Leer(nombre4) Este ejemplo puede resolverse en la forma planteada pero, ¿ qué ocurriría

si la cantidad a ordenar fuera de 100, 500 ó 1000 nombres ?. La solución planteada sería ineficiente, pues se necesitarían tantas variables diferentes como nombres a ingresar.

La causa de este inconveniente esta dada por la imposibilidad de

almacenar mas de un dato en una variable, como solución a ello se utilizan los arreglos. Consisten en agrupar bajo un mismo nombre a un conjunto de variables, donde cada dato tendrá una posición dentro del arreglo, y esa posición es definida por medio de un índice que se adjunta a la variable. Para el caso anterior necesitaríamos un arreglo capaz de contener cuatro datos.

Juan

Ana

María

Miguel

0

1

2

3

Arreglo nombres

Indice Valor

ElementoElemento

Segundo elemento delarreglo nombre

nombre[2] <- "María"

Como se ve en el gráfico, se ha definido un arreglo denominado "nombres" que consta de cuatro elementos, donde para referirse a cada uno de ellas se utilizará un índice de la siguiente manera :


Página 66 de 89

Primer elemento cuyo valor es Juan: nombres[0] Segundo elemento cuyo valor es Ana: nombres[1]Tercer elemento cuyo valor es María: nombres[2]Cuarto elemento cuyo valor es Miguel: nombres[3]

Este tipo de arreglo también se denomina vector, por agrupar las variables

bajo un solo índice o en una dirección. Para almacenar datos en este tipo de variables utilizamos los mismos métodos que para cualquier variable de memoria, con la ventaja que si necesitamos cargar más de una variable del arreglo, podemos ubicar al ingreso dentro de un ciclo : Principio Para c<-0 hasta 3 incrementando 1 hacer : Ingresar(nombres[c]) Fin Para Fin

Ejercitación en Lenguaje Qbasic For c=0 to 3 step 1 print "Ingrese el valor del elemento ";c nombres$(c) next c

De esta forma el primer nombre que se ingrese será almacenado en nombres[0], el segundo en nombres[1] y así sucesivamente. De la misma manera para mostrar el contenido del arreglo también se puede utilizar un ciclo o bien referirse a una variable específica del arreglo. Escribir(nombres[3])

Mostrará por pantalla el contenido de la tercer casilla o elemento del arreglo nombres. Para c = 0 hasta 3 hacer: Escribir(nombres[c]) Fin para

Ejercitación en Lenguaje Qbasic For c=0 to 3 step 1 print "El elemento”;c;”contiene el valor : “;nombres$[c] next c


Página 67 de 89

En este caso se imprimirá el contenido de todas las casillas del vector nombres.

Podemos también definir arreglos de mas de un índice, dependiendo la cantidad máxima de índices del lenguaje de programación que se esté utilizando. Cada índice puede imaginarse como una nueva dimensión del arreglo, por ejemplo si se define el arreglo x[3,4] podemos representarlo :

x[1,0] x[1,1] x[1,2] x[1,3]

x[2,0] x[2,1] x[2,2] x[2,3]

x[0,0] x[0,1] x[0,2] x[0,3]

Arreglo x de3 filas por cuatrocolumnas

Elemento x[0,1]Fila 0, columna 1

En esta representación el primer índice se refiere al número de fila y el

segundo al de la columna en donde se encuentra ubicada la variable del arreglo. La forma de cargar este arreglo por filas sería : Principio Para f=0 hasta 2 hacer Para c=0 hasta 3 hacer

leer(x[f,c]) Fin Para

Fin Para Fin Ejercitación en Lenguaje Qbasic

For f=0 to2 step 1 For c=0 to 3 step 1 print "Ingrese el valor del elemento (”;f;c;”)” input nombres$(f,c) next c next f print "Impresión del arreglo"


Página 68 de 89

for f=0 to 2 step 1 for c=0 to 3 step 1 print f;c;nombres$(f,c), next c print next f

En este caso se utilizan dos ciclos, uno para cada índice, según se ubiquen los índices uno dentro de otro, el arreglo se cargará por filas o por columnas. Para cargarlo por columnas sería : Principio Para c = 0 hasta 3 hacer Para F = 1 hasta 3 hacer Leer(x[f,c])

Fin para Fin para Fin

A los efectos de mostrar u operar con los datos de este arreglo, también se deben colocar los dos índices. Si quisiéramos mostrar solo la primer fila el algoritmo sería :

Principio

Para c=0 hasta 3 hacer: Leer(x[1,c]) Fin Para

Fin De esta manera, teniendo cierta precaución con el manejo de los índices,

podemos operar con sectores del arreglo. En un mismo programa podemos definir varios arreglos de distintas dimensiones, la restricción estará dada por la capacidad de memoria del equipo o el lenguaje que se está utilizando. Téngase en cuenta que en los ejemplos planteados hasta el momento, se utilizó para los ciclos la estructura Para, pudiéndose de igual manera trabajar con arreglos usando las estructuras Mientras y Hasta. Ejemplo A Se tiene un listado con las ventas realizadas en los 30 días de un mes, desordenadas. Realizar un algoritmo que totalice la venta de cada día y emita un listado con dicho total por día y el total mensual. Después del último dato se ingresa un día negativo. Principio


Página 69 de 89

Leer(día) Leer(venta) Mientras (día > 0) hacer: tot(día) <--- tot(día) + venta Leer(día) Leer(venta) Fin Mientras totmes <--- 0 Escribir("Día Total") Para I <- 1 hasta 30 hacer: Escribir(I; " "; tot(i)) totmes <--- totmes + tot(i) Fin Para Escribir("Total del mes: "; totmes) Fin

Ejercitación en Lenguaje Qbasic print "dia :"; input dia print "venta: "; input venta while dia > 0 tot(dia) = tot[dia] + venta print "dia :";dia print "venta:";venta wend totmes=0 print dia;total for i=1 to 30 step 1 print I;tot(i), totmes = totmes + tot(i) next i print "total del mes: “; totmes

Ejemplo B


Página 70 de 89

Se tiene almacenado en un vector la altura de 20 plantas numeradas,

correspondientes a un experimento. Hacer un algoritmo que permita ingresar una altura y muestre los números de las plantas que tienen dicha altura.

Leer(ALTURA) Para C = 1 hasta 20 hacer: Si V(C) = ALTURA entonces hacer: Escribir(C) Fin Si Fin Para

Si quisiéramos agregar al algoritmo la opción de que muestre un mensaje

en el caso de que no se encuentre alguna planta con la altura deseada, seria: Leer(ALTURA) S <--- 0 Para C=1 hasta 20 hacer: Si V(C)=ALTURA entonces hacer: Escribir(C) S <--- 1 Fin Si Fin Para Si S = 0 entonces hacer: Escribir("No hay plantas de tal altura") Fin

Ejercitación en Lenguaje Qbasic print "altura :"; input altura s=0 for c=1 to 20 step 1 if v(c) = altura then print c s = 1 end if next c if s = 1 then print "No hay plantas de tal altura" end if

La variable S, se denomina señal, y se utiliza para saber si se pasó o no por

un lugar determinado del algoritmo. Este método de búsqueda en un arreglo se


Página 71 de 89

denomina Búsqueda Secuencial, el mismo sería ineficiente para el caso de que quisiéramos buscar varios valores dentro del arreglo, pues por cada uno de ellos se deberá recorrer íntegramente al mismo, haciendo esta tarea muy lenta la búsqueda, más aún si el arreglo posee una gran cantidad de datos. La forma de solucionar este problema es ordenando previamente los datos del arreglo, lo que permitirá utilizar otros métodos de búsqueda. Ejemplo C

Dada una matriz N de 25 x 25, hallar la suma de los números almacenados en sus dos diagonales principales. Principio Para FILA=1 hasta 25 hacer: Para COL=1 hasta 25 hacer:

Leer(N(FILA,COL))

Fin Para Fin Para DIAG1 <--- 0 DIAG2 <--- 0 Para I = 1 hasta 25 hacer: DIAG1 <--- DIAG1 + N(I,I) DIAG2 <--- DIAG2 + N(I,26-I) Fin Para Escribir("Diagonal principal: ";DIAG1) Escribir("Diagonal secundaria: ";DIAG2) Fin 4.1.1 4.1.2 Ordenamiento de Vectores

En muchos casos nos encontraremos con la necesidad de ordenar el

contenido de un arreglo en forma ascendente o descendente. El ejemplo mas típico es el de querer ordenar un conjunto de nombres que se ingresaron en un arreglo. Existen varios métodos para ordenar vectores, nosotros nos dedicaremos en un primer momento al que se denomina burbujeo. Plantearemos el ejemplo de un vector de 4 elementos que contiene los siguientes datos :

V(1) V(2) V(3) V(4)

5 4 6 2

Si se quieren ordenar de menor a mayor, el resultado deberá ser el siguiente estado:


Página 72 de 89

V(1) V(2) V(3) V(4)

2 4 5 6

Comenzaremos comparando los datos almacenados en V(1) y en V(2) y colocando el valor mayor en V(2). En este caso pasaría el valor 5 a V(2) y el valor 4 a V(1). De la misma manera compararemos luego V(2) con V(3) y V(3) con V(4). El algoritmo que realizaría esta tarea sería :

Para I=1 hasta 3 hacer: Si (V(I)>V(I+1)) entonces hacer: A <--- V(I) V(I) <--- V(I+1)

V(I+1) <--- A Fin Para Observemos que en el algoritmo se compara cada V(I) con el siguiente,

esto hace que el ciclo para deba ir hasta el valor N-1 considerando a N como número de elementos del vector. En nuestro ejemplo los datos del vector se irán acomodando de la siguiente manera :

V(1) V(2) V(3) V(4)

5 4 6 2

4 5 6 2 I = 1

4 5 6 2 I = 2

4 5 2 6 I = 3

El resultado de aplicar el algoritmo es, para vectores de cualquier longitud y siempre que ordenemos de menor a mayor, que el dato mayor queda ubicado en el último elemento del arreglo. Nótese que si quisiéramos ordenar de mayor a menor cambiando el sentido de la pregunta quedará el número menor en el último casillero del vector.


Página 73 de 89

Este algoritmo deberá ejecutarse N-1 veces (considerando a N como el número de elementos del vector), quedando de esa forma ordenado el vector en forma completa. La forma de implementarlo seria: Para VEZ=1 hasta 3 hacer:

Para I=1 hasta 3 hacer: Si (V(I)>V(I+1)) entonces hacer: A <--- V(I) V(I) <--- V(I+1) V(I+1) <--- A Fin Si Fin Para Fin Para Siendo el resultado de cada vez:

4 5 2 6 VEZ = 1

4 2 5 6 VEZ = 2

2 4 5 6 VEZ = 3

Notemos que luego de cada vez, no se hace necesario comparar los elementos que ya quedaron ordenados, esto puede solucionarse haciendo el ciclo de VEZ desde 3 hasta 1 y realizando el ciclo de I hasta VEZ en lugar de hacerlo siempre hasta N-1. Para VEZ=3 hasta 1 (incrementando -1) hacer: Para I=1 hasta VEZ hacer: Si V(I)>V(I+1) entonces hacer: A <--- V(I)

V(I) <--- V(I+1) V(I+1) <--- A

Fin Si Fin Para Fin Para

De esta manera la primera vez el ciclo I ira hasta 3, la segunda hasta 2 y la tercera hasta 1, haciendo de esta manera mucho más eficiente el algoritmo. En algunos casos se puede dar que el vector quede ordenado antes de realizar todas las veces planteadas el ciclo de comparación I, por lo tanto se ejecutará algunas veces sin necesidad de que así ocurra. La solución para ello es usar una señal


Página 74 de 89

que permita detectar si se realizaron o no intercambios de elementos luego de cada vez. Para VEZ=3 hasta 1 (incrementando -1) hacer:

S <--- 0 Para I=1 hasta VEZ hacer: Si (V(I)>V(I+1)) entonces hacer: A <--- V(I)

V(I) <--- V(I+1) V(I+1) <--- A S <--- 1

Fin Si Fin Para

Si S=0 entonces hacer: VEZ <--- 1

Fin Si Fin Para

En el caso de detectar mediante la señal S que no se ha producido ningún intercambio de contenidos, se fuerza la salida del ciclo VEZ asignando a la variable de control el valor hasta. Ejemplo D

Se tiene un listado con los nombres y edades de 20 personas. Hacer un algoritmo que permita cargar los nombres en un vector NOM, las edades en uno EDAD y emita un listado de los datos ordenados por edad. Principio

Para I=1 hasta 20 hacer: Leer(NOM(I))

Leer(EDAD(I)) Fin Para

Para VEZ=19 hasta 1 (incrementando -1) hacer: S <--- 0 Para I=1 hasta VEZ hacer: Si (EDAD(I)>EDAD(I+1)) entonces hacer: X <--- NOM(I)

NOM(I) <--- NOM(I+1) NOM(I+1) <--- X E <--- EDAD(I) EDAD(I) <--- EDAD(I+1) EDAD(I+1) <--- E S <--- 1


Página 75 de 89

Fin Si Fin Para Si S=0 entonces hacer: VEZ <--- 1 Fin Si Fin Para Para I=1 hasta 20 hacer:

Escribir(NOM(I);" ";EDAD(I)) Fin Para Fin

4.1.2.1 Ordenamiento por Inserción

Algoritmo para ordenar una lista de números de menor a mayor utilizando

una segunda lista inicialmente vacía:

° Paso 1. Si la primera lista tiene sólo un número, sáquelo de la lista, colóquelo en la primera posición disponible en la segunda lista y termine; la segunda lista contiene los números de la primera, ordenados de menor a mayor.

° Paso 2. Recorra la lista completa y encuentre al menor de todos los

números que hay en ella. ° Paso 3. Saque ese número de la primera lista y colóquelo en la primera

posición disponible en la segunda lista. ° Paso 4. Repita el paso 1, pero usando ahora la primera lista reducida, es

decir, sin el número que sacó.

Ejemplo : Aplicando el algoritmo anterior, ordene de menor a mayor la lista (7 3 9 13 2 18 11 2).

Este algoritmo se llama de inserción, ya que va insertando los números de la primera lista en forma ordenada en la segunda lista. Este algoritmo de ordenación de una lista lo utilizamos cuando ordenamos un conjunto de naipes para sujetarlos en la mano. Así, partimos con una lista de naipes desordenados y una mano sin naipes. Luego tomamos cada uno de los naipes de la primera lista y los vamos insertando en forma ordenada en la mano. Al final terminamos con cuando la primera lista no tiene naipes y la mano contiene todos los naipes iniciales ordenados.


Página 76 de 89

4.1.3 Búsqueda en Vectores

Se había planteado anteriormente que para el caso de tener que realizar muchas búsquedas en un vector o tener que buscar datos en vectores de gran longitud, es conveniente ordenar primero el vector y luego utilizar un método mucho más eficiente que la búsqueda secuencial.

Supongamos que tenemos el siguiente arreglo en memoria y se desea saber si en algún elemento del mismo se encuentra almacenado el número 43:

23V(1)

43V(2)

11V(3)

56V(4)

21V(5)

35V(6)

33V(7)

El primer paso será ordenarlo con algún método, con lo que quedará :

11V(1)

21V(2)

23V(3)

33V(4)

35V(5)

43V(6)

56V(7)

El algoritmo del método, siendo N el número máximo de elementos del vector y A el valor a buscar, es : Leer(N) Leer(A) S <--- N I <--- 1 Mientras ((S-I)<>1) hacer: K <--- ENT((S+I)/2) Si V(K) <= A entonces hacer: I <--- K

sino hacer: S <--- k Fin Si Fin Mientras Si V(I)=A entonces hacer: Escribir(V(I)) sino hacer: Si V(S)=A entonces hacer: Escribir(V(S)) sino hacer: Escribir(A;"No se encuentra") Fin Si Fin Si


Página 77 de 89

4.2 Archivos Secuenciales

Como es sabido, las computadoras pueden procesar grandes cantidades de datos. Por ejemplo, un programa que liquide los sueldos de una empresa de 1000 empleados, necesariamente debe contar con datos básicos para realizar tal tarea, como ser: números de legajo, apellidos y nombres, categorías, secciones, sueldos básicos, adicionales, etc., que en total suman un importante volumen de información. Sin embargo, en los programas desarrollados hasta ahora, se han procesado cantidades relativamente pequeñas de datos; almacenados exclusivamente en la memoria de trabajo, la cual posee una capacidad limitada e inferior a la de cualquier soporte de almacenamiento secundario (disco rígido, CD-ROM, cinta, etc).

Aquí se deben hacer algunas consideraciones con respecto al momento en que se usa cada dato, se puede, en principio, pensar que los datos tienen dos tipos de disponibilidad:

a) los que se están usando en un momento dado por un programa. b) los que no se están usando en ese momento, pero que serán requeridos en alguna otra situación futura.

Almacenar datos que no se están utilizando en la memoria de trabajo, es

ocupar espacio inútilmente; sumado a que tal soporte es volátil y por consecuencia, una vez apagado el equipo la memoria se borra, y desaparece la información almacenada. En una computadora, la información que no está siendo procesada, permanece almacenada en unidades de almacenamiento secundario, que pertenecen a la categoría de periféricos de entrada-salida. Aquí los datos no están guardados en variables, sino que permanecen agrupados en bloques de información llamados archivos.. Esta forma de ordenar a los datos es análoga a la que se utiliza en un archivo manual, donde n elementos relacionados se almacenan juntos en un recipiente contenedor. Por ejemplo fichas de alumnos en una carpeta, tarjetas de presentación juntas en un tarjetero, etc.


Página 78 de 89

Archivode datos deALUMNOS

FICHA DEL ALUMNOAlumno: Gomez, MirianFecha nacimiento: 10/03/1972Sexo: femeninoCurso: 7aSituación: regular

FICHA DEL ALUMNOAlumno: Ver, PabloFecha nacimiento: 11/04/1973Sexo: masculinoCurso: 8bSituación: regular

FICHA DEL ALUMNOAlumno: Vega, AnaFecha nacimiento: 09/07/1972Sexo: femeninoCurso: 7aSituación: regular

"Situación" es unitem de datos ócampo

A la ficha ótarjeta del alumnose la denomina"registro"

Obsérvese que la mínima estructura de organización de datos archivo son los caracteres, los que a su vez se agrupan en estructuras mayores -campos y registros-, hasta llegar al archivo. De todas estas estructuras préstese especial atención a la ficha o registro. Este nivel de agrupamiento de los datos presenta tres características importantes:

a) Cada registro corresponde a un alumno, es decir, centraliza toda la información que corresponde a un individuo. b) Todas los registros poseen los mismos items, y éstos están dispuestos en el mismo orden. c) Cada vez que se agrega, modifica o se borra información del archivo, se accede a un registro, aún si solamente se modifica un solo carácter de un determinado ítem o campo.

En el archivo, los registros se almacenan en algún orden preestablecido.

Cada vez que se incorpora un nuevo alumno se agrega un registro con sus datos, cada vez que se produce una baja se quita el registro correspondiente ( o se lo marca como borrado), y cada vez que cambia algún dato se extrae el registro, se lo modifica y se coloca nuevamente en el archivo. Cuando se tienen distintos conjuntos de datos por almacenar, para cada uno se utiliza un archivo, identificándolo con un nombre: "asignaturas", "profesores", "notas_alumnos", etc. En un sistema de computación, se emula la forma de estructurar la información, pero utilizando un soporte físico de almacenamiento distinto, en lugar de usar carpetas, cajones y tarjeteros se utilizan por lo general medios de almacenamiento digitales, tales como: discos, cintas, disquetes,CDROM, etc.


Página 79 de 89

Se puede pensar que cada vez que se graba información en el disco, se realiza una operación equivalente al agregado de una tarjeta a un tarjetero, éste es pues el paquete de datos que se intercambia entre la memoria central y el medio de almacenamiento; este bloque de datos se denomina "registro"; un registro es entonces equivalente a una tarjeta, y en nuestro ejemplo contiene todos los datos correspondientes a un alumno. Cuando se almacenan o se recuperan datos desde un disco, la información se transfiere de a bloques que pueden contener uno o n registros. Al equivalente del ítem en un archivo digital se lo denomina campo, de tal forma que cada registro se compone de n campos, donde cada uno identifica un atributo de la entidad que se desea registrar. Registro del alumno Ana Vega

Campo Alumno Fecha Nacimiento

Sexo Curso Situación

Vega, Ana 09/07/1972 femenino 7a regular Campo 1 Campo 2 Campo 3 Camp

o 4 Campo

5 Archivo de alumnos

Gómez, Mirian 10/03/1972 femenino 6c libre Ver, Pablo 11/04/1972 masculino 7a regular Vega, Ana 09/07/1972 femenino 7a regular

El siguiente cuadro muestra las analogías entre las estructuras de

almacenamiento de información de un proceso manual y de uno informatizado:

MANUAL MAGNETICO mueble, tarjetero, cajonera

CDROM, disco rígido, disquete, cinta

ficha, tarjeta registro item campo letra, dígito numérico, símbolo

caracter

4.2.1 Operaciones Básicas sobre Archivos

En las operaciones de almacenamiento y recuperación de los datos, también existen analogías entre el procesamiento manual y el electrónico. Retornando al ejemplo del archivo manual de alumnos, si es necesario modificar la situación de alumno Gomez, Mirian se deben ejecutar los siguientes pasos:

1. Abrir el tarjetero de "alumnos" 2. Buscar la tarjeta correspondiente al alumno "Gómez, Mirian" 3. Escribir la modificación sobre el ítem "situación".


Página 80 de 89

4. Guardar la tarjeta actualizada en el tarjetero. 5. Cerrar el tarjetero "alumnos"

Con algunas variaciones, se utiliza una secuencia análoga cuando se opera sobre un archivo informático, donde un algoritmo determinará la secuencia de pasos correspondientes.

4.2.1.1 Grabación de Datos

El algoritmo más sencillo es el de creación de un archivo, es decir, crear un

archivo sobre un soporte digital. En este caso, antes que nada, lo primero que se debe hacer es identificar que se desea almacenar, segundo que atributos se asociaran a cada registro (los campos), lo que a su vez determina cuales son los tipos de datos de cada campo. Primer ejemplo:

Suponiendo que se desea almacenar una agenda telefónica personal en un soporte digital, y específicamente interesa registrar los siguientes atributos: apellido, nombre y número de teléfono, el registro quedará configurado como sigue: Registro del archivo agenda

Apellido Nombres Teléfono

También debe tenerse en cuenta que a medida que son grabados, los registros se ubicarán uno a continuación de otro en el archivo:

Registro 1 Registro 2 Registro 3 Registro 4 ... Registro n

En cada registro se almacenan datos existentes en variables de memoria

de trabajo, de tal forma que en cada campo se guarda el dato contenido en una variable: variable 1 ---------> campo 1 variable 2 ---------> campo 2

variable 3 ---------> campo 3 Una grabación de un registro sobre un archivo se indica de la siguiente forma:


Página 81 de 89

Grabar en (nombre de archivo) : (variable 1, variable 2,..., variable n)

En el ejemplo, es necesario dar un nombre al archivo, podría ser "AGENDA"; y las variables se denominan: apellido, nombres y teléfono. La orden de grabación se definiría de la siguiente forma: Grabar en AGENDA(apellido, nombres, teléfono) Existen instrucciones que permiten abrir y cerrar un archivo:

Abrir(nombre de archivo) Abrir AGENDA

y Cerrar(nombre de archivo) Cerrar AGENDA

Los datos que se graban en el archivo AGENDA se toman de variables almacenadas en la memoria de trabajo, por lo tanto es necesario previamente instanciar información en tales variables. Un algoritmo completo para grabar un registro sería el siguiente: Principio Abrir AGENDA Leer(apellido, nombres, teléfono) Grabar en AGENDA(apellido, nombres, teléfono) Cerrar AGENDA Fin.

Este algoritmo graba un registro, es decir, los datos correspondientes a una persona. En el ejemplo es necesario almacenar los datos de muchas personas, con lo que las instrucciones de ingreso y grabación deben repetirse una cantidad no determinada de veces; ello se logra por medio de un ciclo. Hay varias formas posibles de construir un ciclo como éste, la mas común es mediante una estructura "mientras", que repetirá las instrucciones hasta que se ingrese algún carácter determinado, por ejemplo una "x" en la variable apellido: Principio

Abrir AGENDA Leer apellido Mientras apellido <> "x" hacer: { Leer(nombres, teléfono)

Grabar en AGENDA(apellido, nombres, teléfono) Ingresar apellido }

Fin Mientras


Página 82 de 89

Cerrar AGENDA Fin

Ejercitación en Lenguaje Qbasic Carga del archivo agenda OPEN “agenda.bas” FOR OUTPUT AS #1 print "Ingrese apellido (x) fin) : "; input apellido$ while apellido$ <> "x" print "Ingrese nombres : "; input nombres$ print "Ingrese telefono : "; input telefono$ print #1, apellido$,nombres$,telefono$ print "Ingrese apellido (x fin) : "; input apellido$ wend close #1

Después del último registro grabado, la computadora coloca una marca en

el disco que llamamos "marca de fin de archivo" (en inglés "end of file" o EOF), que posteriormente sirve para identificar hasta donde llegan los registros grabados en un archivo. Una cuestión importante a tener en cuenta es que el programa anterior comienza siempre grabando desde el primer registro, borrando lo que hubiera grabado anteriormente. Si deseamos seguir grabando a continuación del último existente, en nuestra convención lo indicaremos como: Grabar al final en (nombre de archivo) Grabar al final en AGENDA

Con estas instrucciones, la computadora antes de grabar buscará la marca de fin de archivo (EOF), para grabar los nuevos registros a continuación, cuando termine colocará el EOF en la nueva posición.

Ejercitación en Lenguaje Qbasic Programa que añade un registro al archivo agenda.


Página 83 de 89

Nótese que en la instrucción de apertura del archivo se utiliza modo append coloca el puntero de archivo al final del archivo. Una instrucción print # o write # luego anexa información al archivo. open “agenda.bas” for append as #1 Apellido$ = "Santolini" Nombres$ = "Lucia Micaela" Telefono$ = "45322" print #1, apellido$,nombres$,telefono$ close #1

4.2.1.2 Recuperación de Datos Grabados

Para leer los datos almacenados en un archivo, el proceso es inverso, o sea

que los datos pasan del registro a variables de memoria central. La operación con la que indicaremos la lectura es: Leer de (nombre de archivo)(variable 1, variable 2, .., variable n)

Supongamos que queremos leer un registro de nuestra agenda telefónica, la instrucción de lectura será: Leer de AGENDA(apellido, nombres, teléfono) Segundo ejemplo

Se desea obtener un listado por impresora con todos los datos almacenados en el archivo AGENDA. Los pasos son: abrir el archivo, leer cada registro e imprimirlo hasta encontrar el fin de archivo (EOF), y cerrar el archivo: Principio

Abrir AGENDA Mientras no (EOF de AGENDA) hacer: Leer de AGENDA(A, N, T) Escribir(A, N, T) Fin Mientras Cerrar AGENDA

Fin

Ejercitación en Len guaje Qbasic


Página 84 de 89

Programa que lee y muestra por pantallas los campos de los registros que conforman el archivo agenda. open “agenda.bas” for input as #1 do while not eof(1) input #1, apellido$,nombres$,telefono$ print apellido$,nombres$,telefono$ enndo close #1

La expresión "EOF de AGENDA" , antes de cada lectura de registro, hace

que la computadora determine si está la marca de fin de archivo, si no la encuentra quiere decir que hay un nuevo registro para leer, con lo cual la instrucción: Mientras no EOF de AGENDA seguida de la instrucción de lectura debe interpretarse como "leer mientras no se encuentre el fin de archivo", dicho en otras palabras, leer mientras haya registros. 4.2.2 Organización Secuencial Volviendo al ejemplo del archivo manual, se puede observar que existen distintas formas de tener ordenadas las tarjetas dentro del mismo, pueden estar por orden alfabético, por curso, por situación, etc. Algo similar ocurre con los archivos informáticos. Se denomina "organización" del archivo a la forma en que está ordenado. De todas las formas posibles, la más primitiva es tenerlo por orden "de llegada", es decir, la tarjeta o registro correspondiente a un nuevo alumno se coloca al final, detrás de todas las demás. En informática es posible grabar los registros de la misma forma, cada nuevo registro, detrás de los anteriores; a esta organización se la denomina "secuencial". Otra forma posible de organización es aquella en que cada ficha de alumno está identificada con un número, el cual indica el orden en que la tarjeta está colocada en el tarjetero. Cuando se desea acceder a una tarjeta n se la localiza por su número, en base a consultar etiquetas asociadas a cada tarjeta que contienen sus números. A esta organización se la denomina "relativa"


Página 85 de 89

4.2.3 Acceso

Se denomina "acceso" a la manera en que se puede buscar un registro determinado dentro de un archivo. Como se comprenderá, la forma de acceso va a depender de la estructura del archivo. Esta sección se dedica exclusivamente a archivos secuenciales.

4.2.3.1 Acceso Secuencial

De la misma forma que en un archivo manual organizado secuencialmente,

el acceso a un registro determinado obliga a buscar en todos los registros, a partir del primero, hasta encontrar el que se desea.

En nuestro ejemplo del archivo de alumnos, supongamos que deseamos mostrar el curso y situación del alumno "Vega, Ana". Para ello, debemos leer desde el primer registro, comparando cada nombre de alumno con el buscado, cuando se lo encuentre, se debe mostrar los datos correspondientes: Abrir ALUMNOS

Mientras no (EOF de ALUMNOS) hacer: Leer de ALUMNOS:(APE_NOM, FECHA_N, SEXO, CURSO, SITUACION)

Si APE_NOM = "Vega, Ana" entonces hacer:

Escribir(APE_NOM,FECHA_N,SEXO,CURSO,SITUACION)

Fin Si Fin mientras

Cerrar CLIENTES Fin

Si deseamos que el algoritmo sirva para buscar los datos de un cliente cualquiera, reemplazar el nombre "Vega, Ana", por una variable cuyo valor se ingresa por teclado al principio:

Ejercitación en Lenguaje Qbasic Programa que solicita por teclado un apellido, lee del archivo agenda todos los registros, y solamente muestra todos aquellos que coincidan con tal apellido. open “agenda.bas” for input as #1


Página 86 de 89

do while not eof(1) print "Ingrese apellido a buscar en el archivo agenda : " input x_apellido$ while not eof(1) input #1, apellido$,nombres$,telefono$ if x_apellido$ = apellido$ then print apellido$,nombres$,telefono$ endif wend close #1

4.2.4 Modificaciones de Datos Sobre Archivos Secuenciales

Dado un archivo secuencial, existen tres formas posibles de introducir modificaciones a los datos contenidos en él:

a) Dar de alta nuevos registros b) Dar de baja registros c) Modificar el contenido de un registro existente.

Un proceso que hace estas tareas es clásico en computación, y

generalmente recibe el nombre de "Altas, Bajas y Modificaciones", o abreviadamente ABM. Este algoritmo puede construirse con tres subrutinas, y un menú que permita al usuario elegir una de ellas. Analizaremos cada subrutina por separado: 4.2.4.1.1 Altas

Por tratarse de un archivo secuencial, cada nuevo registro que se agregue se grabará al final de los demás; el algoritmo es similar al de creación de un archivo, pero la grabación se realiza al final. Cuando se abre el archivo hay que indicar que se lo desea hacer en modo añadir (append), el siguiente es el esquema general de un módulo que implemente el proceso de altas:

Principio

Abrir (archivo) Leer(variable de corte)


Página 87 de 89

Mientras (variable de corte) <> (valor de corte) hacer: Leer(variables restantes)

Grabar al final en (archivo)(variables) Ingresar (variable de corte)

Fin Mientras Cerrar (archivo)

Fin A los efectos de que el módulo anterior sea realmente operativo, se debería

incluir la validación de los datos que se ingresan. 4.2.4.1.2 Bajas

Este es un caso más complejo, ya que es necesario eliminar un registro ubicado entre los demás. Al extraer un registro, el siguiente pasa a ocupar su lugar, proceso que se repite hasta el final del archivo. Suponiendo el siguiente archivo

Registro empleado "Perez" Registro empleado "Diaz" Registro empleado "Welly" Registro empleado "Saltz" Registro empleado "Miranda" Registro empleado "Trileo"

Si se debe dar de baja el registro del empleado Saltz, todos los que le

siguen deben desplazarse un lugar hacia atrás:

Registro empleado "Perez" Registro empleado "Diaz" Registro empleado "Welly" Registro empleado "Miranda" Registro empleado "Trileo"

Para poder hacer esto se debe utilizar un archivo auxiliar, ya que si un

archivo fue abierto para lectura, no pueden grabarse datos en él; y por otra parte debemos leer el archivo a modificar hasta encontrar el registro a dar de baja.

El registro que se debe dar de baja tiene que poder identificarse por un campo, generalmente un número (socio, cuenta, cliente, legajo, etc.). El algoritmo leerá cada registro, comparando el número con el que es desea dar de baja, si no es , se graba en el auxiliar y se pasa a leer el próximo, de lo contrario se va a leer sin grabar nada. El siguiente es el esquema general del algoritmo:

Principio Abrir (archivo) Abrir (auxiliar)


Página 88 de 89

Leer(número-baja) Mientras no (EOF de archivo) hacer:

Leer de (archivo)(número y restantes campos) Si número-baja <> número entonces hacer:

Grabar en (auxiliar)(número y restantes campos) Fin Mientras Cerrar (archivo) Cerrar (auxiliar)

Fin

Hasta aquí los datos quedaron almacenados en el archivo auxiliar, mientras que en el original quedaron los datos sin la baja. Es necesario entonces, copiar los datos del archivo auxiliar al original:

principio Abrir (archivo) Abrir (auxiliar) Mientras (no EOF de auxiliar) hacer: Leer de (auxiliar)(variables)

Grabar en (archivo)(variables) Fin Mientras Cerrar (archivo) Cerrar (auxiliar)

Fin

Este algoritmo resulta ineficiente si se pretenden producir muchas bajas de registros, ya que en cada caso es necesario recorrer todo el archivo y generar el auxiliar, para solucionar de forma eficiente tales situaciones se utilizan otras técnicas. 4.2.4.1.3 Modificaciones

El esquema del algoritmo es similar al de bajas. Si en el ejemplo se desea modificar el registro del empleado Saltz en lugar de borrarlo. Se copian todos los registros en el archivo auxiliar, salvo el que se desea modificar, el cual se graba con los nuevos datos. La estructura "mientras" del algoritmo se especifica como sigue:

Mientras no (EOF de archivo) hacer: Leer de (archivo)(número y restantes campos)

Si número = modif entonces hacer: Ingresar (restantes campos)

Fin Si Grabar en (auxiliar) (número y restantes campos)

Fin Mientras


Página 89 de 89

Bibliografía

Fundamentos de informática, lógica, resolución de p roblemas, programas y computadoras Autores Allen B. Tucker, W. James Bradley, Robert D. Cupper, David K. Garnick Editorial McGraw-Hill Año 1994 Curso de programación Autores Jorge Castro, Felipe Cucker, Xavier Messeger, Albert Rubio, Luis Solano, Borja Valles Editorial McGraw-Hill Año 1993 Fundamentos de programación. Algoritmos y Estructur as de Datos Autores Luis Joyanes Aguilar Editorial McGraw-Hill, 2da edición, Año 1998 Algoritmos. Problemas resueltos y comentados Autores Joaquín Fernández, Francisco J. Oliver, José L. Sánchez Editorial Paraninfo Año 1992

Algorithms Autores Ian Craw y John Pulham. Universidad de Aberdeen. http://www.maths.abdn.ac.uk/~igc/tch/mx4002/notes/notes.html

El Lenguaje de programación C.

Autores B. Kernighan, B y D.Ritchie. Editorial Prenctice Hall , 2da edición Introducción a la programación. Un enfoque práctico Autores J.M. González, J. Cordero, , R. Martínez, R. Romero

Editorial Algaida Informática, año 1996

asignatura: computación carrera: ingeniería en...

Documents