¡Descarga Práctica 1: Diseño de Programas - Programación I y más Apuntes en PDF de Programación C solo en Docsity!
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Práctica 1
DISEÑO DE PROGRAMAS
Objetivo de la práctica ............................................................................................................................................ 1 El ordenador en la resolución de problemas ......................................................................................................... 2 Fases en la creación de un programa .................................................................................................................... 2
_1. Análisis del problema ...................................................................................................................................... 3
- Diseño y verificación del algoritmo ................................................................................................................. 4_ 2.1 Estructuras algorítmicas............................................................................................................................ 6 _2.2 Verificación del algoritmo ....................................................................................................................... 11
- Codificación en un lenguaje de programación .............................................................................................. 12
- Compilación y enlazado................................................................................................................................. 12
- Pruebas y depuración .................................................................................................................................... 14
- Documentación .............................................................................................................................................. 17_ EJERCICIOS RESUELTOS ................................................................................................................................ 18 Ejercicio 1.- Impuesto Valor Añadido ............................................................................................................... 18 Ejercicio 2.- Salario semanal ............................................................................................................................ 20 Ejercicio 3.- Factorial ....................................................................................................................................... 22 Ejercicio 4.- Números primos ............................................................................................................................ 26 Ejercicio 5.- Suma de 50 números de teclado.................................................................................................... 28 Ejercicio 6.- El mayor de 100 números ............................................................................................................. 33 Ejercicio 7.- Diferencia de sumas de positivos y negativos ............................................................................... 36 EJERCICIOS PROPUESTOS ............................................................................................................................. 40 Ejercicio 8.- Analizar el resultado ..................................................................................................................... 40 Ejercicio 9- Área y volumen de un cilindro ....................................................................................................... 40 Ejercicio 10.- Suma de la serie aritmética 3, 6, 9, … 99 ................................................................................... 40 Ejercicio 11.- Las primeras potencias de 2 ....................................................................................................... 41 Ejercicio 12.- Producto mediante sumas ........................................................................................................... 41 Ejercicio 13.- Números de Armstrong ............................................................................................................... 41 Ejercicio 14.- Algoritmo de Euclides (mcd)....................................................................................................... 41 Ejercicio 15.- Media de la suma de una serie de números positivos ................................................................. 42 Ejercicio 16.- Incrementos y decrementos hasta cruce ..................................................................................... 42 Ejercicio 17.- Suma de los pares entre dos límites dados.................................................................................. 42 Ejercicio 18.- Contar ceros................................................................................................................................ 42 Ejercicio 19.- Sumar términos hasta superar límite .......................................................................................... 43 Ejercicio 20.- El valor de la suma de “n” términos .......................................................................................... 43
Objetivo de la práctica
El desarrollo de programas de ordenador, con independencia de su tamaño y complejidad, conlleva un proceso que involucra diferentes métodos de desarrollo y diversas herramientas que de alguna forma automatizan y apoyan la creación de dichos programas. En esta práctica se van a introducir los conceptos básicos necesarios para entender este proceso de creación de programas, ubicando la fase de implementación (también denominada programación o codificación) dentro de un conjunto de etapas a realizar.
Se introducirá también el concepto de algoritmo, y las técnicas y herramientas para su diseño que facilitan su posterior implementación en el lenguaje de programación elegido.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
El ordenador en la resolución de problemas
El ordenador es muy útil para la resolución de problemas que impliquen procesos repetitivos, cálculos complicados o manejen grandes cantidades de datos. En todos estos casos supera con creces la capacidad del hombre. El computador por sí mismo no es capaz de analizar un problema y dar una solución. Esta tarea la realiza el programador , el cual, una vez que ha resuelto el problema, describe al computador de forma clara e inteligible para él los pasos a seguir para resolver el problema: el programa.
Fases en la creación de un programa^1
El proceso de diseño de un programa de ordenador se caracteriza por ser un proceso creativo , en el que no va a existir un conjunto completo de reglas que indiquen como crearlo, debiéndose recurrir en muchas ocasiones a la experiencia del propio desarrollador. De todas formas, en el caso de problemas no muy complejos, podemos enumerar las siguientes fases o pasos que deberán cumplimentarse.
Fase de definición: Analizamos el problema a resolver.
- Análisis del problema.
- Diseño y verificación del algoritmo. Fase de desarrollo: Creamos el/los programas y la documentación asociada a ellos.
- Codificación en un lenguaje de programación.
- Compilación y enlazado.
- Pruebas y depuración.
- Documentación.
Aunque estos pasos se han enunciado de forma secuencial, existen interacciones y realimentaciones entre ellos, tal y como refleja en la figura 1.
A parte de lo que es la resolución del problema, pero incluida dentro del llamado ciclo de vida de software^2 podemos incluir además la Fase de mantenimiento , la cual se centra en el cambio que va asociado a la corrección de errores, a las adaptaciones requeridas por la evolución del programa, a las modificaciones debidas a los cambios de los requisitos dirigidos a reforzar o ampliar el sistema software. La fase de mantenimiento vuelve a aplicar los pasos de las fases de definición y de desarrollo, pero en el contexto del software ya existente.
(^1) El proceso de creación de un programa abarca desde la descripción inicial del problema hasta el propio
desarrollo del programa de ordenador que lo resuelva. (^2) Período de tiempo que comienza cuando se concibe un producto software y finaliza cuando el producto pierde
su utilidad.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
2. Diseño y verificación del algoritmo
Se detalla la secuencia de pasos ( algoritmo ) a seguir para la resolución del problema. El objetivo es determinar como hará el programa la tarea solicitada. Se pasa de tener el centro de atención en el qué hacer, propio del análisis, a tenerlo en el cómo hacerlo, propio del diseño.
Algoritmo Es una secuencia de pasos a seguir para llevar a cabo la resolución de un problema. Debe de cumplir: Ser definido: Debe estar compuesto por un conjunto de acciones especificadas rigurosamente y sin ambigüedad. Siguiendo el algoritmo dos veces con los mismos datos de entrada, deben obtenerse los mismos datos de salida. Ser preciso: Debe estar compuesto por una secuencia finita de operaciones , quedando perfectamente definido el orden en que se deben realizar las mismas. Ser finito: Debe acabar en un número finito de pasos.
Uno de los métodos más utilizados para el diseño de algoritmos es el denominado " divide y vencerás ". Consiste en dividir un problema complejo en subproblemas y a su vez éstos en otros de nivel más bajo hasta obtener subproblemas fáciles de solucionar e implementar (refinamiento sucesivo). Este método se conoce como diseño descendente, top-down o modular.
Los algoritmos deben ser independientes tanto del lenguaje de programación (medio para expresar el algoritmo) como de la computadora (procesador para ejecutarlo) en que se implementen posteriormente.
Para representar los algoritmos podemos utilizar básicamente dos métodos: Métodos informales , como puede ser “narrarlo” en lenguaje natural. Describiríamos el algoritmo como si contáramos a otra persona de forma coloquial los pasos a seguir para la resolución del problema. Sin embargo, el lenguaje natural es a menudo ambiguo y el algoritmo debe estar bien definido.
Métodos formales , entre los que destacamos: Pseudocódigo : consiste en redactar el algoritmo en un pseudolenguaje intermedio entre el natural del programador y el lenguaje de programación seleccionado, utilizando como medio básico de expresión la lengua nativa del programador. No es estándar. No existen unas reglas fijas para su creación, siendo una mezcla de lenguaje natural, símbolos, términos y otras características comúnmente utilizadas en los lenguajes de programación de alto nivel como por ejemplo Pascal ó APL.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Diagramas : son métodos gráficos. Los más extendidos son los Diagramas de flujo o flowchart. El algoritmo se representa por una serie de símbolos normalizados^3 que representan cada acción (ver figuras 2 y 3 ). Los símbolos están unidos por unas flechas que indican el orden en que se realizan las acciones del algoritmo.
Figura 2. Símbolos estándar para diagramas de flujo (ANSI/ISO).
(^3) Por el Instituto Norteamericano de Normalización (ANSI).
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
2.1.1 Secuencia
- Una acción (instrucción) sigue a otra en secuencia.
- Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el fin del proceso.
Asignación : Paso de valores o resultados a una zona de la memoria. Dicha zona será reconocida con el nombre de la variable que recibe el valor.
- Asignación simple: Consiste en pasar un valor constate a una variable (a←15)
- Contador: Variable que se incrementa o decrementa en un valor constante, que normalmente es 1, para llevar el control del número de ocasiones en que se realiza una operación (a ← a+1)
- Acumulador: Variable para ir totalizando cantidades variables resultantes de operaciones aritméticas sucesivas (a ← a+b)
- Asignación de trabajo: Puede recibir el resultado de una operación matemática que involucre muchas variables (a ← c+b*2/4)
Lectura : Consiste en recibir desde un dispositivo de entrada, por ejemplo el teclado, un valor. Leer (a) donde “a” es la variable que recibe el valor
Escritura : Consiste en enviar por un dispositivo de salida, por ejemplo el monitor o la impresora, un resultado o mensaje. Escribir (“El resultado es:”, b) donde “El resultado es:” es un literal, y “b” es una variable que contiene el valor a presentar en salida
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
2.1.2 Selección Comparan una variable contra otro valor, para que en base al resultado de esta comparación, se siga un curso u otro de acción dentro del programa.
Alternativa simple : Evalúa una condición con dos posibles resultados: verdadero y falso. Si resultado verdadero se ejecuta grupo de sentencias. Si falso no se ejecuta nada.
Alternativa doble : Evalúa una condición con dos posibles resultados: verdadero y falso. Si resultado verdadero se ejecuta un grupo de sentencias. Si falso se ejecuta otro grupo de sentencias.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Repetir mientras : Similar al bucle “mientras”, con la diferencia de que la condición se evalúa después de ejecutar el cuerpo del bucle.
Desde : Se utiliza cuando se desea que un bucle se ejecute repetidamente un número determinado de veces que se conoce por anticipado.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
2.2 Verificación del algoritmo
Para verificar el algoritmo se toma una serie de entradas de datos representativas (valores normales, valores extremos e incluso valores incorrectos) y se realiza un seguimiento manual del algoritmo para comprobar que su secuencia de pasos produce el resultado esperado para esos datos de entrada.
La traza de un algoritmo es la representación del valor que van adoptando las variables a medida que se va ejecutando el algoritmo manualmente.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
El compilador realiza básicamente dos tareas:
- Análisis del programa fuente, para comprobar que se usan palabras válidas del lenguaje de programación ( análisis léxico ), las expresiones e instrucciones están bien construidas ( análisis sintáctico ) y no se ha cometido ningún error de significado, como puede ser intentar sumar números con letras ( análisis semántico ).
En el caso de que alguno de los anteriores análisis no se supere correctamente, pueden producirse dos tipos de situaciones en tiempo de compilación:
Errores: El proceso de compilación no continúa, y el propio compilador indica el lugar del programa y el tipo de error detectado. Normalmente el compilador genera la relación completa de los errores encontrados. − Si existen errores, deberá modificarse de nuevo el programa fuente y volver a compilarlo^4.
Advertencias o warnings : Son indicaciones sobre algún aspecto concreto de la traducción del código fuente que podría ser susceptible de producir un error, sin que necesariamente lo sea. En otras palabras, nos está advirtiendo “¡cuidado!, esto puede ser un error, revísalo”. − Son informativos. No provocan la interrupción del proceso de compilación, por lo que llega a generarse programa objeto. El compilador indica el lugar del programa y el tipo de warning detectado. − Si existen warnings, es conveniente revisarlos y evitarlos.
- Generación y optimización de código para generar el programa objeto. El resultado de la compilación es el programa objeto ; ya es código máquina pero no es todavía directamente ejecutable. Después de la compilación de todos los ficheros fuentes en que puede haberse dividido el programa, deberá utilizarse un montador , enlazador o linker para obtener finalmente el programa ejecutable.
En general, en un programa fuente se suele invocar a módulos que son proporcionados por la misma herramienta de desarrollo o por otros desarrolladores, y que resuelven problemas concretos. El código máquina correspondiente a estos módulos debe ser vinculado con los ficheros objeto generados por la compilación, de manera que el resultado final sea un único fichero ejecutable. Esta tarea es la que realiza el enlazador.
En la figura 4 se presenta de forma esquemática las etapas por las que se pasa para obtener un programa ejecutable a partir de un programa escrito en varios ficheros fuente.
(^4) Muchas veces al corregir ciertos errores de compilación, el número de ellos que se genera en una segunda
compilación aumenta en lugar de disminuir. Esto es debido a que ciertos errores primeramente detectados enmascaraban otros que salen en posteriores compilaciones.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Figura 4. Generación del programa ejecutable desde el programa fuente.
5. Pruebas y depuración
La depuración de un programa es el proceso de encontrar los errores de programa, corregirlos y eliminarlos (depurarlos). Al llegar a esta fase, en la que tenemos un buen algoritmo y lo hemos codificado en un lenguaje de programación, no podemos garantizar que el programa resuelva correctamente el problema planteado.
Hay dos tipos de errores que se producen en tiempo de ejecución (también llamados bugs en la “jerga informática”):
- Errores de ejecución : el programa "se para" (aborta) repentinamente sin llegar al final. Algunos errores típicos son ocasionados por intentos de dividir por cero, raíces cuadradas de números negativos, intentos de apertura de archivos inexistentes o acceso a periféricos no conectados. La solución para ellos es normalmente incluir más código en el programa que realice ciertas validaciones y verificaciones antes de intentar realizar la operación que produce el error.
- Errores lógicos : el programa se ejecuta hasta el final pero aportando unos resultados incorrectos. Son errores a veces muy difíciles de detectar. Suelen venir producidos por un mal diseño de la lógica del algoritmo, o bien por equivocaciones
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Figura 5. Tipos de errores en un programa.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
6. Documentación
Existen dos tipos de documentación: La documentación técnica para el mantenimiento del programa, para que cualquier programador ajeno entienda qué hace el programa y cómo lo hace. Esta, a su vez, puede dividirse en interna y externa. La documentación para el usuario final que manejará y utilizará el programa.
La documentación técnica externa se realizará en ficheros distintos al programa fuente. Debe incluir: El análisis y diseño del algoritmo del programa. Diagramas de flujo y pseudocódigo. Especificación de los formatos de los datos de entrada y salida del programa. Explicación de cualquier fórmula o cálculo y expresión compleja del programa. Todas las consideraciones oportunas que deba conocer cualquier programador que necesite modificar posteriormente el programa.
La documentación técnica interna se incluye en el código del programa fuente mediante: Una cabecera de programa , formada con comentarios que reflejen al menos una breve descripción, el nombre del programador, fecha, versión y nombre de los programadores que han incluido modificaciones en el programa. Nombres significativos para describir los identificadores. Comentarios significativos que ayuden a la comprensión del código y que expliquen partes complejas o confusas del algoritmo. Estilo claro y formato : una sentencia por línea, sangrado, líneas en blanco para separar bloques de sentencias relacionadas, etc...
En la documentación para el usuario final deberá especificarse claramente: La finalidad del programa. Instrucciones para su instalación y ejecución. Las restricciones de uso del programa. Los datos de entrada al programa, su formato y la obligatoriedad o no de los mismos. Los datos de salida del programa y su formato. Los nombres y formatos de los ficheros de entrada y/o salida, si el programa los tiene. Los mensajes de error que puede emitir el programa (ante datos incoherentes de entrada, por ejemplo), aclarando el motivo de los mismos y la acción a realizar en su caso.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Algoritmo en pseudocódigo Algoritmo impuesto_valor_añadido Constantes real IVA = 21 Variables real precio_final // Entrada real precio_bruto // Interna de trabajo real impuesto // Salida
Inicio leer (precio_final) precio_bruto ← precio_final / (1 + IVA / 100) impuesto ← (precio_bruto / 100) * IVA escribir (impuesto) Final
Algoritmo en diagrama de flujo
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Ejercicio 2.- Salario semanal
Realizar el análisis y el algoritmo del siguiente problema. Se desea calcular el salario semanal de los empleados de una empresa, sabiendo que éste se calcula en base a las horas semanales trabajadas y a un precio especificado por hora (ambos serán datos de entrada). Si el trabajador sobrepasa las 40 horas semanales, las horas extraordinarias se pagarán a razón de 1,5 veces la hora ordinaria.
Ayuda: El ejercicio puede resolverse con una estructura alternativa doble.
Análisis Datos de entrada: horas trabajo: Horas de trabajo semanales. Tipo real. Se leerá de teclado. precio hora: Precio de la hora de trabajo. Tipo real. Se leerá de teclado.
Datos constantes: Límite de horas de trabajo semanales para considerar horas extras (HORAS_SEM). Tipo entero. Valor 40. Valor hora extra sobre hora normal (VALOR_HORA_EXTRA). Tipo real. Valor 1,5.
Datos de salida: salario semanal. Tipo real. Se mostrará en pantalla.
Definición del problema: Deberemos comprobar si el trabajador sobrepasa las 40 horas de trabajo semanal (HORAS_SEM). Si no las sobrepasa su sueldo será salario semanal = horas trabajo * precio hora
Si las sobrepasara su sueldo será salario extra = (horas trabajo – HORAS_SEM) * VALOR_HORA_EXTRA * precio hora salario semanal = HORAS_SEM * precio hora + salario extra
Algoritmo en pseudocódigo Algoritmo salario_semanal Constantes HORAS_SEM = 40 VALOR_HORA_EXTRA = 1. Variables real horas_trabajo, precio_hora // Entrada real salario_extra // Intermedia de trabajo real salario_semanal // Salida
