106856901-Metodo-de-las-6D-UML-PSEUDOCODIGO-JAVA-Enfoque-algortimico.pdf

MÉTODO DE LAS 6’D UML – Pseudocódigo – Java (Enfoque algorítmico)

UNIVERSIDAD DE S AN M ARTIN DE PORRES Facultad de Ingeniería y Arquitectura

MÉTODO DE LAS 6’D UML – Pseudocódigo - Java (Enfoque algorítmico)

Ing. Juan José Flores Cueto.

- 2005 -

A mi madre adorada, por siempre.

“Lo que escucho, lo olvido. Lo que veo, lo recuerdo. Pero lo que hago, lo entiendo” Confucio. “Fallar no te convierte en un fracaso, aceptar el fracaso y no querer volver a intentarlo, si lo hace” Richard Exley.

AGRADECIMIENTOS

Es importante destacar la participación de mis alumnos del curso de Algoritmo y Estructura de Datos, integrantes del equipo de trabajo, formado para el desarrollo del presente libro. Este libro no se hubiera terminado en tan corto tiempo, con la calidad y cantidad de problemas desarrollados, sino hubiera sido por su valiosa colaboración y aporte. A todos ellos, mi agradecimiento y mis sinceras felicitaciones por el trabajo realizado. Equipo de trabajo: • • • • • •

Isabel Rojas Vidal. Jorge Condezo Guerra. Roberto Pérez Huamaní. Ricky Vilcachagua Mosquera. Shugeily Pérez Campos. Boris Ortega Lescano.

Un agradecimiento especial a Isabel y a Jorge por participar desde el inicio hasta el final del proyecto, por todo el tiempo y esfuerzo dedicado. Gracias Jorge por verificar todos los programas desarrollados en Java. Deseo también hacer extensivo mi agradecimiento a todos los docentes que contribuyeron en el desarrollo del presente libro, a mi esposa Carmen por revisarlo y corregirlo, y a mi amigo Omar por diseñar la carátula. Finalmente, mi sincero agradecimiento a las autoridades de la Facultad de Ingeniería y Arquitectura (FIA) de la Universidad de San Martín de Porres (USMP), en especial al Ing. Raúl Bao García, Decano de la FIA, por todo el apoyo brindado durante el desarrollo del presente libro.

ÍNDICE PRESENTACIÓN. INDICE. PROLOGO. PREFACIO. CAPÍTULO I: Método de las 6’D. Un enfoque algorítmico. Introducción ........................................................................................................ Método de las 6’D ............................................................................................... Etapas y pasos ...................................................................................... Resumen del método ............................................................................. Resultado de las etapas del método ...................................................... Marco de trabajo ................................................................................................. Modelamiento ..................................................................................................... Algoritmo ............................................................................................................. Programación .....................................................................................................

25 27 28 35 36 37 39 45 54

CAPÍTULO II: Estructuras fundamentales para la solución de problemas. Introducción ........................................................................................................ 61 Estructuras de datos. Variables ................................................................................................ 63 Tipos de datos ....................................................................................... 66 Conversión de datos ……………………………………………………….. 71 Estructuras lógicas. Estructuras lógicas de secuencia. Estructuras para la salida de información ESCRIBIR .................. 75 Estructuras para la entrada de datos LEER ................................. 76 Estructuras para operaciones aritméticas y de cálculo ................ 78 Estructuras lógicas de decisión. Estructuras lógicas de decisión simple SI .................................... 80 Estructuras lógicas de decisión doble SI / SINO .......................... 82 Estructuras lógicas de decisión simple CUANDO ........................ 84 Estructuras lógicas de repetición. Estructuras lógica de repetición DESDE ...................................... 87 Estructuras lógica de repetición MIENTRAS ................................ 90 Estructuras lógica de repetición HACER ...................................... 93 Instrucciones de bifurcación .................................................................. 97 Mapa de estructuras lógicas detallado .................................................. 98 Método de las 6’D. Etapas y pasos ....................................................... 99 Problemas resueltos en general del 01 al 27 ........................................ 101 Manejo de excepciones ……………………………………………………………… 195 Problemas resueltos del 28 al 31 ………………………………………..... 198

Desarrollo de capacidades lógicas ..................................................................... 207 Problemas resueltos sobre figuras del 32 al 60 ..................................... 209

CAPÍTULO III: Clases básicas incorporadas en el lenguaje Java. Introducción ........................................................................................................ El paquete del lenguaje Java: java.lang ............................................................. Envoltorios de tipos de datos primitivos: wrappers. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 61 al 64 ........................................................... Funciones matemáticas: Clase Math. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 65 al 99 ........................................................... Manejo de cadenas: Clase String. Introducción ........................................................................................... Métodos ................................................................................................. Problemas resueltos del 100 al 130 ....................................................... Otras clases en Java. Problema resuelto 131 ...........................................................................

259 263 267 269 278 281 282 287 339 340 345 397

CAPÍTULO IV: Estructuras de datos arreglos. Introducción ........................................................................................................ Estructuras de datos: Arreglos. Definición ............................................................................................... Tipos ...................................................................................................... Ventajas y desventajas .......................................................................... Representación gráfica .......................................................................... Declaración, creación e inicialización de arreglos ….............................. Ingreso de datos a un arreglo ................................................................ Manejo de datos de un arreglo .............................................................. Desarrollo de soluciones básicas utilizando arreglos. Introducción ........................................................................................... Formalización de la solución utilizando el método de las 6’D ................ Problemas resueltos del 132 al 145 ....................................................... Desarrollo de soluciones utilizando múltiples arreglos. Arreglos paralelos .................................................................................. Problemas resueltos del 146 al 150 .......................................................

401 403 403 404 406 408 412 414 416 425 425 493 495

CAPÍTULO V: Introducción al Desarrollo de Soluciones Orientadas a Objetos. Introducción ........................................................................................................ Conceptos básicos. Clase ……............................................................................................... Objeto ……............................................................................................. Atributo …………………......................................................................... Método ………………….......................................................................... Métodos que no devuelven valor y no reciben parámetros ...... Métodos que devuelven valor y no reciben parámetros …........ Métodos que no devuelven valor y reciben parámetros …….... Método constructor ………………………………………………... Ocultar atributos de instancia ……………………………………………… Ingreso de datos a través del teclado …………………………………….. Método de las 6’D. Etapas y pasos …………...................................................... Problema resuelto 151 ........................................................................... Otros conceptos ………………………………………………………………………

527 532 534 535 542 544 547 550 554 556 559 561 563 569

APÉNDICE. Problemas propuestos ……………………………………………………... 573 Clase Lectura ......................................................................................... 603 Otras clases Java. DecimalFormat, Calendar, GregorianCalendar, SimpleDateFormat ...................... 605 BIBLIOGRAFÍA ................................................................................................... 625

PRÓLOGO Quiero pensar que al aceptar el grato pedido de Juan José Flores Cueto para prologar su nuevo libro estoy compartiendo o participando de alguna manera en el excelente trabajo que ha realizado para poner al alcance de estudiantes e informáticos un método para la solución de problemas utilizando una computadora. Al reflexionar sobre la tarea que representa escribir un prólogo para este libro, he reparado en lo difícil que resulta agregar valor al ya presentado por su contenido, pues el texto que mi joven amigo pone hoy a disposición de nuestros alumnos y también de profesionales de la especialidad de computación y sistemas, es resultado de la conjunción de varios factores: su experiencia académica, su desempeño profesional y la constante necesidad de estar actualizado. Escasamente un año atrás la Facultad de Ingeniería y Arquitectura de la USMP publicó el primer libro de J. J. Flores Cueto: Método para la solución de Problemas utilizando la Programación Orientada a Objetos y, una de las muchas razones del éxito obtenido por esa obra es que desarrolla una metodología para la solución de la gran cantidad de ejercicios, problemas y aplicaciones que contiene. Este novedoso método está conformado por seis etapas y cada una de ellas tiene una denominación que comienza con la letra D, lo que hace que estos seis pasos se puedan recordar fácilmente. Se tuvo en cuenta primordialmente al usuario y por ello, acertadamente, el método es llamado ahora método de las 6 D’s; pero es importante comprender que su uso puede extenderse a otros temas y a problemas con soluciones más complicadas y que para eso se tiene que redefinir algunos de los pasos de las etapas especificadas en el método. Comprobamos así, que la ópera prima de Juan José contenía, pues, ya el embrión de la segunda y de aquí, entonces, como consecuencia, el título del libro que hoy motiva estas líneas: Método de las 6’D: UML – Pseudocódigo – Java. (Un enfoque algorítmico). ¿Por qué la prisa en publicar esta segunda parte? Sabemos que lo más característico de la informática es su permanente dinámica, reflejada en la aparición de nuevos paradigmas que deben aplicarse rápidamente, pero cuya difusión en los textos no tiene la misma celeridad. El rápido avance de la ciencia y de la tecnología, que para muchos es agobiante, resulta estimulante para un espíritu como el de este prolífico docente de la USMP. El panorama de la ingeniería de computación y sistemas evoluciona y cambia mientras trabajamos en ella; al momento de aparecer su primer libro, nuestro autor sabía ya cuáles eran las nuevas tendencias que se perfilaban, acumulaba información y escribía sobre ellas, profundizando en el método de las 6 D’s para presentarnos en tan corto plazo una nueva obra. El mercado exige que los profesionales de Computación y Sistemas conozcan la últimas técnicas de programación e ingeniería de software y este libro responde a esas demandas introduciendo al estudiante en los conceptos de programación estructurada y en el dominio de la programación orientada a objetos, poniendo énfasis en la solución de problemas y empleando a fondo las capacidades lógicas para el desarrollo de soluciones utilizando una computadora. A mi juicio, las características más importantes del texto se reflejan en su fácil lectura y en su orientación al estudiante; pero mejor aun: en el hecho de haber sido probado

con los alumnos, comprobando su progreso y teniendo en cuenta la definición del problema, una buena documentación y la planificación de soluciones por algoritmos. Por lo arriba expresado y, por la amistad que me une a Juan José, es para mí sumamente gratificante escribir estas apreciaciones sobre su segundo libro y le auguro nuevos aportes como ingeniero y como docente de la USMP.

Ing. José Antonio Chang Escobedo. RECTOR USMP.

PREFACIO Actualmente, existe una tendencia creciente en el uso de herramientas de desarrollo de software y lenguajes de programación orientados a objetos. También existen una serie de métodos que permiten definir los pasos que se tienen que desarrollar para solucionar problemas basados en una computadora. Estos pasos generalmente se desarrollan desde el planteamiento del problema, análisis del problema, diseño de la solución, hasta la codificación y prueba de la misma utilizando herramientas y lenguajes de programación. En este libro se utiliza y se profundiza en el Método de las 6’D, a través del cual se definen los pasos que se tienen que desarrollar para la solución de un problema utilizando una computadora, agrupados en seis etapas (Descripción del problema, Definición de la solución, Diseño de la solución, Desarrollo de la solución, Depuración y pruebas, y Documentación). Todos los nombres de las etapas del Método de las 6’D comienzan con la letra D (de ahí el nombre de método). Los conceptos y temas fundamentales, necesarios para el desarrollo de soluciones utilizando el Método de las 6’D y el desarrollo de sus capacidades lógicas, son tratados durante el desarrollo de los cinco capítulos que forman parte del presente libro. Capítulo I: Se desarrolla la parte teórico formal del método de las 6’D. Se describen sus etapas, así como los pasos y los resultados que se deben esperar de cada una de ellas. Es importante mencionar que, dependiendo de la forma de solucionar los problemas, se van agregando, eliminando o redefiniendo los pasos de algunas de las etapas del método. El método de las 6’D es interactivo e incremental y se puede utilizar la Ingeniería Reversa para actualizar los modelos a partir del código creado. En este capítulo, también se tratan los conceptos fundamentales sobre modelado y el lenguaje unificado de modelado UML, sobre Algoritmos y las herramientas de diseño conocidas como Diagrama de Flujo y Pseudocódigo, y sobre la programación utilizando el lenguaje de programación orientado a objetos Java. Capítulo II: Se desarrolla la estructura de datos más simple: la variable, y se complementa con el estudio de los tipos básicos de datos, la conversión de datos y la forma cómo son utilizados por las herramientas tratadas en el capítulo anterior.

En este capítulo, también se tratan las estructuras lógicas de secuencia, las estructuras lógicas de decisión, las estructuras lógicas de repetición, las instrucciones de bifurcación y el manejo de excepciones. Las estructuras de datos, las estructuras lógicas y las instrucciones de bifurcación son conceptos propios de la programación estructurada y son utilizadas por la programación orientada a objetos para la codificación de los métodos que forman parte de las clases. El manejo de excepciones es un concepto propio de la programación orientada a objetos y ofrece una forma de codificar programas con una mayor claridad y sencillez, separando explícitamente el código que maneja los errores del código básico de la aplicación. Se presentan 31 problemas desarrollados utilizando el método de las 6’D, problemas que se van complicando conforme se tratan y explican los conceptos fundamentales. También se presentan 30 problemas desarrollados sobre diferentes tipos de figuras geométricas, con la finalidad de mejorar el desarrollo de sus capacidades lógicas. Es importante que se analicen cada una de las soluciones, se intenten mejorarlas y se desarrollen cada uno de los problemas propuestos incluyendo las variaciones planteadas. Capítulo III: Se desarrollan los conceptos fundamentales sobre las clases básicas incorporadas en el paquete java.lang del lenguaje de programación Java. Se tratan los conceptos fundamentales sobre el paquete del lenguaje, el paquete java.lang, las clases wrappers (envoltorios), la clase Math y la clase String. Las clases Wrappers, son un complemento de los tipos de datos primitivos y proporcionan métodos para realizar diferentes tareas con los tipos de datos primitivos, tales como la conversión con cadenas de caracteres, comprobación, traslación, entre otras. Se presentan 5 problemas codificados en Java para mejorar la comprensión del tema. La clase Math, proporciona métodos y atributos para implementar diversas funciones matemáticas. La clase Math contiene métodos de cálculo básico como exponencial, logaritmo, raíz cuadrada y funciones trigonométricas. Se presentan 35 problemas codificados en Java para mejorar la comprensión del tema. La clase String, permite declarar y manipular variables de tipo texto o cadena (en realidad no se declaran variables de tipo texto o cadena, sino que se crean objetos de la clase String). La clase String contiene métodos que permiten examinar los caracteres de una cadena para compararlos, ubicarlos, extraerlos como subcadenas, crear copias de

una cadena convirtiendo todos sus caracteres a letra mayúscula o minúscula, entre otras. Se presentan 30 problemas codificados en Java para mejorar la comprensión del tema. También se hace una referencia a otras clases en Java que el lector puede explorar. En el apéndice se incluyen otras clases Java, tales como las clases DecimalFomat, Calendar, GregorianCalendar y SimpleDateFormat. Capítulo IV: Se desarrolla la estructura de datos conocida como arreglos (arrays), su definición, tipos, representación gráfica, declaración, creación y su inicialización. En base al marco teórico se desarrollan soluciones para el ingreso, visualización y cálculo de datos contenido en los arreglos, formalizando el método de las 6’D para el adecuado manejo de los mismos. Se presentan 14 problemas desarrollados, utilizando el método de las 6’D para mejorar la comprensión del tema. Finalmente, se presentan los conceptos fundamentales sobre el manejo de arreglos múltiples (arreglos en paralelos) y se desarrollan 5 problemas utilizando el método de las 6’D. Capítulo V: Se desarrolla una introducción al desarrollo de soluciones orientadas a objetos. Se tratan los conceptos básicos fundamentales sobre las clases, objetos, atributos, métodos y ocultamiento de atributos de instancia. Conforme se presenta cada uno de los conceptos mencionados, se va modificando un proyecto desarrollado en Java para que se pueda analizar como se utiliza el concepto tratado en un lenguaje de programación orientado a objetos. Al final de este capítulo, se formaliza el método de las 6’D, redefiniendo algunos de sus pasos para poder ajustar el método a este tipo de soluciones. Es importante comentar que el presente capítulo, fue el primero en ser desarrollado. A pesar de ello, se consideró no incluirlo en el presente texto, pero faltando unos días para la entrega oficial de todo el material que conformaba el presente libro fue incluido. Finalmente, considero una buena decisión que se incluyera el presente capítulo. Estoy seguro que el lector estará de acuerdo conmigo.

Como se puede apreciar, se profundiza en el Método de las 6’D. Es importante comprender que se puede extender el uso del método a otros temas y a problemas con soluciones mucho más complicadas. Sólo se tendrá que redefinir algunos de los pasos de las etapas especificadas en el método. Por otro lado, también se tratan conceptos de la programación estructurada y fundamentos de programación orientada a objetos, los cuales permiten sentar las bases modernas para la programación, necesarias para el desarrollo de soluciones utilizando una computadora. Los temas desarrollados a través de los 5 capítulos que forman parte de esta obra, pueden ser utilizados de diferente manera de acuerdo a la experiencia de cada persona. Es importante indicar que el lector tendrá un mejor entendimiento del método empleado en la solución de los problemas y de todos los conceptos tratados, conforme avance con el entendimiento de los problemas resueltos y el desarrollo de los problemas propuestos.

Ing. Juan José Flores Cueto.

Capítulo MÉTODO DE LAS 6’D Un Enfoque Algorítmico

Temas: Introducción. Método de las 6’D: • Etapas y pasos. • Resumen del método. • Resultado de las etapas del método.

Marco de trabajo. Modelamiento. Algoritmo. Programación.

1

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

CAPÍTULO I MÉTODO DE LAS 6’D Un Enfoque Algorítmico INTRODUCCIÓN Durante el transcurso de nuestra vida nos enfrentamos a diversos problemas. Algunos de ellos podemos solucionarlos fácilmente, mientras que otros se complican de tal forma que nos afectan de una manera muy profunda. Algunos problemas, por su naturaleza, pueden ser resueltos utilizando una computadora. Estos problemas generalmente son de tipo estructurado, es decir, tienen una solución determinada y pueden ser desde muy sencillos hasta muy complejos. Para resolver problemas estructurados utilizando la computadora es importante utilizar un método. Este método debe ser fácil de comprender y nos debe guiar paso a paso hasta la solución del problema. El método propuesto y utilizado en el presente texto es el Método de las 6’D, que está compuesto de seis etapas, cada una de las cuales consta de una serie de pasos, los cuales se van modificando (ajustando) dependiendo del grado de complejidad del problema y las herramientas que se utilicen para su solución. Con la finalidad de recordar el método, se ha definido que el nombre de cada una de las etapas del método comience con la misma letra, la letra “D”. Es decir, el método tiene seis etapas y el nombre de cada una de las etapas comienza con la letra “D”, de modo que este se pueda recordar como el Método de las 6’D.

Pag. 25

Ing. Juan José Flores Cueto.

Pag. 26

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

MÉTODO DE LAS 6’D En la siguiente figura se muestra el Método de las 6’D con sus respectivas etapas:

Etapa 01 Descripción Problema

Etapa 02 Definición Solución

n veces

Etapa 03 Diseño Solución

Ingeniería Reversa Etapa 04 Desarrollo Solución

Etapa 05 Depuración Pruebas

Etapa 06 Document.

Pag. 27

Ing. Juan José Flores Cueto.

ETAPAS Y PASOS METODO 6’D. Descripción de la Etapa 01 – “Descripción del Problema”: Etapa 01 Descripción del Problema

En esta etapa, en primer lugar, es necesario identificar cual es el problema que se desea resolver. Esto que parece algo sumamente sencillo, muchas veces resulta una tarea agotadora ya que generalmente existen muchas opiniones de cual es el problema central. Identificarlo es una de las tareas más importante que los analistas deben afrontar. Identificado el problema es necesario poder comprenderlo en su totalidad, es decir, comprender qué es exactamente lo que se desea que se resuelva. Finalmente se deberá escribir un enunciado claro, concreto y conciso del problema a resolver. PASOS: ƒ ƒ ƒ

Identificación del problema. Descripción general del problema. Enunciado claro y preciso del problema.

ENUNCIADO

El resultado obtenido en esta etapa es un enunciado claro del problema que se desea solucionar.

Pag. 28

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

METODO 6’D. Descripción de la Etapa 02 – “Definición de la Solución”: Etapa 02 Definición de la Solución

En esta etapa, es necesario estudiar a fondo el problema para poder solucionarlo, saber exactamente en qué consiste y poder descomponerlo en cada una de sus partes para facilitar su comprensión y posterior solución. Esta es una regla que siempre deberá ser aplicada se utilice o no una computadora en la solución de un problema. Una vez entendido el problema, se está en condiciones de estudiarlo a fondo y plantear diversas alternativas que permitan solucionar el problema, para finalmente, seleccionar la alternativa mas adecuada.

PASOS: ƒ ƒ ƒ

Definir el resultado deseado. Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. Determinar la forma en que los datos serán procesados para transformarlos en información.

ESPECIFICACIONES

El resultado obtenido en esta etapa son las especificaciones de lo que se debe hacer para solucionar el problema.

Pag. 29

Ing. Juan José Flores Cueto.

METODO 6’D. Descripción de la Etapa 03 – “Diseño de la Solución”: Etapa 03 Diseño de la Solución

Definida la solución, se procede a diseñar la lógica modelando y desarrollando algoritmos. Para el modelado de la solución del problema se utiliza el Lenguaje Unificado de Modelado (Unified Modeling Language, UML), el cual es una herramienta usada para describir clases, objetos y sus relaciones. Para el desarrollo de algoritmos se utiliza Pseudocódigos o Diagramas de Flujo (DF), los cuales son herramientas utilizadas para diseñar los algoritmos de los diferentes métodos de una clase. Finalizado el desarrollo de los algoritmos es necesario verificar si se ha incluido soluciones para todas las formas en que se presente el problema. A este tipo de prueba se le denomina “Prueba de escritorio”.

PASOS: ƒ ƒ

Definir un nombre para el proyecto. Definición de diagramas, relaciones y clases.

ƒ

Desarrollo de Algoritmos.

DIAGRAMAS Y ALGORITMOS

El resultado obtenido en esta etapa son los diagramas y los algoritmos que especifican cómo se debe hacer para solucionar el problema.

Pag. 30

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

METODO 6’D. Descripción de la Etapa 04 – “Desarrollo de la Solución”: Etapa 04 Desarrollo de la Solución

Una vez previstas todas las posibilidades y alternativas que puedan presentarse y que pasen sin inconvenientes por la clase y los algoritmos, se podrá proceder a la codificación del problema en algún lenguaje de programación. La codificación involucra traducir los diagramas, las especificaciones de las clases (expresadas en notación UML), y los pasos del algoritmo de cada método (expresado en DF o pseudocódigo), en sentencias de un lenguaje de programación determinado. Estas sentencias son almacenadas en un proyecto (o archivo) lógico, y constituyen lo que la computadora podrá ejecutar. PASOS: ƒ

Codificar el proyecto.

ƒ

Desarrollar comentarios internos en los programas de computadora. Desarrollar copias de seguridad de los programas de computadora.

ƒ

PROGRAMAS

El resultado obtenido en esta etapa son los programas y/o clases, codificados en un lenguaje de programación, que permiten solucionar el problema.

Pag. 31

Ing. Juan José Flores Cueto.

METODO 6’D. Descripción de la Etapa 05 – “Depuración y Pruebas”: Etapa 05 Depuración y Pruebas

Luego que se codifiquen los programas y/o clases, deben ser probados mediante la ejecución de los mismos (esto es conocido como corrida del programa). Al realizarse ésta, pueden surgir diferentes tipos de errores, siendo los errores de lógica y sintaxis los más comunes. Hay que corregir el programa; anular, modificar o crear nuevas sentencias, volver a probar el programa y continuar con la corrección y pruebas hasta conseguir el resultado deseado. PASOS: ƒ ƒ ƒ

Realizar la depuración y verificar la correcta escritura de los programas. Realizar pruebas de sintaxis. Realizar pruebas de lógica.

PRUEBAS

El resultado obtenido en esta etapa son las pruebas que registran el adecuado funcionamiento de la solución del problema.

Pag. 32

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

METODO 6’D. Descripción de la Etapa 06 – “Documentación”: Etapa 06 Documentación

En esta etapa se recopila toda la documentación generada en las etapas anteriores, la cual va a servir como base para la elaboración del manual técnico. Dedicarle tiempo a esta etapa nos ayudará a desarrollar buenos hábitos, los cuales serán necesarios cuando se desarrolle software en forma profesional. El manual técnico debe incluir, como mínimo: -

-

Descripción del problema. Resultados esperados y datos necesarios para generar dichos resultados. Diagramas UML, DF y/o Pseudocódigo. Pruebas desarrolladas. Listado de programas con comentarios internos.

PASOS: ƒ ƒ ƒ

Recopilar el material generado en cada una de las etapas anteriores. Generar el manual del programa. Generar el manual del usuario.

Manuales

El resultado obtenido en esta etapa son los manuales que permiten un adecuado manejo de la solución desarrollada.

Pag. 33

Ing. Juan José Flores Cueto.

METODO 6’D. Adicionalmente es posible realizar “Ingeniería Reversa” entre las Etapas 03, 04 y 05:

Ingeniería Reversa

n veces

Es decir, a través de la Ingeniería Reversa es posible programar o codificar algunas partes (hasta su correcto funcionamiento) que no estén especificadas en la Etapa 03 “Diseño de la Solución”. A partir de esta solución se actualizan los diagramas de la Etapa 03 y se continúa con el proceso hasta llegar a la solución deseada.

Etapa 03 Diseño Solución

Etapa 04 Desarrollo Solución

La ingeniería reversa nos permite crear o actualizar el modelo preliminar realizado en la ETAPA 03 “Diseño de la solución” a partir del código del programa realizado en la ETAPA 04 “Desarrollo de la solución” y corregido en la ETAPA 05 “Depuración y pruebas”.

PASOS:

Etapa 05

•

Depuración Pruebas

• •

Exportar proyecto (archivos class o java) al disco de la PC, si está trabajando con un IDE. Importar proyecto (archivos class o java) a una herramienta CASE y realizar la ingeniería reversa. Organizar el modelo obtenido en la herramienta CASE.

DIAGRAMAS ACTUALIZADOS

Pag. 34

Definición Solución

ƒ Definir el resultado deseado. ƒ Determinar los datos que se deben ingresar o generar para obtener el resultado deseado. ƒ Determinar la forma en que los datos serán procesados para transformarlos en información.

ƒ Identificación del problema. ƒ Descripción general del problema. ƒ Enunciado claro y preciso del problema.

Etapa 02

Descripción Problema

Etapa 01

ƒ Definir un nombre para el proyecto. ƒ Definición de diagramas, relaciones y clases. ƒ Desarrollo de Algoritmos.

Pag. 35

Etapa 03 Diseño Solución

Resumen de las etapas y los pasos del método:

METODO 6’D.

RESUMEN DEL MÉTODO

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

ƒ Codificar proyecto. ƒ Desarrollar comentarios internos en programas computadora. ƒ Desarrollar copias seguridad de programas computadora.

Desarrollo Solución

de los de

los de

el

Etapa 04

ƒ Realizar la depuración y verificar la correcta escritura de los programas. ƒ Realizar pruebas de sintaxis. ƒ Realizar pruebas de lógica.

Depuración Pruebas

Etapa 05

ƒ Recopilar el material generado en cada una de las etapas anteriores. ƒ Generar el manual del programa. ƒ Generar el manual del usuario.

Document.

Etapa 06

Definición Solución

ESPECIFICACIONES

ENUNCIADO

Etapa 02

Descripción Problema

Etapa 01

Resultado de las etapas del Método:

METODO 6’D.

RESULTADO DE LAS ETAPAS DEL MÉTODO

Desarrollo Solución

PROGRAMAS

DIAGRAMAS Y ALGORITMOS

Etapa 04

Diseño Solución

Pag. 36

Etapa 03

PRUEBAS

Depuración Pruebas

Etapa 05

Manuales

Document.

Etapa 06

Ing. Juan José Flores Cueto.

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

MARCO DE TRABAJO En el presente texto se solucionarán problemas sencillos utilizando el Método de las 6’D. La solución de los problemas comenzará con el enunciado del problema y luego se desarrollará la etapa 02 (“Definición de la solución”), etapa 03 (“Diseño de la solución”) y etapa 04 (“Desarrollo de la solución”), es decir, solo se desarrollarán las tres etapas del método que son posibles especificar en el presente texto. La etapa 05 (“Depuración y pruebas”) se desarrolla directamente en un lenguaje de programación y la etapa 06 (“Documentación”) es la recopilación del material y la elaboración de los manuales respectivos. Etapa 01 Descripción Problema

ENUNCIADO Etapa 02 Definición Solución

MARCO DE TRABAJO

Etapa 03 Diseño Solución

Etapa 04 Desarrollo Solución

Pag. 37

Ing. Juan José Flores Cueto.

Es importante precisar que en la primera parte del capítulo II, en el capítulo IV y en el capítulo V del presente texto, se solucionan los problemas utilizando el marco de trabajo especificado, mientras que en la segunda parte del capítulo II y el capítulo III, solo se desarrolla la etapa 04 (“Desarrollo de la solución”), con la finalidad de resolver una mayor cantidad de problemas y profundizar en la codificación utilizando el lenguaje de programación Java. Para poder solucionar problemas sencillos utilizando el Método de las 6’D, es necesario conocer los conceptos fundamentales de modelamiento, algoritmo y programación, y dominar el uso de las estructuras lógicas, instrucciones o sentencias de bifurcación y las estructuras de datos. Este tipo de soluciones son el objetivo del presente texto. También es posible plantear soluciones más complejas utilizando el Método de las 6’D. Para ello se tendría que dominar otros conceptos, tales como, Objetos, Métodos, Encapsulamiento, Herencia, Polimorfismo, Interfaces Gráficas, Conexión a Base de Datos, Servlets entre otros. Es importante mencionar, que dependiendo de la complejidad del problema, los pasos especificados en cada una de las etapas del método se pueden redefinir (modificar). Esto significa, que dependiendo de la complejidad del problema y de su solución, se puede plantear nuevos pasos y eliminar pasos ya existentes en las diferentes etapas del método.

Pag. 38

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

MODELAMIENTO El modelamiento se refiere a la forma como se representa la solución de un problema del mundo real en términos de un modelo. Un modelo es una representación gráfica o simbólica de algún aspecto del mundo real, que está bajo observación o estudio. Para representar un modelo se utilizará el UML (Unified Modeling Language). El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que nos permite: • • • • •

Visualizar un modelo. Especificar un modelo (construir modelos precisos, no ambiguos). Construir un modelo en un lenguaje de programación (se establecen correspondencias con lenguajes Orientados a Objetos, como Java, C++, Visual Basic...). Documentar los componentes de un sistema de software (arquitectura, requisitos, diseño, pruebas, versiones, planificación...). Describir el ciclo de vida completo del desarrollo Orientado a Objetos.

Para desarrollar un modelo y representarlo en UML, es necesario conocer todos los conceptos relacionados con el desarrollo de Software Orientado a Objetos. Para nuestro propósito, se detallarán algunos conceptos básicos que serán utilizados en las soluciones planteadas en el presente texto. ƒ

Paquete.- Los paquetes nos permiten organizar las clases de un modelo. Un paquete contiene clases que tienen funciones similares. En UML, un paquete se representa de la siguiente forma:

NombrePaquete

ƒ

Nombre del paquete.

Clase.- Una clase, es simplemente, un modelo que se utiliza para describir uno o más objetos del mismo tipo. En su forma más sencilla, una clase es un conjunto de atributos y métodos. Una clase es una abstracción y no

Pag. 39

Ing. Juan José Flores Cueto.

representa a ningún objeto en particular. En UML, una clase se representa de la siguiente forma: Nombre de la clase y del paquete al cual pertenece la clase.

NombreClase (NombrePaquete al que pertenece)

ƒ

Atributos

Lista de atributos de la clase.

Métodos

Lista de métodos de la clase.

Objeto.- Un objeto es cualquier cosa, real o abstracta, acerca de la cual almacenamos datos y los métodos que controlan y manipulan dichos datos. Un objeto se crea o instancia a partir de una clase, En UML, un objeto se representa de la siguiente forma:

Nombre de la clase a la cual pertenece el objeto y el nombre del objeto. Ambos nombres deben estar separados por dos puntos.

NombreClase : nombreObjeto

UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas, los cuales se muestran a continuación:

Diagramas de Secuencia

Diagramas de Casos de Uso

Diagramas de Clase Paquete

Diagramas de Componentes

Diagramas de Colaboración

Modelo Diagramas de Estado

Diagramas de Objeto

Diagramas de Actividad

Pag. 40

Diagramas de Distribución

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

Para nuestro propósito, se detallará el diagrama de paquetes que será utilizado en las soluciones planteadas en el presente texto. ƒ

Diagrama de paquetes.- Un diagrama de paquetes permite especificar y visualizar las relaciones de dependencia que existe entre los paquetes que forman parte de una solución. Una relación de dependencia entre dos o más paquetes se establece cuando las clases que pertenecen a un paquete pueden tener acceso a todas o a algunas de las clases que pertenecen a otro paquete (dependencia unidireccional). También se puede establecer una relación de dependencia bidireccional cuando las clases que pertenecen a un paquete pueden tener acceso a todas o a algunas de las clases que pertenecen a otro paquete y viceversa. En UML, una relación de dependencia unidireccional entre dos paquetes se gráfica de la siguiente manera:

Relación de dependencia unidireccional.

La dependencia en este caso significa que todas las clases que pertenecen al paquete “dominioDeLaAplicacion” podrán tener acceso a todas o algunas de las clases que pertenecen al paquete “biblioteca” (observe el sentido de la flecha que marca la dependencia unidireccional).

Pag. 41

Ing. Juan José Flores Cueto.

En el Método de las 6’D, el modelamiento de una solución se desarrolla durante la Etapa 03 - “Diseño de la solución”: Etapa 03 Diseño Solución

Se desarrollan los siguientes pasos: ƒ Definir un nombre para el proyecto. La definición del nombre del proyecto, permite agrupar a todos los elementos que serán parte de la solución del problema utilizando el método planteado. El nombre del proyecto comenzará con las letras “Proy” (abreviatura de proyecto), seguido de un nombre que identifique al proyecto. Este nombre debe ser seleccionado adecuadamente. ƒ Definición de diagramas, relaciones y clases. En este paso se desarrollará el diagrama de paquetes y se especificará la relación de dependencia entre los paquetes utilizando UML. Para nuestros fines se crearán dos paquetes en las soluciones. Uno de ellos lo se llamará “dominioDeLaAplicación” y el otro “biblioteca”, y se establecerá una relación de dependencia unidireccional del primero hacia el segundo. En el paquete “dominioDeLaAplicacion”, se definirá la clase que permitirá solucionar el problema planteado utilizando UML. El nombre de la clase comenzará con las letras “Prg” (abreviatura de programa), seguido de un nombre que identifique a la clase. Este nombre debe ser seleccionado adecuadamente. Dicha clase no tendrá ningún atributo definido y solo se definirá un método (el método principal).

Pag. 42

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

En el paquete “biblioteca”, se tendrá clase Lectura1 que facilitará el ingreso de los datos a la computadora.

Regla general para especificar los nombres de los paquetes, clases, atributos y métodos: El nombre de la clase y el nombre del paquete deben comenzar con una letra mayúscula y el resto en minúscula. Si el nombre es compuesto, todas las primeras letras de los nombres simples que forman el nombre de la clase o paquete deberán comenzar con mayúscula. Los nombres de los atributos se escriben en minúscula. En caso que el nombre sea compuesto, a partir de la segunda palabra se escribe la primera letra en mayúscula. Los nombres de los métodos cumplen las mismas características que los nombres de atributos a excepción de los métodos constructores.

1

La clase Lectura se trata en el Capítulo II y se especifica en el Apéndice.

Pag. 43

Ing. Juan José Flores Cueto.

Pag. 44

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

ALGORITMO Una clase, en su forma más simple, está constituida por atributos y métodos. Los métodos representan pequeños subprogramas encapsulados dentro de las clases y contribuyen a definir el comportamiento típico de los objetos. Para especificar cuáles son los pasos desarrollados en un determinado método y cuáles son los datos que manejan dichos pasos se desarrollan los algoritmos. Un algoritmo constituye una lista completa de los pasos y una descripción de los datos que son necesarios para resolver un determinado problema en el ámbito de un método. De esto, se deriva que un algoritmo se desarrolla para un determinado método y que su definición tiene dos partes esenciales: ƒ

Una lista de pasos que deben ser ejecutados.

ƒ

Una descripción de los datos que son manipulados por estos pasos.

CARACTERÍSTICAS ƒ

Descripción de los pasos que deben ser ejecutados (estructuras lógicas).

ƒ

Descripción de los datos que son manipulados por estos pasos (estructuras de datos).

ƒ

Un algoritmo debe ser preciso, indicando el orden de realización de cada paso.

ƒ

Todo algoritmo debe ser finito. Si se sigue un algoritmo, éste debe terminar en algún momento.

ƒ

Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo resultado.

ƒ

Un algoritmo puede o no tener datos de entrada.

ƒ

Un algoritmo producirá uno o más datos de salida.

Pag. 45

Ing. Juan José Flores Cueto.

ƒ

Los datos de entrada y salida deben almacenarse en estructuras de datos.

ƒ

El resultado que se obtenga debe satisfacer los requerimientos de la persona interesada (efectividad).

ƒ

Debe ser estructurado. Es decir, debe ser fácil de leer, entender, usar y cambiar si es preciso.

En conclusión, los algoritmos permiten especificar la lógica de desarrollo de los métodos que conforman una clase. Por lo tanto, se debe entender la importancia de estudiar los “algoritmos” para comprender como se está solucionando un determinado problema.

Se dispone de diversas herramientas para desarrollar los algoritmos para los métodos de las clases. Entre dichas herramientas se puede mencionar al pseudocódigo y al diagrama de flujo. HERRAMIENTAS ƒ

PSEUDOCODIGO Un pseudocódigo permite expresar un algoritmo con palabras en castellano que son semejantes a las sentencias de un lenguaje de programación. Pautas básicas: ‰

‰ ‰

‰

Todo algoritmo debe tener un nombre, el cual deberá comenzar con una letra mayúscula. Si es un nombre compuesto, la primera letra de cada palabra simple deberá estar en mayúscula. No se permiten los espacios en blanco en el nombre del algoritmo (generalmente se utilizará el nombre de la clase y el nombre del método para referirse a un determinado algoritmo). Es necesario que se determinen los datos de entrada y la información de salida. Para declarar una variable “x” se deberá determinar qué tipo de dato se almacenará. Por ejemplo. Si se desea declarar una variable de tipo texto se realizaría de la siguiente manera: TEXTO x. Para asignar un valor a una variable “x” se utiliza el signo igual. Por ejemplo, si se desea asignar 5 a la variable “x” se realizará de la siguiente manera: x = 5.

Pag. 46

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

‰ ‰

Para indicar que la computadora lea un valor desde un dispositivo externo y lo almacene en la variable “z”, se utiliza: LEER z. Para indicar que la computadora escriba hacia un dispositivo externo: ‰ Para escribir un mensaje (observe que el mensaje está entre comillas) se utiliza: ESCRIBIR “hola”. ‰ Para escribir el valor de una variable (observe que la variable no está entre comillas) se utiliza: ESCRIBIR x. ‰ Para escribir el resultado de una expresión (observe que la expresión no está entre comillas) se utiliza: ESCRIBIR x + 2.

Estructura básica de un pseudocódigo: Algoritmo NombreClase – nombreMetodo() ENTRADA: SALIDA:

En ENTRADA y SALIDA se especifican las variables que se usarán en el desarrollo del algoritmo.

INICIO … … … …

Este es el cuerpo del algoritmo expresado en pseudocódigo. Las instrucciones se colocan entre INICIO... FIN.

FIN

ƒ

DIAGRAMA DE FLUJO Un Diagrama de Flujo permite ilustrar la secuencia de pasos de un algoritmo por medio de símbolos especializados y líneas de flujo. La combinación de símbolos especializados y líneas de flujo describe la lógica para la solución del problema (algoritmo). Entonces, se puede afirmar que el Diagrama de Flujo es la representación gráfica de un algoritmo.

FLUJO Porque muestra la secuencia de lo que se tiene que realizar.

DIAGRAMA Por el hecho de ser un dibujo que no requiere estar a escala.

Pag. 47

Ing. Juan José Flores Cueto.

Elementos o símbolos básicos:

PROCESO Utilizado para asignar valores a variables y resultados de operaciones matemáticas.

ENTRADA / SALIDA Utilizado para ingresar datos y visualizar información que resulta del procesamiento.

la

INICIO / FIN Este símbolo permite marcar el inicio y el final del algoritmo.

CONECTOR Este símbolo permite que no se crucen los flujos (líneas) en un diagrama.

FLUJOS (LINEAS) Líneas que permiten unir los diagramas y mostrar la secuencia lógica a la solución del problema.

Pag. 48

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

ƒ

REGLAS UTILIZADAS POR LAS HERRAMIENTAS Con la finalidad de comprender mejor el diseño de los algoritmos, desarrollados en pseudocódigo y diagrama de flujo, se han clasificado en 6 grupos las reglas definidas. REGLA

FORMATO

DESCRIPCIÓN GRUPO 1

Utilizada para el ingreso de datos. El dato ingresado se almacena en la variable especificada.

LEER

LEER x

ESCRIBIR

ESCRIBIR “Hola” ESCRIBIR x ESCRIBIR x + z

Utilizada para la salida de información. Se puede visualizar una cadena, el contenido de una variable o el resultado de una operación matemática.

COMENTARIO

COMENTARIO “Variables”

Utilizada para realizar comentarios internos en la codificación de las soluciones.

NUMERO

NUMERO x

Permite declarar una variable de tipo numérico.

TEXTO

TEXTO mensaje

Permite declarar una variable de tipo texto o cadena.

CARACTER

CARACTER letra

Permite declarar a una variable de tipo texto o cadena de una sola letra.

LÓGICO

LÓGICO aprobado

Permite declarar una variable de tipo lógico.

VERDADERO

aprobado = VERDADERO

Permite asignar el valor VERDADERO a una variable lógica.

FALSO

aprobado = FALSO

Permite asignar el valor FALSO a una variable lógica.

GRUPO 2

SI

SI (condición) ENTONCES instrucciones... FINSI

Pag. 49

Permite especificar una estructura de decisión simple “SI... FINSI”. Las estructuras lógicas serán tratadas en el capítulo II.

Ing. Juan José Flores Cueto.

REGLA

FORMATO

SI / SINO

SI (condición) ENTONCES instrucciones... SINO instrucciones... FINSI

Permite especificar una estructura de decisión doble “SI... SINO... FINSI”. Las estructuras lógicas serán tratadas en el capítulo II.

CUANDO (variable) SEA CASO (valor 1) : instrucciones...

Permite especificar una estructura de decisión múltiple “CUANDO... FINCUANDO”.

CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones.. FINCUANDO

Las estructuras lógicas serán tratadas en el capítulo II.

CUANDO

DESCRIPCIÓN

DESDE

DESDE i = valorInicial HASTA valorFinal instrucción 1 . . . instrucción n FINDESDE

Permite especificar una estructura de repetición “DESDE... FINDESDE”. Las estructuras lógicas serán tratadas en el capítulo II.

MIENTRAS

MIENTRAS (condición) instrucción 1 . . . instrucción n FINMIENTRAS

Permite especificar una estructura de repetición “MIENTRAS...FINMIENTRAS”. Las estructuras lógicas serán tratadas en el capítulo II.

HACER

HACER instrucción 1 . . . instrucción n MIENTRAS (condición)

Permite especificar una estructura de repetición “HACER...FINHACER”. Las estructuras lógicas serán tratadas en el capítulo II.

TERMINAR

TERMINAR

CONTINUAR

Permite terminar la ejecución de una estructura lógica de repetición.

CONTINUAR

Pag. 50

Permite volver a ejecutar una estructura lógica de repetición sin finalizar todas las instrucciones que forman parte de la misma.

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

REGLA

FORMATO

DESCRIPCIÓN GRUPO 3

COSENO

x = COSENO n

SENO

x = SENO n

Permite obtener el coseno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

Permite obtener el seno del valor almacenado en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

LONGITUD

x = LONGITUD n

Permite obtener la longitud de la cadena almacenada en la variable “n” o la longitud del vector “n”. El resultado se almacena en la variable “x”. Ver capítulo III y capítulo IV.

FILA

x = FILA n

Permite obtener el número de filas de una matriz “n”. El resultado se almacena en la variable “x”.

COLUMNA

x = COLUMNA n

Permite obtener el número de columnas de una matriz “n”. El resultado se almacena en la variable “x”.

MAYÚSCULA

x = MAYÚSCULA n

Permite cambiar a mayúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

MINUSCULA

x = MINUSCULA n

Permite cambiar a minúscula la cadena almacenada en la variable “n”. El resultado se almacena en la variable “x”. Ver capítulo III.

GRUPO 4

RESTO

x = z RESTO n

Permite obtener el resto de la división entre las variables “z” y “n”. El resultado se almacena en la variable “x”.

DIVIDIR

x = z DIVIDIR n

Permite obtener la parte entera de la división de las variables “z” y “n”. El resultado se almacena en la variable “x”.

RAIZ

x = z RAIZ n

Permite obtener la raíz “n” del número “z”. El resultado se almacena en la variable “x”.

Pag. 51

Ing. Juan José Flores Cueto.

REGLA

FORMATO

POTENCIA

x = z POTENCIA n

Permite obtener la potencia “n” del número “z”. El resultado se almacena en la variable “x”.

MAXIMO

x = z MAXIMO n

Permite obtener el número mayor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

MINIMO

x = z MINIMO n

Permite obtener el número menor entre el valor almacenado en la variable “n” y la variable “z”. El resultado se almacena en la variable “x”.

CARACTER

x = z CARACTER n

Permite obtener el carácter ubicado en la posición “n” de la cadena “z”. El resultado se almacena en la variable “x”.

x = z ALEATORIO n

Permite obtener un número cualquiera (aleatorio) entre los valores de “n” y “z”. El resultado se almacena en la variable “x”.

ALEATORIO

DESCRIPCIÓN

GRUPO 5

SUBCADENA

x = z SUBCADENA n1, n2

ELIMINAESPACIO x = z ELIMINAESPACIO n1, n2

Permite obtener una subcadena comprendida entre las posiciones especificadas por “n1” y “n2” de la cadena “z”. El resultado se almacena en la variable “x”.

Permite eliminar los espacios existentes en una cadena entre las posiciones especificadas por “n1” y “n2”. El resultado se almacena en la variable “x”.

GRUPO 6

CREAR

CREAR vector[n] CREAR matriz[n1][n2]

Utilizada para crear arreglos previamente declarados. Un arreglo permite almacenar más de un dato del mismo tipo. Los arreglos serán tratados en el capítulo IV.

CREAR

CREAR objeto

Permite crear un determinada clase

EJECUTAR

EJECUTAR algoritmo

Permite ejecutar otro algoritmo.

Pag. 52

objeto

de

una

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

REGLA

FORMATO

DESCRIPCIÓN

PARAMETRO

PARAMETRO listaVariables

Permite especificar si un algoritmo recibe datos o valores.

RETORNAR

RETORNAR variable

Permite especificar si retorna una respuesta.

un

algoritmo

En el Método de las 6’D, el algoritmo de una solución se desarrolla después del modelamiento, durante la Etapa 03 - “Diseño de la solución”: Etapa 03 Diseño Solución

Se desarrollará el siguiente paso: ƒ Desarrollo de algoritmos. En este paso, se desarrollará el algoritmo para el método especificado en la clase, la cual forma parte del paquete “dominioDeLaAplicación”. Para el desarrollo del algoritmo se utilizará pseudocódigo.

Pag. 53

Ing. Juan José Flores Cueto.

PROGRAMACIÓN La programación es la traducción del modelamiento y los algoritmos en sentencias que la computadora puede comprender y ejecutar. En términos sencillos. Se puede decir, que la programación es la acción de escribir programas para una computadora, utilizando alguno de los lenguajes de programación existentes. La acción de escribir programas para una computadora se conoce como codificación. Las personas que escriben los programas son conocidas como programadores, los cuales están divididos en categorías según su experiencia y dominio de diferentes lenguajes de programación. Entonces, un lenguaje de programación es un lenguaje que los programadores utilizan para escribir programas que son comprendidos y ejecutados en una computadora. Nos “comunicamos” con las computadoras a través de los programas desarrollados en un lenguaje de programación en particular. Existen diferentes lenguajes de programación, la mayor parte de los cuales tienen un conjunto de reglas o sentencias muy especializadas.

La forma de programación ha variado con el paso de los años. Al inicio, se desarrolló la programación lineal, luego la programación modular, después la programación estructurada y ahora la programación orientada a objetos. Entre los lenguajes de programación orientados a objetos podemos destacar a Java. LENGUAJES DE PROGRAMACIÓN ƒ

JAVA Java es un lenguaje de programación orientado a objetos desarrollado por Sun MicroSystems, una compañía reconocida por sus estaciones de trabajo UNIX de alta calidad.

Pag. 54

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

Fundamentado en el lenguaje de programación C++, el lenguaje Java se diseñó para ser pequeño, sencillo y portátil a través de plataformas y sistemas operativos, tanto a nivel de código fuente como binario, lo que significa que los programas Java (applets, aplicaciones y servlets), pueden ejecutarse en cualquier computadora que tenga instalada una máquina virtual de Java. A pesar que Java es un lenguaje de programación orientado a objetos, también puede ser utilizado como un lenguaje estructurado, lo cual se hace necesario para poder iniciar el estudio de los conceptos fundamentales de programación.

Estructura básica de un programa desarrollado en Java:

package NombrePaquete; class NombreClase { public static void main ( String arg[ ] ) { … sentencias; …

Este es el cuerpo del programa en Java. Las sentencias se colocan dentro de los corchetes del método main ( ).

} }

En el lenguaje de programación Java, para definir que una clase forma parte de un paquete determinado, se utiliza la siguiente palabra reservada: package En el lenguaje de programación Java para definir una clase se utiliza la siguiente palabra reservada: class

Pag. 55

Ing. Juan José Flores Cueto.

Es importante comprender que una clase está constituida por atributos y métodos. Todo el código ejecutable reside dentro de los métodos de la clase. No existe código que no esté contenido dentro de un método (a excepción de los bloques estáticos). Existen clases que tienen un método especial conocido como “método principal”. Todas las clases que tienen especificado un “método principal”, son clases que pueden ejecutarse. En el lenguaje de programación Java, para especificar que una clase tiene un “método principal”, se utiliza las siguientes sentencias: public static void main (String arg[]) Por lo tanto, en el lenguaje de programación Java, el método principal es conocido como método main ( ).

Palabras reservadas en Java: Una palabra reservada o palabra clave, es aquella que tiene un significado especial para un lenguaje de programación. Todos los lenguajes tienen palabras claves. En el caso de Java tenemos las siguientes:

abstract byte char continue double final for implements int native package public static switch throw try while

Palabras reservadas en Java boolean catch case do class extends default float else if finally instanceof import long interface null new protected private short return super strictfp this synchronized transient throws volatile void widefp break

Pag. 56

MÉTODO DE LAS 6’D – Un Enfoque Algorítmico.

En la actualidad, la Programación Estructurada (PE) y la Programación Orientada a Objetos (POO) son las formas de programación utilizadas por la mayoría de los programadores, siendo la POO la más reciente y la que promete solucionar muchos de los problemas de la PE, incorporando nuevas características y nuevos conceptos. Una característica importante de la POO es que utiliza los mejores conceptos de la PE y de las otras formas de programación. En el Método de las 6’D, la programación de una solución se desarrolla durante la Etapa 04 - “Desarrollo de la solución”: Etapa 04 Desarrollo Solución

Se desarrollará solo el primer paso: ƒ Codificar el proyecto. En este paso, se desarrollará la codificación del proyecto. Es decir, utilizando el lenguaje de programación Java, se traducirá lo especificado en el modelamiento y en los algoritmos, en sentencias que la computadora pueda comprender y ejecutar.

Pag. 57

Ing. Juan José Flores Cueto.

Pag. 58

Capítulo Estructuras Fundamentales para la Solución de Problemas

2

Temas: Introducción. Estructuras de Datos: Variables • Tipos de datos. • Conversión de datos.

Estructuras Lógicas: • • • • •

Estructuras lógicas de secuencia. Estructuras lógicas de decisión. Estructuras lógicas de repetición. Instrucciones de bifurcación. Mapa de estructuras lógicas detallado.

Método de las 6´D. Etapas y pasos. Problemas resueltos en general y sobre figuras.

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

CAPÍTULO II ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCION DE PROBLEMAS INTRODUCCIÓN El modelamiento se refiere a la forma como representamos la solución de un problema del mundo real en términos de un modelo. Un algoritmo constituye una lista completa de los pasos y una descripción de los datos que son necesarios para resolver un determinado problema en el ámbito de un método. La lista completa de los pasos se desarrolla utilizando las estructuras lógicas y las instrucciones de bifurcación, mientras que los datos se almacenan en las estructuras de datos. La programación es la traducción del modelamiento y los algoritmos en sentencias que una computadora puede comprender y ejecutar. La acción de escribir un programa para computadoras se conoce como codificación.

MARCO DE TRABAJO ENUNCIADO DEL PROBLEMA Etapa 02 Definición Solución

Etapa 03 Diseño Solución

Etapa 04 Desarrollo Solución

Pag. 61

Ing. Juan José Flores Cueto.

LISTA DE PASOS

SENTENCIAS

DESCRIPCIÓN DE DATOS

DECLARACIÓN Y DEFINICIÓN DE DATOS

SE DESARROLLAN UTILIZANDO: • Estructuras lógicas de secuencia. • Estructuras lógicas de decisión. • Estructuras lógicas de repetición. • Instrucciones de bifucación. ALMACENADOS EN: • Estructuras de datos tipo variables.

El presente capítulo, trata sobre las estructuras fundamentales para la solución de problemas. Es importante mencionar que utilizando las estructuras fundamentales para la solución de problemas (estructuras lógicas, instrucciones de bifurcación y las estructuras de datos conocidas como variables), se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un lenguaje de programación. La técnica que se emplea en el presente texto para el ingreso de datos y visualización de la información, cada día se utiliza con menos frecuencia (técnica tradicional basada en el ingreso de datos y visualización de información utilizando solo caracteres). En su lugar, se utilizan las interfaces gráficas de usuario o GUI (por sus siglas en inglés), que incorporan ventanas, gráficos, colores y otros objetos que permiten una interface visual con el usuario. El lenguaje de programación Java incorpora un paquete denominado AWT (Abstract Windows Toolking) que contiene clases que permiten crear cualquier tipo de interfaces gráficas de usuarios o GUI (interfaces visuales). También incorpora un paquete llamado SWING (a partir de la versión 2 de Java), que facilita el ingreso y visualización de datos utilizando cuadros de dialogo visuales.

Pag. 62

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

ESTRUCTURAS DE DATOS VARIABLES Definición: Una variable es una estructura de datos que permite reservar un espacio con la finalidad de almacenar o guardar temporalmente los datos. Una variable sólo puede almacenar un dato a la vez. Si se necesita almacenar dos o tres datos, se requerirán dos o tres variables según sea el caso. Declaración de una variable: Declarar una variable significa definir el nombre de la variable y el tipo de dato que podrá almacenar. Generalmente se realiza al inicio de un programa. La declaración de una variable se debe realizar antes de que ésta pueda ser utilizada; esto es necesario en los diferentes lenguajes de programación, y Java no es la excepción. En pseudocódigo y diagrama de flujo: TipoDeDato ListaDeVariables En Java: TipoDeDato ListaDeVariables ; Donde TipoDeDato debe ser un tipo de variable o tipo de dato válido y ListaDeVariables puede tener uno o más nombres de variables separadas por comas. Nombre de variable: Siempre es necesario que las variables tengan un nombre para poder referirse a ellas en cualquier parte de un programa. El nombre de una variable deberá comenzar con una letra minúscula. Si el nombre de la variable está formado por varias palabras, se deberá escribir con mayúscula la primera letra de cada palabra, a partir de la segunda palabra que forme parte del nombre. No es válido que el nombre de una variable tenga espacios en blanco ni caracteres especiales (tales como /()=?¨^* etc). En pseudocódigo: Una variable no puede tener el nombre de una regla o pauta definida. (ejemplo: ESCRIBIR). En Java:

Pag. 63

Ing. Juan José Flores Cueto.

Una variable no puede tener el nombre de una palabra reservada. (Ejemplo: String). Se recomienda que el nombre a utilizar en las variables que se empleen, guarde relación con el valor que estas almacenan. Inicialización de una variable: Es posible que una variable sea definida con un valor inicial y que este valor posteriormente sea modificado. Es bueno definir con un valor inicial a todas las variables declaradas en el programa. En pseudocódigo y diagrama de flujo: TipoDeDato variable = valor En Java: TipoDeDato variable = valor ; Donde valor debe ser un valor equivalente al tipo de variable o tipo de dato definido. Aquí TipoDeDato es opcional y se utiliza sólo si la variable no ha sido declarada anteriormente. Almacenamiento de datos en variables: Para almacenar un valor en una variable se utiliza el nombre con el que esta fue declarada, a continuación el signo igual, seguido del valor que se desea almacenar. En pseudocódigo y diagrama de flujo: variable = valor En Java: variable = valor ; Se deberá tener presente que una variable puede almacenar sólo un valor a la vez y que este valor deberá ser equivalente al tipo de dato con el que se declaró la variable. Cada vez que almacena un valor en la variable, perderá el valor que anteriormente tenía esta. Es posible almacenar un valor en una variable en cualquier parte del programa. El único requisito es que la variable donde se almacene el valor esté previamente declarada. El valor de una variable puede también ser sustituido por el resultado de una operación aritmética o de cálculo. Por ejemplo: En pseudocódigo y diagrama de flujo: suma = 7 + 5

Pag. 64

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

En Java: suma = 7 + 5 ; En ambos casos, cuando se desee visualizar el contenido de la variable suma, se observará que el valor obtenido será 12. Otros usos de las variables: Muchas veces, es necesario utilizar variables que permitan almacenar resultados parciales, obtenidos cada vez que se ejecuta una estructura lógica de repetición (las estructuras lógicas se repetición se estudian más adelante en este mismo capítulo). Dichas variables pueden asumir la función de contador, acumulador o interruptor. La función que pueda asumir una variable dependerá de la forma como se plantee la solución para un determinado problema. Contadores: Un contador es una variable cuyo valor se incrementa o decrementa en una cantidad fija cada vez que se ejecutan los pasos que forman parte de una estructura de repetición. Un contador puede ser creciente o decreciente. Acumuladores: Un acumulador o totalizador es una variable cuya función es almacenar un valor como resultado de sumas o restas sucesivas. Un acumulador realiza la misma función que un contador con la diferencia que el incremento o decremento no es una cantidad fija sino una cantidad variable. Interruptores: Un interruptor o conmutador (denominado también centinela, bandera o flag) es una variable que puede tomar dos posibles valores (1/0, verdadero/falso, si/no, encendido/apagado) dentro de una determinada solución. Dependiendo del valor que tome el interruptor se ejecutarán ciertos pasos. Cabe mencionar que en una solución se puede utilizar una o varias variables que pueden asumir las funciones de contador, acumulador o interruptor.

Pag. 65

Ing. Juan José Flores Cueto.

TIPOS DE DATOS Definición: Los tipos de datos permiten declarar las variables. A pesar que en el pseudocódigo y diagrama de flujo sólo se reconocen tres tipos de datos, en los lenguajes de programación se tiene una gran variedad de tipos de datos, los cuales están divididos –generalmente- en dos categorías: básicos o simples y compuestos. Existen diferentes tipos de datos. En pseudocódigo y diagrama de flujo se utilizan tres tipos (NUMERO, TEXTO y LOGICO). Los lenguajes de programación permiten trabajar con una amplia diversidad de tipos de datos que se extienden desde los más básicos hasta los más complejos. En Java, todos los datos son derivados de ocho tipos de datos básicos; byte, short, int, long, float, double, char y boolean. Los tipos de datos básicos se tratarán en este capítulo y constituyen la base para los tipos de datos compuestos. Tipos de datos en Pseudocódigo: Reglas definidas para los tipos de datos: NUMERO CARACTER TEXTO LOGICO

Referidos a cualquier número. Se puede subdividir en ENTERO y REAL. Referidos a cualquier letra, digito o símbolo encerrado entre comilla simple. Referidos a cualquier texto encerrado entre comillas dobles. Referido a los dos posibles valores lógicos (VERDADERO y/o FALSO).

Hay que tener presente que las palabras NUMERO, ENTERO, REAL. CARACTER. TEXTO y LOGICO son reglas utilizadas en el pseudocódigo y diagrama de flujo, por lo que no podrán ser usadas como nombre de variable. Estos datos nos permiten definir los tres tipos de variables utilizadas: Variables numéricas: Permiten almacenar sólo tipos de datos numéricos (NUMERO, ENTERO y REAL). Con una variable numérica se puede realizar operaciones matemáticas (suma, resta, multiplicación, división, etc.). En este contexto, se debe tener presente que las operaciones matemáticas se resuelven siguiendo las mismas reglas que se aplican en la aritmética tradicional.

Pag. 66

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Por ejemplo: Una serie de operaciones. Primero se resuelven las multiplicaciones y divisiones; luego las sumas y restas. Para alterar esta prioridad se podrá utilizar los paréntesis. Ejemplos: edad = 15 resultado = 5 + 8 * ( 6 – 2) Donde edad y resultado son variables que previamente han sido declaradas como variables de tipo numéricas. Variables de texto: Permiten almacenar datos de tipo texto y datos de tipo caracter (TEXTO y CARACTER). Las variables tipo texto son útiles para almacenar cualquier cadena de texto, tales como nombres de personas, direcciones, número de AFP, etc. Ejemplos: nombre = “Pedro” letra = ‘J’ Donde nombre y siglas son variables que previamente han sido declaradas como variables de tipo texto. Variables lógicas: Permiten almacenar sólo tipo de datos lógicos. Existen sólo dos valores que se pueden almacenar en este tipo de variable: verdadero y falso. Ejemplos: masculino = VERDADERO estudiante = FALSO Donde masculino y estudiante son variables que previamente han sido declaradas como variables de tipo lógico. Las palabras VERDADERO y FALSO constituyen reglas en pseudocódigo y diagrama de flujo, por lo que no está permitido que se usen como nombres de variables.

Pag. 67

Ing. Juan José Flores Cueto.

Tipos de datos en Java: Los tipos de datos básicos o simples de Java son utilizados para declarar las variables que serán utilizadas en los programas, y forman parte de las palabras reservadas del lenguaje. Las palabras reservadas que permiten declarar variables son byte, short, int, long, float, double, char y boolean.

Tipo byte short

Descripción Tipo byte Entero corto

Longitud 1 byte 2 bytes

int

Entero

4 bytes

Entero largo

8 bytes

-128 … 127 -32768 … 32767 -2.147.483.648 2.147.483.647 -9.223.372.036.854.775.808 9.223.372.036.854.775.807

4 bytes

±3,4*10-38 … ±3,4*1038

8 bytes

±1,7*10-308 … ±1,7*10308

2 bytes 1 byte

0 … 65.535 true / flase

long float double char boolean

Real en coma flotante de simple precisión Real con coma flotante de doble precisión. Caracter Lógico

Rango

A diferencia de otros lenguajes de programación, en Java los tipos de datos simples no dependen de la plataforma ni del sistema operativo. Un entero de tipo int siempre tendrá 4 bytes, por lo que no habrá sorpresas al migrar un programa de un sistema operativo a otro. Es importante mencionar que Java no realiza una comprobación de rangos. Por ejemplo: si a una variable de tipo short con el valor 32.767 se le suma 1, el resultado será -32.768 y no se producirá ningún error de ejecución. Es importante destacar que estos ocho tipos de datos simples son diferentes, pero entre ellos se pueden agrupar como datos de tipo NUMERO (byte, short, int, long, float, double), tipo CARACTER (char) y tipo LOGICO (boolean). Los datos tipo NUMERO (datos numéricos) se pueden dividir en valores de tipo ENTERO (byte, short, int, long) y valores de tipo REAL (float, double). Para representar una cadena de caracteres en Java, se utiliza la clase String. Los String en Java no son un tipo de dato básico (simple), sino un tipo de dato compuesto (a pesar de ello, se puede utilizar como un tipo de dato simple para definir datos de tipo TEXTO en Java). Los valores de los datos de tipo String van entre comillas dobles (ejemplo; “Hola”) y permite almacenar cadenas de texto, mientras que los de tipo char van entre comillas simples (ejemplo; ‘K’) y sólo permiten almacenar un solo caracter. Las palabras reservadas de Java no pueden ser utilizadas como nombre de variable.

Pag. 68

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Como regla general, una variable solo puede almacenar valores de acuerdo al tipo de dato con el que fue declarado. Es decir, si se declara una variable con un tipo de dato específico, solo podrá almacenar valores de dicho tipo de dato. En base a esto, si se declara una variable con un tipo de dato específico y se intenta almacenar un valor de distinto tipo, al momento de compilar, el programa indicará un error. Ejemplos:

Clase PrgTipoDato01 package dominioDeLaAplicacion ; class PrgTipoDato01 { public static void main ( String arg [ ] ) { double numReal = 4.3 ; int numEntero ; // La siguiente línea genera error. numEntero = numReal ; System.out.println ( numEntero ) ; } } Observación: No se puede almacenar un número real grande (double) en una variable entera (int).

Clase PrgTipoDato02 package dominioDeLaAplicacion ; class PrgTipoDato02 { public static void main ( String arg [ ] ) { double numRealDouble = 2.3 ; float numRealFloat ; // La siguiente línea genera error. numRealFloat = numRealDouble ; System.out.println ( numRealFloat ) ; } } Observación: No se puede almacenar un número real grande (double) en una variable real (float).

Pag. 69

Ing. Juan José Flores Cueto.

Clase PrgTipoDato03 package dominioDeLaAplicacion ; class PrgTipoDato03 { public static void main ( String arg [ ] ) { boolean estado = true ; char caracter ; // La siguiente línea genera error. caracter = estado ; System.out.println ( caracter ) ; } } Observación: No se puede almacenar un valor lógico (boolean) en una variable caracter (char).

Pag. 70

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

CONVERSIÓN DE DATOS Anteriormente se mencionó que por regla general en una variable solo se puede almacenar un solo valor y este valor debe ser del tipo de dato con el que la variable fue declarada. Pero como toda regla, esta también tiene su excepción, y la excepción para estos casos se denomina conversión de datos. A través de la conversión de datos se puede almacenar en una variable valores de tipo diferente al tipo de dato con el que se declaró la variable. La conversión de datos se aplica generalmente sobre los tipos de datos numéricos, es decir entre datos de tipo byte, short, int, long, float y double. También se puede aplicar sobre el tipo de dato char. Conversión implícita de datos en Java: La conversión implícita de datos se da entre un tipo de dato de menor precisión a un tipo de dato de mayor precisión (mas amplio, mas grande) y son generadas automáticamente por el compilador Java. A continuación se muestra los tipos de datos numéricos ubicados desde el tipo de dato de menor precisión al tipo de dato de mayor precisión: byte, short, int, long, float y double Ejemplos; Clase PrgTipoDato04 package dominioDeLaAplicacion ; class PrgTipoDato04 { public static void main ( String arg [ ] ) { int numEntero = 5 ; long numEnteroGrande ; // La siguiente línea no genera error. numEnteroGrande = numEntero ; // Se visualiza 5 System.out.println ( numEnteroGrande ) ; } }

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte un número entero (int) en un número entero largo (long). Esto es válido ya que el tipo de dato long en Java es de mayor precisión que el tipo de dato int.

Pag. 71

Ing. Juan José Flores Cueto.

Clase PrgTipoDato05 package dominioDeLaAplicacion ; class PrgTipoDato05 { public static void main ( String arg [ ] ) { char caracter = ‘a’ ; double numReal ; // La siguiente línea no genera error. numReal = caracter ; // Se visualiza 97.0 System.out.println ( numReal ) ; } }

Observación: Al ejecutar esta aplicación el compilador utiliza la conversión implícita y convierte la letra ‘a’ en un valor real (double) equivalente a su código ASCII, por lo que se visualiza 97.0 (la letra a en código ASCII es 97).

La conversión implícita de datos se realiza al mezclar variables de distinto tipo en expresiones matemáticas o al ejecutar instrucciones o sentencias de asignación. En ambos casos, es necesario que el lado izquierdo de la expresión tenga un tipo de dato más amplio que el resultado de evaluar el lado derecho: numReal = numEntero + 5 ;

Lado izquierdo de la expresión

En caso contrario, si el lado derecho de la expresión tiene un tipo de dato más amplio que el lado izquierdo, al momento de compilar, el programa indicará un error. La conversión implícita de datos en Java, se da de un tipo de dato de menor precisión a uno de mayor precisión. Conversión explicita de datos en Java (casting): Las conversiones de un tipo de dato de mayor precisón a otro tipo de dato de menor precisión requieren que se coloque en forma explicita en los programas. Estás conversiones son inseguras y puedan dar lugar a errores. Este tipo de conversión de datos se le denomina también cast (casting). El cast se realiza colocando entre paréntesis

Pag. 72

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

el tipo de dato al que se desea convertir el resultado de una expresión. Ejemplo; Clase PrgTipoDato06 package dominioDeLaAplicacion ; class PrgTipoDato06 { public static void main ( String arg [ ] ) { double num1 = 20, num2 = 3 ; int div ; // La siguiente línea genera error. div = num1 / num2 ; System.out.println ( div ) ; } }

Clase PrgTipoDato07 package dominioDeLaAplicacion ; class PrgTipoDato07 { public static void main ( String arg [ ] ) { double num1 = 20, num2 = 3 ; int div ; // La siguiente línea no genera error. div = ( int ) ( num1 / num2 ) ; // Se visualiza 6. System.out.println ( div ) ; } } Observación: Al ejecutar esta aplicación el compilador utiliza la conversión explícita (casting) para poder almacenar el resultado de una división de numeros reales (double) en una variable entera (int).

Finalmente, en el capítulo III se tratán las clases Wrappers que envuelven los tipos de datos simples y también permiten realizar operaciones de conversión, entre otras.

Pag. 73

Ing. Juan José Flores Cueto.

Pag. 74

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

ESTRUCTURAS LÓGICAS ESTRUCTURAS LÓGICAS DE SECUENCIA Definición: Las Estructuras Lógicas de Secuencia son aquellas en las que una instrucción sigue a otra en secuencia. Las instrucciones se ejecutan una a una de tal modo que, finalizada la ejecución de una instrucción, se inicia la ejecución de la siguiente hasta completar la ejecución de todas las instrucciones que forman parte de la secuencia. Las Estructuras Lógicas de Secuencia son las estructuras lógicas más comunes y constituyen la base sobre la cual se desarrollan las demás estructuras lógicas. Tipos: 1. Estructura para la salida de información Definición: La salida de información se refiere a la forma o mecanismos que se emplean para poder conocer el resultado de un determinado algoritmo. Este tipo de estructura permite mostrar información a través de un dispositivo de salida de una computadora. Representación: Para representar la salida o visualización de la información se utiliza: - La regla; ESCRIBIR

En pseudocódigo.

- El símbolo; En diagrama de flujo. - La clase; System

Pag. 75

En Java.

Ing. Juan José Flores Cueto.

Es importante mencionar que se puede visualizar una cadena de texto, el contenido de una variable o el resultado de una operación matemática. Por ejemplo; Si desea visualizar la cadena de texto “Hola Mundo” utilizando pseudocódigo y diagrama de flujo, lo realizará de la siguiente manera: “Hola Mundo”

ESCRIBIR “Hola Mundo”

Si desea codificarlo en el lenguaje de programación Java, deberá realizarlo de la siguiente manera: System.out.print (“Hola Mundo”); System.out.println (“Hola Mundo”); Se puede utilizar la palabra “print” o “println”. Cuando se utiliza la palabra “print” se mostrará la cadena de texto y el cursor permanecerá al final de la cadena de texto mostrada, y cuando se utiliza la palabra “println” se mostrará la cadena de texto y el cursor se colocará en la siguiente línea.

2. Estructura para la entrada de datos Definición: La entrada de datos se refiere a la forma o mecanismos que se emplean para ingresar los datos que necesita un algoritmo para procesarlos y obtener, posteriormente, la información necesaria. Este tipo de estructura permite ingresar datos a través de un dispositivo de entrada de una computadora. Representación: Para representar la entrada de datos se utiliza: - La regla; LEER

En pseudocódigo.

- El símbolo; En diagrama de flujo.

Pag. 76

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

- La clase; Lectura

En Java.

Es importante mencionar que el lenguaje de programación Java no proporciona una clase que facilite el ingreso de datos en forma tradicional. En consecuencia, se utilizará una clase en Java desarrollada especialmente para que cumpla dicha finalidad.

CLASE

MÉTODO

DESCRIPCIÓN

leerString()

Permite ingresar cadena de texto.

leerChar()

Permite ingresar un caracter (una sola letra o número)

leerInt()

Permite ingresar número entero.

un

leerLong()

Permite ingresar número entero largo.

un

leerFloat()

Permite ingresar un número con parte decimal.

leerDouble()

Permite ingresar un número con parte decimal.

Lectura.class

una

La clase Lectura fue desarrollada por la Srta. Gisella Guzmán.

La clase Lectura va a facilitar el ingreso de datos en forma tradicional. 1 Esta clase es una implementación mejorada de la clase Math2 Es importante mencionar, que esta clase permitirá ingresar datos en forma tradicional y será usada para la codificación de algoritmos en Java. En el Apéndice, se trata en detalle la clase Lectura.

1

Se puede revisar el uso de la clase Math2 en el primer libro del autor, titulado “Método para la solución de problemas utilizando la programación orientada a objetos – Aspectos básicos”.

Pag. 77

Ing. Juan José Flores Cueto.

3. Estructura para operaciones aritméticas y de cálculo Definición: Las operaciones aritméticas y de cálculo se refieren a la forma o mecanismos que se emplean para poder procesar los datos ingresados y obtener la información necesaria. Representación: Para representar las operaciones aritméticas se utilizan los mismos signos que se emplean en la aritmética tradicional (+, -, *, /). Suma: Resta: Multiplicación: División:

+ * /

Las operaciones lógicas se representan de la siguiente manera: En pseudocódigo y diagrama de flujo: Y lógico: O lógico: Negación:

Y (AND) O (OR) N (NOT)

En Java: Y lógico: O lógico: Negación:

&& || ~

Formatos: Formato para diseñar algoritmos: Pseudocódigo

EXPLICACIÓN:

INICIO

Todas las instrucciones que son parte de la solución del problema deberán aparecer entre las reglas INICIO y FIN. Estas instrucciones se ejecutarán una tras otra.

Instrucciones ... FIN

Pag. 78

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Diagrama de Flujo EXPLICACIÓN: INICIO

Todas las instrucciones que son parte de la solución del problema aparecerán entre el siguiente símbolo:

Instrucciones ...

FIN

Dentro del símbolo se indicará si es el inicio o el fin de la solución con las reglas INICIO o FIN.

Al conjunto de pasos que forman parte de un algoritmo se les denomina instrucciones.

Formato para codificar algoritmos: Lenguaje de Programación Java

class NombreClase { public static void main (String a[]) { .... // sentencias .... } }

EXPLICACIÓN: Inicialmente, se puede afirmar que todas las sentencias que son parte de la solución aparecerán dentro de los métodos. El método main ( ) es conocido como el método principal, y es desde donde se inicia la ejecución de las sentencias.

Al conjunto de pasos que forman parte de un programa de computadora se les denomina sentencias.

Pag. 79

Ing. Juan José Flores Cueto.

ESTRUCTURAS LÓGICAS DE DECISIÓN Definición: Las Estructuras Lógicas de Decisión son construcciones que permiten alterar el flujo secuencial de una solución, de tal forma que en función de una condición o el valor de una variable, se pueda desviar la secuencia de la solución entre diferentes alternativas. Las Estructuras Lógicas de Decisión son conocidas también como Estructuras de Selección. Tipos: 1. Estructuras lógicas de decisión simple Definición: Una estructura de decisión simple “SI... FINSI” permite alterar el flujo secuencial (o pasos secuenciales) de una solución ejecutando un conjunto de pasos adicionales si el resultado de una condición lógica es verdadera. Este tipo de estructura es útil cuando se tiene la posibilidad de escoger una determinada opción. Formato para diseñar algoritmos:

Pseudocódigo EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.

SI (condición) ENTONCES instrucciones... FINSI

Si la condición resulta falsa, no se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y FINSI.

Pag. 80

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Diagrama de Flujo

VERDADERO

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”.

condición ?

... instrucciones... ...

FALSO

Si la condición resulta falsa, se sigue el flujo etiquetado con la regla o pauta “FALSO” y no se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”.

Formato para codificar algoritmos: Lenguaje de Programación Java

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las sentencias que se encuentra entre las llaves { }.

if (condición) {

Si la condición resulta falsa, no se ejecutan las sentencias que se encuentran entre las llaves { }.

sentencias... }

Pag. 81

Ing. Juan José Flores Cueto.

2. Estructuras lógicas de decisión doble Definición: Una estructura de decisión doble “SI... SINO... FINSI” permite alterar el flujo secuencial (o pasos secuenciales) de una solución, ejecutando un conjunto de pasos dependiendo del resultado de una condición lógica. Si la condición resulta verdadera, se ejecuta un conjunto de pasos, y si la condición resulta falsa, se ejecuta otro conjunto de pasos. En ningún caso se podrá ejecutar ambos conjuntos de pasos a la vez. Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre dos posibles opciones. Formato para diseñar algoritmos:

Pseudocódigo

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran entre las reglas ENTONCES y SINO.

SI (condición) ENTONCES instrucciones... SINO instrucciones... FINSI

Si la condición resulta falsa se ejecutan las instrucciones que se encuentran entre las reglas SINO y FINSI. Sólo se ejecuta uno de los grupos de instrucción, en ningún caso se podrá ejecutar ambos grupos.

Pag. 82

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Diagrama de Flujo EXPLICACIÓN: VERDADERO

FALSO condición ?

... instrucciones ...

... instrucciones ...

Si la condición resulta verdadera, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “VERDADERO”. Si la condición resulta falsa, se ejecutan las instrucciones que se encuentran en el flujo etiquetado con la regla “FALSO”.

Formato para codificar algoritmos: Lenguaje de Programación Java

EXPLICACIÓN: Si la condición resulta verdadera, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada if.

if (condición) { sentencias... } else { sentencias... }

Si la condición resulta falsa, se ejecutan las sentencias que se encuentran entre las llaves { } ubicadas después de la palabra reservada else.

Pag. 83

Ing. Juan José Flores Cueto.

3. Estructuras lógicas de decisión múltiple Definición: Una estructura de decisión múltiple “CUANDO... FINCUANDO” permite alterar el flujo secuencial de una solución ejecutando un conjunto de pasos dependiendo del valor de una variable. Generalmente, para cada posible valor que pueda tener la variable se define un conjunto de pasos a ejecutar. También se define un conjunto de pasos a ejecutar en caso que uno de los valores de la variable no tenga asociado un conjunto de pasos a ejecutar. Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre más de dos opciones.

Formato para diseñar algoritmos: Pseudocódigo

EXPLICACIÓN:

CUANDO (variable) SEA CASO (valor 1) : instrucciones... CASO (valor 2) : instrucciones... CASO (valor n) : instrucciones... OTROS instrucciones... FINCUANDO

Pag. 84

Si el valor de la variable es igual a uno de los valores colocados después de una de las reglas CASO, se ejecutan las instrucciones que están dentro del mismo. Si el valor de la variable no es igual a ninguno de los valores colocados después de una de las reglas CASO, se ejecutan las instrucciones que están dentro de la regla OTROS. La regla OTROS es opcional (es decir, puede aparecer como no).

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Diagrama de Flujo

variable ?

valor 1

instrucciones

valor 2

instrucciones

valor n

instrucciones

OTROS

instrucciones

EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores que tiene como etiqueta el flujo, se ejecutan las instrucciones que están seguidas del flujo (las que indica la flecha). Si el valor de la variable no es igual a uno de los valores de las etiquetas de los flujos, se ejecuta el flujo que tiene como regla OTROS. El flujo con la regla OTROS es opcional.

Pag. 85

Ing. Juan José Flores Cueto.

Formato para codificar algoritmos: Lenguaje de Programación Java

EXPLICACIÓN: Si el valor de la variable es igual a uno de los valores colocados después de la palabra reservada case (valor 1, valor 2, etc), se ejecutan las sentencias que están dentro del mismo hasta llegar al final (es decir hasta la llave) a no ser que encuentre una palabra reservada break entre las sentencias que se ejecutan.

switch (variable) { case valor 1 : sentencias... case valor 2 : sentencias... case valor n : sentencias...

Si el valor de la variable no es igual a ninguno de los valores colocados después de una de las palabras reservadas case, se ejecutan las sentencias que están dentro de la palabra reservada default. La palabra reservada default es opcional (es decir puede aparecer como no).

default : sentencias... }

Es importante tener presente que en Java se deberá usar la palabra reservada break al final de cada bloque de sentencias si se desea que cada alternativa (case) ejecute un grupo de sentencias sin que ejecute el grupo de sentencias de las alternativas (case) que están a continuación. También es importante mencionar que en Java la variable utilizada junto a la palabra reservada switch sólo puede ser de tipo entero o de tipo caracter. Si la variable es de tipo entero (definida con la palabra reservada int), se deberá utilizar números enteros después de la palabra reservada case. En caso que la variable sea de tipo caracter (definida con la palabra reservada char), se deberá utilizar un caracter encerrado entre comillas simples después de la palabra reservada case.

Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión, se debe emplear correctamente los formatos establecidos, ya que estos constituyen lo que denominamos un “estándar” o acuerdo. Cuando se codifique un algoritmo recuerde que se tiene que seguir las reglas del lenguaje de programación que usará, caso contrario, al momento de ejecutar un programa, se dará con la sorpresa que tendrá errores de sintaxis.

Pag. 86

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

ESTRUCTURAS LÓGICAS DE REPETICIÓN Definición: Las Estructuras Lógicas de Repetición son construcciones que permiten repetir determinadas partes de una solución, de tal forma que, en función de una condición o el valor de una variable, se pueda repetir un conjunto de pasos un determinado número de veces. Las Estructuras Lógicas de Repetición son conocidas también como estructuras de iteración o bucles. Tipos: 1. Estructura lógica de repetición “DESDE” Definición: Una estructura de repetición “DESDE... FINDESDE” permite repetir una instrucción, o un bloque de instrucciones, un número determinado de veces o hasta que una condición se cumpla. Una estructura lógica de repetición “DESDE... FINDESDE” con frecuencia se utiliza para iteraciones sencillas en donde se repite un bloque de instrucciones un cierto número de veces y después se detiene. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un cierto número de veces. Formato para diseñar algoritmos: Pseudocódigo DESDE i = valorInicial HASTA valorFinal INCREMENTA valor instrucción 1 . . .

instrucción n FINDESDE

Pag. 87

Ing. Juan José Flores Cueto.

EXPLICACIÓN: Esta estructura tiene tres partes: 1.

Inicialización:

DESDE i = valorInicial

Esta parte se ejecuta una sola vez al momento de iniciar la ejecución de la estructura lógica de repetición DESDE... FINDESDE y permite asignar un valor inicial a la variable “i” o la que se utilice en vez de ésta. Esta variable funciona como un índice que permite mantener el control sobre el número de veces que se repiten las instrucciones ubicadas entre las reglas DESDE y FINDESDE. 2.

Incremento: INCREMENTA valor Cada vez que finaliza la ejecución de las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE, se ejecuta esta parte y se INCREMENTA (aumenta) el valor de la variable índice “i” según se indique en valor. También existe la posibilidad de reducir el valor de la variable índice “i”; en este caso, se utiliza la regla DECREMENTA en lugar de la regla INCREMENTA.

3.

Prueba:

HASTA valorFinal

Una vez que se termina de INCREMENTAR o DECREMENTAR la variable índice, se procede a ejecutar esta parte. Aquí se evalúa si la variable índice es igual a valorFinal, es decir si ya llegó HASTA valorFinal. Si la variable índice no es igual a valorFinal, se volverá a ejecutar las instrucciones o bloque de instrucciones ubicadas entre las reglas DESDE y FINDESDE. En caso que la variable índice sea igual a valorFinal, se finaliza la ejecución del DESDE y se continúa con la ejecución de la instrucción ubicada después de la regla FINDESDE.

El equivalente de esta estructura en diagrama de flujo se muestra a continuación:

Pag. 88

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Diagrama de Flujo

DESDE i HASTA z

FALSO

INCREMENTA x VERDADERO

... instrucciones... ...

EXPLICACIÓN: Las tres partes de esta estructura se representan en el diagrama de flujo a través de las siguientes reglas: DESDE i HASTA z Aquí “i” es la variable índice y “z” es el valor que el índice “i” debe alcanzar para finalizar la ejecución. INCREMENTA x Aquí “x” representa el valor que se incrementará a la variable índice cada vez que se termine la ejecución de las instrucciones que forman parte de la estructura. Ambas reglas se encuentran dentro del símbolo que representa la regla o pauta DESDE, la cual se muestra a continuación:

El fin de las instrucciones o bloque de instrucciones que forman parte de la regla DESDE, se representa por el siguiente símbolo:

Este último símbolo es equivalente a la regla FINDESDE utilizada en pseudocódigo.

Pag. 89

Ing. Juan José Flores Cueto.

Formato para codificar algoritmos: Lenguaje de Programación Java for ( i = valorInicial ; condición ; incremento) { sentencias... } EXPLICACIÓN: En Java, la regla DESDE está representada por la sentencia for. Al igual que en pseudocódigo y diagrama de flujo, en Java esta estructura está constituida por tres partes. En pseudocódigo y diagrama de flujo se utiliza la regla HASTA valorFinal, mientras que en Java se utiliza una condición lógica (ejemplo: i >10). Esta parte constituye la prueba en Java. Si la condición es verdadera, se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición; en el caso que sea falso, se finaliza la ejecución continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia for se representan con llaves ({ }).

2. Estructura lógica de repetición “MIENTRAS” Definición: Una estructura de repetición “MIENTRAS... FINMIENTRAS”, al igual que una estructura lógica de repetición “DESDE... FINDESDE”, permite repetir una instrucción o un bloque de instrucción mientras que una condición se cumpla o ésta sea verdadera. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado.

Pag. 90

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Formato para diseñar algoritmos: Pseudocódigo MIENTRAS (condición) instrucción 1 . . .

instrucción n FINMIENTRAS

EXPLICACIÓN: Cuando se ejecuta la estructura lógica de repetición MIENTRAS... FINMIENTRAS lo primero que se realiza es la evaluación de la condición lógica ubicada junto a la regla MIENTRAS. Una vez evaluada la condición lógica, podemos obtener dos posibles resultados: Si el resultado de evaluar la condición lógica es verdadera, se procede a ejecutar las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS... FINMIENTRAS y se evalúa, nuevamente, la condición lógica. Si el resultado de evaluar la condición lógica es falsa, no se ejecutan las instrucciones que están dentro de la estructura lógica de repetición MIENTRAS... FINMIENTRAS y se continúa con la ejecución del algoritmo. Esto significa que mientras la evaluación de la condición lógica resulte verdadera, se ejecutará la estructura lógica de repetición MIENTRAS... FINMIENTRAS y que sólo finalizará cuando la evaluación de la condición lógica resulte falsa.

El equivalente de esta estructura en diagrama de flujo se muestra a continuación. En la figura, se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.

Pag. 91

Ing. Juan José Flores Cueto.

Diagrama de Flujo

FALSO condición ?

VERDADERO

... instrucciones... ...

Formato para codificar algoritmos:

Lenguaje de Programación Java while (condición) { sentencias... }

Pag. 92

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

EXPLICACIÓN: En Java, la regla MIENTRAS está representada por la sentencia while. En la sentencia while, al igual que en pseudocódigo y diagrama de flujo, se utiliza una condición lógica (ejemplo: i >10) para verificar si se ejecuta la estructura o no. Esta condición lógica constituye la prueba en Java. Si la condición es verdadera, se continúa con la ejecución de las sentencias o bloque de sentencias que pertenecen a la estructura de repetición; en el caso que sea falso, se finaliza la ejecución continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia while se representan con llaves ({ }).

3. Estructura lógica de repetición “HACER” Definición: Una estructura lógica de repetición “HACER... MIENTRAS”, al igual que una estructura lógica de repetición “DESDE... FINDESDE” y una estructura lógica de repetición “MIENTRAS... FINMIENTRAS”, permite repetir una instrucción o un bloque de instrucciones mientras que una condición se cumpla o sea verdadera. La principal diferencia entre ambos consiste en que la estructura lógica de repetición “MIENTRAS... FINMIENTRAS” prueba la condición antes de ejecutar la instrucción o bloque de instrucciones, lo que hace posible que dichas instrucciones no se ejecuten si la condición es falsa la primera vez que se prueba la condición. La estructura lógica de repetición “HACER... MIENTRAS” ejecuta al menos una vez las instrucciones o bloque de instrucciones antes de probar la condición. Este tipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones un número de veces no determinado, siendo necesario ejecutar la instrucción o bloque de instrucciones por lo menos una vez.

Pag. 93

Ing. Juan José Flores Cueto.

Formato para diseñar algoritmos:

Pseudocódigo HACER instrucción 1 . . .

instrucción n MIENTRAS (condición)

EXPLICACIÓN: Cuando se ejecuta la estructura lógica de repetición HACER... MIENTRAS se procede a ejecutar las instrucciones que están dentro de la misma. Al final, se realiza la evaluación de la condición lógica ubicada junto a la regla MIENTRAS. Una vez evaluada la condición lógica se puede obtener dos posibles resultados: Si el resultado de evaluar la condición lógica es verdadero, se procede a ejecutar, nuevamente, las instrucciones que están dentro de la estructura lógica de repetición HACER... MIENTRAS y se evalúa, nuevamente la condición lógica. Si el resultado de evaluar la condición lógica es falso, se continúa con la ejecución del algoritmo. Esto significa que la estructura lógica de repetición HACER... MIENTRAS se ejecuta por lo menos una vez antes de ser evaluada la condición lógica. Si al evaluar la condición lógica ésta resulta verdadera, se vuelve a ejecutar la estructura; caso contrario, finaliza la ejecución de la estructura, continuando con la siguiente instrucción del algoritmo.

Pag. 94

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

El equivalente de está estructura en diagrama de flujo se muestra a continuación. En la figura, se observa donde se ubica la condición lógica y los flujos etiquetados con las reglas “VERDADERO” y “FALSO”.

Diagrama de Flujo

... instrucciones ... ... VERDADERO condición ? FALSO

Formato para codificar algoritmos:

Lenguaje de Programación Java do { sentencias... } while (condición) ;

Pag. 95

Ing. Juan José Flores Cueto.

EXPLICACIÓN: En Java, la regla HACER está representada por la sentencia do. En la sentencia do, al igual que en pseudocódigo y diagrama de flujo, se utiliza una condición lógica (ejemplo: i >10) al final de la estructura, para verificar si se vuelve a ejecuta la estructura o no. Esta condición lógica constituye la prueba en Java. Si la condición es verdadera, se vuelve a ejecutar las sentencias o bloque de sentencias que pertenecen a la estructura de repetición, en el caso que sea falso, se finaliza la ejecución, continuando con la siguiente sentencia. Es importante indicar que el inicio y fin de la sentencia do se representan con llaves ({ }).

Pag. 96

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Instrucciones de bifurcación: Muchas veces es necesario cambiar o alterar el flujo normal de ejecución de una solución a otra parte de la misma. Para esto, se utilizan las instrucciones de bifurcación o salto. 1. Instrucción “TERMINAR”. En Java, esta instrucción de bifurcación es conocida como la sentencia break y tiene tres usos: ƒ ƒ ƒ

Permite finalizar una secuencia de sentencias en un switch (específicamente en el case). Se utiliza para salir de un bucle, sin analizar la condición y sin ejecutar el resto de código del cuerpo del bucle. Se emplea para proporcionar un mecanismo que permita cambiar el flujo de ejecución a otra parte de la solución (equivalente a un goto en otros lenguajes de programación).

2. Instrucción “CONTINUAR” En Java, esta instrucción de bifurcación es conocida como la sentencia continue. Esta sentencia permite salir anticipadamente de una iteracción de un bucle. Es decir; cuando se encuentra la sentencia continue se ejecuta la siguiente iteracción del bucle sin procesar el resto del código. 3. Instrucción “RETORNAR” En Java, esta instrucción de bifurcación es conocida como la sentencia return. Esta sentencia se utiliza para volver explícitamente de un método, es decir, esta sentencia permite que el control de la ejecución de la solución vuelva al método llamante.

Pag. 97

Ing. Juan José Flores Cueto.

Mapa de Estructuras Lógicas detallado:

Utilizando las estructuras lógicas fundamentales y las instrucciones de bifurcación, se pueden desarrollar algoritmos de tal forma que estos puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados en un lenguaje de programación. Las estructuras lógicas fundamentales y las instrucciones de bifurcación se resumen a continuación:

Estructuras Lógicas.

Estructuras Lógicas de Secuencia.

Estructuras Lógicas de Decisión.

Estructuras Lógicas de Repetición.

Instrucciones de Bifurcación.

“LEER”

“SI”

“DESDE”

“TERMINAR”

“ESCRIBIR”

“SI / SINO”

“MIENTRAS”

“CONTINUAR”

“PROCESAR”

“CUANDO”

“HACER”

“RETORNAR”

Pag. 98

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

MÉTODO DE LAS 6´D – ETAPAS Y PASOS A continuación, se presentan las etapas del Método de las 6’D con sus respectivos pasos. Dichas etapas y pasos han sido desarrollados en su totalidad en los primeros 22 problemas. Sin embargo, para los siguientes problemas hasta el final del presente capítulo (capítulo II), y para los problemas del siguiente capítulo (capítulo III), solo se ha incluido la Etapa 04 – “Desarrollo de la solución”. Esto permite presentar una mayor cantidad de problemas con sus respectivas codificaciones.

ENUNCIADO DEL PROBLEMA

Etapa 02 Definición Solución

• Determinar la información deseada (salida). • Determinar los datos de entrada (entrada). • Establecer como se solucionará el problema (proceso).

Etapa 03 Diseño Solución

• Determinar el nombre del proyecto. • Definir los paquetes y desarrollar el diagrama de paquetes respectivo. Establecer la dependencia. (Utilice UML). • Definir las clases que serán parte de la solución del problema. (Utilice UML).

Etapa 04 Desarrollo Solución

• Codificar el diseño de la solución del problema. Se utiliza el lenguaje de programación Java.

• Diseñar el algoritmo para el método principal. Se utiliza pseudocódigo.

En forma general, la Etapa 03 - “Diseño de la lógica” se divide en dos partes: modelamiento (paso 1, 2 y 3) y algoritmo (paso 4), mientras que en la Etapa 04 “Desarrollo de la solución” se tiene la parte de codificación (paso 1). También se puede utilizar esta división en el desarrollo de las soluciones.

Pag. 99

Ing. Juan José Flores Cueto.

Pag. 100

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 01 Etapas para la solución de un problema: Etapa 01 - Descripción del problema. Desarrollar un proyecto que permita mostrar un mensaje por la pantalla. El mensaje a mostrar será “Hola bienvenidos”. Etapa 02 – Definición de la solución. ‰

Resultado deseado:

Mostrar mensaje “Hola bienvenidos”.

‰

Datos necesarios:

Ninguno.

‰

Procesamiento:

El mensaje será almacenado en una variable (mensaje) y posteriormente mostrado.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyMensaje 2. Definición de Paquete y Clase.

Paquete y clase

DominioDeLaAplicacion

PrgMensaje main()

Pag. 101

Ing. Juan José Flores Cueto.

3. Diseño de algoritmo para el método principal

Algoritmo PrgMensaje - método main() ENTRADA: SALIDA:

mensaje

INICIO TEXTO mensaje mensaje = “ Hola bienvenido ” ESCRIBIR mensaje

Algoritmo para el método main ( ) diseñado en pseudocódigo.

FIN

Etapa 04 – Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java. Una vez que se ejecute este programa, se visualiza en la pantalla el mensaje “Hola Bienvenido”.

Clase PrgMensaje /* Este es el primer programa. Aunque es sencillo, podemos apreciar los elementos básicos de un programa en Java. */ package dominioDeLaAplicacion ; class PrgMensaje

{

// La ejecución empieza en el método main. public static void main ( String arg [ ] ) { String mensaje ; mensaje = “ Hola bienvenido ” ; System.out.print (mensaje) ; } }

Pag. 102

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Análisis de la solución: En primer lugar, se definió el nombre del proyecto, se estableció el nombre del paquete, el nombre de la clase y el método main ( ), en el cual se codifica la solución. A continuación, analizaremos el algoritmo del método main ( ) diseñado en pseudocódigo para la solución del problema anterior. La primera línea:

ALGORTIMO PrgMensaje Está referida al nombre del algoritmo. En este caso, el nombre es PrgMensaje. Observe que la primera letra se escribe con mayúscula.

Luego tenemos:

ENTRADA: En esta parte se hace referencia a todas las variables, cuya función en el algoritmo es almacenar datos de entrada. Observe que no se ha definido ninguna variable de entrada.

A continuación:

SALIDA: En esta parte se hace referencia a todas las variables, cuya función en el algoritmo es almacenar datos de salida. Observe que se ha definido la variable mensaje como una variable de salida. SALIDA:

Luego tenemos:

mensaje

INICIO Esta palabra permite indicar el inicio de los pasos que constituyen la solución al problema planteado.

A continuación:

TEXTO mensaje Esta línea está referida al paso 1 del algoritmo diseñado en pseudocódigo. Aquí se declara que se utilizará una variable de nombre mensaje cuyo tipo de dato es TEXTO o cadena.

Luego tenemos:

mensaje = “ Hola bienvenidos ” Esta línea está referida al paso 2 del algoritmo diseñado en pseudocódigo. Aquí se asigna el valor “ Hola bienvenidos ” a la variable mensaje. Recuerde que, para asignar un valor a una variable, se utiliza el símbolo igual (=).

A continuación:

ESCRIBIR mensaje

Pag. 103

Ing. Juan José Flores Cueto.

Esta línea está referida al paso 3 del algoritmo diseñado en pseudocódigo. A través de la palabra ESCRIBIR se muestra el contenido de la variable mensaje. Es decir, se muestra “ Hola bienvenidos ” , valor que fue asignado a la variable en el paso 2. Finalmente:

FIN Esta palabra permite indicar el fin de los pasos que constituyen la solución al problema planteado. Es decir, el final del algoritmo.

Los pasos que están entre las palabras INICIO… FIN constituyen la parte más importante del algoritmo y es conocido como “cuerpo del algoritmo”.

Ahora, analicemos cada línea de la codificación del algoritmo en el lenguaje de programación Java: En primer lugar, observamos que el programa empieza con las siguientes líneas: /* Este es el primer programa. Aunque es sencillo podemos apreciar los elementos básicos de un programa en Java. */

Este es un comentario. Tal como la mayoría de lenguajes de programación, Java le permite colocar comentarios en el código fuente de los programas. Los comentarios no son ejecutados, y su propósito es describir o explicar el objetivo de un programa a cualquiera que lea el código fuente. En nuestro caso, el comentario nos permite identificar el programa. En problemas grandes se utilizan los comentarios para explicar para qué sirve cada característica del programa y cómo éstas se ejecutan. Es decir, se puede utilizar los comentarios para describir paso a paso lo que hace el programa. En Java existen tres tipos de comentarios. El que se acaba de mostrar se llama comentario de múltiples líneas. Este tipo de comentario comienza con una barra seguida de un asterisco (/*) y termina donde aparece un asterisco seguido de una barra (*/). Todo aquello que se escribe entre los dos símbolos de comentario de múltiples líneas /*………. */ es ignorado al momento de ejecutar el programa. Los comentarios de múltiples líneas pueden tener una o varias líneas de longitud.

Pag. 104

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Observemos la siguiente línea de código:

package dominioDeLaAplicacion ;

Esta línea especifica el paquete al cual pertenecerá la clase que se creará con la palabra reservada class. El nombre del paquete está a continuación de la palabra reservada package. En este caso, el nombre del paquete es “dominioDeLaAplicacion”.

En la siguiente línea de código:

class PrgMensaje {

Observe que en la línea de código anterior se utiliza la palabra reservada class, lo cual nos indica que se declara una clase. A continuación encontramos el nombre de la clase PrgMensaje. Finalmente, seguido del nombre se coloca una llave de apertura ( { ), la cual indica el inicio del cuerpo de la misma. La siguiente línea del programa es:

// La ejecución empieza en el método main.

Este también es un comentario. Usa el segundo tipo de comentario disponible en Java y se llama comentario de una sola línea. Los comentarios de una sola línea comienzan con dos barras ( // ) y terminan al final de la línea. La siguiente línea del programa es:

public static void main ( String arg [ ] ) {

Pag. 105

Ing. Juan José Flores Cueto.

Esta línea de código es conocida como la firma del método main ( ) o método principal. Toda clase en Java, que deseamos tenga la posibilidad de ejecutarse, deberá tener un método main ( ) exactamente como ha sido escrito, debido a que Java diferencia las letras mayúsculas de las letras minúsculas. En resumen, podemos decir que para desarrollar un programa básico en Java necesitamos definir un paquete, una clase y un método principal o método main ( ). Recuerde que esto se realizó con las siguientes líneas de código:

package dominioDeLaAplicacion ; class PrgMensaje { public static void main ( String arg [ ] ) { } }

La siguiente línea del programa es:

String mensaje ;

A través de esta línea se declara el uso de la variable mensaje de tipo TEXTO o cadena. En Java, todas las variables deben ser declaradas antes de ser utilizadas (lo que no es necesario realizar en las herramientas utilizadas para diseñar algoritmos). Además, también se debe especificar el tipo de dato que la variable puede almacenar. En este caso, el tipo de la variable mensaje es TEXTO o cadena. En Java, para declarar una variable de tipo TEXTO o cadena, se debe de anteponer al nombre de la variable la palabra String. Es importante mencionar que esta línea de código termina en punto y coma ( ; ). De hecho, todas las sentencias en Java terminan en punto y coma. La siguiente línea del programa es:

mensaje = “ Hola bienvenido ” ;

A través de esta sentencia se asigna un valor a la variable. Es importante mencionar que una variable, antes de ser utilizada, debe tener un valor asignado. En este caso, a la variable mensaje se le asigna el valor “ Hola bienvenido ”. Para asignar valor a una

Pag. 106

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

variable, se utiliza el signo igual ( = ). En Java se crea una cadena cuando se encierra una secuencia de caracteres entre comillas. De esta manera, “ Hola bienvenido ” es una cadena.

La siguiente línea del programa es:

System.out.print (mensaje) ;

Esta es una sentencia de salida por la consola. Hace que el valor de la variable mensaje se visualice por la pantalla. De hecho, también uno puede visualizar cadenas y los resultados de operaciones matemáticas. Las dos últimas líneas del programa son:

} }

La primera indica que el método main ( ) ha terminado y la segunda indica el final de la clase. De esto se deduce, que las siguientes líneas de código se utilizarán en todos los programas que se desarrollen. Sólo variará el nombre del paquete y el nombre de la clase que, en este caso, es dominioDeLaAplicacion y PrgMensaje respectivamente.

package dominioDeLaAplicacion ; class PrgMensaje { public static void main ( String arg [ ] ) { } }

Pag. 107

Ing. Juan José Flores Cueto.

Problema 02 Etapas para la solución de un problema: Etapa 01 - Descripción del problema. Se requiere mostrar el resultado de sumar, multiplicar, restar y dividir los números 9121236 y 735. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰ ‰

Datos necesarios: Procesamiento:

Mostrar el resultado de las operaciones matemáticas básicas; suma, multiplicación, resta y división de los números 9121236 y 735. Ninguno. Los números serán almacenados en variables, luego se realizarán las operaciones matemáticas y, finalmente, se mostrarán los resultados de dichas operaciones.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyOperaciones. 2. Definición de Paquete y Clase.

Paquete y clase

DominioDeLaAplicacion

PrgOperaciones main()

Pag. 108

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Diseño de algoritmo para el método principal. Algoritmo PrgOperaciones - método main() ENTRADA: SALIDA:

suma, multi, resta,divi

INICIO NUMERO num1=9121236, num2=735 NUMERO suma, multi, resta, divi suma = num1 + num2 multi = num1 * num2 resta = num1 - num2 divi = num1 / num2 ESCRIBIR “La suma es ” + suma ESCRIBIR “La multiplicación es ” + multi ESCRIBIR “La resta es ” + resta ESCRIBIR “La división es ” + divi FIN

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java. Clase PrgOperaciones package dominioDeLaAplicacion; class PrgOperaciones

{

// la ejecución empieza en main. public static void main ( String arg[ ] ) { long num1=9121236, num2=735, suma, resta, multi; double divi; suma = num1 + num2; resta = num1 – num2; multi = num1 * num2; divi = (double) (num1) / num2; System.out.println (“La suma es: ” + suma); System.out.println (“La resta es: ” + resta); System.out.println (“La multiplicación es: ” + multi); System.out.println (“La división es: ” + divi); } }

Pag. 109

Ing. Juan José Flores Cueto.

Problema 03 Etapa 01 - Descripción del problema. Convertir y mostrar una cantidad de dinero, expresado en dólares, en su equivalente en nuevos soles. Ingresar la cantidad en dólares y el tipo de cambio. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰ ‰

Datos necesarios: Procesamiento:

Mostrar el equivalente, en nuevos soles, de una cantidad expresada en dólares. El monto en dólares y el tipo de cambio. El monto en dólares y el tipo de cambio serán ingresados por teclado y almacenados en dos variables (dolares y tipo respectivamente). Luego, se calculará el equivalente en nuevos soles utilizando la siguiente operación: soles = dolares * tipo El resultado se almacenará en una variable (soles) para luego ser mostrada por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyDolaresSoles. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.

Diagrama de paquetes

Pag. 110

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgDolaresSoles - método main ( )

ENTRADA: dolares, tipo SALIDA: soles

INICIO NUMERO dolares, tipo, soles LEER dolares, tipo soles = dolares * tipo ESCRIBIR soles FIN

Pag. 111

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgDolaresSoles package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgDolaresSoles { public static void main (String arg[]) { double dolares, tipo, soles ; System.out.print ( “ Ingrese una cantidad de dólares: ” ) ; dolares = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese tipo de cambio del dólar: ” ) ; tipo = Lectura.leerDouble ( ) ; soles = dolares * tipo ; System.out.println ( “ Cantidad equivalente en soles es: ” + soles) ; } }

Pag. 112

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 04 Etapa 01 - Descripción del problema. Calcular la nota final que ha obtenido un alumno en el curso de programación avanzada. Utilizar la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5. Ingresar las notas n1, n2, n3 y n4 a través del teclado. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

Mostrar la nota final de un determinado alumno. Las notas del alumno (en este caso tenemos 4 notas). Las notas serán ingresadas por teclado y almacenadas en variables (n1, n2, n3 y n4 respectivamente). Luego, se realizará el cálculo de la nota final sobre la base de la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5 El resultado se almacenará en una variable (nf) para luego ser mostrada por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyNotaFinal. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 113

Ing. Juan José Flores Cueto.

3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgNotaFinal - método main ( )

ENTRADA: SALIDA:

n1, n2, n3, n4 nf

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0 LEER n1, n2, n3, n4 nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ESCRIBIR nf FIN

Pag. 114

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgNotaFinal package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotaFinal { public static void main (String arg[]) { double n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 ; System.out.print ( “ Ingrese la nota 1 del alumno: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 2 del alumno: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 3 del alumno: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la nota 4 del alumno: ” ) ; n4 = Lectura.leerDouble ( ) ; nf = ( n1 + n2 + n3 + ( n4 * 2)) / 5 ; System.out.print ( “ El promedio obtenido por el alumno es : ” ) ; System.out.println ( nf ) ; } }

Pag. 115

Ing. Juan José Flores Cueto.

Problema 05 Etapa 01 - Descripción del problema. Ingresar el sueldo de un obrero de la empresa “La Poderosa S.A.” y calcular su respectivo descuento del 15% por concepto de impuestos y el 5% por concepto de cafetería. Se deberá visualizar por pantalla el total de descuentos y el sueldo a cobrar. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰ ‰

Datos necesarios: Procesamiento:

Mostrar el total de descuento y el sueldo a cobrar de un obrero de la empresa. El sueldo total del obrero. El sueldo total será ingresado por teclado y almacenado en una variable (sueldo). Luego, se realizarán los cálculos del descuento y del sueldo a cobrar del obrero, utilizando las siguientes operaciones: desc = sueldo * 0.2 pago = sueldo – desc Los resultados se almacenarán en las variables (desc y pago respectivamente) para luego ser mostradas por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProySueldoObrero. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 116

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgSueldoObrero - método main ( )

ENTRADA: SALIDA:

sueldo desc, pago

INICIO NUMERO sueldo = 0, desc = 0, pago = 0 LEER sueldo desc = sueldo * 0.2 pago = sueldo - desc ESCRIBIR desc, pago FIN

Pag. 117

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgSueldoObrero package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSueldoObrero { public static void main (String arg[]) { double sueldo = 0, desc = 0, pago = 0 ; System.out.print ( “ Ingrese el sueldo de un obrero: ” ) ; sueldo = Lectura.leerDouble ( ) ; // Calculando el descuento ( 20% ) desc = sueldo * 0.2 ; // calculando el monto a pagar pago = sueldo – desc ; System.out.print ( “ El total de descuento es: ” ) ; System.out.println ( desc + “ soles ” ) ; System.out.println ( “ El sueldo a pagar es: ” + pago + “ soles ” ) ; } }

Pag. 118

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 06 Etapa 01 - Descripción del problema. Convertir la temperatura de grados Celsius a grados Fahrenheit, de acuerdo a la siguiente fórmula: F = (9/5) * C + 32. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰ ‰

Datos necesarios: Procesamiento:

Calcular y mostrar la temperatura en grados Fahrenheit. La temperatura en grados Celsius. La temperatura en grados Celsius será ingresada y almacenada en una variable (gradosCel), luego se realizará el cálculo de la temperatura en grados Fahrenheit de acuerdo a la siguiente fórmula: gradosFar = (9/5) * gradosCel + 32. El resultado será almacenado en una variable (gradosFar) para luego ser mostrado por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyTemperatura. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 119

Ing. Juan José Flores Cueto.

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgTemperatura - método main ( ) ENTRADA: SALIDA:

gradosCel gradosFar

INICIO NUMERO gradosCel = 0, gradosFar = 0 LEER gradosCel gradosFar = ( 9 / 5 ) * gradosCel + 32 ESCRIBIR gradosFar FIN

Pag. 120

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgTemperatura package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTemperatura { public static void main ( String arg[] ) { double gradosCel = 0, gradosFar = 0 ; System.out.print ( “ Ingrese la temperatura en grados Celsius: " ) ; gradosCel = Lectura.leerDouble ( ) ; gradosFar = ( 9 / 5 ) * gradosCel + 32 ; System.out.println ( “ La temperatura en grados Fahrenheit es: " + gradosFar) ; } }

Pag. 121

Ing. Juan José Flores Cueto.

Problema 07 Etapa 01 - Descripción del problema. Leer el costo de un artículo y su precio de venta. Calcular y mostrar su utilidad. Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Calcular y mostrar la utilidad de un artículo. El costo y el precio de venta del artículo. El costo y el precio de venta del artículo serán ingresados y almacenados en variables (costo, precioVta), luego se realizará el cálculo de la utilidad del artículo de acuerdo a la siguiente fórmula: utilidad = precioVta - costo El resultado será almacenado en una variable (utilidad) para luego ser mostrado por pantalla.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyUtilidad. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 122

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgUtilidad - método main ( ) ENTRADA: SALIDA:

costo, precioVta utilidad

INICIO NUMERO costo = 0, precioVta = 0, utilidad = 0 LEER costo, precioVta utilidad = precioVta - costo ESCRIBIR utilidad FIN

Pag. 123

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgUtilidad package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgUtilidad { public static void main ( String arg[] ) { double costo = 0, precioVta = 0, utilidad = 0 ; System.out.print ( “ Ingrese el costo del artículo: ” ) ; costo = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese el precio de venta del artículo: ” ) ; precioVta = Lectura.leerDouble ( ) ; utilidad = precioVta - costo ; System.out.println ( “ La utilidad del artículo es: s/. ” + utilidad + “ soles ” ) ; } }

Pag. 124

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 08 Etapa 01 - Descripción del problema. Calcular y mostrar la nota final (nf) de un alumno, sabiendo que se tienen sólo dos notas. Si el alumno obtiene una nota final mayor a 13 se deberá visualizar un mensaje de felicitaciones. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰ ‰

Datos necesarios: Procesamiento:

Mostrar nota final y un mensaje de felicitaciones si la nota final es mayor a 13. Las dos notas del alumno. Las notas se ingresarán por el teclado y serán almacenadas en variables (nota1 y nota2), luego se realizará el cálculo de la nota final: nf = ((nota1 + nota2) / 2) El resultado se almacena en una variable (nf). Si la nota final resulta mayor que 13 entonces se almacenará el mensaje “Felicitaciones” en una variable (mensaje). Finalmente, se muestra la nota final y el mensaje.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyNotaFinal2. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.

Diagrama de paquetes

Pag. 125

Ing. Juan José Flores Cueto.

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgNotaFinal2 - método main ( )

ENTRADA: nota1, nota2 SALIDA: nf, mensaje

INICIO NUMERO nota1 = 0, nota2 = 0, nf = 0 TEXTO mensaje = “ ” LEER nota1, nota2 nf = (nota1 + nota2) / 2 SI ( nf > 13 ) ENTONCES mensaje = “Felicitaciones” FINSI ESCRIBIR nf, mensaje FIN

Pag. 126

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgNotaFinal2

package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotaFinal2 { public static void main ( String arg[] ) { double nota1 = 0, nota2 = 0, nf = 0 ; String mensaje = “ ” ; System.out.print ( “ Ingrese la primera nota: ” ) ; nota1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la segunda nota: ” ) ; nota2 = Lectura.leerDouble ( ) ; nf = (nota1 + nota2) / 2 ; if (nf > 13) { mensaje = “ Felicitaciones ” ; } System.out.println ( “ La nota final es: ” + nf + “ ” + mensaje ) ; } }

Pag. 127

Ing. Juan José Flores Cueto.

Problema 09 Etapa 01 - Descripción del problema. Calcular y mostrar el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa horaria, sabiendo que se debe descontar un 10% del sueldo por concepto de impuestos si este es mayor de S/. 3000. Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Mostrar el sueldo de un trabajador. El total de horas trabajadas y la tarifa horaria. El total de horas trabajadas y la tarifa horaria se ingresarán por teclado y se almacenarán en variables (horas y tarifa), luego se realizará el cálculo del sueldo utilizando la siguiente operación: sueldo = horas * tarifa El resultado se almacenará en una variable (sueldo). Si el sueldo resulta mayor que S/.3000 entonces se calcula el sueldo a cobrar restando el 10% del sueldo. El resultado se almacena en la variable sueldo y se muestra a través de la pantala.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProySueldoTrabajador. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 128

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgSueldoTrabajador - método main ( )

ENTRADA: SALIDA:

horas, tarifa sueldo

INICIO NUMERO horas = 0, tarifa = 0, sueldo = 0 LEER horas, tarifa sueldo = horas * tarifa SI ( sueldo > 3000 ) ENTONCES sueldo = sueldo * 0.9 FINSI ESCRIBIR sueldo FIN

Pag. 129

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgSueldoTrabajador package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgSueldoTrabajador { public static void main ( String arg[] ) { int horas = 0 ; double tarifa = 0, sueldo = 0 ; System.out.print ( “ Ingrese el total de horas trabajadas: ” ) ; horas = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la tarifa del trabajador: ” ) ; tarifa = Lectura.leerDouble ( ) ; sueldo = horas * tarifa ; if (sueldo > 3000) { sueldo = sueldo * 0.9 ; } System.out.println ( “ El sueldo es: ” + sueldo ) ; } }

Pag. 130

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 10 Etapa 01 - Descripción del problema. Calcular y mostrar el monto total a pagar por la compra de varios artículos si se tiene que agregar el IGV (Impuesto General a las Ventas). En caso que el monto total a pagar incluido IGV sea mayor a S/.500 nuevos soles se aplica un descuento de 8%, caso contrario el descuento será de 2%. Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Mostrar monto total a pagar. Monto total. El monto total será almacenado en una variable (montoTotal). Se asume que el IGV es 18%. Luego se realizará el cálculo del monto total a pagar (monto total * 1.18) y se almacena en una variable (montoPago). Si el monto total resulta mayor a S/.500 nuevos soles, se descuenta el 8%, sino sólo se descontará el 2%.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyArticulos. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 131

Ing. Juan José Flores Cueto.

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgArticulos - método main ( )

ENTRADA: SALIDA:

montoTotal montoPago

INICIO NUMERO montoTotal = 0, montoPago = 0 LEER montoTotal montoPago = montoTotal * 1.18 SI ( montoPago > 500 ) ENTONCES montoPago = montoPago * 0.92 SINO montoPago = montoPago * 0.98 FINSI ESCRIBIR montoPago FIN

Pag. 132

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgArticulos package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgArticulos { public static void main ( String arg[] ) { double montoTotal = 0, montoPago = 0 ; System.out.print ( “ Ingrese el monto total: ” ) ; montoTotal = Lectura.leerDouble ( ) ; montoPago = montoTotal * 1.18 ; if (montoPago > 500) { montoPago = montoPago * 0.92 ; } else { montoPago = montoPago * 0.98 ; } System.out.print ( “ El monto total a pagar incluido IGV y descuentos es: ” ) ; System.out.println ( montoPago + “ soles ” ) ; } }

Pag. 133

Ing. Juan José Flores Cueto.

Problema 11 Etapa 01 - Descripción del problema. Leer la categoría y el sueldo de un trabajador, y calcular el aumento correspondiente teniendo en cuenta la siguiente tabla. Muestrar el nuevo sueldo del trabajador. Categoría 1 2 3 4

Aumento 25 % 15 % 10 % 05 %

Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Mostrar nuevo sueldo del trabajador. La categoría y el sueldo del trabajador. La categoría y el sueldo del trabajador serán almacenados en variables (categoria y sueldo). Dependiendo la categoría ingresada, se procederá a calcular el nuevo sueldo del trabajador (nuevoSueldo), teniendo como base la tabla mostrada. Finalmente, se mostrará el nuevo sueldo del trabajador.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo. 1. Nombre del Proyecto: ProyAumentoSueldo. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes. Diagrama de paquetes

Pag. 134

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgAumentoSueldo - método main ( ) ENTRADA: SALIDA:

categoria, sueldo nuevoSueldo

INICIO NUMERO categoria = 0, sueldo = 0, nuevoSueldo = 0 LEER sueldo, categoria CUANDO categoria SEA CASO 1 : nuevoSueldo = sueldo * 1.25 TERMINAR CASO 2 : nuevoSueldo = sueldo * 1.15 TERMINAR CASO 3 : nuevoSueldo = sueldo * 1.10 TERMINAR CASO 4 : nuevoSueldo = sueldo * 1.05 TERMINAR OTROS : nuevoSueldo = sueldo FINCUANDO ESCRIBIR nuevoSueldo FIN

Pag. 135

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgAumentoSueldo package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgAumentoSueldo { public static void main ( String arg[] ) { double sueldo = 0, nuevoSueldo = 0 ; int categoria = 0; System.out.print ( “ Ingrese el sueldo del trabajador: ” ) ; sueldo = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la categoría del trabajador: ” ) ; categoria = Lectura.leerInt ( ) ; switch (categoria) { case 1: nuevoSueldo = sueldo * 1.25 ; break ; case 2: nuevoSueldo = sueldo * 1.15 ; break ; case 3: nuevoSueldo = sueldo * 1.10 ; break ; case 4: nuevoSueldo = sueldo * 1.05 ; break ; default: nuevoSueldo = sueldo ; } System.out.println ( “ El nuevo sueldo del trabajador es: ” + nuevoSueldo ) ; } }

Pag. 136

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 12 Etapa 01 - Descripción del problema. Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo al tipo de enfermedad, según los datos de la tabla. Adicionalmente deberá considerarse que las mujeres tienen un incremento del 10% para el primer tipo de enfermedad y los hombres tienen un aumento del 5% para el tercer tipo de enfermedad. Enfermedad Tipo 1 2 3

Costo / Paciente / Día 200 350 420

Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

Mostrar el costo total de un paciente para un hospital. El tipo de enfermedad, el número de días de permanencia del paciente y su sexo. El tipo de enfermedad, el número de días y el sexo (1 si es hombre y 2 si es mujer) del paciente se almacenarán en variables (tipoEnfermedad, dias y sexo). Dependiendo del tipo de enfermedad, se procederá hacer el cálculo del costo que representa para el hospital el paciente, de acuerdo a la siguiente operación costoTotal = ( costo * número de días). Si se trata del primer tipo de enfermedad y el paciente es mujer se le incrementará el 10%. Por otro lado, si se trata del tercer tipo de enfermedad y el paciente es hombre se procederá a incrementar el 5%. El resultado se almacena en una variable (costoTotal) para luego ser mostrado.

Pag. 137

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. Para solucionar el problema se desarrollarán las especificaciones del proyecto en UML y el algoritmo en pseudocódigo.

1. Nombre del Proyecto: ProyHospital. 2. Definición de Paquetes y desarrollo de Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 138

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

4. Diseño de algoritmo para el método principal.

Algoritmo PrgHospital - método main ( )

ENTRADA: SALIDA:

tipoEnfermedad, dias, sexo costoTotal

INICIO NUMERO tipoEnfermedad = 0, dias = 0, sexo = 0, costoTotal = 0 LEER tipoEnfermedad, dias, sexo CUANDO tipoEnfermedad SEA CASO 1 : costoTotal = 200 * dias SI (sexo = 2 ) ENTONCES costoTotal = costoTotal * 1.10 FINSI TERMINAR CASO 2 : costoTotal = 350 * dias TERMINAR CASO 3 : costoTotal = 420 * dias SI ( sexo = 1 ) ENTONCES costoTotal = costoTotal * 1.05 FINSI FINCUANDO ESCRIBIR costoTotal FIN

Pag. 139

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. La codificación se desarrolla utilizando el lenguaje de programación Java.

Clase PrgHospital package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgHospital { public static void main ( String arg[] ) { int tipoEnfermedad = 0, dias = 0, sexo = 0 ; double costoTotal = 0 ; System.out.print ( “ Ingrese el tipo de enfermedad: ” ) ; tipoEnfermedad = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese el sexo del paciente [1=hombre, 2= Mujer]: ” ) ; sexo = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese el número de días que ha estado el paciente: ” ) ; dias = Lectura.leerInt ( ) ; switch ( tipoEnfermedad) { case 1 : costoTotal = 200 * dias ; if ( sexo == 2 ) { costoTotal = costoTotal * 1.10 ; } break ; case 2 : costoTotal = 350 * dias ; break ; case 3 : costoTotal = 420 * dias ; if ( sexo == 1 ) { costoTotal = costoTotal * 1.05 ; } } System.out.println ( “ El costo total es: ” + costoTotal ) ; } }

Pag. 140

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 13 Etapa 01 - Descripción del problema. Ingresar tres notas de un alumno. Muestrar las notas ordenadas en forma ascendente. Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Mostrar las tres notas en forma ascendente. Las tres notas del alumno en cualquier orden. Las tres notas del alumno serán almacenadas en variables (n1, n2 y n3). Se utilizarán tres variables auxiliares para almacenar el orden de las notas (menor, intermedio y mayor). Finalmente, las variables auxiliares mayor, intemedio y menor almacenarán las notas y se mostrarán en orden ascendente.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyOrdena. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 141

Ing. Juan José Flores Cueto.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgOrdena - método main ( ) ENTRADA: SALIDA:

n1, n2, n3 menor, intermedio, mayor

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, menor = 0, intermedio = 0 NUMERO mayor = 0 LEER n1, n2, n3 SI (n1 > n2) ENTONCES SI (n1 > n3) ENTONCES mayor = n1 SI (n2 > n3) ENTONCES intermedio = n2 menor = n3 SINO intermedio = n3 menor = n2 FINSI SINO mayor = n3 intermedio = n1 menor = n2 FINSI SINO SI (n2 > n3) ENTONCES mayor = n2 SI (n1 > n3) ENTONCES intermedio = n1 menor = n3 SINO intermedio = n3 menor = n1 FINSI SINO mayor = n3 intermedio = n2 menor = n1 FINSI FINSI ESCRIBIR menor, intermedio, mayor FIN

Pag. 142

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación.

Clase PrgOrdena package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgOrdena { public static void main ( String arg[] ) { int n1 = 0, n2 = 0, n3 = 0, menor = 0, intermedio = 0, mayor = 0 ; System.out.print ( “ Ingrese la primera nota: ” ) ; n1 = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la segunda nota: ” ) ; n2 = Lectura.leerInt ( ) ; System.out.print ( “ Ingrese la tercera nota: ” ) ; n3 = Lectura.leerInt ( ) ; if (n1 > n2) { if (n1 > n3) { mayor = n1 ; if (n2 > n3) { intermedio = n2 ; menor = n3 ; } else { intermedio = n3 ; menor = n2 ; } } else { mayor = n3 ; intermedio = n1 ; menor = n2 ; } } else { if (n2 > n3) { mayor = n2 ; if ( n1 > n3) { intermedio = n1 ; menor = n3 ; } else { intermedio = n3 ; menor = n1 ; } } else { mayor = n3 ; intermedio = n2 ; menor = n1 ; } } System.out.println ( menor + “ ” + intermedio + “ ” + mayor ) ; } }

Pag. 143

Ing. Juan José Flores Cueto.

Problema 14 Etapa 01 - Descripción del problema. Un curso se evalúa de la siguiente forma: se toma cinco prácticas calificadas, se determina el promedio de las cuatro notas más altas y se le da al estudiante una categoría que puede ser A, B, C o D. Según la siguiente tabla: Rango Desde 17 a 20 Desde 14 a 16 Desde 10 a 13 Desde 00 a 09

Categoria A B C D

Determinar la categoría del alumno.

Etapa 02 - Definición de la solución.

‰

Resultado deseado:

Mostrar la categoría del alumno.

‰

Datos necesarios:

Las cinco notas del estudiante.

‰

Procesamiento:

Las cinco notas del estudiante se ingresan a través del teclado y se almacenan en variables (n1, n2, n3, n4 y n5). La menor de estas notas se guardará en una variable (notaMenor). La suma de las cinco notas se guardará en una variable (sumaNotas). Se realizará el cálculo del promedio del alumno de la siguiente forma: promedio = ( sumaNotas – notaMenor ) / 4 ). El resultado es almacenado en la variable (promedio), este resultado nos permitirá obtener la categoría del alumno (categoria), para luego ser mostrada por pantalla.

Pag. 144

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyCategoriaAlumno. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 145

Ing. Juan José Flores Cueto.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgCategoriaAlumno - método main ( ) ENTRADA: SALIDA:

n1, n2, n3, n4, n5 categoria

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, sumaNotas = 0 NUMERO notaMenor = 0, promedio = 0 TEXTO categoria = ‘ ’ LEER n1, n2, n3, n4, n5 sumaNotas = n1 + n2 + n3 + n4 + n5 notaMenor = n1 SI (notaMenor>n2) ENTONCES notaMenor = n2 FINSI SI (notaMenor > n3) ENTONCES notaMenor = n3 FINSI SI (notaMenor > n4) ENTONCES notaMenor = n4 FINSI SI (notaMenor > n5) ENTONCES notaMenor = n5 FINSI promedio = (sumaNotas - notaMenor) / 4 SI (promedio = 17) ENTONCES categoria = ‘A’ SINO SI (promedio = 14) ENTONCES categoria = ‘B’ SINO SI (promedio = 10) ENTONCES categoria = ‘C’ SINO SI (promedio=0) ENTONCES categoria = ‘D’ FINSI FINSI FINSI FINSI ESCRIBIR categoria FIN

Pag. 146

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Etapa 04 - Desarrollo de la Codificación. Clase PrgCategoriaAlumno package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCategoriaAlumno { public static void main ( String arg[] ) { double n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, sumaNotas = 0 ; double notaMenor = 0, promedio = 0 ; char categoria = ‘ ’ ; System.out.print ( “ Ingrese la 1ra. nota: ” ) ; n1 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 2da. nota: ” ) ; n2 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 3ra. nota: ” ) ; n3 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 4ta. nota: ” ) ; n4 = Lectura.leerDouble ( ) ; System.out.print ( “ Ingrese la 5ta. nota: ” ) ; n5 = Lectura.leerDouble ( ) ; sumaNotas = n1 + n2 + n3 + n4 + n5 ; notaMenor = n1 ; if (notaMenor > n2) notaMenor = n2 ; if (notaMenor > n3) notaMenor = n3 ; if (notaMenor > n4) notaMenor = n4 ; if (notaMenor > n5) notaMenor = n5 ; promedio = (sumaNotas - notaMenor) / 4 ; if (promedio = 17) { categoria = ‘A’ ; } else { if (promedio = 14) { categoria = ‘B’ ; } else { if (promedio = 10) { categoria = ‘C’ ; } else { if (promedio = 0) { categoria = ‘D’ ; } } } } System.out.println ( “ La categoría del alumno es: ” + categoria ) ; } }

Pag. 147

Ing. Juan José Flores Cueto.

Problema 15 Etapa 01 - Descripción del problema. En una oficina de empleados, categorizan a los postulantes en función del sexo y de la edad, de acuerdo a lo siguiente: - Si la persona es de sexo femenino: o Categoría FA si tienen menos de 23 años. o Categoría FB en caso contrario. - Si la persona es de sexo masculino: o Categoría MA si tiene menos de 25 años. o Categoría MB en caso contrario. Etapa 02 - Definición de la solución. ‰ ‰ ‰

Resultado deseado: Datos necesarios: Procesamiento:

Mostrar la categoría del postulante. El sexo y la edad del postulante. El sexo y la edad del postulante se ingresan a través del teclado y se almacenan en variables (sexo y edad). Si es hombre o mujer asignaremos su respectiva categoría dependiendo de la edad del postulante. El resultado es almacenado en una variable (categoria) para luego ser mostrada por pantalla.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyCategoriaPostulante. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

Pag. 148

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal. Algoritmo PrgCategoriaPostulante - método main ( ) ENTRADA: SALIDA:

sexo, edad categoria

INICIO NUMERO edad = 0 TEXTO sexo = ‘F’, categoria = 0 LEER sexo, edad CUANDO sexo SEA CASO ‘f’: CASO ‘F’: SI (edad < 23) ENTONCES categoria = “FA” SINO categoria = “FB” FINSI TERMINAR CASO ‘m’: CASO ‘M’: SI (edad < 25) ENTONCES categoria = “MA” SINO categoria = “MB” FINSI FINCUANDO ESCRIBIR categoria FIN

Pag. 149

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgCategoriaPostulante package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgCategoriaPostulante { public static void main ( String arg[] ) { int edad = 0 ; char sexo = ‘F’ ; String categoria = “ ” ; System.out.print ( “ Ingrese sexo del postulante [ F/M ]: ” ) ; sexo = Lectura.leerChar ( ) ; System.out.print ( “ Ingrese la edad del postulante: ” ) ; edad = Lectura.leerInt ( ) ; switch (sexo) { case ‘f’ : case ‘F’ : if (edad < 23) categoria = “FA” ; else categoria = “FB” ; break ; case ‘m’ : case ‘M’ : if (edad < 25) categoria = “MA” ; else categoria = “MB” ; } System.out.println ( “ La categoría del postulante es: ” + categoria ) ; } }

Pag. 150

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 16 Etapa 01 - Descripción del problema. Calcular la nota final de todos los alumnos del curso utilizando la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 Ingresar las notas a través del teclado. Utilizar la estructura lógica MIENTRAS. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

Mostrar la nota final de todos los alumnos de un curso. Las cuatro notas de cada uno de los alumnos del curso. Las cuatro notas del alumno se ingresan a través del teclado y se almacenan en variables (n1, n2, n3 y n4). Se realizará el cálculo de la nota final en base a la fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable (nf) para luego ser mostrada. Esto se repite para todos los alumnos del curso, con la finalidad de poder mostrar la nota final de cada uno de ellos.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyNotasAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

Pag. 151

Ing. Juan José Flores Cueto.

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

4. Diseño de algoritmo para el método principal.

Algoritmo PrgNotasAlumnos - método main ( )

ENTRADA: numAlumnos, n1, n2, n3, n4 SALIDA: nf INICIO NUMERO i = 1, n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0 NUMERO numAlumnos = 1 LEER numAlumnos MIENTRAS ( i mayorSueldo ) { mayorSueldo = sueldo ; } } switch (categoria) { case 1: sueldo1 = sueldo1 + sueldo ; break ; case 2: sueldo2 = sueldo2 + sueldo ; break ; case 3: sueldo3 = sueldo3 + sueldo ; } } } while (categoria != 0 ) ; System.out.println ( “ Suma de sueldos de obreros: ” + sueldo1 ) ; System.out.println ( “ Suma de sueldos de empleados: ” + sueldo2 ) ; System.out.println ( “ Suma de sueldos de gerentes: ” + sueldo3 ) ; System.out.println ( “ El sueldo más bajo es: ” +menorSueldo ) ; System.out.println ( “ El sueldo más alto es: ” + mayorSueldo ) ; } }

Pag. 160

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 19 Etapa 01 - Descripción del problema. Calcular y mostrar el número de alumnos que tienen promedio final menor que 10, los alumnos que tiene promedio final entre 10 y 14, los alumnos que tienen promedio final entre 15 y 18, y los alumnos que tienen promedio final mayor que 18. Ingresar las 4 notas de cada alumno y calcular su promedio final en base a la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

Mostrar el número de alumnos con promedio final menor que 10, el número de alumnos con promedio final entre 10 y 14, el número de alumnos con promedio final entre 15 y 18, y el número de alumnos con promedio final mayor que 18. Las cuatro notas de cada uno de los alumnos del curso. Las cuatro notas del alumno se ingresan y se almacenan en las variables n1, n2, n3 y n4. Se realiza el cálculo del promedio final en base a la fomula: nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5. El resultado es almacenado en la variable nf, para ser evaluada. Si el promedio final (nf) es menor que 10 se aumenta 1 a la variable total1. Si el promedio final (nf) está entre 10 y 14 se aumenta 1 a la variable total2. Si el promedio final (nf) está entre 15 y 18 se aumenta 1 a la variable total3 y si el promedio final (nf) es mayor que 18 se aumenta 1 a la variable total4. Este proceso se repite para todos los alumnos del curso con la finalidad de determinar su promedio final (nf) y evaluar su rango.

Pag. 161

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyNotasRango. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 162

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

3. Diseño de algoritmo para el método principal.

Algoritmo PrgNotasRango - método main ( ) ENTRADA: SALIDA:

numAlumnos, n1, n2, n3, n4 total1, total2, total3, total4

INICIO NUMERO n1 = 0, n2 = 0, n3 = 0, n4 = 0, nf = 0, numAlumnos = 0 NUMERO i = 1, total1 = 0 , total2 = 0 , total3 = 0 , total4 = 0 LEER numAlumnos MIENTRAS ( i 20) HACER LEER n2 MIENTRAS (n2 < 0 OR n2 > 20) HACER LEER n3 MIENTRAS (n3 < 0 OR n3 > 20) HACER LEER n4 MIENTRAS (n4 < 0 OR n4 > 20) nf = (n1 + n2 + n3 + ( n4 * 2 ) ) / 5 SI (nf < 10.5) ENTONCES total1 = total1 + 1 FINSI SI (nf >= 10.5 AND nf < 14.5) ENTONCES total2 = total2 + 1 FINSI SI (nf >= 14.5 AND nf < 17.5) ENTONCES total3 = total3 + 1 FINSI SI (nf >= 17.5) ENTONCES total4 = total4 + 1 FINSI i=i+1 FINMIENTRAS ESCRIBIR total1, total2, total3, total4 FIN

Pag. 163

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgNotasRango package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNotasRango { public static void main ( String arg[] ) { int i = 1, numAlumnos = 0 ; double n1= 0, n2= 0, n3= 0, n4= 0, nf= 0, total1 = 0, total2 = 0, total3 = 0, total4 = 0 ; System.out.println ( “ Ingrese el número de alumnos: ” ) ; numAlumnos = Lectura.leerInt ( ) ; while (i 20) ; do { System.out.println ( “ Ingrese nota 2 del alumno [” + i + “]: n2 = Lectura.leerDouble ( ) ; } while ((n2 < 0 || n2 > 20) ; do { System.out.println ( “ Ingrese nota 3 del alumno [” + i + “]: n3 = Lectura.leerDouble ( ) ; } while (( n3 < 0 || n3 > 20 ) ; do { System.out.println ( “ Ingrese nota 4 del alumno [” + i + “]: n4 = Lectura.leerDouble ( ) ; } while (( n4 < 0 || n4 > 20 ) ;

”);

”);

”);

”);

nf = (n1 + n2 + n3 + ( n4 * 2) ) / 5 ; if (nf < 10.5) total1++ ; if (nf >= 10.5 && nf < 15.5) total2++ ; if (nf >= 15.5 && nf < 17.5) total3++ ; if (nf >= 17.5) total4++ ; i ++ ; } System.out.println ( “ Total alumnos con promedio menor a 10: ” + total1 ) ; System.out.println ( “ Total alumnos con promedio entre 10 y 14: ” + total2 ) ; System.out.println ( “ Total alumnos con promedio entre 15 y 18: ” + total3 ) ; System.out.println ( “ Total alumnos con promedio mayor a 18: ” + total4 ) ; } }

Pag. 164

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 20 Etapa 01 - Descripción del problema. Elaborar una solución que permita controlar la venta de boletos en un determinado día en un teatro de la capital, en base a la siguiente información: • Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y mezanine. • Por cada entrada vendida se leerá los siguientes datos: número de boleto y lugar (puede ser platea, palco o mezanine). • El programa terminará cuando el número de boleto sea igual a cero. • Antes de finalizar, se deberá proporcionar la siguiente información: • Número total de entradas vendidas durante el día. • El total de soles recaudados en el día. • Número de entradas vendidas para platea, palco y mezanine en el día.

Etapa 02 - Definición de la solución. ‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

El número total de entradas vendidas, el monto total recaudado y el número de entradas vendidas para platea, palco y mezanine en un determinado día. El costo del boleto para platea, palco y mezanine en general, y por cada venta, el número de boleto y el tipo de boleto (es decir, si es para platea, palco o mezanine). El costo del boleto para platea, palco y mezanine se ingresarán a través del teclado y se almacenarán en las variables costoPla, costoPal y costoMez respectivamente. Cada vez que se venda un boleto se ingresará el número y tipo de boleto, y se almacenarán en las variables numBoleto y tipo respectivamente. Luego se evaluará el tipo de boleto. Si es un boleto para platea se aumenta 1 a la variable totalPla, si es un boleto para palco se aumenta 1 a la variable totalPal y si es un boleto para mezanine se aumenta 1 a la variable totalMez. Al finalizar la venta de boletos se suma el valor de las variables totalPla, totalPal y totalMez para obtener el total de boletos vendidos (totalVendidas). De igual forma, cada variable (totalPla, totalPal y totalMez) se multiplica por el costo del boleto (costoPla, costoPal y costoMez) según corresponda, para obtener la ganancia en

Pag. 165

Ing. Juan José Flores Cueto.

platea (gananciaPla), palco (gananciaPal) y mezanine (gananciaMez). La ganancia total (totalGanancia) se obtiene al sumar el valor de las variables ganaciaPla, gananciaPal y gananciaMez.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyTeatro. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 166

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

4. Diseño de algoritmo para el método principal. Algoritmo PrgTeatro - método main ( ) ENTRADA: SALIDA:

costoPla, costoPal, costoMez totalVendidas, totalGanancia, totalPla, totalPal, totaMez

INICIO NUMERO numBoleto = 0, tipo = 0, totalVendidas = 0 NUMERO totalPla = 0, totalPal = 0, totalMez = 0 NUMERO costoPla = 0, costoPal = 0, costoMez = 0 NUMERO totalGanancia =0, gananciaPla = 0, gananciaPal = 0 NUMERO ganaciaMez = 0 LEER costoPla, costoPal, costoMez HACER HACER LEER numBoleto MIENTRAS ( numBoleto < 0) SI ( numBoleto 0 ) ENTONCES HACER LEER tipo MIENTRAS (tipo < 1 OR tipo >3) CUANDO tipo SEA CASO 1 : totalPla = totalPla + 1 TERMINAR CASO 2 totalPal = totalPal + 1 TERMINAR CASO 3 totalMez = totalMez + 1 FINCUANDO MIENTRAS (numBoleto 0) totalVendidas = totalPla + totalPal + totalMez ganaciaPla = totalPla * costoPla ganaciaPal = totalPal * costoPal ganaciaMez = totalMez * costoMez totalGanancia = gananciaPla + gananciaPal + gananciaMez ESCRIBIR totalVendidas ESCRIBIR totalGanancia ESCRIBIR totalPla, totalPal, totalMez FIN

Pag. 167

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. Clase PrgTeatro package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgTeatro { public static void main ( String arg[] ) { int numBoleto = 0, tipo = 0, totalVendidas = 0, totalPla=0, totalPal=0, totalMez=0 ; double totalGanancia=0, costoPla = 0, costoPal = 0, costoMez = 0 ; double gananciaPla = 0, gananciaPal = 0, ganaciaMez = 0 ; System.out.println ( “ Ingrese el costo de la entrada para platea: ” ) ; costoPla = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese el costo de la entrada para palco: ” ) ; costoPal = Lectura.leerDouble ( ) ; System.out.println ( “ Ingrese el costo de la entrada para mezanine: ” ) ; costoMez = Lectura.leerDouble ( ) ; do { do { System.out.println ( “ Ingrese el número de boleto: ” ) ; numBoleto = Lectura.leerInt ( ) ; } while (numBoleto < 0) ; if ( numBoleto != 0) { do { System.out.println ( “ Ingrese el lugar ” ) ; System.out.println ( “ [1] Platea, [2] Palco [3] Mezanine ” ) ; tipo = Lectura.leerInt ( ) ; } while (tipo < 1 || tipo > 3) ; switch ( tipo) { case 1 : totalPla ++ ; break ; case 2 : totalPal ++ ; break ; case 3 : totalMez ++ ; } } } while ( numBoleto != 0 ) ; totalVendidas = totalPla + totalPal + totalMez ; ganaciaPla = totalPla * costoPla ; ganaciaPal = totalPal * costoPal ; ganaciaMez = totalMez * costoMez ; totalGanancia = gananciaPla + gananciaPal + gananciaMez ; System.out.println ( “ Número total de entradas: ” + totalVendidas ) ; System.out.println ( “ Total recaudado S/. ” + totalGanancia ) ; System.out.println ( “ Total vendidas platea: ” + totalPla ) ; System.out.println ( “ Total vendidas palco: ” + totalPal ) ; System.out.println ( “ Total vendidas mezanine: ” + totalMez ) ; } }

Pag. 168

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 21 Etapa 01 - Descripción del problema. Los empleados de una fábrica trabajan en tres turnos; mañana, tarde y noche. Se desea calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente: -

La tarifa del turno mañana y tarde es de S/ 8.00 soles por hora. La tarifa del turno noche es de S/ 10.00 soles por hora. En caso de ser un día domingo, la tarifa se incrementa en 50% para los turnos mañana y tarde y en 60% para el turno noche. Para el turno tarde se incrementa S/ 10.00 soles por concepto de movilidad.

Etapa 02 - Definición de la solución.

‰

Resultado deseado:

‰

Datos necesarios:

‰

Procesamiento:

Calcular y mostrar el jornal diario de cada empleado. El número de horas, el turno y el día que trabajó el empleado. El número de horas, el turno y el día del empleado se ingresan a través del teclado y se almacenan en variables (horas, turno y dia). Dependiendo del turno se obtiene la tarifa para luego hacer el cálculo del jornal de la siguiente forma: jornal = horas * tarifa ; El resultado es almacenado en una variable (jornal) para luego ser mostrada por pantalla. Este proceso se repite para cada uno de los empleados de la fábrica.

Pag. 169

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyJornal. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes. Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 170

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

4. Diseño de algoritmo para el método principal. Algoritmo PrgJornal - método main ( ) ENTRADA: SALIDA:

numEmpleados, horas, turno, dia jornal

INICIO NUMERO numEmpleados = 0, i = 0, horas = 0, dia = 0, turno = 0 NUMERO tarifa = 0, jornal = 0 HACER LEER numEmpleados SI (numEmpleados 10) aprobados += 1 ; } do { System.out.println ( “ ¿Desea ingresar un nuevo alumno [S/N]?: ” ) ; rpta = Lectura.leerChar ( ) ; if ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N ’ ) System.out.println ( “Respuesta no válida.” ) ; } while ( rpta != ‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta != ‘N’ ) ; } while ( rpta == ‘s’ || rpta == ‘S’ ) ; System.out.println ( “Hay ” + matriculadas + “ alumna(s) matriculada(s). ”) ; System.out.println ( “Hay ” + matriculados + “ alumno(s) matriculado(s). ”) ; System.out.println ( “Hay ” + menores + “ alumna(s) menor(es) de 20 años. ” ) ; System.out.println ( “Hay ” + mayores + “ alumno(s) mayor(es) de 18 años. ” ) ; System.out.println ( “Hay ” + desaprobadas + “ alumna(s) desaprobada(s). ” ) ; System.out.println ( “Hay ” + aprobados + “ alumno(s) aprobado(s). ” ) ; } }

Pag. 179

Ing. Juan José Flores Cueto.

Pag. 180

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 23 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar un número por teclado. Mostrar el número con las cifras invertidas, el número de cifras que tiene el número, la suma de las cifras, el número de cifras pares e impares, y si el número es capicua o no. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumCifras package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumCifras { public static void main ( String arg [ ] ) { int num = 0, numInv = 0, res = 0, cont = 0, suma = 0, contPar = 0, contImp = 0, n ; System.out.println ( “ Ingrese un número entero: ” ) ; num = Lectura.leerInt ( ) ; n = num ; while ( n != 0 ) { res = n % 10 ; numInv = numInv * 10 + res ; cont ++ ; suma = suma + res ; if ( res % 2 == 0 ) contPar ++ ; else contImp ++ ; n = n / 10 ; } System.out.println ( “ El número invertido es : ” + numInv ) ; System.out.println ( “ El número de cifras es : ” + cont ) ; System.out.println ( “ La suma de las cifras es : ” + suma ) ; System.out.println ( “ El número de cifras pares es : ” + contPar ) ; System.out.println ( “ El número de cifras impares es : ” + contImp ) ; if ( num == numInv ) System.out.println ( “ El número es capicua ” ) ; else System.out.println ( “ El número no es capicua ” ) ; } }

En base al análisis de la codificación desarrolle la Etapa 02 y la Etapa 03 del método.

Pag. 181

Ing. Juan José Flores Cueto.

Problema 24 Etapa 01 - Descripción del problema. Desarrollar un programa que permita ingresar el día, el mes y el año de una determina fecha. Determinar si la fecha ingresada es correcta y si el año es bisiesto o no. Etapa 04 - Desarrollo de la Codificación. Clase PrgVerificaFecha package dominioDeLaAplicacion; /** Clase: PrgVerificaFecha.java * Dada una fecha en dia, mes y año se determina si esta correcta la fecha y si * es año bisiesto * Un año es bisiesto si es múltiplo de 4, por ejemplo 1984, pero los años * múltiplos de 100 sólo son bisiestos cuando a su vez son múltiplos de 400, * por ejemplo 1800 no es bisiesto, mientras que 2000 si lo es. */ import biblioteca.Lectura; class PrgVerificaFecha { public static void main ( String arg[] ) { int dia, mes, año ; boolean verifdia = false, bisiesto = false ; String mess = “ ” ; System.out.println ( “ Ingrese el número del día: ” ) ; dia = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese el número del mes: ” ) ; mes = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese el año: ” ) ; año = Lectura.leerInt ( ) ; // verifica año bisiesto if ( año % 4 == 0 && año % 100 != 0 || año % 400 == 0 ) { bisiesto = true ; } //verifica el dia switch (mes) { case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 :

Pag. 182

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgVerificaFecha If ( dia > 0 && dia 0) && ( dia 0 ) && ( dia 0 ) && ( dia 0 ) && ( mes 0 ) ) { switch (mes) { case 1 : mess = “Enero” ; break ; case 2 : mess = “Febrero” ; break ; case 3 : mess = “Marzo” ; break ; case 4 : mess = “Abril” ; break ; case 5 : mess = “Mayo” ; break ; case 6 : mess = “Junio” ; break ; case 7 : mess = “Julio” ; break ; case 8 : mess = “Agosto” ; break ;

Pag. 183

Ing. Juan José Flores Cueto.

Clase PrgVerificaFecha case 10 : mess = “Octubre” ; break ; case 11 : mess = “Noviembre” ; break; case 12 : mess = “Diciembre” ; break ; } System.out.println ( dia + “ de ” + mess + “ de ” + año ) ; if ( bisiesto ) { System.out.println ( “ Es año bisiesto ” ) ; } else { System.out.println ( “ No es año bisiesto ” ) ; } } else { System.out.println ( “ error en fecha ” ) ; } } }

Pag. 184

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 25 Etapa 01 - Descripción del problema. Desarrollar un programa que permita ingresar un número arábico entre 1000 y 3000. Determinar y mostrar el equivalente del número ingresado en número romano. Etapa 04 - Desarrollo de la Codificación. Clase PrgNumRomano package dominioDeLaAplicacion ; /** Clase: PrgNumRomano.java * Dado un año en números arábigos, imprimirlo en números romanos dentro de * rango de 1000 a 3000 * Programación Básica */ import biblioteca.Lectura ; class PrgNumRomano { public static void main ( String arg [ ] ) { int arabigo, resto, unidad, decena, centena, miles ; String romano = “ ” ; System.out.println ( “ Ingrese un número entre 1000 y 3000: ” ) ; arabigo = Lectura.leerInt ( ) ; if ( arabigo >= 1000 && arabigo 99 ) System.out.println ( “Número ingresado no válido... Reintente!!! ” ) ; } while ( num < 0 || num > 99 ) ; dec = num / 10 ; uni = num % 10 ; switch ( uni ) { case 0 : letra = cero ; break ; case 1 : letra = uno ; break ;

Pag. 188

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgNumALetras01 case 2 : letra = dos ; break ; case 3 : letra = tres ; break ; case 4 : letra = cuatro ; break ; case 5 : letra = cinco ; break ; case 6 : letra = seis ; break ; case 7 : letra = siete ; break ; case 8 : letra = ocho ; break ; case 9 : letra = nueve ; break ; } switch ( dec ) { case 1 : switch ( uni ) { case 0 : letra = diez ; break ; case 1 : letra = once ; break ; case 2 : letra = doce ; break ; case 3 : letra = trece ; break ; case 4 : letra = catorce ; break ; case 5 : letra = quince ; break ; default : letra = dieci + letra ; } break ;

Pag. 189

Ing. Juan José Flores Cueto.

Clase PrgNumALetras01 case 2 : if ( uni == 0 ) letra = veinte ; else letra = veinti + letra ; break ; case 3 : if ( uni == 0 ) letra = treinta ; else letra = treinta + y + letra ; break ; case 4 : if ( uni == 0 ) letra = cuarenta ; else letra = cuarenta + y + letra ; break ; case 5 : if ( uni == 0 ) letra = cincuenta ; else letra = cincuenta + y + letra ; break ; case 6 : if ( uni == 0 ) letra = sesenta ; else letra = sesenta + y + letra ; break ; case 7 : if ( uni == 0 ) letra = setenta ; else letra = setenta + y + letra ; break ; case 8 : if ( uni == 0 ) letra = ochenta ; else letra = ochenta + y + letra ; break ; case 9 : if ( uni == 0 ) letra = noventa ; else letra = noventa + y + letra ; } System.out.print ( “El número ” + num + “ en letras es ” + letra ) ; } }

Pag. 190

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Problema 27 Etapa 01 - Descripción del problema. En base al programa anterior, desarrollar otro programa que permita ingresar un número entero menor que 1000 y permita mostrar su equivalente en letras. Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumALetras02 package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumALetras02 { public static void main ( String arg [ ] ) { String letra = “”, cero = “cero”, uno = “uno”, dos = “dos”, tres = “tres”; String cuatro = “cuatro”, cinco = “cinco”, seis = “seis”, siete = “siete”; String ocho = “ocho”, nueve = “nueve”, diez = “diez”, once = “once”; String doce = “doce”, trece = “trece”, catorce = “catorce”, quince = “quince”; String dieci = “dieci”; String veinte = “veinte”, veinti = “veinti”, y = “ y ”, treinta = “treinta”; String cuarenta = “cuarenta”, cincuenta = “cincuenta”, sesenta = “sesenta”; String setenta = “setenta”, ochenta = “ochenta”, noventa = “noventa”; String cien = “cien”, ciento = “ciento ”, cientos = “cientos ”; String quinientos = “quinientos ”, sete = “sete”, nove = “nove”; int num, cen, resto, dec, uni; do { System.out.println ( “ Ingrese un número entero menor que 1000: ” ) ; num = Lectura.leerInt ( ) ; if ( num < 0 || num > 999 ) System.out.println ( “ Número ingresado no válido... Reintente!!! ” ) ; } while ( num < 0 || num > 999 ) ; cen = num / 100 ; resto = num % 100 ; dec = resto / 10 ; uni = resto % 10 ; switch ( uni ) { case 0 : letra = cero ; break ; case 1 : letra = uno ; break ;

Pag. 191

Ing. Juan José Flores Cueto.

Clase PrgNumALetras02 case 2 : letra = dos ; break ; case 3 : letra = tres ; break ; case 4 : letra = cuatro ; break ; case 5 : letra = cinco ; break ; case 6 : letra = seis ; break ; case 7 : letra = siete ; break ; case 8 : letra = ocho ; break ; case 9 : letra = nueve ; break ; } switch (dec) { case 1 : switch (uni) { case 0 : letra = diez ; break ; case 1 : letra = once ; break ; case 2 : letra = doce ; break ; case 3 : letra = trece ; break ; case 4 : letra = catorce ; break ; case 5 : letra = quince ; break ; default : letra = dieci + letra ; } break ; case 2 :

Pag. 192

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgNumALetras02 if ( uni == 0 ) letra = veinte ; else letra = veinti + letra ; break ; case 3 : if ( uni == 0 ) letra = treinta ; else letra = treinta + y + letra ; break ; case 4 : if (uni == 0) letra = cuarenta ; else letra = cuarenta + y + letra ; break ; case 5 : if ( uni == 0 ) letra = cincuenta ; else letra = cincuenta + y + letra ; break ; case 6 : if ( uni == 0 ) letra = sesenta ; else letra = sesenta + y + letra ; break ; case 7 : if ( uni == 0 ) letra = setenta ; else letra = setenta + y + letra ; break ; case 8 : if ( uni == 0 ) letra = ochenta ; else letra = ochenta + y + letra ; break ; case 9 : if ( uni == 0 ) letra = noventa ; else letra = noventa + y + letra ; } switch ( cen ) { case 1 : if ( dec == 0 && uni == 0 ) letra = cien ; else

Pag. 193

Ing. Juan José Flores Cueto.

Clase PrgNumALetras02 letra = ciento + letra ; break ; case 2 : if ( dec == 0 && uni == 0 ) letra = dos + cientos ; else letra = dos + cientos + letra ; break ; case 3 : if ( dec == 0 && uni == 0 ) letra = tres + cientos ; else letra = tres + cientos + letra ; break ; case 4 : if ( dec == 0 && uni == 0 ) letra = cuatro + cientos ; else letra = cuatro + cientos + letra ; break ; case 5 : if ( dec == 0 && uni == 0 ) letra = quinientos ; else letra = quinientos + letra ; break ; case 6 : if ( dec == 0 && uni == 0 ) letra = seis + cientos ; else letra = seis + cientos + letra ; break ; case 7 : if ( dec == 0 && uni == 0 ) letra = sete + cientos ; else letra = sete + cientos + letra ; break ; case 8 : if ( dec == 0 && uni == 0 ) letra = ocho + cientos ; else letra = ocho + cientos + letra ; break ; case 9 : if ( dec == 0 && uni == 0 ) letra = nove + cientos ; else letra = nove + cientos + letra ; break ; } System.out.print ( “El número ” + num + “ en letras es ” + letra ) ; } }

Pag. 194

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

MANEJO DE EXCEPCIONES Cuando se está ejecutando un programa y ocurre un error, Java lanza una excepción que cuando no se captura da lugar a un mensaje sobre lo ocurrido y detiene la ejecución del programa (es importante establecer que las excepciones se lanzan, no ocurren). Ahora, si se desea que la ejecución del programa no se detenga, se deberá capturar la excepción lanzada y manejarla. Las excepciones en Java son objetos de subclases de la clase Throwable. Existen diversos errores que pueden ocasionar que se lance una excepción en un programa, por ejemplo, una entrada incorrecta de datos (IOException), una división por cero (ArithmeticException) o una conversión de datos no válida (NumberFormatException). Para evitar que la ejecución de un programa se detenga debido a un error que lanza una excepción, se debe utilizar la sentencia try para alertar al programa acerca del código que puede ocasionar un error, y utilizar la sentencia catch para capturar y manejar cada una de las excepciones que se puedan lanzar. El formato de la sentencia try y catch es el siguiente:

Tipo de excepción capturada por la sentencia catch con la finalidad de manejarla.

try { // Código de la aplicación. … … … … … } catch (

) { // Código de tratamiento de la excepción. … … … … …

}

Significa: “Intentar ejecutar las sentencias ubicadas entre las llaves del try y si ocurre un error y se lanza una excepción capturarla con la sentencia catch y manejarla con las sentencias ubicadas entre las llaves del catch”.

Pag. 195

Ing. Juan José Flores Cueto.

Esto significa que durante la ejecución del programa normalmente se ejecutarán las sentencias que están dentro de las llaves de la sentencia try: try { // Código de la aplicación. … … }

Si no ocurre un error, no se lanzará ninguna excepción, lo que significa que las sentencias que están entre las llaves de la sentencia catch no se ejecutarán. Si ocurre un error, se lanzará una excepción, interrumpiéndose la ejecución de las sentencias que están entre las llaves de la sentencia try y se ejecutarán las sentencias que están entre las llaves de la sentencia catch, siempre y cuando se haya especificado capturar la excepción lanzada. Como se ha indicado, existen diferentes tipos de excepciones por lo que es común observar en un programa una sentencia try con varias sentencias catch. Cada sentencia catch capturará y manejara un excepción. try { /* Código de la aplicación que se prevee que puedan lanzar una excepción.*/ … … } catch ( ArithmeticException e ) { /* Código de tratamiento de ArithmeticException. */ … … } catch ( NumberFormatException e ) { /* Código de tratamiento NumberFormatException. */ … …

de

la

excepción

la

excepción

}

En el ejemplo anterior, se ha especificado capturar dos excepciones en caso de que estás se lancen (ArithmeticException y NumberFormatException).

Pag. 196

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

El manejo de excepciones ofrece una forma de escribir o codificar programas con una mayor claridad y sencillez, separando explícitamente el código que maneja los errores del código básico de una aplicación. En la actualidad, se considera como “buen estilo de programación” el uso de las excepciones en los programas. Como ejemplo de excepciones se puede mencionar:

Excepción

Descripción

ArithmeticException

Una condición aritmética excepcional ocurrio.

NumberFormatException

Se intentó convertir una cadena con un formato inapropiado a un número.

IOException

Problemas al realizar operaciones de entrada y salida de datos.

ArrayIndexOutOfBoundException

Un arreglo fué accedido con un índice ilegal (fuera de los límites permitidos).

NullPointerException

Se intentó utilizar null donde se requería un objeto.

Pag. 197

Ing. Juan José Flores Cueto.

Problema 28 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar dos números enteros. Mostrar el resultado de dividir ambos números. Se debe tener en cuenta que existe la posibilidad que el divisor sea igual a cero. Etapa 04 - Desarrollo de la Codificación.

Clase PrgDivisionSinExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgDivisionSinExcepcion { public static void main ( String arg [ ] ) { int dividendo, divisor, rpta ; System.out.println ( “ Ingrese el dividendo: ” ) ; dividendo = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese el divisor: ” ) ; divisor = Lectura.leerInt ( ) ; rpta = dividendo / divisor ; System.out.println ( “ El resultado de la división es: ” + rpta ) ; } }

Ejecute el siguiente programa e ingrese cero al divisor. Al momento de realizar la división se lanzará la excepcion llamada ArithmeticException debido a que no se puede dividir un número entero entre cero, finalizando la ejecución del programa. Para evitar que el programa finalice es necesario manejar dicha excepción. Intente incluir en el programa anterior el manejo de la excepción lanzada. Analice el siguiente programa y anote sus conclusiones.

Pag. 198

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgDivisionConExcepcion package dominioDeLaAplicacion; import biblioteca.Lectura; class PrgDivisionConExcepcion { public static void main ( String arg [ ] ) { int dividendo, divisor, rpta ; System.out.println ( “ Ingrese el dividendo: ” ) ; dividendo = Lectura.leerInt ( ) ; System.out.println ( “ Ingrese el divisor: ” ) ; divisor = Lectura.leerInt ( ) ; try { rpta = dividendo / divisor ; System.out.println ( “ El resultado de la división es: ” + rpta ) ; } catch ( ArithmeticException e ) { System.out.println ( “ No se puede dividir un número entre cero ” ) ; } } }

Pag. 199

Ing. Juan José Flores Cueto.

Problema 29 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar la hora en el siguiente formato hh:mm:ss donde “hh” es igual a la hora (de 00 a 23 horas), “mm” es igual a los minutos (de 00 a 59 minutos) y “ss” es igual a los segundos (de 00 a 59 segundos). Mostrar un mensaje cuando la hora ingresada sea válida. Manejar excepciones. Etapa 04 - Desarrollo de la Codificación. Clase PrgHoraConExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgHoraConExcepcion { public static void main ( String arg [ ] ) { boolean valido ; String hora, tmp ; int hh, mm, ss ; do { System.out.println ( “ Ingrese la hora en el siguiente formato: hh:mm:ss ” ) ; hora = Lectura.leerString ( ) ; try { tmp = hora.substring ( 0, 2 ) ; hh = Integer.parseInt ( tmp ) ; if ( hh < 0 || hh > 23 ) { System.out.println ( “ Hora ingresada no válida ” ) ; valido = true ; } else { tmp = hora.substring ( 3, 5 ) ; mm = Integer.parseInt ( tmp ) ; if (mm < 0 || mm > 59) { System.out.println ( “ minuto ingresado no válido ” ) ; valido = true ; } else { tmp = hora.substring ( 6 ) ; ss = Integer.parseInt ( tmp ) ; if (ss < 0 || ss > 59) { System.out.println ( “ segundo ingresado no válido ” ) ; valido = true ; } else { valido = false ; } } }

Pag. 200

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgHoraConExcepcion } catch ( NumberFormatException error ) { System.out.println ( “Error... ” ) ; valido = true ; } } while ( valido ) ; System.out.println ( “ La hora se ingresó correctamente... ” ) ; } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como hora lo siguiente: 23:10:xx Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números. Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String.

Pag. 201

Ing. Juan José Flores Cueto.

Problema 30 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar la fecha en una variable de tipo texto o cadena con el siguiente formato: dd/mm/aaaa. Validar que la fecha ingresada tenga el formato especificado. Manejar excepciones. Etapa 04 - Desarrollo de la Codificación. Clase PrgFechaConExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgFechaConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true ; String fecha, tmp, puntos1, puntos2 ; int dia, mes, año ; do { System.out.println ( “ Ingrese la fecha en el formato: dd/mm/aaaa ” ) ; fecha = Lectura.leerString ( ) ; fecha = fecha.trim ( ) ; if ( fecha.length ( ) == 10 ) { try { tmp = fecha.substring ( 0, 2 ) ; dia = Integer.parseInt ( tmp ) ; tmp = fecha.substring ( 3, 5 ) ; mes = Integer.parseInt ( tmp ) ; tmp = fecha.substring ( 6 ) ; año = Integer.parseInt ( tmp ) ; puntos1 = fecha.substring ( 2, 3 ) ; puntos2 = fecha.substring ( 5, 6 ) ; if (puntos1.equals (“/”) && puntos2.equals (“/”) ) valido = false ; else valido = true ; } catch (NumberFormatException error ) { valido = true ; }

Pag. 202

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgFechaConExcepcion } else valido = true ; if ( valido ) System.out.println ( “ Error... Ingrese la fecha según formato!!! ” ) ; } while ( valido ) ; System.out.println ( “ El formato esta correcto... ” ) ; System.out.print ( “ Ahora Ud. continue el programa validando el valor ” ) ; System.out.println ( “ de las variable dia, mes y año ” ) ; // Continúa la validación de la fecha... ver problema 24 y 127. } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como fecha lo siguiente: 23/xx/2005 Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar del / ). Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String.

Pag. 203

Ing. Juan José Flores Cueto.

Problema 31 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar dos números de tres digitos en una variable de tipo texto o cadena con el siguiente formato: nnn//nnn. Validar que los números sean de tres cifras y mostrar la división de los mismos. Manejar excepciones. Etapa 04 - Desarrollo de la Codificación.

Clase PrgNumeroConExcepcion package dominioDeLaAplicacion ; import biblioteca.Lectura ; class PrgNumeroConExcepcion { public static void main ( String arg [ ] ) { boolean valido = true ; String numeros, tmp, puntos1 ; int num1, num2 ; double resultado ; do { System.out.println ( “ Ingrese dos números con el formato: nnn//nnn ” ) ; numeros = Lectura.leerString ( ) ; numeros = numeros.trim ( ) ; if ( numeros.length ( ) == 8 ) { try { tmp = numeros.substring ( 0, 3 ) ; num1 = Integer.parseInt ( tmp ) ; tmp = numeros.substring ( 5 ) ; num2 = Integer.parseInt ( tmp ) ; puntos1 = numeros.substring ( 3, 5 ) ; if ( puntos1.equals ( “//” ) ) { valido = false ; resultado = num1 / num2 ; System.out.println ( “ La división es: ” + resultado ) ; } else { valido = true ; }

Pag. 204

ESTRUCTURAS FUNDAMENTALES EN LA SOLUCIÓN DE PROBLEMAS

Clase PrgNumeroConExcepcion } catch ( NumberFormatException error ) { System.out.println ( “ Formato no válido ” ) ; valido = true ; } catch ( ArithmeticException error ) { System.out.println ( “ No se puede dividir un número entre cero ” ) ; valido = false ; } } else { valido = true ; } if ( valido ) { System.out.println ( “ Error... Ingrese en el formato indicado!!! ” ) ; } } while ( valido ) ; } }

En este programa se captura la excepción NumberFormatException para prevenir que no se intente convertir una cadena con un formato inapropiado a un número. Puede probar el programa ingresando como números lo siguiente: aaa//123 Es decir, en cualquier parte del formato indicado, ingrese letras en lugar de números (inclusive en el lugar de las // ). También se captura la excepción ArithmeticException para prevenir que no se intente dividir los números cuando el segundo número es cero. Puede probar el programa ingresando como números lo siguiente: 123//000 Para poder entender la solución del programa sugiero que revise en el siguiente capítulo la clase Integer (Clase Wrapper) y la clase String.

Pag. 205

Ing. Juan José Flores Cueto.

Pag. 206

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

DESARROLLO DE LAS CAPACIDADES LÓGICAS

Cuando un estudiante se inicia en el estudio de la programación, es necesario que comprenda los conceptos fundamentales relacionados a las estructuras lógicas y las estructuras de datos elementales, con la finalidad de utilizarlas en forma conjunta y lograr desarrollar sus capacidades lógicas. El desarrollo de las capacidades lógicas se logra con la práctica. Es decir, desarrollando soluciones y codificándolas en un lenguaje de programación determinado, como por ejemplo el lenguaje de programación Java, lenguaje de programación utilizado en el presente texto. Existen problemas que por su naturaleza contribuyen de manera significativa a lograr este objetivo, los cuales se desarrollan en esta última parte del presente capítulo. Es importante analizar cada una de las soluciones propuestas siguiendo paso a paso el desarrollo de las mismas y desarrollando a su vez las variaciones planteadas sobre los problemas.

Pag. 207

Ing. Juan José Flores Cueto.

Pag. 208

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Problema 32 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura:

* * * * *

* * * * *

* * * * *

* * * * *

* * * * *

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 20 y que entre los asteriscos no existen espacios en blanco.

Etapa 04 – Desarrollo de la codificación. Clase PrgCuadrado01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgCuadrado01 { public static void main (String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.print ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i = i ; j - - ) { // Se muestra el valor de la variable i. System.out.print ( i ) ; } // Se realiza un salto de línea. System.out.println ( ) ; } } }

Pag. 220

ESTRUCTURAS FUNDAMENTALES PARA LA SOLUCIÓN DE PROBLEMAS

Problema 40 Etapa 01 – Descripción del problema. Desarrollar la codificación de una solución que permita mostrar la siguiente figura: 1 2 3

Nota: En la figura mostrada el número de filas = 5. Asuma que el número de filas puede variar desde 2 hasta 9 y que entre los números no existen espacios en blanco.

4 5 1 2 3 4 5 1 2 3 4 5

Etapa 04 – Desarrollo de la codificación. Clase PrgTriangulo06 package dominioDeLaAplicacion; import biblioteca.*; public class PrgTriangulo06 { public static void main(String[] args) { int totalFilas = 0, i = 0, j = 0, k=0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 9: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 9 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 9 ) ; for ( i = 1 ; i 20 ) ; for ( i = 1 ; i 9 ) ; k=totalFilas+1; for ( i = 1 ; i 20 ) ; for ( i = 1 ; i 20 ) ; for ( i = 1 ; i 20 ) { System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i = 1 ; j - - ) { if ( i < j ) { System.out.print ( “ ” ) ; } else { System.out.print ( “*” ) ; } } System.out.println ( ) ; } } }

Pag. 227

Ing. Juan José Flores Cueto.

Intente mejorar la solución anterior de tal forma que cambie el for interno por el siguiente for: for ( j = 1 ; j < = totalFilas ; j++ ) … … … }

Sino lo consigue analice la siguiente solución:

Clase PrgTriangulo10Mejorado package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgTriangulo10Mejorado { public static void main (String[] args) { int totalFilas = 0, i = 0, j = 0 ; do { System.out.println ( “ Ingresar el número de filas de la figura ” ) ; System.out.print ( “ Valores válidos desde 2 hasta 20: ” ) ; totalFilas = Lectura.leerInt ( ) ; if (totalFilas < 2 || totalFilas > 20 ) { System.out.print ( “ Valor de fila no válido… Reintente!. ” ) ; } } while (totalFilas < 2 || totalFilas > 20 ) ; for ( i = 1 ; i 20 ) ; for ( i = 1 ; i 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( int I = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } System.out.print ( “ El promedio es : ” + ( sumaNotas / numAlu ) ) ; } } Observe el uso de la sentencia do dentro de la sentencia for. Uno de los principales usos de la sentencia do es la consistencia de datos. La consistencia de datos nos permite asegurarnos que el usuario ingrese solo datos válidos antes de que estos se almacenen en las variables o en los arreglos.

Pag. 424

ESTRUCTURAS DE DATOS – Arreglos.

FORMALIZACIÓN DE LA SOLUCIÓN UTILIZANDO EL MÉTODO DE LAS 6’D

Problema 132 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas finales de todos los alumnos de un determinado salón de clase. Determinar y mostrar el promedio de las notas finales. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

Mostrar el promedio de las notas finales de los alumnos de un determinado salón de clase.

‰

Datos necesarios:

El número de alumnos y las notas finales de cada uno de ellos.

‰

Procesamiento:

El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). Con el número de alumnos ingresado se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas finales de todos los alumnos y se almacenan en el arreglo creado. Después, se realiza la suma de todas las notas finales y el resultado se almacena en una variable acumulador (sumaNotas). Finalmente, se realiza el cálculo del promedio, se almacena el resultado en una variable (prom) y se muestra por pantalla.

Pag. 425

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 426

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgAlumnos01 - método main ( ) ENTRADA: numAlu, notas[ ] SALIDA: prom INICIO COMENTARIO “Declaración de variables” NUMERO i, numAlu, sumaNotas = 0, notas[ ], prom COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu 20 || notas[i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas finales” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i] FINDESDE prom = sumaNotas / numAlu ESCRIBIR prom FIN

Pag. 427

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgAlumnos01 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos01 { public static void main(String[] args) { // Declaración de variables. int i, numAlu ; double sumaNotas = 0, prom ; // Determinación del tamaño del arreglo con consistencia de datos. do { System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas finales. for ( i = 0 ; i < numAlu ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } prom = sumaNotas / numAlu ; System.out.println ( “ El promedio es : ” + prom ) ; } }

Pag. 428

ESTRUCTURAS DE DATOS – Arreglos.

Problema 133 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de todas las prácticas de un alumno. Determinar el promedio de las prácticas sabiendo que se elimina la práctica con la nota mas baja. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

Mostrar el promedio redondeado de las notas de las prácticas de un alumno.

‰

Datos necesarios:

El número de prácticas y las notas de las prácticas del alumno.

‰

Procesamiento:

El número de prácticas se ingresa a través del teclado y se almacena en una variable (numPra). Con el número de prácticas se crea un arreglo (notas[ ]). Luego se procede a ingresar las notas de las prácticas del alumno y se almacenan en el arreglo creado. Después, se realiza la suma de todas las notas de las prácticas y el resultado se almacena en una variable de tipo acumulador (sumaNotas). Luego, se determina la nota más baja del alumno y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo del promedio ((sumaNotas – notaMenor) / (numPra – 1)), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 429

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 430

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgAlumnos02 - método main ( ) ENTRADA: numPra, notas[ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i, numPra, sumaNotas = 0, notaMenor = 20 NUMERO notas[ ], promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numPra SI (numPra 20 || notas[i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas de las prácticas” DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1 sumaNotas = sumaNotas + notas[i] FINDESDE DESDE i = 0 HASTA i = numPra - 1 INCREMENTA 1 SI ( notaMenor > notas[i] ) ENTONCES notaMenor = notas[i] FINSI FINDESDE promAlu = ( sumaNotas - notaMenor ) / ( numPra - 1 ) promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FIN

Pag. 431

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación.

Clase PrgAlumnos02 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos02 { public static void main(String[] args) { // Declaración de variables. int i, numPra ; double sumaNotas = 0, notaMenor = 20, promAlu ; // Determinación del tamaño del arreglo con consistencia de datos. do { System.out.print ( “ Ingrese el número de prácticas del alumno : ” ) ; numPra = Lectura.leerInt( ) ; if ( numPra 20 || notas[i] < 0 ) ; } // Proceso de cálculo del promedio de notas de las prácticas. for ( i = 0 ; i < numPra ; i++ ) { sumaNotas = sumaNotas + notas[i] ; } for ( i = 0 ; i < numPra ; i++ ) { if ( notaMenor > notas [i] ) notaMenor = notas[i] ; } promAlu = sumaNotas / numAlu ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio es : ” + promAlu ) ; } }

Pag. 432

ESTRUCTURAS DE DATOS – Arreglos.

Problema 134 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de las tres prácticas de todos los alumnos de un salón de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta. Mostrar el promedio redondeado. Consistenciar el ingreso de datos. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

Mostrar el promedio redondeado de las notas de las tres prácticas de cada alumno.

‰

Datos necesarios:

El número de alumnos y las notas de las tres prácticas de cada alumno.

‰

Procesamiento:

El número de alumnos se ingresa a través del teclado y se almacena en una variable (numAlu). Con el número de alumnos se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las tres prácticas de cada alumno y se almacenan en el arreglo creado. Después, por cada alumno, se realiza la suma de las notas de sus tres prácticas y el resultado se almacena en una variable acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor) / 4), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 433

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 434

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgAlumnos03 - método main ( ) ENTRADA: numAlu, notas[ ][ ] SALIDA: promAlu INICIO COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, sumaNotas = 0, notaMayor = 0 NUMERO notas[ ][ ], promAlu COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu 20 || notas[i][j] < 0 ) FINDESDE FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 notaMayor = notas[i][0] MAXIMO notas[i][1] notaMayor = notas[i][2] MAXIMO notaMayor sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] promAlu = ( sumaNotas + notaMayor ) / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE FIN

Pag. 435

Ing. Juan José Flores Cueto.

Etapa 04 - Desarrollo de la Codificación. Clase PrgAlumnos03 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos03 { public static void main(String[] args) { // Declaración de variables. int i, j, numAlu ; double sumaNotas = 0, notaMayor = 0, promAlu ; // Determinación del tamaño del arreglo con consistencia de datos. do { System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu 20 || notas[i][j] < 0 ) ; } } // Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) { notaMayor = Math.max (notas[i][0], notas[i][1] ) ; notaMayor = Math.max (notas[i][2], notaMayor ) ; sumaNotas = notas[i][0] + notas[i][1] + notas[i][2] ; promAlu = ( sumaNotas + notaMayor ) / 4 ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ; } } }

Pag. 436

ESTRUCTURAS DE DATOS – Arreglos.

Problema 135 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar las notas de las prácticas de todos los alumnos de un salón de clase. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta y se elimina su práctica con la nota mas baja. Mostrar el promedio redondeado a dos decimales. Consistenciar el ingreso de datos. Finalmente; determinar y mostrar el promedio simple de todas las notas de las prácticas de los alumnos del salón de clase. Etapa 02 - Definición de la solución. ‰

Resultado deseado:

Mostrar el promedio redondeado a dos decimales de las notas de las prácticas de cada alumno y el promedio simple de todas las notas de las prácticas de los alumnos.

‰

Datos necesarios:

El número de alumnos, el número de prácticas y las notas de las prácticas de cada alumno.

‰

Procesamiento:

El número de alumnos y el número de prácticas se ingresa a través del teclado y se almacenan en variables (numAlu y numPra respectivamente). Con los datos ingresados se crea un arreglo (notas[ ][ ]). Luego se procede a ingresar las notas de las prácticas de cada alumno y se almacenan en el arreglo creado. Después, por cada alumno, se realiza la suma de las notas de las prácticas y el resultado se almacenan en una variable de tipo acumulador (sumaNotas). Luego, se determina su nota más alta y se almacena en una variable (notaMayor). También se determina su nota mas baja y se almacena en una variable (notaMenor). Finalmente, se realiza el cálculo de su promedio ((sumaNotas + notaMayor - notaMenor) / numPra), se almacena el resultado en una variable (promAlu), se redondea y se muestra por pantalla.

Pag. 437

Ing. Juan José Flores Cueto.

Adicionalmente, se realiza la suma de las notas de las prácticas de todos los alumnos del salón de clase y el resultado se almacena nuevamente en una variable de tipo acumulador (sumaNotas). Se determina el promedio simple, se almacena el resultado en una variable (prom) y se muestra por pantalla.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyAlumnos. 2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases. Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 438

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgAlumnos04 - método main ( ) ENTRADA: numAlu, numPra, notas[ ][ ] SALIDA: promAlu, prom INICIO COMENTARIO “Declaración de variables” NUMERO i, j, numAlu, numPra, sumaNotas = 0, notaMayor = 0 NUMERO notaMenor = 20, notas[ ][ ], promAlu, prom COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numAlu SI (numAlu 20 || notas[1][i] < 0 )

Pag. 445

Ing. Juan José Flores Cueto.

Continúa… 4. Diseño de algoritmo para el método principal.

Algoritmo PrgAlumnos05- método main ( ) HACER COMENTARIO “Examen Final” LEER notas[2][i] SI ( notas[2][i] > 20 || notas[2][i] < 0 ) ENTONCES ESCRIBIR “Nota no válida... Reintente!” FINSI MIENTRAS ( notas[2][i] > 20 || notas[2][i] < 0 ) FINDESDE COMENTARIO “Cálculo del promedio de notas por alumno” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 ESCRIBIR promAlu FINDESDE COMENTARIO “Cálculo del promedio simple de examen final” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 sumaEF = sumaEF + notas[2][i] FINDESDE promEF = sumaEF / numAlu promEF = promEF REDONDEA 2 ESCRIBIR promEF COMENTARIO “Cálculo de alumnos aprobados y desaprobados” DESDE i = 0 HASTA i = numAlu - 1 INCREMENTA 1 sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 promAlu = sumaNotas / 4 promAlu = promAlu REDONDEA 0 SI ( promAlu < 11 ) ENTONCES desaprobados = desaprobados + 1 SINO Aprobados = aprobados + 1 FINSI FINDESDE porceAprob = ( aprobados * 100 ) / numAlu porceAprob = porceAprob REDONDEA 2 porceDesaprob = 100 - porceAprob ESCRIBIR porceAprob + “ % ” ESCRIBIR porceDesaprob + “ % ” FIN

Pag. 446

ESTRUCTURAS DE DATOS – Arreglos.

Etapa 04 - Desarrollo de la Codificación. Clase PrgAlumnos05 package dominioDeLaAplicacion ; import biblioteca.* ; public class PrgAlumnos05 { public static void main(String[] args) { // Declaración de variables. int i, numAlu, aprobados = 0, desaprobados = 0 ; double sumaNotas = 0, sumaEF = 0, promAlu, promEF, porceAprob, porceDesaprob ; // Determinación del tamaño del arreglo con consistencia de datos. do { System.out.print ( “ Ingrese el número de alumnos : ” ) ; numAlu = Lectura.leerInt( ) ; if ( numAlu 20 || notas[0][i] < 0 ) ; do { System.out.print ( “ Ingrese la nota promedio de trabajos : ” ) ; notas[1][i] = Lectura.leerDouble( ) ; if ( notas[1][i] > 20 || notas[1][i] < 0 ) { System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) ; } } while ( notas[1][i] > 20 || notas[1][i] < 0 ) ; do { System.out.print ( “ Ingrese la nota del examen final : ” ) ; notas[2][i] = Lectura.leerDouble( ) ; if ( notas[2][i] > 20 || notas[2][i] < 0 ) { System.out.println ( “ Nota ingresada no es válida… Reintente! ” ) ; } } while ( notas[2][i] > 20 || notas[2][i] < 0 ) ; }

Pag. 447

Ing. Juan José Flores Cueto.

Continúa… Etapa 04 - Desarrollo de la Codificación. Clase PrgAlumnos05 // Cálculo del promedio de notas por alumno. for ( i = 0 ; i < numAlu ; i++ ) { sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ; promAlu = sumaNotas / 4 ; promAlu = Math.round (promAlu) ; System.out.println ( “ El promedio del alumno [ ” + ( i + 1 ) + “ ] es: ” + promAlu ) ; } // Cálculo del promedio simple del examen final. for ( i = 0 ; i < numAlu ; i++ ) { sumaEF = sumaEF + notas[2][i] ; } promEF = sumaEF / numAlu ; promEF = ( Math.round (promEF * 100) ) / 100.0 ; System.out.println ( “ El promedio de las notas del examen final es : ” + promEF ) ; // Cálculo de alumnos aprobados y desaprobados. for ( i = 0 ; i < numAlu ; i++ ) { sumaNotas = notas[0][i] + notas[1][i] + notas[2][i] * 2 ; promAlu = sumaNotas / 4 ; promAlu = Math.round (promAlu) ; if ( promAlu < 11 ) { desaprobados ++ ; } else { aprobados ++ ; } } porceAprob = ( aprobados * 100 ) / numAlu ; porceAprob = ( Math.round (porceAprob * 100) ) / 100.0 ; porceDesaprob = 100 – porceAprob ; System.out.println ( “ El porcentaje de alumnos aprobados es : ” + porceAprob + “ % ” ) ; System.out.print ( “ El porcentaje de alumnos desaprobados es : ” ) ; System.out.println ( porceDesaprob + “ % ” ) ; } }

Pag. 448

ESTRUCTURAS DE DATOS – Arreglos.

Problema 137 Etapa 01 - Descripción del problema. Desarrollar una solución que permita ingresar y almacenar el sueldo de todos los trabajadores de una empresa. Calcular y mostrar el aumento de sueldo de cada uno de los trabajadores (redondeado a dos decimales), de acuerdo a la siguiente tabla. Consistenciar los datos ingresados. Condición

Aumento

sueldo < 410 sueldo >= 410 y sueldo 1600

05 %

Etapa 02 - Definición de la solución. ‰

Resultado deseado:

Mostrar el aumento de sueldo de cada uno de los trabajadores de una empresa.

‰

Datos necesarios:

El número de trabajadores de la empresa y el sueldo de cada uno de ellos.

‰

Procesamiento:

El número de trabajadores se ingresa a través del teclado y se almacena en una variable (numTrab). Con el número de trabajadores se crea un arreglo (sueldos[ ]). Luego se procede a ingresar los sueldos de cada trabajador y se almacenan en el arreglo creado. Después, por cada trabajador, en base a su sueldo se determina su aumento de sueldo. Si el trabajador tiene un sueldo menor a S/.410.00 nuevos soles se le aumenta el 20% de su sueldo. Si el trabajador tiene un sueldo mayor a S/.1,600.00 nuevos soles, se le aumenta el 5% de su sueldo y en otros casos el aumento es del 10% de su sueldo. El aumento se almacena en una variable (aumento), se redondea y se muestra por pantalla.

Pag. 449

Ing. Juan José Flores Cueto.

Etapa 03 - Diseño de la lógica. 1. Nombre del Proyecto: ProyTrabajadores.

2. Definición de Paquetes y desarrollo del Diagrama de Paquetes.

Diagrama de paquetes

3. Definición de las Clases.

Clases dominioDeLaAplicacion

Clases biblioteca

Pag. 450

ESTRUCTURAS DE DATOS – Arreglos.

4. Diseño de algoritmo para el método principal.

Algoritmo PrgTrabajadores01 - método main ( ) ENTRADA: numTrab, sueldos[ ] SALIDA: aumento INICIO COMENTARIO “Declaración de variables” NUMERO i, numTrab, sueldos[ ], aumento = 0 COMENTARIO “Determinación del tamaño del arreglo” HACER LEER numTrab SI (numTrab