Libro 1: Fundamentos de Programación · PDF fileGuía del Estudiante Fundamentos...

Fundamentos de Programación Código del Curso: CY300 Versión 4.0

Guía del Estudiante

Libro 1: Fundamentos de Programación IBM IT Education Services Worldwide Certified Material

.

Información Sobre la Publicación

Esta publicación ha sido producida usando Microsoft Word 2000 y Microsoft PowerPoint 2000 para Windows.

Marcas Registradas

IBM ® es una marca registrada por International Business Machines Corporation.

Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o marcas de servicios de otros.

Trademarks of International Business Machines Corporation

DB2 Informix

Lotus Script Net.data

Marcas Registradas de otras Compañías

Windows, Microsoft Visual Studio Microsoft Corporation

Sybase Sybase Inc.

Edición Agosto 2007

La información contenida en este documento no ha sido sometida a ninguna prueba formal de IBM y es distribuida básicamente “como es" sin ninguna garantía ya sea expresa o implícita. El uso de esta información o la implementación de cualquiera de estas técnicas es responsabilidad del comprador y dependerá de la habilidad de éste para su evaluación e integración en el ambiente operacional del comprador. A pesar de que cada tema ha sido revisado por IBM para su exactitud en una situación específica, no hay garantía de que obtener el mismo resultado o uno similar a éste en otra situación. Los compradores que intenten adaptar estas técnicas a sus propios ambientes lo hacen bajo su propio riesgo.

Copyright International Business Machines Corporation, 2007. All rights reserved. Este documento no puede ser reproducido en su totalidad o en parte sin el previo permiso escrito de IBM.

Instrucciones Especiales para la Impresión de este Curso:

No elimine páginas en blanco que puedan aparecer al final de cada unidad ó entre unidades. Estas páginas fueron insertadas intencionalmente.

Guía del Estudiante Fundamentos de Programación

i © Copyright IBM Corp. 2007

Los materiales del curso no pueden ser reproducidos total o parcialmente sin el previo permiso escrito de IBM.

Contenido Descripción del Curso........................................................................................1 Descripción de Unidades ...................................................................................2 Volumen 1: Conceptos de Programación.........................................................5 Unidad 1: Programas de Computadora ............................................................7

Objetivos del Aprendizaje 7 1. Introducción 8 2. Sistemas de Procesamiento 9 3. Algoritmos 9 4. Metodología para Diseñar Algoritmos 9 5. Programas de Computadora 10 6. Definiciones Básicas 11 7. Crear un Programa de Computadora 12 8. Funcionamiento del Compilador/Enlazador 13 9. Datos, Tipos de Datos y Funciones Incorporadas 14 10. Expresiones: Tipos y Operadores 17 11. Funciones Incorporadas 22 12. Operación de Asignación 23 13. Recomendaciones 24 Resumen 25 Unidad 1: Examen de Autoevaluación 26 Respuestas de la Unidad 1: Examen de Autoevaluación 28

Unidad 2: Conceptos de Diseño Estructurado...............................................29 Objetivos del Aprendizaje 29 1. Introducción 30 2. Conceptos de Diseño Estructurado 30 3. Diseño Top Down 30 4. Diagramas de Estructura 32 5. Diagramas de Flujo o Flujograma 32 6. Recomendaciones para hacer Diagramas de Flujo 36 7. Ejemplo de un Diagrama de Flujo 36 8. Diagramas N-S o de Nassi-Schederman: 37 9. Pseudocódigo 39 Resumen 41

Fundamentos de Programación Guía del Estudiante

ii © Copyright IBM Corp. 2007


Unidad 2: Examen de Autoevaluación 42 Respuesta de la Unidad 2: Examen de Autoevaluación 44

Unidad 3: Programación Estructurada ...........................................................45 Objetivos del Aprendizaje 45 1. Introducción 46 2. Estructuras Secuenciales 46 3. Estructuras Selectivas 47 4. Estructuras Repetitivas o de Ciclo 49 5. Estructuras Anidadas 52 6. Control de Datos de Entrada 54 Resumen 57 Unidad 3: Examen de Autoevaluación 58 Respuestas de la Unidad 3: Examen de Autoevaluación 60

Unidad 4: Funciones y Procedimientos..........................................................61 Objetivos del Aprendizaje 61 1. Introducción 62 2. Funciones 63 3. Procedimientos 67 4. Ámbitos: Variables Globales y Locales 69 5. Comunicación entre Subprogramas: Paso de Parámetros 71 6. Recursividad 75 Resumen 78 Unidad 4: Examen de Autoevaluación 79 Respuesta de la Unidad 4: Examen de Autoevaluación 82

Unidad 5: Estructura de Datos: Arreglos........................................................83 Objetivos del Aprendizaje 83 1. Introducción 84 2. Arreglos Unidimensionales: Arreglos o Vectores 84 3. Arreglos Bidimensionales: Matrices m x n 89 4. Arreglos Multidimensionales: Matrices m x n x...z 91 5. Almacenamiento de Arreglos en Memoria 91 Resumen 93 Unidad 5: Examen de Autoevaluación 94 Respuesta de la Unidad 5: Examen de Autoevaluación 96

Unidad 6: Entrada y Salida...............................................................................97


iii © Copyright IBM Corp. 2007


Objetivos del Aprendizaje 97 1. Introducción 98 2. Entrada y Salida de un Programa 98 3. Buffers de Entrada y Salida 99 4. Imprimir Datos 100 5. Entrada/Salida de Archivo: Formatos de Registros 103 Resumen 107 Unidad 6: Examen de Autoevaluación 108 Respuesta de la Unidad 6: Examen de Autoevaluación 110

Unidad 7: Ejemplos de Programas................................................................111 Objetivos del Aprendizaje 111 1. Verificar la Secuencias 112 2. Rupturas de Control 112 3. Emparejar Transacciones 113 Resumen 117

Volumen 2: Complementos I..........................................................................119 Unidad 1: Sentencias Simples.......................................................................121

1. Conceptos 121 Ejercicios Resueltos 123 Ejercicios por Resolver 129

Unidad 2: Estructuras de Decisión................................................................131 1. Conceptos 131 Ejercicios Resueltos 132 Ejercicios por Resolver 139

Unidad 3: Estructuras de Repetición ............................................................141 1. Conceptos 141 Ejercicios Resueltos 143 Ejercicios Propuestos 148

Unidad 4: Sentencias Simples (Pseudocódigo) ...........................................149 Ejercicios Resueltos 149 Ejercicios por Resolver 152

Unidad 5: Estructuras de Decisión (Pseudocódigo)....................................153 Ejercicios Resueltos 153 Ejercicios por Resolver 159

Unidad 6: Estructuras de Repetición (Pseudocódigo) ................................161 Ejercicios Resueltos 161


iv © Copyright IBM Corp. 2007


Ejercicios Propuestos 166 Volumen 3: Complementos II.........................................................................169 Unidad 4: Funciones y Procedimientos........................................................171

Ejercicios Resueltos 171 Ejercicios Propuestos 175

Unidad 5: Estructuras de Datos - Arreglos...................................................179 Ejercicios Resueltos 179 Ejercicios Propuestos 183

Volumen 4: Ejercicios Propuestos ................................................................189 Unidad 1: Programas de Computadora ........................................................191

Respuestas de la Unidad 1: Ejercicios Propuestos 192 Unidad 2: Conceptos de Diseño Estructurado.............................................193

Respuestas de la Unidad 2: Ejercicios Propuestos 194 Unidad 3: Programación Estructurada. ........................................................197

Respuesta Unidad 3: Ejercicios Propuestos 198 Unidad 4: Procedimientos y Funciones........................................................203

Respuesta Unidad 4: Ejercicios Propuestos 204 Unidad 5: Estructura de Datos: Arreglos......................................................207

Respuesta Unidad 5: Ejercicios Propuestos 208


Libro 1: Fundamentos de Programación Descripción del Curso 1

© Copyright IBM Corp. 2007 Los materiales del curso no pueden ser reproducidos total o

parcialmente sin el previo permiso escrito de IBM.

Descripción del Curso Nombre del Curso Fundamentos de Programación. Duración La duración del curso es de 40 horas. Propósito

El propósito de este curso es introducir los fundamentos de programación, para ello se estudian los elementos del proceso de desarrollo de aplicaciones que se ejecutan en las computadoras. El curso, cubre los conceptos de programa, estructura de datos, tipos de datos, variables y constantes. También, se discuten algunas técnicas para desarrollar algoritmos, que se implementan en la programación estructurada, así como, los elementos estándar de un programa de aplicación de computadora. Audiencia Cualquier persona que desee obtener un conocimiento básico acerca de los fundamentos de la programación. Pre-requisitos Ninguno. Objetivos del Curso

Después de completar este curso, usted estará en la capacidad de:

• Crear la lógica básica de un programa. • Conocer los pasos básicos necesarios para ir desde el diseño de un programa

hasta su ejecución. • Describir los componentes básicos de la configuración de una computadora.

Agenda Cada unidad de este curso es de dos horas académicas de duración.


Descripción de Unidades Libro 1: Fundamentos de Programación 2



Descripción de Unidades Volumen 1: Conceptos de Programación Unidad 1: Programas de Computadora

En esta unidad se define el propósito y el contenido de un programa de computación y se aprende una metodología para resolver problemas de procesamiento de datos. Se discuten los elementos de un programa, para ello se estudian los conceptos de variables, variables contadoras, variables acumuladoras, constantes, los operadores aritméticos y operadores lógicos. Se estudian las operaciones incorporadas y se discuten algunos de los errores más comunes que se cometen en la programación. Se presentan también, algunas sugerencias para programar con estilo y disciplina.

Unidad 2: Conceptos de Diseño Incorporado

Aquí se definen los conceptos utilizados para facilitar el entendimiento de un problema. Se utilizan técnicas Top-Down (de abajo hacia arriba) y se aprende cómo dibujar gráficos que muestran la jerarquía de un problema, y así poder, a partir de estos gráficos, analizar el problema, crear los diagramas de flujo y el pseudocódigo necesario para comenzar a escribir un programa de computación. Se discuten los Diagramas de Estructura, los Diagramas de Flujo, los Diagramas N-S o de Nassi-Schederman, así como los conceptos y elementos del pseudocódigo.

Unidad 3: Programación Estructurada

Se describen los conceptos relacionados con las estructuras de los bloques de código que conforman un programa de computadora bajo el concepto de Programación Estructurada. Se revisan las estructuras secuenciales, las selectivas o de bifurcación para direccionar el flujo de control. También, se estudian las estructuras de bloques de código para ciclos o repeticiones, en conjunto con las capacidades de anidamiento de bloques de código. Por último, se muestran algunos casos del uso de las estructuras de control y repetición en la entrada de datos.

Unidad 4: Funciones y Procedimientos

En esta unidad, se estudia el concepto de funciones y procedimientos. Se describe la sintaxis y el uso de los procedimientos y funciones como parte de un programa de computadora. Se analiza el ámbito de las variables, la invocación de funciones y procedimientos desde un programa, así como la comunicación entre subprogramas o pase de parámetros o argumentos. Por último, se revisa el concepto de recursividad, además de cómo se definen y usan las funciones y procedimientos recursivos.


Libro 1: Fundamentos de Programación Descripción de Unidades 3



Unidad 5: Estructura de Datos: Arreglos

Se estudian las estructuras de almacenamiento continuo y su representación en la memoria del computador. Se revisan los conceptos de arreglos unidimensionales o vectores, matrices de dos dimensiones y matrices multidimensionales.

Unidad 6: Entrada y Salida

Esta unidad presenta la descripción de los conceptos básicos de entrada y salida en un programa de computadora, tomando en cuenta algunas consideraciones específicas para imprimir una salida. Se describen los conceptos de registros de datos fijos, variable y bloqueado. Se finaliza con la creación del diseño de un programa que permite manejar encabezados de página.

Unidad 7: Ejemplos de Programas

Esta unidad está diseñada para reforzar los conceptos presentados en las unidades anteriores. Se presentan ejemplos que permiten diseñar programas para manejar la verificación de secuencias y rupturas de control, así como para resolver problemas de emparejamiento de transacciones.

Volumen 2: Complementos I Unidad 1: Sentencias Simples

En esta unidad se aprecia cómo se realiza la Declaración de Variables, Asignación de Variables, Lectura de Variables desde un dispositivo de entrada de datos hacia la memoria, Escritura de Datos desde la memoria hacia un dispositivo de salida, todo esto con su respectiva notación de Diagramas de Flujo o Flujogramas. También se presentan una serie de Ejercicios Resueltos aplicando la técnica de Diagrama de Flujo o Flujograma.

Unidad 2: Estructuras de Decisión

Aquí se visualiza la aplicación de los tres tipos de Estructuras de Decisión: simple, dobles y múltiples. Denotando el concepto de cada una de ellas y aplicando estas bajo la técnica de Flujograma o Diagrama de Flujo.

Unidad 3: Estructuras de Repetición

Se describen los conceptos relacionados con las estructuras de Repetición: Ciclo Mientras.. Hacer (while .. do), Ciclo Repetir .. Hasta (Repeat ..until), Ciclo Desde (for); aplicando cada uno de ellos bajo la técnica de Flujograma o Diagrama de Flujo.

Unidad 4: Sentencias Simples (Pseudocódigo)

En esta unidad se aprecia cómo se realiza la Declaración de Variables, Asignación de Variables, Lectura de Variables, así como la estructura básica de un algoritmo


Descripción de Unidades Libro 1: Fundamentos de Programación 4



representada bajo la técnica de Pseudocódigo. También se presentan una serie de Ejercicios Resueltos aplicando la técnica de Pseudocódigo.

Unidad 5: Estructuras de Decisión (Pseudocódigo)

Aquí se visualiza la aplicación de los tres tipos de Estructuras de Decisión: simple, dobles y múltiples. Denotando el concepto de cada una de ellas y aplicando estas bajo la técnica de Pseudocódigo.

Unidad 6: Estructuras de Repetición (Pseudocódigo)

Se describen los conceptos relacionados con las estructuras de Repetición: Ciclo Mientras.. Hacer (while .. do), Ciclo Repetir .. Hasta (Repeat ..until), Ciclo Desde (for); aplicando cada uno de ellos bajo la técnica de Pseudocódigo.

Volumen 3: Complementos II Unidad 1: Funciones y Procedimientos

Aquí se presentan una serie de ejercicios resueltos aplicando la técnica de Pseudocódigo, empleando los conceptos de Funciones y Procedimientos que permite visualizar su aplicación.

Unidad 2: Estructuras de Datos - Arreglos

En esta unidad se aprecia la representación de Arreglos unidimensionales y bidimensionales por medio de ejercicios resueltos, utilizando la técnica de Pseudocódigo.

Volumen 4: Ejercicios Propuestos Desde la Unidad 1 hasta la Unidad 5, se presenta una variedad de ejercicios correspondientes a los conceptos manejados por cada unidad, que han sido resueltos para mayor comprensión. En la mayoría de los casos se aplica la técnica de Pseudocódigo para el diseño de algoritmos, en otro caso una descripción comprensible de la solución del problema como se puede visualizar en la resolución de los ejercicios para la Unidad 1.


Libro 1: Fundamentos de Programación Descripción de Unidades 5



Volumen 1: Conceptos de Programación


Unidad 1: Programas de Computadora Libro 1: Fundamentos de Programación 7

© Copyright IBM Corp. 2007 El material del curso no puede ser reproducido total ni

parcialmente sin el permiso escrito previo de IBM.

Unidad 1: Programas de Computadora

Objetivos del Aprendizaje Al finalizar esta unidad, usted será capaz de:

• Definir el propósito y el contenido de un programa de computadora. • Establecer una metodología para resolver problemas de procesamiento de

datos. • Definir el concepto de dato, los tipos de datos y las funciones incorporadas a los

lenguajes de programación. • Enumerar las recomendaciones más comunes necesarias para programar con

estilo.


Libro 1: Fundamentos de Programación Unidad 1: Programas de Computadora 8



1. Introducción En la actualidad es común contar con la ayuda de las computadoras para la solución de problemas. Para casi cualquier problema típico en las áreas de negocios, servicios y tecnologías, entre otras, la solución puede ser modelada con programas de computadora, esta solución es generalmente más confiable y de menor costo.

Los programas de computadora permiten dar solución a problemas de cualquier nivel, estas soluciones típicamente llamadas aplicaciones, las realiza un equipo multidisciplinario donde se encuentran los programadores, diseñadores y analistas de sistemas, entre otros especialistas.

Generalmente, los programadores utilizan algún lenguaje de programación para desarrollar las aplicaciones requeridas por los clientes. Estos lenguajes de programación sirven como puente de enlace entre el análisis realizado por el equipo de desarrollo y la capacidad de cálculo que ofrece la computadora. En otras palabras, por medio del lenguaje de programación, el programador le indicará al computador la secuencia de instrucciones que se deben ejecutar para obtener la solución esperada por los clientes.

Todo esto hace pensar que de alguna manera, un programador debe tener cierta lógica que le ayude a tratar con el lenguaje de programación, esto es, debe saber exactamente las capacidades brindadas por el lenguaje de programación y más aún, debe tener nociones claras de los fundamentos generales de la programación.

Como cualquier ciencia, la programación requiere de una serie de conocimientos básicos comunes a cualquier lenguaje de programación, que le permitan al programador indicarle inequívocamente al computador las tareas que éste debe realizar. Dichos conocimientos básicos son conocidos como Fundamentos de Programación, los cuales no son más que un conjunto de reglas, técnicas y conceptos que ayudan a definir lo que se puede hacer con un lenguaje de programación y así dar los primeros pasos para desarrollar aplicaciones para la solución de problemas computacionales.

Este curso introduce al estudiante a los fundamentos de la programación de manera breve y concisa. Se discuten diversos temas, tales como: ¿qué son los programas de computadora?, el diseño estructurado, la lógica de programación, diagramas de flujos, pseudocódigo, entrada y salida, entre otros.

Para desarrollar programas de computadora existe una gran variedad de lenguajes de programación, por esta razón, fue necesario definir una notación genérica que permitiera, en primer lugar, representar y describir el problema de forma clara y sencilla. Esta representación se obtiene con el uso de algoritmos, los cuales permiten definir una secuencia finita de pasos claros y sencillos, para obtener una solución del problema.

El proceso para desarrollar programas de computadora requiere entender y conceptuar el problema, para luego definir los aspectos importantes acerca de la entrada, salida y almacenamiento.





En esta unidad se discuten los conceptos básicos más importantes de la programación y la metodología para desarrollar una solución computacional de un problema.

2. Sistemas de Procesamiento Un ordenador es una máquina de procesamiento de información. Es una máquina, porque tiene cables, circuitos y demás elementos mecánicos. Es además de procesamiento, porque es capaz de transformar o procesar datos y de información porque maneja conjuntos ordenados de datos.

Para procesar la información se requiere del hardware como microprocesador, memoria RAM, entre otros y del software que sirve para manejar el hardware tal como programas, sistema operativo, etc.

3. Algoritmos El concepto de algoritmo fue desarrollado por el matemático persa Abu Jafar Mohammed Ibn Musa Al Khwarizmi. Se puede decir que un algoritmo es una fórmula para resolver un problema. Es un conjunto de acciones o secuencia de operaciones que ejecutadas en un determinado orden, resuelven el problema planteado.

Un algoritmo debe tener las siguientes características:

• Estar bien definido. • Ser preciso. • Ser finito.

Básicamente, un algoritmo es un proceso metódico que define una serie finita de pasos sencillos y sin ambigüedades para la solución de un problema.

La programación consiste en adaptar el algoritmo al ordenador. El algoritmo es independiente de la implementación en algún lenguaje de programación.

4. Metodología para Diseñar Algoritmos Un algoritmo es una fórmula para obtener la solución de un problema, ésta fórmula puede ser planteada de diferentes formas y cada una de estas formas puede efectivamente resolver el problema planteado. Por esa razón, el diseño de un algoritmo es un proceso creativo, ya que no existe un conjunto de reglas que indiquen expresamente cómo escribir un algoritmo en forma correcta, por el contrario, si existen muchas maneras de resolver un problema, entonces existen muchos algoritmos que implementen la solución.

Sin embargo, hay una serie de pasos que permiten resolver un problema de la forma más conveniente, estos son:

• Análisis del problema.





• Diseño del algoritmo. • Verificación del algoritmo.

Análisis delProblema

Diseño delAlgoritmo

Verificacióndel Algoritmo

Figura 1.1: Metodología de Diseño de Algoritmos

1.1 Análisis del Problema

El primer paso es identificar el problema. Se debe revisar cuidadosamente el problema para determinar qué tipo de información se necesita producir como salida. Luego se identifica toda la información que se necesita para encontrar la solución. En otras palabras, es importante considerar lo que se está pidiendo en el problema, con qué elementos se cuenta y cuáles se deben solicitar para establecer el camino a seguir en la solucionar el problema. Luego de obtener todos estos datos, se inicia la fase de Diseño del Algoritmo.

1.2 Diseño del Algoritmo

En esta fase, la solución del problema puede requerir varios pasos, así que es necesario buscar la manera más fácil para simplificar la propuesta. Una forma de hacerlo, es identificar los procesos más importantes y colocarlos en orden ascendente según su importancia y precedencia, esto sirve como un algoritmo inicial.

Este algoritmo inicial podrá ser refinado en sucesivas operaciones, hasta obtener una solución más detallada y más fácil de traducir a un lenguaje de programación.

1.3 Verificación del Algoritmo

Cuando el algoritmo está listo, es necesario comprobar que cumple con los procesos ideados y produce el resultado esperado. Una manera de hacerlo, es por medio de la ejecución manual, que consiste en realizar una prueba del algoritmo con datos significativos y comprobar que al ejecutar todos los procesos se obtienen los resultados esperados para la salida.

5. Programas de Computadora Un programa es un conjunto de instrucciones que ejecutadas ordenadamente resuelven un problema, en otras palabras es la implementación del algoritmo. Un programa de computadora es una secuencia de instrucciones que le indican al computador que realice operaciones específicas para lograr un resultado deseado. Consiste de uno o más módulos o rutinas, cada uno de los cuales puede estar compuesto a su vez de otros módulos o subprogramas. Un programa de computadora no es:

• Una caja mágica.





• Intrínsicamente correcto.

Un programa de computadora debe ser:

• Una solución a un problema. • Una secuencia de instrucciones hechas para ejecutarse en una computadora. • Sólo tan correcto como el programador lo haya hecho.

En resumen, un programa de computadora es un conjunto de instrucciones generadas por el programador, que le dicen al computador exactamente lo que debe hacer.

6. Definiciones Básicas A continuación se presentan un conjunto de definiciones básicas que se usan en el entorno de un programa de computadora:

Lenguaje de Máquina: es un lenguaje que puede ser interpretado directamente por los circuitos internos de la computadora porque está basado en instrucciones compuestas por secuencias de ceros (0) y unos (1).

Ventajas:

• No necesita ser traducido puesto que la máquina lo entiende. • Opera directamente con la máquina. • Puede llegar a ser muy eficiente en el manejo de recursos.

Desventajas son:

• Extremadamente difícil de aprender, implementar y mantener. • Es único y particular para cada procesador.

Lenguaje de Bajo Nivel (Ensamblador): es un lenguaje que usa el programador para codificar sentencias simbólicas que un compilador (programa traductor) puede convertir una a una en instrucciones de lenguaje de máquina. Hace uso de mnemotécnicos o abreviaturas, para representar las instrucciones de máquina.

Ventajas:

• No es tan complicado como el lenguaje de máquina. • Eficiente en el manejo de recursos.

Desventajas son:

• Cada procesador tiene su propio juego de instrucciones en ensamblador. • Debe ser traducido (ensamblado).

Lenguaje de Alto Nivel: es un lenguaje de programación orientado al problema o procedimientos, es cercano al idioma humano. Ejemplos de estos lenguajes son COBOL, PL/I, FORTRAN, Java, etc.





Algunos lenguajes de alto nivel se denominan Lenguajes de Programación Orientado a Objetos (ó OOPL). Ejemplos de éstos son: Smalltalk, Java, C++, Eiffel, etc.

Ventajas:

• Son independientes del procesador. • Son mucho más fáciles de aprender, implementar y mantener. • Tienen un carácter genérico.

Desventajas son:

• Menos eficientes en el manejo de los recursos. • Requiere de un proceso de traducción (compilación).

Compilar: Es traducir un programa escrito en un lenguaje de alto nivel a un programa en lenguaje de máquina, que es la forma en que la computadora puede ejecutar directamente las acciones o instrucciones. Típicamente una instrucción de alto nivel se compila o traduce, en muchas instrucciones de lenguaje de máquina.

En algunos casos, el proceso de compilación se descompone en dos pasos:

• Compilar las instrucciones de alto nivel para producir lo que se denomina el código objeto.

• Enlazar (link) que es tomar el código objeto generado y cualquier otro código objeto que sea requerido, que haya sido previamente generado y colocarlos juntos, produciendo así el programa ejecutable o código ejecutable.

Base de Datos: Es una colección de datos completa e integrada, organizada para evitar duplicados, que permite recuperar información para satisfacer a una amplia variedad de usuarios.

Sistema Operativo: Es una colección organizada de software que se usa para ayudar y controlar las operaciones de una computadora.

Almacenamiento: Se refiere a un dispositivo en el que los datos se pueden ingresar, guardar y posteriormente recuperar.

7. Crear un Programa de Computadora Para crear un programa de computadora, generalmente el programador debe partir de un algoritmo y escribir las sentencias (instrucciones) del código fuente en un editor. Un editor es un programa utilitario que permite la edición de textos y programas. Existen muchos editores que están diseñados específicamente para ayudar en la creación del programa fuente. Algunos incluso siguen la especificación de un lenguaje particular.

El conjunto de sentencias fuente se denomina un “programa fuente”. El programa fuente es la entrada para el compilador, que lo convierte en un conjunto de comandos entendibles por el computador llamado “programa ejecutable.”





Si se encuentra algún error en la sintaxis de los comandos en el programa fuente, el compilador listará cada uno de ellos y no producirá el programa ejecutable. El programador debe repetir los pasos de editar/compilar hasta que no se encuentren errores de compilación.

La Figura 1.2 presenta en forma esquemática los pasos para crear un programa de computadora.

Figura 1.2: Creación de un Programa de Computadora

8. Funcionamiento del Compilador/Enlazador Previo a la creación del programa ejecutable, el compilador, si no detecta errores de sintaxis, crea un programa objeto y un listado del programa fuente. La Figura 1.3 muestra la creación del programa ejecutable, partiendo del programa fuente, con un paso de enlace (link) involucrado.

El programa objeto, producido por el compilador, se usa como la entrada al enlazador para realizar lo que se llama el paso de “edición de enlace”. El enlazador, combina el programa objeto recién creado con otros programas objeto ya existentes, produciendo





el programa ejecutable. Los otros programas objeto generalmente residen en un archivo en disco llamado “Librería de Enlace”.

Figura 1.3: Compilador / Enlazador

9. Datos, Tipos de Datos y Funciones Incorporadas Un programa de computadora, para que pueda ser ejecutado, debe ser cargado en memoria. La unidad de procesamiento del ordenador sólo puede trabajar con los datos e instrucciones que residen en la memoria.

9.1 Dato

El dato es cualquier objeto o elemento de información que se usa a lo largo de diversas operaciones dentro de un programa o fragmentos de éste. Los datos son los elementos sobre los que se opera cuando se efectúa una operación en el computador, es decir, cuando se ejecuta una instrucción en un programa.

Un dato tiene un nombre que lo identifica y distingue de los demás elementos del programa. Dicho nombre no es más que otra forma de referenciar la dirección de memoria que ocupa el dato, así que cuando se trabaja con el nombre del dato, en realidad se trabajar con el valor que se encuentra en esa dirección de memoria.

Cuando se está trabajando con un programa de computadora, siempre se está trabajando con direcciones de memoria, es por ello que es una estrategia común referenciar esas posiciones de memoria por medio de nombres o identificadores significativos para los humanos. En otras palabras, un programa de computadora es una serie de instrucciones organizadas para manipular y trabajar con direcciones de memoria en un computador.

Los datos pertenecen a un tipo de dato específico, lo cual le indica al computador el rango de valores que dicho dato puede aceptar y las operaciones que sobre él se pueden realizar.

Compilación

Programa fuente

Programa Objeto Compilador Enlazador

Programa Ejecutable

Librerías de enlace

Enlace

Compilación





Por último, los datos poseen un valor que bien puede cambiar o permanecer constante a lo largo del programa o mientras el dato esté disponible.

9.2 Tipo de Dato

El tipo de dato es una definición que agrupa los valores válidos para un conjunto de datos y las operaciones que sobre ellos se pueden realizar. Normalmente, se puede establecer una relación de orden sobre los datos de naturaleza escalar o con valores determinísticos.

Cada tipo de dato tiene una representación determinada en el computador. Esto tiene que ver con el tamaño o la cantidad de memoria que el computador reserva para almacenar los datos de un tipo especifico cualquiera. Todo, absolutamente todo, en la memoria de un computador se representa por medio de código binario, un código binario es un número en base 2, cuyos dígitos son ceros o unos. De esta manera, un código cualquiera puede ser tratado como un número entero en un momento dado, como un carácter en otro o en cualquier otra forma diferente de acuerdo a las necesidades del programa.

Los tipos de datos pueden ser:

• Tipo dato primitivo: Tipos básicos o simples predefinidos en el sistema. • Tipo de dato definidos por el usuario: Agregados por el programador.

Los tipos de datos primitivos más importantes son: numéricos, lógicos y carácter. A continuación se detalla cada uno de ellos:

• Numéricos: Pueden ser a su vez: - Entero: Subconjunto finito del conjunto matemático de los números enteros. No

tiene parte decimal. El rango de los valores depende del tamaño que se les asigne en la memoria para su representación, este tamaño es definido por el lenguaje de programación, usualmente 2 bytes.

- Real: Subconjunto finito del conjunto matemático de los números reales. Llevan signo y parte decimal. Se almacenan usualmente en 4 bytes o más (dependiendo del lenguaje de programación que se utilice). Si se utilizan números reales muy grandes, se puede usar notación científica que se divide en mantisa, base y exponente. De tal forma que el valor se obtiene multiplicando la mantisa por la base elevada al exponente.

• Lógicos o booleanos: Es aquel que sólo puede tomar uno de los dos valores, verdadero o falso (1 ó 0). Este es el tipo de dato que retorna todas las operaciones lógicas.

• Carácter: Abarca al conjunto finito y ordenado de caracteres que reconoce la computadora: letras, dígitos, caracteres especiales, ASCII, UNICODE. Generalmente, sus valores se representan dentro de un par de comillas simples, aunque también se puede suministrar su código numérico o posición dentro del conjunto de caracteres válidos que se esté usando.





• Tipo cadena o string: Conjunto de caracteres, que usualmente se presentan entre los símbolos de comilla doble (“”).

Los diversos lenguajes existentes pueden añadir más tipos de datos u otros modificadores. Por ejemplo, el modificador Long se usa comúnmente con los tipos entero (int) para indicar un entero de gran tamaño (Long int).

En algunos lenguajes se definen tipos especiales para la fecha y hora, sobre todo en los lenguajes modernos, tales como Java.

9.3 Variables

Las variables son instancias de un tipo de dato determinado, cuyo valor puede cambiar durante la ejecución del programa o corrida del algoritmo.

Antes de usar una variable, el programador debe definirla o declararla, indicando su nombre y el tipo de dato al que pertenece.

El nombre que se elija para una variable se denomina identificador y debe ser un nombre significativo que esté relacionado con el propósito para el que se vaya a usar la variable en el programa.

El identificador de una variable será un conjunto de caracteres que tendrán ciertas restricciones, según lo defina el lenguaje de programación. Por lo general, el identificador de una variable tiene que empezar por una letra, el tamaño y caracteres permitidos como parte del identificador dependen del lenguaje de programación.

Algunos lenguajes de programación asignan un valor por omisión o defecto a las variables, al momento de su declaración. En cualquier caso una variable puede tomar un valor inicial e ir cambiándolo a lo largo de la ejecución del programa o corrida del algoritmo. Al momento de asignar un valor inicial a una variable, se le denomina inicialización de la variable.

9.4 Variables Acumuladoras

Aquellas variables que el programador use para ir sumando valores a lo largo de la ejecución del programa, se denominan acumuladoras y es recomendable inicializarlas con un valor conveniente al uso que posteriormente se les dé.

9.5 Variables Contadoras

Se llaman así a las variables que el programador usa para ir contando a lo largo de la ejecución del programa.

9.6 Constantes

Las constantes son instancias de un tipo de dato determinado, que tienen un valor fijo asignado por el programador en el momento en que la define. Este valor no puede ser modificado durante la ejecución del programa o corrida del algoritmo.





Las constantes pueden llevar asociados un nombre o no, si no lo llevan, se llaman literales. El programador especifica su valor al definir la constante, que ya no puede cambiar a lo largo de la ejecución del programa. En cuanto al tipo de dato, hay que colocarlo o no dependiendo del lenguaje de programación. Si no hace falta colocarlo, es porque la constante tomará el tipo de dato del valor que se le asigne al definirla.

Por ejemplo: Const PI=3,1416.

La ventaja de usar constantes con nombre, es que en cualquier lugar donde quiera que vaya la constante, basta con colocar su nombre y luego el compilador lo sustituirá por su valor.

Las constantes sin nombres o literales son de valor fijo: 5, 6, ‘a’, “hola”.

9.7 Relación entre Variables y Constantes en Memoria

Al declarar una variable o constante con nombre, automáticamente se reserva en memoria espacio para guardarla. El espacio reservado depende del tipo de dato de la variable o constante. En esa zona de memoria, es en la que se guardará el valor asociado a la variable o constante. Cuando el programa use esa variable o constante, irá a ese lugar de la memoria a buscar su valor.

10. Expresiones: Tipos y Operadores Una expresión es una combinación de constantes, variables, signos de operación, paréntesis y nombres especiales (nombres de funciones estándar), con un sentido unívoco y definido. De la evaluación de una expresión resulta un único valor o resultado.

Una expresión tiene asociado un tipo de dato que corresponde con el tipo del valor que devuelve la expresión cuando se evalúa, por lo que habrá tantos tipos de expresiones como tipos de datos. En tal sentido, se tienen expresiones numéricas y lógicas.

10.1 Expresiones Numéricas: Operadores Aritméticos

La expresión numérica es una combinación de variables y constantes numéricas con operadores aritméticos, que al evaluarla devuelve un valor numérico.

Algunos de los operadores aritméticos más comunes son: +, -, *, / , los cuales equivalen a las operaciones suma, resta, multiplicación y división respectivamente.

Otras operaciones aritméticas soportadas en algunos lenguajes de programación son:

• Operador Resto o Módulo: Devuelve el resto de una división entera.





Lenguaje Operador Ejemplo Resultado

C % 5 % 2 1

Pascal mod 5 mod 2 1

Tabla 1.1: Operador Resto o Módulo

• Operador División Entera: Devuelve la parte entera del cociente de una división.


C / 5 / 2 2

Pascal Div 5 div 2 2

Tabla 1.2: Operador División Entera

• Operador Potencia: Devuelve el valor de una base elevada a una potencia dada.


Basic ^ 5 ^ 2 25

Tabla 1.3: Operador Potencia

Los operadores anteriores se denominan operadores binarios porque utilizan dos operando. Existen también otros tipos de operadores que sólo necesitan de un operando y se denominan operadores unarios.

Algunos de los operadores unarios más comunes son:

• El signo negativo: Operador unario que devuelve el valor actual del operando multiplicado por menos uno (-1).


C - X= 5; -X; X= -5;

Tabla 1.4: Signo Negativo

• Operador Decremento: Operador unario que devuelve el valor actual del operador decrementado en una unidad.






C -- X= 5; --X; X= 4;


• Operador Incremento: Operador unario que devuelve el valor actual del operador incrementado en una unidad.


C ++ X= 5; ++X; X= 6;


10.2 Reglas de Precedencia

El orden en que se evalúan los operadores aritméticos dentro de una expresión influye directamente en el resultado que retorna dicha expresión.

Ejemplo:

Sea la siguiente expresión aritmética: 2 + 3 * 2 + 3

Si se evalúa en el orden de aparición se tiene: (((2 + 3) * 2) + 3) = 13

Si se evalúa primero la suma (+) y luego la multiplicación (*) se tendrá la expresión:

(2 + 3) * (2 + 3) = 25

Si se evalúa primero la multiplicación y luego la suma se tendrá la expresión:

2 + (3 * 2) + 3 = 11

Entonces, ¿Cómo resolver está situación potencialmente problemática?

La solución es aplicar prioridad entre los operadores, de modo que ante la posibilidad de usar varios operadores aritméticos en una misma expresión, siempre se aplicará primero el de mayor prioridad.

Cada lenguaje de programación puede establecer sus propias reglas de prioridad o precedencia de operadores. Siempre se pueden utilizar los paréntesis ( ) para definir y cambiar el orden en que se evalúa una expresión aritmética dada.

El orden de precedencia definido comúnmente para los operadores aritméticos básicos es:

1. ^





2. *, /, div y mod 3. + y –

Entre dos operaciones que tienen la misma precedencia, para resolver la ambigüedad hay que usar la regla de la asociatividad. La más normal, es la asociatividad por la izquierda (primero lo de la izquierda).

De esta forma, la expresión 2+3 * 2 / 3 – 5 ^ 2 será evaluada como (2 + ((3 * 2) / 3)) – (5 ^ 2).

10.3 Expresiones Lógicas: Operadores Relacionales y Lógicos.

Una expresión lógica es aquella que sólo puede devolver uno de dos valores: verdadero o falso. Los operadores que pueden aparecer en una expresión lógica son de dos tipos: lógicos o relacionales. Los operadores lógicos sólo trabajan sobre expresiones o datos que retornan valores booleanos. Los operadores relacionales trabajan con expresiones numéricas para realizar comparaciones que retornan un valor booleano. Es común tener expresiones que combinan tanto los operadores lógicos como relacionales, en estas expresiones se evalúa más de una condición o relación por medio de operadores lógicos.

Los operadores relacionales más usados son:

< menor que > mayor que = igualdad (en C: ==) <> diferente (en C: !=)

≤ menor o igual que

≥ mayor o igual que

Para evaluar una expresión relacional:

• Se evalúa el primer operando y se sustituye por su valor. • Se evalúa el segundo operando y se sustituye por su valor. • Se aplica el operador relacional y se devuelve el valor booleano correspondiente.

Ejemplo: ((5 * 4) + 1 – (5 ^ 2)) < (2 - 1) - 4 < 1 la expresión retorna Verdadero Ejercicio:

Evaluar las siguientes expresiones si a la variable “x” se le asigna el valor 2 y a la variable “y” se le asigna el valor 4.

Cada respuesta debe ser VERDADERO o FALSO, según corresponda:





1. x == y : ___________ 2. x <> y : ___________ 3. y > x : ___________ 4. x >= y : ___________

El problema es que en algunos casos se requiere preguntar o evaluar más de una condición al mismo tiempo, para esto, están los operadores lógicos.

Los operadores lógicos más utilizados son:

Y (and, &&) O (or, ||) No (not, ~, !) O exclusivo (xor, ^)

Y, O y O exclusivo son operadores binarios.

Estos operadores trabajan bajo el esquema: <Operando 1> Operador <Operando 2>

El operador No es de tipo unario y se coloca precediendo al operando al que se niega.

La tabla de verdad para los operadores lógicos binarios es como sigue:

Operando 1 Operando 2 AND OR XOR

V V V V F

V F F V V

F V F V V

F F F F F

V= Verdadero; F= Falso Tabla 1.5: Tabla de Verdad para los operadores lógicos binarios

La tabla de verdad para el operador unario No es como sigue:

NOT Operando

V F

F V

Tabla 1.6: Tabla de Verdad para el operador unario “No”





Se observa que para que el operador lógico AND sea Verdadero, es necesario que ambos operandos sean Verdaderos.

Para que el operador lógico OR sea Verdadero, basta con que al menos uno de sus operandos sea Verdadero.

Para que el operador XOR sea Verdadero, ambos operandos deben ser diferentes entre sí.

Ejercicio:

Si x representa “1 > 2” (FALSO) e y representa “4 < 8” (VERDADERO)

Cuál es el resultado de cada una de las siguientes expresiones:

1. NOT x : ___________ 2. x AND y : ___________ 3. y OR x : ___________ 4. (NOT x) AND y : ___________ 5. x XOR y : ___________

11. Funciones Incorporadas Las funciones Incorporadas son funciones adicionales a las operaciones básicas, que se incorporan al lenguaje de programación. Se consideran estándar en la mayoría de lenguajes de programación. Son dependientes del lenguaje y normalmente se encuentran en librerías externas que se pueden incluir en un programa. La sintaxis exacta y el nombre de las funciones pueden variar de un lenguaje a otro, pero la funcionalidad suele mantenerse entre las diversas herramientas de programación.

Las más comunes son las librerías de soporte matemático y las de entrada / salida.

Todos los lenguajes de programación proporcionan mecanismos para incorporar diversos elementos que brinden funcionalidad extra a los programas. La Tabla 1.7, muestra la forma en que algunos lenguajes de programación populares incorporan funcionalidad extra.

Lenguaje Sentencia Ejemplo

Pascal use use conio;

C y C++ #include<> #include<iostream.h>

Java import Import java.io.*;

Tabla 1.7: Funcionalidad extra de algunos programas





12. Operación de Asignación La operación de asignación consiste en atribuir un valor a una variable. El valor asignado puede ser una expresión, una constante o el valor de otra variable.

Las formas más comunes del operador de asignación se resumen en la Tabla 1.8:

Lenguaje Operador Ejemplo

Pascal := var := 5 + 3;

C y C++ = var = var + 5;

Java = var = Math.sin(90.0);

Tabla 1.8: Operador de Asignación

En los ejemplos de la tabla anterior, var representa la variable a la que se le asigna el valor dado en la expresión a la derecha del operador de asignación.

El proceso de asignación se realiza en 2 fases:

• Se evalúa la expresión de la parte derecha de la asignación obteniéndose un único valor.

• Se asigna ese valor a la variable de la parte izquierda.

Debe tenerse en cuenta:

• En la parte izquierda de la operación de asignación, sólo puede haber una variable.

• La variable a la que se le asigna el valor pierde su valor anterior. • Si la variable a la que se le asigna un valor (parte izquierda) participa en la

expresión a evaluar (parte derecha), como por ejemplo la sentencia: x = x + 1 , entonces como primero se evalúa la expresión antes de realizar la asignación, el valor usado en la expresión es el que tenía la variable antes de la operación. En el ejemplo dado si x tenía un valor igual a 5, entonces la evaluación de la expresión x = x + 1 sería x = 5 + 1, quedando x con un valor final de 6.

• El tipo de dato del valor resultante al evaluar la parte derecha de una operación de asignación, tiene que ser del mismo tipo de dato o de un tipo compatible, con la variable a la cual se le va a asignar el resultado de la operación. Muchos lenguajes de programación imponen sus propias reglas de conversión de tipos de datos, definiendo cuáles son las operaciones permitidas entre los diversos tipos de datos.





13. Recomendaciones Cuando se programa existen una serie de problemas y errores de programación que tienden a presentarse una y otra vez en los programas.

Para minimizar la ocurrencia de errores en la programación, es aconsejable que se consideren las siguientes recomendaciones:

• Reutilizar código probado: Puede existir un código ya desarrollado y probado para resolver totalmente o parte del problema que pueda utilizarse. Esto facilita la solución del problema y minimiza el tiempo de desarrollo. Al reutilizar código no se desperdicia tiempo depurando una parte de la lógica que se sabe que funciona.

• No asumir los datos de entrada como válidos: Si no se tiene ningún control sobre la fuente de los datos, no se tiene ningún control sobre la calidad de los mismos.

• No asumir que los datos de entrada están en la secuencia correcta. • Verificar siempre la secuencia: Es muy fácil para alguien proporcionar datos

erróneos. • Diseñar los tamaños de los campos de datos, de modo que tengan capacidad

para contener el valor más grande permitido. • Usar comentarios libremente. Explicar cualquier cosa que pueda confundir a un

futuro lector, además de señalar cualquier área que pueda estar sujeta a cambios.

• Hacer programas legibles y fáciles de entender. • Usar nombres adecuados para las variables, que sean auto descriptivos. • Usar sangrías, alineación y espacios donde sea necesario (líneas blancas y

columnas).





Resumen Ahora que ha completado esta unidad, usted debe ser capaz de:

• Definir el propósito y el contenido de un programa de computadora. • Utilizar una metodología para resolver problemas de procesamiento de datos. • Describir el funcionamiento de un compilador/enlazador. • Definir el concepto de Dato. • Describir los diferentes tipos de datos y las operaciones incorporadas a los

lenguajes de programación. • Presentar las recomendaciones que ayudan a programar con estilo.





Unidad 1: Examen de Autoevaluación 1) ¿Cuáles de los siguientes son lenguajes de alto nivel?

a) Cobol b) Fortran c) Java d) Ensamblador

2) Se entiende por algoritmo, un conjunto de reglas bien definidas para la solución de

un problema en un número de pasos que podría no ser finito. a) Verdadero b) Falso

3) Seleccione las afirmaciones correctas en referencia a un programa de

computadora. a) Es una solución a un problema b) Es una caja mágica c) Es un conjunto de instrucciones hechas para ejecutarse en una computadora d) Todas las anteriores

4) Para diseñar un programa de computadora se requiere de un proceso que cumpla

con las siguientes características: a) Actualizable b) Fácil de mantener c) No estructurado d) Ninguna de las anteriores

5) Seleccione las afirmaciones correctas:

a) El conjunto de sentencias creadas para resolver un problema se denomina "programa fuente"

b) Un compilador convierte un programa fuente en un programa ejecutable c) Si se encuentran errores de sintaxis en las instrucciones del programa fuente,

el compilador lista cada uno de ellos y produce un archivo ejecutable d) Ninguna de las anteriores





6) ¿Cuáles de los siguientes son lenguajes de programación orientado a objetos? a) Java b) C c) C++ d) Cobol

7) Compilar es traducir un programa escrito en un lenguaje de máquina en un

programa de alto nivel; forma en la cual la computadora puede ejecutar acciones o instrucciones. a) Verdadero b) Falso

8) Para minimizar la ocurrencia de errores en la programación se recomienda revisar

que los programas cumplan con lo siguiente: a) Reutilización de código b) Asumir que todas las entradas de usuario son correctas c) Verificar que la secuencia de entrada de datos es la requerida por el programa d) Que las instrucciones sean legibles y fáciles de entender

9) Un sistema operativo es una colección organizada de software que se usa para

ayudar y, en parte, controlar las operaciones de una computadora. a) Verdadero b) Falso

10) ¿Cuáles de los siguientes son dispositivos de almacenamiento?

a) Teclado b) Cinta magnética c) Impresora d) Otra computadora





Respuestas de la Unidad 1: Examen de Autoevaluación

1) a, b y c 2) b 3) a y c 4) a y b 5) a y b 6) a y c 7) b 8) a, c y d 9) a

10) b y d


Unidad 2: Conceptos de Diseño Estructurado Libro 1: Fundamentos de Programación 29



Unidad 2: Conceptos de Diseño Estructurado


• Listar las características del Diseño Estructurado. • Definir los conceptos de diseño Top-Down. • Describir los Diagramas de Estructura, Diagramas de Flujo y Diagramas de Nassi

– Schederman. • Definir el concepto de Pseudocódigo.


Libro 1: Fundamentos de Programación Unidad 2: Conceptos de Diseño Estructurado 30



1. Introducción Existen técnicas para facilitar el entendimiento de un problema en términos que permitan desarrollar un algoritmo que ofrezca una solución y que, posteriormente, conlleve al desarrollo de un programa que solucione el problema con la ayuda de un computador. Éstas técnicas son:

• El diseño Top-Down (de arriba hacia abajo). • Los diagramas de estructura. • Los diagramas de flujo. • El pseudocódigo.

2. Conceptos de Diseño Estructurado El diseño estructurado es una metodología para el desarrollo de programas, que puede ser definida a través de las siguientes características:

• El sistema desarrollado siguiendo el diseño estructurado tendrá una entrada y una salida, con variaciones ocasionales.

• El diseño estructurado divide el problema a resolver en partes o módulos. • El diseño estructurado evita el uso de la sentencia GOTO (sentencia que se utiliza

para desviar el flujo normal de un programa; la desventaja de esta sentencia es que el seguimiento del programa puede ser desde difícil hasta imposible).

3. Diseño Top Down El diseño top down o “refinamiento paso a paso”, establece que debe irse de lo más general a lo más específico y se define como el proceso de dividir un problema en sub-problemas más pequeños.

Para entender el diseño top down se presenta a continuación un problema ejemplo y se discute cómo se aplica esta técnica en el diseño de programas.

Enunciado del problema:

Se le ha solicitado que escriba un programa para una tienda de videos que tenga como objetivo permitir que un cliente, previamente registrado en la tienda, alquile videos.

Ya existe un sistema para llevar el control del inventario de películas y registro de clientes.

La tienda tiene un conjunto de reglas que deben cumplirse para que un cliente alquile un video. Estas son:

• Un cliente es un miembro registrado. • El cliente no debe tener alquileres vencidos.





• El cliente no debe nada a la tienda. • La película está en inventario. • La película no está reservada.

Un programa de alto nivel será: Alquilar un video.

Al descomponer este programa de alto nivel, se obtienen los siguientes sub-programas:

• Verificar si el cliente es un miembro registrado. • Verificar si tiene alquileres vencidos. • Verificar si el miembro debe dinero. • Verificar si la película está en el inventario. • Verificar si la película está reservada.

Al descomponer de nuevo cada uno de los pasos anteriores, se obtiene:

1. Verificar si el cliente es un miembro registrado:

• Ingresar una identificación del cliente en el sistema. • Verificar si el sistema ha encontrado un perfil que coincida con este cliente.

2. Verificar los alquileres vencidos:

• Ver si el perfil refleja cualquier alquiler vencido en el sistema. 3. Verificar si el miembro debe algún dinero:

• Ver si el perfil refleja algún cargo pendiente. 4. Verificar si la película está en el inventario:

• Ingresar el nombre de la película al sistema. • Verificar si hay alguna copia que no esté alquilada.

5. Verificar si la película está reservada:

• Ver si las copias que no están alquiladas están reservadas. De nuevo, al descomponer el sub-programa “Verificar si el cliente es un miembro registrado”: 1.1. Verificar si el cliente es un miembro registrado:

• Preguntar la identificación al cliente. 1.2. Ingresar la identificación en el sistema:

• Seleccionar del menú la opción de “verificar la identificación del miembro”. • Ingresar la identificación del cliente en el prompt.





• Presionar la tecla que indica al sistema que está listo, para que éste verifique por un número que coincida con el que se ha ingresado.

1.3. Leer la pantalla para ver si el sistema ha encontrado alguna coincidencia:

• Verificar visualmente si el sistema dice ‘sí ' o ‘no ' es un miembro.

4. Diagramas de Estructura Un diagrama de estructura es una manera gráfica de representar el diseño top down. Permite representar en forma clara la organización de alto nivel de un programa.

La Figura 2.1 muestra un diagrama de estructura parcial del problema presentado en el punto anterior.

Figura 2.1: Diagrama de Estructura del Problema Ejemplo

5. Diagramas de Flujo o Flujograma Un diagrama de flujo es una representación gráfica de la lógica del diseño. Generalmente, presenta un nivel de detalle mucho mayor que los diagramas de estructura.

Un diagrama de flujo resulta adecuado cuando se desea obtener mayor detalle, tal como agregar bifurcación de condicionales y/o iteraciones.

En todo diagrama de flujo, siempre habrá una caja de inicio y otra de fin para el principio y final del algoritmo.

Alquilar una

Película

Verificar si es un

miembro

Verificar alquileres vencidos

Verificar deudas

pendientes Verificar si

película está

Verificar si no está

reservada

Preguntar identifica-

ción

Ingresar identifica-

ción Examinar

perfil





5.1 Los símbolos A continuación los símbolos más comunes que se usan en un diagrama de flujo:

Flechas o Líneas de Flujo: sirven para conectar los símbolos del diagrama. La flecha indica la secuencia en la que se van a ejecutar las acciones.

Símbolo de Proceso: Indica la acción que tiene que realizar la computadora. Dentro se escribe la acción.

Entrada/Salida: Representa las acciones de entrada y salida. Dentro se colocan las acciones de lectura y escritura.

Condición: En el rombo se coloca una condición, al encontrar este signo, se evalúa la condición que hay dentro. Según la condición, sea verdadera o falsa, se toma un camino u otro. Sirve para representar estructuras selectivas y repetitivas.

Principio y Fin: Dentro del símbolo va la palabra inicio o fin del algoritmo.

Subprograma: Dentro se coloca el nombre del subprograma al que se llama.

Conectores: Sirven cuando un flujograma no cabe en una columna de la hoja y hay que seguir en otra columna. Se colocan uno donde termina la columna y otro donde empieza. Hay 2 tipos: - Si es en la misma hoja.

- Si es en una hoja distinta.

Aclaratoria: Se usa para añadir comentarios que permitan entender mejor el código, no es parte del código.





5.2 Otros Símbolos

Pantalla: Cuando una salida es por pantalla.

Teclado: También se usa para representar una entrada por teclado.

Impresora

Entrada/Salida por Disco

Las bifurcaciones condicionales se ejecutan según una determinada condición, es decir, si la condición es verdadera se ejecuta un bloque del proceso, si es falsa se ejecuta un bloque diferente.

Una iteración es cuando en un segmento de un algoritmo, los pasos se repiten un número determinado de veces mientras se cumple una determinada condición.

La metodología para representar un problema utilizando diagramas de flujo, se describe en la Figura 2.2.





5.3 Metodología para Resolver un Problema con Diagramas de Flujo

Figura 2.2: Metodología para Resolver un Problema con Diagramas de Flujo

Determinar requerimientos del proceso

Determinar requerimientos del post-proceso

Fin

¿Diagrama Flujo OK?

Crear Diagrama de Flujo

Verificar Diagrama de Flujo

NO

SI

Inicio





6. Recomendaciones para hacer Diagramas de Flujo • El diagrama debe mostrar claramente donde inicia y donde termina. • Cualquier camino que se siga, debe conducir al fin. • Los símbolos deben estar organizados de tal forma, que visualmente el flujo vaya

de arriba abajo y de izquierda a derecha. • No debe usarse lenguajes de programación dentro de los símbolos. • El diagrama debe estar centrado dentro de la página. • Las flechas deben ser verticales u horizontales, nunca diagonales. • No deben cruzarse las flechas, para evitar esto están los conectores. • No abusar de los conectores. • A un símbolo sólo debe llegar una flecha, si fuese necesario otras flechas

entrantes, estas deben llegar a un conector. • Las flechas deben entrar a los símbolos por arriba o por la izquierda,

preferiblemente. • Debe tratarse de que el diagrama se ajuste a una página, de no ser posible debe

usarse un conector.

7. Ejemplo de un Diagrama de Flujo Ejemplo 2.1

Calcular el producto de los números positivos introducidos por teclado. El proceso finaliza cuando se ingresa un número negativo o un cero.

Algoritmo:

1. Iniciar la variable que va a contener el producto.

2. Leer el primer número.

3. Preguntar si es negativo o positivo.

4. Si es negativo o cero se sale de la iteración y se escribe el producto.

5. Si es mayor que cero, se multiplica el número leído y se lee un nuevo número. Se vuelve al paso 2.





Figura 2.3: Diagrama de Flujo para el cálculo del producto de enteros

Fin del Ejemplo 2.1

8. Diagramas N-S o de Nassi-Schederman: Es una forma de representación semejante al flujograma o diagrama de flujo, pero sin flechas y cambiando los símbolos de condición y repetición. Está conformado por una serie de cajas de procesos que constituyen las secuencias de acciones necesarias para presentar el algoritmo. Las cajas de proceso o acción van unidas entre sí. Los Diagramas N-S son muy útiles para representar diagramas estructurados.

A continuación en la Figura 2.4 se observa la representación de las condiciones.

INICIO

P = 1

LEER NUM

NUM > 0P = P x NUM

ESCRIBIR P

FIN

SI

NO





INICIO

p = 1

Leer num

Mientras (num > 0)

p = p x num

Leer num

Escribir p

FIN

Figura 2.4: Representación de Condiciones

Seguidamente, se presenta la Figura 2.5 en la cual se representan las estructuras repetitivas:

Figura 2.5: Estructuras Repetitivas

A continuación se presenta nuevamente el problema de determinar el producto de un conjunto de enteros, cuya solución es representada en esta oportunidad mediante un diagrama de N-S. Para ello, observe la Figura 2.6.

Figura 2.6: Diagrama de N-S para el Cálculo del Producto de Enteros

Mientras <Condición>

<Acciones>

<Acciones>

Repetir Hasta <Condición>

Desde Var = V1 Hasta V2

<Acciones>

Condición

<Acciones> <Acciones>

SI NO





9. Pseudocódigo El pseudocódigo es un lenguaje de documentación de programas similar al español o al inglés (se parece a cualquier lenguaje de programación de alto nivel). No necesita seguir ninguna regla específica, como por ejemplo ser requerido por los programas que van a ser traducidos o compilados. El pseudocódigo normalmente no es muy específico para las áreas de E/S.

No hay ningún estándar en la industria definido para escribir pseudocódigo y tiene la ventaja de que se puede crear fácilmente con cualquier editor de texto.

Un ejemplo de pseudocódigo parecido a PL/I, se muestra a continuación: do while( count = 0 ) do process count = count - 1 end

Un ejemplo de pseudocódigo parecido a COBOL:

perform until count = 0

perform process

subtract 1 from count

end-perform

El pseudocódigo también puede utilizar una serie de palabras claves o palabras especiales que van indicando lo que significa el algoritmo.

Ejemplo 2.2 Ejemplo de palabras claves en pseudocódigo:

1. Inicio y Fin: Por donde empieza y termina el algoritmo.

2. Si <condición>

3. Entonces <acciones>

4. Sino <acciones>

5. Mientras <condición> hacer

6. Repetir / hasta <condición>

7. Desde / hasta

8. Según sea (Para evaluar opciones múltiples)

Nota: Se debe tomar en cuenta que los comentarios van encerrados entre llaves y hay que utilizar sangría al escribir el código. La estructura recomendada para los algoritmos en pseudocódigo es:





Algoritmo <nombre algoritmo> Var <nombre>: <tipo> Inicio <Instrucciones> Fin

Se presenta el pseudocódigo para el ejemplo de determinar el producto de un conjunto de enteros:

1. Algoritmo Producto

2. Var p, num: entero

3. Inicio

4. p = 1

5. Leer num

6. Mientras num > 0 hacer

7. p = p * num

8. Leer num

9. Fin mientras

10. Escribir p

11. Fin

Fin del Ejemplo 2.2






• Listar las características del Diseño Estructurado. • Definir los conceptos de diseño top-down. • Describir los Diagramas de Estructura, Diagramas de Flujo y Diagramas de Nassi

– Schederman. • Dibujar un diagrama de estructura para mostrar la jerarquía de un programa. • Definir el concepto de Pseudocódigo.





Unidad 2: Examen de Autoevaluación 1) El pseudocódigo es un lenguaje de documentación que:

a) Necesita una sintaxis específica b) Necesita ser traducido pero no compilado c) Se puede crear fácilmente d) Ninguna de las anteriores

2) En diseño estructurado, el proceso de dividir un problema en subproblemas más

pequeños se conoce como: a) Diagrama de flujo b) Diagrama de estructura c) Refinamiento paso a paso d) Diseño Top – Down

3) ¿Cuáles de las siguientes afirmaciones son verdaderas sobre diseño estructurado?

a) Tiene una entrada y una salida b) Divide el problema en sub-problemas. c) Elimina el uso de la sentencia GO TO d) Ninguna de las anteriores

4) El refinamiento paso a paso puede representarse gráficamente con un:

a) Diagrama de clases b) Árbol binario c) Diagrama de estructura d) Diagrama de secuencia

5) Para la representación de un problema, cumple la misma función utilizar un diagrama

de flujo o un diseño top-down. a) Verdadero b) Falso

6) Si un algoritmo se representa en un diagrama de flujo, entonces no se puede

representar en pseudocódigo. a) Verdadero b) Falso





7) Cuando se trabaja con programas grandes se hace difícil: a) El refinamiento paso a paso b) La representación gráfica de la lógica del diseño c) Probar totalmente el código d) Todas las anteriores

8) Un diagrama de flujo es:

a) La representación de un algoritmo en un lenguaje de alto nivel b) La representación gráfica de la lógica del diseño c) Un refinamiento “paso a paso” d) Ninguna de las anteriores

9) ¿Indique cuáles de las siguientes son características del pseudo-código?

a) Es un lenguaje de documentación similar al ingles o español b) Normalmente no es muy específico para las áreas de entrada y salida c) Se puede compilar para revisar las fallas de sintaxis d) Se puede crear fácilmente con cualquier editor de texto

10) ¿Cuál es la forma de representación del diseño top-down?

a) Diagrama de Flujo b) Algoritmos c) Pseudocódigo d) Diagrama de Estructura





Respuesta de la Unidad 2: Examen de Autoevaluación 1) c 2) c y d 3) a, b y c 4) c 5) b 6) b 7) d 8) b 9) a, b y d

10) d


Unidad 3: Programación Estructurada Libro 1: Fundamentos de Programación 45



Unidad 3: Programación Estructurada Objetivos del Aprendizaje

Al finalizar esta unidad usted será capaz de:

• Conocer las técnicas de programación estructurada. • Trabajar con las estructuras secuenciales. • Trabajar con las estructuras selectivas. • Trabajar con las estructuras repetitivas. • Conocer la anidación de bucles y condicionales. • Realizar el control de datos de entrada.


Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada 46



1. Introducción La característica fundamental de la programación estructurada es que se basa en el uso únicamente de tres estructuras de control y se apoya en los siguientes conceptos:

• Recursos Abstractos: Son los recursos que se tienen en el momento de programar y que se irán transformando en recursos concretos.

• Diseño Descendente (top down): Se trata de ir descomponiendo el problema en niveles o pasos cada vez más sencillos, de forma que la salida de una etapa va a servir como entrada de la siguiente. En las primeras etapas se toma el punto de vista externo, es decir, qué entradas se tienen y qué salidas se producen. A medida que se avanza en la descomposición del problema, se van concretando las abstracciones, es decir cómo en efecto se resuelve.

• Estructuras Básicas de Control: Para construir un programa se siguen los pasos de razonamiento anteriores y al final se codifica el programa usando tres tipos de estructuras: repetitivas, alternativas y secuenciales.

Al final todo programa tendrá una única entrada y una única salida. Desde la entrada tienen que existir caminos que permitan pasar por todas las partes del programa y llegar a la salida. Se permiten los bucles infinitos.

2. Estructuras Secuenciales En las estructuras secuenciales una instrucción sigue a otra en secuencia, es decir, la salida de una instrucción es la entrada de la siguiente. Observe la Figura 3.1.

FLUJOGRAMA DIAGRAMAS N-S PSEUDOCÓDIGO Leer num

num=num*2 Escribir num

Leer num num=num*2 Escribir num

Leer num num = num * 2 Escribir num

Figura 3.1: Estructuras Secuenciales





3. Estructuras Selectivas En este tipo de estructuras se evalúa una condición y en función del resultado lógico (verdadero o falso) u otro resultado se ejecuta un conjunto de instrucciones. Son también denominadas estructuras de control de flujo, estructuras condicionales o de toma de decisiones. Hay tres tipos de estructuras selectivas: simples, dobles o múltiples.

3.1 Estructura Selectiva Simple

La estructura selectiva simple es la estructura condicional elemental y básica. Presenta la forma:

Si <condición> entonces

<acciones>

Fin si

En esta estructura condicional se evalúa la condición, si el resultado es verdadero se ejecuta el conjunto de acciones asociadas al bloque, entonces si el resultado es falso no se ejecuta acción alguna. Esto está representado en la Figura 3.2.

FLUJOGRAMA DIAGRAMAS N-S PSEUDOCÓDIGO

|

Si <condición>

entonces

<acciones>

Fin si

Figura 3.2: Estructura Selectiva Simple

3.2 Estructura Selectiva Doble

La estructura selectiva doble es una estructura condicional que evalúa una condición dada. Si es verdad, se ejecutan el conjunto de acciones asociadas a la parte del ‘si’, si es falso se ejecutan el conjunto de acciones asociadas a la parte del ‘no’. En la siguiente figura se podrá observar con detalle esta estructura.

Condición

Acciones

si

no SI NO

Acciones

Acciones

Condición





Figura 3.3: Estructura Selectiva Doble

3.3 Estructura Selectiva de Alternativa Múltiple

En la estructura selectiva de alternativa múltiple se evalúa una condición o expresión que puede tomar “n” valores distintos. Según sea el valor de la expresión en un instante dado, se ejecutarán las acciones correspondientes a ese valor. En realidad equivale a un conjunto de condiciones anidadas. En muchos lenguajes de programación se conocen como sentencias Case o Switch.

Es una sentencia de la forma:

Según sea <expresión>

<valor1>: <acciones 1>

<valor2>: <acciones 2>

[<otro> : <acciones n>]

fin según

Las acciones asociadas a la opción ‘Otro:’ se ejecutan cuando la expresión no toma ninguno de los valores que aparecen antes. En algunos lenguajes de programación se le conoce como alternativa ‘Otherwise’, ‘Else’ o ‘Default’.

El valor con el que se compara la expresión es dependiente de los lenguajes de programación. Por lo general, se espera un tipo de dato determinístico y con valores secuenciales, tales como los enteros y caracteres. En general, ese valor puede ser un valor constante, un rango de valores determinístico o incluso otra condición. La Figura 3.4 representa una Estructura Selectiva de Alternativa Múltiple.

Si <condición> entonces <acciones> Sino <acciones> Fin si

PSEUDOCÓDIGO DIAGRAMAS N-S FLUJOGRAMA

condicióncondición

acciones

acciones

acciones

acciones acciones

Si

Si

No

No





Figura 3.4: Estructura Selectiva de Alternativa Múltiple

Ejemplo 3.1: Uso de la Estructura Selectiva de Alternativa Múltiple

Escribir un programa que dada una nota entera presente por pantalla un mensaje acorde a la nota suministrada según un rango de valores.

Var nota: entero Leer nota Según sea nota

1..4: escribir “suspendido” 5..6: escribir “aprobado” 7..8: escribir “Notable” 9: escribir “Sobresaliente” 10: escribir “Cuadro de honor”

Fin según

Fin del Ejemplo 3.1

4. Estructuras Repetitivas o de Ciclo Las estructuras repetitivas o de ciclo representan un bucle o conjunto de instrucciones que se repiten un número finito de veces. Cada repetición del bucle se llama una iteración. Todo bucle tiene asociada una condición, que es la que va a determinar si debe ejecutarse el bucle y hasta cuando.

Existen tres tipos de básicos de estructuras repetitivas:

1. Mientras-hacer (while)

Según sea <expresión> <valor1>:<acciones> <valor2>:<acciones> <valor3>:<acciones> <valor4>:<acciones> [<otro> :<acciones>] Fin según


Expresión

V1

V2

V3 V4

V1

V2

V3 V4

Expresión

acciones





2. Repetir-hasta (repeat until)

3. Desde (for)

4.1 Estructura Repetitiva Mientras-Hacer

En la estructura repetitiva Mientras-Hacer, la condición de entrada al ciclo se evalúa antes de realizar cualquier iteración del bucle. Si la condición no se cumple, el ciclo no se ejecuta y el programa continúa con la secuencia de acciones siguientes al ciclo. Si la condición es verdadera, comienzan a ejecutarse las acciones del Mientras-Hacer.

Después de la última acción, se repite el proceso de evaluación de la condición, esto es, si la condición es verdadera de nuevo, entonces se repiten las acciones. Este proceso se conoce como un bucle y continua hasta que la condición sea falsa y la ejecución prosiga con la sentencia siguiente después del bucle.

Al evaluarse la condición la primera vez antes de entrar en el bucle, si la condición es falsa no se entra nunca en el bucle, en estas circunstancias el bucle nunca se ejecuta. Por lo tanto, se usará el bucle Mientras-hacer en el caso de que exista la posibilidad de que el bucle nunca deba ejecutarse.

Figura 3.5: Estructura Repetitiva Mientras-Hacer

4.2 Estructura Repetitiva Repetir-Hasta

En la estructura repetitiva Repetir-Hasta, la condición del ciclo se evalúa después de realizar la primera iteración del bucle. Este bucle se repite mientras la condición evaluada al final se mantenga falsa. Al cumplirse la condición y ser verdadera, se sale del bucle. De allí su nombre “repetir hasta” que se cumpla la condición.

Mientras <condición> Hacer <acciones> Fin mientras


Mientras <cond.> Hacer

<acciones>

acciones

condición

Si

No





Como la condición se evalúa al final, se pasa al menos una vez por el bucle. Es decir que cuando un bucle se tenga que ejecutar como mínimo una vez, se puede usar una estructura ‘repetir hasta’. Ver Figura 3.6.

Figura 3.6: Estructura Repetitiva Repetir-Hasta

En un ciclo ‘mientras-hacer’ se repite el bucle siempre que la condición sea verdadera, por el contrario, un ciclo ‘repetir-hasta’ se repite el bucle siempre que la condición sea falsa. A continuación un ejemplo.

Ejemplo 3.2

Leer 3 números y calcular su suma:

Mientras hacer Repetir hasta

cont = 0

suma = 0

Mientras (cont <> 3) Hacer

Leer num

suma= suma + num

cont= cont + 1

Fin mientras

cont = 0

suma = 0

Repetir

Leer num

suma= suma + num

cont= cont + 1

Hasta (cont == 3)

Fin del Ejemplo 3.2

4.3 Estructura Repetitiva Desde

La estructura repetitiva ‘Desde’ se usa cuando se sabe el número exacto de veces que se va ha ejecutar el bucle. El bucle lleva asociado una variable que se denomina variable

Repetir <acciones> Hasta <condición>

PSEUDOCÓDIGO

DIAGRAMAS N-S

FLUJOGRAMA

condición

Acciones

No

Si

<Acciones>

Repetir hasta <condición>





índice, a la que se le asigna un valor inicial y se establece cual va a ser su valor final. La variable índice se incrementa o decrementa de manera automática, en cada iteración del bucle, en un valor constante. El programador no se tiene que ocupar de actualizar el valor de esta variable en cada iteración del bucle; es una operación implícita.

Por lo tanto, en cada iteración del bucle, la variable índice se actualiza automáticamente y cuando alcanza el valor que se ha establecido como final, se termina la ejecución del bucle. Observe la Figura 3.7.

Figura 3.7: Estructura Repetitiva Desde

5. Estructuras Anidadas Las estructuras selectivas, como los bucles, se pueden escribir unas dentro de otras. Esto se conoce como estructuras anidadas.

En otras palabras, por ejemplo un ciclo ‘desde’ puede tener dentro de sus sentencias otro ciclo ‘desde’ o cualquier otra estructura estudiada anteriormente. También se pueden presentar anidaciones de estructuras condicionales.

5.1 Anidación de Condicionales

En muchas situaciones, se requiere evaluar un conjunto de condiciones en forma secuencial y separada. En estos casos, se recomienda utilizar una anidación de sentencias condicionales. La ventaja de anidar sentencias condicionales, es que cuando una se cumple no hay por que evaluar las condiciones que están debajo o que le siguen.

Sintaxis:

PSEUDOCÓDIGO

DIAGRAMAS N-S

FLUJOGRAMA

v = vi

v <= vf

no

acciones

v = v + 1

Desde v=vi hasta vf

<acciones>si

Desde <v=vi> hasta <vf> <acciones> Fin desde





Si <condicion1>

Entonces <sentencia1>

Sino si <condicion2>


Sino si <condicion2>


Fin si

Fin si

Fin si

La forma común de realizar el anidamiento es colocar la condición en la parte ‘no’ (else) de la sentencia.

La sentencia ‘según sea’ (case) siempre equivale a una anidación de condicionales, pero lo contrario no es cierto.

5.2 Bucles Anidados

Al igual que se pueden colocar unas expresiones dentro de otras, los bucles pueden estar unos dentro de otros. Al anidar bucles hay que tener en cuenta que el bucle interno funciona como una sentencia más en el bloque del bucle externo, por lo tanto, en cada iteración del bucle externo se van a ejecutar todas las iteraciones del bucle interno.

Los bucles deben estar bien formados y ser sintácticamente correctos para que pueda haber un anidamiento válido, en otras palabras, nunca pueden cruzarse las sentencias de los bucles. Si se tiene un ciclo ‘desde’ que internamente posee un ciclo ‘mientras hacer’, es necesario finalizar las sentencias o instrucciones del ciclo más interno, en este caso ‘mientras-hacer’ antes de colocar la culminación del ciclo externo ‘desde’.

Si el bucle externo se repite n veces y el interno se repite m veces y por cada iteración del externo se repite el interno, entonces el número total de iteraciones será el producto de m x n. Los bucles que se anidan pueden ser de igual o distinto tipo.

A continuación se presenta un ejemplo de anidamiento de bucle.

Ejemplo 3.3 1. Desde i=1 hasta 8

2. Desde k=1 hasta 5

3. Escribir “Profesor ” i ” introduzca su asignatura nº ” k

4. Leer asignatura

5. Fin desde

6. Fin desde





Note como cada ciclo interno termina antes de cerrar el más externo. No existen limitaciones formales en cuanto al número de sentencias y estructuras anidadas que se pueden colocar en un mismo bloque de código, esto depende del lenguaje de programación que se está usando. No obstante, no es conveniente abusar de los anidamientos de estructuras, ya que resultan en un código difícil de leer y por lo tanto difícil de mantener.

Fin del Ejemplo 3.3

6. Control de Datos de Entrada Existen una serie de situaciones comunes en programación donde se toman datos desde un dispositivo de entrada y se requiere de alguna forma de control implementada por bucles. A continuación algunas de estas situaciones.

6.1 Usando un Valor Centinela que Determina el Fin del Bucle

En este caso se espera la entrada de un valor centinela para decidir si se va a ingresar al ciclo o no de entrada de datos. El bucle se va a repetir mientras no se lea un valor determinado. La primera lectura se va a realizar fuera del bucle. Si al ingresar el dato de entrada, éste es el valor centinela entonces no se entra en el bucle y se seguirá con el resto del algoritmo. En caso contrario, se entra en el bucle para seguir con la entrada de datos.

Se recomienda utilizar una estructura Mientras-Hacer.

Ejemplo 3.4

1. centinela = 9

2. Leer opcion

3. Mientras (opcion <> centinela) hacer

4. <acciones>

5. Leer opcion

6.Fin mientras

Fin del Ejemplo 3.4

6.2 Lectura Secuencial de un Archivo

Los datos de entrada pueden estar en un archivo, el cual debe ser leído desde el primer al último registro para recuperar todos los datos, para ello se realiza una lectura secuencial de todos los registros del archivo.

Una estrategia común de lectura para un archivo con acceso secuencial es: abrir el archivo





leer un registro del archivo

verificar si no es fin de archivo al entrar a un ciclo para recorrer el archivo

realizar operaciones con los datos de entrada

volver a leer datos del archivo, con cada operación de lectura se avanza de registro en registro en los datos del archivo

regresar al ciclo hasta que sea fin de archivo.

Ejemplo 3.5 1. Archivo mi_archivo

2. Abrir_Archivo(mi_archivo)

3. Leer_Archivo(mi_archivo)

4. Mientras (No (Fin_de_Archivo(mi_archivo))) Hacer

5. <acciones con los datos del archivo>

6. Leer_Archivo(mi_archivo)

7.Fin mientras

Fin del Ejemplo 3.5

6.3 Cuando se Sabe el Número Exacto de Veces que se Ejecuta una Acción o Proceso

Cuando se sabe el número exacto de veces que se ejecuta una acción o proceso, la opción natural para realizar el control de entrada es utilizar un ciclo o bucle ‘Desde...Hasta’.

Normalmente, el número de veces que se desea repetir el proceso, es solicitado como un valor de entrada o es suministrado desde alguna otra fuente (variable de entorno, constante, archivo de configuración, entre otros). Una vez que se obtiene este valor, se le asigna a la variable de índice para el ciclo ‘Desde’. Se efectúa la operación hasta que se cumpla el número de veces deseado.

Ejemplo 3.6 1. Var i : Entero

2. Mostrar “Ingrese el numero da materias a registrar: ”

3. Leer numero_materias

3. Desde i = 1 Hasta numero_materias

4. Mostrar “Ingresar datos Materia numero ” ,i, “ : ”

5. Leer materia

6. <acciones a realizar con materia>





7.Fin desde

Fin del Ejemplo 3.6

6.4 Control de Datos Para no Permitir Datos Erróneos

El control de ingreso de datos para evitar datos de entrada erróneos, se usa cuando se controla al usuario para que introduzca los datos válidos. Por ejemplo: ‘un valor numérico dentro de un rango determinado’, en estos casos, se recomienda usar un ciclo ‘Repetir...Hasta’.

Ejemplo 3.7

1. Var opcion : Entero

2. opcion = 0

3. Repetir

4. Mostrar “Menu:”

5. Mostrar “1. Crear Archivo”

6. Mostrar “2. Borra Archivo”

7. Mostrar “3. Incluir Registro”

8. Mostrar “4. Salir del sistema”

9. Mostrar “Su opcion :”

10. Leer opcion

11.Hasta (opcion >= 1) Y (opcion <= 4)

Fin del Ejemplo 3.7





Resumen Ahora que ha completado esta unidad, Ud. debe ser capaz de:

• Conocer las técnicas de programación estructurada. • Trabajar con las estructuras secuenciales. • Trabajar con las estructuras selectivas. • Trabajar con las estructuras repetitivas. • Conocer la anidación de bucles y condicionales. • Realizar el control de datos de entrada.





Unidad 3: Examen de Autoevaluación 1) ¿Cuáles de los siguientes son estructuras de ciclo?

a) Mientras hacer b) Desde c) Hasta d) Repetir hacer

2) Todo bucle tiene asociada dos condiciones: Una que determina si se ejecuta el bucle

y otras hasta cuando. a) Falso b) Verdadero

3) ¿Cuáles de las siguientes son estructuras básicas de control? a) Alternativas b) Directivas c) Repetitivas d) Ejecutorias

4) No es posible la anidación de estructuras de selección con estructuras de bucles.

a) Verdadero b) Falso

5) ¿Cuáles de las siguientes afirmaciones son correctas con respecto a los centinelas?

a) Se recomienda utilizar una estructura Repetir b) La primera lectura se va a realizar fuera del bucle c) El bucle se va a repetir mientras no se lea un valor determinado d) Se utiliza únicamente con lenguajes orientados a objetos

6) Con respecto a las estructuras repetitivas, ¿Cuáles de las siguientes no son

verdaderas? a) Cada repetición del bucle se llama una iteración b) Existen dos tipos básicos de estructuras repetitivas c) Cada serie del bucle se llama una repetición d) Son un conjunto de instrucciones que se repiten un número infinito de veces





7) El bucle ‘Mientras-hacer’ garantiza su ejecución por lo menos una vez. a) Verdadero b) Falso

8) La estructura de ciclo ‘Desde’ debe ser utilizada cuando no se conoce el número de

veces que se debe ejecutar el ciclo. a) Verdadero b) Falso

9) Las estructuras selectivas de selección múltiple no poseen un mecanismo que

permita evaluar otro valor diferente a los especificados puntualmente. a) Verdadero b) Falso

10) La variable índice del ciclo ‘Desde’ actualiza su valor automáticamente.






Respuestas de la Unidad 3: Examen de Autoevaluación 1) a y b 2) a 3) a y c 4) b 5) b y c 6) b, c y d 7) b 8) b 9) b

10) a


Unidad 4: Funciones y Procedimientos Libro 1: Fundamentos de Programación 61





• Definir qué son las funciones, sus características y sintaxis. • Definir los procedimientos, sus características y sintaxis. • Explicar el ámbito de las variables.

• Explicar la comunicación entre subprogramas. • Definir qué es la Recursividad.


Libro 1: Fundamentos de Programación Unidad 4: Funciones y Procedimientos 62



1. Introducción La programación modular es una de las técnicas fundamentales de la programación. Se apoya en el diseño top down y en la filosofía de “divide y vencerás”. La programación modular toma el problema y lo divide en problemas más simples o más pequeños y cada uno de estos se implementa como un módulo independiente. A cada uno de estos módulos se le llama subprogramas. El objetivo es tener tanto subprogramas como sea necesario para resolver un problema mayor y cada subprograma debe cumplir cabalmente una tarea específica.

Siempre existirá un módulo o programa principal donde comienza la ejecución de todo el programa. A partir de éste, se van llamando al resto de los módulos que posea el sistema y que han sido implementados como subprogramas. Cada vez que se invoca a un subprograma, en la llamada se le pasa la información que necesita, seguidamente éste comienza a ejecutarse y cuando termina su ejecución el control regresa a la instrucción siguiente a la línea de código en la cual se efectuó la llamada, en el programa o subprograma que hizo la llamada.

Un ejemplo de programación modular puede ser un sistema que realice el cálculo de los impuestos, donde el problema del cálculo de los impuestos puede ser dividido a su vez en 4 subproblemas, que se implementarán como 4 módulos o subprogramas, para ilustrarlo gráficamente observe la Figura 4.1:

Figura 4.1: Ejemplo de Programación Modular

Entre las ventajas de la programación modular están:

• Simplifica el diseño. • Disminuye la complejidad de los algoritmos. • Disminuye el tamaño total del programa.

Cálculo de Impuesto

Calcular Retención después de Impuesto

Calcular Impuesto

Calcular Retención antes de Impuesto

Calcular Ingreso

Calcular Impuesto

sobre la Renta

Calcular Impuesto Activos





• Ahorra en tiempo de programación porque promueve la reusabilidad del código. • Favorece el trabajo en equipo. • Facilita la depuración y prueba. • Facilita el mantenimiento. • Permite la estructuración de librerías específicas.

Hay una correspondencia directa entre el problema principal y el algoritmo principal o módulo principal (también llamado controlador) y también hay correspondencia entre los subproblemas en los que se haya dividido el problema principal y los submódulos o subprogramas que conforman el programa principal.

La estructura de un subprograma o módulo, es muy similar a la estructura de un programa normal, va a tener una información de entrada que es la que se le pasa al hacer la llamada y que se coloca junto al nombre del subprograma. Esta información de entrada se denomina parámetros formales del subprograma o argumentos formales. Dentro del cuerpo del subprograma se pueden colocar cualquier número de acciones o sentencias de código e incluso declarar variables y llamar a otros módulos, tal como se hace desde un programa principal. Al terminar la ejecución del módulo o subprograma puede que este último devuelva o no resultados o valores al programa que lo llamó. A los subprogramas que pueden retornar valores, usualmente se les denominan funciones, mientras que a los subprogramas que no poseen valor de retorno se les denomina procedimientos.

2. Funciones Desde el punto de vista matemático, una función es una operación que toma uno o varios operando (parámetros) y devuelve un resultado. Desde el punto de vista algorítmico, una función es un subprograma que toma uno o varios parámetros como entrada y devuelve un único resultado.

Este único resultado irá asociado al nombre de la función, es por ello que es una práctica común el hecho de que al invocar una función, su valor de retorno se le asigne a una variable u expresión adecuada.

Existen dos tipos de funciones:

• Internas o Incorporadas: Son las que vienen definidas por defecto en el lenguaje de programación.

• Externas o del Usuario: Son las que define el usuario y tienen un nombre o identificador.

Para llamar a una función se escribe su nombre y entre paréntesis los argumentos o parámetros que se quieren pasar a la función.





2.1 Declaración de una Función

La estructura de una función es semejante a la de cualquier subprograma. Tendrá una cabecera con el nombre y los parámetros y un cuerpo con la declaración de los parámetros de la función y las instrucciones.

Sintaxis

La sintaxis para la declaración de una función depende del lenguaje de programación utilizado, se propone un esquema que usa la palabra ‘Función’ para indicar el inicio de la función seguido del identificador o nombre, la lista de parámetros, el tipo de dato de retorno de la función y por último, el cuerpo de la función enmarcado entre sentencias de inicio y fin de bloque de código.

Función <nombre_funcion> (nom_parametro: tipo): tipo_retorno

Var <variables locales de la función>

Inicio

<acciones>

retorno <valor>

fin <nombre_función>

La lista de parámetros es la información que se le tiene que pasar a la función. Los parámetros dentro del cuerpo de la función, se utilizan como variables locales definidas en la función. Es necesario definirle a cada parámetro su nombre y tipo de dato al momento de declarar la función. El nombre de la función lo da el programador y debe ser un nombre significativo.

En las variables locales se declaran las variables que se desea utilizar dentro de la función.

Dentro del cuerpo de la función, se escriben todas las acciones o sentencias de código destinadas a cumplir el propósito de la función. Es necesario para las funciones, que entre las acciones escritas en su cuerpo, se incluya una del tipo ‘retorno <valor>’. Esta sentencia pondrá fin a la ejecución de la función y devolverá el valor de la función al programa que la invocó. El valor de retorno tiene que ser del mismo tipo, que el tipo de dato que se ha indicado al declarar la función en la parte final de la cabecera.

Por definición, una función siempre debe devolver algún valor. Algunos lenguajes de programación declaran un tipo de dato nulo para permitir así que las funciones “no retornen” valores, aunque en realidad retornan un tipo no utilizado.

Los parámetros que aparecen en la declaración de la función se denominan parámetros formales. Los parámetros que se utilizan cuando la función es invocada se denominan parámetros actuales o reales. Estos últimos son las constantes, valores de retorno, expresiones, variables u otro elemento del contexto de la llamada que es necesario pasar a la función.





2.2 Invocación de una Función

Para llamar o invocar una función, se coloca el nombre de la función y entre paréntesis se añaden los parámetros reales que necesita la función. Los parámetros reales pueden ser variables, expresiones e incluso constantes, pero siempre deben corresponder al mismo tipo de dato que los parámetros formales asociados con la función.

Por ejemplo, si se tiene la siguiente declaración de función: 1. Función sumarEnteros(num1: Entero, num2:Entero): Entero

2. Var

3. resultado: Entero

4. Inicio

5. Resultado = num1 + num2

6. Retornar resultado

7. Fin sumarEnteros

La función puede ser llamada desde el programa principal o desde cualquier otro subprograma mediante sentencias tales como:

1. Var

2. resultado : Entero

3. numero : Entero

4.Inicial

5. resultado= sumarEnteros(8, 9)

6. Mostrar “8 + 9 es: ” resultado

7. numero= 12;

8. resultado= sumarEnteros(numero, 5)

9. Mostrar “12 + 5 es: ” resultado

10. Mostrar “2 + 2 es: ” sumarEnteros(2, 2)

11.Fin

Para que una función pueda ser invocada desde cualquier parte de un programa, es necesario que la definición de dicha función ya sea del conocimiento previo del compilador antes de usarla. Esto último, es así porque usualmente la mayoría de los lenguajes de programación requieren que la función, procedimiento o subrutina, esté definida antes de permitir su uso. En otras palabras, la firma de la función que corresponde a su nombre, tipo y número de argumentos debe estar presente en algún lugar válido del programa antes de poder invocarla.

A través de los parámetros reales de la llamada, se proporciona a la función la información que necesita para cumplir su cometido y al momento de hacer la llamada, se produce una asociación automática entre los parámetros reales y los parámetros





formales. Esta asociación se realiza según el orden de aparición de izquierda a derecha de los parámetros formales de la función.

Como regla general el parámetro real y su correspondiente parámetro formal deben ser del mismo tipo. Si el parámetro formal no es del mismo tipo que el parámetro real, en algunos lenguajes, como Pascal, se produce un error de compilación; en otros lenguajes, como el lenguaje C, ocurre una conversión implícita de tipos, si es posible.

2.3 Pasos para Hacer la Llamada a una Función

Cuando se efectúa la llamada, se cede el control a la función y se asocia, es decir, se asigna, el valor de cada parámetro real al parámetro formal correspondiente, siempre por orden de aparición de izquierda a derecha. Se produce un error cuando no coincidan los tipos o el número de parámetros formales y reales.

Si la llamada a la función es válida entonces se ejecutan las acciones de la función hasta que se encuentre una instrucción del tipo ‘retorno <valor>’. Esta instrucción pondrá fin a la ejecución de la función y el control se pasa al punto siguiente de donde se efectuó la llamada. Pueden existir varias sentencias de retorno en la misma función, colocadas en diferentes bloques de código y normalmente dependen de sentencias condicionales para su ejecución.

En resumen, se asocia el valor retornado con el nombre de la función y se devuelve el control al subprograma que hizo la llamada, sustituyendo así el nombre de la función por el valor devuelto.

Ejemplo 4.1

Se necesita una función que calcule la mitad del valor que recibe como parámetro. Suponga que el parámetro es un valor entero.

1. Funcion mitad (n: entero): real

2. Var med: real

3. Inicio

4. med = n / 2

5. Retorno med

6. Fin mitad

7. Algoritmo calcular_mitad

8. Var num: entero

9. Inicio

10. Escribir “Introduzca un número entero para hallar su mitad: ”

11. Leer num





12. Escribir “La mitad de “ num ” es “ mitad(num)

13.Fin

En este ejemplo la función mitad() se llama desde una expresión.

Fin del Ejemplo 4.1

3. Procedimientos Un procedimiento es un subprograma que realiza una determinada tarea, pero que tras ejecutar esa tarea no tiene ningún valor asociado a su nombre, como ocurre en las funciones. Si un procedimiento devuelve información, lo hace a través de parámetros de entrada-salida o de salida.

Al invocar un procedimiento, se le cede el control, comienza a ejecutarse y cuando termina devuelve el control a la instrucción siguiente, al punto donde se efectuó la llamada.

3.1 Diferencias entre Funciones y Procedimientos

Las funciones están diseñadas para devolver un único valor y un procedimiento puede devolver ningún o muchos valores por medio de sus argumentos o parámetros.

Ninguno de los resultados devueltos por el procedimiento se asocia a su nombre como ocurre con la función.

Mientras que la llamada a una función siempre puede formar parte de una expresión, la llamada a un procedimiento es una instrucción aislada, que por sí sola no puede formar parte de una expresión.

3.2 Sintaxis

La sintaxis para declarar un procedimiento es esencialmente la misma que para definir una función, sólo que no se coloca un tipo de retorno asociado. La cabecera va a estar formada por el nombre del procedimiento que será un identificador válido y que debe ser significativo. Luego, entre paréntesis, se deben colocar los parámetros o argumentos formales que requiere el procedimiento. Por cada parámetro es necesario indicar el tipo de paso de parámetro.

En el cuerpo del procedimiento se colocan todas las sentencias necesarias para cumplir con su tarea y no habrá ninguna sentencia de tipo ‘retorno <valor>’. Ahora bien, si el procedimiento devuelve resultados a través de sus parámetros, cosa que sólo podrá hacer a través de los parámetros que se pasan por referencia, tendrán que existir sentencias de asignación de valores a estos parámetros pasados por referencia para devolver los resultados.





3.3 Pasos para Hacer la Llamada a un Procedimiento

En primer lugar, desde el programa principal o subrutina, se coloca el nombre del procedimiento con su lista de parámetros reales entre paréntesis como una sentencia única. Esto cede el control al procedimiento que se llama y después de esto lo primero que se hace es sustituir cada parámetro formal de la definición, por el parámetro actual o real asociado a él en la llamada. Esta asociación entre parámetros formales y reales se realiza de izquierda a derecha por orden de ubicación. Para que se pueda producir la asociación tienen que existir el mismo número de parámetros formales que reales y además, el tipo de dato tiene que coincidir con el del parámetro formal asociado. Se produce un error en la llamada al procedimiento si no se cumple alguna de estas condiciones.

Si la asociación ha sido correcta, comienzan a ejecutarse las instrucciones del procedimiento hasta llegar a la última instrucción. Al llegar a la instrucción, se vuelven a asociar los parámetros formales que devuelven los resultados a los parámetros reales asociados en la llamada, es decir, de esta manera algunos de los parámetros reales de la llamada ya contendrán los resultados del procedimiento.

Finalmente, se cede el control a la instrucción siguiente a la que efectuó la llamada al procedimiento.

Ejemplo 4.2

1. Procedimiento mitad (num:entero, ent-sal med:real)

2. Inicio

3. med = num / 2

4. Fin mitad

5. Algoritmo calcular_mitad

6. Var

7. n: entero

8. mit: real

9. Inicio

10. Escribir “Introduzca un número”

11. Leer n

12. mitad (n, mit)

13. Escribir “La mitad es” mit

14. fin

En el ejemplo anterior ent-sal med: real, se usa para indicar que el parámetro del tipo real med es de entrada-salida o que es un parámetro por referencia. Cada lenguaje de programación definirá su propia sintaxis para indicar cuándo los parámetros son por valor o por referencia.





4. Ámbitos: Variables Globales y Locales El ámbito de un identificador ya sea variable, constante, función, entre otros, se refiere a la parte del programa en la que se conoce y por tanto se puede usar al identificador. Recuerde que un identificador es un nombre construido bajo ciertas reglas de sintaxis y se asocia a un elemento del programa.

Existen dos tipos de ámbitos básicos:

• El ámbito global: Se refiere a los identificadores que se declaran dentro del programa principal y fuera de cualquier otro bloque de código. Al ser declarados de esta forma, los identificadores globales están disponibles a lo largo del programa y podrán ser usados en cualquier parte del mismo, de allí su nombre de globales porque se dice que son globales al programa.

• El ámbito local: Se refiere a los identificadores declarados dentro de un bloque de código diferente al programa principal, como por ejemplo una subrutina o procedimiento, siendo visibles y accesibles, por lo tanto sólo dentro de ese bloque de código específico.

Como regla general todo identificador sólo es visible y accesible dentro del bloque de código que lo declara y dentro de los bloques anidados que éste último pueda tener. Lo contrario no es cierto, es decir, los identificadores declarados en un sub-bloque de código no son visibles ni accesibles desde el bloque de código del cual depende.

El ámbito es importante cuando se trabaja con variables, por lo que se tienen variables locales y globales

4.1 Variable Local

Una variable local es aquella que está declarada y definida dentro de un subprograma o sub-bloque de código, por lo tanto, su ámbito coincidirá con el ámbito del subprograma en la que esté definida.

Esto quiere decir que la variable no tiene ningún significado, no se conoce y no se puede acceder a ella desde fuera del subprograma o bloque de código. Tiene una posición de memoria distinta a la de cualquier otra variable del programa, incluso si es de una variable que tiene el mismo nombre pero que está definida fuera del subprograma.

Las variables locales de un subprograma se definen en la parte de definición de variables del mismo. Los parámetros formales que se le ponen a un subprograma se comportan dentro de él como si fueran también variables locales al subprograma.

Si se tiene una variable local con el mismo identificador que una variable global, las referencias que se hacen dentro del bloque de código en que se declara la variable local, harán referencia a dicha variable local y no a la variable global.





4.2 Variable Global

Una variable global es aquella que está definida a nivel del programa, es decir, su ámbito es el programa o algoritmo principal y todos los subprogramas que dependen de éste último.

Una variable global se puede acceder desde cualquiera de los subprogramas y cualquier parte del programa principal, salvo que alguno de esos subprogramas tenga definida una variable local con el mismo nombre que la variable global. En este caso, si se utiliza el nombre de esa variable se va referir a la local, nunca a la global, ya que ambas variables tienen ubicaciones de memoria diferentes.

Hay que ser cuidadosos a la hora de usar variables globales, ya que como todos los subprogramas las pueden modificar, es posible que se pueda hacer un uso indebido o se produzcan efectos indeseados cuando un subprograma utilice una variable global sin saber que otro subprograma ya ha modificado su valor. Esta es la razón por la cual no se deben utilizar variables globales para pasar información entre los subprogramas, para tal fin, se recomienda usar variables locales por medio de parámetros reales.

4.3 Procedimientos Anidados

La anidación de procedimientos no se permite en todos los lenguajes y consiste en que dentro de un procedimiento se pueda definir o declarar el código completo de otros procedimientos.

Si la anidación de procedimientos está permitida, se plantean más problemas en cuanto al ámbito, desde este punto de vista, se dice que una variable local se conoce en el procedimiento en el que está definida y en todos los procedimientos anidados que componen el ámbito de dicho procedimiento. Salvo que en alguno de esos procedimientos anidados, se defina una variable local con el mismo nombre que la global, en cuyo caso, dentro de ese procedimiento siempre se va a referir a la variable local, porque siempre se considera el ámbito más restringido.

A continuación, se presenta la Figura 4.2, la cual es un ejemplo de declaración de variables en diferentes ámbitos:

Figura 4.2: Ejemplo del Ámbito de la Declaración de Variables

P1 Var a, c, d

P2 Var c, d

P1.1 Var d, e, f

PP Var a, b





En la declaración anterior de variables dentro de los diferentes procedimientos, su visibilidad será como la representada en la Tabla 4.1.

VARIABLE AMBITO ÁMBITO SUBPROGRAMA

A PP PP, P2

B PP PP, P1, P1.1, P2

A P1 P1, P1.1

C P1 P1, P1.1

D P1 P1

D P1.1 P1.1

E P1.1 P1.1

F P1.1 P1.1

C P2 P2

D P2 P2

Tabla 4.1: Visibilidad de la declaración de variables anterior

5. Comunicación entre Subprogramas: Paso de Parámetros La mejor forma para llevar a cabo la comunicación entre subprogramas, es a través del paso de parámetros. Cuando se invoca una función o procedimiento se le pasan, a través de los parámetros los datos que necesita. En el caso de un procedimiento, los resultados también se devuelven a través de sus parámetros. Para ello, se define el tipo del parámetro al principio del subprograma, que es lo que se conoce como parámetros formales. Al hacer la llamada se pasan los datos a través de los parámetros reales.

5.1 Cómo se Efectúa la Correspondencia entre Parámetros Formales y Reales

Existen dos métodos para realizar la correspondencia entre parámetros formales y reales, los cuales se explican a continuación:

5.1.1 Correspondencia Posicional

En este caso se hacen corresponder los parámetros formales y reales por la posición que ocupan (orden de declaración) de izquierda a derecha. Para que se pueda realizar esta asociación, tiene que haber el mismo número de parámetros formales y reales, además el parámetro formal debe ser del mismo tipo que el parámetro real correspondiente.

Si se tiene el procedimiento:

Proc(x : entero, y : real)





Una llamada válida es:

Proc(8, a)

Donde ‘8’ es una constante literal entera y ‘a’ es una variable real previamente definida. En este caso, al efectuar la llamada al parámetro formal ‘x’, se le asigna el valor de 8 y al parámetro formal ‘y’ se le asignara el valor que tenga almacenado el parámetro real definido por la variable ‘a’.

5.1.2 Correspondencia por Nombre Implícito

En este enfoque, en la llamada al subprograma, se coloca explícitamente a que parámetro formal corresponde cada parámetro real.

En la llamada, se coloca el nombre del parámetro formal, separado por dos puntos (:) y seguido por el nombre del parámetro real que se pasa, de esta forma no importa la posición en la que se colocan los argumentos del procedimiento o función.

Para el ejemplo anterior y bajo este enfoque las siguientes llamadas son válidas:

Proc(x : 8, y : a)

Proc(y : a, x : 8)

ADA es un lenguaje de programación que permite la correspondencia de parámetros por nombre implícito.

A lo largo de este manual se usará siempre el método de correspondencia posicional.

5.2 Tipos de parámetros

Existen tres tipos básicos de parámetros según su uso como entrada de datos o para obtener resultados. Estos son:

• De Entrada: Son parámetros que sólo aportan el valor que tienen, como entrada al subprogama al que pertenecen como parámetros. En el caso de las funciones, todos sus parámetros son de este tipo. Como sólo sirven como entrada, sólo pueden ser leídos, pero no modificados. Aunque sean modificados dentro de un subprograma, esa modificación no va a tener efecto fuera del subprograma.

• De Salida: Se usan sólo y exclusivamente para devolver resultados a través de ellos. Su valor al hacer la llamada al subprograma no es de relevancia. Ese valor sólo va a tener sentido cuando termine la ejecución del subprograma. Un parámetro de este tipo teóricamente nunca se puede leer, sólo se va actualizar o modificar.

• De Entrada y Salida: El valor del parámetro tiene importancia tanto a la entrada como a la salida del subprograma. Aporta dato cuando se llama al subprograma y por otra parte, devuelve a través de él los resultados cuando se termina el subprograma. En este caso, tiene sentido tanto poder leer como actualizar el parámetro.





ADA es un lenguaje que soporta los tres tipos de pase de parámetros suministrados. Se ponen como In, Out e In-Out respectivamente.

La mayoría de otros lenguajes sólo permiten dos tipos de parámetros: de entrada sólo para leer datos y de entrada-salida para leer datos y devolver resultados.

5.3 Métodos de Paso de Parámetros

Existe una variedad de métodos definidos para el paso de parámetros, para efectos de este manual sólo se estudiarán dos de ellos por ser los más utilizados y conocidos en las herramientas de programación.

El paso de parámetros se va a clasificar en:

• Paso de parámetros por copia o por valor. • Paso de parámetros por referencia.

5.3.1 Paso de Parámetros por Copia o Valor

La característica fundamental de este método de paso de parámetros es que la función o procedimiento invocado, no puede modificar el valor de los parámetros reales. Al realizarse la llamada a la función, se copia el valor del argumento en el parámetro formal de la función. El parámetro formal de la función tiene asociada una dirección de memoria diferente a la dirección de memoria del parámetro real, por lo tanto, este parámetro formal se comporta como una variable local en la función o procedimiento al cual pertenece. Se puede cambiar el valor del parámetro dentro de la rutina y no repercutirá en el argumento originalmente transferido, ya que comparten direcciones de memoria diferentes e independientes.

El parámetro real puede ser: una constante, expresión o variable. Como ya se sabe, nunca se va a usar para devolver resultados a través de él; por esa razón, puede ser una constante o una expresión, porque al no devolver resultados a través del parámetro, no necesita tomar ninguna ubicación de memoria para almacenarlo.

Observe el siguiente ejemplo:

Ejemplo 4.3 1. Procedimiento Duplicar(x : entero)

2. Inicio

3. x = x * 2

4. Escribir x

5. Fin Duplicar

6. Algoritmo CopiaValor

7. Var a : entero





8. Inicio

9. a = 3

10. Duplicar(a)

11. Escribir a

12. Fin

El valor de ‘a’ será 3 y el de ‘x’ será 6.

Fin del Ejemplo 4.3

5.3.2 Paso de Parámetros por Referencia

La característica fundamental de este método de paso de parámetros es que la función invocada puede modificar el valor de los parámetros reales.

Al realizar la llamada a la función o procedimiento, se almacena la dirección de memoria de su parámetro real asociado, es decir, el parámetro formal apunta a la dirección de memoria del parámetro real que tiene asociado. Cualquier modificación que se efectúe sobre el parámetro formal dentro de la función, tendrá un efecto directo en el parámetro real asociado, ya que se modificará el valor almacenado en la dirección de memoria que indica el parámetro formal, que es a su vez la dirección de su parámetro real asociado.

El parámetro real no puede ser ni constantes ni expresiones. Sólo pueden ser variables.

Para indicar que el tipo de paso de parámetro es por referencia, se va a utilizar la palabra clave ent-sal precediendo al parámetro que se pasa por referencia.

Procedimiento Duplicar(ent-sal x : entero)

Inicio

x = x * 2

Fin Duplicar

Algoritmo Referencia

Var a

Inicio

a = 3

Duplicar(a)

Escribir(a)

Fin

Al finalizar el algoritmo, el valor de ‘a’ será igual a 6, valor asignado a ‘x’ en el subprograma Duplicar().

De acuerdo a lo estudiado en los dos puntos anteriores se puede resumir que en el paso de parámetros por:





• Valor: El parámetro actual no cambia de valor. • Referencia: El parámetro actual puede cambiar de valor.

6. Recursividad Se dice que un subprograma es recursivo cuando se llama a sí mismo. La recursividad se puede utilizar en subprogramas que se pueden definir en términos recursivos, es decir, en términos de sí mismo, como procesos de alguna manera repetitivos.

Un ejemplo de definición recursiva es el de la función matemática factorial, donde:

Factorial(x) = x * Factorial(x-1)

Note como se utiliza la función factorial para definir el factorial de un número entero.

Hay que ser cuidadosos al utilizar la recursividad e incluso evitarla siempre que sea posible utilizando algoritmos iterativos. Cada vez que un subprograma se llama a sí mismo, hay que almacenar en la pila del sistema (un lugar de memoria especial) la dirección de retorno de ese subprograma. De esta forma, si se efectúan muchas llamadas recursivas se irá llenando la pila del sistema, existiendo la posibilidad de que se agote la memoria disponible. Esta situación se conoce como desborde de la pila del sistema.

Todo programa recursivo tiene que tener alguna condición que ponga fin a la recursividad, un punto en el que el subprograma deje de llamarse a sí mismo cuando se cumpla la condición. De otra forma, se genera un bucle infinito con el consecuente error de desbordamiento de pila mencionado anteriormente.

En el ejemplo de la función factorial, la condición de control es que el factorial de todo número menor o igual a 1 es 1.

De aquí:

si (x > 1) entonces

Factorial(x) = x * Factorial(x-1)

sino Factorial(x)=1

La función factorial en forma recursiva:

Funcion FactorialRecursiva(x : entero): entero

Inicio

Si (x > 1) entonces

Retornar (x * FactorialRecursiva(x – 1))

Sino

Retornar 1

Fin FactorialRecursiva





Si se realiza el cálculo del factorial de 4, la función al ejecutarse realizaría los siguientes pasos:

Figura 4.3: Pasos para calcular el factorial de 4

A continuación se presenta el Ejemplo 4.4 para efectuar la función factorial en forma iterativa:

Ejemplo 4.4

1. Funcion FactorialIterativa(x : entero): entero

2. Var

3. res : entero

4. i : entero

5. Inicio

6. res = x

7. Si (x > 1) entonces

8. Desde i = x - 1 hasta 1

9. res = res * i

Factorial(4)=4*Factorial(3) retorno Factorial=24

Factorial(3)=3*Factorial(2) retorno

Factorial(2)=2*Factorial(1) retorno

Factorial=6

Factorial=2

Factorial=1

x=2

x=3

x=4

x=1

Factorial(1)=1 retorno





10. Fin Desde

11. Sino

12. res = 1

13. Retorno (res)

14. Fin FactorialIterativa

Toda función recursiva puede expresarse en forma iterativa, lo contrario no es cierto.

Fin del Ejemplo 4.4

Como guía para el uso o no de la recursividad, puede considerarse:

• Las funciones y procedimientos recursivos se pueden utilizar, cuando los datos del problema están organizados en una estructura de datos que se define recursivamente.

• Si un algoritmo no recursivo se puede obtener y es menos complejo que el recursivo, es mejor utilizar el no recursivo.

• No debe usarse la recursividad a menos que se tenga un medio para terminar las llamadas recursivas.

• Cada llamada recursiva requiere la asignación de espacio de memoria para todas las variables locales, parámetros por valor y la dirección de retorno. Por lo que cada llamada utiliza memoria, lo que representa una limitación.






• Definir qué son las funciones. • Listar las características de las funciones. • Conocer la sintaxis de las funciones. • Definir los Procedimientos. • Listar las características de los procedimientos. • Explicar el Ámbito de las Variables. • Explicar la comunicación entre subprogramas. • Definir que es la recursividad.





Unidad 4: Examen de Autoevaluación 1) En relación a las Funciones, ¿Cuáles de siguientes afirmaciones son correctas?

I. Un programador puede establecer que la función devuelva o no un valor II. Es necesario que en el cuerpo se incluya una sentencia retorno <valor> III. Se puede devolver varios resultados asociados al nombre de la función IV. El parámetro real de una función puede ser el valor de retorno de otra función

a) I, II, IV b) II, III, IV c) I, II, III, IV d) Ninguna de las anteriores

2) Los parámetros pueden ser pasados por:

a) Referencia b) Copia c) Constantes d) Ninguna de las anteriores

3) Con respecto a la recursividad, ¿Cuáles de las siguientes afirmaciones no son

verdaderas? I. Todo algoritmo recursivo debe tener una condición que finalice la recursividad II. Todo algoritmo iterativo puede ser reescrito como un algoritmo recursivo III. Los algoritmos iterativos son menos eficientes que los algoritmos recursivos IV. Un programa recursivo puede ocasionar un desborde de pila del sistema

a) I, II, IV b) II, III c) I, IV d) II, III, IV

4) La mayoría de los lenguajes sólo permiten tipos de parámetros de entrada y de

salida a) Verdadero b) Falso





5) Con respecto a la anidación de procedimientos ¿Cuál de las siguientes afirmaciones es cierta? a) Está permitida en todos los lenguajes b) Se presentan problemas en el ámbito de las variables c) El procedimiento interno únicamente es visto por el procedimiento externo al

cual pertenece. d) Una variable x en el procedimiento externo puede ser ocultada por una variable

x en el procedimiento interno.

6) La cabecera de una función comprende: a) Tipo de dato de retorno b) Lista de parámetros c) Identificador d) Grupo de sentencias

7) Con relación a los procedimientos, ¿Cuáles de las siguientes afirmaciones son

verdaderas? I. Sólo pueden devolver cero o un valor por sus parámetros II. Por si solos pueden formar parte de una expresión III. El valor devuelto es asociado al nombre del procedimiento IV. Puede recibir sólo parámetros por referencia

a) I, II b) II, III, IV c) III, IV d) Ninguna de las anteriores

8) El valor de un parámetro por referencia pasado a una función no puede ser

modificado dentro de ella a) Verdadero b) Falso

9) Dado el siguiente algoritmo:

Procedimiento Duplicar(x:entero)

Inicio

x=x*2

Fin Duplicar

Algoritmo Sumar

Var a,b: entero

Inicio





a=3

b=Duplicar(a)+Duplicar(a)

Escribir(b)

Fin Se puede decir que el algoritmo está bien elaborado y funciona correctamente


10) Las variables locales a una función o procedimiento sólo existen dentro del contexto

en donde se encuentran definidas a) Verdadero b) Falso





Respuesta de la Unidad 4: Examen de Autoevaluación

1) a 2) a y b 3) b 4) b 5) b, c y d 6) a, b y c 7) d 8) b 9) b

10) a


Unidad 5: Estructura de Datos: Arreglos Libro 1: Fundamentos de Programación 83



Unidad 5: Estructura de Datos: Arreglos


• Conocer las estructuras de datos. • Trabajar con arreglos unidimensionales o vectores. • Realizar operaciones con arreglos unidimensionales o vectores. • Trabajar con arreglos bidimensionales o matrices. • Conocer los arreglos multidimensionales. • Entender el almacenamiento de arreglos en memoria.


Libro 1: Fundamentos de Programación Unidad 5: Estructura de Datos: Arreglos 84



1. Introducción En las unidades anteriores se estudiaron los conceptos de algoritmos y programas, así como una serie de elementos, entre ellos, la lógica, que ayudan a resolver problemas computacionales. También se discutió cómo un programa o algoritmo puede ser representado gráficamente mediante un diagrama de flujo y se trabajó con los principios de la programación estructurada, sus recursos y técnicas. Ésta unidad se ocupa de estudiar una de las representaciones de datos más usadas en programación: Los Arreglos o Vectores. Los arreglos se utilizan para almacenar datos consecutivos de un mismo tipo, por lo que se usan generalmente en algoritmos de clasificación, ordenamiento y búsqueda.

2. Arreglos Unidimensionales: Arreglos o Vectores Un arreglo unidimensional o vector, es un conjunto finito, consecutivo y organizado de elementos homogéneos, es decir, elementos pertenecientes a un mismo tipo de dato.

Se dice que es:

• Finito: El arreglo tiene un número determinado de elementos. • Homogéneo: Todos los elementos del arreglo son del mismo tipo. • Organizado: Existe una forma de referenciar cada elemento del arreglo y de

acceder a cada uno de sus elementos de manera independiente. • Consecutivo: Por la forma en que se almacena o representa un vector en la

memoria del computador, en posiciones consecutivas de la memoria.

Para referenciar cada elemento de un arreglo se usa el índice, que es un valor que directa o indirectamente referencia la posición del elemento dentro del arreglo.

Los índices deben ser de cualquier tipo de datos escalar, porque en un escalar se puede definir un orden y entre dos elementos consecutivos no puede haber infinitos elementos. Un ejemplo de datos escalares son los enteros y caracteres. Normalmente, como índices se van a utilizar números enteros.

Para referenciar un elemento de un arreglo se usa el nombre del arreglo y entre corchetes ([ ]) el índice que determina la posición de ese elemento en el arreglo.

El rango o longitud de un vector o arreglo lineal es la diferencia entre el índice de valor máximo en el arreglo y el índice de valor mínimo + 1. Normalmente, los índices comienzan a enumerarse desde 0 ó 1, como el valor mínimo del índice, dependiendo del lenguaje de programación (en Pascal inician con 1 y en ‘C’ inician con 0). Sin embargo, nada impide que comiencen con cualquier otro valor.

Los arreglos se almacenan siempre en posiciones consecutivas de memoria y se puede acceder a cada elemento del arreglo de manera independiente, a través de los índices. Un índice no tiene porque ser un valor constante, puede ser también una variable o una





expresión que al ser evaluada devuelva un valor escalar que se encuentre entre el índice menor y el índice mayor del arreglo o ambos inclusive.

2.1 Definición de un Arreglo o Vector

Para definir un arreglo, se da el nombre del arreglo, el rango de sus índices y el tipo de los datos que contiene. Esto es:

<nom_arreglo>: arreglo [rango] de <tipo>

Ejemplo: sueldo: arreglo[8] de real

i: entero

i = 2

sueldo[i]= 23.5

Si el valor mínimo del rango del índice es 1 la sentencia sueldo[i]= 23.5 asigna el valor 23.5 a la segunda posición de un arreglo de ocho elementos.

Si el valor mínimo del rango del índice es 0 la sentencia sueldo[i]= 23.5, se asigna el valor 23.5 a la tercera posición de un arreglo dado que el valor del índice i es 2.

Se considera un error intentar acceder a una posición del arreglo que esté fuera del rango del índice. Este error se denomina comúnmente ‘índice fuera de rango’.

2.2 Operaciones con vectores

Se va a usar la declaración de vector:

ventas: arreglo[12] de entero

Gráficamente éste vector puede representarse como:

2.2.1 Asignar un Dato a una Posición del Arreglo

Consiste en asignar un valor dado a una posición del arreglo dada por un índice.

La sintaxis de ésta operación es:

<nom_arreglo>[indice] = valor

Ejemplo: Asignar el valor 600000 a la posición 5 del vector.

ventas[5] = 600000

2.2.2 Lectura y Escritura de Datos

Consiste en usar una posición cualquiera del arreglo definida por un índice para operaciones de entrada y salida.

1 2 3 4 5 6 7 8 9 10 11 12





La sintaxis para estas operaciones es:

Leer <nom_arreglo>[indice]

Escribir <nom_arreglo>[indice]

Ejemplo 5.1

Leer y mostrar las ventas de los 12 meses del año y almacenarlas en un vector.

1. Desde i = 1 Hasta 12

2. Escribir “Introduzca las ventas del mes ” i

3. Leer ventas[i]

4. Fin Desde


6. Escribir “Ventas del mes ” i ” = ” ventas [i]

7. Fin Desde

Fin del Ejemplo 5.1

2.2.3 Recorrido o Acceso Secuencial de un Arreglo

Consiste en pasar por todas las posiciones del arreglo para procesar su información. Usualmente, se usa un ciclo ‘Desde’ para recorrer el vector.

La sintaxis de esta operación es:

Desde indice = 1 Hasta Rango_Arreglo

<acciones con el arreglo>

Fin Desde

Ejemplo 5.2

Sumar 1 millón a las ventas de cada mes.


2. Ventas[i] = ventas[i] + 1000000

3. Fin Desde

Fin del Ejemplo 5.2





2.2.4 Actualización de un Arreglo

• Añadir Datos

Es un caso especial de la operación de inserción de un elemento en un arreglo, donde el elemento nuevo se agrega después de la última posición que contiene información válida en el arreglo. Para hacer esta operación, es necesario que si actualmente el arreglo tiene k posiciones de información válida, tenga un tamaño de al menos k + 1 para que se pueda añadir otro elemento a continuación del elemento en la posición k.

Sintaxis: <nom_arreglo>[K + 1] = valor

• Insertar Datos

Consiste en introducir un elemento en una posición del interior de un arreglo, para lo cual será necesario desplazar una posición a la derecha a todos los elementos que estén a la derecha de donde se va a insertar el elemento, esto con el fin de conservar el orden relativo entre los elementos.

Para que se pueda insertar un nuevo elemento en el arreglo, si ya existen n elementos con información en el arreglo, el arreglo tendrá que tener un tamaño al menos de n + 1 para poder insertar el nuevo elemento.

C E F J M O

Al insertar ‘G’ en la cuarta posición queda:

C E F G J M O

Si k es la posición donde se va a insertar el nuevo elemento, n es el número de elementos válidos en el arreglo en el momento de la inserción y suponiendo un tamaño mínimo de n + 1, el algoritmo de inserción es:

Desde i= n hasta k con decremento 1

A[i+1] = A[i]

Fin Desde

A[k] = valor

Ejemplo 5.3

Insertar 30000 correspondientes a las ventas del mes 5.

1. Desde i= 11 hasta 5 con decremento 1

2. ventas[i + 1] = ventas[i]





3. Fin Desde

4. ventas[5] = 30000

Fin del Ejemplo 5.3

• Eliminar Datos

Para eliminar un elemento de un arreglo, si ese elemento está posicionado al final del arreglo, no hay ningún problema, simplemente si el tamaño del arreglo era n, ahora hay que considerar que el tamaño del arreglo es n - 1.

Si el elemento a eliminar ocupa cualquier otra posición, entonces se tendrán que desplazar una posición hacia la izquierda todos los elementos situados a la derecha del elemento a borrar, para que el arreglo quede organizado.

C E F J M O

Al borrar el elemento J de la cuarta posición.

C E F M O

Suponiendo que el número de elementos válidos actualmente es “n” y que se desea borrar el elemento de la posición k.

Desde i = k Hasta n - 1

A[i] = A[i+1]

Fin Desde

Ejemplo 5.4

Eliminar las ventas registradas en el mes 4 y desplazar las de los meses subsiguientes hacia la izquierda.

1. Desde i= 4 Hasta 11

2. ventas[i] = ventas[i+1]

3. Fin Desde

4. El número de elementos validos n es ahora n = n – 1

Fin del Ejemplo 5.4





3. Arreglos Bidimensionales: Matrices m x n En un arreglo unidimensional o vector cada elemento es referenciado por un índice. En un arreglo bidimensional cada elemento se va a referenciar por 2 índices.

La representación lógica de un arreglo bidimensional es una matriz de dimensiones M x N, donde M es el número de filas de la matriz y N es el número de columnas, es decir, la 1ª dimensión indica las filas y la 2ª dimensión indica las columnas. Al acceder a un elemento I,J se está accediendo al elemento que ocupa la fila I y la columna J.

Un arreglo bidimensional de M x N elementos es un conjunto de M x N elementos, todos del mismo tipo, cada uno de los cuales es referenciado a través de 2 subíndices. El primer subíndice varía entre 1 y M o entre 0 hasta M-1, dependiendo desde donde comience el índice. El segundo índice varía entre 1 y N o entre 0 y N-1.

En general se puede definir un arreglo de 2 dimensiones de la siguiente manera:

<nombre arreglo>: arreglo[rango-filas, rango-columnas] de <tipo de dato>

Así la matriz para la representación de las ventas mensuales de cinco años será: ventas: arreglo[5, 12] de real

tamaño = m x n = 5 x 12 = 60

En memoria, sin embargo todos los elementos del arreglo se almacenan en posiciones contiguas.

Matriz de ventas 5 x 12, total de 60 elementos:

1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 120 5

ventas[4, 3] = 120

En memoria se almacenan los elementos en forma consecutiva:

1,1 1,2 1,3 1,4 ... 1,12 2,1 2,2 2,3 … 5,1 ... 5,12





3.1 Manejo de Matrices

3.1.2 Colocar el Valor de Cero a todos los Elementos de la Matriz

Esta es una operación útil cuando se desea inicializar todos los elementos de la matriz a un valor dado, usualmente ese valor es cero, aunque bien podría ser cualquier otro valor válido.

Sintaxis M: arreglo[m, n] de entero Var i, j : entero Desde i = 1 Hasta m

Desde j = 1 Hasta n M[i, j] = 0

Fin Desde Fin Desde

Ejemplo 5.5

Inicializar la matriz de ventas mensuales para 5 años. 1. ventas: arreglo[5, 12] de entero 2. Var i, j : entero 3. Desde i = 1 Hasta 5 4. Desde j = 1 Hasta 12 5. ventas[i, j] = 0 6. Fin Desde 7. Fin Desde

Fin del Ejemplo 5.5

3.1.3 Colocar el valor de cero a sólo los elementos de una fila dada

En este caso, se mantiene fija la fila y se recorren las columnas asignándoles un valor suministrado, usualmente ese valor es cero.

Sintaxis M: arreglo[m, n] de entero Var i, j : entero i = fila Desde j = 1 Hasta n

M[i, j] = 0 Fin desde





Ejemplo 5.6

Inicializar las ventas mensuales del año 3.

1. ventas: arreglo[5, 12] de entero 2. Var i, j : entero 3. i = 3 4. Desde j = 1 Hasta 12 5. M[i, j] = 0 6. Fin desde

En este caso, se le asignó el valor de cero a los elementos de la tercera fila de la matriz ventas.

Fin del Ejemplo 5.6

4. Arreglos Multidimensionales: Matrices m x n x...z Un arreglo multidimensional es una matriz de 3 ó más dimensiones. Si se tiene un arreglo de N dimensiones, donde cada dimensión es de tamaño d1,d2,..,dN, el número de elementos del arreglo será d1xd2x..xdN.

Para acceder a un elemento del arreglo se utilizan N índices, cada uno de los cuales referencia a una posición dentro de una dimensión, siempre según el orden de declaración.

En memoria, el arreglo se sigue almacenando en posiciones consecutivas.

La declaración de un arreglo multidimensional será:

Nom_arreglo: arreglo[rangoI, rangoII, ..., rangoN] de tipo

Ejemplo 5.7

Definir la matriz de ventas mensuales por cinco años para tres vendedores y asignar a las ventas del mes 10 del cuarto año para el vendedor 2, la cantidad de 120000.5.

ventas : arreglo[3, 5, 12] de real

ventas[2, 4, 10]= 120000.5

Fin del Ejemplo 5.7

5. Almacenamiento de Arreglos en Memoria Un arreglo en memoria siempre se almacena en posiciones contiguas a partir de la dirección base de comienzo del arreglo, la cual se asigna cuando se declara una variable del tipo arreglo.





El tamaño que ocupa el arreglo en memoria es el producto del número de sus elementos por el tamaño de cada uno de ellos. Por ejemplo, Arreglo[100] de carácter, si se asume que cada carácter necesita un byte para ser almacenado, entonces el arreglo necesita un total de 100 bytes de memoria: 1 byte x 100 elementos = 100 bytes.

En el caso de un arreglo multidimensional, también se almacena en posiciones contiguas de memoria. Su tamaño será el producto de sus elementos por el tamaño requerido para representar cada elemento en memoria. Por ejemplo, Arreglo[3, 5, 12] de enteros, si se asume que cada entero necesita dos byte para ser almacenado y se tiene un total de 3 x 5 x 12 = 180 elementos, entonces el arreglo requiere un total de 360 bytes de memoria: 2 bytes x (3 x 5 x 12) elementos = 360 bytes.






• Conocer las estructuras de datos. • Trabajar con arreglos unidimensionales o vectores. • Realizar operaciones con arreglos unidimensionales o vectores. • Trabajar con arreglos bidimensionales o matrices. • Conocer los arreglos multidimensionales. • Entender el almacenamiento de arreglos en memoria.





Unidad 5: Examen de Autoevaluación 1) Un vector es un conjunto finito, consecutivo y organizado de elemento heterogéneos.


2) Si se asume que el tipo de dato real requiere 4 bytes para su almacenamiento,

¿cuántos bytes se necesitan en memoria para almacenar la matriz Arreglo[2,3,5] de real? a) 10 bytes b) 30 bytes c) 120 bytes d) 120 bits

3) La representación lógica de un arreglo bidimensional es una matriz de dimensiones

M x N donde M representa: a) El número de la dimensión del vector b) El número de filas de la matriz c) El número de columnas de la matriz d) Ninguna de las anteriores

4) Un índice puede ser un valor constante.


5) Con referencia a los vectores, ¿Cuáles de las siguientes afirmaciones son correctas?

a) La longitud de un vector es dada por la multiplicación del rango del vector por el tamaño en bytes del tipo de datos.

b) Se almacenan en posiciones lineales o contiguas de memoria. c) En los índices de un arreglo, por lo común, se utilizan tipos de datos enteros y

caracteres. d) El tamaño máximo de un arreglo es el tamaño del tipo de datos al que pertenece

menos uno. 6) Se puede utilizar un procedimiento que devuelva un valor entero como índice de un

arreglo. a) Verdadero b) Falso





7) El siguiente algoritmo: M: arreglo [1..N,1..M] de entero Var i,j entero Desde i=1 hasta N

Desde j=1 hasta M M [1,j]= 5

Fin desde Fin desde

a) Inicializa a cinco todos los elementos del arreglo multidimensional b) Inicializa a cinco todas las filas del arreglo multidimensional c) Inicializa a cinco todas las columnas del arreglo multidimensional d) Ninguna de las anteriores

8) Todos los lenguajes de programación permiten declarar arreglos multidimensionales.


9) Al eliminar el primer elemento de un arreglo de cinco elementos, los restantes elementos deben ser desplazados hacia la izquierda. a) Verdadero b) Falso

10) Dado un arreglo X de M x N elementos, donde los elementos son números enteros,

la dirección de comienzo del elemento 5º del arreglo sabiendo que se almacena a partir de la dirección 1200 y que en nuestra máquina los enteros ocupan 2 bytes es: a) 1200 b) 1204 c) 1206 d) 1208





Respuesta de la Unidad 5: Examen de Autoevaluación 1) b 2) c 3) b 4) a 5) b y c 6) b 7) d 8) b 9) a

10) d


Unidad 6: Entrada y Salida Libro 1: Fundamentos de Programación 97



Unidad 6: Entrada y Salida


• Describir los conceptos básicos de entrada y salida en un programa de computadora.

• Listar algunas consideraciones específicas para imprimir la salida. • Describir los conceptos de registros de datos fijo, variable y bloqueado.


Libro 1: Fundamentos de Programación Unidad 6: Entrada y Salida 98



1. Introducción La solución a problemas de la vida real mediante computadoras incluye el uso de programas especializados para resolver dichos problemas. Los programas generalmente usarán, leyendo y escribiendo, datos provenientes de fuentes externas. Para que esto sea posible, las computadoras ofrecen capacidades de entrada y salida que le permiten a las aplicaciones comunicarse con ese entorno que se encuentra fuera del programa mismo.

En esta unidad se introducen los conceptos básicos de entrada y salida (E/S), mediante los cuales los programas de computadora pueden intercambiar, capturar y mostrar datos para la solución de problemas específicos.

2. Entrada y Salida de un Programa Un programa se carga en la computadora en el Procesador o Unidad Central de Procesamiento (CPU), cuando el programa se ejecute necesitará probablemente leer datos o escribir datos desde o hacia algún dispositivo.

El lenguaje que se emplee para escribir un programa tendrá algunos comandos especiales o funciones que se pueden usar para realizar la entrada y salida de los datos.

La entrada y salida, generalmente son las partes más complejas de cualquier programa o cualquier lenguaje de programación. La transferencia real de datos hacia o desde los dispositivos de E/S, suele ser la parte más lenta de un programa.

Los comandos que se usan para la entrada son normalmente: read, get o scan. Los comandos de la salida son, por su parte: print, write o put.

La Figura 6.1 muestra posibles entradas y salidas de un programa.

Figura 6.1: Entrada/Salida

Red

Scanner

PROCESADOR (programa en

ejecución)SALIDA

Teclado

Archivo en disco

Impresora

Archivo en disco

Pantalla

Red

ENTRADA





3. Buffers de Entrada y Salida Los datos externos que se procesan en un programa se leen y escriben realmente en un buffer que maneja la computadora. Un buffer es un espacio de memoria que el sistema operativo reserva para operaciones específicas, con la finalidad de acelerar esas operaciones y así optimizar el rendimiento. El sistema lee físicamente los datos de algún dispositivo externo a un buffer de entrada y los escribe en un buffer de salida. El sistema es propietario de los buffers y los administra.

El programa accede a los datos usando estos buffers del sistema, de tal forma que lee del buffer de entrada y escribe al buffer de salida. El manejo de estos buffers es total competencia del sistema operativo e ignorado por el programador.

Cuando se empieza el procesamiento con una operación de entrada, el sistema lee los datos del dispositivo de entrada y llena el buffer de entrada. A medida que se vacían los datos del buffer de entrada, el sistema sigue la pista del buffer y llena el buffer desde el dispositivo cuando está vacío.

Igualmente, las operaciones de escritura de un programa se realizan en el buffer de salida, también monitoreado por el sistema operativo. Cuando el buffer de salida está lleno, el sistema escribe el contenido del buffer de salida al dispositivo de salida designado, de forma transparente al programador.

Todo este movimiento de datos externo, lo maneja la parte del sistema operativo denominada Sistema de Control de I/O (IOCS). El IOCS se ejecuta paralelamente a la ejecución del programa. Esto significa que el programa puede continuar haciendo lo que necesite a los datos y el sistema se ocupa de transportarlos hacia y desde los dispositivos de E/S. Observe la Figura 6.2.





Figura 6.2: Buffers de Datos

4. Imprimir Datos Imprimir la salida a una impresora requiere ciertas consideraciones especiales como:

• Definir los formatos de salida para las líneas de datos y las líneas de título. • Contar las líneas impresas para no exceder la hoja de papel. • Contar las páginas para imprimir el número de página. • Escribir encabezados de páginas para identificar los datos impresos. • Control físico del carro de la impresora para imprimir los datos en el lugar

adecuado de la página.

Las situaciones enumeradas anteriormente deben ser manejadas en el programa.

Se puede inferir que hay que considerar formatos especiales cuando se escriben datos a un dispositivo de impresión. Debe mantenerse un contador de líneas para tener seguimiento de cuántas líneas se han impreso, para que así se pueda tener control de cuándo saltar a una nueva página y colocar los encabezados en una nueva página de salida. Debe mantenerse un contador de páginas que permita colocar el número de la página en la nueva página y se incremente cada vez que se vaya a imprimir una nueva página.

Por otra parte, hacen falta formatos específicos de impresión para imprimir las líneas de datos y las líneas de encabezado. Normalmente, el encabezado de la página requiere de

Buffers

ENTRADA SALI DA

LEER (READ)

ESCRIBIR(WRITE)

... HACER MIENTRAS (MAS DATOS) LEER /* PROCESAR */ ESCRIBIR FINHACER ...

Programa

Disco





formatos únicos de línea para las múltiples líneas de encabezado y los encabezados de columna.

El control de carro le indica a la impresora dónde imprimir la próxima línea.

4.1 Control de Carro de Impresora

La mayoría de los lenguajes de programación que proporcionan acceso directo a una impresora, también proporcionan un medio para controlar dónde se va a imprimir una línea. Esto generalmente se hace con un carácter de control en la primera posición de la impresión de cada línea. En la Tabla 6.1 se presentan los caracteres de control.

Caracteres Acción de Control

espacio Espaciar 1 línea

0 Espaciar 2 línea

_ Espaciar 3 línea

1 Saltar a una nueva página

+ Suprimir espaciado

Tabla 6.1: Caracteres de Control

Los caracteres de control se colocan en la primera posición de la impresión de cada línea y no se verán en la copia impresa. Este carácter de control siempre se aplica a la línea que se va a imprimir a continuación.

Cuando se usa el carácter de control “0” se da la apariencia de doble espacio. El “+” puede usarse para suprimir el espaciado de línea, para dar apariencia de sobreimpresión (overstrike) o negrita.

4.2 Imprimir Reportes

Como se mencionó anteriormente, cuando se escriben los reportes a una impresora, el programador tiene que considerar aspectos tales como; encabezados de páginas, números de las páginas, además de contadores de línea y pie de páginas que serán necesarias para cada página impresa.

Existen varios tipos de líneas que deben definirse:

• Línea de título: Contiene información que identifica al reporte: fecha, nombre del reporte y aparece en parte superior de cada página.

• Líneas de encabezados: Los encabezados de las columnas deben ser alineados con el de los datos.

• Líneas de datos: Son los datos del reporte.





• Líneas de resumen: Son los totales de página, totales finales o información complementaria.

• Líneas de pie de página: Contiene los números de la página, información de seguridad, etc.

El programador define la información para las partes constantes de las líneas de título, encabezado y de pie de página. Estos registros constantes se imprimirán mediante rutinas que se deberán ejecutar cuando se alcanza el inicio de una nueva página o el fin de ésta, según corresponda.

El fin de una página se determina contando las líneas y probando éste valor contra un número máximo deseado de líneas por página. Cuando se alcanza el límite de la página, el programa debe imprimir una línea de pie de página opcional en la página actual y, de haber una nueva página, imprimir una línea de título en la nueva página. Si se usan encabezados de columnas, éstos deben imprimirse antes de continuar la impresión y contar las líneas de detalle.

Pueden tenerse una rutina o procedimiento, para manejar las líneas de encabezado y otra para el pie de página o puede ser una sola que se encargue de ambas situaciones.

4.3 Encabezados de Páginas

El programador debe definir el tamaño de la página y una variable como contador de línea. El contador de línea se inicializa con el número máximo de líneas a imprimir, para permitir la invocación al procedimiento que imprime el encabezado del reporte.

Las consideraciones para el contador de línea son:

• Después de imprimir cada línea de detalle debe compararse (>=) con el tamaño de página, para determinar cuándo se debe llamar a la rutina de encabezado de página.

• Se debe incrementar inmediatamente después de imprimir una línea, basado en el espaciado simple, doble o triple.

• Siempre debe reflejar el número de la línea de la última línea escrita. • La rutina de encabezado de página debe inicializar de nuevo el contador de línea.

El tamaño de la página es el número máximo de líneas a ser impresas en la página. El programador decide el número que será y lo fija como una constante en el programa.

La rutina de encabezado de página también debe ocuparse de la variable contadora de página, la cual debe ser incrementada cada vez que se vaya a escribir en una nueva página. Esta variable puede ser parte de la línea del título o de pie de página, según el estilo del reporte.





5. Entrada/Salida de Archivo: Formatos de Registros Los datos escritos o leídos desde un archivo, generalmente se manejan como un registro. Existen típicamente dos formas en que pueden procesarse los datos de un registro, estas son como registros de largo fijo o como registros de largo variable. Los registros también pueden formar bloques para lograr eficiencia en la transferencia hacia y desde el dispositivo de almacenamiento. La Figura 6.4 representa esto.

Figura 6.4: Formatos de Registros

Las operaciones de E/S que usan un archivo de disco o cinta, normalmente trabajan con registros de datos y requieren que el programador considere los formatos del registro.

El tamaño de los registros fijos se establece generalmente, como un parámetro en el proceso de E/S. El tamaño de los registros variables es diferente para cada registro y se coloca en la cabecera del registro para indicar el número de bytes que éste ocupa.

Esto también se cumple para bloques de datos. El número de registros en cada bloque de un conjunto de datos de bloque fijo, se da como un parámetro del sistema de E/S. El tamaño para bloques variables puede ser diferente para cada bloque, así que el tamaño también es embebido en una porción de la cabecera de cada bloque.

Organizar datos en bloques es ventajoso, porque permite al sistema de control de E/S leer o escribir múltiples registros en cada transacción de flujo de los datos, según la cantidad de registros que contenga el bloque.

Número de bytes en el bloque

REGISTRO REGISTRO REGISTRO REGIST

REGISTRO REGISTRO REGISTRO REGIST

BLOQUE

FIJO

FIJO BLOQUEADO

VARIABLE BLOQUEADO

VARIABLE REGISTRO REGISTRO REGISTRO

Número de bytes en el registro

REGISTRO REGISTRO REGISTRO

BLOQUE





Ejemplo 6.1: Ejercicio de E/S

Diseñe un programa para generar un reporte de las horas trabajadas por un grupo de empleados. El formato del informe debe reflejar el nombre del empleado, las horas trabajadas y una indicación de horas de sobre tiempo, si el empleado trabajó más de cuarenta horas. El reporte debe contener un título y encabezados de columnas y debe manejar múltiples páginas.

La tarea será examinar los registros de entrada y el formato del reporte deseado, para luego hacer lo siguiente:

• Listar las localidades de entrada, salida y de procesamiento requeridos. • Listar los requerimientos de pre-proceso, proceso y post-proceso. • Dibujar un diagrama de flujo que muestra una solución correcta. • Verificar la solución.

Registros Entrada: Anderson 35 Andrews 42 Appleton 40 Arnold 30 Astor 45 Formato del Reporte: Reporte de Horas Trabajadas Nombre Horas Sobre tiempo Anderson 35 Andrews 42 si Appleton 40 Arnold 30 Astor 45 si





A continuación se presenta el diagrama de flujo de la solución al problema de E/S:

Figura 6.5: Diagrama de Flujo del Ejercicio de E/S

NO

NO

INICIO

CONT_LINEA >=

CONT PG

INDICADOR = ‘NO’

HORAS > 40

SI

SI

INICIO

LEER SIGUIENTE REGISTRO

CONT_LINEA = MAX_LINEAS CONT_PG = 1

NO FIN DE ARCHIVO

LEER 1er. REGISTRO

PROCESAR REGISTRO

FIN

ASIGNAR CAMPOS ENTRADA A

CAMPOS SALIDA

INDICADOR = ‘SI’

ESCRIBIR REGISTRO

CONT_LINEA = CONT_LINEA + 1

FIN

SI

NO

PROCESAR REGISTRO

NUEVA PÁGINA





Figura 6.6: Diagrama de Flujo del Ejercicio de E/S

Fin del Ejemplo 6.1

FIN

SALTAR A NUEVA PÁGINA

ESCRIBIR LINEA DE TÍTULO

ESCRIBIR LINEA DE CABECERA

CONT_LINEA = MAX LINEA

CON_PG = CONT_PG + 1

INICIO

NUEVA PÁGINA






• Describir los conceptos básicos de entrada y salida para programas de computadora.

• Listar algunas consideraciones específicas para imprimir la salida. • Describir los conceptos de registros de datos fijo, variable y bloqueado. • Crear un diseño de programa para manejar encabezados de página.





Unidad 6: Examen de Autoevaluación 1) Indique las sentencias correctas en referencia a entrada salida:

a) Los comandos que se usan para escribir un programa incluyen funciones o procedimientos especiales que se pueden usar para realizar la entrada y salida.

b) La entrada y salida generalmente son las partes más complejas de cualquier programa o cualquier lenguaje de programación

c) La transferencia real de datos hacia o desde los dispositivos de E/S, será generalmente la parte más lenta de un programa.

d) Sólo (a) y (c) 2) Los comandos que se usan para la entrada son normalmente:

a) write b) get c) display d) scan

3) Los comandos que se usan para la salida son normalmente:

a) print b) write c) put d) get

4) Los datos externos que se procesan en un programa se leen y escriben realmente en

un buffer que maneja la computadora. a) Verdadero b) Falso

5) De las siguientes, ¿cuáles son consideraciones especiales requeridas para Imprimir

la salida a una impresora? a) Separar los formatos de salida para las líneas de datos y las líneas del título b) Contadores de línea c) Contadores de páginas d) Encabezados de páginas e) Caracteres de control de carro en las líneas de salida





6) El carácter de control para indicar espaciado de 2 líneas es: a) espacio b) – c) 0 d) 1

7) Existen típicamente dos formas en que pueden procesarse los datos de un registro,

estas son: a) Registros encapsulados b) Registros fijos c) Registros variables d) Registros hash

8) El tamaño de los registros fijos, se establece generalmente como un parámetro en el

proceso de E/S a) Verdadero b) Falso

9) El tamaño de los registros variables, varía para cada registro y se coloca en el

registro en la cabecera para indicar el número de bytes que ocupa. a) Verdadero b) Falso

10) Organizar datos en los bloques permite al sistema de control de E/S leer o escribir

múltiples registros (el valor de un bloque) para cada transacción en el flujo de los datos. a) Verdadero b) Falso





Respuesta de la Unidad 6: Examen de Autoevaluación

1) a, b y c 2) b y d 3) b y c 4) a 5) b, c, d y e 6) c 7) b y c 8) a 9) a

10) a


Libro 1: Fundamentos de Programación Unidad 7: Ejemplos de Programas 111



Unidad 7: Ejemplos de Programas


• Diseñar un programa para manejar la verificación de secuencias y rupturas de control.

• Diseñar un programa para resolver un problema de emparejamiento de transacción.


Unidad 7: Ejemplos de Programas Libro 1: Fundamentos de Programación 112



1. Verificar la Secuencias Una secuencia puede ser:

• Una serie continua o conectada: El alfabeto. • Un orden consecutivo o por rango: Los naipes. • Un conjunto de elementos ordenados: Los números naturales.

Una verificación de secuencia es el proceso de garantizar el orden correcto de los registros al procesar un archivo secuencial, esto implica que esos datos se han ordenado previamente y requieren una jerarquía de datos y un valor clave para determinar el orden correcto.

Verificar la secuencia implica trabajar con un archivo de registros de datos que se ha ordenado previamente, generalmente en orden ascendente. Ejemplos de valores claves para ordenar pueden ser el número del empleado para registros de empleado o el número de parte para los registros del inventario.

El proceso de ordenar las cosas en orden ascendente es un problema de programación clásico. Esto se puede realizar a través de alguna función del sistema o proceso periférico fuera del programa que se está produciendo.

2. Rupturas de Control La ruptura de control (Control Break) es el reconocimiento de un cambio en el valor clave, cuando se procesan secuencias de registros que contienen múltiples registros con una clave común. Normalmente, se usa para procesar registros en secuencia en un sistema que contiene múltiples actualizaciones a registros maestros.

La ruptura de control, generalmente implica recolectar subtotales o imprimir los resúmenes parciales.

Un ejemplo de procesamiento con ruptura de control es el procesamiento de promedio de notas de los estudiantes de un salón de clase. La clave para hacer la ruptura de control, puede ser el ID del estudiante o el nombre del estudiante.

A medida que el programa lee el conjunto ordenado de registros de notas del estudiante, promedia las notas de todos los cursos del estudiante en particular y rompe el control cuando encuentra un nuevo ID de estudiante o nombre.

Al interrumpir el control, este programa calcula el promedio de notas del estudiante y luego reinicializan todos los acumuladores para preparar el procesamiento del próximo estudiante.





3. Emparejar Transacciones Emparejar Transacciones es emparejar el valor clave de un registro de un archivo contra el valor clave de los registros en un archivo maestro.

El Archivo Maestro es una colección de registros que contienen los datos permanentes o acumulados para un sistema. Ver Figura 7.1

Figura 7.1: Transacciones

Emparejar transacciones es una actividad común en el procesamiento de archivos. Típicamente hay muchos registros de transacción para ser procesados contra sólo un registro en el archivo maestro con el valor clave.

Algunos ejemplos donde se aplica son:

• Las notas del estudiante de un semestre: Las transacciones son las notas que se emparejan contra los registros de notas permanentes para la cohorte que constituyen el archivo maestro.

• La comprobación diaria y la actividad de depósito: Las transacciones son los movimientos diarios que se emparejan contra el registro de cuenta para la cuenta corriente, que conforma el archivo maestro.

• Un almacén y el reabastecimiento diario: Las ventas diarias son las transacciones, emparejado contra la información detallada de inventario actual para un producto, que conforma el archivo maestro.

3.1 Ejercicio de Punto de Chequeo

Hay que diseñar un programa para generar un informe del resumen de ventas para un grupo de departamentos. El formato del informe debe reflejar el número del departamento y las ventas totales. Cada departamento puede tener múltiples registros de entrada. Se requiere verificar la secuencia del número del departamento. Si un registro de entrada está fuera de la secuencia, se debe imprimir un mensaje de error, los resultados acumulados y terminar el programa. El informe debe contener las

00120 01655 24898 59437 76990 98144

Archivo Maestro

01655 59437 76990

Transacciones





cabeceras de las columnas y debe ocuparse de páginas múltiples. El título para el informe es optativo. La tarea será examinar los registros de entrada, el formato del informe deseado y hacer lo siguiente:

• Listar la entrada, salida y localidades de almacenamiento de proceso requeridas. • Listar los requisitos de pre-proceso, proceso y post-proceso. • Hacer un diagrama de flujo que muestre una solución correcta. • Verificar la solución usando los dos juegos de entrada que se muestran a

continuación:

Entrada 1:

5 5 5 6 6

16 16

200.00 100.00 100.00 50.00 200.00 300.00 100.00

Entrada 2:

555

1616

96

200.00 100.00 100.00 300.00 200.00 50.00 200.00

Salida 2: Dpto. No.

516

Ventas 400.00 500.00

Salida 1:

Dpto. No. 5 6

16

Ventas 400.00 250.00 400.00

Error de Secuencia Figura 7.2: Punto de Chequeo





Figura 7.3: Diagrama de Flujo del Ejercicio de Punto de Chequeo

LEER 1ER REGISTRO

DEPT = DEPT-LEIDO

LEER SIGUIENTE REGISTRO

VENTAS_ACUM = 0

SW = 1

INICIO

DEPT <

DEPT-LEIDO

SW = 0

VENTAS_ACUM = VENTAS_ACUM + VENTAS_LEIDAS

ERROR

DEPT >

DEPT-LEIDO

no

FIN

NO

PROCESAR VENTAS

si

ASIGNAR Y ESCRIBIR TOTAL DE VENTAS ÚLTIMO

PROCESAR VENTAS

SI

MENSAJE DE ERROR DE SECUENCIA

INICIO

FIN

SI

NO

CONT_LINEA = MAX_LINEA CONT_PG = 1

SW = 0

NO FIN ARCHIVO Y SW = 1

si

no

RUPTURA

PUNTO DE CHEQUEO





Figura 7.4: Diagrama de Flujo del Ejercicio de Punto de Chequeo

NO

CONT_LINEA = CONT_LINEA + 1

DEPT = DEPT-LEIDO

FIN

VENTAS_ACUM = VENTAS_LEIDAS

ASIGNAR Y ESCRIBIR LINEA DE DAYTOS PARA EL DPTO.

INICIO

SI

FIN

SALTAR A NUEVA PÁGINA

ESCRIBIR LINEA DE TÍTULO

ESCRIBIR LINEA DE CABECERA

CONT_LINEA = MAX LINEA

CON_PG = CONT_PG + 1

INICIO

RUPTURA

NUEVA_PAGINA

CONT_LINEA >= MAX_LINEA






• Diseñar un programa para manejar la verificación de secuencias y rupturas de control.

• Diseñar un programa para resolver un problema de emparejamiento de transacción.





Volumen 2: Complementos I


Libro 1: Fundamentos de Programación Unidad 1: Sentencias Simples 121



Unidad 1: Sentencias Simples

1. Conceptos Un algoritmo es una serie de pasos lógicos, que se estructuran para resolver un problema. Generalmente, un algoritmo se compone de sentencias simples y sentencias de control. Las sentencias simples son:

1.1 Declaración de Variables

Consiste en escribir el tipo de datos y la lista de identificadores que se tendrán de dicho tipo, separando cada identificador por medio de comas (,). Para mejorar la claridad de la declaración se puede colocar dos puntos (:) para separar el tipo de datos de la lista de identificadores, por ejemplo:

1.2 Asignación de Variables

Asignar un valor a una variable equivale a decir que se guarda dicho valor en la posición de memoria reservada para la variable en mención. Ejm:

1.3 Lectura de Variables

La instrucción (LEER, OBTENER o ADQUIRIR) se utiliza para enviar información desde un dispositivo de entrada de datos hacia la memoria, por ejemplo:

Resultado = 2 * 3

Estatura = 1.80

Edad = 10

Entero: edad

Real: estatura, peso, sueldo

edad

Cadena: nombre, dirección


Unidad 1: Sentencias Simples Libro 1: Fundamentos de Programación 122



Para la leer u obtener datos desde un dispositivo de entrada hacia la memoria, frecuencia también se utiliza el símbolo:

1.4 Escritura de Datos

La instrucción (MOSTRAR, IMPRIMIR o ESCRIBIR) permite enviar datos desde la memoria hacia un dispositivo de salida como la pantalla. La información que se envía puede ser el calor de una constante o también el contenido de variables, por ejemplo:

Edad

“Su peso es: ” peso

Estatura, peso

edad





Ejercicios Resueltos 1) Dada las horas trabajadas de una persona y la tarifa de pago por hora, calcule su

salario e imprímalo.

INICIO

tarifa

entero horas real tarifa, salario

salario = horas * tarifa

“El salario es: ”salario

FIN

“Ingrese la cantidad de

horas”

“Ingrese la tarifa”

horas





2) Dada la base y altura de un rectángulo, calcular el área y el perímetro del mismo. Las fórmulas a utilizar son: Area = base * altura y Perímetro = 2 * (base + altura)

INICIO

base

real base, altura, area, perimetro

area = base * altura

“El area es:” area

FIN

perimetro = 2 * (base + altura)

“El perímetro es:”

perimetro

“Ingrese la

altura: ”

“Ingrese la base:

”

altura





3) Obtener la edad de una persona en meses, si se ingresa su edad en años y meses. Por ejemplo, si se ingresan 3 años 4 meses debe mostrar 40 meses

INICIO

anios

entero meses, anios, totalM

totalM = (anios * 12) + meses

“La edad en meses es: ” totalM

FIN

“Ingrese los años de la persona”

meses

“Ingrese los meses de la persona”





4) Escriba un algoritmo que permita convertir un valor ingresado en pies a metros. La fórmula a utilizar es 1pie = 30.48 cm.

5) Convertir una velocidad expresada en km/h a m/s. Si 1Km=1000 m y 1h=3600

seg.

INICIO

pies

real pies, metros, centimetros

centimetros = pies * 30.48

pies “pies equivalen a ” metros “metros”

FIN

“Ingrese un valor en pies”

metros = centimetros / 100

INICIO

kmph

real kmph, mps

mps = kmph * 5 / 18

kmph “Km/h equivales a: ” mps

“M/s”

FIN

“Ingrese la velocidad en Km/h”





6) Dada una cantidad de hombres y de mujeres, calcular el porcentaje de cada género dentro del grupo.

INICIO

hombres

entero hombres, mujeres, total real porch, porcm

total = hombres + mujeres

“%hombres= ” porch

FIN

porch = hombres / total

“% mujeres = ” porcm

porcm = mujeres / total

mujeres

“Ingrese cantidad de hombres”

“Ingrese cantidad de mujeres”





7) Un instructor prepara tres modelos de exámenes para tres salones en un curso de programación. El instructor sabe que tarda 5 min en el modelo del salón A, 8 min en el modelo del salón B y 6 minutos en el modelo del salón C. Dadas las cantidades de estudiantes en cada salón, ¿Cuántas horas y minutos tardará el instructor en revisar los exámenes de todos los salones?

INICIO

estA, estB, estC

entero estA, estB, estC, tiempoA, tiempoB, tiempoC, tiempoT,

horasT, minT

tiempoA = estA * 5 tiempoB = estB * 8 tiempoC = estC * 6

tiempoT = tiempoA + tiempoB+tiempoC

“El instructor tardará ” horasT “horas y ” minT

“minutos”

FIN

horasT = tiempoT div 60

minT = tiempoT mod 60

“Ingrese la cantidad de estudiantes de los salones A, B y

C”





Ejercicios por Resolver 1) Determine el promedio de 3 números reales. 2) Calcular y mostrar el área de un triángulo si se ingresa por teclado la base y la

altura. 3) Calcular el área y perímetro de un triángulo, conocidos sus lados. 4) Hacer un algoritmo que permita ingresar dos números enteros y calcule las 4

operaciones básicas (suma, resta, multiplicación, división). Además, calcular la potencia. El algoritmo debe mostrar los números y los resultados.

5) Escriba un algoritmo que lea la velocidad en km/h y el número de horas transcurridas por un móvil, para determinar la distancia recorrida.

6) Un corredor reporta el número de minutos que corre en un año. Escribir un programa que dé como salida la cantidad de tiempo equivalente en meses, semanas, días, horas y minutos.

7) Calcule el interés generado (interes), por un capital depositado (capdep) durante cierta cantidad de períodos (cp) a una tasa de interés determinada (tasa) expresada en porcentaje. Use las fórmulas: a) monto = (capdep)*(1+tasa/100)cp b) interes = monto – capdep

8) Dado un tiempo en minutos, calcular los días, horas y minutos que le corresponden.


Libro 1: Fundamentos de Programación Unidad 2: Estructuras de Decisión 131



Unidad 2: Estructuras de Decisión

1. Conceptos Las estructuras de decisión o también llamadas de selección, permiten que el algoritmo tome decisiones y ejecute u omita algunos procesos dependiendo del cumplimiento de una condición.

Se pueden manejar tres tipos de decisiones: simple, doble y múltiple.

Una decisión es simple, cuando sólo se tiene determinado los pasos a seguir si el resultado de la condición es verdadero, mientras que si es falso, la ejecución del algoritmo continúa después de la estructura condicional.

Una decisión es doble, cuando se tiene un curso de acción para el caso que el resultado de la comparación sea verdadero y otro para cuando sea falso.

La decisión múltiple determina el valor de una variable y dependiendo de éste sigue un curso de acción. Es importante tener en cuenta que sólo se verifica la condición de igualdad entre la variable y la constante.


Unidad 2: Estructuras de Decisión Libro 1: Fundamentos de Programación 132



Ejercicios Resueltos 1) Solicite un número al usuario e imprima su valor absoluto. Recuerde que el valor

absoluto de un número es el mismo valor si es positivo y es el valor cambiado de signo en caso de que sea negativo.

INICIO

numero

entero numero

“Ingrese un número entero”

num ero < 0

“El valor absoluto es: “ numero

numero=numero * (-1)

FIN

si

no





2) Elabore un programa que imprima el mayor de dos números enteros introducidos por el usuario.

INICIO

a

entero a, b, mayor

mayor = a

“El mayor es:” mayor

FIN

“Ingrese el primer valor”

a > b SI

b

“Ingrese el segundo

valor”

mayor = b

NO





3) Dados dos números introducidos por el usuario, identifique cuál es el mayor, cuál es el menor y si son iguales muestre un mensaje.

INICIO

a

entero a, b

“Los números son iguales”

FIN

“Ingrese el primer valor”

a == bsi

b

“Ingrese el segundo valor”

NO a > b

“El mayor es:” a

“El menor es:” b

“El mayor es:” b

“El menor es:” a

SI

no





4) Elabore un programa que solicite el salario de un empleado y calcule el nuevo salario de la siguiente forma: Si el empleado gana hasta de 500.000 tendrá un incremento del 10%, si devenga más de 500.000 y hasta 800.000 recibirá un aumento del 8% y si gana más de 800.000 un aumento del 5%. Muestre por pantalla el monto del aumento y el nuevo salario total del empleado.

INICIO

real salario, porc, aumento, nuevosal

“Ingrese el salario: “

salario

salario <= 500000 porc = 10 si

salario <= 800000

no

porc = 8porc = 5 si no

aumento = salario * porc / 100

nuevosal = salario + aumento

“Ud ha recibido un aumento de “ aumento “ Su nuevo salario es “ nuevosal

FIN





5) Elaborar un programa que lea tres notas y calcule el promedio. Si éste es menor a 10, imprimir: “Nota deficiente”. Si es mayor o igual a 10 y menor o igual a 15, imprimir: “Nota regular”. Si es mayor que 15, imprimir: “Nota excelente”.

INICIO

entero nota1, nota2, nota3 real promedio

“Ingrese 3 notas: “

nota1, nota2, nota3

promedio = (nota1+nota2+nota3)/3

promedio < 10

promedio <= 15

no

no si

“Nota excelente” “Nota regular”

“Nota deficiente”

FIN





6) Una tienda que vende televisores, lavadoras y neveras tiene una promoción. Si el cliente compra tres artículos iguales o más, recibe un descuento del 15% sobre el precio de dicho artículo; de lo contrario sólo recibe un descuento del 5%. Calcular el monto total a pagar por el cliente y mostrarlo por pantalla. Los televisores cuestan 25.000, las lavadoras 30.000 y las neveras 75.000.

FIN

Entero cantT, cantL, cantN Real precioT, precioL, precioN Real totalT, totalL, totalN, total

“Ingrese cantidad de TV’s, lavadoras y neveras”

cantT, cantL, cantN

cantT >= 3

precioT=25000*0.95

no si

precioT=25000*0.85

cantL >= 3

precioL=30000*0.85precioL=30000*0.95

A

cantN >= 3

precioN=75000*0.95 precioN=75000*0.85

A INICIO

totalT = cantT * precioT

totalL = cantL * precioL

totalN = cantN * precioN

total = totalT + totalL + totalN

“Monto a pagar” “Televisores: “ totalT “Lavadoras: “ totalL “Neveras: “ totalN “Monto Total: “ total





7) Una aseguradora de vehículos tiene los siguientes porcentajes de prima dependiendo de los años de antigüedad del vehículo. Los vehículos de 1 año pagan el 5% de su valor, de dos años el 8%, de tres años el 10%, de cuatro años el 12% y de cinco años o más pagan el 15%. Elabore un programa que solicite el valor del vehículo y los años de antigüedad y muestre por pantalla el valor de la prima.

INICIO

Entero valor, anios Real porc, prima

“Ingrese el valor del vehículo y los años de antigüedad:”

valor, anios

anios

porc = 5 porc = 8 porc = 10 porc = 12 porc =15

1 2 3 4 otro

FIN

prima = valor * porc/100

“El monto de la prima es: “ prima





Ejercicios por Resolver 1) Dados sus tres lados (a,b,c), determinar si un triangulo es: equilátero, isósceles o

escaleno. 2) A un trabajador le pagan según sus horas y una tarifa de pago por horas. Si la

cantidad de horas trabajadas es mayor a 40 horas, entonces la tarifa se incrementa en un 50% para las horas extras. Calcular el salario del trabajador dadas las horas trabajadas y la tarifa.

3) A un trabajador le descuentan de su sueldo el 10% si su sueldo es menor o igual a 1000. por encima de 1000 y hasta 2000 el 5% del adicional y por encima de 2000 el 3% del adicional. Calcular el descuento y sueldo neto que recibe el trabajador dado su sueldo.

4) Dado un monto, calcular el descuento considerando que por encima de 100 el descuento es el 10% y por debajo de 100 el descuento es el 2%.

5) Elabore un programa que permita emitir la factura correspondiente a una compra de un artículo determinado, del que se adquieren una o varias unidades. El IVA es del 15% y si el monto bruto (precio venta más IVA) es mayor de 50.00 pesetas se debe realizar un descuento del 5% sobre el monto total.

6) Dado un tiempo en segundos, calcular los segundos restantes que le correspondan para convertirse exactamente en minutos. Por ejemplo, si el usuario introduce 340 el resultado debe ser 20.


Libro 1: Fundamentos de Programación Unidad 3: Estructuras de Repetición 141



Unidad 3: Estructuras de Repetición

1. Conceptos Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces dependiendo del cumplimiento de una condición. En algunos casos, el número de repeticiones se conoce con anterioridad, mientras que en otros depende de cálculos o estados de variables que se dan dentro de la solución del problema. Existen tres tipos de ciclos, los cuales se explican a continuación.

1.1 Ciclo Mientras .. Hacer (while .. do)

Este ciclo consiste en un conjunto de instrucciones que se repiten mientras se cumpla una condición. De igual manera que en los condicionales, la condición es evaluada y retorna un valor lógico, que puede ser verdadero o falso. En el caso del ciclo mientras, las instrucciones contenidas en la estructura de repetición se ejecutarán solamente si al evaluar la condición se genera un valor verdadero; es decir, si la condición se cumple; en caso contrario, se ejecutará la instrucción que aparece después de fin mientras.

El ciclo mientras, comienza evaluando la expresión condicional, si el resultado es verdadero se ejecutarán las instrucciones que estén entre el mientras y el fin mientras. Al encontrarse la línea fin mientras, se volverá a evaluar la condición, si se cumple se ejecutarán nuevamente las instrucciones y así sucesivamente hasta que la condición deje de cumplirse, en cuyo caso, el control del programa pasa a la línea que aparece después de fin mientras.

Si en la primera pasada por el ciclo mientras la condición no se cumple las instrucciones que están dentro del ciclo no se ejecutarán ni una sola vez.

1.2 Ciclo Repetir .. Hasta (Repeat .. until)

En este ciclo, se ejecutarán las sentencias, hasta que se cumpla la condición. Además, una diferencia con la sentencia de control anterior, es que en ésta por lo menos se entra una vez en el ciclo.

1.3 Ciclo Desde (for)

Este ciclo, al igual que los demás, permite ejecutar repetidas veces una instrucción o un grupo de ellas, pero a diferencia de otras instrucciones de repetición, ésta maneja el valor inicial, el valor de incremento o decremento y el valor final de la variable de control como parte de la instrucción.

Cuando al ejecutarse un algoritmo se encuentra una instrucción para la variable de control (contador) toma el valor inicial, se verifica que el valor inicial no sobrepase el valor final y luego se ejecutan las instrucciones del ciclo. Al encontrar la instrucción fin para, se produce el incremento y se vuelve a verificar que la variable de control no haya


Unidad 3: Estructuras de Repetición Libro 1: Fundamentos de Programación 142



superado el límite admitido y se vuelven a ejecutar las instrucciones que están dentro del ciclo, y así sucesivamente tantas veces como sea necesario hasta que se supere el valor final establecido.

El ciclo termina en el momento en que la variable de control (contador) sobrepasa el valor final; es decir, que la igualdad está permitida y las instrucciones se ejecutan cuando el contador es igual al valor final.





Ejercicios Resueltos 1) Elabore un programa que muestre los números del 1 al 10. Ciclo Mientras..Hacer.

INICIO

Entero numero = 1

FIN

numero <= 10 numero numero = numero + 1

si

no





2) Solicite al usuario 10 números y muestre el promedio de ellos. Ciclo Mientras..Hacer.

INICIO

Entero numero, suma=0, n=1, Real promedio

n <= 10 “Ingrese un numero” numero

suma = suma + numero

n = n + 1

si

no

promedio = suma / 10

“El promedio es: “ promedio

FIN





3) Solicite al usuario 10 números positivos y muestre el mayor de ellos. Ciclo Hacer..Mientras.

INICIO

Entero numero, mayor = 0, contador =

“Ingrese un numero entero positivo”

numero

numero > mayor mayor = numero si

no

contador = contador + 1

contador < 10 si

“El mayor es “ mayor

FIN

no





4) La serie Fibonacci comienza con los números: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... Se requiere un algoritmo para generar los primeros 10 números. Ciclo Mientras..Hacer.

FIN

INICIO

Entero a = 1, b = 1, n = 2, c

“1, 1”

n = n +1

n < 10 si

b = c

a = b

“, “ c

c = a + b





5) Dado N notas de un estudiante calcular:

a) Cuántas notas tiene desaprobadas. b) Cuántas notas tiene aprobadas. c) El promedio de todas las notas. d) El promedio de notas aprobadas y desaprobadas.

º

FIN

INICIO

Entero n ,i=1, nota, naprob=0, ndes=0, acum._aprb=0, acum._des=0 Real promaprob, promdes, promtotal

“¿Cuántas notas desea introducir?”

n

i = i +1

acum_des = acum_des + nota

acum_aprob = acum_aprob + nota

ndes = ndes + 1 napron = naprob + 1

nota >= 10

nota

“Ingrese nota”i <= n

A

si

no

si no

A

promaprob = acum_aprob / naprob

promdes = acum_des / ndes

promtotal = (acum_aprob + acum_des) / n

“Notas aprobadas: “ acum._aprob “Notas desaprobadas: “ acum_des “Promedio total: “ promtotal “Promedio aprobadas: “ promaprob “Promedio desaprobadas: “ promdes





Ejercicios Propuestos 1. Construya un algoritmo que reciba como entrada un cierto valor n y genere como

salida n veces la palabra “hola".

2. Construya un algoritmo que reciba como entrada un cierto valor n y genere como salida el valor de la serie: 1 + 2 + 3 + 4 + : : : + n

3. Dado un número determinar la suma de sus dígitos.

4. Realizar un algoritmo que permita pedir 20 números naturales y determine e imprima cuántos son pares, impares, positivos y negativos.

5. Desarrollar un algoritmo para calcular e imprimir el factorial de un número.

6. Elaborar un programa que lea N cantidad de notas, calcule el promedio. Si éste es menor que 10, imprimir: “Reprobado”. Si es mayor o igual a 10, imprimir:”Aprobado”.

7. En un evento público donde entran N cantidad de personas y las entradas cuestan S cantidad de bolívares, hay un descuento para adultos de 25%, para menores de 12 años de 50% y para menores de 6 años de 70%. Elaborar un programa que solicite el valor de las entradas y las edades de N personas y calcule el monto a pagar.

8. Calcular y visualizar la suma y el producto de los números pares comprendidos entre 20 y 400 ambos inclusive.

9. Hacer un programa que al ingresar un número indique si es o no es un número Ámstrong, si no lo es que indique que vuelva a intentar (un número es Ámstrong si la suma de los dígitos que lo componen, elevados al cubo, es igual al número. Ejemplo: 153 es Ámstrong porque 13 + 53 + 33 = 1 + 125+ 27).


Libro 1: Fundamentos de Programación Unidad 4: Sentencias Simples (Pseudocódigo) 149



Unidad 4: Sentencias Simples (Pseudocódigo)

Ejercicios Resueltos 1. Dada las horas trabajadas de una persona y la tarifa de pago por hora, calcule su salario e imprímalo.

1. algoritmo salario

2. var horas: entero

3. tarifa, salario: real

4. inicio

5. mostrar “Ingrese la cantidad de horas: ”

6. leer horas

7. mostrar “Ingrese la tarifa”

8. leer tarifa

9. salario = horas * tarifa

10. mostrar “El salario es: ” salario

11.fin salario

2. Dada la base y altura de un rectángulo, calcular el área y el perímetro del mismo. Las fórmulas a utilizar son: Area = base * altura y Perímetro = 2 * (base + altura).

1. algoritmo rectangulo

2. var base, altura, area, perímetro: real

3. inicio

4. mostrar “Ingrese la base: ”

5. leer base

6. mostrar “Ingrese la altura: ”

7. leer altura

8. area = base * altura

9. perimetro = 2 * (base + altura)

10. mostrar “El area es: ” area

11. mostrar “El perímetro es: ” perimetro

12.fin rectangulo


Unidad 4: Sentencias Simples (Pseudocódigo) Libro 1: Fundamentos de Programación 150



3. Obtener la edad de una persona en meses, si se ingresa su edad en años y meses. Por ejemplo: Si se ingresan 3 años 4 meses debe mostrar 40 meses.

1. algoritmo edad

2. var meses, anios, totalM: entero

3. inicio 4. mostrar “Ingrese los años de la persona: ”

5. leer anios

6. mostrar “Ingrese los meses de la persona: ”

7. leer meses

8. totalM = (anios * 12) + meses

9. mostrar “La edad en meses es: ” totalM

10. fin edad

4. Escriba un algoritmo que permita convertir un valor ingresado en pies a metros. La fórmula a utilizar es 1pie = 30.48 cm.

1. algoritmo piesametros

2. var pies, metros, centímetros: real

3. inicio 4. mostrar “Ingrese un valor en pies: ”

5. leer pies

6. centimetros = pies * 30.48

7. metros = centimetros / 100

8. mostrar pies “ equivalen a ” metros “ metros.”

9. fin piesametros

5. Convertir una velocidad expresada en km/h a m/s. Si 1Km=1000 m y 1h=3600 segundos.

1. algoritmo kmhamps

2. var kmph, mps: real

3. inicio

4. mostrar “Ingrese la velocidad en Km/h: ”

5. leer kmph

6. mps = kmph * 5 / 18

7. mostrar kmph “ Km/h equivales a ” mps “ m/s.”

8. fin kmhamps


Libro 1: Fundamentos de Programación Unidad 4: Sentencias Simples (Pseudocódigo) 151



6. Dada una cantidad de hombres y de mujeres, calcular el porcentaje de cada género dentro del grupo.

1. algoritmo porcgeneros

2. var hombres, mujeres, total: entero

3. porch, porcm: real

4. inicio

5. mostrar “Ingrese la cantidad de hombres: ”

6. leer hombres

7. mostrar “Ingrese la cantidad de mujeres: ”

8. leer mujeres

9. total = hombres + mujeres

10. porch = hombres / total

11. porcm = mujeres / total

12. mostrar “%hombres = ” porch

13. mostrar “%mujeres = ” porcm

14.fin porcgeneros

7. Un instructor prepara tres modelos de exámenes para tres salones en un curso de programación. El instructor sabe que tarda 5 min en el modelo del salón A, 8 min en el modelo del salón B y 6 minutos en el modelo del salón C. Dadas las cantidades de estudiantes en cada salón, ¿Cuántas horas y minutos tardará el instructor en revisar los exámenes de todos los salones?

1. algoritmo examenes

2. var estA, estB, estC, tiempoA, tiempoB, tiempoC, tiempoT, horasT, minT: entero

3. inicio

4. mostrar “Ingrese la cantidad de estudiantes de los salones A, B y C: ”

5. leer estA, estB, estC

6. tiempoA = estA * 5

7. tiempoB = estB * 8

8. tiempoC = estC * 6

9. tiempoT = tiempoA + tiempoB + tiempoC

10. horasT = tiempoT / 60

11. minT = tiempoT mod 60 12. mostrar “El instructor tardará ” horasT “ horas con ” minT “

minutos.”

13.fin examenes


Unidad 4: Sentencias Simples (Pseudocódigo) Libro 1: Fundamentos de Programación 152



Ejercicios por Resolver 1. Determine el promedio de 3 números reales.

2. Calcular y mostrar el área de un triángulo si se ingresa por teclado la base y la altura.

3. Calcular el área y perímetro de un triángulo, conocidos sus lados.

4. Hacer un algoritmo que permita ingresar dos números enteros y calcule las 4 operaciones básicas (suma, resta, multiplicación, división). Además, calcular la potencia. El algoritmo debe mostrar los números y los resultados.

5. Escriba un algoritmo que lea la velocidad en km/h y el número de horas transcurridas por un móvil, para determinar la distancia recorrida.

6. Un corredor reporta el número de minutos que corre en un año. Escribir un programa que dé como salida la cantidad de tiempo equivalente en meses, semanas, días, horas y minutos.

7. Calcule el interés generado (interes) por un capital depositado (capdep) durante cierta cantidad de períodos (cp) a una tasa de interés determinada (tasa) expresada en porcentaje. Use las fórmulas:

a. monto = (capdep)*(1+tasa/100)cp

b. interes = monto – capdep

8. Dado un tiempo en minutos, calcular los días, horas y minutos que le corresponden.


Libro 1: Fundamentos de Programación Unidad 5: Estructuras de Decisión (Pseudocódigo) 153



Unidad 5: Estructuras de Decisión (Pseudocódigo)

Ejercicios Resueltos 1. Solicite un número al usuario e imprima su valor absoluto. Recuerde que el valor absoluto de un número es el mismo valor si es positivo y es el valor cambiado de signo en caso de que sea negativo.

1. algoritmo valor_absoluto

2. var numero: entero

3. inicio

4. mostrar “Ingrese un número entero: ”

5. leer numero

6. si numero < 0 entonces

7. numero = numero * (-1)

8. fin si

9. mostrar “El valor absoluto es: ” numero

10.fin valor_absoluto

2. Elabore un programa que imprima el mayor de dos números enteros introducidos por el usuario.

1. algoritmo mayor

2. inicio

3. var a, b, mayor: entero

4. inicio

5. mostrar “Ingrese el primer valor: ”

6. leer a

7. mostrar “Ingrese el segundo valor: ”

8. leer b

9. si a > b entonces

10. mayor = a

11. sino

12. mayor = b

13. fin si

14. mostrar “El mayor es: ” mayor

15.fin mayor


Unidad 5: Estructuras de Decisión (Pseudocódigo) Libro 1: Fundamentos de Programación 154



3. Dados dos números introducidos por el usuario, identifique cuál es el mayor, cuál es el menor y si son iguales muestre un mensaje.

1. algoritmo comparar

2. var a, b: entero

3. inicio

4. mostrar “Ingrese el primer valor: ”

5. leer a

6. mostrar “Ingrese el segundo valor: ”

7. leer b

8. si a == b entonces

9. mostrar “Los números son iguales. ”

10. sino

11. si a > b entonces

12. mostrar “El mayor es: ” a

13. mostrar “El menor es: ” b

14. sino

15. mostrar “El mayor es: ” b

16. mostrar “El menor es: ” a

17. fin si

18. fin si

19. fin comparar

4. Elabore un programa que solicite el salario de un empleado y calcule el nuevo salario de la siguiente forma: Si el empleado gana hasta de 500.000 tendrá un incremento del 10%, si devenga más de 500.000 y hasta 800.000 recibirá un aumento del 8% y si gana más de 800.000 un aumento del 5%. Muestre por pantalla el monto del aumento y el nuevo salario total del empleado.

1. algoritmo aumento

2. var salario, porc, aumento, nuevosal: real

3. inicio

4. mostrar “Ingrese el salario: ”

5. leer salario

6. si salario <= 500000 entonces

7. porc = 10

8. sino

9. si salario <= 800000 entonces

10. porc = 8

11. sino

12. porc = 5

13. fin si





14. fin si

15. aumento = salario * porc / 100

16. nuevosal = salario + aumento

17. mostrar “Ud. ha recibido un aumento de: ” aumento

18. mostrar “Su nuevo salario es: ” nuevosal

19.fin aumento

5. Elaborar un programa que lea tres notas y calcule el promedio. Si éste es menor a 10, imprimir: “Nota deficiente”. Si es mayor o igual a 10 y menor o igual a 15, imprimir: “Nota regular”. Si es mayor que 15, imprimir: “Nota excelente”.

1. algoritmo promedio

2. var nota1, nota2, nota3: entero

3. promedio: real

4. inicio 5. mostrar “Ingrese las tres notas: ”

6. leer nota1, nota2, nota3

7. promedio = (nota1 + nota2 + nota3) / 3

8. si promedio < 10 entonces

9. mostrar “Nota deficiente”

10. sino

11. si promedio <= 15 entonces

12. mostrar “Nota regular”

13. sino

14. mostrar “Nota excelente”

15. fin si

16. fin si

17. fin promedio

6. Dado un tiempo en segundos, calcular los segundos restantes que le correspondan para convertirse exactamente en minutos.

1. algoritmo tiempo

2. var tiempo_seg, segundos = 0: entero

3. inicio

4. mostrar “Ingrese el tiempo en segundos: ”

5. leer tiempo_seg

6. segundos = tiempo_seg mod 60

7. si segundos > 0 entonces

8. segundos = 60 – segundos

9. fin si





10. mostrar “Faltan: ” segundos “ seg.”

11. fin tiempo

7. Una tienda que vende televisores, lavadoras y neveras tiene una promoción. Si el cliente compra tres artículos iguales o más recibe un descuento del 15% sobre el precio de dicho artículo; de lo contrario sólo recibe un descuento del 5%. Calcular el monto total a pagar por el cliente y mostrarlo por pantalla. Los televisores cuestan 25.000, las lavadoras 30.000 y las neveras 75.000.

1. algoritmo tienda

2. var cantT, cantL, cantN: entero

3. precioT, precioL, precioN, totalT, totalL, totalN, total: real

4. inicio 5. mostrar “Ingrese la cantidad de TV’s, Lavadoras y Neveras: ”

6. leer cantT, cantL, cantN

7. si cantT >= 3 entonces

8. precioT = 25000 * 0.85

9. sino

10. precioT = 25000 * 0.95

11. fin si

12. si cantL >= 3 entonces

13. precioL = 30000 * 0.85

14. sino

15. precioL = 30000 * 0.95

16. fin si

17. si cantN >= 3 entonces

18. precioN = 75000 * 0.85

19. sino

20. precioN = 75000 * 0.95

21. fin si

22. totalT = cantT * precioT

23. totalL = cantL * precioL

24. totalN = cantN * precioN

25. total = totalT + totalL + totalN

26. mostrar “Monto a pagar”

27. mostrar “Televisores: ” totalT

28. mostrar “Lavadoras: ” totalL

29. mostrar “Neveras: ” totalN

30. mostrar “Monto total: ” total

31.fin tienda





8. Una aseguradora de vehículos tiene los siguientes porcentajes de prima dependiendo de los años de antigüedad del vehículo. Vehículos de 1 año pagan el 5% de su valor, de dos años el 8%, de tres años el 10%, de cuatro años el 12% y de cinco años o más pagan el 15%. Elabore un programa que solicite el valor del vehículo, los años de antigüedad y muestre por pantalla el valor de la prima.

1. algoritmo seguros

2. var valor, anios: entero

3. porc, prima: real

4. inicio

5. mostrar “Ingrese el valor del vehículo y los años de antiguedad: ”

6. leer valor, anios

7. segun sea anios

8. 1: porc = 5

9. 2: porc = 8

10. 3: porc = 10

11. 4: porc = 12

12. otro: porc = 15

13. fin segun

14. prima = porc * valor

15. mostrar “El monto de la prima es: ”

16.fin seguros

9. A un trabajador le pagan según sus horas y una tarifa de pago por horas. Si la cantidad de horas trabajadas es mayor a 40 horas, entonces la tarifa se incrementa en un 50% para las horas extras. Calcular el salario del trabajador dadas las horas trabajadas y la tarifa.

1. algoritmo salario

2. var horas_trabajadas: entero

3. tarifa,horas_extras,salario,tarifa_extra: real 4. inicio

5. mostrar “Ingrese las horas trabajadas y la tarifa normal: ”

6. leer horas_trabajadas,tarifa

7. si horas_trabajadas <= 40 entonces 8. salario = horas_trabajadas * tarifa

9. sino 10. tarifa_extra = tarifa + 0.50 * tarifa

11. horas_extras = horas_trabajadas - 40

12. salario = horas_extras * tarifa_extra + 40 * tarifa

13. fin si





14. mostrar “El salario es: ” salario

15.fin salario

10. A un trabajador le descuentan de su sueldo el 10% si su sueldo es menor o igual a 1000, por encima de 1000 y hasta 2000 el 5% del adicional y por encima de 2000 el 3% del adicional. Calcular el descuento y sueldo neto que recibe el trabajador dado su sueldo.

1. algoritmo descuento

2. var sueldo,sueldo_neto,descuento: real 3. inicio

4. mostrar “Ingrese el sueldo: ”

5. leer sueldo 6. si sueldo <= 1000 entonces

7. descuento = sueldo * 0.1

8. sino 9. si sueldo <= 2000 entonces

10. descuento = (sueldo - 1000) * 0.05 + 1000 * 0.1

11. sino

12. descuento = (sueldo - 2000) * 0.03 + 1000 * 0.1

13. fin si

14. fin si 15. mostrar “Descuento: ” descuento

16. Fin descuento

11. Dado un monto calcular el descuento considerando que por encima de 100 el descuento es el 10% y por debajo de 100 el descuento es el 2%.

1. algoritmo descuento100

2. var monto,descuento: real 3. inicio

4. mostrar “Ingrese el monto: ”

5. leer monto

6. si monto > 100 entonces 7. descuento = monto * 10 / 100

8. sino 9. descuento = monto * 2 / 100

10. fin si

11. mostrar “Monto: ” monto

12. mostrar “Descuento: ” descuento

13.fin descuento100





Ejercicios por Resolver 1. Escribir un programa que pida un número e indique si se trata de un número par.

2. Escribir un programa que pida una nota e imprima por pantalla la calificación en formato “Apto” o “No Apto” según si la nota es mayor o menor que 10.

3. Escribir un programa que lea tres valores enteros y muestre por pantalla el máximo y el mínimo de ellos.

4. Escribir un programa que pida un número entero y determine si es múltiplo de 2 y de 5.

5. Escribir un programa que pida la nota de un examen (un número real entre 0 y 20) e imprima por pantalla la calificación en formato “Suspendido”, si la nota es menor que 10, “Aprobado” si está entre 10 inclusive y 15 sin incluir, “Notable” si está entre 15 inclusive y 18 sin incluir, “Sobresaliente” si está entre 18 inclusive y 20 sin incluir y “Matrícula de honor” si la nota es igual a 20.

6. Escribir un programa que, dado el número del mes y la información de si el año es bisiesto, imprima por pantalla el número de días del mes.

7. Escribir un programa que, pida la fecha de nacimiento de una persona e imprima por pantalla su signo zodiacal.

8. Elabore un programa que permita emitir la factura correspondiente a una compra de un artículo determinado, del que se adquieren una o varias unidades. El IVA es del 14% y si el monto bruto (precio venta mas IVA) es mayor que 50.000 se debe realizar un descuento del 5% sobre el monto total.

9. Dados sus tres lados (a,b,c), determinar si un triangulo es : Equilátero, isósceles o escaleno.

Fundamentos de Programación Complementos II

Unidad 1: Funciones y Procedimientos Volumen 1: Conceptos de Programación 161



Unidad 6: Estructuras de Repetición (Pseudocódigo)

Ejercicios Resueltos 1. Calcular mediante un algoritmo repetitivo la suma de los N primeros números naturales.

1. algoritmo naturales

2. var N, i, suma: entero

3. inicio 4. mostrar “¿Cuantos números naturales desea sumar? ”

5. Leer N

6. i = 1

7. suma = 0

8. mientras i <= N hacer 9. suma = suma + i

10. i = i + 1

11. fin mientras

12. mostrar “La suma es: ” suma

13. fin naturales

2. Solicite 10 números enteros al usuario e imprima su promedio. 1. algoritmo promedio

2. var suma = 0, promedio, I, numero: entero

3. inicio

4. I = 1

5. mientras I <= 10 hacer


7. Leer numero

8. suma = suma + numero

9. I = I +1

10. fin mientras

11. promedio = suma /10

12. mostrar “El promedio es: ” promedio

13.fin promedio


Volumen 1: Conceptos de Programación Unidad 1: Funciones y Procedimientos 162



3. Dada las horas trabajadas de n personas y la tarifa general de pago por hora, calcule el salario de todos los trabajadores y muéstrelo por pantalla. Muestre además la suma de todos los salarios.

1. algoritmo nomina

2. var N, I, suma, tarifa, horas, sueldo: entero

3. inicio 4. mostrar “¿Cuantos trabajadores desea introducir?”

5. leer: N 6. mostrar “¿Cual es la tarifa general? ”

7. leer tarifa

8. I = 1

9. suma = 0

10. mientras I <= N hacer 11. mostrar “Ingrese las horas trabajadas: ”

12. Leer horas

13. sueldo = horas * tarifa

14. mostrar “El sueldo es: ” sueldo

15. suma = suma + sueldo

16. I = I + 1

17. fin mientras 18. mostrar “El monto total de la nómina es: ” suma

19.fin nomina

4. Dado N notas de un estudiante calcular:

a) Cuántas notas tiene desaprobadas. b) Cuántos aprobadas. c) El promedio de notas. d) El promedio de notas aprobadas y desaprobadas.

1. algoritmo notas

2. var n, i=1, nota, naprob = 0, ndes = 0, acum_aprob = 0, acum_des = 0: entero 3. promaprob, promdes, promtotal: real

4. inicio

5. mostrar “Cuantas notas desea introducir?”

6. leer n

7. mientras I <= n hacer

8. mostrar “Ingrese nota: ”

Complementos II Fundamentos de Programación




9. leer nota

10. si nota >= 10 entonces

11. naprob = naprob + 1

12. acum_aprob = acum_aprob + nota

13. sino

14. ndes = ndes + 1

15. acum_des = acum_des + nota

16. fin si

17. I = I + 1

18. fin mientras

19. promaprob = acum_aprob / naprob

20. promdes = acum_des / ndes

21. promtotal = (acum_aprob + acum_des) / n

22. mostrar “Notas aprobadas: ” acum_aprob

23. mostrar “Notas desaprobadas: ” acum_des

24. mostrar “Promedio total: ” promtotal

25. mostrar “Promedio aprobadas: ” promaprob

26. mostrar “Promedio desaprobadas: ” promdes

27. fin notas

5. Dado un número entero determinar la suma de sus dígitos. 1. algoritmo digitos

2. var n, suma, residuo: entero

3. inicio


5. Leer n

6. suma = 0

7. mientras n <> 0 hacer 8. residuo = n mod 10

9. suma = suma + residuo

10. n = n div 10

11. fin mientras

12. mostrar “La suma es: ” suma 13.fin digitos

6. Realizar un algoritmo que solicite 20 números enteros al usuario y muestre cuántos de ellos son pares, impares, positivos y negativos.





1. algoritmo naturales

2. var pares = 0, impares = 0, positivos = 0, negativos = 0, I, numero: entero

3. inicio

4. desde I = 1 hasta 100 5. mostrar “Ingrese un numero entero: ”

6. leer numero

7. si numero mod 2 == 0 entonces

8. pares = pares + 1

9. sino 10. impares = impares + 1

11. fin si

12. si numero > 0 entonces

13. positivos = positivos + 1

14. sino

15. negativos = negativos + 1

16. fin si

17. fin desde 18. mostrar “Pares: ” pares

19. mostrar “Impares : ” impares

20. mostrar “Positivos: ” positivos

21. mostrar “Negativos: ” negativos

22.fin naturales

7. Desarrollar un algoritmo para calcular e imprimir el factorial de un número. 1. algoritmo factorial

2. var fact, num, I: entero

3. inicio

4. mostrar “Ingrese un número entero positivo: ”

5. fact = 1

6. desde I = 1 hasta num 7. fact = fact * I

8. fin desde 9. mostrar “El factorial de ” num “ es: ” fact

10.fin factorial

8. Calcular y visualizar la suma y el producto de los números pares comprendidos entre 20 y 400, ambos inclusive.





1. algoritmo sumayprod

2. var suma, producto, I: entero

3. inicio

4. suma = 0

5. producto = 1

6. I = 20

7. mientras I <= 400 hacer 8. suma = suma + I

9. producto = producto * I

10. I = I + 2

11. fin mientras 12. mostrar “Suma: ” suma

13. mostrar “Producto: ” producto

14.fin sumayprod





Ejercicios Propuestos 1) Hacer un programa que al ingresar un número de Amstrong escriba si es o no un

número de Amstrong, si no es, indique que vuelva a intentar. 2) Construya un algoritmo que reciba como entrada dos valores: a y b, donde a < b.

Este algoritmo debe generar como salida los múltiplos de a, que son menores que b.

3) Construya un algoritmo que reciba como entrada varios montos de depósito y despliegue la suma de ellos. Considere que un valor negativo, significa que no hay más datos y no debe ser considerado como dato válido.

4) Construya un algoritmo que reciba como entrada una secuencia de valores numéricos y genere como salida la suma de los valores pares y la multiplicación de los impares. Considere que un valor negativo significa que no hay más datos y no debe ser considerado como dato válido.

5) Construya un algoritmo que reciba como entrada una secuencia de valores de temperaturas y genere como salida el total de veces que la temperatura fue 0±. Considere que un valor de temperatura negativo significa que no hay más datos y no debe ser considerado como válido.

6) Construya un algoritmo que reciba como entrada una secuencia de valores de temperaturas y genere como salida el total de veces que se registró una temperatura menor que 0±, el total de veces que fue 0± y el total de veces que fue mayor que 0±. Considere que una temperatura con valor 99± ó (°99)± es una temperatura no válida e indica el término de los datos.

7) Construya un algoritmo que genere como salida los términos de la siguiente serie: 2; 5; 7; 10; 12; 15; 17; : : : ; 1800

8) Los n superamigos del “Salón de la Justicia" lograron obtener un aumento de sueldo en el último mes. Este aumento de sueldo se determinó por niveles, de acuerdo a la siguiente tabla:

nivel sueldo %aumento

A 0 - 1000000 8

B 1000001 – 3000000

6

C 3000001 – 6000000

4

D > 6000000 2

9) Construya un algoritmo que reciba como entrada el sueldo actual de cada uno de los trabajadores y calcule el nuevo sueldo. Además, el algoritmo deberá indicar cuánto más gasta la empresa por concepto de sueldos, después del aumento.

10) Se dispone de una tabla con las temperaturas registradas a medio día durante el año 2003. Se desea determinar cuál fue la máxima, cuál fue la mínima y cuántas veces se repitió cada una de estas durante el año 2003. Además, se desea saber el promedio de dichas temperaturas.





11) Construya un algoritmo que reciba como entrada un valor n y calcule una aproximación del valor de e, como la suma de la siguiente serie:

!1...

!51

!41

!31

!21

!111

n+++++++





Volumen 3: Complementos II






Ejercicios Resueltos 1) Escribir un programa que determine la mayor de tres cantidades enteras, utilizando

una función que determine la mayor de dos cantidades enteras.

1. funcion maximo ( x:entero, y:entero): entero 2. var max: entero 3. inicio 4. si (x > y) entonces max = x 5. sino max = y 6. retorno max 7. fin maximo algoritmo calcular_max_tres_enteros var a,b,c,d: entero inicio

mostrar “introduzca tres valores enteros” Leer a,b,c d = maximo(a,b) d = maximo(c,d) mostrar “El maximo es:”, d

fin

2) Escribir una función que calcule el valor de xn siendo x real y n un valor entero

1. funcion potencia(n: entero, x: real): real 2. var y: real 3. i: entero 4. inicio 5. si x = 0 6. entonces y = 0 7. retornar y 8. sino 9. y = 1 10. desde i = 1 hasta i = abs(n) hacer 11. y = y*x 12. fin desde 13. si n > 0 14. entonces retornar y 15. sino retornar y = 1 / y 16. fin si 17. fin si 18. fin funcion





3) Escribir funciones para convertir pies a pulgadas, pulgadas a centímetros y centímetros a metros.

Escribir un algoritmo que le pida al usuario una medida en píe, lo convierta y lo muestre en metros.

Se sabe que: 1 píe = 12 pulgadas 1 pulgadas = 2.54 cm 100 cm = 1 metro.

1. funcion pies_a_pulgadas(pies: real): real 2. var pulg: real 3. inicio 4. pulg= 12 * pies 5. retornar pulg 6. fin funcion

7. funcion pulg_a_centimetro(pulg: real): real 8. var cm: real 9. inicio 10. cm = 2.54 * pulg 11. retornar cm 12. fin funcion 13. funcion cm_a_metro(cm: real): real 14. var metro:real 15. inicio 16. metro = cm / 100.0 17. retornar metro 18. fin funcion 19. algoritmo conversion 20. var pies, pulgadas, cms, metros: real 21. inicio 22. mostrar “introduzca la medida en pie” 23. leer pies 24. pulgadas = pies_a_pulgadas(pies) 25. cms = pulg_a_centimetro(pulgadas) 26. metros = cm_a_metro(cms) 27. mostrar pies, “pies es igual a”, pulgadas, “pulgadas” 28. mostrar pies, “pies es igual a”, cms, “centimetros” 29. mostrar pies, “pies es igual a”, metros, “metros”

30.fin





4) Diseñar una función que dado como parámetro de entrada un número entero retorne su factorial.

La función factorial se define como n!

n! =1 si n = 0

n! = n x (n-1) x (n-2) x...x 3x 2 x 1 si n > 1

Resuelva el problema usando:

a) Una función recursiva. b) Una función iterativa.

c) Función factorial implementación recursiva:

función factorial (n:entero): entero { calculo recursivo del factorial de n } inicio

si (n = 0) entonces retornar (1) sino retornar (n * factorial(n-1)) fin si

fin factorial

d) Función factorial implementación iterativa:

función factorial_iterativa (n:entero): entero { calculo iterativo del factorial de n } var f, i:entero inicio

f = 1 si (n = 0) entonces retornar (f) sino

desde i = 1 hasta n hacer f = f * i fin desde retornar (f)

fin si

fin factorial_iterativo





5) Escribir un procedimiento que tenga como entrada la longitud de una cadena de caracteres, escriba la cadena en orden inverso.

Ejemplo: Venezuela se obtiene aleuzeneV

El programa debe usar la recursividad para la escritura inversa.

procedimiento invertir_recursivo (n:entero) var car: char inicio

si (n <= 1) entonces

leer car escribir car

sino leer car invertir_recursivo(n-1) escribir car

fin si

fin invertir_recursivo





Ejercicios Propuestos

1) Escribir una función salario que calcule el salario de un trabajador. Esta función recibe como parámetros el número de horas trabajadas y el salario por hora.

Las horas extras serán calculadas con un salario/hora 1,5 veces mayor al salario/ hora establecida. Se consideran horas extras las trabajadas por encima de las 40 horas.

Presente el algoritmo para calcular y mostrar el salario de 50 empleados usando la función salario.

2) Escribir una función que convierta una temperatura dada en grados Celsius a grados Fahrenheit.

La fórmula de conversión es:

F = (9/5) * C + 32

3) Escribir funciones para:

a) Calcular el área, dada la base y altura del triángulo:

Area_triangulo = (base x altura ) / 2

b) Calcular el perímetro de un triángulo dados sus lados:

Perímetro_triangulo = suma de los tres lados

Presentar el algoritmo que invoca a las funciones y muestra los resultados.

4) Escribir funciones para:

a) Calcular el área de un círculo dado su radio:

Area_circulo = (3 / 4) * 3.1416 * radio * radio

b) Calcular el área de un cuadrado dada la longitud de uno de sus lados:

Area_cuadrado = lado x lado

c) Calcular el área de un rectángulo dada la longitud de dos de sus lados:

Area_rectangulo = lado1 x lado2

d) Calcular el área dada la base y altura del triángulo:

Area_triangulo = (base x altura) / 2:.

El algoritmo debe mostrar un menú que permita seleccionar la figura geométrica a la cual se desea calcular el área y una opción para salir del programa.





5) Escribir un algoritmo que permita ingresar dos números enteros y calcule las 4 operaciones básicas suma, resta, multiplicación y división, además de calcular la potencia. Cada una de las operaciones deben implementarse como una función. El algoritmo debe mostrar los números y los resultados.

6) Escriba un algoritmo que lea dos números x y n, y calcule la suma de la progresión geométrica:

1 + x + x2 + x3 + ... + xn

Use funciones para devolver la suma y calcular el valor de xn.

7) Escribir un procedimiento que ordene tres números mediante un procedimiento de intercambio de dos variables, usando el pase de parámetros por referencia.

8) Diseñar un algoritmo que lea las longitudes de los tres lados de un triángulo (L1,L2,L3) y determine el tipo de triángulo al que corresponde.

Suponga que A detona el mayor de los tres lados y B y C corresponden a los otros dos lados, entonces:

Si A >= B + C No se trata de un triángulo Si A = B + C Es un triángulo rectángulo Si A > B + C Es un triángulo obtusángulo Si A < B + C Es un triángulo acutángulo

Desarrolle funciones para cada tipo de triángulo, que tomen como parámetros de entrada los lados del triángulo y devuelvan un valor booleano si el triángulo pertenece o no a ese tipo.

9) Considerar el siguiente procedimiento llamado Intercambio, que tiene los parámetros X y Y. Se supone que T es una variable local. PROCEDIMIENTO Intercambio(X,Y:entero) inicio

Var T:entero T = X X = Y Y = T

fin

El procedimiento debe usarse en los siguientes enunciados: I = 1 A = 2 B = 0 Intercambio (I, A)

Escribir I,A,B

¿Cuáles son los resultados del algoritmo?, explique con detalle lo que sucede en cada caso:





a) La correspondencia entre parámetros formales y actuales se establece por paso por valor.

b) La correspondencia entre parámetros formales y actuales se establece por paso por referencia.

10) ¿Cuál es la salida del siguiente algoritmo?

procedimiento listar ( n:entero) inicio

si (n = 1) entonces

escribir “listo” sino

escribir “vuelta” listar(n-1)

fin si fin listar

Algoritmo demo inicio listar(4) fin

11) Escribir un procedimiento recursivo que tome como entrada un número entero y escriba el número invertido.

Dado el número 12345 su inverso es 54321


a) Un procedimiento recursivo. b) Un procedimiento iterativo.

12) Escribir un algoritmo que llame a una función recursiva para encontrar la suma de los enteros pares hasta N.

Suma_Pares = 2 + 4 + 6 +...+ (N-2) + N

13) Escribir una función recursiva que permita multiplicar dos enteros m y n por medio de sumas sucesivas.

14) Escribir una función recursiva que calcule la potencia de entero:

Xn donde x:real

n:entero





15) Escribir una función que dado el entero positivo x devuelva verdadero si y sólo si x es una potencia de 2.



16) Los números de Fibonnacci son una secuencia de números, donde cada término de la secuencia se define como:

F (1)= F (2)=1 para n=1 y n=2 F (n)= F (n-1) + F (n-2) para n > 2 Por tanto,

F(3) = F(1) + F(2) = 1 + 1 = 2 F(4) = F(3) + F(2) = 2 + 1 = 3 F(5) = F(4) + F(3) = 3 + 2 = 5

Escribir una función que tome como entrada un entero positivo que indique la posición del término en la serie y retorne el valor del término en esa posición.




Libro 1: Fundamentos de Programación Unidad 5: Estructuras de Datos - Arreglos 179



Unidad 5: Estructuras de Datos - Arreglos

Ejercicios Resueltos 1) Diseñar un algoritmo que lea las notas de una clase de “Introducción a la

Programación” en un vector, calcule el promedio de notas e imprima las notas mayores al promedio.

1. Algoritmo Calificaciones 2. var 3. MAX = 100 {número máximo de estudiantes} 4. notas: arreglo[1..MAX] de real 5. numero, i:entero 6. suma, promedio:real 7. inicio 8. escribir “Introducir numero de calificaciones” 9. leer numero 10. si numero > MAX 11. entonces “no se puede procesar mas de” MAX “notas” 12. sino 13. suma = 0 14. escribir “Introducir las calificaciones” 15. desde i = 1 hasta numero 16. leer notas[i] 17. suma = suma + notas[i] 18. fin desde 19. promedio = suma / numero 20. escribir “el promedio de las notas es:” promedio 21. escribir “las notas mayores que el promedio son:” 22. desde i = 1 hasta numero 23. si notas[i] > promedio 24. entonces escribir notas[i] 25. fin si 26. fin desde 27. fin si

28. fin Calificaciones


Unidad 5: Estructuras de Datos - Arreglos Libro 1: Fundamentos de Programación 180



2) Diseñar un algoritmo que dados dos vectores ordenados A y B, de tamaño M y N respectivamente, produzca un tercer vector C ordenado, de tamaño M+N y formado a partir de los elementos de los vectores A Y B.

Ejemplo:

Vector A: 2 5 7 100 250

Vector B: -4 0 10 98 120 300 310 540

Vector C: -4 0 2 5 7 10 98 100 120 250 300 310 540

El algoritmo es el siguiente:

a) Seleccionar el elemento de valor más pequeño en los vectores A y B, ubíquelo en el nuevo vector C.

b) Para ello, se compara a[i] y b[j] y se coloca el elemento más pequeño en c[k], donde i, j , k, son los índices correspondientes en cada uno de los vectores.

c) Se sigue la secuencia de comparaciones hasta que los elementos de uno de los vectores A ó B se hayan agotado y entonces se copia el resto del otro vector en el vector C.

1. Algoritmo Mezcla implementado como un procedimiento: 2. Procedimiento Mezcla (A,B,C:arreglos de enteros, M,N:enteros) 3. {A y B: entrada: Vectores ordenados} 4. {M y N: número de elementos de A y B respectivamente} 5. {C:salida. Vector resultado de la mezcla de A Y B} 6. {El vector C tiene una longitud mínima de M + N} 7. var 8. i, j, k, p:entero

9. inicio 10. i = 1 11. j = 1 12. k = 1 13. mientras (i <= M) && (j <= N) hacer 14. si A[i] <= B[j] 15. entonces 16. C[k] = A[i] 17. i = i + 1 18. sino 19. C[k] = B[j] 20. j = j + 1 21. fin si 22. k = k + 1 23. fin mientras





24. { copiar el resto del vector no agotado}

25. si i > M {agotado el vector A copiar B} 26. entonces 27. desde p = j hasta N 28. C[k] = B[p] 29. k = k + 1 30. fin desde 31. sino {j > M agotado el vector B copiar A } 32. desde p = i hasta M 33. C[k] = A[p] 34. k = k + 1 35. fin desde 36. fin si 37. fin procedimiento mezclar

3) Diseñar un algoritmo para sumar el número de elementos positivos y negativos de una tabla o arreglo.

La matriz es de dimensión MxN y se lee desde el teclado.

1. Algoritmo Suma 2. var 3. M = 10: entero 4. N = 8: entero 5. tabla: arreglo[M,N] de entero 6. SP, SN, i, j:entero

7. inicio 8. { leer elementos de la tabla} 9. escribir “Introducir elementos de la tabla” 10. SP = 0 11. SN = 0 12. desde i = 1 hasta M 13. desde j = 1 hasta N 14. escribir “Introducir elemento (“ i “,” j “)” 15. leer tabla(i,j) 16. si tabla(i,j) > 0 17. entonces SP = SP + tabla(i,j) 18. sino SN = SN + tabla(i,j) 19. fin si 20. fin desde 21. fin desde 22. escribir “la suma de elementos positivos es:” SP 23. escribir “la suma de elementos negativos es:” SN 24. fin





4) Diseñar un algoritmo donde se declare una matriz M de enteros de dimensión 100 x

200, asignándose los siguientes valores: 1 0 1 0 1 0 1 0 …

0 1 0 1 0 1 0 1 …

1 0 1 0 1 0 1 0 …

0 1 0 1 0 1 0 1 …

etc.

1. Algoritmo Inicializar_Matriz

2. var 3. M[100, 200] arreglo de enteros 4. I,j:entero

5. inicio 6. desde i=1 hasta 100 incremento 1 7. si (i mod 2 == 0) {Filas pares comienzan en 0} 8. entonces 9. desde j=1 hasta j = 200 incremento 2 10. M[i,j] = 0 11. M[i,j+1] = 1 12. fin desde 13. sino {Filas impares comienzan en 1} 14. desde j=1 hasta j = 200 incremento 2 15. M[i,j] = 1 16. M[i,j+1] = 0 17. fin desde 18. fin si 19. fin

20. j = 0 21. repetir 22. j = j + 1 23. si f[i,j] = 1 24. entonces 25. escribir “Existe un enlace con la ciudad” j 26. fin si 27. hasta ( j = n) 28.fin





Ejercicios Propuestos 1) Elaborar un algoritmo que llame a las siguientes funciones:

1.1 La función SIGMA que calcula la suma de los n elementos de un vector X donde X y n son los parámetros de la función.

1.2 La función PROD para calcular el producto de los n elementos de un vector X donde X y n son los parámetros de la función.

2) Diseñar un algoritmo que lea en un arreglo N números reales, determine el máximo,

mínimo y el promedio. Para calcular estos valores debe hacer uso de funciones que retornan ese valor.

Las funciones a definirse son:

a) Max_vector: Retorna el valor máximo de un arreglo.

b) Min_vector: Retorna el valor mínimo de un arreglo.

c) Med_vector: Retorna el promedio de un arreglo de reales.

Todas las funciones reciben el vector como parámetro de entrada.

3) Diseñar una función que devuelva VERDAD si dos arreglos dados como entrada son iguales y FALSO en caso contrario.

4) Se necesita una función para determinar si un valor dado existe en el vector. Asuma que los valores en el vector no están ordenados.

La función debe aceptar dos parámetros:

• El nombre de un vector. • El valor que debe buscarse en ese vector.

La función debe regresar:

• 1 si el valor se encuentra en el vector. • 0 si la búsqueda es infructuosa.

Ni el vector ni el valor deben ser alterados. ¿Qué tipo de parámetros es preferible? ¿Por qué?.

5) Modifique la función anterior asumiendo que el vector está ordenado en forma creciente.

6) Dado un vector A de n números reales, obtener la diferencia más grande entre dos elementos consecutivos de ese vector.

7) Dado un vector A de n números reales, obtener la diferencia más grande y la menor diferencia entre dos elementos consecutivos de ese vector.





8) En todo experimento existe cierta cantidad de incertidumbre asociada con cualquier medición. Una técnica conocida como ajuste de curvas puede utilizarse para reducir el error en el análisis de los resultados.

Se supone que una serie de valores reales, ha sido registrada de N repeticiones de un experimento en particular, los cuales se almacenan en un vector llamado V. Antes de proceder al análisis de estos resultados experimentales, la siguiente operación de ajuste simple debe aplicarse a los valores de V:

• Para cada valor, excepto el primero y el último, que deben permanecer sin cambios, Vi debe reemplazarse por: Vi = (Vi-1 + Vi + Vi+1) / 3

Diseñar un algoritmo para leer las mediciones iniciales e imprimir los valores observados y los ‘ajustados’.

Los valores ajustados deberán ser almacenados en otro vector.

9) Diseñar un algoritmo que dados dos vectores ordenados A y B de tamaño M y N respectivamente, produzca un tercer vector C ordenado de tamaño M+N, formado a partir de los elementos de los vectores A Y B y que no incluya los elementos repetidos en el vector de salida.

10) La moda de un arreglo de vocales, es la vocal que se repite más frecuentemente. Si varias vocales se repiten con la misma frecuencia máxima, entonces no hay moda. Escribir una función que acepte un vector de caracteres y devuelva su moda o una indicación de que la moda no existe.

11) Diseñar un procedimiento que acepte como parámetro un vector que pueda contener elementos repetidos. El procedimiento debe reemplazar cada elemento repetido por -1 y regresar al punto de llamada el vector modificado, además del número de modificaciones realizadas.

12) Diseñar un algoritmo que lea un vector desordenado A, compuesto de n enteros e imprima el vector en la misma secuencia, pero ignorando los valores duplicados que se encuentren en él.

También se necesita saber el número de elementos m que permanecen en él.

Por ejemplo, dado el vector siguiente:

18 32 23 18 75 23 45 18 32 90

compuesto de 10 enteros, el vector comprimido que resulta estará formado por

18 32 23 75 45 90

con m = 6.

13) Dadas las siguientes declaraciones de variables:

a: arreglo[0..9] DE ENTEROS

x, i, k: ENTERO





Donde el vector a se inicializa con los valores: 6, 3, 9, 7, 1, 8, 10, 2, 4 y 5, determinar el valor de x cuando se ejecutan los siguientes segmentos de código y comentar qué operación se realizan:

a) x = 0 PARA i = 0 HASTA 9 CON INCREMENTO DE 1

x = x + a(i) FIN_PARA

b) x = a(0)

PARA i = 1 HASTA 9 CON INCREMENTO DE 1 SI x < a(i)

ENTONCES x = a(i) FIN_SI

FIN_PARA

c) k = 0 PARA i = 1 HASTA 9 CON INCREMENTO DE 1

SI a(k) < a(i) ENTONCES k = i

FIN_SI

FIN_PARA

14) Diseñar un algoritmo que lea la matriz:

1. 6 8 9 2

2. 5 1 0 8

3. 1 2 6 9

Cree y escriba una nueva matriz de la forma:

3 4 5

4. 5 1

8 1 2

9 0 6

2 8 9

Esto corresponde a la matriz traspuesta de la matriz original.

15) Realizar un procedimiento que acepte como parámetro un vector de elementos enteros y el tamaño del vector. El procedimiento debe ordenar los elementos y regresar el vector ordenado por medio del mismo parámetro. ¿Qué tipo de paso de parámetros se requiere? ¿Por qué?.

Utilice el algoritmo de ordenación por selección, que consiste en buscar el elemento menor y colocarlo en la primera posición. Luego buscar el segundo elemento más pequeño y colocarlo en la segunda posición, y así sucesivamente.





Los pasos del algoritmo son:

1. Seleccionar el elemento menor del vector de n elementos. 2. Intercambiar dicho elemento con el primero. 3. Repetir esta operación con los n-1 restantes, seleccionando el segundo elemento. 4. Continuar con los n-2 restantes, y así sucesivamente, hasta que sólo quede el mayor.

16) Diseñar un algoritmo que dada una matriz cuadrada determine la suma de todos los elementos que están en la diagonal. Los elementos de la diagonal son los A[i, j] de la matriz A que cumplen con i=j.

17) Diseñar un algoritmo que dada una matriz cuadrada determine la suma de todos los elementos que no pertenecen a la diagonal principal.

18) Una agencia de ventas automóviles distribuye 12 modelos diferentes y tiene 8 vendedores.

Diseñar un algoritmo que produzca un informe mensual de:

a) Las ventas por vendedor. b) Las ventas por modelo. c) El número de automóviles vendidos por todos los vendedores. d) El número total de cada modelo vendido por todos los vendedores. e) El vendedor que más vehículos ha vendido para la entrega del premio al mejor

vendedor.

Asuma que los datos están representados en una matriz, donde las filas representan a los vendedores y las columnas a los modelos de vehículos.

19) Diseñar diferentes procedimientos que tomen dos matrices cuadradas de dimensión N y realicen:

a) La suma de dos matrices. b) La resta de dos matrices. c) El producto de dos matrices.

20) Un analista de imágenes posee una imagen digitalizada representada en una matriz bidimensional de enteros, con valores de colores entre 0 y 20, se desea convertirla a una imagen en blanco y negro y visualizarla por pantalla.

Se debe considerar para convertir lo siguiente:

• Cada elemento (i,j) de la matriz representa un punto de la imagen. • Al elemento se le asigna el valor negro (20) si la suma del contenido del

elemento (i,j) más el contenido de los elementos inmediatos a la derecha, a la izquierda, arriba y abajo de éste, al dividirla (la suma) entre 5 es mayor que 10, de lo contrario se le asigna 0.

Suma = (elem(i,j) + elem(i+1,j) + elem( i -1,,j) + elem(i,j+1) + elem(i,j-1) ) / 5





Considere las condiciones de borde, es decir, cuando la posición del elemento está en los límites de la matriz.

Diseñar un procedimiento que tome la imagen digitalizada inicial y devuelva la imagen en blanco y negro.

21) Diseñar un algoritmo dada una matriz de enteros (n x n), donde cada elemento (i,,j) de la matriz representa la distancia entre las ciudades i, j. Si el contenido es –1, indica que no existe camino entre esas dos ciudades. El algoritmo debe devolver los pares de ciudades entre los que la distancia es menor que una distancia dada como entrada.

Fundamentos de Programación Ejercicios Propuestos




Volumen 4: Ejercicios Propuestos





Unidad 1: Programas de Computadora 1) Evalúe las siguientes expresiones:

A = (3*2^5 mod 1 + 8*(3-5) < (2+8-1 mod 1) A = A o (3+5*8) < 3 y ((-6/3 div 4)*2 < 2) B = 3 mod 2 div 3 C = (-B*2 <> 8*3 mod 4) y (‘A’>’B’) A = C o no (3=5) y (8 <> 3+B)





Respuestas de la Unidad 1: Ejercicios Propuestos 1) A = (3*2^5 mod 1 + 8*(3-5) < (2+8-1 mod 1)

A = (3*32 mod 1 + (-16)) < 10 A = -16 < 10 A = Verdadero

2) A = A o (3+5*8) < 3 y ((-6/3 div 4)*2 < 2)

A = Verdadero o 43 < 3 y (0*2 < 2) A = Verdadero o Falso y Verdadero A = Verdadero o Falso A = Verdadero

3) B = 3 mod 2 div 3

B = 1 div 3 B = 0

4) C = (-B*2 <> 8*3 mod 4) y (‘A’>’B’) C = (0 <> 24 mod 4) y Falso C = Falso y Falso C = Falso

5) A = C o no (3=5) y (8 <> 3+B)

A = Falso o Verdadero y Verdadero A = Falso o Verdadero A = Verdadero





Unidad 2: Conceptos de Diseño Estructurado

1) Desarrollar un algoritmo que calcule el volumen de un paralelepípedo.

2) Desarrollar un algoritmo que dado un valor entero, que representa un monto en Bolívares, indique el número de billetes de 5000, 1000 y monedas de 100, 50, 10, 1, que equivalen al monto dado.

3) Desarrollar un algoritmo que dada la temperatura en grados Celsius, escriba en

pantalla la temperatura equivalente en grados Fahrenheit. La fórmula es: °F = (9 * °C / 5)+32.





Respuestas de la Unidad 2: Ejercicios Propuestos 1) Desarrollar un algoritmo que calcule el volumen de un paralelepípedo.

Algoritmo para Calcular al Volumen de un Paralelepípedo Var altura, ancho, profundidad, volumen : real Inicio Escribir “Introducir Altura” Leer altura Escribir “Introducir Ancho” Leer ancho Escribir “Introducir Profundidad” Leer profundidad volumen = altura * profundidad * ancho Escribir “El volumen es: ” volumen Fin

2) Desarrollar un algoritmo que dado un valor entero, que representa un monto en

Bolívares, indique el número de billetes de 5000, 1000 y monedas de 100, 50, 10, 1, que equivalen al monto dado.

Algoritmo Calcular cambio Var bolivares: real Inicio Escribir “Introduce los bolívares” Leer bolivares Escribir bolivares div 5000 “billetes de 5000” bolivares = bolivares mod 5000 Escribir bolivares div 1000 “billetes de 1000” bolivares = bolivares mod 1000 Escribir bolivares div 100 “monedas de 100” bolivares = bolivares mod 100 Escribir bolivares div 50 “monedas de 50” bolivares = bolivares mod 50 Escribir bolivares div 10 “monedas de 10” bolivares = bolivares mod 10 Escribir bolivares Fin





3) Desarrollar un algoritmo que dada la temperatura en grados Celsius, escriba en pantalla la temperatura en grados Fahrenheit, el equivalente es: F = (9C/5)+32.

La fórmula es: °F = (9 * °C / 5)+32

Algoritmo para Calcular dada la temperatura en °C el equivalente en °F Var fahrenheit, celsius: real Inicio Escribir “Introducir los grados Celsius:” Leer celsius fahrenheit = (9*celsius/5)+32 Escribir “La temperatura es: “ Fahrenheit Fin


Unidad 3: Programación Estructurada. Libro 1: Fundamentos de Programación 197



Unidad 3: Programación Estructurada. 1) Desarrollar un algoritmo que determine los números primos comprendidos entre 1 y

1000.

2) Desarrollar un algoritmo para determinar el máximo valor entre un conjunto de números positivos, ingresados a través del teclado. Un número negativo indica que no existen más números.

3) Desarrollar un algoritmo para determinar cuáles son los múltiplos de 5 comprendidos entre 1 y N.

4) Desarrollar un algoritmo que al final de curso, que determine cuál es el alumno con el promedio de notas más alto del semestre. Se sabe que en el semestre están inscritos 150 alumnos y cursan 5 asignaturas.

5) Calcular la suma de los divisores de cada número ingresado a través del teclado. Se termina el proceso cuando se ingresa un número negativo ó 0.

6) Se coloca un capital C, a un interés I, durante M años y se desea saber en cuánto se habrá convertido ese capital en m años, sabiendo que es acumulativo.


Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada. 198



Respuesta Unidad 3: Ejercicios Propuestos 1) Desarrollar un algoritmo que determine los números primos comprendidos entre 1 y

1000.

Algoritmo para Determinar los números primos entre 1 y 1000

Const Primero=1 Limite=1000 Var cont, i, j: entero primo: boolean Inicio Cont = 0 Desde i= primero hasta limite primo = verdadero j = 2 mientras (i>j) y (primo =verdadero) Si i mod j = 0 Entonces primo = falso Sino j = j + 1 Fin si Fin mientras Si primo = verdadero Entonces escribir i” “ Cont = cont + 1 Fin si Fin desde Escribir “Entre “primero” y “limite” hay “cont” nº primos” Fin





2) Desarrollar un algoritmo para determinar el máximo valor entre un conjunto de números positivos ingresados a través del teclado. Un número negativo indica que no existen más números.

Algoritmo para Determinar el Valor Máximo entre un Conjunto de Números Positivos

Var num, max: entero Inicio Max = 0 Escribir “Introduzca nº positivos y para acabar introduzca uno negativo” Leer num Mientras num >=0 hacer Si num >max Entonces max = num Fin si Leer num Fin mientras Escribir “El mayor número es” max Fin

3) Desarrollar un algoritmo para determinar cuáles son los múltiplos de 5 comprendidos

entre 1 y N.

Algoritmo Para Determinar los Múltiplos de 5 en un Rango de Números Dado

Var i: entero Inicio Desde i=1 hasta n Si i mod 5 =0 Entonces escribir i Fin si Fin desde Fin


Libro 1: Fundamentos de Programación Unidad 3: Programación Estructurada. 200



4) Desarrollar un algoritmo, que al final de curso, determine cuál es el alumno con el promedio de notas más alto del semestre. Se sabe que en el semestre están inscritos 150 alumnos y cursan 5 asignaturas.

Algoritmo para Determinar el Alumno con el Promedio de Notas Más Alto del Semestre

Const Alumnos=150 Asignaturas=5 Var Nombre, mejor_alum: cadena Nota, suma, media, acum: real I, j: entero Inicio Acum = 0 Desde i=1 hasta alumnos Suma = 0 Escribir “Introduzca el nombre del alumno” Leer nombre Desde j=1 hasta asignaturas Escribir “Introduzca la nota de la asignatura” Leer nota Suma = suma + nota Fin desde Media = suma / asignaturas Si media > acum Entonces acum = media Mejor_alum = nombre Fin si Fin desde Escribir “El mejor alumno es “mejor_alum Escribir “Su nota media es “acum Fin





5) Calcular la suma de los divisores de cada número introducido por teclado. Terminará cuando el número sea negativo ó 0.

Algoritmo Para Calcular la Suma de Los Divisores de un Conjunto de Números Var Numero, i, suma :entero Inicio Escribir “Introduce un número y para terminar introduce un número negativo o 0” Leer número Mientras numero > 0 hacer Suma = 0 Desde i=1 hasta numero /2 Si numero mod i =0 Entonces suma = suma + i Fin si Fin desde Suma = suma + numero Escribir “La suma de los divisores del número es “suma Leer numero Fin mientras Fin

6) Se coloca un capital C, a un interés I, durante M años y se desea saber en cuánto se habrá convertido ese capital en m años, sabiendo que es acumulativo.

Algoritmo para Calcular Final Var I, j, m: entero c, temporal: real Inicio repetir Escribir “Introduce el capital, el interés y el tiempo” Leer c, i, m Hasta (c>0) y ((i<=0)y(i<=100)) y (m >=0)

Desde j=1 hasta m

c = c * (1+I/100) Fin desde

Escribir “Tienes “c” Bs.” Fin


Libro 1: Fundamentos de Programación Unidad 4: Procedimientos y Funciones 203



Unidad 4: Procedimientos y Funciones 1) Desarrollar un algoritmo calcular los n primeros términos de la serie de Fibonacci.

Los términos de la serie de Fibonacci se definen como sigue:

Fibonacci (1)= Fibonacci (2)=1 para n=1 y n=2

Fibonacci (n)= Fibonacci (n-1) + Fibonacci (n-2) para n > 2

2) Desarrollar un algoritmo que determine cuál es la primera potencia en base 2 mayor que un número que se pasa como parámetro, devolviendo el valor de dicha potencia y el exponente al que está elevado.

3) Desarrollar un algoritmo que calcule recursivamente en cuánto se convierte un capital C al final de N años y a un interés I.





Respuesta Unidad 4: Ejercicios Propuestos 1) Desarrollar un algoritmo para calcular los n primeros términos de la serie de Fibonacci:

Los términos de la serie de Fibonacci están definidos como sigue:

Fibonacci (1)= Fibonacci (2)=1 para n=1 y n=2

Fibonacci (n)= Fibonacci (n-1) + Fibonacci (n-2) para n > 2

Algoritmo para Determinar los n Primeros Términos de la Serie de Fibonacci Var i, n: entero Inicio Escribir “Introduce un número” Leer n Desde i=1 hasta n Escribir “La serie de fibonacci de “i” es “fibonacci (i) Fin desde Fin Funcion fibonacci (num: entero): entero Inicio Si (num = 1) o (num = 2) Entonces retorno 1 Sino Retorno (fibonacci (num - 1) + fibonacci (num - 2) Fin si Fin fibonacci





2) Implementar un algoritmo que indique cuál es la primera potencia en base 2 mayor que un número que se pasa como parámetro, devolviendo el valor de dicha potencia y el exponente al que está elevado.

Algoritmo elevar Var Numero, resp1, resp2: entero Inicio Escribir “Introduce un número” Leer numero Comprueba (numero, resp1, resp2) Escribir “2^”resp1”=”resp2” >”numero Fin Procedimiento comprueba (num: entero; ent-sal n: entero; ent-sal pot: entero) Inicio n =1 ********Valor inical de pot falta**************************** Mientras pot < n hacer pot = pot *2 n = n+1 Fin mientras Fin comprueba

3) Implementar un algoritmo que calcule recursivamente en cuánto se convierte un

capital C al final de N años y a un interés I.

Algoritmo

Funcion calculo (c: entero; i: entero; n: entero): real Inicio Si m=0 Entonces retorno C Sino Retorno (c * (1 + i / 100) + calculo (c, i, n-1) Fin si Fin calculo





Unidad 5: Estructura de Datos: Arreglos 1) Un multicine tiene 5 salas y cada sala tiene una capacidad de 100 personas

distribuidas en 5 filas de 20 asientos.

Desarrolle un algoritmo que cuando un cliente solicite una entrada para una de las salas, indique si hay un asiento disponible.

2) Dado el siguiente algoritmo ¿Cuál es la salida que produce?

Algoritmo Principal Var Datos: array [1..10] de entero i: entero inicio desde i=1 hasta 10 datos [i] = i fin desde P1 (datos,datos[3]) Desde i=1 hasta 10 Escribir datos [i] Fin desde Fin Procedimiento P1 (a: array [1..10] de entero; ent-sal x: entero) Inicio x = 0 Desde i=1 hasta 10 x = x + a[i] Fin desde Fin P1

3) Dada una matriz A de M*N elementos, actualizar la matriz de manera que en la matriz resultante, los elementos de la diagonal principal sean el resultado de su valor inicial dividido entre la suma de los elementos que no forman parte de ella.





Respuesta Unidad 5: Ejercicios Propuestos 1) Un multicine tiene 5 salas y cada sala tiene una capacidad de 100 personas

distribuidas en 5 filas de 20 asientos.

Desarrolle un algoritmo que cuando un cliente solicite una entrada para una de las salas indique si hay un asiento disponible.

Algoritmo Disponibilidad de Asiento en la Sala de Cine

Const Salas=5 Asientos=20 Filas=5 Var N_salas,j,k: entero Marca: boolean A: array [1..salas,1..asientos,1..filas] de entero Inicio Pedir_datos (n_salas) Mientras n_salas <> 0 hacer Marca = falso j = 0 k = 1 Repetir Si j > asientos Entonces j =1 k = k+1 Fin si Si (j=asientos) y (k>=filas) Entonces

escribir “Sala llena” Marca = verdadero Sino

si a [n_salas,j,k]=0 Entonces a[n_salas,j,k] = 1

Escribir “Asiento”j”fila”k Marca = verdadero Sino j = j + 1 Fin si Fin si Hasta (a[n_salas,j,k]=1) y (marca=verdadero) Pedir_datos (n_salas) Fin mientras





Fin Procedimiento pedir_datos (ent-sal s: entero) Inicio Repetir Escribir “¿En qué sala quieres entrar?” Leer s Hasta (s>=0) y (s<=salas) Fin pedir_datos

2) Dado el siguiente algoritmo ¿Cuál es la salida que produce? Algoritmo Principal Var Datos: array [1..10] de entero i: entero inicio desde i=1 hasta 10 datos [i] = i fin desde P1 (datos,datos[3]) Desde i=1 hasta 10 Escribir datos [i] Fin desde Fin Procedimiento P1 (a: array [1..10] de entero; ent-sal x: entero) Inicio X = 0 Desde i=1 hasta 10 X = x + a[i] Fin desde Fin P1 Salida del Algoritmo: 1, 2, 55, 4, 5, 6, 7, 8, 9, 10.





3) Dada una matriz A de M*N elementos, actualizar la matriz de manera que en la matriz resultante, los elementos de la diagonal principal sean el resultado de su valor inicial dividido entre la suma de los elementos que no forman parte de ella. Algoritmo div_matriz Var A: array [1..M,1..N] de real Suma: real Inicio Pedir_datos (a) Sumar (a,suma) Escribir (a) Fin Procedimiento pedir_datos (matriz: array [1..M,1..N] de real) Var I,j: entero Inicio Desde i=1 hasta M Desde j=1 hasta N Escribir “Introduce el elemento”i”,”j Leer a[i,j] Fin desde Fin desde Fin pedir_datos Procedimiento sumar (matriz: array [1..M,1..N] de real; ent-sal s: real) Var I,j: entero Inicio S = 0 Desde i=1 hasta M Desde j=1 hasta N Si i< > j Entonces s = s + matriz [i,j] Fin si Fin desde Fin desde Fin sumar





Procedimiento escribir (matriz: array [1..M,1..N] de real; s: real) Var I,j: entero Inicio Desde i=1 hasta M Desde j=1 hasta N Si i=j Entonces escribir a[i,j]/s Sino escribir a[i,j] Fin si Fin desde Fin desde

Fin escribir

Libro 1: Fundamentos de Programación · PDF fileGuía del Estudiante Fundamentos...

Documents

Transcript of Libro 1: Fundamentos de Programación · PDF fileGuía del Estudiante Fundamentos...