g18106.3

SEGUNDO BIMESTRE Guía didáctica: Lógica de la Programación

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja 57

SEGUNDO BIMESTREGuía didáctica: Lógica de la Programación

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja56

In icio

Anio _n, m es_n, d ia _n

Solicitar año , m es y d ía d e nacim iento , va lidando que cum plan con sus va lores m áxim os y m ínim os

Anio _a, m es_a, d ia _a

Solicitar año , m es y d ía actuales validando que

cum plan con sus va lores m áxim os y m ínim os

E

E

edad_d d ia _a – dia _n

dia _n > d ia_a dia _a d ia_a + 30SI

m es_a m es_a - 1

N O

edad_m m es_a – m es_n

m es _n > m es_a m es_a m es_a + 12SI

anio_a _anio_a - 1N O

Figura 5.6 Diagrama de flujo parcial cálculo edad. Procesando los meses




In icio


Solicitar a ño , m es y día de nacim iento , va lidando que cum plan co n sus v a lores m áxim os y m ín im os


Solicitar a ño , m es y día actuales va lidando que

cum plan con sus v a lores m áxim os y m ín im os

E

E


dia _n > d ia_a dia _a d ia_a + 30SI m es_a m es _a - 1

N O


m es _n > m es_a m es_a m es_a + 12SI anio_a _anio_a - 1

N O

edad_a anio _a – anio_n

anio _n > a nio_a

N O

“Error: La fecha de n acim iento es m ayor a la

actual”

S

SI

“Edad: “ , edad_a, edad_m , edad_d

S

F in

Figura 5.7 Diagrama de flujo cálculo edad





Unavezquehemoscompletadoeldiagramadelafigura5.7,leinvitoaqueejecutealgunascorridasdel diagrama utilizando algunos casos de prueba para ver si el comportamiento de la solución es correcto, es decir funciona bien para todos los casos y se ajusta a las condiciones del problema, como sugerencia para seleccionar las fechas de ingreso, considere a las siguientes:

• Lafechadenacimientomenoralafechaactual(casonormal)• Tantolafechadenacimiento,comolafechaactualexactamenteiguales.(Pocousual)• Lafechadenacimientomayorquelafechaactual.(Casoerróneo)

Utilice las siguientes tablas para ejecutar la corrida.

Caso 1:

anio_n mes_n dia_n anio_a mes_a dia_a edad_a edad_m edad_d Salida

Caso II


Caso III


Luego de haber probado el funcionamiento del diagrama de flujo, trate de responder a las siguientes interrogantes:

1. ¿Funciona bien para todos los casos?

2. ¿Hay algún error de concepción que hace que los resultados no siempre sean exactos?

3. ¿Hay alguna manera alterna de desarrollar el diagrama de flujo?

4. ¿Se puede simplificar la solución?

5. ¿Hace falta algún tipo de validación?

Antes de pasar al siguiente capítulo, complemente su estudio con la sección “Diagramas de flujo para casos prácticos” del texto básico.




5.3 Ejercicios con diagramas de flujo

Para la mayoría de desarrolladores y profesores de programación, la única manera de aprender a programar es programando, esto significa que mientras más ejercicios resuelva mejor desarrollará las competencias requeridas, en tal virtud se ha preparado el presente apartado para ayudarle justamente a realizar ejercicios con diagramas de flujo. Podría simplemente haber colocado los ejercicios y dejar que los resuelva, pero la idea es que los desarrolle con un poco de ayuda, a manera de taller, por tanto vamos a proponer los ejercicios y a dar algunas pautas para su solución.

EJERCICIOS 5.1

Desarrolle un diagrama de flujo para obtener el salario neto de los empleados de una empresa que ganan de acuerdo a las siguientes condiciones, la horas menores o iguales a 40 se pagan como hora normal que se introduce por teclado, las horas que exceden a las 40 se pagan como extras a 1.5 veces el valor de la hora normal. Los impuestos se deducen de acuerdo a las siguientes condiciones: si gana menos de 2000 USD, no paga impuestos, los siguiente 1500 USD pagan el 20% y el resto el 30%.

Para desarrollar este ejercicio léalo detenidamente y elabore en primer lugar los enunciados correspondientes a las salidas, proceso y entradas.

Enunciados para la salida

1. El sueldo debe expresarse en dólares.

2. Como resultado debe mostrarse el sueldo, los impuestos y el valor neto.

3. ______________________________________________________________

4. ______________________________________________________________

5. ______________________________________________________________

6. ______________________________________________________________

7. ______________________________________________________________





Enunciados para el proceso

1. El costo de horas normales se obtiene multiplicando las horas hasta 40 por el costo de cada hora ingresada.

2. ______________________________________________________________

3. ______________________________________________________________

4. ______________________________________________________________

5. ______________________________________________________________

6. ______________________________________________________________

7. ______________________________________________________________

Enunciados para la entrada proceso

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------




Una vez que ha terminado de desarrollar los enunciados, desarrolle el diagrama de flujo empezando por los enunciados para la entrada de datos, luego para los del procesamiento y finalmente para los de la salida.





Luego deberá realizar pruebas de escritorio, ocupe el siguiente espacio para hacerlo. Estas pruebas le permitirán determinar si el algoritmo es correcto o no, si no lo es, identifique el problema y corrija el diagrama para que arroje los resultados correctos.




EJERCICIOS 5.2

Este ejercicio se trata de analizar un diagrama de flujo y establecer si es correcto o no con los casos de prueba planteados. Si encuentra algún problema debe corregirlo y probarlo nuevamente, de modo que se asegure de que funciona.

Planteamiento del problema: Se desea desarrollar un algoritmo que permita establecer si un número es primo. Por definición “En matemáticas, un número primo es un número natural que tiene únicamente dos divisores naturales distintos: él mismo y el 1”, y además la unidad no se considera como número primo7.

La estrategia usada para el desarrollo se basa en la definición y consiste en contar el número de divisores exactos comprendidos entre la unidad y el número.

In icio

d 2

num

num % d = 0

d <= n um

dExactos dExactos + 1SI

d d+1

N O

d

dExactos = 0“El num ero es p r im o”SI

“El núm ero no e s

pr im o”

N O

F in

Figura 5.8 Diagrama de flujo para determinar si un número es primo

7. Wikipedia (2009): Numero Primo , [En línea] Disponible en: http://es.wikipedia.org/wiki/N%C3%BAmero_primo [Consulta 25-06-2009].





Ahora sí, manos a la obra, verifique si el diagrama de flujo funciona con los números 1, 2, 4, 5, 9,11, 13, 33. Utilice el siguiente espacio para resolver la tarea propuesta:

Pruebas de Escritorio

num d dExactos resultado




Si encontró el problema, utilice el siguiente espacio para proponer un diagrama que lo corrija.





EJERCICIOS 5.3

El propósito de ejercicio es optimizar el diagrama de modo que se reduzcan el número de ciclos del bucle. Para darse cuenta qué opciones hay para ello ejecútelo con los mismos datos del ejercicio anterior para que analice el porqué el número de ciclos es alto. Hay al menos dos forma de optimizarlo.

In icio

D 2

num

num % d = 0

esPr im o 1

d <= n um

esPr im o 0SI

d d+1

N O

d

esPr im o = 1“El num ero es p r im o”

“El núm ero no e s

pr im o”

F in

Figura 5.9 Diagrama de flujo para verificar si un número es primo




EJERCICIOS 5.4

Se desea construir un algoritmo que le permita generar una tabla de amortización de préstamos para lo cual se requiere calcular lo que debe pagar mensualmente hasta que termine de realizar los pagos. Los intereses siempre se pagan sobre el saldo del capital prestado, por lo tanto nunca una cuota es mayor igual que la del mes anterior.

Ahora intente resolver el problema en un diagrama de flujo.

Luego de ver el problema, es probable no haya podido hacer absolutamente nada por falta de información, ahora ¿Cómo se supone que debemos resolver este problema?





De acuerdo a lo estudiado debemos comenzar haciendo el análisis del problema, esto es identificando y elaborando enunciados para las salidas, proceso y finalmente para las entradas. Luego podemos optar por desarrollar la miniespecificación o directamente el diagrama de flujo.

Autoevaluación 5

Ánimo, ya ha concluido la Unidad 5, sólo le falta medir cuánto aprendió en ella, para ello lo invito a desarrollarelexamenrápidodelcapítulo8deltextobásico.




UNIDAD VI

DESARROLLO DE PROBLEMAS DE PROGRAMACIÓN

La práctica de la programación es un arte y una ciencia muy interesante para nosotros como seres humanos, el hecho de poder diseñar algo que es capaz de procesar la información es de por sí una creación en la que plasmamos nuestra forma de resolver los problemas.

A lo largo de la presente guía didáctica, nuestro principal interés ha sido el de inducir el pensamiento lógico aplicado a la solución de problemas de programación, en este capítulo vamos a usar todo lo aprendido para diseñar un pequeño programa, considerando cada uno de los componentes.

Puesto que hasta ahora no ha tenido la oportunidad de ver funcionando nada en la computadora, vamosausarunaherramientadeprogramaciónvisualconocidacomoRAPTOR,desarrolladaporLaAcademia Pilotos de las Fuerzas Armadas de los Estados Unidos, en la cual tendrá la oportunidad de diseñar sus diagramas de flujo y ejecutarlos para ver los resultados, vale aclarar, que el uso de esta herramienta sirve únicamente para ayudarle a visualizar cómo funciona la lógica de un programa.

Para el desarrollo de los contenidos de esta unidad, utilizaremos el capítulo 9 del texto básico.Los capítulos 10,11,12 y 13 le enseñan a traducir los algoritmos o las miniespecificaciones a un lenguaje como Visual Basic.Net, Java, C# o C++, cuyo estudio está fuera del alcance de esta asignatura y por lo tanto queda a su criterio el estudiarlos.

6.1 Abstracción de problemas de programación

El esquema básico de funcionamiento del computador, como mencionamos en la Unidad 1, es de entradas, proceso, almacenamiento y salida, por tanto una aplicación de software debe corresponder con estas funciones, a cada una de estas le vamos a llamar capas. En la siguiente tabla vamos establecer la correspondencia entre las funciones y las capas.

Función Capa Descripción

Entrada Interfaz de usuario

Corresponde a los elementos en pantalla u otro dispositivo que permite que el usuario ingrese información.

Proceso Lógica de proceso

Código de programa que ejecuta las tareas de procesamiento de una aplicación. Toma los datos de entrada y los procesa para almacenarlo o para enviarlos a un dispositivo de salida. Esta capa incluye los datos y estructuras de datos que se guardan en la memoria principal del computador (RAM) que son requeridos para realizar el procesamiento.

Almace-namiento

Datos Estructura de datos o archivos que guardan la información, aunque se dice que el almacenamiento es lógico, muchas de las veces se lo conoce como almacenamiento físico porque se guarda en un disco u otro dispositivo ocupando espacio físico en disco.

Salida Interfaz de usuario

Nos referimos nuevamente a la interfaz de usuario en razón de que la interfaz sirve para interactuar, esto es ingresar o visualizar información. Muchas de las veces la salida puede ser un sonido, una impresión o un mensaje.





Sin importar el tamaño de la aplicación, siempre debemos pensar en estas capas, aunque puede haber programas que no las requieran, por ejemplo un programa podría no requerir la capa de almacenamiento, porque no guarda información. Es posible también que existan programas con muchas más capas debido a la complejidad de los mismos, normalmente esto se da en aplicaciones corporativas, las cuales tienen en su diseño varias capas, el mismo que se conoce como la arquitectura de la aplicación.

Ahora, vamos tomar una de las aplicaciones que hemos desarrollado para identificar en ellas las diferentes capas, por supuesto que no van a estar muy elaboradas, puesto que no hemos centrado nuestro interés en el desarrollo de interfaces sofisticadas, sin embargo vamos a ver que si tiene al menos 3 de las 4 capas, puesto que en ninguna de ellas hemos guardado información en disco, eso significa que no tendrá la capa de datos.

EJERCICIOS 6.1

Cálculo de la edad de una persona

En el ejemplo del cálculo de la edad de una persona identificamos las siguientes capas. Si no recuerda revise nuevamente el ejercicio del diagrama correspondiente a la unidad 5.

Capa de interfaz de usuario

Puesto que hemos dicho que la interfaz de usuario corresponde a las entradas o salidas de la información, en nuestro diagrama la interfaz de usuario estaría dada por los símbolos de la figura 6.1:



E

E“Edad: “, edad_a, edad_m , edad_d

S “Error: La fecha de n acim iento es m ayor a la

actual”

S

Figura 6.1 Instrucciones del diagrama para interfaz de usuario

Si analiza un poco los diagramas, estos corresponde al símbolo de datos, es decir a las instrucciones de ingreso ó salida de información. Puesto que en un diagrama no es necesario incluir elementos gráficos de interfaz, esto se ha omitido acá, pero en los programas es necesario implementar ciertos diseños de pantallas que resulten más agradables al usuario y le permitan comprender de manera intuitiva el funcionamiento de la aplicación, a los programas que cumplen con esta característica se los conoce como amigables. En la figura 6.2 colocamos un ejemplo de cómo podría ser una pantalla para esta misma aplicación.




Figura 6.2 Modelos de interfaz de usuario

El ejemplo de la figura 6.2 muestra una interfaz básica en la que las ventanas aparecen conforme se va ejecutando la aplicación, pero las aplicaciones de software normalmente utilizan modelos de interfaz que integran tanto componentes de entrada como componentes de salida, tal como se aprecia en la figura 6.3, la cual ha sido desarrollada en java con el IDE netbeans.

Figura 6.3 Modelo de interfaz de usuario avanzado

Capa de lógica de proceso

A la lógica de procesamiento corresponden los siguientes símbolos, si se analizan con cuidado estos procesos se ejecutan luego de que se completó el proceso de ingreso de datos y el usuario no tiene idea





de lo que está pasando internamente. Las instrucciones del diagrama correspondientes a esta capa son las que se muestran en la figura 6.4


dia _n > d ia_a dia _a d ia_a + 30SI m es_a m es _a - 1

N O


m es _n > m es_a m es_a m es_a + 12SI anio_a _anio_a - 1

N O

edad_a anio _a – anio_n

anio _n > a nio_a

N O

Figura 6.4 Instrucciones del diagrama para capa de proceso

Capa de datos

En este problema, no se usa una capa de datos, puesto que no hay almacenamiento secundario, todos los datos de entrada se procesan para producir la salida y termina sin almacenamiento.

Ejercicios

Pongamos en práctica lo visto en esta sección, realizando los siguientes ejercicios:

• Desarrolleunanálisisdecapassimilaralaplicadoalcadaunodelosproblemasdesarrolladosenla sección 5.3 de la guía.

• Diseñeposiblesinterfacesdeusuarioparacadaunodelosejerciciosdelasección5.3.Puedeusar Microsoft Visio u otro diagramador para hacerlo.




6.2 Componentes de una aplicación

Al igual que cualquier producto, el software se compone de una serie de elementos que son fabricados de código, por tanto los componentes son lógicos. En el apartado anterior abstraíamos las capas que forman parte de una aplicación en la que hacíamos mención a diferentes instrucciones del diagrama de flujo, pero estas instrucciones se organizan de manera lógica en diferentes tipos de componentes, los cuales vamos a listar a continuación.

CapaNombre del componente

Descripción

Interfaz de usuario

VentanasFormulariosBotonesCuadros de textoListas combinadasListas

Son objetos propios de interfaz de usuario que normalmente se los encuentra como librerías de los lenguajes de programación, o se pueden crear y definir como componentes reutilizables en bibliotecas de componentes.

Lógica de proceso

FuncionesProcedimientosClasesMódulosVariablesConstantes

Elementos de código que construye el programador a los cuales les asigna la responsabilidad de procesar y validar la información.

DatosArchivosTablas

Elementos que poseen una estructura que se guarda físicamente en el disco duro con información relacionada a la aplicación.

Estos son los componentes que por lo general se encuentra en las aplicaciones de software, y si usted ha tenido oportunidad de desarrollar alguna aplicación, habrá reconocido algunos de ellos.

Suele ocurrir con mucha frecuencia que en el código de muchas aplicaciones no se distingue las capas que indicamos, y esto es un problema sobre todo cuando surgen cosas que hay que corregir, por ello es importante desde el inicio tener en cuenta esta estructura para diseñar las aplicaciones adecuadamente, de todos modos en el alcance de la asignatura no revisamos este tipo de aplicaciones, sin embargo usted puede estudiar por su cuenta el tema en los capítulos posteriores del texto para programación en alguno de los lenguajes establecidos.

Ahora bien, si piensa un poco en la capa de interfaz, lenguajes como Visual Basic, traen una interfaz de desarrollo que permite colocar estos elemento en la ventana donde se ejecutarán, de modo que los programadores no pierdan mucho tiempo dándoles forma y se puedan centrar en la capa de procesamiento.

En la capa de lógica de programación, los componentes tales como las funciones y procedimientos pueden ser provistos por el lenguaje de programación o desarrollados como parte de la aplicación, por ello es importante conocer las prestaciones que ofrece un lenguaje determinado para simplificar nuestra tarea de programación.

Funciones y Procedimientos

Conocemos como funciones y procedimientos a ciertas partes de código que se diseñan para cumplir una tarea específica y devolver el control a la sección de código que la llamó, en términos generales





se las conoce como subrutinas y si recuerda el capítulo 5, la llamada a las mismas se representa con el símbolo . Las subrutinas hacen que los programas sean mucho más eficientes.

Las subrutinas que caen en la denominación de funciones se caracterizan porque siempre devuelven un valor que es almacenado en una variable o se usan como parte de una expresión, por ejemplo la funciónpi()puededevolverelvalordeπ,enestecasononecesitarecibirningúnparámetrodeentrada.Por otro lado las que caen en categoría de procedimientos se caracterizan porque al ser llamadas ejecutan una acción, pero no retornan ningún valor y por tanto no pueden colocarse como parte de una expresión.

En la tabla 6.1 nos permitimos listar algunas de las funciones comunes que la mayoría de lenguajes de programación suelen traer.

Tabla 6.1 Tabla de funciones comunes en lenguajes de programación

Función Descripción

abs(n) Devuelve el valor absoluto de n, es decir ignora el signo de positivo o negativo.

sqrt(n) Obtienelaraízcuadradaden.

sqr (n) Obtieneelcuadradoden.

random(n) Obtieneunnúmeroaleatoriocomprendidoentre0yn.

log(n) Devuelve el logaritmo de n.

exp (n) Devuelve el antilogaritmo de n.

ln() Devuelve el logaritmo natural de n.

Tal como lo imagina el contar con estas funciones hacen que se simplifique considerablemente el esfuerzo de programación, todos los lenguajes de programación entre ellos java, c++, c#, Visual Basic, ofrecen un rico conjunto de funciones que se pueden usar en la fase de codificación.

Librerías

Para sacar el máximo provecho a estas funciones y procedimientos, lo que se suele hacer es crear bibliotecas de código, de forma tal que puedan ser utilizadas en más de un programa. Archivos de datos

Cuando usted desarrolla un aplicación que necesita guardar información tiene dos opciones para hacerlo, la primera es crear archivos de datos tipo texto o binarios que sólo puede ser leídos por su aplicación y la segunda es utilizar un sistema gestor de base de datos tal como mysql, Access, Sqlserver entre otros, en cuyo caso se vale del lenguaje que implementa el motor de base de datos para manipularlos.

6.3 Desarrollo de aplicaciones sencillas

Hasta aquí, usted ha tenido la oportunidad de conocer y aplicar algunas herramientas de diseño de programas para computadora, y quizá se haya preguntado porque no ha utilizado el computador. Pues bien llegó el momento de hacerlo, y para ello en el disco anexo a la guía didáctica encontrará el programa Raptor,




Una característica muy importante de Raptor es que le permite dibujar el diagrama de flujo y ejecutarlo, mostrando además los valores de las variables utilizadas, es decir le ahorra todo el proceso manual, además entre otras cosas le permite generar código para lenguajes como Ada, Java, C++ o puede generar un programa ejecutable que funciona como cualquier aplicación.

No queremos extendernos más en el asunto y pongámonos manos a la obra, lo que sí debemos advertirle es que hay algunas variaciones en los símbolos usados para realizar los diagramas en Raptor, de todos modos deberá estudiarlo para poder hacer uso de él.

Iniciemos instalando el programa Raptor que se encuentra en su disco, si tiene alguna dificultad, consulte la documentación.

Una vez que ha logrado instalar Raptor, tome el capítulo 9 de su texto básico y desarrolle los ejemplos y aplicaciones que el autor propone.

Estoy seguro de que se siente muy entusiasmado con el uso de esta herramienta, en realidad se puede hacer muchas cosas, por tanto lo que queda es desarrollar más ejercicios y quizá estaría demás decir que programe en raptor todos los ejercicios desarrollados hasta ahora.

Para completar este capítulo, nos hemos permitido desarrollar una aplicación completa en Raptor con el propósito de que entienda como se construye una aplicación.

Ejemplo 6.1

Desarrollar en Raptor un programa para jugar al ahorcado.

Descripción de la aplicación:

Se trata del juego del ahorcado en el cual se le pide al usuario que adivine una palabra seleccionada al azar, para lo cual debe ingresar de una en una las letras que considera que la forman, si la letra está en la palabra debe mostrarse en su posición, los demás espacios se muestran como guiones para que tenga una idea de la longitud de la palabra, si la letra no consta en la palabra del juego o está repetida se contará como error e irá dibujando poco a poco un muñeco por cada error cometido, hasta que el muñeco se ahorca, si acierta y adivina la palabra, deberá felicitarle. En cualquiera de los dos casos termina el juego.

Revisemos ahora los enunciados para este juego:

Salidas:

1. Mostrar la palabra con las letras que adivinó y guiones en aquellas que no acertó, esto por cada letra que ingresa el usuario.

2. Si adivina la palabra en la cantidad de intentos datos, debe felicitar al usuario.

3. Si no logra adivinar debe presentar un dibujo de un muñeco ahorcado y termina el juego.





Proceso:

1. Debe contar con una lista de palabras para seleccionar una de ellas aleatoriamente.

2. Cada letra correcta se muestra en pantalla.

3. Cada error cometido produce un paso hacia el ahorcamiento del muñeco.

4. Se considera como error a una letra repetida o una letra que no consta en la palabra.

Entrada:

1. Se requiere que el usuario ingrese letras hasta que adivine la palabra o hasta que se le acaben las opciones.

Como podrá darse cuenta, los enunciados nos pueden llevar a detalles de implementación mucho más complejos, pero a medida que se explique la aplicación las únicas habilidades que necesita son las de poder escribir expresiones correctamente y utilizar adecuadamente los diagramas de flujo, por lo tanto le sugiero que si tuvo alguna dificultad con el seguimiento del capítulo del texto básico indicado, lo retome hasta comprenderlo debidamente.

Ahora analicemos los componentes de la aplicación por capas:

CAPA DE INTERFAZ

A este nivel nos hemos permitido desarrollar dos componentes, el primero es una pantalla de ingreso de las letras, y el segundo es una pantalla gráfica que muestra el estado de la palabra y en caso de cometer errores el dibujo del muñeco ahorcándose. En las figuras 6.5 y 6.6 se muestran las interfaces definidas para el efecto. Recuerde que en la capa de interfaz representamos tanto las entradas como las salidas.

Figura 6.5 Interfaz para el ingreso de datos




Figura 6.6 Interfaz gráfica de salida de la aplicación.

CAPA DE LÓGICA

A nivel de lógica necesitamos datos predefinidos y varios grupos de instrucciones organizados en subrutinas, las cuales debemos ir llamando conforme las necesitemos, además debemos hacer uso de varias funciones de la biblioteca de raptor que nos permitan hacer cosas como seleccionar aleatoriamente una palabra, inicializar el modo gráfico y dibujar las figuras.

A nivel de diagramas y subdiagramas necesitamos lo siguiente:

1. Un programa principal desde donde empieza a ejecutarse la aplicación.

2. Varios subprogramas con propósitos específicos, algunos de ellos necesitan recibir ciertos datos de entrada para poder realizar su tarea, en este caso hablamos de procedimientos. Los podemos apreciar en la Tabla 6.2





Tabla 6.2 Lista de diagramas y subdiagramas que conforman la aplicación

Nombre Propósito Llamado desde

main Programa principal, desde aquí se ejecuta toda la aplicación.

No debe tener llamadas.

crear_lista Crea la lista de palabras en una matriz.

inicializar_juego.

inicializar_palabra Rellena con guiones la palabra que se le muestra al usuario.

inicializar_juego.

ahorcar Dibuja paso a paso el muñeco del juego.

main.

escribir Dibuja la palabra donde constan las letras acertadas y guiones en las demás.

main.

inicializar_juego Crea el entorno de datos necesario para poder comenzar el juego.

main .

crear_interfaz Crea la interfaz gráfica. main .

CAPA DE DATOS

Aunque la aplicación no guarda la información en archivos, requiere de datos que en este caso son las palabras que debe adivinar, para ello usamos un arreglo que es una variable capaz de contener varias casillas con una palabra cada una, a ellas se puede acceder con el nombre del arreglo y un subíndice entre corchetes, esto se puede apreciar en el sub diagrama inicializar_lista.

Una recomendación importante que quiero hacerle es que haga el seguimiento al programa completo, puede hacerlo manualmente o preferentemente en el entorno Raptor, puesto que va resaltando cada instrucción y muestra los valores de las variables.

Para visualizar y analizar la aplicación abra el archivo ahorcado.rap que se encuentra en el CD en la carpeta ejemplos raptor

EJERCICIOS 6.1

Conloaprendidoenestecapítulo,desarrolleunjuegoenRaptorenelcualteniendounmáximode7intentos la máquina adivina un número del 1 al 100 pensado por el usuario utilizando el método de la búsqueda binaria. La búsqueda binaria consiste en dividir el rango de números posible en 2 y realizar dos preguntas, la primera mostrar el número del centro del rango y preguntar si se trata de ese número, si el usuario dice que es correcto el computador a logrado adivinar el número y termina, en caso de no ser el número, realiza la segunda pregunta que sería si el número es mayor o menor, si es mayor divide el rango nuevamente cogiendo el grupo superior y repite el proceso, luego si es menor hace lo mismo conelrangoinferior,demodoquecadavezvaencerrandoalnúmero.Sinololograen7intentos,elusuario respondió incorrectamente las preguntas, en este caso debe alertar del particular.


SOLUCIONARIOGuía didáctica: Lógica de la Programación

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja80 UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja 81



Con este tema finalizamos la asignatura, y estamos seguros de que les será de gran utilidad para las asignaturas siguientes, como recomendación final le sugerimos seleccione uno de los lenguajes de programación desarrollados en el libro y trate de programar en el las soluciones dadas. En el disco adjunto a la guía hemos incluido algunos de los lenguajes de programación como java y c++ para que los use en su aprendizaje.

Autoevaluación 6

Concluya el estudio de esta materia desarrollando el examen rápido del capítulo 9 del texto básico.

SOLUCIONARIO Guía didáctica: Lógica de la Programación






8. Solucionario

UNIDAD 1Parte 1

1. a2. b3. a4. b5. c

Parte 2

6. v7. f8. f9. v10. v

UNIDAD 2Parte 1

1. c 2. a3. c4. b5. c

Parte 2

6. V 7. F8. F9. F10. V

UNIDAD 3Parte 1

1. c 2. a3. c4. a5. b

Parte 2

6. F 7. F8. F9. V10. V

UNIDAD 4Parte 1

1. b 2. c3. a4. a5. c

Parte 2

6. F 7. F8. F9. V10. F


GLOSARIOGuía didáctica: Lógica de la Programación




UNIDAD 5

Parte 11. a

C am bios de e stado ( var iab les de tr abajo)

Estructuras de contro l

Estructuras de d ecisión

D eclaraciones

Petición d e datos

m uestra

C am bios de e stado ( var iab les de tr abajo)

UNIDAD 6Parte 1

1. b2. c3. b4. b5. a

Parte 2

6. F7. V8. F9. V10. V

GLOSARIO Guía didáctica: Lógica de la Programación

UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja 83UNIVERSIDAD TÉCNICA PARTICULAR DE LOJA La Universidad Católica de Loja 83

9. Glosario

ADA.- Lenguaje de programación orientado a objetos.

Algoritmo.- Secuencia ordenada de pasos que nos permiten realizar alguna actividad.

Aplicación.- Conjunto de componentes de software y datos que permiten resolver problemas o realizar actividades con la ayuda del computador.

Bucle.- Estructura de control que permite la repetición de una o más instrucciones, existen tres tipos de bucles, los que evalúan la condición a la entrada, los que evalúan la condición a la salida y los que se ejecutan un determinado número de veces con la ayuda de un contador.

Booleano.- .oslaf o oredadrev res edeup rolav oyuc nóiserpxe anu a o elbairav anu a racilpa edeup eS Deriva del Álgebra de Boole.

Condición.- Expresión booleana que se usa para desviar el flujo del programa o terminar un bucle.

Constante.- Espacio de memoria capaz de guardar un valor que no cambia durante la ejecución de un programa. Matemáticamente son valores fijos que se utilizan para realizar diferentes cálculos.

Conclusión.- Resultado al que se llega partiendo de unas premisas y aplicando reglas de inferencia.

C++.- Lenguaje de programación orientado a objetos muy utilizado en el desarrollo de aplicaciones de mediano y bajo nivel, deriva del lenguaje C.

C# (si charp).- Versión de C orientado a objetos desarrollado por Microsoft he incluido en su plataforma Visual Studio .Net.

Expresión.- Grupo de constantes y/o variables con operadores que de acuerdo a una sintaxis permite realizar la transformación de los datos, sus resultados se almacenan en variables.

Enunciado.- En lógica de programación es una expresión lingüística que establece un pensamiento, puede ser interrogativo, imperativo o declarativo.

MPAE&JSCB/ vt/05-08-09/83

cll/2011-11-09

g18106.3

Documents