¡Descarga Programación básica USAL y más Apuntes en PDF de Informática General 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 ............................................................................................................................................ El ordenador en la resolución de problemas ......................................................................................................... Fases en la creación de un programa ....................................................................................................................
_1. Análisis del problema ......................................................................................................................................
- Diseño y verificación del algoritmo.................................................................................................................
- Codificación en un lenguaje de programación................................................................................................
- Compilación y enlazado ..................................................................................................................................
- Pruebas y depuración ....................................................................................................................................
- Documentación .............................................................................................................................................._ EJERCICIOS RESUELTOS................................................................................................................................ Ejercicio 1.- Impuesto Valor Añadido ............................................................................................................... Ejercicio 2.- Salario semanal ............................................................................................................................ Ejercicio 3.- Factorial ....................................................................................................................................... Ejercicio 4.- Números primos............................................................................................................................ Ejercicio 5.- Suma de 50 números de teclado ................................................................................................... Ejercicio 6.- El mayor de 100 números ............................................................................................................. Ejercicio 7.- Diferencia de sumas de positivos y negativos............................................................................... EJERCICIOS PROPUESTOS ............................................................................................................................. Ejercicio 8.- Analizar el resultado..................................................................................................................... Ejercicio 9- Área y volumen de un cilindro ....................................................................................................... Ejercicio 10.- Suma de la serie aritmética 3, 6, 9, … 99 ................................................................................... Ejercicio 11.- Las primeras potencias de 2 ....................................................................................................... Ejercicio 12.- Producto mediante sumas........................................................................................................... Ejercicio 13.- Números de Armstrong ............................................................................................................... Ejercicio 14.- Algoritmo de Euclides (mcd) ...................................................................................................... Ejercicio 15.- Media de la suma de una serie de números positivos................................................................. Ejercicio 16.- Incrementos y decrementos hasta cruce ..................................................................................... Ejercicio 17.- Suma de los pares entre dos límites dados ................................................................................. Ejercicio 18.- Contar ceros ............................................................................................................................... Ejercicio 19.- Sumar términos hasta superar límite.......................................................................................... Ejercicio 20.- El valor de la suma de “n” términos ..........................................................................................
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.
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.
(^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
Figura 3. Símbolos estándar para diagramas de flujo (ANSI/ISO) – Símbolos secundarios.
3. Codificación en un lenguaje de programación
El algoritmo diseñando se escribe en el lenguaje de programación elegido. El objetivo es elaborar el programa.
Utilizando un editor de textos se genera un fichero en disco llamado programa fuente, el cual está constituido por una serie de sentencias escritas en algún lenguaje de programación determinado. Esta actividad se denomina programación propiamente dicha.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
4. Compilación y enlazado
Ya que el ordenador sólo entiende código máquina, el programa fuente no es directamente interpretable por la computadora, por lo que debe de sufrir un proceso de traducción.
Estos “traductores” son de dos tipos: compiladores e intérpretes.
Un intérprete toma el programa fuente sentencia a sentencia (de una en una), la analiza y la interpreta produciéndose su ejecución. Toma una sentencia del programa fuente cada vez, la analiza e interpreta, ejecutándola inmediatamente, y así sucesivamente.
Un intérprete tiene las siguientes características: Cada vez que se desee ejecutar un programa, hay que volver a traducirlo. La traducción se realiza justo antes de la ejecución. Por tener que ir traduciendo cada sentencia antes de ejecutarla, la ejecución es más lenta que en el caso de un programa compilado. Se utilizan mucho menos que los compiladores.
Un compilador traduce el programa fuente a lenguaje máquina, generando el denominado programa objeto. Este programa objeto puede almacenarse en disco para ser utilizado posteriormente sin necesidad de volverlo a compilar el programa fuente.
Un compilador sólo traduce el programa, no lo ejecuta.
Se requiere un compilador diferente para cada lenguaje de programación y para cada arquitectura, pudiendo existir diferentes compiladores para un mismo lenguaje y una misma arquitectura.
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:
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 y corregir o 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, etc. 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
en que ha incurrido el programador al transcribir el algoritmo a programa. La solución para ellos suele ser una revisión del programa codificado confrontándolo con el algoritmo, y si este no fuera el problema se pasará a la revisión del algoritmo y en su caso, si es necesario, su rediseño.
Para depurar un programa realizado con un compilador es muy recomendable ejecutar dicho programa bajo el control de un programa especial denominado depurador o debugger 5.
Un depurador es una herramienta software que suelen incorporar todos los entornos de desarrollo, y que es capaz de cargar y ejecutar de forma controlada nuestro programa. Permite la ejecución paso a paso (instrucción a instrucción), evaluación de expresiones, examen de contenido de variables, registros de la UCP, etc. Generalmente, cuando se realiza la compilación, se debe indicar al compilador, mediante la correspondiente opción, que debe generar código para ejecutar con depurador.
(^5) La traducción estricta del inglés de término “debug” es “desinfectar” o “matar chinches”. En los primeros
tiempos de la informática, una polilla colocada sobre un contacto electromecánico del ordenador Mark II ocasionó un error en el programa que ejecutaba esta máquina. A partir de entonces, se asocia el término “debug” al hecho de corregir 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 programadores ha incluido modificaciones en el programa. Nombres significativos para describir los identificadores. Comentarios significativos que ayudan a la comprensión del código y que expliquen partes complejas o confusas del algoritmo. Claro estilo 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
EJERCICIOS RESUELTOS
Ejercicio 1.- Impuesto Valor Añadido
Supongamos que el Impuesto sobre el Valor Añadido (IVA) con el que se gravan los vehículos en España es del 16%. Dado un coche cuyo valor para el comprador sea de Precio final , ¿cuál es la cantidad que percibe el Estado en concepto de este impuesto?.
Realizar un análisis y algoritmo que haga las preguntas oportunas y responda a la cuestión formulada.
Ayuda: El ejercicio puede resolverse con una estructura secuencial.
Análisis Datos de entrada: Precio final del vehículo. Tipo real. Se leerá de teclado.
Datos constantes: El porcentaje de IVA. Tipo real. Valor 16.
Datos de salida: El impuesto que grava el precio final del vehículo. Tipo real. Se mostrará en pantalla.
Definición del problema:
Precio final = Precio bruto + Impuesto (ecuación 1)
Precio bruto donde Impuesto = ------------------ * IVA (ecuación 2) 100 Sustituyendo la ecuación 2 en la ecuación 1 y despejando, obtenemos Precio bruto en función del Precio final y del IVA , uno dato de entrada y el otro una constante. Precio final Precio bruto = -------------------- (ecuación 3) (1 + IVA /100)
Y conocido Precio bruto , a través de la ecuación 2 puede obtenerse el Impuesto.
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
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Inicio leer (horas_trabajo, precio_hora)
Si (horas_trabajo > HORAS_SEM) salario_extra (horas_trabajo – HORAS_SEM) * VALOR_HORA_EXTRA * precio_hora salario_semanal (HORAS_SEM * precio_hora) + salario_extra Sino salario_semanal horas_trabajo * precio_hora FinSi
escribir (salario_semanal) Final
Algoritmo en diagrama de flujo
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Algoritmo en diagrama de flujo
Verificación del algoritmo. Traza del algoritmo. Sabemos que el factorial de 5 es 120. Podemos comprobar el algoritmo con el valor 5 de entrada y obtendremos la siguiente tabla de traza, que demuestra que el algoritmo es correcto.
n num factorial 5 5 1 5 4 5 5 3 20 5 2 60 5 1 120
Para este algoritmo podría haberse utilizado también una estructura repetitiva desde.
Práctica 1.- Diseño de Programas
Grado en Ingeniería Informática – Programación I
Algoritmo en pseudocódigo – versión desde Algoritmo calculo_factorial Variables entero n // Entrada. Número a calcular el factorial entero num // Intermedia de trabajo real factorial // Salida Inicio leer (n)
factorial ← 1 Desde num ← 1 hasta n con incremento 1 factorial ← factorial * num FinDesde
escribir (factorial) Final
