Método de Las 6'D, Tomo I - Juan José Flores Cueto

Método de las 6`D Modelamiento - Algoritmo - Programación.
Tomo I. Enfoque orientado a las estructuras lógicas

Autores: Juan José Flores Cueto y Carmen Bertoloƫ Zuñiga
© Derechos de autor registrados:

Empresa Editora Macro EIRL
© Derechos de edición, arte gráfico y diagramación reservados:

Empresa Editora Macro EIRL
Corrección de estilo:
Mónica Barrera Velasco
Milton A. Gonzales M.
Coordinación de arte y diseño:

Alejandro Marcas León
Diagramación:
Lizbeth Eufracio Quispe
SebasƟan Alvarez Sanchez
Edición a cargo de:

© Empresa Editora Macro EIRL
Av. Paseo de la República N.° 5613 , Miraflores, Lima, Perú
 Teléfono: (511) 748 0560

 E-mail: proyecto@editorialmacro.com
Página web: www.editorialmacro.com
Primera edición: seƟembre de 2014

Tiraje: 1000 ejemplares
Impresión
Talleres gráficos de la Empresa Editora Macro EIRL
Jr. San Agusơn N.° 612-624, Surquillo, Lima, Perú
ISBN N.° 978-612-304-218-9

Hecho el depósito legal en la Biblioteca Nacional del Perú Nº 2014-12577
Prohibida la reproducción parcial o total, por cualquier medio o método, de este libro sin
previa autorización de la Empresa Editora Macro EIRL.
Juan José Flores Cueto
Ingeniero de Computación y Sistemas, magister en Administración con mención en Gerencia Estratégica de
Organización; doctor en Educación por la Universidad de San Martín de Porres (USMP). Además, obtuvo el título
de Especialista y el Diploma de Estudios Avanzados (DEA) en Integración de las Tecnologías de la Información en
las Organizaciones (ITIO), por la Universidad Politécnica de Valencia (UPV), España. Actualmente, es doctorando
del Programa ITIO de la UPV.
Se ha desempeñado profesionalmente en diversas empresas nacionales, ocupando las funciones de desarrollador

de soŌware, analista de sistemas, auditor de sistemas y jefe de proyectos. Desde mayo del 2009 ocupa el cargo
de director de la USMP Virtual, donde además ejerce la docencia. También se desempeña como catedrático en la
Facultad de Ingeniería y Arquitectura (FIA) de la Universidad de San Martín de Porres (USMP), y en la Universidad
Nacional José Faustino Sánchez Carrión (UNJFSC).
Es autor de diversos libros, como guías y manuales, los cuales se utilizan para la enseñanza universitaria. También
ha colaborado con artículos para revistas nacionales e internacionales, y ha participado en diversos congresos.
La página personal del autor es: h p://jjflorescueto.googlepages.com/. Y sus publicaciones se pueden encontrar
en: h p://www.lulu.com/spotlight/jjflorescueto, y en la red: h p://www.reddolac.org
Carmen Bertoloƫ Zuñiga
Ingeniera de Computación y Sistemas, egresada de la Universidad de San Martín de Porres (USMP).
Con estudios finalizados en la maestría en Educación con mención en Informática y Tecnología, en la
USMP. Se desempeña como docente contratada en la Facultad de Ingeniería y Arquitectura (FIA), de la
USMP, así como en otras instituciones educativas.
Es autora del libro Método de las 6’D. Modelamiento - Algoritmo - Programación. (Enfoque orientado a
las estructuras lógicas). 2da. ed. Lima: Fondo Editorial USMP, 2008. También ha escrito diversos artículos
en el boletín electrónico InfoFIA de la FIA USMP; además, es autora de guías y manuales utilizados en el
quehacer universitario. Ha laborado en diversas empresas del sector privado, desempeñándose como
ingeniera de desarrollo y jefe de sistemas.
Dedicatoria
A nuestros hijos, Danae y el pequeño Rodrigo

Índice
Capítulo 1
Método y herramientas .......................................................................................................................... 13
1.1 Método de las 6’D ...........................................................................................................15
1.1.1 Etapas y pasos ..........................................................................................................16
1.1.2 Resumen de método ................................................................................................23
1.1.3 Resultado de las etapas del método ........................................................................24
1.2 Marco de trabajo .............................................................................................................25
1.3 Modelamiento .................................................................................................................26
1.3.1 Paquete ...................................................................................................................26
1.3.2 Clase .........................................................................................................................26
1.3.3 Objeto ......................................................................................................................27
1.3.4 Diagrama de paquetes .............................................................................................28
1.4 Algoritmo..........................................................................................................................29
1.4.1 Características ..........................................................................................................29
1.4.2 Herramientas ...........................................................................................................30
1.5 Programación ..................................................................................................................39
1.5.1 Tipos de lenguajes de programación .......................................................................40
Capítulo 2
Estructuras lógicas de secuencia y estructura de datos variable ........................................................... 41
2.1 Estructuras lógicas de secuencia .....................................................................................45
2.1.1 Definición .................................................................................................................45
2.2 Método de las 6´D - Desarrollo de soluciones con un paquete .......................................46
2.3 Estructuras lógicas de secuencia: Mostrar información ..................................................47
2.3.1 Definición .................................................................................................................47
2.3.2 Representación ........................................................................................................47
2.3.3 Consideraciones adicionales para los lenguajes de programación C++ y Java .........49
2.4 Estructura de datos: Variable ..........................................................................................60
2.4.1 Definición .................................................................................................................60
2.4.2 Declaración ..............................................................................................................60
2.4.3 Nombre ....................................................................................................................60
2.4.4 Inicialización .............................................................................................................61
2.4.5 Almacenamiento o asignación de datos ..................................................................61
2.4.6 Constantes ...............................................................................................................62
2.5 Tipos de dato ...................................................................................................................62
2.5.1 Definición .................................................................................................................62
2.5.2 En pseudocódigo y diagrama de flujo ......................................................................63
2.5.3 En lenguaje C++........................................................................................................64
2.5.4 En lenguaje Java .......................................................................................................65
2.6 Uso de comentarios .........................................................................................................75
2.7 Estructura lógica de secuencia: Ingresar datos................................................................80
2.7.1 Definición .................................................................................................................80
2.7.2 Representación ........................................................................................................80
2.8 Estructura lógica de secuencia: Procesar datos................................................................91
2.8.1 Definición .................................................................................................................91
2.8.2 Tipos.........................................................................................................................91
2.9 Método de las 6`D - Desarrollo de soluciones con dos paquetes ....................................100
2.10 Desarrollo de Aplicaciones Java, utilizando Java Development Kit (JDK ) ......................126
2.10.1 Edición....................................................................................................................126
2.10.2 Compilación ...........................................................................................................126
2.10.3 Ejecución ................................................................................................................126
2.11 Soluciones utilizando cuadros de diálogo......................................................................128
2.11.1 Uso de la clase LE codificada en Java .....................................................................128
2.11.2 Método de las 6´D - Uso de cuadros de diálogo ....................................................129
Capítulo 3
Estructuras lógicas de decisión o selección ............................................................................................ 143
3.1 Desarrollo de soluciones con un paquete .......................................................................147
3.2 Estructuras lógicas de decisión ........................................................................................147
3.2.1 Definición .................................................................................................................147
3.2.2 Estructura lógica de decisión simple ........................................................................148
3.2.3 Estructura lógica de decisión doble .........................................................................167
3.2.4 Estructura lógica de decisión múltiple: “CUANDO” .................................................184
3.2.5 Estructura lógica de decisión múltiple: “SI ANIDADOS” ..........................................208
3.3 Uso combinado de las estructuras lógicas de decisión....................................................237
3.4 Uso anidado de las estructuras lógicas de decisión.........................................................237
3.5 Desarrollo de aplicaciones Java, utilizando Integrated Development Environment (IDE) .. 257
3.6 Método de las 6´D - Uso de cuadros de diálogo ..............................................................259
Capítulo 4
Estructuras lógicas de control o repeƟción ............................................................................................ 281
4.1 Método de las 6’D - Desarrollo de soluciones con dos paquetes ...................................285
4.2 Estructuras lógicas de repetición .....................................................................................286
4.2.1 Otros usos de las variables .......................................................................................287
4.2.2 Estructura lógica de repetición: “HACER” ................................................................287
4.2.4 Estructura lógica de repetición: “MIENTRAS” ..........................................................348
4.2.5 Estructura lógica de repetición: “DESDE” o “PARA” .................................................378
4.3 Empaquetar aplicaciones Java utilizando Java ARchives ( JAR ).......................................409
4.3.1 Creación de un JAR...................................................................................................409
4.3.2 Ejecución de un JAR .................................................................................................411
4.3.3 Visualizar un JAR ......................................................................................................412
4.3.4 Extracción de un JAR ................................................................................................413
4.4 SoŌware para decompilar aplicaciones java ...................................................................415
4.4.1 Uso de javap del JDK ................................................................................................415
4.4.2 Uso de otros soŌware ..............................................................................................416
4.5 Método de las 6´D - Uso de cuadros de diálogo ..............................................................418
Capítulo 5
Estructuras lógicas combinadas .............................................................................................................. 435
5.1 Uso combinado de las estructuras lógicas ......................................................................439
5.2 Manejo de excepciones en el lenguaje de programación Java ........................................522
5.3 Desarrollo de las capacidades lógicas..............................................................................530
5.4 Desarrollo de miniaplicaciones Java (Applet) utilizando Java Development Kit ( JDK ) ...557
5.5 Métodos de las 6´D – Uso de cuadros de diálogo ...........................................................559
Capítulo 6
Introducción al desarrollo de soluciones orientadas a objetos y al uso de Interfaz Gráfica de
Usuario .................................................................................................................................................... 583
6.1 Conceptos básicos ...........................................................................................................588
6.1.1 Clase .........................................................................................................................588
6.1.2 Objeto (Modelos de entes del mundo) ...................................................................589
6.1.3 Atributo ....................................................................................................................590
6.1.4 Método ....................................................................................................................595
6.2 Método de las 6’D: Redefinición de pasos ......................................................................608
6.2.1 Ajuste de los pasos definidos para las etapas del método .......................................608
6.3 SoŌware para generar ejecutables en MS-Windows basado en aplicaciones Java ........615
6.3.1 Uso de soŌware ......................................................................................................615
6.4 Introducción a las soluciones utilizando Interfaz Gráfica de Usuario (GUI) .....................618
6.4.1 Introducción .............................................................................................................618
6.4.2 Definición .................................................................................................................618
6.4.3 Etapas para el desarrollo de GUI ..............................................................................618
6.4.4 Contenedores y componentes de la GUI..................................................................619
6.4.5 Administradores de diseño de la GUI.......................................................................620
6.4.6 Manejadores de evento de la GUI ...........................................................................620
6.5 Método de las 6´D – Desarrollo de soluciones con GUI ..................................................621
Bibliograİa .............................................................................................................................................. 631

Apéndice *
Clases creadas e incorporadas en Java ................................................................................................... 633

Clases incorporadas en el lenguaje Java ..................................................................................635
Clase Lectura........................................................................................................................635
Clase LE (versión 2.2) ...........................................................................................................636
El paquete del lenguaje Java................................................................................................643
Conversión de datos .................................................................................................................645
Conversión implícita de datos en Java .................................................................................646
Conversión explícita de datos en Java (casting) ...................................................................648
Envoltorios de los tipos de datos primitivos: clases wrappers.............................................649
Funciones matemáticas: clase Math ........................................................................................659
Introducción ........................................................................................................................659
Métodos ..............................................................................................................................660
Manejo de cadenas: clase String ..............................................................................................703
Introducción ........................................................................................................................703
Métodos ..............................................................................................................................704
Manejo de formatos: clase Decimalformat ..............................................................................754
Manejo de fechas: clase Calendar............................................................................................759
Manejo de fechas: clase Gregoriancalendar ............................................................................764
Manejo de fechas: clase Simpledateformat .............................................................................766
* El presente apéndice solo se encuentra disponible en la página web de la editorial: www.editorialmacro.com

Introducción
En este libro se trata en forma detallada y dinámica los conceptos y temas fundamentales necesarios
para el desarrollo de soluciones utilizando el Método de las 6’D, y el empleo de sus capacidades
lógicas.
Se explican los conceptos fundamentales sobre el modelamiento y el UML, profundizando en el

tema de algoritmos y su diseño utilizando diagramas de flujo y pseudocódigo. Se presenta también
el diagrama de actividades como una herramienta adicional para diseñar algoritmos, y se desarrollan
conceptos sobre programación y codificación utilizando los lenguajes de programación orientados
a objetos C++ y Java.
Se tratan las Estructuras Lógicas de Secuencia (ELS), las variables, las Estructuras Lógicas de Decisión
(ELD), las Estructuras Lógicas de Repetición (ELR) y las Estructuras Lógicas Combinadas (ELC).
También se tratan las estructuras de bifurcación y el manejo de excepciones en Java (try, catch), y
se finaliza con una introducción al desarrollo de soluciones orientadas a objetos y al uso de Interfaz
Gráfica de Usuario (GUI) en los programas Java.
La estructura de los capítulos y su relación directa con los problemas propuestos al final de cada
uno de ellos, y la gran cantidad de soluciones desarrolladas (250 en total), en las cuales se incluyen
75 pseudocódigos, 59 diagramas de Flujo, 6 diagramas de actividad, 76 programas en C++, 217
problemas en Java utilizando la consola y 23 programas en Java utilizando cuadros de diálogo,
garantizan un aprendizaje progresivo y adecuado de cada uno de los temas tratados.
Finalmente, se incluye una sección llamada PUNTO A PARTE, que permitirá al lector conocer
nuevas herramientas de software gratuitas que complementarán sus conocimientos y le ayudarán a
desarrollar mejores aplicaciones en Java. Los temas incluidos son:
}|Desarrollo de aplicaciones Java utilizando Java Development Kit ( JDK )

}|Desarrollo de aplicaciones Java utilizando Integrated Development Environment ( IDE )
}|Empaquetar aplicaciones Java utilizando Java ARchives ( JAR )
}|Software para decompilar aplicaciones Java
}|Desarrollo de miniaplicaciones Java (Applet) utilizando Java Development Kit ( JDK )
}|Software para generar ejecutables en MS-Windows basado en aplicaciones Java

CAP.
M é to d o y h e r r a m i e n t a s
1
CAP. 1: M ÉTODO Y HERRAMIENTAS 15
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.
Por su naturaleza, algunos problemas pueden ser resueltos utilizando una computadora. Generalmente
son de tipo estructurado; es decir, que tienen una solución determinada y pueden llegar a ser muy
sencillos o extremadamente complejos. Para resolver estos problemas estructurados utilizando una
computadora, es importante aplicar un método fácil de comprender y que guíe 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. Está compuesto de
seis etapas, cada una de las cuales consta de una serie de pasos que se van modificando o 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 establecido que el nombre de cada una de sus seis etapas
comience con la letra “D”.
1.1 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
del problema
Etapa 02
Definición
Solución n veces Ingeniería
reversa
Etapa 03
Diseño
Solución
Etapa 04
Desarrollo
Solución
MODELAMIENTO Etapa 05
ALGORITMO Depuración
Pruebas
Etapa 06
CODIFICACIÓN
N Documento
16 MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS
1.1.1 Etapas y pasos
A. Descripción de la Etapa 01 – Descripción del problema
Etapa 01
Lo primero que se debe hacer en esta
Descripción etapa es identificar cuál es el problema que
del problema se desea resolver. Esto que parece algo
sumamente sencillo, muchas veces resulta
una tarea agotadora, ya que existen muchas
opiniones acerca de cuál es el problema
central. Identificarlo es una de las tareas más
importantes que los analistas deben afrontar.
Una vez identificado el problema, es necesario

comprenderlo en su totalidad, es decir,
entender qué es exactamente lo que se
desea resolver. Finalmente, se debe escribir
un enunciado claro, concreto y conciso del
problema a resolver.
Pasos:
}|Identificacióndel problema.
}|Descripcióngeneral 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.
B. Descripción de la Etapa 02 – Definición de la solución
Etapa 02
En esta etapa es necesario estudiar a fondo
Definición el problema para poder solucionarlo, saber
de la solución exactamente en qué consiste y descomponerlo
en cada una de sus partes, facilitando su
comprensión y posterior solución. Esta es una
regla que siempre debe 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 solucionarlo,
aplicando siempre la más 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
En esta etapa se obtienen las especificaciones, que determinan lo que se debe hacer para solucionar
el problema.
C. Descripción de la Etapa 03 – Definición de la solución
Etapa 03
Una vez definida la solución se procederá a
Diseño diseñar la lógica, modelando y desarrollando
de la solución algoritmos.
Para el modelado de la solución del problema

se utilizará el Lenguaje Unificado de Modelado
(Unified Modeling Language, UML), que es
una herramienta usada para describir clases,
objetos y sus relaciones.
Para el desarrollo de algoritmos se utilizarán

Pseudocódigos o Diagramas de Flujo (DF),
que son herramientas utilizadas para diseñar
algoritmos de los diferentes métodos de una
clase.
Finalizado el desarrollo de los algoritmos es

necesario verificar si se han incluido soluciones
para todas las formas en que se presenta el
problema. A este tipo de prueba se le denomina
“Prueba de escritorio”.
Pasos:
}|Definir un nombre para el proyecto.

MODELAMIENTO }|Definición de diagramas, relaciones y
clases.
ALGORITMO }|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.
D. Descripción de la Etapa 04 – Desarrollo de la solución
Etapa 04
Una vez previstas todas las posibilidades y
Desarrollo alternativas que puedan presentarse y que
de la solución pasen sin inconvenientes por la clase y los
algoritmos, se 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:
CODIFICACIÓN }|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.
E. Descripción de la Etapa 05 – Depuración y pruebas
Etapa 05
Luego que se codifiquen los programas y/o
Depuración y clases, deberán ser probados mediante su
pruebas ejecución (esta acción se conoce como corrida
del programa). Al realizarse pueden surgir
diferentes tipos de errores, siendo los 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
F. Descripción de la Etapa 06 – Documentación
Etapa 06
En esta etapa se recopila toda la documentación
Documentación generada en las etapas anteriores, la cual
servirá como base para la elaboración del
manual técnico.
El tiempo dedicado a esta etapa será de

mucha ayuda para desarrollar buenos hábitos,
necesarios cuando se desarrolle el soŌware en
forma profesional.
El manual técnico debe incluir, como mínimo:
}|Descripcióndel 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.
Adicionalmente, es posible realizar ingeniería reversa entre las etapas 03, 04 y 05.
Ingeniería La ingeniería reversa permite crear o

reversa 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
n veces 04 “Desarrollo de la solución”, y corregido en
la Etapa 05 “Depuración y pruebas”.
Etapa 03
Es decir, a través de la ingeniería reversa es
Diseño
posible programar o codificar algunas partes
Solución
(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
Etapa 04 se continúa con el proceso hasta llegar a la
solución deseada.
Desarrollo
Solución
Pasos:
Etapa 05
}|Exportar proyecto (archivos class o
Depuración y Java) al disco de la PC, si está trabajando
pruebas con un IDE.
}|Importar proyecto (archivos class o
Java) a una herramienta CASE y realizar
la ingeniería reversa.
MODELAMIENTO
}|Organizar el modelo obtenido en la
ALGORITMO herramienta CASE.
CODIFICACIÓN
DIAGRAMAS
ACTUALIZADOS
Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06
Descripción Definición Diseño Desarrollo Depuración

Documento
Problema Solución Solución Solución Pruebas
1.1.2 Resumen de método
}|Identificación }|Definir el }|Definir un }|Codificar el }|Realizar la }|Recopilar el

del problema. resultado nombre para el proyecto. depuración material generado
}|Descripción deseado. proyecto. }|Desarrollar y verificar en cada una de las
general del }|Determinar los }|Definición de comentarios la correcta etapas anteriores.
Resumen de las etapas y los pasos del método.
problema. datos que se diagramas, internos en los escritura de los }|Generar el manual
}|Enunciado claro deben ingresar relaciones y programas de programas. del programa.

y preciso del o generar clases. computadora. }|Realizar pruebas }|Generar el manual
problema. para obtener }|Desarrollo de }|Desarrollar de sintaxis. del usuario.
el resultado algoritmos. copias de }|Realizar pruebas
deseado. seguridad de lógica.
}|Determinar la de los
forma en que programas de
los datos serán computadora.
procesados
CAP. 1: M ÉTODO
para
transformarlos
en información.
Y HERRAMIENTAS
23
24
Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06
Descripción Definición Diseño Desarrollo Depuración Documento

Problema Solución Solución Solución Pruebas
1.1.3 Resultado de las etapas del método
Diagramas
Enunciado Especificaciones Programas Pruebas
y algoritmos
Manuales
MÉTODO DE LAS 6’D - ENFOQUE ORIENTADO A LAS ESTRUCTURAS LÓGICAS
1.2 MARCO DE TRABAJO

Este libro busca dar solución a problemas sencillos utilizando el Método de las 6’D. La solución de los
problemas se iniciará con el enunciado del problema, para luego 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 desarrollará 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
MARCO DE TRABAJO
Descripción
del problema
ENUNCIADO
Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
MODELAMIENTO Desarrollo
ALGORITMO Solución
CODIFICACIÓN
Para 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 conocidas como variables.
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 deben dominar algunos conceptos claves como Objetos, Métodos, Encapsulamiento, Herencia,
Polimorfismo, Interfaces gráficas, Conexión a base de datos y 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 o modificar. Esto significa que, dependiendo
de la complejidad del problema y de su solución, se puede plantear nuevos pasos y eliminar los ya
existentes en las diferentes etapas del método. Conforme se avance con el desarrollo de las soluciones,
se podrá observar cómo se redefinen los pasos de las etapas del método.
1.3 MODELAMIENTO
Se llama modelamiento a la forma en la que se representa la solución de un problema del mundo real
en términos de un modelo. Esta es una representación gráfica o simbólica de algún aspecto del mundo
que se encuentra bajo observación o estudio. Para representar un modelo se utiliza el UML (Unified
Modeling Language).
El Lenguaje Unificado de Modelado (UML) es un lenguaje gráfico que permite:
}|Visualizarun 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 soŌware (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 soŌware orientado a objetos. Para dicho propósito, se detallarán
algunos conceptos básicos que serán utilizados en las soluciones que plantea este libro.
1.3.1 Paquete
Los paquetes permiten organizar las clases de un modelo. Un paquete contiene clases cuyas
funciones similares. En UML, un paquete se representa de la siguiente forma:
NombrePaquete Nombre del paquete
1.3.2 Clase
Una clase es 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; es una abstracción y no representa a
ningún objeto en particular. En UML, una clase se representa de la siguiente forma:
NombreClase Nombre de la clase y del paquete al

(NombrePaquete al que cual pertenece la clase
pertenece)
Atributos Lista de atributos de la clase
Métodos Lista de métodos de la clase

1.3.3 Objeto
Es cualquier cosa real o abstracta de la que se almacenan datos, y los métodos 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
NombreClase : nombreObjeto del objeto. Ambos nombres
deben estar separados por dos
puntos.
UML incorpora nueve diagramas que permiten representar un modelo desde diferentes perspectivas.
Estos se muestran a continuación:
Diagramas de
Casos de Uso
Diagramas de
Diagramas de
Clase
Secuencia
Paquete
Diagramas de Diagramas de
Colaboración MODELO Objeto
Estado Componentes
Actividad Distribución
A continuación, se detalla el diagrama de paquetes que será utilizado en las soluciones planteadas
en el presente texto.
1.3.4 Diagrama de paquetes
Este permite especificar y visualizar las relaciones de dependencia existentes 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 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 algunas de las clases que pertenecen a otro paquete, y viceversa. En UML, una
relación de dependencia unidireccional entre dos paquetes se grafica de la siguiente manera:
dominioDeLaAplicacion Biblioteca
Relación de dependencia
unidireccional
En este caso, dependencia significa que todas las clases pertenecientes 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).
|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
Definición
Solución
MODELAMIENTO
Se desarrollan los siguientes pasos:
}|Definir un nombre para el proyecto. Este paso permitirá agrupar 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 estos, utilizando UML. En las soluciones, primero
se creará un paquete y luego todos los demás. Fundamentalmente, se desarrollarán soluciones
con dos paquetes donde uno de ellos se llamará “dominioDeLaAplicación” y el otro “Biblioteca”,
estableciendo una relación de dependencia unidireccional del primero hacia el segundo.
En el paquete “dominioDeLaAplicacion” se definirá la clase que va a permitir solucionar el problema

planteado utilizando UML. El nombre de la clase que define el método principal comienza con las
letras “Prg” (abreviatura de programa), seguido de un nombre que identifique a la clase. Este nombre
deberá ser seleccionado adecuadamente. Dicha clase por lo general no tendrá atributos definidos.
En el paquete “Biblioteca” se tendrán clases reutilizables, tales como la clase Lectura1 y la clase LE2,
que facilitarán 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 las clases debe 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.
El nombre de los paquetes, el nombre de los atributos y el nombre de los métodos se escriben en
letra minúscula. En caso que el nombre sea compuesto, a partir de la segunda palabra se escribirá
la primera letra en mayúscula. Los métodos constructores son una excepción a esta regla y tienen el
mismo nombre que su clase (por lo que su nombre comienza con letra mayúscula).
1.4 ALGORITMO
En su forma más simple, una clase 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.
Los algoritmos se desarrollan para especificar cuáles son los pasos desarrollados en un determinado
método y cuáles son los datos que manejan dichos pasos. 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.
1.4.1 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, este debe terminar en algún momento.
}|Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener el mismo
resultado.
1
La clase Lectura se uƟliza en todos los capítulos. La clase Lectura se especifica en el apéndice.
2
La clase LE se trata en la parte final de cada capítulo, y con mayor intensidad en el capítulo final. La clase LE se
especifica en el apéndice.
}|Un algoritmo puede o no tener datos de entrada.

}|Un algoritmo producirá uno o más datos de salida.
}|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 cómo se está solucionando un determinado problema.
Se dispone de diversas herramientas para desarrollar los algoritmos en los métodos de las clases.
Entre estas herramientas se puede mencionar al pseudocódigo y al diagrama de flujo.
1.4.2 Herramientas
A. Pseudocódigo
B. Diagrama de flujo
C. Diagrama de actividad
A. Pseudocódigo
Permite expresar un algoritmo con palabras en castellano que son semejantes a las sentencias de
un lenguaje de programación.
a. Pautas básicas:
}|Todo algoritmo debe tener un nombre que empiece 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á de la siguiente manera: TEXTO x.
}|Para asignar un valor a una variable “x” se utilizará el signo igual. Por ejemplo, si se desea asignar
5 a la variable “x” se realizará de la siguiente manera: x = 5.
}|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.
b. Estructura básica de un pseudocódigo:
Algoritmo NombreClase – nombreMetodo( )
ENTRADA:
En Entrada y Salida se especifican
SALIDA: 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
FIN:
INICIO... FIN
c. Reglas o pautas
}|Con la finalidad de comprender mejor el diseño de los algoritmos desarrollados en pseudocódigo
y diagrama de flujo, se han clasificado en seis grupos las reglas definidas.
REGLA FORMATO DESCRIPCIÓN

GRUPO 1
Utilizada para el ingreso de datos.

LEER LEER x El dato ingresado se almacena en la
variable especificada.
Utilizada para la salida de

ESCRIBIR “Hola”
información. Se puede visualizar una
ESCRIBIR x
ESCRIBIR cadena, el contenido de una variable
ESCRIBIR x + z
o el resultado de una operación
matemática.
Utilizada para realizar comentarios

COMENTARIO COMENTARIO “Variables” internos en los algoritmos de las
soluciones.
Permite declarar una variable de tipo

NUMERO NUMERO x
numérico.

TEXTO TEXTO mensaje
texto o cadena.
Permite declarar a una variable de

CARACTER CARACTER letra
tipo texto o cadena de una sola letra.

LOGICO LOGICO aprobado
lógico
Permite asignar el valor VERDADERO

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

FALSO aprobado = FALSO
variable lógica.

GRUPO 2
SI (condición) ENTONCES
Permite especificar una estructura de

SI instrucciones...
decisión simple “SI... FINSI”.
FINSI
instrucciones...
SI / SINO SINO
decisión doble “SI... SINO... FINSI”.
instrucciones...
FINSI
CUANDO (variable) SEA

CASO valor 1 :
instrucciones...
CASO valor 2 :
Permite especificar una estructura
instrucciones...
CUANDO de decisión múltiple “CUANDO...
CASO valor n :
FINCUANDO”.
instrucciones...
OTROS
instrucciones…
FINCUANDO
DESDE i = valorInicial
HASTA valorFinal
instrucción 1
.
de repetición “DESDE... FINDESDE”.
DESDE .
Esta estructura es equivalente a
.
PARA.
instrucción n
FINDESDE
PARA ( i = valorInicial ;
condición ; valor )
instrucción 1
. Permite especificar una estructura de
PARA . repetición “PARA... FINPARA”. Esta
. estructura es equivalente a DESDE.
instrucción n
FINPARA
MIENTRAS (condición)
instrucción 1
.
.
MIENTRAS de repetición “MIENTRAS...
.
FINMIENTRAS”.
instrucción n
FINMIENTRAS
HACER
instrucción 1
.
HACER .
repetición “HACER... MIENTRAS”.
.
instrucción n
MIENTRAS (condición
Permite terminar la ejecución de una

TERMINAR TERMINAR
estructura lógica de repetición.
Permite volver a ejecutar una

estructura lógica de repetición, sin
CONTINUAR CONTINUA
finalizar todas las instrucciones que
forman parte de la misma.

GRUPO 3
Permite obtener el coseno del valor

almacenado en la variable “n”. El
COSENO
x = COSENO n resultado se almacena en la variable
“x”.
Permite obtener el seno del valor

almacenado en la variable “n”. El
SENO x = SENO n
resultado se almacena en la variable
“x”.
Permite obtener la longitud de la

cadena almacenada en la variable
LONGITUD x = LONGITUD n “n” o la longitud del vector “n”. El
“x”.
Permite obtener el número de filas

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

columnas de una matriz “n”. El
COLUMNA x = COLUMNA n
“x”.
Permite cambiar a mayúscula la

x = MAYUSCULA n cadena almacenada en la variable
MAYUSCULA
“n”. El resultado se almacena en la
variable “x”.
Permite cambiar a minúscula la

cadena almacenada en la variable
MINUSCULA x = MINUSCULA n
variable “x”.

GRUPO 4
Permite obtener el resto de la división

entre las variables “z” y “n”. El
RESTO x = z RESTO n
“x”.
Permite obtener la parte entera de la

división de las variables “z” y “n”. El
DIVIDIR x = z DIVIDIR n
“x”.
Permite obtener la raíz “n” del número

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

POTENCIA x = z POTENCIA n número “z”. El resultado se almacena
en la variable “x”.
Permite obtener el número mayor

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

entre los valores almacenados en las
MAYOR x = MAYOR n1, n2, n3… variables “n1”, “n2”, “n3”…
El resultado se almacena en la
variable “x”.
Permite obtener el número menor

entre los valores almacenados en las
MENOR x = MENOR n1, n2, n3… variables “n1”, “n2”, “n3”…
variable “x”.
Permite obtener el número menor

entre el valor almacenado en la
MINIMO x = z MINIMO n variable “n” y la variable “z”. El
“x”.
Permite obtener el promedio entre los

valores almacenados en las variables
PROMEDIO x = PROMEDIO n1, n2, n3… “n1”, “n2”, “n3”…
variable “x”
Permite obtener el carácter ubicado

en la posición “n” de la cadena “z”. El
CARACTER x = z CARACTER n
“x”.
Permite obtener un número cualquiera

(aleatorio) entre los valores de “z” y
ALEATORIO x = z ALEATORIO n
variable “x”.
Permite redondear un número “z” al

número de decimales especificado
REDONDEAR x = z REDONDEAR n
en “n” El resultado se almacena en la
variable “x”.

GRUPO 5
Permite obtener una subcadena

comprendida entre las posiciones
SUBCADENA x = z SUBCADENA n1, n2 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
x = z ELIMINAESPACIO n1,
ELIMINAESPACIO posiciones especificadas por “n1” y
n2
“n2”. El resultado se almacena en la
variable “x”.

GRUPO 6
Utilizada para crear arreglos

CREAR vector[n] previamente declarados. Un arreglo
CREAR permite almacenar más de un dato
CREAR matriz[n1][n2] del mismo tipo.
CLASE CLASE PrgEjemplo Utilizada para especificar una clase.
Permite crear un objeto de una

CREAR CREAR objeto
determinada clase.
EJECUTAR EJECUTAR algoritmo Permite ejecutar otro algoritmo.
Permite especificar si un algoritmo

PARAMETRO PARAMETRO listaVariables
recibe datos o valores.
Permite especificar si un algoritmo

RETORNAR RETORNAR variable
retorna una respuesta.
B. 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.
DIAGRAMA DE FLUJO
FLUJO
Porque muestra la secuencia de lo que se
tiene que realizar.
DIAGRAMA
Por el hecho de ser dibujo que no
requiere estar a escala.
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 la información que
resulta del procesamiento.
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 (LÍNEAS)
Líneas que permiten unir los diagramas y mostrar la secuencia
lógica a la solución del problema.
Estructura básica de un diagrama de flujo:
Algoritmo NombreClase – nombreMetodo()
INICIO
Este es el cuerpo del algoritmo

expresado en diagrama de
Instrucciones… flujo. Las instrucciones se
colocan entre INICIO… FIN.
FIN
C. Diagrama de actividades
Son parte del lenguaje unificado de modelado (UML) y se utilizan comúnmente en dos formas:
1.- Es el modelado de flujos de trabajo, haciendo hincapié en las actividades tal y como son vistas
por los actores que colaboran con el sistema, esto es, modelando procesos de negocio.
2.- Es el modelado de una operación, utilizando los diagramas de actividad como diagramas de flujo
para amostrar detalles de un algoritmo, haciendo amplio uso de las condiciones de procesos
concurrentes.
Los diagramas de actividad están compuestos por símbolos de propósito especial, tales como
los símbolos de estado de acción, diamantes, pequeños círculos y barras de sincronización. Estos
símbolos están conectados mediante flechas de transición, las cuales representan el flujo de
actividad.
Cada estado de acción representa la realización de una o varias tareas. Se representa por un
rectángulo de sus lados izquierdo y derecho reemplazados con arcos hacia fuera. Cada actividad
contiene una expresión de acción que especifica una acción particular a realizar. Las acciones
pueden incluir cálculos aritméticos, lógicos u operaciones de entrada y salida. La expresión de
acción puede especificarse en lenguaje natural o utilizando pseudocódigo.
Las flechas en el Diagrama de Actividad se llaman flechas de transición. Estas flechas representan
transiciones, las cuales indican el orden en el que ocurren las acciones representadas por los
estados de acción.
El círculo sólido en la parte superior del diagrama de actividad representa el estado inicial de la
actividad, es decir, el inicio de flujo de trabajo antes de que el programa realice las tareas modeladas.
El círculo sólido rodeado por una circunferencia que aparece en la parte inferior del diagrama de
actividad representa el estado final, es decir, el final del flujo de trabajo después de que el programa
realiza todas las tareas. Un diamante o rombo permite representar caminos alternativos según se
cumpla alguna condición.
Las barras de sincronización permiten mostrar actividades concurrentes, es decir, actividades

que pueden realizarse en paralelo. Sin embargo, en la realidad puede ser que no se ejecuten
simultáneamente. La idea es indicar qué actividades se pueden realizar en paralelo, sin que ello
signifique que deba forzosamente realizarse así. Puede realizarse en cualquier orden, lo importante
es dar la idea de que se pueden ejecutar al mismo tiempo. Las barras de sincronización son líneas
continuas gruesas y pueden ser verticales u horizontales.
En un Diagrama de Actividad, como en cualquier diagrama UML, puede incluir notas. Las notas
son comentarios con explicaciones que describen el propósito de los símbolos del diagrama de
Actividad. Las notas son símbolos representados por rectángulos con la esquina superior derecha
doblada. Una línea punteada permite conectar cada nota con el elemento que describe dicha nota.
Generalmente, las notas pueden utilizarse para describir como se relacionan los diagramas con un
lenguaje de programación en particular.
Al igual que los Pseudocódigo y los Diagramas de Flujo, los Diagramas de Actividades ayudan a los
programadores a desarrollar y representar los algoritmos, aunque muchos programadores prefieren
utilizar Pseudocódigo o Diagramas de Flujo. Los Diagramas de Actividad claramente muestran cómo
operan las estructuras lógicas y pueden ser usados para diseñar algoritmos.
Elementos o símbolos básicos:
ESTADO INICIAL
Este símbolo permite marcar el inicio del algoritmo.
ESTADO DE ACCIÓN O ACTIVIDAD

Representa la realización de una o varias tareas.
DECISIÓN
Permite representar caminos alternativos en base a una
condición.
ESTADO FINAL
Este símbolo permite marcar el final del algoritmo.
FLECHAS DE TRANSICIÓN
Líneas que indican el orden en que ocurren las acciones.
BARRAS DE SINCRONIZACIÓN
Líneas que permiten mostrar actividades concurrentes.
NOTAS
Comentarios que permiten describir el propósito de los
diagramas.
|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
MODELAMIENTO
ALGORITMO
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 y/o Diagrama de Flujo.
También, en algunos casos, a modo de introducción se utilizarán los diagramas de actividades.
1.5 PROGRAMACIÓN
La programación es la traducción del modelamiento y los algoritmos en sentencias que la computadora
puede comprender y ejecutar. Es decir, que la programación es la acción de escribir programas para
una computadora, utilizando alguno de los lenguajes de programación existentes. Dicha acción 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 aquel que utilizan los programadores, 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 parƟcular. Existen diferentes lenguajes de programación, la mayor parte de los
cuales Ɵenen 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 de 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 C++ y Java.
1.5.1 Tipos de lenguajes de programación
A. C++
C++ es un lenguaje de programación, diseñado a mediados de los años 1980 por Bjame Stroudstrup,
como extensión del lenguaje de programación C.
Actualmente, existe un estándar denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos.
Existen también algunos intérpretes como ROOT (enlace externo). Las principales características del
C++ son el soporte para programación orientada a objetos y el soporte de plantillas o programación
genérica (templates). Se puede decir que C++ es un lenguaje que abarca tres paradigmas de la
programación: la programación estructurada, la programación genérica y la programación orientada
a objetos.
C++ está considerado por muchos programadores como uno de los mejores lenguajes de
programación, debido a que permite trabajar tanto a alto como a bajo nivel; sin embargo es a su vez
uno de los que menos automatizaciones tiene (obliga a hacerlo casi todo manualmente al igual que
C) lo que genera más tiempo para su aprendizaje.
B. 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.
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 servlests), pueden ejecutarse
en cualquier computadora que tenga instalada una máquina virtual de Java.
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 asegura solucionar la mayoría de los problemas de la PE, incorporando nuevas
características y nuevos conceptos. Una característica importante de la POO es que utiliza conceptos
óptimos 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
CODIFICACIÓ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 y/o C++, se traducirá lo especificado en el modelamiento y en los
algoritmos en sentencias que la computadora pueda comprender y ejecutar.
CAP.
Estructuras lógicas de
secuencia y estructura
2
d e d a to s v a r i a b l e
CAP. 2: ESTRUCTURAS LÓGICAS DE SECUENCIA Y ESTRUCTURA DE DATOS VARIABLE 43
El modelamiento es la forma en la que se representa la solución de un problema del mundo real en

términos de un modelo. Por otro lado, 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
pueda comprender y ejecutar. La acción de escribir un programa para computadoras se conoce como
programación.
MARCO DE TRABAJO
ENUNCIADO
DEL
PROBLEMA
Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
Desarrollo
MODELAMIENTO Solución
ALGORITMO
CODIFICACIÓN
MODELAMIENTO
PROYECTO CODIFICACIÓN
Nombre
Clase
Atributos
Método( ) ALGORITMO
Lista de pasos Sentencias

Declaración y
Descripcción definición de
de datos datos
SE DESARROLLAN UTILIZANDO:
Estructuras lógicas de secuencia.
ALMACENANDO EN:
Estructuras de datos: Variable
En este capítulo se hablará de las estructuras lógicas de secuencia y la estructura de datos, conocida
como variable.
Es importante mencionar que, utilizando las estructuras lógicas de secuencia y las variables, se pueden
desarrollar algoritmos, de manera que estos puedan ser diseñados en pseudocódigo, diagrama de
flujo o diagrama de actividades, para luego ser codificados en un lenguaje de programación como C++
o Java.
En las primeras veintiún soluciones desarrolladas, se ingresan datos y se visualiza la información

utilizando solo caracteres (técnica tradicional basada en consola). Esto permite que el lector comprenda
los conceptos fundamentales del desarrollo de soluciones, además de resultar útil para iniciar el
estudio de las estructuras lógicas y las variables. Una contribución importante en esta parte es el uso
del diagrama de paquetes para explicar conceptos básicos de modelamiento.
En las siguientes cuatro soluciones desarrolladas se emplea una clase reutilizable creada en el lenguaje
de programación Java, para facilitar el ingreso de datos y visualización de la información utilizando
cuadros de diálogo prediseñados. Esto permite que las soluciones planteadas sean vistosas y más
amigables desde el punto de vista del usuario, logrando que el lector se familiarice con el uso de
cuadros y ventanas en las soluciones. Una contribución importante en esta parte es el uso del diagrama
de actividades como alternativa para el diseño de algoritmos.
Las veinticinco soluciones desarrolladas en el presente capítulo y los problemas propuestos al final del
mismo, contribuirán con el desarrollo de sus capacidades lógicas, necesarias para plantear soluciones
de calidad basadas en un lenguaje de programación determinado.
2.1 ESTRUCTURAS LÓGICAS DE SECUENCIA
2.1.1 Definición
Son aquellas en las que una instrucción sigue a otra en secuencia. Las instrucciones se ejecutan una
a una, de modo que al finalizar su ejecución se inicia la siguiente, hasta completar la ejecución de
todas las instrucciones que forman parte de la secuencia.
Las estructuras lógicas de secuencia son el tipo de estructuras más comunes y constituyen la base
sobre la cual se desarrollan las demás estructuras lógicas (aunque muchos especialistas no las
consideren como tales, sino simples instrucciones básicas para el desarrollo de soluciones).
}|Mapa de estructuras lógicas de secuencia

Utilizando las estructuras lógicas de secuencia se pueden desarrollar algoritmos simples, 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.
Estructuras lógicas de secuencia
Ingresar Procesar Mostrar

Datos Datos Datos
“LEER” “PROCESAR” “ESCRIBIR”
}|Mapa de estructuras lógicas:
Estructuras lógicas
Estructuras lógicas Estructuras lógicas Estructuras lógicas Instrucciones

de secuencia de decisión de repetición de bifurcación
“LEER” “SI” “DESDE” “TERMINAR”
“ESCRIBIR” “SI / SINO” “MIENTRAS” “CONTINUAR”
“PROCESAR” “CUANDO” “HACER” “HACER”

"SI ANIDADOS"
2.2 MÉTODO DE LAS 6´D - DESARROLLO DE SOLUCIONES CON UN PAQUETE

A continuación, se definirán formalmente los pasos del Método de las 6’D para el desarrollo de
soluciones utilizando un paquete.
ENUNCIADO
DEL
PROBLEMA
Etapa 02 Etapa 03 Etapa 04

Definición Diseño Desarrollo
Solución Solución Solución
MODELAMIENTO CODIFICACIÓN
}|Determinar la }|Determinar el }|Codificar el diseño
información nombre del de la solución del
deseada (salida). proyecto. problema. Utilizar
}|Determinar los }|Definir el paquete el lenguaje de
datos de entrada y las clases que programación C++
(entrada). formarán parte o Java.
}|Establecer como de la solución del
se solucionará el problema. Utilice
problema (proceso). UML.
ALGORITMO
}|Diseñar el algoritmo
para el método
principal. Utilizar
pseudocódigo o
diagrama de flujo.
De manera general, la Etapa 03 - Diseño de la lógica se divide en dos partes: modelamiento (paso 1
y 2) y algoritmo (paso 3). Por otro lado, 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.
2.3 ESTRUCTURAS LÓGICAS DE SECUENCIA: MOSTRAR INFORMACIÓN
2.3.1 Definición
Cuando se habla de la salida de información, se está haciendo referencia a la forma o mecanismo

empleado para conocer el resultado de un determinado algoritmo. En los lenguajes de programación,
este tipo de estructura permite mostrar información a través de un dispositivo de salida de una
computadora.
2.3.2 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 sentencia: cout En C++
La clase: System En Java
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:
Para visualizar la cadena de texto “Hola Mundo” deberá realizar lo siguiente:
}|En pseudocódigo:
ESCRIBIR “Hola Mundo”
Alternativamente puede usar las reglas MOSTRAR e IMPRIMIR, que permiten visualizar datos
explícitamente a través de la pantalla (consola) y de la impresora, respectivamente.
}|En diagrama de flujo:
"Hola Mundo"
Alternativamente puede usar los símbolos siguientes:
Mostrar datos por la pantalla

(consola)
Mostrar datos por la impresora

}|En el lenguaje de programación C++:
cout << “Hola Mundo”;
Esta sentencia permite la salida de datos por la pantalla (consola) de la computadora. Utilizando
“cout”, se mostrará la información que se coloque a la derecha del operador de salida “<<”. En
el ejemplo, se mostrará el mensaje “Hola Mundo”. Una vez mostrada la información, el cursor
permanecerá al final de la línea. También puede utilizar la siguiente sentencia:
cout << “Hola Mundo” << endl;
La palabra reservada “endl” permite que el cursor se ubique en la línea siguiente donde se mostró la
información. Esto es necesario cuando se desea visualizar información en diferentes líneas.
Cuando utilice cout o endl deberá asegurarse de incluir al inicio de sus programas el archivo de
cabecera iostream, utilizando la siguiente línea de código:
#include <iostream>
También deberá asegurarse de incluir la sentencia using respectiva al inicio de sus programas. Esto
es necesario, ya que en C++ se requiere indicar el espacio de nombre al que pertenecen dichas
sentencias; es decir, las siguientes líneas de código serán necesarias cuando se utilizan dichas
sentencias:
using std::cout ;
using std::endl ;
Si no se utilizan, deberá anteceder a todas las sentencias cout o endl el prefijo std::.
}|En el lenguaje de programación Java:9
System.out.print (“Hola Mundo”);
Esta sentencia permite la salida de datos por la pantalla (consola) de la computadora. Utilizando
“print”, se mostrará la información que se coloque entre los paréntesis “( )”. En el ejemplo, se
mostrará el mensaje “Hola Mundo”; una vez mostrada la información el cursor permanecerá al final
de la línea. También puede utilizar la siguiente sentencia:
System.out.println (“Hola Mundo”);

Utilizando “println” en lugar de “print”, el cursor se ubicará en la línea siguiente donde se mostró la
información. Esto es equivalente a utilizar “endl” en C++.
La clase System pertenece a la biblioteca de clases del lenguaje de programación Java, y es parte de
su paquete principal denominado java.lang.
Cuando se desarrolla un programa en Java, y necesita utilizar clases que son parte de otros paquetes,
deberá indicarlo utilizando para ello la sentencia import.
Esto se cumple para todos los paquetes que necesite utilizar, tanto para los que ha creado como para
los del lenguaje de programación Java, a excepción del paquete java.lang. Es decir, para trabajar con
la clase System o cualquier clase de paquete java.lang no necesitará importar dicho paquete.
2.3.3 Consideraciones adicionales para los lenguajes de programación C++ y Java
Con la finalidad de mejorar la manera como se muestra la información visualizada a través de la

consola, se pueden utilizar las constantes de carácter de barra invertida. “\n” y “\t”:
“\n” Permite mostrar información en la siguiente línea.

“\t” Permite insertar una tabulación horizontal.
Problema 001
Etapa 01 – Descripción del problema
Enunciado: Muestre un mensaje por la pantalla. El mensaje a mostrar será: “Hola bienvenidos”.
Etapa 02 – Definición de la solución
A. Resultado deseado: mostrar mensaje “Hola bienvenidos”.

B. Datos necesarios: ninguno.
C. Procesamiento: el mensaje será mostrado por la pantalla.
Etapa 03 – Diseño de la lógica
1. Nombre del proyecto: ProyMensaje

2. Definición de paquete y clase
Paquete y clase
PrgMensaje
dominioDeLaAplicacion
}|main ( )
3. Diseño del algoritmo

En pseudocódigo:
Algoritmo PrgMensaje – main ( )
ENTRADA:
SALIDA:
INICIO
ESCRIBIR “Hola bienvenidos”
FIN
En diagrama de flujo:
Algoritmo PrgMensaje – main ( )
INICIO
“Hola bienvenidos”
FIN
Etapa 04 - Desarrollo de la codificación
En lenguaje de programación C++:
Clase PrgMensaje
#include <iostream>
using std::cout ;
int main ( ) {
cout << “ Hola bienvenidos ” ;
return 0 ;
}
En lenguaje de programación Java:

Clase PrgMensaje
package dominioDeLaAplicacion ;
class PrgMensaje {
public static void main ( String arg [ ] ) {
System.out.print ( “ Hola bienvenidos ” ) ;

}
}
Análisis de la solución:
A continuación, se analizará el algoritmo de main diseñado en pseudocódigo para la solución del

problema anterior.
Primero se tiene: ALGORITMO PrgMensaje – main ( )
Se refiere al nombre del algoritmo. En este caso, el nombre es PrgMensaje

– main ( ). Observe que la primera letra se escribe con mayúscula.
Luego: 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. El tema de variables será tratado más adelante
en este mismo capítulo.
A continuación: SALIDA:
Se hace referencia a todas las variables cuya función en el algoritmo
es almacenar datos de salida. Observe que no se ha definido ninguna
variable de salida.
Luego se tiene: INICIO

Esta regla permite indicar el inicio de los pasos que constituyen la solución
al problema planteado.
A continuación: ESCRIBIR “Hola bienvenidos”

Esta línea se refiere al paso 1 del algoritmo diseñado en pseudocódigo. A
través de la regla ESCRIBIR, se muestra el texto encerrado entre comillas, o
sea el mensaje Hola bienvenidos.
Finalmente: FIN
Esta regla 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 reglas INICIO… FIN constituyen la parte más importante del algoritmo,
y son conocidos como el cuerpo del algoritmo.
Ahora, se analizará el algoritmo de main diseñado en diagrama de flujo para la solución del problema
anterior.
Primero se tiene: ALGORITMO PrgMensaje – main ( )
Se refiere al nombre del algoritmo. En este caso, el nombre es PrgMensaje

– main ( ). Note que la primera letra se escribe con mayúscula.
Luego tenemos: INICIO
Este símbolo permite indicar el inicio de los pasos que constituyen la

solución al problema planteado.
A continuación: “Hola bienvenidos”
Este símbolo permite mostrar el texto encerrado entre comillas, es decir, se

muestra “Hola bienvenidos”.
Finalmente: FIN
Este símbolo permite indicar el fin de los pasos que constituyen la solución

al problema planteado, es decir, el final del algoritmo.
Ahora, debe analizarse cada sentencia de la codificación del algoritmo en el lenguaje de programación
C++.
En primer lugar, se observa que el programa empieza con la línea de código siguiente:
#include <iostream>
El lenguaje C++ define varios archivos llamados archivos de encabezado, que contienen
información útil o necesaria para su programa. Para este programa se necesita el archivo de
encabezado iostream, necesario para utilizar la sentencia cout. Los archivos de encabezado son
proporcionados con el software C++ y constituyen la biblioteca estándar del mismo.
Es importante indicar que este archivo de encabezado debe estar incluido dentro de cualquier
programa en el que se necesite mostrar datos a través del monitor, o ingresar datos a través
del teclado (iostream es un archivo de encabezado de flujo de entrada / salida - input / output
stream header file).
La línea de código siguiente:
using std::cout ;
Utiliza using y la notación std::cout.

Por lo general, la palabra using se coloca al inicio del programa y permite indicar qué “espacios
de nombres” se van a utilizar. Se puede incluir varias veces la palabra using en un programa. La
notación std::cout especifica que se está utilizando un nombre, en este caso cout, que pertenece
al “espacio de nombre” std. Los espacios de nombres son una característica avanzada de C++ y
resuelven los conflictos que pueden generarse al utilizar bibliotecas de terceros.
La línea de código using std::cout eliminan la necesidad de repetir el prefijo std:: en las sentencias
cout. Si no utiliza esta línea de código, deberá anteceder a todas las sentencias cout el prefijo
std::. En el ejemplo, si no utiliza using deberá cambiar la línea de código:
Por la línea de código siguiente:
std::cout << “ Hola bienvenidos ” ;
int main ( ) {
Es conocida como la firma de la función main o función principal. Todo programa en C++ que sea
posible de ejecutarse deberá tener una función main. La palabra int a la izquierda de main indica
que main “devuelve” un valor entero (un número).
Permite mostrar a través de una pantalla el texto contenido entre comillas, es decir, se muestra
el mensaje Hola bienvenidos. De igual forma, se puede visualizar el contenido de una variable o
los resultados de operaciones matemáticas.
En la línea de código siguiente:
return 0 ;
Se indica que la finalización del programa ha sido exitosa y devuelve el control al sistema
operativo o al IDE que lo ejecutó. La palabra return es una de las muchas formas que se utilizan
para indicar la finalización de una función.
La última línea de código es:
Indica el final del método main y del programa.
En resumen, para desarrollar un programa básico en C++ es necesario indicar el uso de archivos de
encabezado, sentencias using (aunque estrictamente hablando no es necesaria) y la función main.
De esto se deduce que las siguientes líneas de código se utilizarán en todos los programas C++ que
se desarrollen. Solo variará el nombre de los archivos de encabezado que se utilicen y las sentencias
using que se incluyan.
#include <iostream>
using std :: cout ;
int main ( ) {
return 0 ;
}
En algunos casos es necesario incluir sentencias que permitan mantener la visualización de los
resultados del programa, debido fundamentalmente a que existen IDEs (Interfaces de Desarrollo
Integrado) que no cuentan con una ventana de consola incorporada para mostrar los resultados.
Observe lo siguiente:
#include <iostream>
using std :: cout ;
int main ( ) {
system ( “PAUSE” ) ;
return 0 ;
}
La sentencia system permite ejecutar comandos del sistema operativo. En este caso, “PAUSE” es un
comando del sistema operativo DOS que muestra el mensaje “Presione una tecla para continuar”, y
hace una pausa mientras no se presione una tecla, permitiendo la visualización de los resultados del
programa. Sin embargo, dependiendo del sistema operativo en el que se esté trabajando, se deberá
emplear el comando adecuado.
Otra solución que permite visualizar los resultados del programa y no emplea comandos del sistema
operativo es la siguiente:
#include <iostream>
#include <conio.h>
using std :: cout ;
int main ( ) {
getch() ;
return 0 ;
}
#include <conio.h>
Es un archivo de encabezado necesario para utilizar la sentencia getch() ;

getch() ;
Permite hacer una pausa para visualizar los resultados del programa. Esta pausa se mantendrá
hasta presionar cualquier tecla.
Finalmente, se debe analizar cada sentencia de la codificación del algoritmo en el lenguaje de

programación Java.
En primer lugar, se observa que el programa empieza con la línea de código siguiente:
La palabra reservada package especifica el nombre del paquete al que va a pertenecer la clase
creada con la palabra reservada class. El nombre del paquete se encuentra a continuación de la
palabra reservada package. En este caso, el nombre del paquete es “dominioDeLaAplicacion”.
class PrgMensaje {
Observe que se utiliza la palabra reservada class, indicando que se declara una clase. A
continuación se encontrará el nombre de la clase, que es PrgMensaje. Finalmente, seguido del
nombre se coloca una llave de apertura ( { ), que indica el inicio del cuerpo de la clase.
Es conocida como la firma del método main o método principal. Toda clase en Java que sea
posible de ejecurtarse, deberá tener un método main exactamente como ha sido escrito,
respetando las letras minúsculas y mayúsculas.
System.out.print ( “ Hola bienvenidos ” ) ;
Permite mostrar por pantalla el texto entre comillas, es decir, se muestra “Hola bienvenidos”.
También se puede visualizar el contenido de una variable y los resultados de operaciones
matemáticas.
Las dos últimas líneas de código son:
}
}
La primera línea indica el final del método main, y la segunda línea indica el final de la clase.
En resumen, se puede decir que para desarrollar un programa básico en Java es necesario definir
un paquete, una clase y el método main. De esto se deduce que las siguientes líneas de código
se utilizarán en todos los programas que se desarrollen, y solo se dará una variación en el nombre
del paquete y el nombre de la clase, que en este caso son dominioDeLaAplicacion y PrgMensaje
respectivamente.
class PrgMensaje {
}
}
Problema 002
Etapa 01 - Descripción del problema
Enunciado: Muestre dos mensajes por pantalla, cada uno en líneas diferentes. El primer mensaje a
mostrar será “Hola bienvenidos”, y el segundo “Este es el segundo programa”.
A. Resultado deseado: Mostrar los mensajes “Hola bienvenidos” y “Este es el segundo programa”.
B. Datos necesarios: Ninguno.
C. Procesamiento: Los mensajes serán mostrados por la pantalla.
1. Nombre del proyecto: ProyMensaje2

Paquete y clase
PrgMensaje2
||main ()

En pseudocódigo:
Algoritmo PrgMensaje2 – main ( )
ENTRADA:
SALIDA:
INICIO

ESCRIBIR “Este es el segundo programa”
FIN
INICIO
“Hola
bienvenidos”
“Este es el
segundo”
FIN

Clase PrgMensaje2
#include <iostream>
using std::cout ;
using std::endl ;
int main ( ) {
cout << “ Hola bienvenidos ” << endl ;
cout << “ Este es el segundo programa ” << “\n \n” ;
return 0 ;
}
Clase PrgMensaje2
class PrgMensaje2 {

System.out.println ( “ Hola bienvenidos ” ) ;
System.out.println ( “ Este es el segundo programa ” ) ;
}
}
Problema 003
Enunciado: Muestre los mensajes siguientes por la pantalla.
Hola Bienvenidos
Hemos mostrado mensajes
En una sola línea Prob.1
En dos líneas Prob.2
En múltiples líneas Prob.3
Intente desarrollar la Etapa 02 – Definición de la solución
1. Nombre del proyecto: ProyMensaje3

Paquete y clase
PrgMensaje3
||main ()
En pseudocódigo:
ENTRADA:
SALIDA:
INICIO

ESCRIBIR “Hemos mostrado mensajes”
ESCRIBIR “En una sola línea Prob.1”
ESCRIBIR “En dos líneas Prob.2”
ESCRIBIR “En múltiples líneas Prob.3”
FIN
INICIO
“Hola bienvenidos”
“Hemos mostrado mensajes”
“En una sola línea Prob.1”
“En dos líneas Prob.2”
“En múltiples líneas Prob.3”
FIN

Clase PrgMensaje3
#include <iostream>
#include <conio.h>
using std:: cout ;
int main ( ) {
cout << “ Hola bienvenidos \n” ;
cout << “ Hemos mostrado mensajes ” << “\n” ;
cout << “ En una sola línea \t Prob.1 \n En dos líneas \t\t Prob.2 \n
En múltiples líneas \t Prob.3 ” ;
getch ( ) ;
return 0 ;
}

Clase PrgMensaje3
class PrgMensaje3 {

System.out.println ( “ Hola bienvenidos” ) ;
System.out.println ( “ Hemos mostrado mensajes ” ) ;
System.out.print ( “ En una sola línea \t Prob.1 \n En dos líneas \t\t
Prob.2 \n En múltiples líneas\t Prob.3” ) ;
}
}
2.4 ESTRUCTURA DE DATOS: VARIABLE
2.4.1 Definición
Una variable es una estructura de datos, lineal o estática, que permite reservar un espacio para
almacenar o guardar datos de forma temporal. Una variable solo puede almacenar un dato a la vez;
si se necesita almacenar dos o tres datos al mismo tiempo, se requerirán dos o tres variables según
sea el caso.
2.4.2 Declaración
Al declarar una variable es posible definir su nombre 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
pueda ser utilizada, cuestión necesaria en los diferentes lenguajes de programación.
En pseudocódigo y diagrama de flujo:
TipoDeDato ListaDeVariables
En C++ y 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.
2.4.3 Nombre
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 y no debe tener
una longitud mayor a 31 caracteres, de manera que se asegure la portabilidad de los programas a
otros sistemas operativos. 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, como /, (, ), =, ?, ¨, ^, *, etc.
En pseudocódigo:
Una variable no puede tener el nombre de una regla o pauta definida.
Ejemplo: ESCRIBIR.
En C++ y Java:
Una variable no puede tener el nombre de una palabra reservada. Ejemplos:
System en Java o cout en C++.
IMPORTANTE
Se recomienda que el nombre a uƟlizar en las variables que se
empleen, guarde relación con el valor que estas almacenan.
2.4.4 Inicialización
Es posible que una variable sea definida con un valor inicial, y que posteriormente sea modificado.
Además, es recomendable definir con un valor inicial a todas las variables declaradas en el programa.
TipoDeDato variable = valor
En C++ y 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 solo si la variable no ha sido declarada anteriormente.
2.4.5 Almacenamiento o asignación de datos
Para almacenar un valor en una variable se utiliza el nombre con el que esta fue declarada, y a
continuación el signo igual (=) seguido del valor que se desea almacenar.
variable = valor
En C++ y Java:
variable = valor ;
Se debe tener en cuenta que una variable puede almacenar solo 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 se almacena un valor en la variable, se pierde el valor que anteriormente tenía. 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:
suma = 7 + 5
En C++ y 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.
2.4.6 Constantes
Una constante es un tipo de variable que mantiene el valor asignado a lo largo de un algoritmo o un
programa. A una variable tipo constante, generalmente se le declara y asigna un valor al inicio de un
algoritmo o un programa. Dicho valor no cambia en todo el algoritmo o en todo el programa.
variable = valor
En C++:
const variable = valor ;
En Java:
final variable = valor ;
Se debe tener presente que una constante es una variación lógica del concepto de una variable.
2.5 TIPOS DE DATO
2.5.1 Definición
Los tipos de dato permiten declarar las variables. A pesar que en el pseudocódigo y el diagrama de flujo
solo se reconocen cuatro tipos de datos, en los lenguajes de programación existe una gran variedad de
estos tipos, generalmente divididos en dos categorías: básicos o simples y compuestos.
Existen diferentes tipos de dato. En pseudocódigo y diagrama de flujo se utilizan cuatro tipos
(NUMERO, CARACTER, TEXTO y LOGICO). Los lenguajes de programación permiten trabajar con una
amplia variedad de tipos de datos, que se extienden desde los más básicos hasta los más complejos.
Los tipos de datos básicos se tratarán en este capítulo, y constituyen la base para los tipos de dato
compuestos.
2.5.2 En pseudocódigo y diagrama de flujo
Reglas definidas para los tipos de dato:
}|NUMERO Referidos a cualquier número. Se puede subdividir en ENTERO y REAL.

}|CARACTER Referidos a cualquier letra, dÍgito o símbolo encerrado entre apóstrofes ( ‘ ’ ).
}|TEXTO Referido a cualquier texto encerrado entre comillas ( “ ” ).
}|LOGICO Referido a los dos posibles valores lógicos (VERDADERO y/o FALSO).
Se debe tener en cuenta que las palabras NUMERO, ENTERO, REAL, CARACTER, TEXTO, LOGICO,
VERDADERO y FALSO son reglas utilizadas en el pseudocódigo y diagrama de flujo, por lo que no
podrán ser usadas como nombre de variable. Estas palabras nos permiten definir los tres tipos de
variables utilizadas:
A. Variables numéricas: Permiten almacenar solo tipos de dato numérico (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. Es decir, primero
se resuelven las multiplicaciones y divisiones; luego las sumas y restas. Para alterar esta prioridad
se podrán 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 NUMERO.
B. Variables de texto: Permiten almacenar datos de tipo texto y datos de tipo carácter (TEXTO y
CARACTER). Las variables tipo texto son útiles para almacenar cualquier cadena de texto, tales
como nombres de personas, direcciones, etc. Las variables tipo carácter permiten almacenar una
sola letra, dígito o símbolo. Para almacenar un valor a una variable texto se coloca el texto entre
comillas, mientras que para almacenar un valor a una variable carácter se debe colocar entre
apóstrofes.
Ejemplos:
nombre = “Pedro”
letra = ‘J’
Donde nombre y letra son variables que previamente han sido declaradas como variables de tipo
TEXTO y CARACTER respectivamente.
C. Variables lógicas: Permiten almacenar solo datos de tipo lógico. Existen solo 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 LOGICO. 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.
2.5.3 En lenguaje C++
Los tipos de dato básicos o simples de C++ 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 short, int, long, float, double, boolean, char, wchar_t y string.
T®ÖÊ DÝÙ®Ö®ÌÄ
short entero corto
int entero
long entero largo
float real en coma flotante de doble precisión
double lógico
bool carácter
char carácter ancho
string cadena o texto
Las palabras reservadas short, int y long permiten declarar variables de tipo ENTERO, mientras que las
palabras reservadas float y double permiten declarar variables de tipo REAL. En conjunto, las palabras
reservadas short, int, long, float y double permiten declarar variables de tipo NÚMERO.
La palabra reservada bool permite declarar variables de tipo LOGICO.
Las palabras reservadas char y wchar_t permiten declarar variables de tipo CARACTER, mientras que
la palabra reservada string permite declarar variables de tipo TEXTO o cadena.
2.5.4 En lenguaje 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.
T®ÖÊ DÝÙ®Ö®ÌÄ
byte tipo byte
short entero corto
int entero
long entero largo
float real en coma flotante de simple precisión
double real con coma flotante de doble precisión.
char carácter
boolean lógico
Las palabras reservadas byte, short, int y long permiten declarar variables de tipo ENTERO, mientras
que las palabras reservadas float y double permiten declarar variables de tipo REAL. En conjunto, las
palabras reservadas short, int, long, float y double permiten declarar variables de tipo NÚMERO.
La palabra reservada boolean permite declarar variables de tipo LOGICO. La palabra reservada char
permite declarar variables de tipo CARACTER.
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 o 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).
A diferencia de otros lenguajes de programación, en C++ y Java los tipos de datos simples no dependen
de la plataforma ni del sistema operativo. Un entero de tipo int siempre tendrá el mismo tamaño,
por lo que no habrá sorpresas al migrar un programa de un sistema operativo a otro. Las palabras
reservadas de C++ y Java no pueden ser utilizadas como nombre de variable.
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, el programa indicará un error al momento de compilar.
Problema 004
Enunciado: Muestre el día y el mes de cumpleaños de una persona que nació el 23 de agosto.
Etapa 02 - Definición del problema
A. Resultado deseado: Mostrar el día y el mes de cumpleaños de una persona que nació el 23 de
agosto.
C. Procesamiento: El día y mes de cumpleaños de la persona serán almacenados en las
variables dia y mes respectivamente, y finalmente serán mostrados.
Etapa 03 - Diseño de la lógica
1. Nombre del proyecto: ProyCumpleaños

Paquete y clase
PrgCumpleaños
||main ()

En pseudocódigo:
Algoritmo PrgCumpleaños – main ( )
ENTRADA:
SALIDA: dia, mes
INICIO
COMENTARIO “Este es nuestro cuarto algoritmo”
NUMERO dia
TEXTO mes
dia= 23
mes = “Agosto”
ESCRIBIR dia, mes
FIN
Algoritmo PrgCumpleaños – main ( )
INICIO
Este es nuestro cuarto algoritmo
NUMERO dia
TEXTO mes
dia = 23
mes= "Agosto"
dia, mes
FIN
Clase PrgCumpleaños
/* Este es nuestro cuarto programa. Aunque es sencillo, podemos apreciar los elementos
básicos de un programa en C++ y sus posibles variaciones.
*/
#include <iostream>
#include <string>
using std::cout ;
using std::string ;
// La ejecución empieza en main.

int main ( ) {
int dia ;
string mes ;
dia= 23 ;
mes = “Agosto” ;
cout << “ Cumpleaños: ” << dia << “ de ” << mes << “ \n\n ” ;
return 0 ;
}
Clase PrgCumpleaños
básicos de un programa en Java y sus posibles variaciones.
*/
class PrgCumpleaños {
public static void main ( String arg[ ] ) {
int dia ;
String mes ;
dia= 23 ;
System.out.println ( “Cumpleaños: ” + dia + “ de ” + mes) ;
}
}
A continuación, se analizará el algoritmo de main diseñado en pseudocódigo para la solución del

problema anterior.
Primero se tiene: ALGORITMO PrgCumpleaños – main ( )
Está referida al nombre del algoritmo. En este caso, el nombre es

PrgCumpleaños – main(). Observe que la primera letra se escribe con
mayúscula.
Luego: 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 como
variable de salida a dia y mes.
Luego se tiene: INICIO:
Esta regla permite indicar el inicio de los pasos que constituyen la solución
al problema planteado.
A continuación: COMENTARIO “Este es nuestro cuarto algoritmo”
Utilizando la regla COMENTARIO, se pueden incluir diversas anotaciones

o descripciones dentro de un algoritmo diseñado en pseudocódigo, de
manera que permita mejorar la comprensión del mismo. En esta línea
se incluye el comentario “Este es nuestro cuarto algoritmo”. El uso de
comentarios dentro de un algoritmo es considerado una buena práctica de
programación.
Luego se tiene: NUMERO dia
Esta línea está referida al paso 1 del algoritmo diseñado en pseudocódigo. A

través de la regla NUMERO, se declara una variable numérica denominada
dia.
A continuación: TEXTO mes
Esta línea está referida al paso 2 del algoritmo diseñado en pseudocódigo. A

través de la regla TEXTO se declara una variable texto o cadena denominada
mes.
Luego tenemos: dia = 23
Esta línea está referida al paso 3 del algoritmo diseñado en pseudocódigo.

Aquí se asigna el valor 23 a la variable dia.
A continuación: mes = “Agosto”
Aquí se asigna la cadena de texto “Agosto” a la variable mes. Note que para
asignar una cadena de texto a una variable, esta debe estar entre comillas.
Luego tenemos: ESCRIBIR dia, mes
A través de la regla ESCRIBIR, se muestra el contenido de las variables dia y

mes. Observe que para mostrar el contenido de más de una variable, solo
deberá colocarlas una junto a la otra separadas por una coma.
Finalmente: FIN
Esta regla permite indicar el fin de los pasos que constituyen la solución

al problema planteado, es decir, el final del algoritmo diseñado en
pseudocódigo.
A continuación, se analizará el algoritmo de main diseñado en diagrama de flujo para la solución del
problema anterior.
Primero se tiene: ALGORITMO PrgCumpleaños – main ( )
Está referida al nombre del algoritmo. En este caso, el nombre es

PrgCumpleaños – main ( ). Note que la primera letra se escribe con
mayúscula.
Luego: INICIO
Este símbolo permite indicar el inicio de los pasos que constituyen la

solución al problema planteado.
A continuación: Este es nuestro cuarto algoritmo
Este símbolo permite incluir comentarios en el diagrama, con la finalidad

de mejorar la comprensión del algoritmo.
Luego tenemos: NUMERO dia

TEXTO mes
Este símbolo permite declarar variables. Se puede colocar varias

declaraciones en un solo rectángulo, o cada declaración en un solo
rectángulo. Se declara la variable dia de tipo NÚMERO y la variable mes de
tipo TEXTO.
A continuación: dia = 23
mes= "Agosto"
Este símbolo también se utiliza para asignar valores a las variables. Se asigna
el valor 23 a la variable dia y la cadena de texto “Agosto” a la variable mes.
Luego se tiene: dia, mes
Este símbolo permite mostrar el valor de las variables dia y mes.
Finalmente: FIN
Este símbolo permite indicar el fin de los pasos que constituyen la solución

al problema planteado, es decir, el final del algoritmo.
Ahora, analicemos cada sentencia de la codificación del algoritmo en el lenguaje de programación C++.
En primer lugar, observamos que el programa empieza con las líneas de código siguiente:
básicos de un programa en C++ y sus posibles variaciones
*/
Este es un comentario de múltiples líneas en C++. Para agregar un comentario de este tipo se utilizan los
símbolos /* para el inicio del comentario, y los símbolos */ para finalizar el comentario. Es importante
indicar que los comentarios son ignorados al momento de ejecutar el programa.
#include <iostream>
Indica que en el programa se utilizará el archivo de encabezado iostream, el cual es necesario para
utilizar la sentencia cout y la sentencia endl.
#include <string>
Indica que en el programa se utilizará el archivo de encabezado string, el cual es necesario para utilizar
tipos de dato TEXTO.
Es importante indicar que este archivo de encabezado debe estar incluido dentro de cualquier
programa en el que se necesite utilizar tipos de dato TEXTO (definidos como string en C++).
using std::cout ;
Elimina la necesidad de repetir el prefijo std:: en las sentencias cout.
using std::endl ;
Elimina la necesidad de repetir el prefijo std:: en las sentencias endl, las mismas que permiten
realizar un salto de línea y que la información se pueda visualizar en diferentes líneas.
using std::string ;
Elimina la necesidad de repetir el prefijo std:: cuando se usan tipos de dato TEXTO y las funciones
asociadas para el manejo de estos datos.
Es un comentario de una sola línea en C++. Para agregar un comentario de este tipo, solo es
necesario utilizar los símbolos // al inicio del comentario.
int main ( ) {
Es conocida como la firma de la función main o función principal. Todo programa en C++ que se
quiera ejecutar, deberá tener una función main. La palabra int a la izquierda de main indica que
main “devuelve” un valor entero (un número).
int dia ;
Permite declarar la variable dia como variable de tipo NUMERO. En C++ las variables de tipo
NUMERO pueden ser declaradas utilizando int.
string mes ;
Permite declarar la variable mes como variable de tipo TEXTO. En C++ las variables de tipo TEXTO
son declaradas utilizando string.
dia = 23 ;
Permite asignar el valor 23 a la variable dia, previamente declarada.
Permite asignar el valor “Agosto” a la variable mes, previamente declarada
cout << “ Cumpleaños: ” << dia << “ de ” << mes ;
Permite mostrar por pantalla el texto “Cumpleaños:”. Luego se muestra el contenido de la variable
dia, después el texto “de” y finalmente el contenido de la variable mes.
return 0 ;
Se indica que la finalización del programa ha sido exitosa, y devuelve el control al sistema operativo
o al IDE que lo ejecutó. La palabra return es una de las varias formas que se utilizan para indicar la
finalización de una función.
La última línea de código es:
Indica el final de la función main ( ) y del programa.
Finalmente, se analizará cada sentencia de la codificación del algoritmo en el lenguaje de programación

Java.
En primer lugar, se observa que el programa empieza con las líneas de código siguiente:
básicos de un programa en Java y sus posibles variaciones
*/
Este es un comentario de múltiples líneas en Java. Observe que este comentario también existe en C++
y es utilizado en Java de la misma forma.
La palabra reservada package especifica el nombre del paquete al que pertenecerá la clase creada con
la palabra reservada class. El nombre del paquete se encuentra a continuación de la palabra reservada
package. En este caso, el nombre del paquete es “dominioDeLaAplicacion”.
class PrgCumpleaños {
Observe que se utiliza la palabra reservada class, lo cual indica que se está declarando una clase. A
continuación, se encontrará el nombre de la clase: PrgCumpleaños. Finalmente, seguido del nombre
se coloca una llave de apertura ( { ), que indica el inicio del cuerpo de la clase.
Este es un comentario de una sola línea en Java. Observe que este comentario también existe en C++ y
es utilizado en Java de la misma forma.
Es conocida como la firma del método main ( ) o método principal. Toda clase en Java que se desee
ejecutar, deberá tener un método main ( ) exactamente como ha sido escrito, respetando las letras
minúsculas y mayúsculas.
int dia ;
Permite declarar la variable dia como variable de tipo NÚMERO. En Java, al igual que en C++, las
variables de tipo NÚMERO pueden ser declaradas utilizando int.
String mes ;
Permite declarar la variable mes como variable de tipo TEXTO. En Java, las variables de tipo TEXTO
son declaradas utilizando String.
dia = 23 ;
Permite asignar el valor 23 a la variable dia, previamente declarada.
Permite asignar el valor “Agosto” a la variable mes, previamente declarada.

System.out.println ( “Cumpleaños: ” + dia + “ de ” + mes) ;
Permite mostrar por pantalla el texto “Cumpleaños: ”. Luego se muestra el contenido de la variable dia;
después el texto “ de ” y finalmente el contenido de la variable mes.
Las dos últimas líneas de código son:
}
}
La primera llave de cierre ( } ) indica el final del método main ( ). La última llave de cierre indica el final
de la clase.
2.6 USO DE COMENTARIOS

La mayoría de lenguajes de programación permiten a los desarrolladores colocar comentarios dentro
de un programa o una clase, lo que permite mejorar la comprensión y entendimiento de estos. El uso
de comentarios en los programas y clases es considerado como una buena práctica de programación,
y contribuye a facilitar el mantenimiento (modificación de los programas o las clases con la finalidad
de corregir errores o mejorar su funcionamiento).
En Java y C++ existen tres tipos de comentarios, y en ambos lenguajes de programación se utilizan de
la misma forma y con los mismos símbolos.
El primer tipo de comentario se llama comentario de múltiples líneas. Este tipo de comentario empieza
con un /* (una barra seguida por un asterisco) y termina con un */ (un asterisco seguida por una
barra). Todas las líneas que quedan comprendidas entre los dos símbolos de comentario son ignoradas
al momento de ejecutar el programa o la clase. Los comentarios de este tipo pueden tener una o más
líneas de longitud.
El segundo tipo de comentario se llama comentario de una sola línea. Este tipo de comentario empieza
con un // (dos barras) y termina al final de la línea. Típicamente, los programadores usan comentarios
de múltiples líneas al describir comentarios extensos de múltiples líneas, y usan comentarios de una
sola línea cuando necesitan comentarios más breves. No obstante, este es un tema de estilo personal.
El tercer tipo de comentario permite documentar una clase desarrollada para ser utilizada en diferentes
soluciones (documentación de clases reutilizables). Un ejemplo de este tipo de comentarios se puede
encontrar en la definición de la clase LE, especificada en el apéndice.
Problema 005
Enunciado: El alumno Wally Flores ha obtenido 15 de promedio final en Matemática; se requiere

mostrar su nombre, su apellido y su promedio final.
Etapa 02 - Definición del problema
A. Resultado deseado: Mostrar datos del alumno y el promedio obtenido.

C. Procesamiento: Los datos serán almacenados en variables; luego se mostrarán los datos.
1. Nombre del proyecto: ProyAlumno

Paquete y clase
PrgAlumno
||main ()

En pseudocódigo:
Algoritmo PrgAlumno – main ( )
ENTRADA:
SALIDA: nombre, apellido, nf
INICIO
COMENTARIO “Declaración de variables y asignación de datos.”
TEXTO nombre = “Wally”, apellido = “Flores”
NUMERO nf = 15
COMENTARIO “Mostrar información.”

ESCRIBIR “Nombre del alumno: ” + nombre + “ ” + apellido
ESCRIBIR “promedio final: ” + nf
FIN
INICIO
Declaración de variables y
asignación de datos.
TEXTO nombre = “Wally”, apellido = “Flores”
NUMERO nf = 15
Mostrar información.
nombre, apellido,
nf
FIN
Clase PrgAlumno
class PrgAlumno {
public static void main ( String arg[ ] ) {
// Declaración de variables y asignación de datos.

String nombre = “Wally”, apellido = “Flores” ;
int nf = 15 ;
// Mostrar información.
System.out.println ( “Nombre del alumno: ” + nombre + “ ” + apellido) ;
System.out.println ( “Promedio final: ” + nf + “.” ) ;
}
}
Intente desarrollar la codificación en el lenguaje de programación C++.

Problema 006
Enunciado: Se desea mostrar el mensaje “Feliz Navidad” y el mensaje “Próspero Año nuevo”.
Etapa 02 - Definición de la solución
A. Resultado deseado: Mostrar mensajes de saludo.

C. Procesamiento: Los saludos serán almacenados en dos variables llamadas msjNavidad y
msjNuevo, y luego serán mostrados.
1. Nombre del proyecto: ProySaludo

Paquete y clase
PrgSaludo
||main ()

En pseudocódigo:
Algoritmo PrgSaludo – main ( )
ENTRADA:
SALIDA: msjNavidad, msjNuevo
INICIO
COMENTARIO “Declaración de variables y asignación de datos.”

TEXTO msjNavidad, msjNuevo = “Próspero año nuevo”
msjNavidad = “Feliz Navidad”
COMENTARIO “Mostrar información.”

ESCRIBIR msjNavidad + “ y ” + msjNuevo
FIN
INICIO
Declaración de variables y asignación
de datos.
TEXTO msjNavidad, msjNuevo = “Próspero año
nuevo”
msjNavidad = “Feliz Navidad”
Mostrar información.
msjNavidad, msjNuevo
FIN

Clase PrgSaludo
#include <iostream>
#include <conio.h>
#include <string>
using std::cout ;
using std::string ;
int main ( ) {
// Declaración de variables y asignación de datos.

string msjNavidad, msjNuevo = “ Próspero Año Nuevo” ;
msjNavidad = “ Feliz Navidad” ;
// Mostrar información.
cout << msjNavidad << “ y” << msjNuevo ;
getch ( ) ;
return 0 ;
}
Intente desarrollar la codificación en el lenguaje de programación Java.
IMPORTANTE
Se recomienda solucionar los problemas propuestos del 1 al 5,
planteados al final del presente capítulo.
2.7 ESTRUCTURA LÓGICA DE SECUENCIA: INGRESAR DATOS
2.7.1 Definición
El ingreso de datos es la forma o mecanismo empleado para obtener los datos que un algoritmo
necesita para generar información. En los lenguajes de programación, este tipo de estructura
permite ingresar datos a través de un dispositivo de entrada de una computadora.
2.7.2 Representación
Para representar la entrada de datos se utiliza:
La regla: LEER En pseudocódigo
El símbolo : En diagrama de flujo
La sentencia: cin En C++
La clase: Lectura En Java
Para ingresar una cadena de texto y almacenar el valor ingresado en la variable nombre, deberá
realizar los siguientes pasos:
En pseudocódigo: LEER nombre
En diagrama de flujo: nombre
En el lenguaje de programación C++: cin >> nombre ;
Esta sentencia permite el ingreso de datos por teclado. El operador “>>” permite que el valor
ingresado a través de “cin” se asigne a la variable ubicada a la derecha, ya que “cin” en este caso es
el dispositivo de entrada, y representa una entrada a través del teclado.
Cuando utilice cin deberá asegurarse de incluir al inicio de sus programas el archivo de cabecera
iostream, utilizando la siguiente línea de código:
#include<iostream>
También deberá asegurarse de incluir al inicio de sus programas la sentencia using respectiva. Esto es
necesario ya que en C++ se necesita indicar el espacio de nombre al que pertenece dicha sentencia, es
decir, la siguiente línea de código será necesaria cuando utilice dicha sentencia:
using std::cin ;
Si no utiliza la sentencia, deberá anteceder a todas las sentencias cin el prefijo std::
En el lenguaje de programación Java:
nombre = Lectura.leerString ( ) ;
Se utiliza la clase Lectura y el método apropiado de dicha clase. Esta clase permite el ingreso de datos
por teclado. El método leerString( ) de la clase Lectura permite que una cadena de texto ingresada
por teclado se almacene en una variable. En el ejemplo, la cadena de texto se almacena en la variable
nombre.
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, denominada Lectura.
La clase Lectura facilita el ingreso de datos en consola. Esta clase permite ingresar datos en forma
tradicional y será usada para la codificación de algoritmos en Java.
CLASE MÉTODO DESCRIPCIÓN
leerString() Permite ingresar una cadena de texto.
Permite ingresar un carácter (una sola

leerChar()
letra, número o símbolo).
leerInt() Permite ingresar un número entero.
Lectura.class Permite ingresar un número entero

leerLong()
largo.
Permite ingresar un número con parte

leerFloat()
decimal de simple precisión.
Permite ingresar un número con parte

leerDouble()
decimal de doble precisión.
La definición de la clase se muestra a continuación:
Lectura
||leerString ()
||leerChar ()
||leerInt ()
||leerLong ()
||leerFloat ()
||leerDouble ()
Una consideración importante en la definición de la clase Lectura es el paquete al cual pertenece. Si

desea, puede definir la clase Lectura en el mismo paquete en el cual se definió la clase que permite
solucionar el problema, es decir, en el paquete dominioDeLaAplicacion (ver problemas resueltos del
007 al 012).
Pero la mejor decisión será definir la clase Lectura en un paquete independiente, distinto al paquete
dominioDeLaAplicacion, al que se le denominará biblioteca. Esto se justifica debido a que, por
definición, los paquetes permiten agrupar clases con funciones similares (ver los problemas resueltos
a partir del problema 013).
Si se define la clase Lectura en un paquete denominado biblioteca, cada vez que desee utilizar esta
clase en sus soluciones deberá indicarlo explícitamente, utilizando la sentencia siguiente:
import biblioteca.Lectura ;
En el apéndice podrá encontrar la codificación de la clase Lectura. Esta constituye un buen ejemplo de
una clase reutilizable, y ha sido diseñada solo con fines académicos.
Problema 007
Enunciado: Ingrese el nombre de una persona y muéstrelo junto al mensaje “bienvenido. ¿Cómo
estás?”.
A. Resultado deseado: Mostrar el nombre de una persona y un mensaje de bienvenida.

B. Datos necesarios: Nombre de una persona.
C. Procesamiento: El nombre de la persona será ingresado por teclado y almacenado en una
variable (nombre). Luego se mostrará el nombre que ingresó junto con el
mensaje “bienvenido. ¿Cómo estás?”, almacenado en la variable (mensaje).
1. Nombre del proyecto: ProyBienvenida2

2. Definición de paquete y clases
Paquete
Clases de dominioDeLaAplicación
Lectura
||leerString ( )
||leerChar ( )
PrgBienvenida2
||leerInt ( )
||main ( ) ||leerLong ( )
||leerFloat ( )
||leerDouble ( )
3. Diseño del algoritmo.

En pseudocódigo:
Algoritmo PrgBienvenida2 – main ( )
ENTRADA: nombre
SALIDA: nombre, mensaje
INICIO
TEXTO nombre, mensaje

mensaje = “ bienvenido. ¿Cómo estás? ”
LEER nombre
ESCRIBIR nombre, mensaje
FIN
Algoritmo PrgBienvenida2 – main ( )
INICIO
TEXTO nombre, mensaje
mensaje = “ bienvenido. ¿Cómo estás? ”
nombre
nombre, mensaje
FIN
Clase PrgBienvenida2
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::endl ;
using std::string ;
int main ( ) {
string nombre, mensaje ;
mensaje = “ bienvenido. ¿Cómo estás? ” ;
cout << “ Ingrese su nombre: ” ;

cin >> nombre ;
cout << nombre << “ ” << mensaje << endl ;

cout << endl ;
return 0 ;
}
class PrgBienvenida2 {
String nombre, mensaje ;
mensaje = “bienvenido. ¿Cómo estás? ” ;
System.out.print ( “ Ingrese su nombre: ” ) ;

System.out.println ( nombre + “ ” + mensaje ) ;

}
}
Problema 008
Enunciado: Ingrese el nombre y la edad de una persona. Muestre los datos ingresados.
A. Resultado deseado: Mostrar el nombre y la edad de una persona.

B. Datos necesarios: Nombre y edad de una persona.
C. Procesamiento: El nombre de la persona y su edad serán ingresados por teclado
y almacenados en variables (nombre y edad respectivamente). Luego se
mostrarán dichos datos.
1. Nombre del proyecto: ProyEdad

Paquete
Lectura
||leerString ( )
||leerChar ( )
PrgEdad
||leerInt ( )
||leerFloat ( )
||leerDouble ( )

Algoritmo PrgEdad – main ( )
INICIO
TEXTO nombre
ENTERO edad
nombre, edad
“El nombre es ” + nombre

+ “ y su edad es “ + edad
FIN
Intente diseñar el algoritmo en pseudocódigo.
Clase PrgEdad
#include <iostream>
#include <string>
using namespace std ;
int main ( ) {
string nombre ;
int edad ;
cout << “ Ingrese su nombre: ” ;

cin >> nombre ;
cout << “ Ingrese su edad: ” ;
cin >> edad ;
cout << “ Su nombre es ” << nombre << “ y su edad es ” << edad ;
cout << “ \n\n ” ;
return 0 ;
}

¿Qué hay de nuevo en la codificación?
Permite especificar el uso de namespace std. El contenido del archivo de encabezado <iostream>
se define como parte del namespace std. Este tiene como miembros a cout, cin, endl, string, entre
otros.
La instrucción using namespace especifica que los miembros de un namespace van a utilizarse
frecuentemente en un programa. Esto permite tener acceso a todos los miembros del namespace y
codificar sentencias de manera más concisa.
Es importante indicar que la mayoría de programadores de C++ consideran que es una mala
práctica el escribir una instrucción using como la indicada, ya que se incluye todo el contenido del
namespace. Si no se utiliza dicha línea de código, deberá especificar qué miembros del namespace
utilizará en su programa. En este caso se utilizarán las siguientes líneas de código, del mismo modo
que en los problemas anteriores:
using std::cout ;
using std::cin ;
using std::endl ;
using std::string ;
Problema 009
Enunciado: Ingrese el peso de una bolsa de chocolates y muestre los datos ingresados.
A. Resultado deseado: Mostrar el peso de una bolsa de chocolates.

B. Datos necesarios: Peso de la bolsa.
C. Procesamiento: El peso de la bolsa de chocolates será ingresado por teclado y almacenado
en una variable (peso). Luego se mostrará el peso que se ingresó.
1. Nombre del proyecto: ProyPeso

2. Definición de paquete y clases
Paquete
Lectura
||leerString ( )
||leerChar ( )
PrgPeso
||leerInt ( )
||leerFloat ( )
||leerDouble ( )

En pseudocódigo:
Algoritmo PrgPeso – main ( )
ENTRADA: peso
SALIDA: peso
INICIO
REAL peso
LEER peso
ESCRIBIR peso
FIN
Intente diseñar el algoritmo en diagrama de flujo.

Clase PrgPeso
class PrgPeso {
public static void main ( String arg []) {
double peso ;
System.out.print ( “ Ingrese el peso de la bolsa de chocolates: ” ) ;
peso = Lectura.leerDouble( ) ;
System.out.print ( “ El peso de la bolsa de chocolates es: ” + peso ) ;
}
}
IMPORTANTE
Se recomienda solucionar los problemas propuestos del 6
al 10, planteados al final del presente capítulo.
2.8 ESTRUCTURA LÓGICA DE SECUENCIA: PROCESAR DATOS
2.8.1 Definición
Las operaciones aritméticas y lógicas son las formas o mecanismos que se emplean para procesar los
datos ingresados y obtener información.
2.8.2 Tipos
A. Operadores aritméticos
Para representar las operaciones aritméticas básicas se utilizan los operadores aritméticos, y se
emplean los mismos signos que en la aritmética tradicional.
PÝçÊÌ®¦Ê ù
C++ ù Jò RÖÙÝÄã
®¦ÙÃ ¥½ç¹Ê
+ + Suma
- - Resta
* * Multiplicación
/ / División
% o RESTO % Resto o módulo
Los operadores aritméticos son binarios, es decir, son operadores que requieren dos operandos.
Por ejemplo, la expresión aritmética num1 * num2 contiene el operador aritmético binario de
multiplicación y dos operandos num1 y num2.
Las expresiones aritméticas deben introducirse en línea recta, y pueden utilizar paréntesis de la
misma forma que en las expresiones algebraicas.
En una expresión aritmética se evalúan primero las operaciones que están entre paréntesis, luego las
operaciones de multiplicación, división y resto, y finalmente las operaciones de suma y resta.
B. Operador de asignación
Permite asignar un determinado valor a una variable.
PÝçÊÌ®¦Ê ù
®¦ÙÃ ¥½ç¹Ê
= = Asignación de datos
C. Operadores relacionales
Permiten crear condiciones lógicas simples que puedan ser usadas en estructuras lógicas de decisión
y estructuras lógicas de repetición.
PÝçÊÌ®¦Ê ù
®¦ÙÃ ¥½ç¹Ê
< < Menor que
> > Mayor que
= ó == == Igual que
<= <= Menor o igual que
>= >= Mayor o igual que
<> ó != != Distinto de
Estos operadores serán utilizados a partir del capítulo III.
D. Operadores lógicos
Permiten crear condiciones lógicas compuestas, que pueden ser usadas en estructuras lógicas de
decisión y estructuras lógicas de repetición.
PÝçÊÌ®¦Ê ù
®¦ÙÃ ¥½ç¹Ê
NO (NOT) ó ! ! Negación
Y (AND) ó && && Conjunción
O (OR) ó || || Disyunción
Estos operadores serán utilizados a partir del tercer capítulo.
Problema 010
Enunciado: Se requiere mostrar el resultado de sumar, multiplicar, restar y dividir los números
912123 y 735.
A. Resultado deseado: Mostrar el resultado de las operaciones matemáticas básicas: suma,

multiplicación, resta y división de los números 912123 y 735.
C. Procesamiento: 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.
Defina el nombre del proyecto y desarrolle la definición del paquete y las clases.

En pseudocódigo:
Algoritmo PrgOperaciones – main ( )
ENTRADA:
SALIDA: suma, multi, resta, divi
INICIO
NUMERO num1 = 912123, 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
INICIO
NUMERO num1=912123, num2=735, suma,

multi, resta, divi
suma = num1 + num2

multi = num1 * num2
resta = num1 – num2
divi = num1 / num2
suma, multi, resta, divi
FIN

Clase PrgOperaciones
#include <iostream>
#include <conio.h>
using std::cout ;
using std::endl ;
int main () {
long num1 = 912123, num2 = 735, suma, resta, multi ;
double divi ;
suma = num1 + num2 ;
resta = num1 – num2 ;
multi = num1 * num2 ;
divi = (double) (num1) / num2 ;
cout << “ La suma es: ” << suma << endl ;

cout << “ La resta es: ” << resta << endl ;
cout << “ La multiplicación es: ” << multi << endl ;
cout << “ La división es: ” << divi << endl << endl ;
getch ( ) ;
return 0 ;
}
class PrgOperaciones {

long num1 = 912123, 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 ) ;
}
}
Problema 011
Enunciado: Ingrese el precio de un artículo y su respectivo descuento (expresado en %). Muestre

el precio total a pagar considerando el descuento y el IGV respectivos (IGV: Impuesto General a las
Ventas = 19 %).
A. Resultado deseado: Mostrar el precio total a pagar por un determinado artículo.

B. Datos necesarios: Precio del artículo sin incluir IGV y su respectivo descuento(expresado en %).
C. Procesamiento: El precio del artículo y el descuento serán ingresados a través del teclado,
y almacenados en variables (precio y descuento). Luego, se calcula el precio
total a pagar utilizando la siguiente fórmula:
precioTotal = (precio – (precio * descuento) / 100 ) * 1.19
El resultado se almacena en una variable (precioTotal), para luego mostrar el

resultado de dicha operación.

En pseudocódigo:
Algoritmo PrgArƟculo – main ( )
ENTRADA: precio, descuento

SALIDA: precioTotal
INICIO
NUMERO precio, descuento, precioTotal

LEER precio, descuento
precioTotal = (precio – ( precio * descuento ) / 100 ) * 1.19
ESCRIBIR precioTotal
FIN
INICIO
NUMERO precio, descuento, precioTotal
precio,
descuento
precioTotal = ( precio – ( precio * descuento ) / 100 ) * 1.19
precioTotal
FIN
En el lenguaje de programacion Java:
Clase PrgArƟculo
class PrgArticulo {
double precio, descuento, precioTotal ;
System.out.print ( “ Ingrese el precio del artículo: ” ) ;

precio = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese descuento en %: ” ) ;

descuento = Lectura.leerDouble ( ) ;
precioTotal = ( precio – ( precio * descuento ) / 100 ) * 1.19 ;
System.out.print ( “ El precio total a pagar es: ” ) ;

System.out.println ( precioTotal ) ;
}
}

Problema 012
Enunciado: Diseñe un programa que permita ingresar dos números enteros, y muestre la suma de
los dígitos correspondientes a las unidades, decenas y centenas de los números ingresados.
Desarrolle la definición de la solución

En pseudocódigo:
Algoritmo PrgSumaDigitos – main ( )
ENTRADA: numero1, numero2

SALIDA: sumaUnidades, sumaDecenas, sumaCentenas
INICIO
ENTERO numero1, numero2

ENTERO unidades1, unidades2, sumaUnidades
ENTERO decenas1, decenas2, sumaDecenas
ENTERO centenas1, centenas2, sumaCentenas
LEER numero1, numero2
unidades1 = numero1 % 10
unidades2 = numero2 % 10
decenas1 = ( numero1 / 10 ) % 10
decenas2 = ( numero2 / 10 ) % 10
centenas1 = ( numero1 / 100 ) % 10
centenas2 = ( numero2 / 100 ) % 10
sumaUnidades = unidades1 + unidades2

sumaDecenas = decenas1 + decenas2
sumaCentenas = centenas1 + centenas2
ESCRIBIR sumaUnidades, sumaDecenas, sumaCentenas

FIN

Clase PrgSumaDigitos
class PrgSumaDigitos {
int numero1, numero2 ;
int unidades1, unidades2, sumaUnidades ;

int decenas1, decenas2, sumaDecenas ;
int centenas1, centenas2, sumaCentenas ;
System.out.print ( “Ingrese el primer número: ” ) ;

numero1 = Lectura.leerInt ( ) ;
System.out.print ( “Ingrese el segundo número: ” ) ;

numero2 = Lectura.leerInt ( ) ;
unidades1 = numero1 % 10 ;
decenas1 = ( numero1 / 10 ) % 10 ;
decenas2 = ( numero2 / 10 ) % 10 ;
centenas1 = ( numero1 / 100 ) % 10 ;

centenas2 = ( numero2 / 100 ) % 10 ;
sumaUnidades = unidades1 + unidades2 ;

sumaDecenas = decenas1 + decenas2 ;
sumaCentenas = centenas1 + centenas2 ;
System.out.print ( " \nNúmeros ingresados " + numero1 + " y "+ numero2 ) ;

System.out.print ( " \n\nLa suma de sus unidades es\t:" + sumaUnidades ) ;
System.out.print ( " \nLa suma de sus decenas es\t:" + sumaDecenas ) ;
System.out.println ( " \nLa suma de sus centenas es\t:" + sumaCentenas) ;
}
}
Clase PrgSumaDigitos
#include <iostream>
#include <conio.h>
int main () {
int numero1, numero2 ;

int unidades1, unidades2, sumaUnidades ;
int decenas1, decenas2, sumaDecenas ;
int centenas1, centenas2, sumaCentenas ;
cout << “Ingrese el primer número: ” ;

cin >> numero1;
cout << “Ingrese el segundo número: ” ;

cin >> numero2 ;
decenas1 = ( numero1 / 10 ) % 10 ;
decenas2 = ( numero2 / 10 ) % 10 ;
centenas1 = ( numero1 / 100 ) % 10 ;

centenas2 = ( numero2 / 100 ) % 10 ;
sumaUnidades = unidades1 + unidades2 ;

sumaDecenas = decenas1 + decenas2 ;
sumaCentenas = centenas1 + centenas2 ;
cout << “\nNúmeros ingresados ” << numero1 << “ y ” << numero2 ;

cout << “\n\nLa suma de sus unidades es \t: ” << sumaUnidades ;
cout << “\nLa suma de sus decenas es \t: ” << sumaDecenas ;
cout << “\nLa suma de sus centenas es \t: ” << sumaCentenas;
cout << endl ;
return EXIT_SUCCESS ;
}
IMPORTANTE

que están planteados al final del presente capítulo.
2.9 MÉTODO DE LAS 6´D - DESARROLLO DE SOLUCIONES CON DOS PAQUETES
A continuación, se definen formalmente los pasos del Método de las 6’D para el desarrollo de
soluciones utilizando dos paquetes.
ENUNCIADO
DEL
PROBLEMA

información deseada nombre del proyecto. de la solución del
(salida). }|Definir los paquetes problema. Utilizar
}|Determinar los y desarrollar el el lenguaje de
datos de entrada diagrama de paquetes programación C++ o
(entrada). respectivo. Establecer Java.
}|Establecer cómo la dependencia.
se solucionará el Utilice UML.
problema (proceso). }|Definir las clases
que serán parte
de la solución del
problema. Utilice
UML.
ALGORITMO
para el método
principal. Utilizar
pseudocódigo o
diagrama de flujo.
De manera general, la Etapa 03 - “Diseño de la solución” se divide en dos partes: modelamiento (paso
1, 2 y 3) y algoritmo (paso 4); mientras que la Etapa 04 - “Desarrollo de la solución” contiene la parte
de codificación (paso 1). También se puede utilizar esta división en el desarrollo de las soluciones.
Problema 013
Enunciado: Desarrolle una solución que permita calcular el área de un cuadrado y el área de un
triángulo rectángulo. Considere:
Área del cuadrado = lado2
Área del triángulo rectángulo = (base x altura) / 2
A. Resultado deseado: Mostrar el área de un cuadrado y el área de un triángulo rectángulo.

B. Datos necesarios: Lado del cuadrado y la base y altura de triángulo rectángulo.
C. Procesamiento: El lado del cuadrado y la base y la altura del triángulo rectángulo serán
ingresados por teclado y almacenados en variables (lado, base y altura).
Luego, se calculará el área del cuadrado y el área del triángulo rectángulo.
Los resultados serán almacenados en variables (areaCuadrado y
areaTriangulo), para luego ser mostrados.
1. Nombre del proyecto: ProyAreas

2. Definición de paquetes y diagrama de paquetes
Diagrama de paquetes
dominioDeLaAplicacion biblioteca
3. Definición de clases
Desarrolle la definición de las clases

En pseudocódigo:
Algoritmo PrgAreas – main ( )
ENTRADA: lado, base, altura
SALIDA: areaCuadrado, areaTriangulo
INICIO
REAL lado, base, altura, areaCuadrado, areaRectangulo
LEER lado, base, altura
areaCuadrado = lado * lado

areaTriangulo = ( base * altura ) / 2
ESCRIBIR “ El área del cuadrado es: ” + areaCuadrado

ESCRIBIR “ El área del triángulo rectángulo es: ” + areaTriangulo
FIN
Algoritmo PrgAreas – main ( )
INICIO
REAL lado, base, altura,

area Cuadrado, areaTriangulo
lado, base, altura
areaCuadrado = lado * lado

areaTriangulo = ( base*altura ) / 2
areaCuadrado,
areaTriangulo
FIN
Clase PrgAreas
#include <iostream>
#include <conio.h>
using namespace::std;
int main ( ) {
double lado, base, altura , areaCuadrado, areaTriangulo ;
cout << “ Ingrese el lado del cuadrado: ” ;
cin >> lado ;
cout << “ Ingrese la base del triángulo: ” ;
cin >> base ;
cout << “ Ingrese la altura del triángulo: ” ;
cin >> altura ;
areaCuadrado = lado * lado ;

areaTriangulo = ( base * altura ) / 2 ;
cout << endl ;

cout << “ El área del cuadrado es \t: ” << areaCuadrado << endl ;
cout << “ El área del triángulo es \t: ” << areaTriangulo << endl ;
getch ( ) ;
return 0 ;
}
Clase PrgAreas
class PrgAreas {
double lado, base, altura, areaCuadrado, areaTriangulo ;
System.out.print ( “ Ingrese el lado del cuadrado: ” ) ;
lado = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese la base del triángulo: ” ) ;
base = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese la altura del triángulo: ” ) ;
altura = Lectura.leerInt ( ) ;
areaCuadrado = lado * lado ;

areaTriangulo = ( base * altura ) / 2;
System.out.println ( ) ;
System.out.println ( “ El área del cuadrado es \t: ” + areaCuadrado ) ;
System.out.println ( “ El área del triángulo es \t: ” + areaTriangulo ) ;
}
}
Problema 014
Enunciado: Desarrolle una solución que permita ingresar una cantidad de dinero en dólares,
mostrando la menor cantidad de billetes de 100, 50, 10 y monedas de 1 dólar que serán necesarios
para completar la cantidad ingresada.
A. Resultado deseado: Mostrar la menor cantidad de billetes de 100, 50, 10 y monedas de 1 dólar,
necesarios para completar la cantidad ingresada.
B. Datos necesarios: Cantidad de dinero en dólares.
C. Procesamiento: La cantidad de dinero en dólares será ingresada por el teclado y almacenado
en una variable (dolares). Luego se calculará la menor cantidad de billetes
y monedas necesarios para completar la cantidad ingresada, almacenando
los resultados en variables (b100, b50, b10 y m1). Los resultados se
mostrarán por pantalla.
1. Nombre del proyecto: ProyDolares

Clase de
Clase de biblioteca
Lectura
||leerString ( )
PrgDolares ||leerChar ( )
||leerInt ( )
||main
||leerLong ( )
||leerFloat ( )
||leerDouble ( )

En pseudocódigo:
Algoritmo PrgDolares – main ( )
ENTRADA: dolares
SALIDA: b100, b50, b10, m1
INICIO
ENTERO dolares, b100, b50, b10, m1

LEER dolares
b100 = dolares / 100

b50 = dolares % 100 / 50
b10 = dolares % 100 % 50 / 10
m1 = dolares % 100 % 50 % 10
ESCRIBIR b100, b50, b10, m1
FIN
Algoritmo PrgDolares – main ( )
INICIO
ENTERO dolares, b100, b50, b10, m1
dolares
b100 = dolares / 100

b50 = dolares % 100 / 50
b10 = dolares % 100 % 50 / 10
m1 = dolares % 100 % 50 % 10;
b100, b50, b10, m1
FIN

Clase PrgDolares
#include <iostream>
#include <conio.h>
int main ( ) {
int dolares, b100, b50, b10, m1 ;
cout << “ Ingrese una cantidad en dólares: ” ;

cin >> dolares ;
b100 = dolares / 100 ;

b50 = dolares % 100 / 50 ;
b10 = dolares % 100 % 50 / 10 ;
m1 = dolares % 100 % 50 % 10 ;
cout << endl ;

cout << “ Cantidad de billetes de $100 \t: ” << b100 << endl ;
cout << “ Cantidad de monedas de $1 \t: ” << m1 << endl ;
getch ( ) ;
return 0 ;
}
Clase PrgDolares
class PrgDolares {
int dolares, b100, b50, b10, m1 ;
System.out.print ( “ Ingrese una cantidad de dólares: ” ) ;

dolares = Lectura.leerInt ( ) ;
b100 = dolares / 100 ;

b50 = dolares % 100 / 50 ;
b10 = dolares % 100 % 50 / 10 ;
m1 = dolares % 100 % 50 % 10 ;
System.out.println ( “ Cantidad de billetes de $100 \t: ” + b100 ) ;
System.out.println ( “ Cantidad de monedas de $1 \t: ” + m1 ) ;
}
}
Problema 015
Enunciado: Leer un número y calcular el resto de dividir el número entre 2. Muestre el resto de la
división.
A. Resultado deseado: Mostrar el resto de dividir un número entre el número 2.

B. Datos necesarios: El número a dividir.
C. Procesamiento: El número será ingresado por teclado y almacenado en una variable
(numero). Luego, el resto de la división se almacenará en una variable
(resto), para luego ser mostrada por pantalla.
1. Nombre del proyecto: ProyRestoDivision

Clase de Clase de biblioteca

Lectura
||leerString ( )
PrgRestoDivision
||leerChar ( )
||main ||leerInt ( )
||leerLong ( )
||leerFloat ( )
||leerDouble ( )

En pseudocódigo:
Algoritmo PrgRestoDivision – main ( )
ENTRADA: numero
SALIDA: resto
INICIO
NUMERO numero, resto

LEER numero
resto = numero RESTO 2
ESCRIBIR resto
FIN
Intente diseñar el algoritmo en un diagrama de flujo.
Observe que en el diseño del algoritmo aparece la regla “RESTO”, que es utilizada en pseudocódigo
y diagrama de flujo para obtener el resto o residuo de una división. Dicha palabra no se puede
utilizar como nombre de variable. Puede utilizar también el signo de porcentaje (%).
Clase PrgRestoDivision
class PrgRestoDivision {
int numero, resto ;
System.out.print ( “ Ingrese un número entero: ” ) ;

numero = Lectura.leerInt ( ) ;
resto = numero % 2 ;
System.out.print ( “ El resto de dividir el número ” + numero ) ;

System.out.println ( “ entre el número 2 es: ” + resto ) ;
}
}

Problema 016
Enunciado: Dada las horas, minutos y segundos transcurridos del día miércoles, desarrolle una
solución que permita mostrar las horas, minutos y segundos faltantes para llegar al mediodía del
viernes próximo.
Desarrolle la definición de la solución.
Defina el nombre del proyecto, desarrolle la definición de paquetes, el diagrama de paquetes y la

definición de las clases.

En pseudocódigo:
Algoritmo PrgHoras – main ( )
ENTRADA: segTransMier
SALIDA: horas, minutos, segundos
INICIO
ENTERO segTransMier ;
ENTERO segFaltanMier, segFaltanJue, segFaltanVie, segFaltanTotal
ENTERO horas, minutos, segundos
LEER segTransMier
segFaltanMier = 24 * 3600 - segTransMier

segFaltanJue = 24 * 3600
segFaltanVie = 12 * 3600
segFaltanTotal = segFaltanMier + segFaltanJue + segFaltanVie
horas = segFaltanTotal / 3600

minutos = segFaltanTotal % 3600 / 60
segundos = segFaltanTotal % 3600 % 60
ESCRIBIR horas, minutos, segundos
FIN

Clase PrgHoras
#include <iostream>
#include <conio.h>
int main ( ) {
int segTransMier ;
int segFaltanMier, segFaltanJue, segFaltanVie,segFaltanTotal ;
int horas, minutos, segundos ;
cout << “ Ingrese los segundos transcurridos del día miércoles: ” ;

cin >> segTransMier ;
// Hallando los segundos que faltan para el medio día del viernes
segFaltanMier = 24 * 3600 – segTransMier ;
segFaltanJue = 24 * 3600 ;
segFaltanVie = 12 * 3600 ;
segFaltanTotal = segFaltanMier + segFaltanJue + segFaltanVie ;
// Hallando las horas, minutos y segundos que faltan para el viernes

horas = segFaltanTotal / 3600 ;
minutos = segFaltanTotal % 3600 / 60 ;
segundos = segFaltanTotal % 3600 % 60 ;
// Visualizando los resultados

cout << “ \n Faltan: ” << horas << “ horas, ” << minutos <<
“ minutos y ” << segundos << “ segundos ” ;
cout << “ \n Para llegar al medio día del viernes próximo. ” ;
getch ( ) ;
return 0 ;
}
Clase PrgHoras
class PrgHoras {
int segTransMier ;
int segFaltanMier, segFaltanJue, segFaltanVie,segFaltanTotal ;
System.out.print ( “ Ingrese segundos transcurridos del día miércoles: ” );

segTransMier = Lectura.leerInt( ) ;
// Hallando los segundos que faltan para el medio día del viernes
segFaltanMier = 24 * 3600 - segTransMier ;
segFaltanJue = 24 * 3600 ;
segFaltanVie = 12 * 3600 ;
segFaltanTotal = segFaltanMier + segFaltanJue + segFaltanVie ;
// Hallando las horas, minutos y segundos que faltan para el viernes

horas = segFaltanTotal / 3600 ;
minutos = segFaltanTotal % 3600 / 60 ;
segundos = segFaltanTotal % 3600 % 60 ;
// Visualizando los resultados

System.out.println ( “ \n Faltan: ” + horas + “ horas, ” + minutos +
“ minutos y ” + segundos + “ segundos ” ) ;
System.out.println ( “ Para llegar al medio día del viernes próximo. ” ) ;
}
}
Problema 017
Enunciado: Una fábrica que se dedica a la producción de baldes de plástico, tiene registrado los
siguientes tiempos de producción para cada uno de sus productos.
}|Baldes tipo A: 0.25 minutos

}|Baldes tipo B: 15 segundos
}|Baldes tipo C: 1 minuto y 2 segundos
Se solicita desarrollar una solución que permita determinar el tiempo en horas, minutos y segundos
que se necesitarán para producir una determinada cantidad de baldes de cada tipo.


En pseudocódigo:
Algoritmo PrgBaldes – main ( )
ENTRADA: baldesA, baldesB, baldesC

SALIDA: horas, minutos, segundos
INICIO
ENTERO baldesA, baldesB, baldesC

ENTERO tiempoA, tiempoB, tiempoC, tiempoTotal
ENTERO horas, minutos, segundos
LEER baldesA, baldesB, baldesC
tiempoA = baldesA * 15
tiempoB = baldesB * 15
tiempoC = baldesC * 62
tiempoTotal = tiempoA + tiempoB + tiempoC
horas = tiempoTotal / 3600

minutos = tiempoTotal % 3600 / 60
segundos = tiempoTotal % 3600 % 60
ESCRIBIR horas, minutos, segundos
FIN

Clase PrgBaldes
#include <iostream>
#include <conio.h>
int main ( ) {
int baldesA, baldesB, baldesC ;

int tiempoA, tiempoB, tiempoC, tiempoTotal ;
cout << “ Ingrese cantidad de baldes tipo \“A\” a producir: ” ;

cin >> baldesA ;
cout << “ Ingrese cantidad de baldes tipo \“B\” a producir: ” ;
cin >> baldesB ;
cout << “ Ingrese cantidad de baldes tipo \“C\” a producir: ” ;
cin >> baldesC ;
// Tiempo en segundos que demora fabricar el total de baldes

// de cada tipo
tiempoA = baldesA * 15 ;
tiempoB = baldesB * 15 ;
tiempoC = baldesC * 62 ;
// Hallando la cantidad de horas minutos y segundos que demorará la

// fabricación de todos los baldes
tiempoTotal = tiempoA + tiempoB + tiempoC ;
horas = tiempoTotal / 3600;

minutos = tiempoTotal % 3600 / 60 ;
segundos = tiempoTotal % 3600 % 60 ;
cout << endl ;

cout << “ Cantidad de horas \t : ” << horas ;
cout << “ \n Cantidad de minutos \t : ” << minutos ;
cout << “ \n Cantidad de segundos \t : ” << segundos ;
getch ( ) ;
return 0 ;
}
Clase PrgBaldes
class PrgBaldes {
int baldesA, baldesB, baldesC ;

int tiempoA, tiempoB, tiempoC, tiempoTotal ;
System.out.print (“ Ingrese cantidad de baldes tipo\“A\” a producir: ” ) ;

baldesA = Lectura.leerInt ( ) ;
System.out.print (“ Ingrese cantidad de baldes tipo\“B\” a producir: ” ) ;
baldesB = Lectura.leerInt ( ) ;
System.out.print (“ Ingrese cantidad de baldes tipo\"C\" a producir: ” ) ;
baldesC = Lectura.leerInt ( ) ;
// Tiempo en segundos que demora fabricar el total de baldes

// de cada tipo
tiempoA = baldesA * 15 ;
tiempoB = baldesB * 15 ;
tiempoC = baldesC * 62 ;
// Hallando la cantidad de horas minutos y segundos que demorará la

// fabricación de todos los baldes
tiempoTotal = tiempoA + tiempoB + tiempoC ;
horas = tiempoTotal / 3600 ;

minutos = tiempoTotal % 3600 / 60 ;
segundos = tiempoTotal % 3600 % 60 ;
System.out.print ( ) ;
System.out.print ( “ Cantidad de horas \t : ” + horas ) ;
System.out.print ( “ \n Cantidad de minutos \t : ” + minutos ) ;
System.out.print ( “ \n Cantidad de segundos \t : ” + segundos ) ;
}
}
Problema 018
Enunciado: Una empresa encuestadora ha categorizado a los habitantes de una provincia en cuatro
categorías, tal como se muestra en el cuadro siguiente:
Cã¦ÊÙ° CÄã® ÖÙÝÊÄÝ ÖÊÙ ã¦ÊÙ°

A 30 % del total de personas
B 40 % de las personas de la categoría A
C 25 % de la suma de las personas de la categoría y la categoría B
D La cantidad restante de personas
Desarrolle una solución basada en una cantidad de personas, determine y muestre la cantidad de
personas por cada categoría y el porcentaje que representa cada una.


Algoritmo PrgCatPersonas – main ( )
INICIO
ENTERO personas
REAL numA, numB, numC, numD
REAL porA, porB, porC, porD
El símbolo que contiene una letra al final del diagrama, representa un conector de página y permite diseñar
un diagrama de flujo en varias páginas.
Algoritmo PrgCatPersonas – main ( )
personas
numA = personas * 0.30

numB = numA * 0.40
numC = ( numA + numB ) * 0.25
numD = personas - ( numA + numB + numC)
porA = numA / personas * 100

porB = numB / personas * 100
porC = numC / personas * 100
porD = numD / personas * 100
porA, porB, porC, porD
FIN
Clase PrgCatPersonas
#include <iostream>
int main ( ) {
int personas ;
double numA, numB, numC, numD ;
double porA, porB, porC, porD ;
cout << “ Ingrese la cantidad total de personas: ” ;

cin >> personas ;
numA = personas * 0.30 ;

numB = numA * 0.40 ;
numC = (numA + numB) * 0.25 ;
numD = personas - ( numA + numB + numC ) ;
porA = numA / personas * 100 ;

porB = numB / personas * 100 ;
porC = numC / personas * 100 ;
porD = numD / personas * 100 ;
cout << “ \n -----------------------” ;

cout << “ \n CATEGORÍA \t % ” ;
cout << “ \n -----------------------” ;
cout << “ \n A \t \t ” << porA << “ % ” ;
cout << “ \n B \t \t ” << porB << “ % ” ;
cout << “ \n C \t \t ” << porC << “ % ” ;
cout << “ \n D \t \t ” << porD << “ % ” ;
cout << “ \n -----------------------” << endl ;
return 0 ;
}
Problema 019
Enunciado: Calcule y visualice el perímetro y el área de un círculo. Ingrese el radio del círculo.
A. Resultado deseado: Mostrar el perímetro y el área de un círculo.

B. Datos necesarios: El radio del círculo y el valor 3.1416.
C. Procesamiento: El radio del círculo será ingresado por teclado y almacenado en una variable
(radio). También se utilizará una constante denominada pi cuyo valor
será pi = 3.1416. Luego, se realizarán los cálculos del perímetro y del
área. Los resultados se almacenarán en dos variables (perimetro y area
respectivamente) para luego ser mostradas por pantalla.


Algoritmo PrgDatosCirculo – main ( )
INICIO
NUMERO pi = 3.1416, radio, area, perimetro
radio
area = pi * radio * radio

perimetro = 2 * pi * radio
area, perimetro
FIN
Algoritmo PrgDatosCirculo – main ( )
# include <iostream>
#include <conio.h>
int main() {
const double pi = 3.1416 ;

double radio, area, perimetro ;
cout << “ Ingrese el radio de un círculo: ” ;

cin >> radio ;
area = pi * radio * radio ;
perimetro = 2 * pi * radio ;
cout << endl ;

cout << “ El área del círculo es: ” << area << endl ;
cout << “ El perímetro del círculo es: ” << perimetro << endl ;
getch ( ) ;
return 0 ;
}
Clase PrgDatosCirculo
class PrgDatosCirculo {
final double pi = 3.1416 ;

System.out.print ( “ Ingrese el radio de un círculo: ” ) ;

radio = Lectura.leerDouble ( ) ;
area = pi * radio * radio ;
perimetro = 2 * pi * radio ;
System.out.println ( “ El área del círculo es: ” + area ) ;
System.out.println ( “ El perímetro del círculo es: ” + perimetro ) ;
}
}
Problema 020
Enunciado: Calcule la nota final que ha obtenido un alumno en el curso de programación avanzada.
Utilice la siguiente fórmula: nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5. Ingrese las notas n1, n2, n3 y n4 a
través del teclado.
A. Resultado deseado: Mostrar la nota final de un determinado alumno.

B. Datos necesarios: Las notas del alumno (en esta caso tenemos cuatro notas).
C. Procesamiento: 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 nf
= ( n1 + n2 + n3 + ( n4 * 2) ) / 5. El resultado se almacenará en una variable
(nf) para luego ser mostradas por pantalla.


Algoritmo PrgNotaFinal – main ( )
INICIO
NUMERO n1, n2, n3, n4, nf
LEER n1, n2, n3, n4
nf = ( n1 + n2 + n3 + ( n4 * 2)) / 5
ESCRIBIR nf
FIN
En pseudocódigo:
ENTRADA: n1, n2, n3, n4

SALIDA: nf
INICIO
NUMERO n1, n2, n3, n4, nf

LEER n1, n2, n3, n4
nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5
ESCRIBIR nf
FIN
Clase PrgNotaFinal
#include <iostream>
#include <conio.h>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double n1, n2, n3, n4, nf ;
cout << “ Ingrese la nota 1 del alumno: ” ;

cin >> n1 ;
cin >> n2 ;
cin >> n3 ;
cin >> n4 ;
nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5 ;
cout << endl ;

cout << “ El promedio obtenido por el alumno es: ” ;
cout << nf << endl ;
getch ( ) ;
return 0 ;
}
class PrgNotaFinal {
System.out.print ( “ Ingrese la nota 1 del alumno: ” ) ;

n1 = Lectura.leerDouble ( ) ;
nf = ( n1 + n2 + n3 + ( n4 * 2) ) / 5 ;
System.out.print ( “ El promedio obtenido por el alumno es ” ) ;
System.out.println ( nf ) ;
}
}
Problema 021
Enunciado: Los empleados de una empresa ganan un sueldo neto que es igual al sueldo bruto
menos descuentos. Si se sabe que los descuentos constituyen el 12 % del sueldo bruto y que los
empleados cobran el 40 % del sueldo neto en la quincena y el resto a fin de mes. Desarrolle
una solución que permita calcular y mostrar lo siguiente: el descuento, el sueldo neto, el monto a
cobrar en quincena y el monto a cobrar a fin de mes.
A. Resultado deseado: Mostrar el monto de descuento, el sueldo neto, el monto a cobrar en

quincena y el monto a cobrar a fin de mes de un obrero de la empresa.
B. Datos necesarios: El sueldo bruto del obrero.
C. Procesamiento: El sueldo bruto será ingresado y almacenado en una variable (sBruto). Luego
se realizará el cálculo del descuento (sBruto * 0.12) y del sueldo neto
(sBruto – descuento) que se almacenarán en las variables (descuento y
sNeto). Luego se hallará el monto a cobrar en quincena (nNeto * 0.4) y el
monto a cobrar a fin de mes (mNeto * 0.6). Estos resultados se almacenarán
en variables (mQuincena, mFinMes respectivamente), para luego ser
mostradas por pantalla.


En pseudocódigo:
Algoritmo PrgSueldoObrero – main ( )
ENTRADA: sBruto
SALIDA: descuento, sNeto, mQuincena, mFinMes
INICIO
REAL sBruto, descuento, sNeto, mQuincena, mFinMes

LEER sBruto
COMENTARIO “Calculando el descuento (12%), el Sueldo neto,

el monto de pago en quincena y el monto de pago
a fin de mes “
descuento = sBruto * 0.12
sNeto = sBruto – descuento

mQuincena = mNeto * 0.4
mFinMes = mNeto * 0.6
ESCRIBIR descuento, sNeto, mQuincena, mFinMes
FIN
Algoritmo PrgSueldoObrero – main ( )
INICIO
Calculando el descuento
REAL sBruto, descuento, sNeto, (12 %),
mQuincena, mFinMes el sueldo neto, el monto
de pago en quincena y
el monto de pago a fin
de mes.
LEER sBruto
descuento = sBruto * 0.12

sNeto = sBruto – descuento
mQuincena = sNeto * 0.4
mFinMes = sNeto * 0.6
ESCRIBIR
descuento, sNeto,
mQuincena, mFinMes
FIN
Clase PrgSueldoObrero
#include <iostream>
#include <conio.h>
int main ( ) {
double sBruto, descuento, sNeto, mQuincena, mFinMes ;

cout << “ Ingrese el sueldo Bruto de un obrero: ” ;
cin >> sBruto ;
// Calculando el descuento ( 12% )

descuento = sBruto * 0.12 ;
// Calculando del sueldo Neto

sNeto = sBruto - descuento ;
// Calculando el pago en quincena y fin de mes

mQuincena = sNeto * 0.4 ;
mFinMes= sNeto * 0.6 ;
cout << endl ;

cout << “ El total de descuento es: ” << descuento << endl ;
cout << “ El sueldo Neto es: ” << sNeto << endl ;
cout << “ El monto a cobrar en quincena es: ” << mQuincena << endl ;
cout << “ El monto a cobrar en fin de mes es: ” << mFinMes << endl ;
getch ( ) ;
return 0 ;
}
Clase PrgSueldoObrero
class PrgSueldoObrero {
public static void main ( String arg [] ) {
double sBruto, descuento, sNeto, mQuincena, mFinMes ;

System.out.print ( “ Ingrese el sueldo Bruto de un obrero: ” ) ;
sBruto=Lectura.leerDouble() ;
// Calculando el descuento ( 12% )

descuento = sBruto * 0.12 ;
// Calculando del sueldo Neto

sNeto = sBruto - descuento ;
// Calculando el pago en quincena y fin de mes

mQuincena = sNeto * 0.4;
mFinMes= sNeto * 0.6;
System.out.println ( “ El total de descuento es: ” + descuento) ;
System.out.println ( “ El sueldo Neto es: ” + sNeto) ;
System.out.println ( “ El monto a cobrar en quincena es: ” + mQuincena) ;
System.out.println ( “ El monto a cobrar en fin de mes es: ” + mFinMes) ;
}
}
IMPORTANTE
Se recomienda solucionar los problemas propuestos del 16 al

60, planteados al final del presente capítulo.
PUNTO APARTE
2.10 DESARROLLO DE APLICACIONES JAVA, UTILIZANDO JAVA DEVELOPMENT KIT (JDK )

Antes de desarrollar una aplicación en Java, deberá asegurarse de tener instalado en su computadora el
JDK ("Java Development Kit", es decir Kit de desarrollo de Java). El JDK es un conjunto de herramientas,
utilidades, documentación y ejemplos para desarrollar aplicaciones Java. El JDK puede obtenerlo de
las páginas de Sun (h p://java.sun.com), y existen versiones disponibles para varias plataformas. La
instalación será distinta para cada sistema operativo, pero en general muy sencilla. Se recomienda
observar y establecer los valores de las variables de entorno PATH (variable de entorno que indica
desde qué ruta, además del directorio actual, se pueden ejecutar los programas) y CLASSPATH (indica
al compilador Java en qué rutas se encuentran los ficheros de clase).
Una vez instalado el JDK y establecidos los valores de las variables de entorno mencionadas, deberá
desarrollar sus aplicaciones siguiendo las siguientes etapas:
2.10.1 Edición
Esta etapa se refiere a la codificación de la solución en Java. La codificación se puede realizar en

cualquier procesador de texto (ejemplo un block de notas). Finalizada la codificación de la solución
deberá guardar el archivo con el mismo nombre que tiene la clase y con la extensión “Java”. A este
archivo generado se le denomina archivo fuente.
Observe el uso del block de notas de MS-Windows para la edición o codificación de la solución del
segundo problema planteado en el presente texto. Como ejemplo, este archivo será grabado con el
nombre “PrgMensaje2.java” en la carpeta “C:\aplicaciones\dominioDeLaAplicacion”.
2.10.2 Compilación
Etapa en la que se genera un archivo class (archivo de código de bytes) en base a un archivo fuente.
La compilación se realiza utilizando un programa denominado javac.exe. almacenado en la carpeta
bin de la carpeta donde se instaló el JDK.
2.10.3 Ejecución
Se ejecuta el archivo class generado en la etapa de compilación. Este archivo class es ejecutado
por la Máquina Virtual de Java (JVM por sus siglas en ingles). Es importante indicar que existe una
JVM por cada plataforma, y todas las JVM pueden ejecutar el archivo class generado. La ejecución
se puede realizar utilizando el programa denominado java.exe o el programa llamado javaw.exe,
ambos almacenados en la carpeta bin de la carpeta donde se instaló el JDK. (Uno se utiliza para
aplicaciones basadas en consola y el otro para aplicaciones basadas en ventanas).
Resulta muy conveniente escribir un archivo por lotes, llamado también archivo de comando o archivo
de batería, que permita compilar y ejecutar un determinado archivo fuente.
Observe la creación de un archivo por lotes en la plataforma MS-Windows y como se utilizan los
programas javac.exe y java.exe para compilar y ejecutar el archivo “PrgMensaje2.java” almacenado
en la carpeta “C:\aplicaciones\dominioDeLaAplicacion” en la etapa de EDICIÓN. Como ejemplo, el
archivo por lotes será grabado con el nombre “PrgMensaje2.bat” en la carpeta “C:\aplicaciones”.
Al ejecutar el archivo por lotes de MS-Windows (se ejecuta haciendo doble clic sobre el archivo), se
crea el archivo class en la carpeta “C:\aplicaciones\dominioDeLaAplicacion” y se ejecuta la aplicación.
Para una correcta ejecución de la aplicación, recuerde que deberá observar y establecer los valores de
las variables de entorno PATH y CLASSPATH. En MS-Windows, dichos valores se establecen en el PANEL
DE CONTROL en la utilidad SISTEMA. Ahí deberá seleccionar Opciones avanzadas y luego Variables de
entorno.
Es imprescindible que verifique por lo menos la variable PATH. En dicha variable se habrá especificado
la ruta donde se encuentran los archivos ejecutables de Java. Dichos archivos se encuentran en la
carpeta bin, dentro de la carpeta donde instaló el JDK. Por ejemplo, para la ejecución de la aplicación
anterior se instaló el JDK en la carpeta “C:\jdk1.5.0_06”. Esto significa que se deberá verificar si la ruta
“C:\jdk1.5.0_06\bin” está establecida en la variable PATH. Si no está establecida se deberá modificar la
variable PATH y agregar dicha ruta al final de las rutas ya establecidas, anteponiendo un punto y coma,
tal y como se muestra en el siguiente gráfico:
Finalizado el establecimiento de dicha ruta podrá utilizar los programas javac.exe, java.exe, javaw.exe
o cualquier otro programa del JDK desde cualquier carpeta.
2.11 SOLUCIONES UTILIZANDO CUADROS DE DIÁLOGO
2.11.1 Uso de la clase LE codificada en Java
Para ingresar datos y mostrar información en Java, también puede utilizar la clase LE. Esta clase,
a diferencia de la System y la de Lectura, permite ingresar datos y mostrar información utilizando
cuadros de diálogo. A continuación se explican los métodos básicos definidos en la clase LE:
CLASE MÉTODO DESCRIPCIÓN
leerString (String) Permite ingresar una cadena de texto.
leerChar (String) Permite ingresar un caracter (una sola letra o número).
leerInt (String) Permite ingresar un número entero.
leerLong (String) Permite ingresar un número entero largo.
Permite ingresar un número con parte decimal de

leerFloat (String)
LE.class simple precisión.
Permite ingresar un número con parte decimal de

leerDouble (String)
doble precisión.
mostrarResultado (String) Permite mostrar un determinado resultado.
mostrarInformacion (String) Permite mostrar una determinada información.
mostrarError (String) Permite mostrar un determinado error.

2.11.2 Método de las 6´D - Uso de cuadros de diálogo
A continuación se definen formalmente los pasos del Método de las 6’D para el desarrollo de
ENUNCIADO
DEL
PROBLEMA
}|Determinar la }|Determinar el nombre }|Codificar el diseño
información deseada del proyecto. de la solución del
(salida). }|Definir los paquetes problema. Utilizar
}|Determinar los y desarrollar el el lenguaje de
datos de entrada diagrama de paquetes programación Java.
(entrada). respectivo. Establecer UƟlice la clase
}|Establecer como la dependencia. Utilice reuƟlizable LE.
se solucionará el UML.
problema (proceso). }|Definir las clases que
serán parte de la
Utilice UML.
ALGORITMO
para el método principal.
UƟlizar diagrama de
acƟvidades.
Problema 022
Enunciado: En base al enunciado del problema N⁰ 6, se desea mostrar el mensaje “Feliz Navidad”
y el mensaje “Prospero año nuevo”. Desarrolle el modelamiento y la codificación en el lenguaje de
programación Java. Utilice la clase LE para mostrar información.
1. Nombre del proyecto: ProySaludo

Paquete
Clases de dominioDeLaAplicacion
LE
(from biblioteca)
||leerString ( )
||leerChar ( )
PrgSaludo ||leerInt ( )
||leerLong ( )
||main ( )
||leerFloat ( )
||leerDouble( )
||mostrarResultado ( )
||mostrarInformacion ( )
||mostrarError ( )

En diagrama de actividad:
msjNavidad
INICIO
y msjNuevo son
variables
Almacenar los mensajes “Feliz Navidad”

y “Próspero año nuevo” en msjNavidad y
msjNuevo
Mostrar msjNavidad
y msjNuevo
FIN
Observe el uso de lenguaje natural en la expresión contenida en cada estado de acción.
Clase PrgSaludo
import biblioteca.LE ;
class PrgSaludo {
String msjNavidad, msjNuevo = “ Próspero año nuevo ” ;

msjNavidad = “ Feliz Navidad ” ;
LE.mostrarResultado ( msjNavidad + “ y ” + msjNuevo ) ;

}
}
Resultado:
Problema 023
Enunciado: En base al enunciado del problema N⁰ 8, ingrese el nombre y la edad de una persona
y luego muéstrelos por pantalla. Desarrolle el modelamiento y la codificación en el lenguaje de
programación Java. Utilice la clase LE para ingresar datos y mostrar información.
1. Nombre del proyecto: ProyEdad

Paquete
LE
(from biblioteca)
||leerString ()
PrgEdad
||leerChar ()
||main () ||leerInt ()
||leerLong ()
||leerFloat ()
||leerDouble ()
||mostrarResultado ()
||mostrarInformacion ()
||mostrarError ()
…

Algoritmo PrgEdad – main ( )
INICIO
LEER nombre, edad
ESCRIBIR nombre,
edad
FIN
Observe el uso de pseudocódigo en la expresión contenida en cada estado de acción.
Clase PrgEdad
class PrgEdad {
String nombre ;
int edad ;
nombre = LE.leerString ( “ Ingrese el nombre de una persona ” ) ;

edad = LE. leerInt ( “ Ingrese su edad ” ) ;
LE.mostrarInformacion ( “ El nombre es ” + nombre + “ y su edad es ”

+ edad ) ;
}
}
Resultado:
La clase LE facilita el ingreso de datos y permite mostrar información utilizando cuadros de diálogo. La
codificación de la clase LE podrá encontrarla en el apéndice. Observe que la clase LE utiliza la clase
JOpƟonPane que se encuentra en el paquete javax.swing, del lenguaje de programación Java.
Para ingresar datos se utilizan los métodos leerChar( ), leerDouble( ), leerFloat( ), leerInt( ),
leerLong( ) y leerString( ) de la clase LE. Dependiendo el tipo de dato que desee ingresar deberá
utilizar el método correspondiente. El método leerClave( ) permite ingresar datos sin que estos se
visualicen, en lugar de visualizar los datos ingresados se visualizan asteriscos.
El método mostrarInformacion( ) de la clase LE permite mostrar información en un cuadro de

diálogo con un título y un ícono determinado. Existe también otro método mostrarInformacion( )
de la clase LE que será utilizado en el capítulo IV.
|En la solución del problema 022 se uƟlizó otro método de la clase LE que permite mostrar
información denominado mostrarResultado( ). Este método no muestra un ícono determinado.
Problema 024
Enunciado: Ingrese el precio de un artículo y su respectivo descuento (expresado en %) y muestre

el precio total a pagar incluyendo el I.G.V. (Impuesto General a las Ventas = 19 %). Desarrolle la
codificación en el lenguaje de programación Java y utilice la clase LE para ingresar datos y mostrar
información.
Clase PrgArƟculo2
class PrgArticulo2 {
double precio, descuento, precioTotal ;
precio = LE.leerDouble ( “ Ingrese el precio del artículo ” ) ;

descuento = LE.leerDouble ( “ Ingrese descuento en % ” ) ;
precioTotal = ( precio – ( precio * descuento) / 100 ) * 1.19 ;
LE.mostrarInformacion ( “ El precio a pagar es ” + precioTotal ) ;

}
}
Resultado:
Problema 025
Enunciado: Calcule y visualice el área de un triángulo rectángulo e ingrese la base y la altura.
Desarrolle la codificación en el lenguaje de programación Java, utilizando la clase LE para ingresar

datos y mostrar información.
Clase PrgAreaTriangulo
class PrgAreaTriangulo {
double altura, base, area ;
altura = LE.leerDouble( “ Ingrese la altura de un triángulo ” ) ;

base = LE.leerDouble( “ Ingrese la base de un triángulo ” ) ;
area = ( base * altura) / 2 ;
LE.mostrarResultado ( “ El área del triángulo es ” + area ) ;

}
}
Resultado:
IMPORTANTE
Se recomienda solucionar todos los problemas propuestos planteados

al final del presente capítulo, uƟlizando la clase reuƟlizable LE.
PROBLEMAS PROPUESTOS
1. Desarrollar una solución que permita mostrar el mensaje “Hola, FIA”.

2. Desarrollar una solución que permita mostrar el mensaje “Hola, me llamo Rodrigo José, mi código
es 20070728, y mi nota es 19”.
3. Desarrollar una solución que permita mostrar dos mensajes, el primero “Mis notas en el curso
de Algoritmo son: 15, 16, 17, 18”; y el segundo mensaje “Mi promedio final es 17”. Mostrar los
mensajes en diferentes líneas.
4. Desarrollar una solución que permita mostrar los mensajes “Feliz cumpleaños”, “Hoy será un
buen día” y “Felices Fiestas Patrias”. Utilice las constantes de carácter de barra invertida “\n” y
“\t” de los lenguajes de programación para mejorar la forma como se muestra la información.
5. Desarrollar una solución que permita mostrar el mensaje “No a las drogas”. Intente mostrar el
mensaje en forma creativa.
6. Desarrollar una solución que permita ingresar su nombre, apellido, edad y sexo. Mostrar los datos
ingresados en una sola línea.
7. Desarrollar una solución que permita ingresar el precio de un artículo. Mostrar el precio del
artículo junto con el mensaje “Cocina en oferta”.
8. Desarrollar una solución que permita ingresar el nombre de un artículo. Mostrar el nombre del
artículo junto con el mensaje “Cómpralo en la tienda del tío Tony”.
9. Desarrollar una solución que permita ingresar el nombre y la nota de dos alumnos. Mostrar los
datos en diferentes líneas. Adicionalmente, mostrar en la tercera línea el mensaje “El que estudia
triunfa”.
10. Desarrollar una solución que permita ingresar el día, mes y año actual. Mostrar los datos separados
por el símbolo “/”.
11. Desarrollar una solución que permita ingresar cuatro números. Mostrar la suma y multiplicación
de dichos números.
12. Desarrollar una solución que permita ingresar un número de horas. Mostrar su equivalente en
minutos y segundos en diferentes líneas.
13. Desarrollar una solución que permita ingresar el precio de un artículo y su respectivo incrementado
por inflación. Mostrar el precio total a pagar incluyendo el I.G.V. (19 % Impuesto General a las
Ventas).
14. Desarrollar una solución que permita ingresar el nombre y el código de un alumno, así como
también el nombre de uno de sus cursos y sus tres notas. Calcular el promedio de notas del
alumno utilizando la fórmula siguiente: (n1 + n2 + n3*2)/4. Mostrar el nombre y el código del
alumno en una línea, y el nombre y promedio del curso en la siguiente línea.
15. Desarrollar una solución que permita calcular y mostrar el promedio final de un curso, en base a
la siguiente fórmula:
PF = (PP + EP + 2*EF)/4
PP: Promedio de prácticas (n1 + n2 + n3)/3
EP: Examen Parcial
EF: Examen Final
16. Desarrollar una solución que permita ingresar la suma y diferencia de dos números enteros, y en
base a estas cantidades calcular y mostrar los números.
17. Desarrollar una solución que permita ingresar la velocidad promedio y el tiempo total que demoró
en llegar a la meta el campeón del rally “El poderoso”. Calcular y mostrar la distancia recorrida.
18. Desarrollar una solución que permita ingresar 5 números enteros positivo. Mostrar la media
aritmética y la media armónica de dichos números.
19. Desarrollar una solución que permita ingresar la masa y la aceleración de un objeto. Calcular la
fuerza y mostrar el equivalente en Newton (N), Dina (Dn) y kilogramos fuerza (kgf).
1 N = 1 kg m/s2
1 Dn = 1 g cm/s2
1 kgf = 9.8 kg m/s2
20. Desarrollar una solución que permita ingresar la base mayor, la base menor y la altura de un
trapecio. Calcular y mostrar su área.
21. Desarrollar una solución que permitan mostrar dos mensajes separados por dos líneas. El 1er
mensaje será: “Universidad San Martín de Porres”, y el 2do mensaje: “Facultad de Ingeniería y
Arquitectura”.
22. Desarrollar una solución que permita ingresar una cantidad entera de dinero. Mostrar el menor
número posible de billetes de S/. 200, S/. 100, S/. 50, S/. 20 y S/. 10 que existen en la cantidad de
dinero ingresada.
23. Desarrollar una solución que permita ingresar tu nombre. Mostrar el mensaje: “Hola, me llamo”,
seguido de un espacio en blanco y el nombre ingresado.
24. Desarrollar una solución que permita obtener el promedio ponderado de un alumno del 3er
ciclo de estudios. El promedio se calcula con la sumatoria de los promedios finales de cada curso
multiplicado cada uno por sus respectivos números de créditos, entre la sumatoria de números
de créditos. Los promedios finales serán ingresados por teclado, tener en cuenta la siguiente
información:
Curso Créditos
AED I 5
Fund. de Diseño Web 3
Cálculo II 5
Física I 5
Estadística I 4
Teoría Económica 3
Mostrar el promedio ponderado.
25. Desarrollar una solución que permita ingresar la hora de entrada y la hora de salida de un obrero
en un día de trabajo (en minutos), y en base a esta información calcular y mostrar el tiempo que
permaneció en la empresa (en horas y minutos), y el sueldo en soles que ganará ese dia, si por
hora le pagan $ 6. Considere: tipo de cambio = 3.10 nuevos soles.
26. Desarrollar una solución que permita calcular y mostrar la potencia 4 de un número ingresado
por teclado.
27. Desarrollar una solución que permita ingresar la temperatura en Celsius. Mostrar su equivalente
en grados Fahrenheit y en Kelvin. Considere:
F = (9/5) * C + 32
K = C + 273
28. Desarrollar una solución que permita calcular y mostrar el promedio ponderado que un alumno
ha obtenido en base a sus cuatro notas y al peso asignado a cada una de ellas.
29. Desarrollar una solución que permita calcular la velocidad final de un automóvil que parte del
reposo y que se mueve con aceleración constante durante siete segundos. Ingresar el valor de la
aceleración y mostrar la velocidad final del automóvil después de transcurridos los 7 segundos.
Considere: Vf = Vo + a * t.
30. Desarrollar una solución que permita ingresar el radio y la altura de un cilindro. Calcular y mostrar
el volumen del cilindro. Considere: v = [3.1416 * (radio**2)] * altura.
31. Desarrollar una solución que permita determinar la suma de los primeros “n” números enteros
consecutivos, utilizando la siguiente fórmula: n * (n + 1) / 2.
32. Desarrollar una solución que permita mostrar el tiempo (en segundos) que demora en caer una
pelota luego de ser lanzada hacia arriba desde el suelo (despreciar unidades).
Considere: tiempo de vuelo = (2*Velocidad Inicial) / g.
Donde: g = 9,8 m/s2.
33. Desarrollar una solución que permita mostrar las dimensiones reales de un terreno a partir de un
mapa de escala 1:100000. Ingresar la representación en el mapa en centímetros (cm). Considere:
t = 100000 * cm.
34. Desarrollar una solución que permita ingresar varios números enteros. Calcular la sumatoria de
los cubos de los números ingresados. Considere: [n*(n + 1) / 2] ** 2.
35. Desarrollar una solución que permita mostrar el precio real de un artículo, teniendo en cuenta
que al ingresar el precio del artículo no se incluye el I.G.V. (el I.G.V. es equivalente al 19% del precio
del artículo).
36. Desarrollar una solución que permita leer el costo de un artículo y su precio de venta. Calcular y
mostrar su utilidad.
37. Desarrollar una solución que permita convertir y mostrar una cantidad de soles a dólares y a
euros. Considerar como tipo de cambio; 1 dólar = 3.00 soles, y 1 euro = 1.4 dólares.
38. Desarrollar una solución que permita convertir una cantidad expresada en metros a sus
equivalentes en centímetros, pulgadas, pies y yardas. Considerar la siguiente información:
}|1 metro = 100 cm
}|1 pulgada = 2.54 cm
}|1 pie = 12 pulgadas
}|1 yarda = 3 pies
39. Desarrollar una solución que permita leer la capacidad de un disco duro en Gigabytes. Mostrar el
equivalente en Megabytes, Kilobytes y Bytes.
}|1 Kilobyte = 1024 Bytes
}|1 Megabyte = 1024 Kilobytes
}|1 Gigabyte = 1024 Megabytes
40. Desarrollar una solución que permita calcular el porcentaje de hombres y el porcentaje de
mujeres que están matriculados en un determinado curso.
41. Desarrollar una solución que permita determinar la cantidad total de metros2 que tiene un
terreno, en base a sus medidas parciales en pulgadas2, pies2, yardas2 y metros2. Considere las
siguientes equivalencias:
1 metro2 = 1549.99 pulgadas2 = 10.76 pies2 = 1.20 yardas2.
42. Un contratista desea determinar cuánto gastará en pagar la mano de obra por la construcción de
un edificio, conociendo la tarifa por hora de sus trabajadores, la cantidad de minutos trabajados
por cada uno ellos y el monto que se pagará por hora trabajada.
Tipo trabajador Tarifa por hora
A S/. 50
B S/. 25
C S/. 20
D S/. 10
43. Una compañía telefónica desea que se desarrolle una solución que permita determinar cuánto
le debe cobrar a sus usuarios por llamada, conociendo la hora de inicio y fin de las mismas.
Asimismo, considerar que la hora o fracción cuesta S/. 1.00 y existe un costo por establecimiento
de llamada de S/. 0.50.
44. Desarrollar una solución que permita calcular y visualizar el número de segundos que hay en un
determinado número de días.
45. Desarrollar una solución que permita ingresar un número de cuatro cifras. Determinar la suma de
las cifras del número ingresado.
46. Desarrollar una solución que permita determinar la velocidad inicial con que partió un automóvil
de un determinado punto y cuál fue la distancia que recorrió, conociendo su velocidad final, su
aceleración y el tiempo empleado en el recorrido. Considerar las siguientes fórmulas:
e = Vo + at2
Vf = Vo + at
donde:
Vo = Velocidad Inicial
Vf = Velocidad Final
a = Aceleración
e = Espacio recorrido
47. Desarrollar una solución que permita realizar el cálculo del pago mensual del sueldo de un
empleado de una empresa. Dicho cálculo se realiza de la siguiente manera: el sueldo básico se
calcula en base al número total de horas trabajadas, basado en una tarifa horaria. Al sueldo
básico se le aplica una bonificación del 35 % obteniéndose el sueldo bruto. Al sueldo básico se
le aplica un descuento del 12 % obteniéndose el sueldo neto. Mostrar el sueldo básico, el sueldo
bruto y el sueldo neto de un trabajador.
48. Desarrollar una solución que permita calcular y visualizar el perímetro y el área de un rectángulo.
Ingresar la base y la altura del rectángulo. Considerar: area = base * altura, y perímetro = 2 * (base
+ altura).
49. Desarrollar una solución que permita ingresar el sueldo de un obrero. Calcular el aumento de
sueldo del obrero por concepto de escolaridad (17 %). Mostrar el sueldo a cobrar.
50. Desarrollar una solución que permita ingresar el sueldo de un obrero de la empresa “El Gran
Chaparral S. A.”. Calcular su respectivo descuento del 14 % por concepto de impuestos y el 3 %
por concepto de cafetería. Mostrar el total de descuentos y el sueldo a cobrar.
51. Desarrollar una solución que permita invertir un número de cuatro dígitos. El número deberá ser
ingresado por teclado. Ejemplo: se ingresa el número 3579 se debe visualizar 9753.
52. Desarrollar una solución que permita calcular el sueldo neto de un vendedor. Dicho cálculo se
realiza en base a un sueldo básico equivalente a S/. 465.00 nuevos soles, más una comisión del
18 % por cada venta que el vendedor realice. Mostrar el sueldo neto del vendedor sabiendo que
hizo cinco ventas en el mes.
53. Desarrollar una solución que permita calcular el volumen de una esfera. Ingresar el radio.
Considerar: v = (4/3) * pi * radio ** 3.
54. Desarrollar una solucion que permita ingresar un número de tres cifras y permita mostrarlo con
sus cifras invertidas. Por ejemplo, si se ingresa 351 se debe visualizar 153.
55. Desarrollar una solución que permita ingresar un número de una cifra. Calcular su potencia 4.
Mostrar como resultado el número invertido.
56. Desarrollar una solución que permita ingresar un número de una cifra de tipo REAL. Calcular su
potencia 5. Mostrar como resultado la parte entera del número invertido.
57. Un padre desea hacer su testamento, en el desea repartir su fortuna entre sus cuatro hijos, y
desea hacerlo en forma proporcional a sus edades. Desarrolle una solución que determine el
monto que le toca a cada hijo
58. Desarrollar una solución que permita utilizar la ecuación de la energía, para poder calcular la
cantidad de energía que podría producir la materia con una masa determinada (en kg). Ingresar
la masa de la materia. Considerar:
E = m * C2
C = 300 000 km/s (velocidad de la luz)
59. Desarrollar una solución que permita calcular el error absoluto (EA) para cada una de las
observaciones siguientes:
Ni ai (cm)
1 7.13
2 7.16
3 7.09
4 7.02
Mostrar los resultados obtenidos.
60. Dos amigos desean juntar un capital para realizar una inversión; para ello, cada uno aporta un
cierto capital en soles, dólares y euros. Si la inversión requerida es de 3500 euros, desarrolle una
solución que permita mostrar el capital total aportado, y si el capital total aportado cubre o no el
monto de la inversión.
Considere: 1 dólar = 3.25 soles.
1 euro = 1.28 dólares.
CAP.
Estructuras lógicas de
decisión o selección
3
CAP. 3: ESTRUCTURAS LÓGICAS DE DECISIÓN O SELECCIÓN 145
Este capítulo explica las estructuras lógicas de decisión. Es importante mencionar que utilizando
las estructuras lógicas de decisió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.
Se emplearán las técnicas para el ingreso de datos y visualización de la información, utilizando la

consola de solo caracteres y la que emplea cuadros de diálogo.
ENUNCIADO MARCO DE TRABAJO

DEL
PROBLEMA
Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
Solución
ALGORITMO
PROGRAMACIÓN
PROYECTO MODELAMIENTO
CODIFICACIÓN
Nombre
Clase
Atributos
Método( ) ALGORITMO
Sentencias
Declaración y
Descripción definición de
de datos datos
- Estructuras lógicas de secuencia.
- Estructuras lógicas de decisión.
ALMACENANDO EN:
Estructuras de datos (Variable)
Se tratará además el diseño en algoritmos y su codificación en un lenguaje de programación. Es

importante indicar que el dominio de las estructuras lógicas de secuencia tratadas en el capítulo
anterior es trascendental para iniciar el estudio del presente capítulo.
En el desarrollo de las primeras treinta soluciones se puede apreciar el uso de las estructuras lógicas de
decisión simple, doble y múltiple; cómo se diseñan los algoritmos utilizando pseudocódigo y/o diagrama
de flujo, y cómo se codifican en el lenguaje de programación C++ y/o Java. Esto permite comprender
los aspectos fundamentales del desarrollo de soluciones utilizando este tipo de estructuras lógicas.
En el desarrollo de las siguientes cinco soluciones se diseñan algoritmos utilizando diagrama de

actividades y se codifican en el lenguaje de programación Java, utilizando para ello la clase reutilizable
LE. En esta parte se utilizan métodos complementarios de la clase LE que permiten plantear soluciones
mas vistosas aún y mucho más amigables para el usuario, utilizando cuadros de diálogo.
3.1 DESARROLLO DE SOLUCIONES CON UN PAQUETE

A continuación se definen formalmente los pasos del Método de las 6’D para el desarrollo de soluciones
utilizando dos paquetes.
ENUNCIADO DEL
PROBLEMA

Definición Diseño Derrollo
}|Determinar la }|Determinar
el nombre }|Codificar el diseño de la
información deseada del proyecto. solución del problema.
(salida). }|Definir los paquetes y Utilizar el lenguaje de
}|Determinar los datos de desarrollar el diagrama programación C++ o
entrada (entrada). de paquetes respectivo Java.
}|Establecer como se }|Establecer la
solucionará el problema dependencia. Utilice
(proceso). UML.
}|Definir las clases que
serán parte de la
Utilice UML.
ALGORITMO
para el método
principal. Utilizar
pseudocódigo o
diagrama de flujo.
De manera general, la Etapa 03 - “Diseño de la Solución” se divide en dos partes: modelamiento (paso
1, 2 y 3) y algoritmo (paso 4); por otro lado, la Etapa 04 - “Desarrollo de la solución” contiene la parte de
3.2 ESTRUCTURAS LÓGICAS DE DECISIÓN
3.2.1 Definición
Son construcciones que permiten alterar el flujo secuencial de una solución, de manera 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
lógicas de selección.
}|Mapa de estructuras lógicas de decisión

Utilizando las estructuras lógicas de decisión se pueden desarrollar algoritmos medianamente
complejos, de manera que puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego
ser codificados en un lenguaje de programación.
Estructuras lógicas de decisión
Estructura lógica de Estructura lógica de Estructura lógica de

decisión simple decisión doble decisión múltiple
“SI” “SI / SINO” “CUANDO”

“SI ANIDADOS”
}|Mapa de estructuras lógicas detallado

“LEER” “SI” “DESDE” “TERMINAR”
“ESCRIBIR” “SI / SINO” “MIENTRAS” “CONTINUAR”
“PROCESAR” “CUANDO” “HACER” “RETORNAR”

"SI ANIDADOS"
3.2.2 Estructura lógica de decisión simple
A. Definición: Una estructura de decisión simple “SI... FINSI”, permite alterar el flujo secuencial o los
pasos secuenciales de una solución, ejecutando un conjunto de pasos adicionales si el resultado de
una condición lógica es verdadero.
Este tipo de estructura es útil cuando se tiene la posibilidad de decidir si se ejecuta una determinada
opción o no.
B. Representación
a. Formato para diseñar algoritmos
En pseudocódigo:
Explicación:
SI (condición) ENTONCES Si la condición resulta verdadera, se ejecutan las

… instrucciones que se encuentran entre las reglas SI…
instrucciones ENTONCES y FINSI.
…
FINSI Si la condición resulta falsa, no se ejecutan las
instrucciones que se encuentran entre las reglas SI…
ENTONCES y FINSI.
VERDADERO
condición
...
FALSO instrucciones
...
F®¦. 3.1
FALSO
condición
VERDADERO
VER
...
instrucciones
...
F®¦. 3.2
VERDADERO
condición instrucciones
FALSO
F®¦. 3.3
||Explicación:
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 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”.
Observe las figuras anteriores. Estas representan una estructura de decisión simple en diagrama
de flujo, donde el rombo indica el inicio de la estructura y el círculo indica el final. El rombo permite
evaluar una condición lógica; si el resultado de dicha evaluación es verdadero se ejecuta una o
varias instrucciones; en el caso que se ejecute una o dos instrucciones se puede utilizar el diagrama
de flujo de la figura 3.3, y si se necesitan ejecutar varias instrucciones será preferible utilizar los
diagramas de flujo de la figura 3.1 o de la figura 3.2. Cualquiera sea su elección, recuerde elaborar
un diagrama de flujo con estética y simetría.
Existe también la posibilidad de obviar el círculo de cierre de la estructura de decisión simple,

como se muestra en las siguientes figuras.
VERDADERO
condición
...
FALSO instrucciones
...
F®¦. 3.4
FALSO
condición
VERDADERO
VER
...
instrucciones
...
F®¦. 3.5
VERDADERO
FALSO
F®¦. 3.6
Recuerde que los diagramas de flujo deben elaborarse de izquierda a derecha, y preferentemente
de arriba hacia abajo. En este libro se utilizará el diagrama de flujo mostrado en la figura 3.1 o en
la figura 3.2, para elaborar estructuras lógicas de decisión simple.
b. Formato para codificar algoritmos

En lenguaje de programación C++ y Java:
Explicación:
if (condición) {
Si la condición resulta verdadera, se ejecutan las
…
sentencias que se encuentra entre las llaves { }.
sentencias
…
Si la condición resulta falsa, no se ejecutan las sentencias
}
que se encuentran entre las llaves { }.
Problema 026
Enunciado: Ingresar el lado de un cuadrado. Calcular y mostrar su área. Si el área del cuadrado
resulta menor que 100, se deberá visualizar el mensaje “Cuadrado pequeño”.
A. Resultado deseado: Mostrar el área de un cuadrado y un mensaje.

B. Datos necesarios: El lado del cuadrado.
C. Procesamiento: El lado del cuadrado será almacenado en una variable (lado); luego se
realizará el cálculo del área uƟlizando la siguiente fórmula:
area = lado * lado
El resultado será almacenado en una variable (area). Si el área resulta menor

que 100, entonces se almacenará el mensaje “Cuadrado pequeño” en una
variable (mensaje). Finalmente, se mostrará el área y el mensaje.
1. Nombre del proyecto: ProyAreaCuadrado

Clases de dominioDeLaAplicación Clase de biblioteca
Lectura
|leerString ( )
PrgAreaCuadrado
|leerChar ( )
|leerInt ( )
|main ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgAreaCuadrado – main ( )
ENTRADA: lado
SALIDA: area, mensaje
INICIO
NUMERO lado, area
TEXTO mensaje = “ ”
LEER lado
area = lado * lado
SI (area < 100 ) ENTONCES

mensaje = “Cuadrado pequeño”
FINSI
ESCRIBIR area, mensaje
FIN
Algoritmo PrgAreaCuadrado – main ( )
INICIO
REAL lado, area

lado
area = lado * lado
VERDADERO
area < 100
mensaje = “Cuadrado pequeño”

FALSO
area, mensaje
FIN

Clase PrgAreaCuadrado
#include <iostream>
#include <string>
int main ( ) {
int lado, area ;
string mensaje = “ ” ;
cout << “ Ingrese el lado del cuadrado: ” ;

cin >> lado ;
area = lado * lado ;

if (area < 100) {
mensaje = “ Cuadrado pequeño ” ;
}
cout << “ El área es: ” << area << “. ” << “\n” ;

cout << mensaje << ”\n\n” ;
return 0 ;
}
Clase PrgAreaCuadrado
class PrgAreaCuadrado {
int lado, area ;

String mensaje = “ ” ;
System.out.print ( “Ingrese el lado del cuadrado: ” ) ;
area = lado * lado ;

if (area < 100) {
mensaje = “ Cuadrado pequeño ” ;
}
System.out.println ( “ El área es: ” + area ) ;
System.out.println ( mensaje) ;
}
}
Problema 027
Enunciado: Ingresar el radio de un círculo. Calcular y mostrar el área y perímetro. Si el área del círculo
resulta mayor que 50, se deberá visualizar el mensaje “Círculo grande”.
A. Resultado deseado: Mostrar el área y perímetro del círculo.

B. Datos necesarios: El radio del círculo.
C. Procesamiento: El radio del círculo será almacenado en una variable (radio), luego se
realizará el cálculo del área y el perímetro uƟlizando las siguientes fórmulas:
area = radio * radio * 3.14

perimetro= 2 * 3.14 * radio
El resultado será almacenado en dos variables (area, perimetro). Si el área

resulta mayor que 50, entonces se almacenará el mensaje “Círculo grande”
en una variable (mensaje). Finalmente, se mostrarán el área, el perímetro
y el mensaje.
1. Nombre del proyecto: ProyAreaCirculo

Lectura
|leerString ()
PrgAreaCirculo
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgAreaCirculo – main ( )
ENTRADA: radio
SALIDA: area, perimetro, mensaje
INICIO
REAL radio, area, perimetro

LEER radio

perimetro = 2 * 3.14 * radio
SI ( area > 50 ) ENTONCES

mensaje = “Círculo grande”
FINSI
ESCRIBIR area, perimetro, mensaje
FIN
Algoritmo PrgAreaCirculo – main ( )
INICIO
REAL radio, area, perimetro

radio
perimetro =2 * 3.14 * radio
VERDADERO
area > 50
FALSO
mensaje = “Círculo grande”
area, perimetro,
mensaje
FIN

Clase PrgAreaCirculo
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
int main ( ) {
cout << “ Ingrese el radio del círculo: ” ;

cin >> radio ;
area = radio * radio * 3.14 ;
perimetro = 2 * 3.14 * radio ;
if ( area > 50 ) {
mensaje = “Círculo grande ” ;
}
cout << “ El área es: ” << area << “. ” << “\n” ;

cout << “ El perímetro es :” << perimetro << “\n” ;
cout << mensaje << “ \n\n ” ;
return 0 ;
}
Clase PrgAreaCirculo
class PrgAreaCirculo {
System.out.print ( “ Ingrese el radio del círculo: ” ) ;
radio = Lectura.leerInt ( ) ;
area = radio * radio * 3.14 ;

perimetro= 2 * 3.14 * radio ;
if ( area > 50 ) {
mensaje = “ Círculo grande ” ;
}
System.out.println ( “ El área es: ” + area) ;
System.out.println ( “ El perímetro es : ” + perimetro) ;
System.out.println ( mensaje + “ \n” ) ;
}
}
Problema 028

Enunciado: Calcular y mostrar la nota final obtenida por un alumno, sabiendo que se Ɵenen solo
dos notas. Si el alumno obƟene una nota final mayor a 13, se deberá visualizar un mensaje de
felicitaciones.

A. Resultado deseado: Mostrar nota final y mensaje.
B. Datos necesarios: Las dos notas del alumno.
C. Procesamiento: Las notas se ingresarán por el teclado y serán almacenadaen variables
(nota1 y nota2), luego se realizará el cálculo de la nota final uƟlizando la
fórmula siguiente:
nf = (nota1 + nota2) / 2
El resultado se almacenará en una variable (nf). Si la nota final resulta mayor que 13, se almacenará
el mensaje “Felicitaciones” en una variable (mensaje). Finalmente, se mostrará la nota final y el
mensaje.
Defina el nombre del proyecto, luego desarrolle la definición de paquetes, el diagrama de paquetes
y la definición de las clases.

En pseudocódigo:
ENTRADA: nota1, nota2

SALIDA: nf, mensaje
INICIO
REAL nota1, nota2, nf
LEER nota1, nota2

nf = ( nota + nota2 ) / 2
SI ( nf > 13 ) ENTONCES
mensaje = “Felicitaciones”
FINSI
ESCRIBIR nf, mensaje
FIN

Clase PrgNotaFinal
#include <iostream>
#include <string>
int main ( ) {
double nota1, nota2, nf ;
cout << “ Ingrese la primera nota : ” ;
cin >> nota1 ;
cout << “ Ingrese la segunda nota: ” ;
cin >> nota2 ;
nf = ( nota1 + nota2 ) / 2 ;
if ( nf > 13 ) {
mensaje = “ Felicitaciones ” ;
}
cout << “ La nota final es: ” << nf << “ \n” ;
cout << mensaje << “\n\n” ;
return 0 ;
}
Clase PrgNotaFinal
class PrgNotaFinal {
double nota1, nota2, nf ;

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 ) ;
System.out.println ( mensaje ) ;
}
}
Problema 029

Enunciado: Calcular el sueldo de un trabajador, conociendo el número de horas trabajadas y su tarifa
horaria. Se sabe que se debe descontar un 20 % del sueldo por concepto de impuestos, si este es
mayor de S/. 1600 nuevos soles. Mostrar el descuento y el sueldo respecƟvo.

A. Resultado deseado: Mostrar el sueldo y el descuento de un trabajador.
B. Datos necesarios: Total de horas trabajadas y tarifa horaria.
C. Procesamiento: 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, uƟlizando la operación sueldo = horas * tarifa. El resultado se
almacenará en una variable (sueldo). Si el sueldo resulta mayor que S/. 1
600 nuevos soles, se calculará y almacenará el descuento en una variable
(descuento), uƟlizando la operación descuento = sueldo * 0.2. Luego se
realizará el descuento; sueldo = sueldo – descuento. Finalmente, se mostrará
el sueldo a cobrar y el descuento.

En pseudocódigo:
Algoritmo PrgSueldo – main ( )
ENTRADA: horas, tarifa

SALIDA: sueldo, descuento
INICIO
ENTERO horas
REAL tarifa, sueldo, descuento = 0
LEER horas, tarifa

sueldo = horas * tarifa
SI ( sueldo > 1600 ) ENTONCES

descuento = sueldo * 0.2
sueldo = sueldo - descuento
FINSI
ESCRIBIR descuento, sueldo
FIN
INICIO
ENTERO horas , tarifa , sueldo ,

descuento = 0
horas , tarifa
VERDADERO
sueldo >
1600
FALSO
descuento = sueldo * 0.2
suedo = sueldo - descuento
descuento,
sueldo
FIN

Clase PrgSueldo
class PrgSueldo {
int horas ;
double tarifa, sueldo, descuento = 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 > 1600 ) {

descuento = sueldo * 0.2 ;
sueldo = sueldo - descuento ;
}
System.out.println ( “ El descuento es: ” + descuento ) ;

System.out.println ( “ El sueldo a cobrar es: ” + sueldo ) ;
}
}

Problema 030

Enunciado: Ingresar el precio de compra y venta de un determinado producto. También ingresar la
canƟdad de arơculos que una persona desea comprar de dicho producto; calcular y mostrar el monto
total a pagar por el comprador y la uƟlidad del vendedor, sabiendo que si se compran más de diez
arơculos se realiza un descuento del 2 %.

A. Resultado deseado: Mostrar el monto total a pagar y la uƟlidad del vendedor.
B. Datos necesarios: Precio de compra, precio de venta del arơculo, canƟdad de arơculos.
C. Procesamiento: El precio de compra, el precio de venta y la canƟdad de arơculos se ingresarán
por teclado y se almacenarán en variables (pC, pV y canƟdad); luego se
realizará el cálculo del monto total a pagar uƟlizando la operación total = pV
* canƟdad. El resultado se almacenará en una variable (total). Si la canƟdad
resulta mayor que diez, se calculará y almacenará el descuento en una
variable (descuento) uƟlizando la operación descuento = total * 0.2. Luego
se realizará el descuento total = total – descuento. Luego se procederá a
calcular la uƟlidad del vendedor uƟlizando la siguiente operación: uƟlidad =
total -(pC * canƟdad). El resultado se almacenará en una variable (uƟlidad).
Finalmente, se mostrará el monto total a pagar y la uƟlidad del vendedor.

En pseudocódigo:
Algoritmo PrgCompra – main ( )
ENTRADA: pV, pC, cantidad

SALIDA: total, utilidad
INICIO
ENTERO cantidad
REAL total , pV, pC , utilidad , descuento = 0
LEER pV , pC , cantidad
total = pV * cantidad
SI ( cantidad > 10 ) ENTONCES

descuento = total * 0.2
total = total - descuento
FINSI
utilidad = total - ( pC * cantidad )
ESCRIBIR total , utilidad
FIN
INICIO
ENTERO cantidad, pV, pC, utilidad,

descuento = 0
pV, pC ,
cantidad
total = pV * cantidad
VERDADERO
cantidad > 10
FALSO descuento = total * 0.2

El símbolo que contiene una letra al final del diagrama, representa un conector de página y permite diseñar
un diagrama de flujo en varias páginas.
utilidad = total - ( pC * cantidad )
total,
utilidad
FIN
Clase PrgCompra
class PrgCompra {
int cantidad ;
double total , pV , pC , utilidad , descuento = 0 ;
System.out.print ( “ Ingrese la cantidad de productos: ” ) ;
cantidad = Lectura.leerInt() ;
System.out.print ( “ Ingrese el precio de compra del producto: ” ) ;
pC = Lectura.leerDouble() ;
System.out.print ( “ Ingrese el precio de venta del producto: ” ) ;
pV = Lectura.leerDouble() ;
total = pV * cantidad ;
if ( cantidad > 10 ) {
descuento = total * 0.2 ;
total = total – descuento ;
}
utilidad = total - ( pC * cantidad ) ;
System.out.println ( “ El total a pagar es: ” + total ) ;
System.out.println ( “ La utilidad es: ” + utilidad ) ;
}
}
IMPORTANTE
planteados al final del presente capítulo.
3.2.3 Estructura lógica de decisión doble
A. 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 que dependen 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.
B. Representación:
En pseudocódigo:
EXPLICACIÓN:
… Si la condición resulta verdadera, se ejecutan las
instrucciones instrucciones que se encuentran entre las reglas SI…
… ENTONCES y SINO.
SINO
… Si la condición resulta falsa, se ejecutan las instrucciones
instrucciones que se encuentran entre las reglas SINO y FINSI.
…
FINSI Solo se ejecuta uno de los grupos de instrucciones; en
ningún caso se podrán ejecutar ambos grupos en una
misma ejecución o corrida del programa.
FALSO V
VERDADERO
condición
... ...
instrucciones instrucciones
... ...
F®¦. 3.7
VERDADERO
FALSO
LSO
...
instrucciones
...
F®¦. 3.8
VERDADERO
condición
FALSO
LSO
... ...
... ...
F®¦. 3.9
EXPLICACIÓN:
}|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”.
}|También se pueden elaborar los diagramas de flujo mostrados sin utilizar el círculo de cierre de la
estructura de decisión doble, tal como se muestra a continuación.
FALSO V
VERDADERO
condición
... ...
... ...
F®¦. 3.10
VERDADERO
FALSO
LSO
...
instrucciones
...
F®¦. 3.11
VERDADERO
condición
FALSO
LSO
... ...
... ...
F®¦. 3.12
En el presente libro se utilizará el diagrama de flujo mostrado en la figura 3.7 o en la figura 3.9 para
elaborar estructuras lógicas de decisión doble, y siempre se utilizará el círculo para mostrar de manera
más adecuada dónde finaliza la estructura lógica.
b. Formato para codificar algoritmos:
if (condición) { EXPLICACIÓN:
…
sentencias Si la condición resulta verdadera, se ejecutan las
… sentencias que se encuentran entre las llaves { }
} else { ubicadas después de la palabra reservada if.
…
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.
Problema 031
Enunciado: Ingresar la edad de una persona, si la edad es menor a dieciocho se deberá mostrar el
mensaje “Menor de edad”; caso contrario, se mostrará el mensaje “Mayor de edad”.
A. Resultado deseado: Mostrar un mensaje.

B. Datos necesarios: La edad de la persona.
C. Procesamiento: La edad de la persona será almacenada en una variable (edad). Si la edad es
menor que dieciocho el mensaje será:
mensaje = “Menor de edad”.
Caso contrario el mensaje será:
mensaje = “Mayor de edad”.
El resultado será almacenado en una variable (mensaje). Finalmente, se

mostrará el mensaje.
1. Nombre del proyecto: ProyMensajeEdad

Lectura
|leerString ()
PrgMensajeEdad
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgMensajeEdad – main ( )
ENTRADA: edad
SALIDA: mensaje
INICIO
ENTERO edad
TEXTO mensaje
LEER edad
SI ( edad < 18 ) ENTONCES
mensaje = “Menor de edad”
SINO
mensaje = “Mayor de edad”
FINSI
ESCRIBIR mensaje
FIN
Algoritmo PrgMensajeEdad – main ( )
INICIO
ENTERO edad
TEXTO mensaje
Edad
FALSO VERDADERO
edad < 18
mensaje = “Mayor de edad” mensaje = “Menor de edad”
mensaje
FIN
Clase PrgMensajeEdad
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
int main ( ) {
int edad ;
string mensaje ;
cout << “ Ingrese la edad de la persona: ” ;

cin >> edad ;
if ( edad < 18 ) {
mensaje = “ Menor de edad ” ;
} else {
mensaje = “ Mayor de edad ” ;
}
cout << mensaje ;

cout << “ \n\n” ;
system ( “ PAUSE ” ) ;
return 0
}

Clase PrgMensajeEdad
class PrgMensajeEdad {
int edad ;
String mensaje ;
System.out.print ( “ Ingrese la edad de la persona: ” ) ;

edad = Lectura.leerInt ( ) ;
if ( edad < 18 ) {
mensaje = “ Menor de edad ” ;
} else {
mensaje = “ Mayor de edad ” ;
}
}
}
Problema 032
Enunciado: Calcular y mostrar la nota final de un alumno en base a tres notas ingresadas. Si la nota
final es menor a catorce se deberá mostrar el mensaje “Desaprobado”; caso contrario, se mostrará el
mensaje “Aprobado”. Considerar: nf = (n1 + n2 + n3) / 3.
A. Resultado deseado: Mostrar nota final y mensaje.

B. Datos necesarios: Las tres notas del alumno.
C. Procesamiento: Las notas serán ingresadas y almacenadas en variables (n1, n2 y n3), luego
se realizará el cálculo de la nota final:
nf = (n1 + n2 + n3) / 3.
El resultado se almacenará en una variable (nf). Si la nota final resulta menor que 14 entonces se
almacenará en una variable (mensaje) el mensaje “Desaprobado”; caso contrario, se almacenará el
mensaje “Aprobado”. Finalmente, se mostrará la nota y el mensaje
1. Nombre del proyecto: ProyNotaFinal2

Lectura
|leerString ()
PrgNotaFinal2 |leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgNotaFinal2 – main ( )
ENTRADA: n1, n2, n3

SALIDA: nf, mensaje
INICIO
REAL n1, n2, n3, nf
TEXTO mensaje
LEER n1, n2, n3
nf = (n1 + n2 + n3) / 3
SI ( nf < 14 ) ENTONCES
mensaje = “Desaprobado”
SINO
mensaje = “Aprobado”
FINSI
FIN
INICIO
NUMERO n1, n2, n3, nf , TEXTO mensaje
n1, n2, n3
FALSO VERDADERO
nf < 14
mensaje = “Aprobado” mensaje = “Desaprobado”
nf, mensaje
FIN

Clase PrgNotaFinal2
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::endl ;
using std::string ;
int main ( ) {
double n1, n2, n3, nf ;
string mensaje ;
cout << “ Ingrese la primera nota: ” ;

cin >> n1 ;
cin >> n2 ;
cout << “ Ingrese la tercera nota: ” ;
cin >> n3 ;
nf = (n1 + n2 + n3) / 3 ;
if ( nf < 14 ) {
mensaje = “Desaprobado ” ;
} else {
mensaje = “ Aprobado ” ;
}
cout << “ La nota final es: ” << nf << “\n” ;

cout << mensaje << endl << endl ;
system ( “ PAUSE ” ) ;
return 0 ;
}
Clase PrgNotaFinal2
class PrgNotaFinal2 {

String mensaje ;
System.out.print ( “ Ingrese la primera nota: ” ) ;

n1 = Lectura.leerDouble( ) ;
System.out.print ( “ Ingrese la segunda nota: ” ) ;

System.out.print ( “ Ingrese la tercera nota: ” ) ;

nf = (n1 + n2 + n3) / 3 ;
if ( nf < 14 ) {
mensaje = “ Desaprobado ” ;
} else {
}
System.out.println ( “ La nota final es: ” + nf ) ;

}
}
Problema 033
Enunciado: Ingrese el monto a pagar por la compra de varios productos. A dicho monto ingresado
deberá agregarle el Impuesto General a las Ventas (I.G.V.). En caso de que el monto a pagar -incluido
I.G.V.- sea mayor a S/. 500.00 nuevos soles, no se aplicará un descuento de 8 % sino de 2 %.
A. Resultado deseado: Mostrar monto total a pagar.

B. Datos necesarios: Monto total.
C. Procesamiento: El monto a pagar será almacenado en una variable (montoPago). Se asume
que el I.G.V. es 18 %. Luego se realizará el cálculo del monto total a pagar:
montoTotalPagar = montoPago * 1.19.
El resultado se almacenará en una variable (montoPagoFinal). Si el monto

total resulta mayor a S/.500.00 nuevos soles, se descontará el 8% uƟlizando
la operación:
montoPagoFinal = montoPagoFinal * 0.92.
Caso contrario se descontará el 3% uƟlizando la operación:
montoPagoFinal = montoPagoFinal * 0.97.

En pseudocódigo:
ENTRADA: montoPago
SALIDA: montoPagoFinal
INICIO
REAL montoPago, montoPagoFinal
LEER montoPago
montoPagoFinal = montoPago * 1.19
SI (montoPagoFinal > 500 ) ENTONCES

montoPagoFinal = montoPagoFinal * 0.92
SINO
FINSI
ESCRIBIR montoPagoFinal
FIN
INICIO
REAL montoPago, montoPagoFinal
montoPago
montoPagoFinal = montoPago * 1.19
VERDADERO
FALSO
montoPagoFinal
> 500

0 97 montoPagoFinal
monto = montoPagoFinal * 0.97
montoPagoFinal
FIN

Clase PrgArƟculo
class PrgArticulo {
double montoPago, montoPagoFinal ;
System.out.print ( “ Ingrese el monto total: ” ) ;

montoPago = Lectura.leerDouble( ) ;
montoPagoFinal = montoPago * 1.19 ;
if (montoPagoFinal > 500 ) {

montoPagoFinal = montoPagoFinal * 0.92 ;
} else {
montoPagoFinal = montoPagoFinal * 0.97 ;
}
System.out.println ( “ El monto a pagar es: ” + montoPagoFinal) ;

}
}
Problema 034
Enunciado: Ingresar un número y determinar si el número ingresado es un número par o un número

impar.

A. Resultado deseado: Mostrar si el número es par o impar.
B. Datos necesarios: Número a determinar si es par o impar.
C. Procesamiento: El número a evaluar será almacenado en una variable (numero). Si el
resto de dividir el número entre 2 resulta cero, entonces se almacenará el
mensaje “el número es par”; en caso contrario, se almacenará el mensaje
“el número es impar”. El mensaje se almacenará en una variable (mensaje)
para, finalmente, mostrar su contenido.
Defina el nombre del proyecto y luego desarrolle la definición de paquetes, el diagrama de paquetes

En pseudocódigo:
Algoritmo PrgParImpar – main ( )
ENTRADA: numero
SALIDA: mensaje
INICIO
ENTERO numero
TEXTO mensaje
LEER numero
SI ( numero % 2 == 0 ) ENTONCES
mensaje = “Número es par”
SINO
mensaje = “Número es impar”
FINSI
ESCRIBIR mensaje
FIN
Algoritmo PrgParImpar – main ( )
INICIO
ENTERO numero
TEXTO mensaje
numero
FALSO VERDADERO
numero % 2 ==0
mensaje = “Número es impar” mensaje = “Número es par”
mensaje
FIN

Clase PrgParImpar
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
int main ( ) {
int numero ;
string mensaje ;
cout << “ Ingrese un número: ” ;

cin >> numero ;
if ( numero % 2 == 0 ) {
mensaje = “ El número es par ” ;
} else {
mensaje = “ El número es impar ” ;
}
return 0 ;
}
Clase PrgParImpar
class PrgParImpar {
int numero ;
String mensaje ;
System.out.print ( “ Ingrese un número: ” ) ;

numero = Lectura.leerInt( ) ;
if ( numero % 2 == 0) {
mensaje = “ El número es par ” ;
} else {
mensaje = “ El número es impar ” ;
}
}
}
Problema 035
Enunciado: Calcular el sueldo de un trabajador conociendo el número de horas trabajadas y su tarifa

horaria, sabiendo que se debe aumentar el 20 % del sueldo por bonificación familiar si este es mayor
de S/. 2400 nuevos soles, y 10 % en caso contrario. Mostrar el sueldo y el aumento respecƟvo.
A. Resultado deseado: Mostrar el sueldo y el aumento de un trabajador.

B. Datos necesarios: Total de horas trabajadas y tarifa horaria.
C. Procesamiento: 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 uƟlizando la operación sueldo = horas * tarifa. El resultado se
almacenará en una variable (sueldo). Si el sueldo resulta mayor que S/. 2400,
se calculará y almacenará el aumento en una variable (aumento) uƟlizando
la operación aumento = sueldo * 0.2; en caso contrario aumento = sueldo *
0.1. Luego se realizará el aumento; sueldo = sueldo + aumento. Finalmente,
se mostrará el sueldo a cobrar y el aumento.


En pseudocódigo:
Algoritmo PrgAumento – main ( )
ENTRADA: horas, tarifa

SALIDA: sueldo, aumento
INICIO
ENTERO horas
REAL tarifa, sueldo, aumento
LEER horas, tarifa
aumento = sueldo * 0.2
SINO
aumento = sueldo * 0.1
FINSI
sueldo = sueldo + aumento

ESCRIBIR sueldo, aumento
FIN


Clase PrgAumento
class PrgAumento {
int horas ;
double tarifa, sueldo, aumento ;
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 > 2400 ) {

aumento = sueldo * 0.2 ;
} else {
aumento = sueldo * 0.1 ;
}
sueldo = sueldo + aumento ;
System.out.println ( “ El sueldo a cobrar es: ” + sueldo ) ;

System.out.println ( “ El aumento es: ” + aumento) ;
}
}
IMPORTANTE
3.2.4 Estructura lógica de decisión múltiple: “CUANDO”
A. 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 uno de los valores
de la variable no tenga asociado un conjunto de pasos a ejecutar. La variable a utilizar podrá ser de
tipo CARACTER o ENTERO.
Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre más de dos opciones y
se presentan múltiples opciones, a las que se les puede asociar valores de tipo CARACTER o ENTERO.
B. Representación
En pseudocódigo:
CUANDO (variable) SEA EXPLICACIÓN:

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

instrucciones instrucciones instrucciones instrucciones
F®¦. 3.13
valor
variable
valor 1 valor 2 valor n OTROS
F®¦. 3.14
valor
variable
valor 1 valor 2 valor 3 valor 4 OTROS
instrucciones instrucciones instrucciones instrucciones instrucciones
F®¦. 3.15
valor
variable
valor 1 valor 2 valor 3 valor 4 OTROS

instrucciones instrucciones instrucciones instrucciones instrucciones
F®¦. 3.16
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.
Los diagramas de flujo mostrados en las figuras 3.13, 3.14, 3.15 y 3.16 se utilizan en forma alternativa
para elaborar estructuras lógicas de decisión múltiple, que no requieren evaluar una condición lógica
sino el valor de una variable. En estas estructuras se evalúa una variable y dependiendo de su valor se
ejecutarán un conjunto de instrucciones; sin embargo, es importante comprender que estos diagramas
muestran diferentes formas de diseñar una estructura lógica de decisión múltiple usando diagramas
de flujo.
Alternativamente puede usar el siguiente diagrama:
VERDADERO
instrucciones
valor == 1
FALSO
VERDADERO
instrucciones
valor == 2
FALSO
VERDADERO
valor == 3 instrucciones
FALSO
...
instrucciones
...
F®¦. 3.17
FALSO VERDADERO
condición 1
FALSO VERDADERO ...

condición 2 instrucciones
...
... ...
... ...
F®¦. 3.18
Es posible utilizar el diagrama de flujo mostrado en la figura 3.18 y extenderlo para evaluar una mayor
cantidad de posibles valores. Solo recuerde mantener la simetría y la estética al elaborar el diagrama
de flujo.

EXPLICACIÓN:
switch (variable) {
case valor 1 : Si el valor de la variable es igual a uno de los valores
sentencias ... colocados después de la palabra reservada case
break ; (valor 1, valor 2, etc.), se ejecutan las sentencias
que están dentro del mismo hasta llegar al final (es
case valor 2 :
decir hasta la llave); a no ser que encuentre una
sentencias ... palabra reservada break entre las sentencias que se
break ; ejecutan.
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
break ;
reservadas case, se ejecutan las sentencias que
default : están dentro de la palabra reservada default. La
sentencias ... palabra reservada default es opcional (es decir
} puede aparecer como no).
Es importante tener presente que en Java se deberá usar la palabra reservada break al final de cada
bloque de sentencias, esto 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.
Además, en Java la variable utilizada junto a la palabra reservada switch solo puede ser de tipo ENTERO
o de tipo CARACTER.
Si la variable es de tipo ENTERO (definida con la palabra reservada int), se deberán 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 carácter encerrado entre apóstrofe ( ' ' ) después
de la palabra reservada case.
Cuando se diseñe un algoritmo que necesite utilizar estructuras de decisión, se deben emplear
correctamente los formatos establecidos, ya que estos constituyen un “estándar” o acuerdo.
Cuando se codifique un algoritmo recuerde seguir las reglas del lenguaje de programación que usará;
de lo contrario, al momento de ejecutar un programa se dará con la sorpresa que tendrá errores de
sintaxis.
Problema 036

Enunciado: Ingresar un número del 1 al 7 y mostrar el día de la semana que le corresponde. Asuma
que el lunes es equivalente al día 1 y el domingo al día 7.
A. Resultado deseado: Mostrar el día equivalente.

B. Datos necesarios: Un número.
C. Procesamiento: Se ingresará un número por el teclado y se almacenará en una variable
(numero). Luego se almacenará el día equivalente en una variable (dia),
sabiendo que el número 1 equivale al día lunes, el 2 equivale al día martes
y así sucesivamente hasta el 7, que equivale al día domingo. Finalmente, se
mostrará el contenido de la variable dia.
1. Nombre del proyecto: ProyDia

Lectura
|leerString ()
PrgDia
|leerChar ( )
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgDia – main ( )
ENTRADA: numero
SALIDA: dia
INICIO
ENTERO numero
TEXTO dia = “ ”
LEER numero
CUANDO ( numero ) SEA
CASO 1 :
dia = “Lunes”
TERMINAR
CASO 2 :
dia = “Martes”
TERMINAR
CASO 3 :
dia = “Miércoles”
TERMINAR
CASO 4 :
dia = “Jueves”
TERMINAR
CASO 5 :
dia = “Viernes”
TERMINAR
CASO 6 :
dia = “Sábado”
TERMINAR
CASO 7 :
dia = “Domingo”
FINCUANDO
ESCRIBIR dia
FIN


Clase PrgDia
#include <iostream>
#include <string>
int main ( ) {
int numero ;
string dia = “ ” ;
cout << “ Ingrese un número del 1 al 7: ” ;

cin >> numero ;
switch ( numero ) {
case 1 :
dia = “ Lunes ” ;
break ;
case 2 :
dia = “ Martes ” ;
break ;
case 3 :
dia = “ Miércoles ” ;
break ;
case 4 :
dia = “ Jueves ” ;
break ;
case 5 :
dia = “ Viernes ” ;
break ;
case 6:
dia = “ Sábado ” ;
break ;
case 7 :
dia = “ Domingo ” ;
default :
dia = “ Valor no valido...!!!! ” ;
cout << dia << “\n\n ” ;
return 0 ;
}
Clase PrgDia
class PrgDia {
int numero ;
String dia = “ ” ;
System.out.print ( “ Ingrese un número del 1 al 7: ” ) ;

numero = Lectura.leerInt() ;
switch (numero) {
case 1 :
dia = “ Lunes ” ;
break ;
case 2 :
dia = “ Martes ” ;
break ;
case 3 :
dia = “ Miércoles ” ;
break ;
case 4 :
dia = “ Jueves ” ;
break ;
case 5 :
dia = “ Viernes ” ;
break ;
case 6:
dia = “ Sábado ” ;
break ;
case 7 :
dia = “ Domingo ” ;
break ;
default :
dia = “ Valor no válido...!!!! ” ;
System.out.println ( dia) ;
}
}
Problema 037
Enunciado: Leer la categoría y sueldo de un trabajador, y calcular el aumento correspondiente de

acuerdo a la tabla adjunta. Mostrar el sueldo incrementado del trabajador.
Cã¦ÊÙ° AçÃÄãÊ
A 18 %
B 12 %
C 09 %
D 06 %
Si se ingresa una categoría no existente, mostrar un mensaje de error.
A. Resultado deseado: Mostrar sueldo incrementado del trabajador.

B. Datos necesarios: Categoría y sueldo del trabajador.
C. Procesamiento: La categoría y el sueldo del trabajador serán almacenados en variables
(categoria y sueldo o s). Dependiendo de la categoría ingresada se procederá
a incrementar el sueldo del trabajador (sueldo o s), teniendo como base
la tabla mostrada. Finalmente, se mostrará el sueldo incrementado del
trabajador.

En pseudocódigo:
Algoritmo PrgAumentoSueldo – main ( )
ENTRADA: categoria, sueldo

SALIDA: sueldo
INICIO
NUMERO sueldo
CARACTER categoria
LEER sueldo, categoria
CUANDO (categoria) SEA

CASO ‘A’ :
CASO ‘a’ :
sueldo = sueldo * 1.18
TERMINAR
CASO ‘B’ :
CASO ‘b’ :
TERMINAR
CASO ‘C’ :
CASO ‘c’ :

TERMINAR
CASO ‘D’ :
CASO ‘d’ :
TERMINAR
OTROS:
ESCRIBIR “Categoría no válida”
FINCUANDO
ESCRIBIR sueldo
FIN
INICIO
NUMERO s
CARACTER categoria
categoria , s
categoria
OTROS
‘a’ ‘A’ ‘b’ ‘B’ ‘c’ ‘C’ ‘d’ ‘D’
s=s*1.18 s=s*1.12 s=s*1.09 s=s*1.06 "Error"
FIN
Donde: la variable sueldo ha sido renombrada por s, por motivos de espacio.

Clase PrgAumentoSueldo
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double sueldo ;
char categoria ;
cout << “ Ingrese el sueldo del trabajador : ” ;
cin >> sueldo ;
cout << “ Ingrese la categoría del trabajador : ” ;

cin >> categoria ;
switch ( categoria ) {
case ‘A’ :
case ‘a’ :
sueldo = sueldo * 1.18 ;
break ;
case ‘B’ :
case ‘b’ :
break ;
case ‘C’ :
case ‘c’ :
break ;
case ‘D’ :
case ‘d’ :
break ;
default :
cout << “Categoría no válida ” << endl ;
}
cout << “ El sueldo incrementado es: ” << sueldo << “\n\n ” ;

return 0 ;
}
class PrgAumentoSueldo {
double sueldo ;
char categoria ;
System.out.print ( “ Ingrese el sueldo del trabajador : ” ) ;

sueldo = Lectura.leerDouble( ) ;
System.out.print ( “ Ingrese la categoría del trabajador : ” ) ;

categoria = Lectura.leerChar( ) ;
case ‘A’ :
case ‘a’ :
break ;
case ‘B’ :
case ‘b’ :
break ;
case ‘C’ :
case ‘c’ :
break ;
case ‘D’ :
case ‘d’ :
break ;
default :
System.out.println ( “Categoría no válida ” ) ;
}
System.out.println ( “ El sueldo incrementado es : ” + sueldo ) ;
}
}
Problema 038

Enunciado: En una dulcería se venden cuatro Ɵpos de sándwich, de acuerdo a la siguiente tabla:
T®ÖÊ CÊÝãÊ
1 = Moderado S/. 4.5
2 = Mediano S/. 5.0
3 = Extra grande S/. 7.5
4 = Full S/. 13.5
Calcule y muestre el monto total a pagar por un sándwich, sabiendo que adicionalmente hay que
pagar el 5 % por el servicio y 2 % por propinas. Si se ingresa otro Ɵpo de sándwich considerar costo =
0 y mostrar un mensaje de error.
A. Resultado deseado: Mostrar el monto total a pagar por consumo.

B. Datos necesarios: Tipo de sándwich.
C. Procesamiento: El Ɵpo de sándwich será almacenado en una variable (Ɵpo - se considerará
4 Ɵpos de sándwich 1, 2, 3 y 4 respecƟvamente). Dependiendo del Ɵpo de
sándwich se conocerá su costo y luego se procederá a aumentar el 5% y el
2% del costo para calcular el monto total a pagar (montoPago). Finalmente,
se mostrará el resultado deseado.

En pseudocódigo:
Algoritmo PrgPagoSandwich – main ( )
ENTRADA: tipo
SALIDA: montoPago
INICIO
ENTERO tipo
REAL costo , montoPago
LEER tipo
CUANDO ( tipo ) SEA
CASO 1 :
costo = 4.5
TERMINAR
CASO 2 :
costo = 5.0
TERMINAR
CASO 3 :
costo = 7.5
TERMINAR
CASO 4 :
costo = 13.5
TERMINAR
OTROS :
ESCRIBIR “ Tipo de sándwich no válido ”
costo = 0
FINCUANDO
montoPago = costo + costo * 0.05 + costo * 0.02
ESCRIBIR montoPago
FIN
INICIO
NUMERO tipo
REAL costo, montoPago
tipo
tipo
OTROS
1 2 3 4
costo = 4.5 costo = 5 costo = 7.5 costo = 13.5 "Error"
costo = 0
montoPago = costo + costo * 0.05 + costo * 0.02
montoPago
FIN
Etapa 04 - Desarrollo de la codificación.

Clase PrgPagoSandwich
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int tipo ;
double costo, montoPago ;
cout << “ Ingrese el tipo de sándwich: ” ;

cin >> tipo ;
switch ( tipo ) {
case 1 :
costo = 4.5 ;
break ;
case 2 :
costo = 5.0 ;
break ;
case 3 :
costo = 7.5 ;
break ;
case 4 :
costo = 13.5 ;
break ;
default :
cout << “ Tipo de sándwich no válido ” << endl ;
costo = 0 ;
montoPago = costo + costo * 0.05 + costo * 0.02 ;

cout << “ Monto a pagar: ” << montoPago << “ \n\n” ;
return 0 ;
}
Clase PrgPagoSandwich
class PrgPagoSandwich {
int tipo ;
double costo, montoPago ;
System.out.print ( “ Ingrese el tipo de sándwich: ” ) ;

tipo = Lectura.leerInt( ) ;
switch ( tipo ) {
case 1 :
costo = 4.5 ;
break ;
case 2 :
costo = 5.0 ;
break ;
case 3 :
costo = 7.5 ;
break ;
case 4 :
costo = 13.5 ;
break ;
default :
System.out.println ( “ Tipo de sándwich no válido ” ) ;
costo = 0 ;
montoPago = costo + costo * 0.05 + costo * 0.02 ;

System.out.println ( “ Monto a pagar: ” + montoPago) ;
}
}
Problema 039
Enunciado: Desarrollar una solución que permita realizar operaciones de suma, resta o mulƟplicación.
Se deberá ingresar dos números y el Ɵpo de operación que se desea realizar. Muestre un mensaje de
error si se ingresa un operador no válido.
A. Resultado deseado: Mostrar el resultado de la suma, resta o mulƟplicación de dos números.

B. Datos necesarios: Tipo de operación y dos números.
C. Procesamiento: El Ɵpo de operación y los dos números se almacenarán en variables (Ɵpo,
n1 y n2 respecƟvamente - se considerará 3 Ɵpos de operaciones aritméƟcas
“+”, “-” y “*”). Dependiendo del Ɵpo de operación se procederá a hacer la
suma, la resta o la mulƟplicación de los dos números y mostrar su resultado
(rpta).
1. Nombre del proyecto: ProyOperaciones

Lectura
|leerString ()
PrgOperaciones
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

INICIO
REAL n1, n2, rpta

CARACTER tipo
tipo, n1, n2
tipo
OTROS
‘+’ ‘-’ ‘*’
rpta = n1 + n2 rpta = n1 - n2 rpta = n1 * n2 rpta = 0
rpta
FIN
Observe la forma cómo finaliza la estructura lógica de decisión CUANDO. Esta es una forma alternativa de
hacer el diagrama de la estructura CUANDO.

#include <iostream>
int main ( ) {
double n1, n2, rpta ;

char tipo ;
cout << “ Ingrese el tipo de operación: ” ;

cin >> tipo ;
if ( tipo == ‘+’ || tipo == ‘-’ || tipo == ‘*’ ) {
cout << “ Ingrese el primer número: ” ;

cin >> n1 ;
cout << “ Ingrese el segundo número: ” ;

cin >> n2 ;
switch ( tipo ) {
case ‘+’ :
rpta = n1 + n2 ;
break ;
case ‘-’ :
rpta = n1 - n2 ;
break ;
case ‘*’ :
rpta = n1 * n2 ;
break;
}
cout << “ Resultado: ” << rpta << “ \n\n ” ;
} else {
cout << “ Operador no válido …!!! \n\n ” ;
}
return 0 ;
}

class PrgOperciones {
double n1, n2, rpta ;

char tipo ;
System.out.print ( “ Ingrese el tipo de operación: ” ) ;

tipo = Lectura.leerChar( ) ;
if ( tipo == ‘+‘ || tipo == ‘-‘ || tipo == ‘*‘ ) {
System.out.print ( “ Ingrese el primer número: ” ) ;

n1= Lectura.leerDouble( ) ;
System.out.print ( “ Ingrese el segundo número: ” ) ;

switch ( tipo ) {
case ‘+’ :
rpta = n1 + n2 ;
break ;
case ‘-’ :
rpta = n1 - n2 ;
break ;
case ‘*’ :
rpta ta = n1 * n2 ;
break;
}
System.out.println ( “ Resultado: ” + rpta ) ;
} else {
System.out.print << “ Operador no válido !!! \n\n ” ;
}
}
}
Problema 040
Enunciado: Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo
al Ɵpo de enfermedad, según los datos de la tabla. Considere que el costo mostrado en la tabla es por
cada día que el paciente estuvo internado en el hospital.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ½ Ö®Äã ÖÊÙ °

11 200
12 350
13 420
A. Resultado deseado: Mostrar el costo total de un paciente para un hospital.

B. Datos necesarios: El Ɵpo de enfermedad y el número de días de permanencia del paciente.
C. Procesamiento: El Ɵpo de enfermedad y el número de días que el paciente estuvo internado
en el hospital se almacenarán en variables (Ɵpo y dias). Dependiendo del
Ɵpo de enfermedad, se procederá a hallar el costo por día (costo), para
posteriormente hacer el cálculo del costo total que el paciente representa
para el hospital, de acuerdo a la siguiente operación.
costoTotal = costo * dias
El resultado se almacena en una variable (costoTotal), para luego ser

mostrado.

En pseudocódigo:
Algoritmo PrgHospital – main ( )
ENTRADA: tipo, dias

SALIDA: costoTotal
INICIO
ENTERO tipo , dias

REAL costo = 0, costoTotal
LEER tipo, dias
CUANDO ( tipo ) SEA
CASO 11 :
costo = 200
TERMINAR
CASO 12 :
costo = 350
TERMINAR
CASO 13 :
costo = 420
OTROS :
ESCRIBIR “ Tipo de enfermedad no válida!!! ”
FINCUANDO
costoTotal = costo * dia

ESCRIBIR costototal
FIN
Algoritmo PrgHospital – main ( )
INICIO
ENTERO tipo, dias

REAL costo = 0, costoTotal
tipo , dias
tipo
11 12 13
costo = 200 costo = 350 costo = 420
costoTotal = costo * dias
costoTotal
FIN

Clase PrgHospital
#include <iostream>
int main ( ) {
int tipo, dias ;
double costo = 0, costoTotal ;
cout << “ Ingrese el tipo de enfermedad: ” ;

cin >> tipo ;
cout << “ Número de días de internamiento: ” ;
cin >> dias ;
switch ( tipo ) {
case 11 :
costo = 200 ;
break ;
case 12 :
costo = 350 ;
break ;
case 13 :
costo = 420 ;
break ;
default :
cout << “ \n Tipo de enfermedad no valida…!!! ” << “\n” ;
}
costoTotal = costo * dias ;

cout << “ El costo total es: ” << costoTotal << “ \n\n ” ;
return 0 ;
}
Clase PrgHospital
class PrgHospital {
int tipo, dias ;

double costo = 0, costoTotal ;
System.out.print ( “ Ingrese el tipo de enfermedad: ” ) ;

tipo = Lectura.leerInt ( ) ;
System.out.print ( “ Número de días de internamiento: ” ) ;
dias = Lectura.leerInt ( ) ;
switch ( tipo) {
case 11 :
costo = 200 * dias ;
break ;
case 12 :
break ;
case 13 :
default :
System.out.print ( “ \n Tipo de enfermedad no valida…!!! \n” );
}
costoTotal = costo * dias ;
System.out.println ( );
System.out.println ( “ El costo total es: ” + costoTotal ) ;
}
}
IMPORTANTE
3.2.5 Estructura lógica de decisión múltiple: “SI ANIDADOS”
A. Definición: Una estructura de decisión múltiple “SI ANIDADOS” permite alterar el flujo secuencial
de una solución, ejecutando un conjunto de pasos que dependen del resultado de varias condiciones
lógicas. Generalmente, cuando se tiene un problema con múltiples condiciones lógicas la mejor
opción será emplear SI ANIDADOS para la solución. Esto fundamentalmente por que la estructura
lógica de decisión múltiple CUANDO no trabaja con condiciones lógicas, sino solo con el valor de
una variable que puede ser de tipo CARACTER o ENTERO.
Este tipo de estructura es útil cuando se tiene la necesidad de escoger entre más de dos opciones
y se presentan múltiples condiciones lógicas.
B. Representación
En pseudocódigo:
SI (condición) ENTONCES Explicación:

…
instrucciones Si la condición resulta verdadera, se ejecutan las
… instrucciones que se encuentran entre las reglas
SI…ENTONCES y SINO.
SINO
SI (condición) ENTONCES Si la condición resulta falsa se ejecutan las

… instrucciones que se encuentran entre las reglas
instrucciones SINO y FINSI.
…
FINSI Solo se ejecuta uno de los grupos de instrucciones,
en ningún caso se podrá ejecutar ambos grupos.
FINSI
FALSO VERDADERO
condición 1
...
condición 2 VERDADERO instrucciones
...
...
FALSO instrucciones
...
F®¦. 3.18
En la figura 3.18 se muestra una estructura de decisión múltiple utilizando diagramas de flujo.
En la figura se puede observar claramente el diagrama de flujo de una estructura de decisión doble,
y el diagrama de flujo de una estructura de decisión simple en el flujo “FALSO” de la evaluación de
la condición. La idea fundamental es que el diagrama de flujo represente una estructura de decisión
múltiple, donde se debe utilizar diagramas de flujo de estructuras de decisión simple y doble en
forma combinada, de acuerdo a las necesidades que se determinen.
En las figuras 3.19, 3.20, 3.21, 3.22 y 3.23 se pueden apreciar algunos ejemplos. Observe que en todo
momento se elaboran los diagramas de flujo guardando estética, simetría y buen gusto.
FALSO VERDADERO
condición 1
FALSO VERDADERO ...

...
... ...
... ...
F®¦. 3.19
FALSO VERDADERO
condición 1
VERDADERO
...
condición 2
instrucciones
...
FALSO ...
instrucciones
...
F®¦. 3.20
FALSO VERDADERO
condición 1
... FALSO VERDADERO

instrucciones condición 2
...
... ...
... ...
F®¦. 3.21
VERDADERO
condición 1
FALSO
VERDADERO
condición 2
FALSO
... ...
... ...
F®¦. 3.22
FALSO VERDADERO
condición 1
FALSO VERDADERO FALSO VERDADERO

condición 2 condición 2
... ... ... ...

... ... ... ...
CAP. 3: ESTRUCTURAS
F®¦. 3.23
LÓGICAS DE DECISIÓN O SELECCIÓN
211
Existe la posibilidad de reducir el tamaño del diagrama de flujo cuando se tienen múltiples condiciones,
y cada condición en su flujo “VERDADERO” ejecuta una o dos instrucciones. Esto puede apreciarse a
continuación:
VERDADERO
FALSO
VERDADERO
FALSO
VERDADERO
FALSO
...
instrucciones
...
F®¦. 3.24
Observando la figura anterior, podrá apreciar que el diagrama de flujo se ha elaborado utilizando
múltiples estructuras de decisión doble (ver figura 3.8). Recuerde que si existien muchas instrucciones
en los flujos “VERDADERO” de las condiciones lógicas, existe la posibilidad de que el diagrama de flujo
pierda simetría y estética; en ese caso, se recomienda utilizar un diagrama de flujo como el que se
muestra en la figura 3.23.
Problema 041
Enunciado: Calcular el área de un rectángulo conociendo su base y altura. Si el área es menor que
100, se deberá visualizar el mensaje “rectángulo pequeño”; si el área es mayor o igual a 100 y menor
que 1000, se visualizará el mensaje “rectángulo mediano”; y si el área es mayor o igual que 1000, el
mensaje será “rectángulo grande”.
A. Resultado deseado: Mostrar el área de un rectángulo y un mensaje referido al tamaño de este.

B. Datos necesarios: La base y la altura del rectángulo.
C. Procesamiento: La base y la altura del rectángulo se almacenarán en variables (base y
altura). Se calcula el área del rectángulo (base y altura) y se almacena en
una variable (area). Si el área resulta menor que 100, se almacenará en una
variable (mensaje) el texto “rectángulo pequeño”. Si el área resulta mayor
o igual que 100 y menor que 1000, se almacenará el texto “rectángulo
mediano”. Si el área resulta mayor o igual que 1000, se almacenará el
texto “rectángulo grande”. Finalmente, se mostrará el área (area) y el texto
respecƟvo (mensaje) en pantalla.
1. Nombre del proyecto: ProyAreaRectangulo

2. Definición de paquete y diagrama de paquetes
Lectura
|leerString ()
PrgOperaciones
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgAreaRectangulo – main ( )
ENTRADA: base, altura

SALIDA: area, mensaje
INICIO
REAL base, altura, area

TEXTO mensaje
LEER base, altura
area = base * altura
SI ( area < 100 ) ENTONCES

mensaje = “ rectángulo pequeño ”
SINO
SI ( area >= 1000 ) ENTONCES
mensaje = “ rectángulo grande ”
SINO
mensaje = “ rectángulo mediano ”
FINSI
FINSI
ESCRIBIR area, mensaje
FIN
INICIO
REAL base, altura, area

TEXTO mensaje
base, altura
area= base * altura
FALSO VERDADERO
area <100
FALSO VERDADERO
area <100 mensaje = “rectángulo mediano”
mensaje = “ rectángulo mediano” mensaje = “ rectángulo grande”
mensaje
FIN
Clase PrgAreaRectangulo
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
int main ( ) {
double base, altura, area ;

string mensaje ;
cout << “ Ingrese la base del rectángulo: ” ;

cin >> base ;
cout << “ Ingrese la altura del rectángulo: ” ;

cin >> altura ;
area = base * altura ;
if ( area < 100 ) {

mensaje = “ rectángulo pequeño ” ;
} else {
if ( area >= 1000 ) {

mensaje = “ rectángulo grande ” ;
} else {
mensaje = “ rectángulo mediano ” ;
}
cout << “\n” ;

cout << “ El área es: ” << area << “\n” ;
cout << “ Es un” << mensaje << “\n\n” ;
return 0 ;
}

Clase PrgAreaRectangulo
class PrgAreaRectangulo {
double base, altura, area ;

String mensaje;
System.out.print ( “ Ingrese la base del rectángulo : ” ) ;

base = Lectura.leerDouble( ) ;
System.out.print ( “ Ingrese la altura del rectángulo : ” ) ;

altura = Lectura.leerDouble( ) ;
area = base * altura ;
if ( area < 100 ) {

mensaje = “ rectángulo pequeño ” ;
} else {
if ( area >= 1000 ) {

mensaje = “ rectángulo grande ” ;
} else {
mensaje = “ rectángulo mediano ” ;
}
System.out.println ( “ ” ) ;
System.out.println ( “ El área es: ” + area ) ;
System.out.println ( “ Es un ” + mensaje ) ;
}
}
Problema 042
Enunciado: Observe el sueldo de un trabajador y calcule su aumento por incremento del costo de
vida de acuerdo a la siguiente tabla. Mostrar el nuevo sueldo.
CÊÄ®®ÌÄ AçÃÄãÊ
sueldo < 2000 20 %
2000 < = sueldo < =3000 13 %
sueldo > 3000 9%
A. Resultado deseado: Mostrar el sueldo del trabajador, incluido su incremento.

B. Datos necesarios: El sueldo actual del trabajador.
C. Procesamiento: El sueldo actual del trabajador se almacenará en una variable (sueldo). Si el
sueldo resulta menor que S/. 2000 nuevos soles, el incremento será del 20
%; si es mayor que S/. 3000 nuevos soles, será de 9 %, y en otros casos será
de 13 %. El resultado se almacenará en una variable (nuevoSueldo) para
luego ser mostrado en pantalla.
1. Nombre del proyecto: ProyAumentoSueldo2

2. Definición de paquete y diagrama de paquetes
Lectura
|leerString ()
PrgAumentoSueldo2
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgAumentoSueldo2 – main ( )
ENTRADA: sueldo
SALIDA: nuevoSueldo
INICIO
REAL sueldo, nuevoSueldo
LEER sueldo
SI ( sueldo < 2000 ) ENTONCES

nuevoSueldo = sueldo * 1.2
SINO

SINO
FINSI
FINSI
ESCRIBIR nuevoSueldo
FIN
Algoritmo PrgAumentoSueldo2 – main ( )
INICIO
REAL sueldo, nuevoSueldo
sueldo
FALSO VERDADERO
sueldo<2000
FALSO VERDADERO
sueldo>3000 nuevoSueldo = sueldo * 1.2
nuevoSueldo = sueldo * 1.13 nuevoSueldo = sueldo * 1.09
nuevoSueldo
FIN

Clase PrgAumentoSueldo2
#include <iostream>
int main ( ) {
double sueldo, nuevoSueldo ;

cout << “ Ingrese el sueldo del trabajador: ” ;
cin >> sueldo ;
if ( sueldo < 2000 ) {
nuevoSueldo = sueldo * 1.2 ;
} else {
if ( sueldo > 3000 ) {
} else {
}
}
cout << “ El nuevo sueldo es: ” << nuevoSueldo << “\n\n” ;
return 0 ;
}
Clase PrgAumentoSueldo2
class PrgAumentoSueldo2 {
double sueldo, nuevoSueldo ;

System.out.print ( “ Ingrese el sueldo del trabajador : ” ) ;
sueldo = Lectura.leerDouble( ) ;
if ( sueldo < 2000 ) {
} else {
if ( sueldo > 3000 ) {
} else {
}
}
System.out.println ( “ El nuevo sueldo es: ” + nuevoSueldo ) ;
}
}
Problema 043
Enunciado: Desarrolle una solución que permita determinar si un número (num) es par, impar o nulo.
Muestre un mensaje si el número es par, impar o nulo.
A. Resultado deseado: Mostrar si un número es par, impar o nulo.

C. Procesamiento: El número a evaluar será almacenado en una variable (num). Si el resultado
de la evaluación (num == 0) resulta verdadera, se almacenará en una variable
Ɵpo texto “el número es nulo”. Si el resultado es falso, se evaluará (num%2 ==
0); si el resultado es verdadero, el número evaluado será un número par y se
almacenará el texto “el número es par”. En otros casos, el número evaluado
será un número impar y se almacenará el texto “el número es impar”.

En pseudocódigo:
Algoritmo PrgNumTipo2 - main ( )
ENTRADA: num
SALIDA: tipo
INICIO
ENTERO num
TEXTO tipo
LEER num
SI ( num == 0 ) ENTONCES
tipo = “El número es nulo ”
SINO
SI ( num % 2 == 0 ) ENTONCES
tipo = “ El número es par ”
SINO
tipo = “ El número es impar ”
FINSI
FINSI
ESCRIBIR tipo
FIN
Algoritmo PrgNumTipo2 – main ( )
INICIO
ENTERO num
TEXTO tipo
num
FALSO VERDADERO
num == 0
FALSO VERDADERO
tipo = “El número es nulo”
num % 2 == 0
tipo = “El número es par” tipo = “El número es par”
tipo
FIN

Clase PrgNumTipo2
#include <iostream>
int main ( ) {
int num ;
string tipo ;
cout << “ Ingrese un número: ”;
cin >> num ;
if ( num == 0 ) {
tipo = “ El número es nulo ”;
} else {
if (num % 2 == 0 ) {
tipo = “ El número es par ” ;
} else {
tipo = “ El número es impar ” ;
}
}
cout << tipo << “ \n\n ” ;
return 0 ;
}
Clase PrgNumTipo2
class PrgNumTipo2 {
int num ;
String tipo ;
num = Lectura.leerInt( ) ;
if ( num == 0 ) {
tipo = “ El número es nulo ” ;
} else {
if (num % 2 == 0 ) {
tipo = “ El número es par ” ;
} else {
tipo = “ El número es impar ” ;
}
}
System.out.println ( tipo ) ;
}
}
Problema 044
Enunciado: Determinar si un número es divisor de otro número. UƟlice la expresión (num1 % num2
== 0), donde “num1” y “num2” son los dos números.
A. Resultado deseado: Mostrar si un número es divisor de otro.

B. Datos necesarios: Dos números.
C. Procesamiento: Los dos números a evaluar serán almacenados en variables (num1 y num2).
Se determinará cuál de los dos es el número mayor y luego se uƟlizará la
expresión (num1 RESTO num2) == 0 en el caso que el primer número (num1)
sea mayor o igual que el segundo número (num2,) o la expresión (num2
RESTO num1) == 0 en el caso que el segundo número (num2) sea mayor que
el primer número (num1), para determinar si un número es divisor o no del
otro. Finalmente, se mostrará la variable (mensaje) que indica si uno de los
números es o no divisor del otro número.

En pseudocódigo:
Algoritmo PrgNumeroDivisor - main ( )
ENTRADA: num1, num2

SALIDA: mensaje
INICIO
ENTERO num1, num2

TEXTO mensaje
LEER num1, num2
SI ( num1 >= num2 ) ENTONCES
SI ( num1 % num2 == 0 ) ENTONCES

mensaje = “El segundo número es divisor del primer número”
SINO
mensaje = “El segundo número no es divisor del primer número”
FINSI
SINO
SI ( num2 % num1 == 0 ) ENTONCES

mensaje = “El primer número es divisor del segundo número”
SINO
mensaje = “El primer número no es divisor del segundo número”
FINSI
FINSI
ESCRIBIR mensaje
FIN

Clase PrgNumeroDivisor
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
int main ( ) {
int num1, num2 ;

string mensaje ;
cin >> num1 ;
cin >> num2 ;
if ( num1 >= num2 ) {

if ( num1 % num2 == 0 ) {
mensaje = “ El segundo número es divisor del primero ” ;
} else {
mensaje = “ El segundo número no es divisor del primero ” ;
}
} else {
if ( num2 % num1 == 0 ) {
mensaje = “ Primer número es divisor del segundo” ;
} else {
mensaje = “ Primer número no es divisor del segundo” ;
}
}
return 0 ;
}
Clase PrgNumeroDivisor
class PrgNumeroDivisor {
int num1, num2 ;

String mensaje ;

num1 = Lectura.leerInt( ) ;
if ( num1 >= num2 ) {

if ( num1 % num2 == 0 ) {
mensaje = “ El segundo número es divisor del primero ” ;
} else {
mensaje = “ El segundo número no es divisor del primero ” ;
}
} else {
if ( num2 % num1 == 0 ) {
mensaje = “ El primer número es divisor del segundo ” ;
} else {
mensaje = “ El primer número no es divisor del segundo ” ;
}
}
}
}
Problema 045
Enunciado: Un curso se evalúa de la siguiente forma: se toma cinco prácƟcas 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 tabla siguiente, mostrar el promedio y la categoría del alumno.
Considerar que todas las notas ingresadas están dentro de los valores válidos (de 0 a 20).
RÄ¦Ê Cã¦ÊÙ°
Desde 17 a 20 A
Desde 14 a 16 B
Desde 10 a 13 C
Desde 00 a 09 D
A. Resultado deseado: Mostrar la categoría del alumno.

B. Datos necesarios: Las cinco notas del estudiante.
C. 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

permiƟrá obtener la categoría del alumno (categoria), para luego ser
mostrada en la pantalla.

En pseudocódigo:
Algoritmo PrgCategoriaAlumno - main ( )
ENTRADA: n1, n2, n3, n4, n5

SALIDA: categoria
INICIO
REAL n1, n2, n3, n4, n5, sumaNotas

REAL notaMenor, promedio
CARACTER categoria = ‘ ’
LEER n1, n2, n3, n4, n5
sumaNotas = n1 + n2 + n3 + n4 + n5
notaMenor = n1
SI ( notaMenor > n2 ) ENTONCES

notaMenor = n2
FINSI
notaMenor = n3
FINSI
notaMenor = n4
FINSI
notaMenor = n5
FINSI
promedio = ( sumaNotas – notaMenor ) / 4
SI ( promedio <= 20 AND promedio >= 17 ) ENTONCES

categoria = ‘A’
SINO
SI ( promedio >= 14 ) ENTONCES
categoria = ‘B’
SINO
SI ( promedio >= 10 ) ENTONCES
categoria = ‘C’
SINO
categoria = ‘D’
FINSI
FINSI
FINSI
ESCRIBIR promedio, categoria
FIN
Clase PrgCategoriaAlumno
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double n1, n2, n3, n4, n5, sumaNotas ;

double notaMenor , promedio ;
char categoria = ‘ ’ ;
out << “ Ingrese la 1ra. nota: ” ;

cin >>n1 ;
cout << “ Ingrese la 2da. nota: ” ;
cin >>n2 ;
cout << “ Ingrese la 3ra. nota: ” ;
cin >>n3 ;
cout << “ Ingrese la 4ta. nota: ” ;
cin >>n4;
cout << “ Ingrese la 5ta. nota: ” ;
cin >> n5 ;
sumaNotas = n1 + n2 + n3 + n4 + n5 ;
notaMenor = n1 ;
if ( notaMenor > n2 )
notaMenor = n2 ;
notaMenor = n3 ;
notaMenor = n4 ;
notaMenor = n5 ;
promedio = ( sumaNotas – notaMenor ) / 4 ;
if ( promedio <= 20 && promedio >= 17 ) {

categoria = ‘A’ ;
} else {
if (promedio >= 14 ) {
categoria = ‘B’ ;
} else {
categoria = ‘C’ ;
} else {
categoria = ‘D’ ;
}
}
}
cout << “\n El promedio del alumno es: " << promedio << “\n” ;
cout << “Su categoría es: ” << categoria << “\n” ;
cout << “\n” ;
return 0 ;
}

class PrgCategoriaAlumno {
double notaMenor, promedio ;
System.out.print ( “ Ingrese la 1ra. nota: ” ) ;

System.out.print ( “ Ingrese la 2da. nota: ” ) ;
System.out.print ( “ Ingrese la 3ra. nota: ” ) ;
System.out.print ( “ Ingrese la 4ta. nota: ” ) ;
System.out.print ( “ Ingrese la 5ta. nota: ” ) ;
sumaNotas = n1 + n2 + n3 + n4 + n5 ;
notaMenor = n1 ;
notaMenor = n2 ;
notaMenor = n3 ;
notaMenor = n4 ;
notaMenor = n5 ;
promedio = ( sumaNotas - notaMenor ) / 4 ;

} else {
} else {
if ( promedio >= 10 ) {
} else {
}
}
}
System.out.println ( ) ; // Inserta una línea en blanco.
System.out.println ( “ El promedio del alumno es: ” + promedio ) ;
System.out.println ( “ Su categoría del alumno es: ” + categoria ) ;
}
}
Problema 046
Enunciado: Ingresar tres notas de un alumno y mostrar las notas ordenadas en forma ascendente.
A. Resultado deseado: Mostrar las tres notas de un alumno en forma ascendente.

B. Datos necesarios: Las tres notas del alumno en cualquier orden.
C. Procesamiento: Las tres notas del alumno serán almacenadas en variables (n1, n2 y n3).
Se uƟlizarán tres variables auxiliares para ir almacenando el orden de

las notas de acuerdo a diferentes comparaciones entre ellas (menor,
intermedio y mayor). Finalmente, la variable auxiliar mayor, intermedio y
menor almacenarán las notas y se mostrarán en orden ascendente.

En pseudocódigo:
Algoritmo PrgOrdena – main ( )
ENTRADA: n1, n2, n3

SALIDA: menor, intermedio, mayor
INICIO
ENTERO n1, n2, n3, menor, intermedio, mayor

LEER n1, n2, n3
SI ( n1 > n2 ) ENTONCES
mayor = n1
intermedio = n2
menor = n3
SINO
intermedio = n3
menor = n2
FINSI
SINO
mayor = n3
intermedio = n1
menor = n2
FINSI
SINO
mayor = n2
intermedio = n1
menor = n3
SINO
intermedio = n3
menor = n1
FINSI
SINO
mayor = n3
intermedio = n2
menor = n1
FINSI
FINSI
ESCRIBIR menor, intermedio, mayor
FIN
Algoritmo PrgOrdena – main ( )
INICIO
ENTERO n1 , n2 , n3 , mayor , intermedio , mayor
n1 , n2 , n3
FALSO VERDADERO
n1 > n2

n1 > n3 n1 > n3
mayor = n3 mayor = n2 mayor = n3 mayor = n1

intermedio = n2 intermedio = n1
menor = n1 menor = n2
n1 > n3 n2 > n3
intermedio = n3 intermedio = n1 intermedio = n3 intermedio = n2

menor = n1 menor = n3 menor = n2 menor = n3
menor ,
intermedio ,
mayor
FIN

Clase PrgOrdena
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int n1, n2, n3, menor, intermedio, mayor ;
cout << “ Ingrese la primera nota: ” ;
cin >> n1 ;
cin >> n2 ;
cout << “ Ingrese la tercera nota: ” ;
cin >> n3 ;
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 ;
}
}
cout << “ Las notas ordenadas en forma ascendente son: ” ;
cout << menor << “, ” << intermedio << “ y ” << mayor << “\n\n”;
return 0 ;
}

Clase PrgOrdena
class PrgOrdena {
int n1, n2, n3, menor, intermedio, mayor ;
n1 = Lectura.leerInt( ) ;
System.out.print ( “ Ingrese la tercera nota: ” ) ;
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 ( n2 > n3 ) {
intermedio = n1 ;
menor = n3 ;
} else {
intermedio = n3 ;
menor = n1 ;
}
} else {
mayor = n3 ;
intermedio = n2 ;
menor = n1 ;
}
}
System.out.print ( ) ;
System.out.print ( “ Las notas ordenadas en forma ascendente son: ” ) ;
System.out.println ( menor + “, ” + intermedio + “ y ” + mayor ) ;
}
}
IMPORTANTE

3.3 USO COMBINADO DE LAS ESTRUCTURAS LÓGICAS DE DECISIÓN

Como se ha mencionado anteriormente, existen tres tipos de estructura de decisión, las cuales se
utilizan en la solución de problemas.
Es común que en las soluciones planteadas se utilice una o más de estas estructuras lógicas; así, puede
utilizarse una estructura lógica de decisión doble y una estructura lógica de decisión múltiple en una
solución; una estructura lógica de decisión simple y una estructura de decisión doble en otra solución
y muchas otras combinaciones posibles.
También puede utilizarse más de una estructura lógica de decisión al mismo tipo; además, pueden
utilizarse varias estructuras lógicas de decisión doble en una solución o varias estructuras lógicas de
decisión múltiple en otra solución, así como otras combinaciones posibles.
3.4 USO ANIDADO DE LAS ESTRUCTURAS LÓGICAS DE DECISIÓN

Adicionalmente al uso combinado de las estructuras lógicas de decisión, existen otras soluciones en
las que se utilizan dos o más estructuras lógicas de decisión en forma anidada. Se define que dos
estructuras lógicas están anidadas, cuando una está dentro de la otra.
Se puede utilizar una estructura lógica de decisión simple dentro de una estructura lógica de decisión
múltiple en una solución o una estructura lógica de decisión doble dentro de otra estructura lógica de
decisión doble, y muchas otras posibilidades.
A continuación, se presentan algunas soluciones que permiten ilustrar el uso combinado y el uso
anidado de las estructuras de decisión.
Debido a que la Etapa 2 se ha desarrollado en todos los problemas anteriores, a partir de ahora no se
incluirá en las siguientes soluciones. Sin embargo, se recuerda que es imprescindible ejecutar dicha
etapa para asegurar una correcta y eficiente definición de la solución.
Problema 047
Enunciado: Una editorial ha puesto a la venta tres Ɵpos de libros de acuerdo a la tabla adjunta.
Considerando que para el caso de los libros Ɵpo B, el precio Ɵenen un incremento del 18.5 %, si la
compra es realizada con tarjeta de crédito y para los libros Ɵpo C, el precio Ɵene un descuento del
40 % si se compra en efecƟvo. Desarrolle una solucion que permita determinar y mostrar el precio a
pagar por la compra de cierta canƟdad de libros del mismo Ɵpo.
T®ÖÊ ½®ÙÊ PÙ®Ê

A 40
B 30
C 25
Defina el nombre del proyecto, y luego desarrolle la definición de paquetes, el diagrama de paquetes

En pseudocódigo:
Algoritmo PrgVentaLibro – main ( )
ENTRADA: tipoLibro, cantidad, tipoPago

SALIDA: montoPago
INICIO
NUMERO cantidad, tipoPago, montoPago, precio=0

CARACTER tipoLibro
LEER tipoLibro, cantidad, tipoPago
CUANDO ( tipoLibro ) SEA

CASO ‘A’ : CASO ‘a’ :
precio = 40
TERMINAR
CASO ‘B’ : CASO ‘b’ :
precio = 30
SI ( tipoPago == 1 ) ENTONCES
precio=precio * 1.185
FINSI
TERMINAR
CASO ‘C’ : CASO ‘c’ :
precio = 25
SI ( tipoPago == 0 ) ENTONCES
precio=precio * 0.60
FINSI
FINCUANDO
montoPago = precio * cantidad

ESCRIBIR montoPago
FIN
Clase PrgVentaLibro
class PrgVentaLibro {
double montoPago, precio = 0 ;

int cantidad, tipoPago ;
char tipoLibro ;
System.out.print ( “ Ingrese el tipo de libro: ” ) ;

tipoLibro = Lectura.leerChar( ) ;
System.out.print ( “ Ingrese la cantidad a comprar: ” ) ;
cantidad = Lectura.leerInt( ) ;
System.out.print ( “ Ingrese el tipo de pago [ 0=Efectivo, 1=
Tarjeta ] : ” );
tipoPago = Lectura.leerInt( ) ;
switch ( tipoLibro ) {
case ‘A’ : case ‘a’ :
precio = 40 ;
break ;
case ‘B’ : case ‘b’ :
precio = 30 ;
if ( tipoPago == 1 ) {
precio=precio * 1.185 ;
}
break ;
case ‘C’ : case ‘c’ :
precio = 25 ;
if ( tipoPago == 0 ) {
precio = precio * 0.60 ;
}
}
montoPago = precio * cantidad ;
System.out.println ( “ El precio a pagar es: ” + montoPago ) ;
}
}
Problema 048
Enunciado: Una empresa vende dos Ɵpos de jabones, cada uno de los cuales Ɵene una calidad
disƟnta. Considerando que los precios no incluyen I.G.V., desarrolle una solución que muestre el
monto subtotal (sin incluir I.G.V.), el monto del I.G.V. (18 % del subtotal) y el monto a pagar (monto
incluido I.G.V.) por la compra de cierta canƟdad de jabones del mismo Ɵpo y la misma calidad.
T®ÖÊ ¹ÌÄ PÙ®Ê ½® 1 PÙ®Ê ½® 2

1 2.0 2.5
2 30 3.5
Defina el nombre del proyecto, y luego desarrolle la definición de paquetes, el diagrama de paquetes

En pseudocódigo:
Algoritmo PrgVentaJabones – main ( )
ENTRADA: tipoJabon, cantidad, calidad

SALIDA: subtotal, igv, total
INICIO
NUMERO tipoJabon, cantidad, calidad, precio=0, subtotal, igv, total

LEER tipoJabon, cantidad, calidad
CUANDO ( tipoJabon ) SEA
CASO 1 :
SI ( calidad == 1 ) ENTONCES
precio = 2.0
SINO
precio = 2.5
FINSI
TERMINAR
CASO 2 :
SI ( calidad == 1 ) ENTONCES
precio = 3.0
SINO
precio = 3.5
FINSI
TERMINAR
FINCUANDO
subtotal = precio * cantidad

igv = subtotal * 0.19
total = subtotal + igv
ESCRIBIR subtotal, igv, total
FIN

Clase PrgVentaJabones
class PrgVentaJabones {
int tipoJabon, cantidad, calidad ;

double precio = 0, subtotal, igv, total ;
System.out.print ( “Ingrese el tipo de jabón [ 1 o 2 ]: ” ) ;

tipoJabon = Lectura.leerInt ( ) ;
System.out.print ( “Ingrese la cantidad: ” ) ;

cantidad = Lectura.leerInt ( ) ;
System.out.print ( “Ingrese la calidad [ 1 o 2 ]: ” ) ;

calidad = Lectura.leerInt ( ) ;
switch (tipoJabon) {
case 1 :
if (calidad == 1) {
precio = 2.0 ;
} else {
precio = 2.5 ;
}
break ;
case 2 :
if (calidad == 1) {
precio = 3.0 ;
} else {
precio = 3.5 ;
}
break ;
}
subtotal = precio * cantidad ;
igv = subtotal * 0.19 ;
total = subtotal + igv ;
System.out.println ( “El subtotal es: ” + subtotal ) ;
System.out.println ( “El IGV es: ” + igv) ;
System.out.println ( “El total es: ” + total ) ;
}
}

Problema 049
Enunciado: Según los datos de la tabla, calcular y mostrar el costo total que representa un paciente
para un hospital de acuerdo al Ɵpo de enfermedad. Adicionalmente, deberá considerarse que las
mujeres Ɵenen un incremento del 10 % para el Ɵpo 1 de enfermedad y los hombres un aumento del
5 % para el Ɵpo 3 de enfermedad.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ®Ù®Ê ÖÊÙ Ö®Äã

1 200
2 350
3 420

En pseudocódigo:
Algoritmo PrgHospital1 - main ( )
ENTRADA: tipoEnfermedad, dias, sexo

SALIDA: costoTotal
INICIO
NUMERO tipoEnfermedad, dias, sexo, 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 :
TERMINAR
CASO 3 :
SI ( sexo == 1 ) ENTONCES
costoTotal = costoTotal * 1.05
FINSI
FINCUANDO
ESCRIBIR costoTotal
FIN

Clase PrgHospital1
class PrgHospital1 {
int tipoEnfermedad, dias, sexo ;

double costoTotal = 0 ;
System.out.print ( “ Ingrese el tipo de enfermedad: ” ) ;

tipoEnfermedad = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el sexo [1=hombre, 2= Mujer] : ” ) ;

sexo = Lectura.leerInt ( ) ;
System.out.print ( “ Número de días internado: ” ) ;

switch ( tipoEnfermedad ) {
case 1 :
costoTotal = 200 * dias ;
if ( sexo == 2 ) {
costoTotal = costoTotal * 1.10 ;
}
break ;
case 2 :
break ;
case 3 :
if ( sexo == 1 ) {
}
}
System.out.println ( “ El costo total es: ” + costoTotal ) ;
}
}

Problema 050
Enunciado: Según los datos de la tabla, leer las notas obtenidas por un alumno del curso de
MatemáƟca Básica III y calcular su nota final (nf) de acuerdo a la fórmula empleada por su profesor.
Mostrar la nota final (nf) del alumno y determinar si está aprobado o no, considerando que la nota
mínima aprobatoria es 12 (doce).
CÌ®¦Ê ÖÙÊ¥ÝÊÙ FÌÙÃç½

1 nf = (n1 + n2 ) / 2
2 nf = (n1 + n2*2) / 3
3 nf = (n1*2 + n2) / 3

En pseudocódigo:
ENTRADA: n1, n2, codigo

SALIDA: nf, mensaje
INICIO
NUMERO codigo, n1, n2, nf = 0
TEXTO mensaje
LEER codigo, n1, n2
CUANDO ( codigo ) SEA
CASO 1 :
nf = ( n1 + n2 ) / 2
TERMINAR
CASO 2 :
nf = ( n1 + n2 * 2 ) / 3
TERMINAR
CASO 3 :
nf = ( n1 * 2 + n2 ) / 3
FINCUANDO
SI ( nf > 12) ENTONCES
mensaje = “aprobado”
SINO
mensaje = “desaprobado”
FINSI
FIN

Clase PrgNotaFinal3
int codigo ;
double n1, n2, nf = 0 ;
String mensaje ;
System.out.print ( “ Ingrese el código del profesor: ” ) ;

codigo = Lectura.leerInt ( ) ;
switch ( codigo ) {
case 1 :
nf = ( n1 + n2 ) / 2 ;
break ;
case 2 :
nf = ( n1 + n2 * 2 ) / 3 ;
break ;
case 3 :
nf = ( n1 * 2 + n2 ) / 3 ;
}
if ( nf > 12 ) {
mensaje = “ Alumno aprobado” ;
} else {
mensaje = “ Alumno desaprobado” ;
}
System.out.println ( “ Nota final: ” + nf ) ;
}
}

Problema 051
Enunciado: Una librería ha puesto a la venta cuadernos ofreciendo descuentos según el siguiente
detalle:
Dã½½ ÝçÄãÊÝ
Por las primeras 12 unidades→ 10 % de descuento
Por las 12 unidades siguientes → 20 % de descuento
Por las demás unidades → 40 % de descuento
Desarrolle una solución que permita determinar y mostrar el importe subtotal, el importe del
descuento y el importe a pagar por la compra de cierta canƟdad de cuadernos.

En pseudocódigo:
Algoritmo PrgLibreria – main ( )
ENTRADA: precio, cantidad

SALIDA: subtotal, iDescuento , iPagar
INICIO
ENTERO cantidad
REAL precio, iSubtotal, iDescuento, iPagar, dscto
LEER precio, cantidad
SI ( cantidad <= 12 ) ENTONCES

dscto = cantidad * 0.10
SINO SI ( cantidad <= 24 ) ENTONCES
dscto = 12 * 0.10 + (cantidad – 12) * 0.20
SINO
dscto = 12 * 0.10 + 12 * 0.20 + (cantidad – 24) * 0.
FINSI
iSubtotal = precio * cantidad
iDescuento= precio * dscto
iPagar = iSubtotal - iDescuento
ESCRIBIR iSubtotal, iDescuento, iPagar
FIN

|En algunas ocasiones podrá encontrar una solución como la mostrada anteriormente, donde
la estructura lógica de decisión múltiple (SI) no presenta explícitamente el fin de la estructura
(FINSI). Este formato se puede utilizar en forma opcional, cuando existe solo una instrucción en
cada uno de los bloques o flujos de la estructura lógica de decisión múltiple (SI). Es importante
mencionar que, para poder visualizar adecuadamente este formato, se utiliza un número diferente
de tabulaciones en cada instrucción. Su uso se ha extendido debido a las nuevas posibilidades que
ofrecen los actuales lenguajes de programación.
Clase PrgLibreria
class PrgLibreria {
int cantidad ;
double precio, iSubtotal, iDescuento, iPagar, dscto ;
System.out.print ( “ Ingrese el precio: ” ) ;

precio = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese la cantidad: ” ) ;

if ( cantidad <= 12 )
dscto = cantidad * 0.10 ;
else if ( cantidad <= 24 )
dscto = 12 * 0.10 + (cantidad – 12) * 0.20 ;
else
dscto = 12 * 0.10 + 12 * 0.20 + (cantidad – 24) * 0.40 ;
iSubtotal = precio * cantidad ;

iDescuento= precio * dscto ;
iPagar = iSubtotal - iDescuento ;
System.out.println ( “ El importe subtotal es: ” + iSubtotal) ;
System.out.println ( “ El importe de descuento es: ” + iDescuento) ;
System.out.println ( “ El importe a pagar es: ” + iPagar) ;
}
}

Problema 052
Enunciado: 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:

||Categoría FA si tienen menos de 23 años.
||Categoría FB en caso contrario.

- Si la persona es de sexo masculino:
||Categoría MA si tiene menos de 25 años.
||Categoría MB en caso contrario.

En pseudocódigo:
Algoritmo PrgCategoriaPostulante – main ( )
ENTRADA: sexo, edad

SALIDA: categoria
INICIO
CARACTER sexo
ENTERO edad
TEXTO categoria = “ ”
LEER sexo, edad
CUANDO ( sexo ) SEA
CASO ‘f’ :
CASO ‘F’ :
categoria = “FA”
SINO
categoria = “FB”
FINSI
TERMINAR
CASO ‘m’ :
CASO ‘M’ :
categoria = “MA”
SINO
categoria = “MB”
FINSI
FINCUANDO
ESCRIBIR categoria
FIN

Clase PrgCategoriaPostulante
class PrgCategoriaPostulante {
char sexo ;
int edad ;
String categoria = “ ” ;
System.out.print ( “ Ingrese sexo del postulante [ F/M ]: ” ) ;

sexo = Lectura.leerChar ( ) ;
System.out.print ( “ Ingrese la edad del postulante: ” ) ;

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” ;
break ;
}
System.out.println ( “ La categoría del postulante es:” + categoria ) ;

}
}

Problema 053
Enunciado: Un negocio vende tres Ɵpos de arơculos; el mouse Ɵene un costo de US$ 3, el teclado
cuesta US$5 y la CPU US$ 250. Según la canƟdad que compra el cliente se aplica la siguiente tabla
de descuentos:
T®ÖÊ ÖÙÊçãÊ CÄã® < 10 CÄã® >=10

Mouse 2% 4%
Teclado 3% 6%
CPU 5% 7%
Ingresar la canƟdad y el Ɵpo de arơculo que el cliente desea comprar y considere que el cliente solo
puede comprar un Ɵpo de producto a la vez. Determinar el monto total a pagar.
Diseño del algoritmo

Intente diseñar el algoritmo en pseudocódigo y diagrama de flujo.

Clase PrgVenta
class PrgVenta {
char tipo ;
int cantidad ;
double pago = 0, preMou = 3.0, preTecl = 5.0, preCpu = 250.0 ;
System.out.print ( “ Ingrese tipo de producto (M / T / C) : ” ) ;

tipo = Lectura.leerChar( ) ;
System.out.print ( “ Ingrese cantidad que comprar: ” ) ;

switch ( tipo ) {
case ‘M’ : case ‘m’ :
if ( cantidad < 10 )
pago = preMou * cantidad * 0.98 ;
else
pago = preMou * cantidad * 0.96 ;
break ;
case ‘T’ : case ‘t’ :

pago = preTecl * cantidad * 0.97 ;
else
pago = preTecl * cantidad * 0.94 ;
break ;
case ‘C’ : case ‘c’ :
pago = preCpu * cantidad * 0.95 ;
else
pago = preCpu * cantidad * 0.93 ;
break ;
default :
System.out.print (“ \n Tipo de artículo no valido ” ) ;
}
System.out.println ( “ \n Monto a pagar: ” + pago ) ;

}
}
Problema 054
Enunciado: Desarrollar un programa que permita ingresar el día, el mes y el año de una determina
fecha. Comprobar si la fecha ingresada es correcta y si el año es bisiesto o no.

Clase PrgVerificaFecha
/** 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.
*/
class PrgVerificaFecha {
public static void main ( String arg[] ) {
int dia, mes, año ;

boolean verifdia = false, bisiesto = false ;
String mess = “ ” ;
System.out.print ( “ Ingrese el número del día: ” ) ;

dia = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el número del mes: ” ) ;

mes = Lectura.leerInt ( ) ;
System.out.print ( “ 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 :
if ( dia > 0 && dia <= 31 ) {

verifdia = true ;
}
break ;
case 4 :
case 6 :
case 9 :
case 11 :
if( ( dia > 0) && ( dia <= 30 ) )

verifdia = true ;
break ;
case 2 :
if ( bisiesto ) {
if ( ( dia > 0 ) && ( dia <= 29 ) ) {
verifdia = true ;
} else {
if ( ( dia > 0 ) && ( dia <= 28 ) )
verifdia = true ;
}
}
break ;
}
//selecciona el nombre del mes

if ( verifdia && ( mes > 0 ) && ( mes <= 12 ) && ( año > 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 ;
case 10 :
mess = “Octubre” ;
break ;
case 11 :
mess = “Noviembre” ;
break;
case 12 :
mess = “Diciembre” ;
break ;
}
System.out.println ( “ Fecha: “+ 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 ” ) ;
}
}
}
Problema 055
Enunciado: Desarrollar un programa que permita ingresar un número arábico entre 1000 y 3000.
Determinar y mostrar el número ingresado por medio de su equivalente en número romano.

Clase PrgNumRomano
/** 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
*/
class PrgNumRomano {
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 <= 3000 ) {
miles = arabigo / 1000 ;

resto = arabigo % 1000 ;
centena = resto / 100 ;
resto = resto % 100 ;
decena = resto / 10 ;
unidad = resto % 10 ;
//formar el número romano. Obtener miles

switch ( miles ) {
case 1 :
romano = romano + “M” ;
break ;
case 2 :
romano = romano + “MM” ;
break ;
case 3 :
romano = romano + “MMM” ;
}
//obtener centenas
switch ( centena ) {
case 1 :
romano = romano + “C” ;
break ;
case 2 :
romano = romano + “CC” ;
break ;
case 3 :
romano = romano + “CCC” ;
break ;
case 4 :
romano = romano + “CD” ;
break ;
case 5 :
romano = romano + “D” ;
break ;
case 6 :
romano = romano + “DC” ;
break ;
case 7 :
romano = romano + “DCC” ;
break ;
case 8 :
romano = romano + “DCCC” ;
break ;
case 9 :
romano = romano + “CM” ;
}
//obtener decenas
switch ( decena ) {
case 1 :
romano = romano + “X” ;
break ;
case 2 :
romano = romano + “XX” ;
break ;
case 3 :
romano = romano + “XXX” ;
break ;
case 4 :
romano = romano + “XL” ;
break ;
case 5 :
romano = romano + “L” ;
break ;
case 6 :
romano = romano + “LX” ;
break ;
case 7 :
romano = romano + “LXX” ;
break ;
case 8 :
romano = romano + “LXXX” ;
break ;
case 9 :
romano = romano + “XC” ;
}
//obtener unidades
switch ( unidad ) {
case 1 :
romano = romano + “I” ;
break ;
case 2 :
romano = romano + “II” ;
break ;
case 3 :
romano = romano + “III” ;
break ;
case 4 :
romano = romano + “IV” ;
break ;
case 5 :
romano = romano + “V” ;
break ;
case 6 :
romano = romano + “VI” ;
break ;
case 7 :
romano = romano + “VII” ;
break ;
case 8 :
romano = romano + “VIII” ;
break ;
case 9 :
romano = romano + “IX” ;
}
// Mostrar número romano
System.out.println ( Arábigo + “ = ” + romano ) ;
} else {
System.out.println ( " Número ingresado no válido " ) ;
}
}
}
IMPORTANTE
PUNTO A PARTE
3.5 DESARROLLO DE APLICACIONES JAVA, UTILIZANDO INTEGRATED DEVELOPMENT ENVIRONMENT (IDE)

Para desarrollar aplicaciones en Java de una manera más práctica y fácil, también se puede
utilizar un Entorno Integrado de Desarrollo o IDE. Un IDE es un entorno de programación que ha
sido empaquetado como un programa de aplicación; es decir, consiste en un editor de código, un
compilador, un depurador y un constructor de interfaz gráfica (GUI). En la actualidad existe una gran
variedad de IDE en el mercado, algunos de los cuales pueden ser elegidos precisamente para editar,
compilar y ejecutar sus aplicaciones desarrolladas en Java.
Es un Entorno de Desarrollo Integrado (IDE por su sigla en inglés de

Integrated Development Environment); es decir, es un programa
informático que está compuesto por un conjunto de herramientas que
facilitan el desarrollo de programas informáticos (no es un lenguaje de
programación). En general, está constituido por un editor de código,
un compilador, un depurador y un constructor de interfaz gráfica (GUI),
que facilitan el desarrollo de programas en un determinado lenguaje de
programación.
Eclipse originalmente fue creado por IBM, y en la actualidad es

desarrollado por la Fundación Eclipse, una organización independiente
sin fines de lucro que fomenta una comunidad de código abierto.
Se trata de un IDE para Java desarrollado por la empresa Xinox, cuya

filoso a es la sencillez. Hay dos versiones, JCreator "Pro" y JCreator
"Lite". La versión "pro" es comercial, aunque se pueden descargar
versiones de evaluación. La versión "lite" es libre. Su uso puede ser de
mucha utilidad cuando no se requieren características avanzadas de
entornos como Eclipse, puesto que resulta ser más rápido y compacto.
JCreator no es multiplataforma y solo está disponible para Windows.
|Puede uƟlizar cualquier buscador de Internet para ampliar sus conocimientos sobre estos y
otros soŌware; solo coloque el nombre del soŌware y podrá observar varios link que incluso le
permiƟrán desacargar el soŌware a su PC.
3.6 MÉTODO DE LAS 6´D – USO DE CUADROS DE DIÁLOGO

ENUNCIADO
DEL
PROBLEMA

Definición Diseño Derrollo
}|Determinar los }|Definir los paquetes el lenguaje de
datos de entrada y desarrollar programación Java.
(entrada). el diagrama de UƟlice la clase
}|Establecer como paquetes respectivo. reuƟlizable LE.
se solucionará el Establecer la
problema (proceso). dependencia. Utilice
UML.
}|Definir las clases
que serán parte
de la solución del
problema. Utilice
UML.
ALGORITMO
para el método
principal. Utilizar
diagrama de
actividades.
Problema 056
Enunciado: Ingresar el precio de compra y venta de un determinado producto. Luego introducir la

canƟdad de arơculos que una persona desea comprar de dicho producto, calcular y mostrar el monto
total a pagar por el comprador y la uƟlidad del vendedor, sabiendo que si se compran más de diez
arơculos se realiza un descuento del 2 %. Desarrolle el algoritmo y la codificación en el lenguaje de
programación Java y uƟlice la clase LE para ingresar los datos y mostrar la información.

INICIO
LEER cantidad, pventa,

pcompra
total = pventa * cantidad
VERDADERO
cantidad > 10
FALSO
descuento = total * 0.2
utilidad = total –
(pcompra * cantidad)
total = pventa * cantidad
FIN
Etapa 04 - Desarrollo de la codificación en lenguaje de programación Java
Clase PrgCompra
class PrgCompra {
int cantidad ;
double total, pventa, pcompra, utilidad, descuento = 0 ;
cantidad = LE.leerInt ( “ Ingrese la cantidad de productos ” ) ;
pcompra = LE.leerDouble ( “ Ingrese el precio compra del producto ” ) ;
pventa = LE.leerDouble ( “Ingrese el precio de venta del producto ” ) ;
total = pventa * cantidad ;
if ( cantidad > 10 ) {
descuento = total * 0.2 ;
total = total - descuento ;
}
utilidad = total - ( pcompra * cantidad ) ;
String mensaje = “ El total a pagar es ” + total + “\n” +

“La utilidad es ” + utilidad ;
LE.mostrarInformacion( mensaje ) ;
}
}
Resultado:
Problema 057
Enunciado: Calcular y mostrar la nota final de un alumno en base a tres notas ingresadas. Si la nota
final es menor a 14, se deberá mostrar el mensaje “Desaprobado”; en caso contrario se mostrará el
mensaje “Aprobado”. Desarrolle el algoritmo y la codificación en el lenguaje de programación Java y
uƟlice la clase LE para ingresar los datos y mostrar la información.

INICIO
LEER n1, n2, n3
nf = (n1 + n2 + n3) / 3
FALSO VERDADERO
nf < 14
mensaje = “Aprobado” mensaje = “Desaprobado”
FIN

Clase PrgNotaFinal2

String mensaje ;
n1 = LE.leerDouble ( “ Ingrese la primera nota ” ) ;

n2 = LE.leerDouble ( “ Ingrese la segunda nota ” ) ;
n3 = LE.leerDouble ( “ Ingrese la tercera nota ” ) ;
nf = (n1 + n2 + n3) / 3 ;
if ( nf < 14 ) {
mensaje = “ Desaprobado ” ;
} else {
}
LE.mostrarInformacion ( “ La nota final es ” + nf + “. ” + mensaje ) ;
}
}
Resultado:
Problema 058
Enunciado: Observar la categoría y sueldo de un trabajador y entonces calcular el aumento

correspondiente de acuerdo a la tabla. Mostrar el sueldo incrementado del trabajador, luego
desarrolle el algoritmo y la codificación en el lenguaje de programación Java. Para ello, uƟlice la clase
LE para ingresar los datos y mostrar la información.
A 18 %
B 12 %
C 09 %
D 06 %

INICIO
LEER sueldo,
categoria
categoria
0 1 2 3 otros
sueldo = sueldo = sueldo = sueldo = sueldo =0

sueldo * 1.18 sueldo * 1.12 sueldo * 1.09 sueldo * 1.06
ESCRIBIR
ESCRIBIR sueldo “Error”
FIN

class PrgAumentoSueldo {
String categorias[ ] = { “A” , “B” , “C” , “D” } ;
double sueldo ;
int categoria ;
sueldo = LE.leerDouble ( “ Ingrese el sueldo del trabajador ” ) ;

categoria = LE.seleccionarOpcionIndex ( “ Categorías ”,
“ Seleccione la categoría del trabajador ”, categorias ) ;
switch (categoria) {
case 0 :
break ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
default :
sueldo = 0 ;
LE.mostrarError ( “ Categoría no válida ” ) ;
}
LE.mostrarInformacion ( “ El sueldo incrementado es ” + sueldo ) ;
}
}
El método mostrarError( ) de la clase LE permite mostrar información de error en un cuadro de

diálogo con un ơtulo y un ícono determinados. Generalmente, este método se uƟliza para resaltar
un error que el usuario ha comeƟdo al momento de ingresar o destacar errores en el procesamiento
de los datos.
Los métodos seleccionarOpcion( ) y seleccionarOpcionIndex( ) de la clase LE permite mostrar un

cuadro de diálogo con múlƟples opciones, teniendo la posibilidad de seleccionar una de ellas. La
diferencia entre ambos métodos es que el primero de ellos retorna la opción seleccionada y el
segundo retorna un número entero con la posición de la opción seleccionada (donde la primera
posición es cero, la segunda es 1 y así sucesivamente).
Ambos métodos reciben tres parámetros. El primero es un String con el ơtutlo del cuadro de diálogo,
el segundo es el String que se visualizará dentro del cuadro de diálogo y el tercero es un arreglo de
String conteniendo las opciones que el usuario puede seleccionar. El tema de arreglos será tratado
en profundidad más adelante.
Para obtener el cuadro de diálogo mostrado se uƟlizaron las siguientes líneas de código Java:
String categorias[ ] = { “A” , “B” , “C” , “D” } ;

int categoria ;
categoria = LE.seleccionarOpcionIndex ( “ Categorías ”,

“ Seleccione la categoría del trabajador ”, categorias
Problema 059
Enunciado: Un curso se evalúa de la siguiente forma: se toman cinco prácƟcas calificadas, se

determina el promedio de las cuatro notas más altas y se le asigna al estudiante una categoría, que
puede ser A, B, C o D, según la tabla mostrada. Determine la categoría del alumno y desarrolle la
codificación en el lenguaje de programación Java. Luego uƟlice la clase LE para ingresar los datos y
mostrar la información.
RÄ¦Ê Cã¦ÊÙ°
Desde 17 a 20 A
Desde 14 a 16 B
Desde 10 a 13 C
Desde 00 a 09 D

class PrgCategoriaAlumno {

double notaMenor, promedio ;
n1 = LE.leerDouble ( “ Ingrese la 1ra. nota ” ) ;

n2 = LE.leerDouble ( “ Ingrese la 2da. nota ” ) ;
n3 = LE.leerDouble ( “ Ingrese la 3ra. nota ” ) ;
n4 = LE.leerDouble ( “ Ingrese la 4ta. nota ” ) ;
n5 = LE.leerDouble ( “ Ingrese la 5ta. nota ” ) ;
sumaNotas = n1 + n2 + n3 + n4 + n5 ;
notaMenor = n1 ;
notaMenor = n2 ;
notaMenor = n3 ;
notaMenor = n4 ;
notaMenor = n5 ;
promedio = ( sumaNotas - notaMenor ) / 4 ;

} else {
} else {
} else {
} else {
LE.mostrarError ( “ No se estableció categoría ” ) ;
}
}
}
}
LE.mostrarInformacion ( “ La categoría del alumno es ” + categoria ) ;
}
}
Resultado:
Problema 060
Enunciado: Calcular y mostrar el costo total que representa un paciente para un hospital de acuerdo
al Ɵpo de enfermedad, según los datos de la tabla. Adicionalmente, deberá considerar que las
mujeres Ɵenen un incremento del 10 % para la enfermedad Ɵpo 1 y los hombres Ɵenen un aumento
del 5 % para la enfermedad Ɵpo 3. Desarrolle la codificación en el lenguaje de programación Java.
Luego uƟlice la clase LE para ingresar los datos y muestre la información.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ®Ù®Ê ÖÊÙ Ö®Äã

1 200
2 350
3 420

Clase PrgHospital1
class PrgHospital1 {
String tipos [ ] = { “1” , “2” , “3” } ;

int tipoEnfermedad = 0, dias = 0, sexo = 0 ;
double costoTotal = 0 ;
tipoEnfermedad = LE.seleccionarOpcionIndex
( “Tipo Enfermedad” , “Seleccione tipo de enfermedad” , tipos ) ;
sexo = LE.leerInt ( “ Ingrese el sexo [1=hombre, 2= Mujer] ” ) ;

dias = LE.leerInt ( “ Número de días internado ” ) ;
switch ( tipoEnfermedad ) {
case 0 :

if ( sexo == 2 ) {
}
break ;
case 1 :
break ;
case 2 :
if ( sexo == 1 ) {
}
default :
LE.mostrarError ( “ No seleccionó categoría ” ) ;
}
LE.mostrarInformacion ( “ El costo total es ” + costoTotal ) ;
}
}
Resultado:
IMPORTANTE
Se recomienda solucionar todos los problemas propuestos planteados
al final del presente capítulo, uƟlizando la clase reuƟlizable LE.
1. Desarrollar una solución que permita ingresar y mostrar un número y determinar si es par; en
caso de ser así, mostrar un mensaje que indique: “El número ingresado es par”.
2. Desarrollar una solución que permita ingresar las cuatro notas de un alumno. Calcular el promedio
del alumno con la fórmula (n1 + n2 + n3 + n4) / 4. Mostrar el promedio del alumno, si este es
menor que 11, mostrar el siguiente mensaje: “El alumno está desaprobado”.
3. Desarrollar una solución que permita ingresar y mostrar las edades de dos personas. Si la primera
edad es mayor que la segunda, mostrar un mensaje que diga: “La primera persona es mayor que
la segunda”.
4. Desarrollar una solución que permita ingresar el promedio y la desviación estándar de un número
de datos. Calcular el coeficiente de variabilidad y si este es mayor al 25 %, mostrar un mensaje que
indique: “Este grupo tiene mucha variabilidad”.
CV = (S / X) * 100
CV : Coeficiente de Variabilidad
S : Desviación Estándar
X : Promedio
5. Desarrollar una solución que permita ingresar la cantidad de borradores que se compraron en la
librería “El Boligrafito” y el precio de cada uno. Calcular y mostrar el monto a pagar, y en caso de
que supere los S/. 100.00 nuevos soles aplicarle un descuento de 7 %.
6. Desarrollar una solución que permita calcular y mostrar el volumen de una esfera. Si el volumen
es mayor a 400, se debe visualizar el mensaje: “Esfera grande”.
7. Desarrollar una solución que permita calcular y mostrar el área de un cuadrado. Si dicha área
resulta mayor que 768, se deberá mostrar el mensaje: “Cuadrado grande”.
8. Desarrollar una solución que permita determinar cómo se clasifica un ángulo ingresado a tráves
teclado. Los ángulos se clasifican de la siguiente manera:
Ángulo = 0 Nulo
0 < ángulo <90 Agudo
Ángulo = 90 Recto
90 < ángulo < 180 Obtuso
Ángulo = 180 Llano
180 < ángulo < 360 Cóncavo
Ángulo = 360 Completo
9. Desarrollar una solución que permita calcular y mostrar la nota final (nf) de un alumno, sabiendo
que se tienen solo dos notas. Si el alumno obtiene una nota final mayor o igual a 18 se deberá
visualizar un mensaje de Felicitaciones.
10. Desarrollar una solución que permita calcular el sueldo de un trabajador, conociendo el número
de horas trabajadas y la tarifa horaria además, se deberá aumentar el 16 % por concepto de
bonificación familiar, si el sueldo es menor a S/. 1860.00 nuevos soles. Mostrar la cantidad del
sueldo y el aumento respectivo.
11. Desarrollar una solución que permita determinar el sueldo neto, el sueldo bruto y el descuento de
un trabajador de una empresa. Se debe tener en cuenta que dicha empresa paga a sus vendedores
por horas trabajadas. Hasta 40 horas se paga una tarifa normal y sobre las 48 horas, la tarifa tiene
un recargo del 20 %. Además,considere de que si el sueldo bruto es superior a S/. 1650.00 nuevos
soles estará sujeto a un descuento del 15 %.
12. Desarrollar una solución que permita ingresar tres notas de un determinado alumno. Entonces
mostrar las notas ordenadas en forma descendente (de mayor a menor).
13. Desarrollar una solución que calcule el costo total de hospitalización, sabiendo el total de días y el
costo de la habitación. Este se determina de acuerdo a la siguiente tabla:
ÁÙ CÊÝãÊ
1 150
2 120
Otra 100
14. Desarrollar una solución que permita determinar si un número ingresado por teclado es capicúa
o no. Un número es capicúa si se lee de la misma forma de derecha a izquierda y viceversa. (Por
ejemplo; el número 4554 es un número capicúa)
15. Desarrollar una solución que permita ingresar un número comprendido entre 1 y 5. Luego mostrar
el número en letras.
16. Desarrollar una solución que permita calcular el monto a pagar por la compra de un producto,
considerando un descuento del 27 % por la compra de 150 unidades.
17. Desarrollar una solución que permita calcular y mostrar el monto total a pagar por la compra
de varios artículos. Considerar que deberá agregar el I.G.V. respectivo. Si el monto total a pagar
incluido I.G.V. es mayor a S/. 1800.00 nuevos soles se aplicará un descuento del 12 %, en caso
contrario el descuento será del 3 %.
18. Desarrollar una solución que permita determinar qué proveedor es más conveniente para una
empresa que desea adquirir cierta cantidad de unidades de un producto. Para ello se cuenta con
las siguientes propuestas:
||Proveedor A: Costo unitario igual a S/. 25.00 y 15 % de descuento para más de 50 unidades
adquiridas.
||Proveedor B: Costo unitario igual a S/. 27.5 y 10 % de descuento para mas de 35 unidades
adquiridas.
19. Desarrollar una solución que permita determinar si un número es múltiplo de otro número.
20. Desarrollar una solución que permita ingresar un número entero. Luego mostrar si el número
ingresado es negativo, par o múltiplo de 7.
21. Desarrollar una solución que permita determinar si un número es o no, múltiplo de los números;
3, 7 y 13. Finalmente mostrar un mensaje que indique si es múltiplo de los tres números o no.
22. Desarrollar una solución que permita ingresar un número entre 1 y 12; y mostrar el nombre del
mes del año correspondiente:(enero, febrero,…).
23. Desarrollar una solución que permita ingresar la categoría y el sueldo de un trabajador. Calcular el
aumento correspondiente teniendo en cuenta la tabla y mostrar el nuevo sueldo del trabajador.
1 35 %
2 25 %
3 15 %
4 5%
24. Una empresa paga a sus empleados un sueldo básico en base a la siguiente tabla:
Cã¦ÊÙ° BÝ®Ê
A S/. 400
B S/. 500
C S/. 600
D S/. 700
Adicionalmente, les paga una comisión en base al monto de sus ventas, según se detalla en el
cuadro siguiente:
VÄãÝ BÝ®Ê
0 a 500 0%
501 a 1500 20.5 %
1501 a 2500 30.5 %
Más de 2500 45.5 %
Desarrolle una solución que permita calcular y mostrar el sueldo básico, la comisión y el sueldo a
cobrar (sueldo básico + comisión) por el empleado.
25. Desarrollar una solución que permita 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,
se debe considerar que las mujeres tiene un incremento del 19 % para la de enfermedad tipo 1 y
los hombres tienen un descuento del 4 % para la enfermedad tipo 3.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ®Ù®Ê

1 120
2 360
3 620
26. Desarrollar una solución que permita determinar y mostrar si una persona que va a mirar un
programa de televisión está apta o no. Considerar la siguiente tabla:
E Cã¦ÊÙ°
18 – más Adultos
11 – 17 Mayores de 14
0 – 10 Apta para todos
27. Un colegio categoriza y cobra la mensualidad de sus estudiantes de acuerdo a la siguiente tabla:
Cã¦ÊÙ° MÄÝç½®
1 500
2 600
3 700
Ademea aplica un descuento en el costo de las mensualidades, de acuerdo al promedio obtenido

por sus alumnos:
PÙÊÃ®Ê DÝçÄãÊ
0 a 13 0%
Más de 13 pero menos que 17 10 %
Más de 16 pero menos que 19 25 %
Más de 18 hasta 20 40 %
Desarrolle una solución que permita hallar y mostrar cuánto sería el costo de la mensualidad por
un alumno, teniendo en cuenta su promedio y categoría.
28. Una fábrica codifica sus productos mediante un número de cinco cifras.
||La primera cifra define el tipo de producto (1: zapatos, 2: correas y 3: carteras).
||La segunda cifra define el color (1: natural, 2: negro y 3 marrón).
||La tercera cifra define el material (1: cuero y 2: sintético).
||La cuarta y quinta cifra, el lote al que corresponde.
Desarrolle una solución que permita obtener la información del tipo, color, material y lote de un
producto en base a su código.
29. Desarrollar una solución que permita determinar la categoría de un alumno. Considerar que la
categorización de los alumnos se realiza en función de la nota, en base a la siguiente tabla:
PÙÊÃ®Ê Cã¦ÊÙ°
18 – 20 Excelente
15 – 17 Bueno
11 – 14 Regular
0 – 10 Malo
30. Desarrollar una solución que permita ingresar las cinco notas de un alumno y calcular el promedio
del alumno sabiendo que se elimina la nota más baja y se duplica la nota más alta. Finalmente,
determinar la categoría obtenida por el alumno, considerando que la categoría del alumno está
en función de su promedio, tal como se muestra en la siguiente tabla:
PÙÊÃ®Ê Cã¦ÊÙ°
17 – 20 A
14 – 16 B
10 – 13 C
0–9 D
31. Desarrollar una solución que permita mostrar en palabras, el valor de las unidades de un número
natural.
32. Desarrollar una solución que permita ingresar el nombre del alumno, el tipo de participante
(profesor, alumno y externo) y el nivel de curso (básico, intermedio y avanzado). En la tabla que se
muestra a continuación se detallan los costos de los cursos:
BÝ®Ê IÄãÙÃ®Ê AòÄþÊ

PÙÊ¥ÝÊÙ 35 40 45
A½çÃÄÊ 40 50 60
EøãÙÄÊ 60 80 100
Mostrar los datos del recibo, tal como se muestra en el siguiente ejemplo:
RECIBO
Alumno Juan Pérez
Costo (de acuerdo a la tabla)
Nivel (de acuerdo al ingresado)
33. Desarrollar una solución que permita ingresar el sueldo de un trabajador. Calcular y mostrar su
aumento por incremento del costo de vida, de acuerdo a la siguiente tabla:
CÊÄ®®ÌÄ AçÃÄãÊ
Sueldo < 2000 23 %
2000>=Sueldo<=3000 17 %
Sueldo > 3000 12 %
34. Desarrollar una solución que permita ingresar la temperatura promedio (tp) de un día y mostrar
el tipo de clima, de acuerdo a la siguiente tabla:
TÃÖÙãçÙ (ãÖ) T®ÖÊ ½®Ã
tp <= 9 Frío
9 >= tp <=17 Nublado
17 >= tp <= 27 Caluroso
tp > 27 Tropical
35. Desarrollar una solución que permita ingresar una fecha en el siguiente formato: (dd/ mm/ aaaa).
Luego, calcular el número de días que tiene el mes y si el año es bisiesto o no.
36. Desarrollar una solución que calcule el sueldo de un obrero por un día, ingresando el número de
horas trabajadas y la categoría. Mostrar el sueldo y la categoría de acuerdo a la siguiente tabla:
Cã¦ÊÙ° Sç½Ê
1 horas * 300
2 horas * 450
3 horas * 500
37. Desarrollar una solución que permita mostrar el precio de un sándwich y el tipo. Luego ingrese la
categoría del sándwich:
Cã¦ÊÙ° T®ÖÊ PÙ®Ê
1 Triple S/. 4
2 Mixto S/. 6
3 Pollo S/. 2
4 Hamburguesa S/. 10
38. Desarrollar una solución que permita calcular y mostrar el precio de distintos autos, sabiendo que
se debe agregar el I.G.V. = 18 %. Tomar en cuenta la siguiente información:
MÙ MÊ½Ê PÙ®Ê

Tercel $. 3500
Toyota Yaris $. 6000
Canry $. 10 000
Sentra $. 4000
Nissan Primera $. 5000
Pulser $. 4000
39. Desarrollar una solución que permita calcular y mostrar el descuento de un televisor según su
marca.
MÙ PÙ®Ê DÝçÄãÊ
Samsung $. 500 10 %
Sony $. 1000 5%
LG $. 900 8%
Philips $. 800 10 %
40. Desarrollar una solución que permita calcular el monto a pagar por la compra de un producto,
considerando un descuento del 13 % por la compra de más de 200 unidades.
41. Desarrollar una solución que permita ingresar tres números; calcular la suma y resta, y mostrar si
la suma es par o impar y si la resta es múltiplo de 3. Luego desarrollar una solución que permite
ingresar tres números, calcular su suma y resta. Finalmente, comprobar si la suma es par o impar
y si la resta es múltiplo de 3.
42. Desarrollar una solución que permita calcular la ganancia total por la venta de cierta cantidad
de helados en un día, si su costo de producción es el 55 % del precio de venta. Los precios se
muestran en la siguiente tabla:
T®ÖÊ PÙ®Ê
Fresa S/. 0.50
Lúcuma S/. 0.70
Mango S/. 0.50
43. En una pizzería se venden pizzas de cinco tamaños:
T®ÖÊ TÃÇÊ (®ÃãÙÊ)

Pequeña 10 pulg.
Mediana 12 pulg.
Grande 14 pulg.
Familiar 16 pulg.
Extra grande 18 pulg.
Si se cobra S/. 2 por cada ingrediente extra y el precio de la pizza sencilla es calculado por 1.5 *
diámetro. Desarrollar una solución que permita calcular y mostrar el precio total de una pizza,
ingresando el tipo y el número de ingredientes extras.
44. En un cine se cobran las entradas según la categoría:

Cã¦ÊÙ° CÊÝãÊ
1 Adultos S/. 12
2 Niños S/. 10
3 Mayores de 60 S/. 9
Desarrollar una solución que calcule y muestre el precio de entrada ingresando la categoría.
Además, tener en cuenta que los días martes se cobra un 50 % más.
45. Desarrollar una solución que solicite un año e indique si es bisiesto o no. Un año es bisiesto si es
múltiplo de 4, excluyendo aquellos que son múltiplo de 100 y no de 400.
||Los años exactamente divisibles entre 4 son años bisiestos.
||Los años exactamente divisibles entre 100 no son años bisiestos.
||Los años exactamente divisibles entre 400 son años bisiestos.
46. Desarrollar una solución que permita calcular el área de un trapecio y mostrar un mensaje si el
área es mayor de 400; además, indicar si el área es par o impar. Ingresar las bases y la altura del
trapecio a tráves del teclado.
47. Desarrollar una solución que muestre el “Ku” e indicar qué tipo de curva representa:
Kç T®ÖÊ çÙò
Ku < 0.25 Platicúrtica
Ku = 0.25 Mesocúrtica
Ku > 0.25 Leptocúrtica
Ingresar a tráves del teclado los datos necesarios para la aplicación de la fórmula:
Ku = (Q3 – Q1) / 2*(D9 – D1)
48. Desarrollar una solución que permita mostrar el Skp (coeficiente de asimetría), y si la curva es
simétrica o asimétrica, y de qué tipo, si:
S»Ö AÝ®ÃãÙ°
Skp < 0 Asimet. a la izq.
Skp = 0 Simétrica
Skp > 0 Asimet. a la der.
Ingrese a tráves del teclado el promedio (X), la mediana (Me) y la desviación estándar (S) para
aplicar la formula:
Skp = 3(X – Me) / S
49. Desarrollar una solución que permita calcular el mayor de dos números ingresados a través del
teclado; además, mostrar un mensaje que muestre el número mayor.
50. Desarrollar una solución que permita calcular el promedio de un alumno. Luego, mostrar el
mensaje de aprobado (prom>=11) o desaprobado (prom<=11), teniendo en cuenta la siguiente
fórmula:
prom = (n1 + n2 + n3 + 2*n4) / 5
51. Desarrollar una solución en la cual se pueda ingresar y mostrar el precio de un artículo, si el precio
de dicho artículo es mayor a S/. 70.00 nuevos soles, mostrar el siguiente mensaje: “Te ganaste
una mochila”, de lo contrario mostrar el mensaje: “Te llevas una cartuchera”.
52. Desarrollar una solución que permita calcular y mostrar la suma de los 100 primeros números
enteros consecutivos, teniendo en cuenta la siguiente fórmula:
suma = n * ( n + 1 ) / 2
Además, mostrar un mensaje que se lea si la suma es par o no.

53. Desarrollar una solución que permita calcular un descuento del 10 % en las entradas a un
concierto, en caso de que el cliente compre más de tres entradas. Ingresar el costo de la entrada
y el número de entradas que el cliente desea comprar.
54. Desarrollar una solución que permita aumentar el salario de un empleado, en base a la siguiente
información:
S½Ù®Ê AçÃÄãÊ
0 a 500 soles 15 %
501 a 1000 soles 12 %
1001 a 2000 10 %
Más de 2000 5%
Calcular y mostrar el aumento correspondiente, así como el nuevo salario del empleado.
55. Desarrollar una solución que permita ingresar tres números enteros. Luego mostrar el menor
número, y si este es capicúa o no.
56. Desarrollar una solución que permita ingresar la categoría y el sueldo de un trabajador. Calcular
el aumento correspondiente, teniendo en cuenta la siguiente tabla. Mostrar la categoría del
trabajador y su nuevo sueldo.
1 30 %
2 25 %
3 20 %
4 10 %
57. Desarrollar una solución que permita ingresar cinco números impares, luego determinar si su
suma es par o impar, y si es múltiplo de 5.
58. Desarrollar una solución que permita introducir el promedio de un alumno ingresante y clasificarlo
según la siguiente información:
RÄ¦Ê ÖÙÊÃ®Ê Aç½

prom >= 17 101
14 <= prom < 17 102
11 <= prom < 14 103
prom < 11 104
59. Desarrollar una solución que permita ingresar el nombre de una tienda, el costo total de compra y
el monto total de venta de todos sus productos. Entonces, calcular la ganancia total, y de acuerdo
a esto clasificar a la tienda, teniendo en cuenta la siguiente información:
VÄãÝ T®ÖÊ
Gan >= 3000 A1
1000 <= Gan <3000 B
Gan <1000 C
60. Desarrollar una solución que permita controlar las ventas de entradas de un teatro que atiende
solo los días viernes, sábados y domingos, y cuenta con tres localidades (palco, platea y mezanine).
Tener en cuenta las siguientes tablas:
D° DÝçÄãÊ
Viernes 10 %
Sábado 5%
Domingo 3%
LÊ½® PÙ®Ê ÙçãÊ

Palco 80
Platea 60
Mezanine 50
Finalmente, mostrar el precio neto a pagar, dependiendo el día y la localidad. Según la siguiente
formula:
Precio Neto = Precio Bruto – Descuento
para un hospital de acuerdo al tipo de enfermedad, según los datos de la tabla. Adicionalmente,
se debe considerar que las mujeres mayores de 18 años tienen un incremento del 19 % para la
enfermedad tipo 1 y los hombres tienen un aumento del 4 % para la tipo 3, si son menores de
edad, y del 10 % en caso contrario.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ®Ù®Ê

1 180
2 420
3 513
para un hospital de acuerdo al tipo de enfermedad, según los datos de la tabla. Adicionalmente,
debe considerar que los pacientes menores de edad tienen un descuento especial de acuerdo al
tipo de enfermedad, según se muestra en la tabla.
EÄ¥ÙÃ ã®ÖÊ CÊÝãÊ ®Ù®Ê % DÝçÄãÊ

1 123 10 %
2 234 15 %
3 345 20 %
4 567 25 %
63. Desarrollar una solución que permita ingresar el tipo de sangre de una persona y mostrar un
mensaje de acuerdo al siguiente cuadro:
T®ÖÊ MÄÝ¹
O+ Compatible
O- Incompatible
64. Desarrolle una solución que permita ingresar la edad de una persona y determine cuál es su
empleo más adecuado para dicha persona, teniendo en cuenta la siguiente información:
E EÃÖ½Ê
19 - 23 Recepcionista
23 - 25 Secretaria
25 - 30 Ejecutivo de Ventas
65. Desarrollar una solución que permita ingresar el promedio ponderado de un alumno. Si el
promedio es mayor a 16, mostrar un mensaje que se lea: “El alumno obtuvo una beca integral”.
66. Desarrollar una solución que permita ingresar el costo y el precio de venta de una computadora
portátil. Si un cliente compra más de tres computadoras se le otorgará un descuento del 10 %
sobre el precio de venta. Calcular y mostrar el monto que tiene que pagar el cliente al realizar la
compra, y cuál será la ganancia del vendedor.
67. Desarrollar una solución que permita ingresar tres números enteros. Calcular y mostrar la suma
y resta de los números; además, restar los resultados de la suma y resta. Si este resultado sale
negativo mostrar el mensaje: “Error”; de lo contrario, mostrar el resultado junto con el mensaje:
“La operación se realizó con éxito”.
68. Desarrollar una solución que permita anotar los ingresos y egresos que ha tenido una empresa.
Determinar si tiene o no estabilidad, sabiendo que si su ganancia es mayor o igual a s/.10.00
Nuevos Soles la empresa tiene estabilidad. Si tiene estabilidad mostrar el mensaje: “La empresa
califica internacionalmente”, en caso contrario no califica.
69. Desarrollar una solución que permita ingresar la cantidad de cd vendidos en una tienda y
distribuirlos según los géneros: pop, latin, hip-hop, rock; el que tenga la cantidad más alta de cd
vendidos será mostrado por un mensaje que diga: “Este género está de moda”.
70. En una tienda de muñecos de peluche se realizan descuentos y obsequian artículos según el
tamaño de los muñecos. Desarrollar una solución que permita ingresar el tamaño y el precio
de un peluche. Finalmente, calcular el descuento y determinar el regalo que obtiene el cliente,
teniendo en cuenta la siguiente información:
P½ç«Ý
Cã¦ÊÙ° DÝçÄãÊ R¦½Ê
Pequeño 7% Una bolsa de regalo
Mediano 15% Un llavero
Grande 23% Un peluche pequeño
71. Desarrollar una solución que permita ingresar el nombre y el promedio de tres alumnos de un
salón de clase, y determinar quién es el alumno que tiene el mayor promedio. Luego, mostrar el
nombre del alumno que tiene el mayor promedio junto con un mensaje de felicitaciones.
72. En la clínica “La Buena Salud” se internan diariamente muchas personas. Desarrollar una solución
que permita calcular el costo total de un paciente internado en dicha clínica, teniendo en cuenta
el total de días y el costo de la habitación. Este último se determina en base al área de ubicación
de la misma, de acuerdo a la siguiente información:
CLÍNICA “L BçÄ S½ç”

ÁÙ CÊÝãÊ
1 250
2 180
Otra 120
73. Desarrollar una solución que permita ingresar tres números. Multiplicar los números y mostrar el
resultado. Adicionalmente, si el resultado es múltiplo de seis, realizar dos saltos de línea y mostrar
el mensaje: “El resultado es un número múltiplo de seis”.
74. Desarrollar una solución que permita ingresar el precio de un artículo; si este es mayor a S/.
100.00 nuevos soles, mostrar un mensaje indicando que el artículo está de oferta.
75. Desarrollar una solución que permita retirar dinero del cajero de un banco; si el monto a retirar
es mayor a S/. 1000.00 nuevos soles, mostrar el mensaje “Se pasó del límite”; de lo contrario se
mostrará el mensaje “Gracias por usar nuestros servicios”
76. En una farmacia se desea comprar un fármaco. En caso de que no hay stock de ese producto
mostrar el mensaje “Agotado”; de lo contrario, se mostrará el precio del fármaco. El precio será
ingresado por teclado.
77. En una farmacia se desea comprar un fármaco. Si el fármaco se agotó mostrar el mensaje:
“Agotado”, de lo contrario, se mostrará el precio del fármaco. El cual será ingresado a tráves del
teclado. Adicionalmente, si el precio del fármaco es mayor a S/. 128 nuevos soles y el cliente
decide comprarlo se le otorgará un descuento del 3.0 %. Mostrar el descuento y el monto a pagar.
78. En una fábrica de artículos se realiza un análisis de control de calidad de piezas; si el número de la
serie de la pieza se encuentra entre los siguientes rangos de valores 146 – 156, 700 – 799 y 888 –
911 se dirá que la pieza es “defectuosa”, caso contrario se dirá que es “correcta”. Adicionalmente,
en caso que la pieza fuera correcta, determinar y mostrar si el número de la serie es un número
par o impar.
79. Una fotocopiadora permite obtener copias al por mayor según la tabla siguiente:
CÊÖ®Ý SÊ½Ý
De 1 a 10 0.10
De 11 a 50 0.05
De 50 a100 0.04
Mad de 100 0.03
Ingresar el número de hojas que el cliente necesita fotocopiar y mostrar el monto total a pagar.
Tener en cuenta lo siguiente:
monto = numCopias x soles
80. Desarrollar una solución que lea un número entero de tres cifras, luego mostrar el menor número
y el mayor número posible de dos cifras que se puedan formar empleando la cifra mayor y la cifra
menor del número ingresado.
CAP.
E st r u c t u r a s l ó g i c a s d e
c o n t ro l o r e p et i c i ó n
4
CAP. 4: ESTRUCTURAS LÓGICAS DE CONTROL O REPETICIÓN 283
El presente capítulo explica en detalle las estructuras lógicas de repetición. Es importante mencionar
que, utilizando las estructuras lógicas de repetició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. Se emplearán las técnicas para el ingreso de datos y visualización de la
información, utilizando la consola (solo caracteres) y las que emplean cuadros de diálogo.

DEL
PROBLEMA
Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
ALGORITMO Solución
PROGRAMACIÓN
PROYECTO
MODELAMIENTO
CODIFICACIÓN
dominioDeLaAplicación biblioteca
Nombre
Clase
Atributos
ALGORITMO
Método ( ) Sentencias
Descripción de Declaración y
datos definición de datos
- Estructuras lógicas de secuencia
- Estructuras lógicas de decisión
- Estructuras lógicas de repetición
ALMACENADOS EN:
- Estructuras de datos variable
}|Contadores
}|Acumuladores
}|Centinelas
Por otro lado, se tratará sobre las estructuras lógicas de repetición, su diseño en algoritmos y su
codificación en un lenguaje de programación. Es importante indicar que el dominio de las estructuras
lógicas de secuencia y de decisión tratadas en los capítulos anteriores son indispensables para iniciar
el estudio del presente capítulo.
En el desarrollo de las primeras setenta soluciones se podrá apreciar el uso de las estructuras
lógicas de repetición HACER, MIENTRAS y DESDE o PARA; cómo se diseñan los algoritmos utilizando
pseudocódigo y/o diagrama de flujo, y cómo se codifican en el lenguaje de programación C++ y/o Java.
Esto permite comprender los aspectos fundamentales del desarrollo de soluciones utilizando este tipo
de estructuras lógicas.
En el desarrollo de las siguientes cinco soluciones se diseñan algoritmos con el diagrama de actividades,
y se codifican en el lenguaje de programación Java, utilizando para ello la clase reutilizable LE. En
esta parte se utilizan métodos complementarios de la clase LE, que permiten plantear soluciones más
vistosas y mucho más amigables para el usuario, a tráves del uso de cuadros de diálogo.
4.
4.1 MÉTODO DE LAS 6’D - DESARROLLO DE SOLUCIONES CON DOS PAQUETES

ENUNCIADO
DEL
PROBLEMA

MODELAMIENTO CODIFICACION
}|Determinar los }|Definir los paquetes el lenguaje de
datos de entrada y desarrollar programación C++
(entrada). el diagrama de o Java.
}|Establecer cómo paquetes respectivo.
se solucionará Establecer la
el problema dependencia. Utilice
(proceso). UML.
que serán parte
de la solución del
problema. Utilice
UML.
ALGORITMO
para el método
principal. Utilizar
pseudocódigo o
diagrama de flujo.
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
4.2 ESTRUCTURAS LÓGICAS DE REPETICIÓN

Las estructuras lógicas de repetición son construcciones que permiten repetir determinadas
secuencias de una solución, de tal forma que en función de una condición o el valor de una variable,
un conjunto de instrucciones pueda ser repetido un determinado número de veces.
}|Mapa de estructuras lógicas de repetición

Utilizando las estructuras lógicas de repetición se pueden desarrollar algoritmos complejos, de
manera que puedan ser diseñados en pseudocódigo o diagrama de flujo, para luego ser codificados
en un lenguaje de programación.
Estructuras lógicas de repetición
Estructura lógica Estructura lógica Estructura lógica

de repetición 1 de repetición 2 de repetición 3
“HACER” “MIENTRAS” “DESDE” o “PARA”
}|Mapa de estructuras lógicas detallado

“LEER” “SI” “DESDE” (*) “TERMINAR”
“ESCRIBIR” “SI/NO” “MIENTRAS” “CONTINUAR”
“PROCESAR” “CUANDO” “HACER” “RETORNAR”

“SI ANIDADOS”
(*) En forma equivalente a la regla DESDE se utiliza también la regla PARA.

4.2.1 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
estudiarán más adelante en este capítulo). Dichas variables pueden asumir la función de contador,
acumulador o centinela. La función que pueda asumir una variable dependerá de la forma como se
plantee la solución para un determinado problema.
A. Contadores: Un contador es una variable cuyo valor se incrementa o disminuye 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.
B. Acumuladores: Un acumulador o totalizador es una variable cuya función consiste en almacenar un
valor como resultado de sumas o restas sucesivas. Asimismo, realiza la función de un contador, con
la diferencia de que el incremento o decremento no es una cantidad fija sino una cantidad variable.
C. Centinelas: Un centinela (denominado también interruptor, conmutador, 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 la variable centinela, 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 centinela.
4.2.2 Estructura lógica de repetición: “HACER”
A. Definición: Una estructura de repetición “HACER”, al igual que una estructura de repetición “DESDE”
y una estructura de repetición “MIENTRAS” (las cuales se estudiarán más adelante), permiten
repetir una instrucción o un bloque de instrucciones mientras que una condición se cumpla o sea
verdadera.
La principal diferencia entre una estructura de repetición HACER y una estructura de repetición
MIENTRAS, consiste en que el bucle “MIENTRAS” 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. Los bucles “HACER” ejecutan 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 dicha instrucción o bloque por
lo menos una vez.
B. Representación
En pseudocódigo:
HACER
instruccion 1
.
.
.
instruccion n
MIENTRAS (condicion)
Explicación:
Cuando se ejecuta la estructura 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 instrucción
MIENTRAS, etiquetada con la palabra (condición).
Una vez evaluada la condición lógica, se pueden 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 HACER... MIENTRAS, y se evalúa nuevamente la
condición lógica.
Si al evaluar la condición lógica esta resulta falsa, se continúa con la ejecución del algoritmo.
Esto significa que la estructura 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 esta 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.
Los equivalentes de esta estructura en el diagrama de flujo se muestran a continuación. Observe dónde
se ubican la condición lógica y los flujos “VERDADERO” y “FALSO”.
...
instrucciones
...
condición
VERDADERO FALSO
Fig. 4.1
...
instrucciones
...
VERDADERO
condición
FALSO
Fig. 4.2
...
instrucciones
...
VERDADERO
condición
FALSO

do {
sentencias ...
} while ( condición ) ;
Explicación:
En C++ y Java, la estructura de repetición 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 la estructura se vuelve a ejecutar o no.
Esta condición lógica constituye la prueba en Java y en C++. Si la condición es verdadera, se vuelven a
ejecutar las instrucciones o bloque de instrucciones que pertenecen a la estructura de repetición; en
el caso que sea falso, se finaliza la ejecución de la estructura y se continúa con la siguiente sentencia.
Es importante indicar que el inicio y el final del do se representa con llaves ( { } ).

Problema 061
Enunciado: Ingrese un número entero positivo y determine si el número ingresado es múltiplo de 5.

Consistencie la entrada de datos (el número ingresado deberá ser mayor que cero).
A. Resultado deseado: Mostrar si el número es multiplo de 5.

B. Datos necesarios: El número entero positivo.
C. Procesamiento: El número entero positivo será almacenado en una variable (numero);
luego se realizará la validación utilizando la estructura do - while.
Si el número es menor que cero se mostrará un mensaje de error; de
lo contrario, se verificará si el número es múltiplo de cinco utilizando la
siguiente fórmula:
numero % 5
El resultado se almacenará en una variable (mensaje). Finalmente, se

mostrará el resultado.
1. Nombre del proyecto: ProyMulƟploCinco

Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgMultiploCinco
|leerChar ( )
|main () |leerInt ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgMulƟploCinco – main ( )
ENTRADA: numero
SALIDA: mensaje
INICIO
NUMERO numero
TEXTO mensaje = “”
HACER
LEER numero
SI ( numero <= 0 )
ENTONCES
ESCRIBIR “Error, ingrese un número entero mayor que 0 ”
FINSI
MIENTRAS ( numero <= 0 )
SI ( numero % 5 == 0 )
ENTONCES
mensaje = “El número: ” + numero + “ es múltiplo de 5. ”
SINO
mensaje = “El número: ” + numero + “ no es múltiplo de 5. ”
FINSI
ESCRIBIR mensaje
FIN
INICIO
NUMERO numero
numero
VERDADERO
numero < 1
“Error ingrese un
número mayor
que 0”
FALSO
"error"
numero < 1
VERDADERO
FALSO
FALSO VERDADERO
numero % 5 == 0
mensaje = “El mensaje = “El

número no es número es múltiplo
múltiplo de 5” de 5”
mensaje
FIN
#include <iostream>
int main ( ) {
int numero ;
string mensaje = “” ;
do {
cout << “ Ingrese un número entero positivo: ” ;
cin >> numero ;
if ( numero < 1 ) {
cout << “ Error, ingrese número mayor que 0 ” << “\n\n” ;
}
} while ( numero < 1 ) ;
if ( numero % 5 == 0 ) {
mensaje = “ El número es múltiplo de 5 ” ;
} else {
mensaje = “ El número no es múltiplo de 5 ” ;
}
cout << mensaje << endl << endl ;
return 0 ;
}
Clase PrgMulƟploCinco
class PrgMultiploCinco {
int numero ;
String mensaje ;
do {
System.out.print ( “ Ingrese un número entero positivo: ” ) ;
if ( numero < 1 ) {
System.out.println (“ Error,ingrese número mayor que 0” + “\n”) ;
}
} while ( numero < 1 ) ;
if ( numero % 5 == 0 ) {
mensaje = “ El número es múltiplo de 5 ” ;
} else {
mensaje = “ El número no es múltiplo de 5 ” ;
}
}
}
Problema 062
Enunciado: Ingrese el precio de compra y venta de un determinado producto. Calcule y muestre su

utilidad, sabiendo que:
utilidad = precio de venta – precio de compra.
Consistencie la entrada de datos (precio de compra mayor que cero y precio de venta mayor que
precio de compra).
A. Resultado deseado: Mostrar la utilidad.

B. Datos necesarios: El precio de compra y el precio de venta del producto.
C. Procesamiento: El precio de compra y el de venta serán almacenados en variables (pC y
pV respectivamente); luego se realizará la validación y, si el precio de
compra es menor que cero o mayor que el precio de venta, entonces se
mostrará un mensaje de error y luego se realizará el cálculo de la utilidad
utilizando la siguiente fórmula:
utilidad = pV – pC
El resultado será almacenado en una variable (uƟlidad), para finalmente

ser mostrado a tráves de la pantalla.
1.- Nombre del proyecto: ProyUƟlidad

2.- Definición de paquetes y diagrama de paquetes
Diagramas de paquetes
3.- Definición de clases
Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgUtilidad
|leerChar ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )
En pseudocódigo:
Algoritmo PrgUƟlidad – main ( )
ENTRADA: pC, pV
SALIDA: utilidad
INICIO
REAL pC , pV , utilidad
HACER
LEER pC
SI ( pC <= 0 ) ENTONCES
ESCRIBIR “ El precio de compra debe ser mayor que 0. Vuelva a ingresarlo.”
FINSI
MIENTRAS ( pC <= 0 )
HACER
LEER pV
SI ( pC >= pV ) ENTONCES
ESCRIBIR “ El precio de venta debe ser mayor que el precio de compra.
Vuelva a ingresarlo.”
FINSI
MIENTRAS ( pC >= pV )
utilidad = pV - pC
ESCRIBIR utilidad
FIN
INICIO
REAL pC, pV, utilidad
pC
VERDADERO
pC <= 0
FALSO
“error”
pC <= 0
VERDADERO
O
FALSO
pV
VERDADERO
pV <= pC
FALSO
“error”
pV <= pC
VERDADERO
O
FALSO
A
utilidad = pV - pC
utilidad
FIN
Clase PrgUƟlidad
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double pC , pV , utilidad ;
do {
cout << “ Ingrese el precio de compra: ” ;
cin >> pC ;
if ( pC <= 0 ) {
cout << “ El precio de compra debe ser mayor que 0.
Vuelva a ingresarlo.” << endl ;
}
} while ( pC <= 0 ) ;
do {
cout << “ Ingrese el precio de venta: ” ;
cin >> pV ;
if ( pV <= pC ) {
cout << “ El precio de venta debe ser mayor que el
precio de compra. Vuelva a ingresarlo.” ;
cout << endl << endl ;
}
} while ( pV <= pC ) ;
utilidad = pV - pC ;
cout << endl ;
cout << “ La utilidad es: ” << utilidad << endl << endl ;
return 0 ;
}

Problema 063
Enunciado: Ingrese el nombre de una persona. Muestre la primera y última letra del nombre
ingresado, luego consistencie la entrada de datos (el nombre debe tener una longitud mayor a 1).
A. Resultado deseado: Mostrar primera y última letra del nombre ingresado.

B. Datos necesarios: Nombre de una persona.
C. Procesamiento: El nombre será ingresado y almacenado en una variable tipo cadena (nombre).
Se validará el tamaño de la cadena ingresada, de tal forma que sea mayor

que 1. Finalmente, se mostrará la primera y la última letra del nombre
ingresado, previamente almacenados en variables (primeraLetra y
ulƟmaLetra).
1.- Nombre del proyecto: ProyNombre

2.- Definición de paquete y diagrama de paquetes
3.- Definición de clases

Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgNombre
|leerChar ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )
4.- Diseño del algoritmo

En pseudocódigo:
Algoritmo PrgNombre – main ( )
ENTRADA: nombre
SALIDA: primeraLetra, ultimaLetra
INICIO
TEXTO nombre
CARACTER primeraLetra , ultimaLetra
HACER
LEER nombre
SI ( LONGITUD nombre <= 1 )

ENTONCES
ESCRIBIR “Ingresar un nombre con más de un caracter ”
FINSI
MIENTRAS ( LONGITUD nombre <= 1 )
primeraLetra = nombre CARACTER 0

ultimaLetra = nombre CARACTER ( LONGITUD nombre - 1 )
ESCRIBIR “La primera y última letra del nombre: ” + nombre + “ son: ”

+ primeraLetra + “ y ” + ultimaLetra
FIN
|Observe el uso de las pautas o reglas del pseudocódigo y diagrama de flujo, que permiten
manipular caracteres y cadenas de texto. En el capítulo uno, puede observar el uso de dichas
pautas o reglas.
Algoritmo PrgNombre – main ( )
INICIO
TEXTO nombre
CARACTER primeraLetra , ultimaLetra
NUMERO lon
nombre
lon = LONGITUD nombre
VERDADERO
nombre
FALSO “error”
lon <= 1
VERDADERO
O
FALSO
primeraLetra = nombre CARACTER 0

ultimaLetra = nombre CARACTER ( lon - 1 )
nombre,
primeraLetra ,
ultimaLetra
FIN
Clase PrgNombre
class PrNombre {
String nombre ;
char primeraLetra , ultimaLetra ;
do {
System.out.print ( “ Ingrese su nombre: ” ) ;

nombre = nombre.trim ( ) ;
if ( nombre.length ( ) <=1 ) {
System.out.println ( “ Ingresar un nombre con más de
un caracter ” ) ;
}
} while ( nombre.length ( ) <= 1 ) ;
primeraLetra = nombre.charAt ( 0 ) ;
ultimaLetra = nombre.charAt ( nombre.length ( ) - 1 ) ;
System.out.println ( “ La primera y última letra del nombre: ” +
nombre + “ son: ” + primeraLetra + “ y ” + ultimaLetra ) ;
}
}
|Observe el uso de los métodos trim ( ), length ( ) y charAt ( ) de la clase String de Java. La clase
String de Java no es tratada en el presente libro; sin embargo, dicha información la podrá encontrar
en la página web de los autores.
Problema 064
Enunciado: Desarrolle un menú de opciones con lo siguiente:
[1] Ingresar un número

[2] Mostrar si el número es múltiplo de 3
[3] Finalizar
A. Resultado deseado: Mostrar si un número es múltiplo de 3.

C. Procesamiento: El número será ingresado y almacenado en una variable entera (numero).
Con la finalidad de determinar si el número es múltiplo de 3, se utilizará la
siguiente formula:
numero RESTO 3 = 0
Finalmente, se mostrará un mensaje indicando si el número ingresado es

o no múltiplo de 3.
1.- Nombre del proyecto: ProyNombre

2.- Definición de paquete y diagrama de paquetes
Intente desarrollar la definición de clases.
3.- Diseño del algoritmo

En pseudocódigo:
Algoritmo PrgMulƟploTres – main ( )
ENTRADA: opc , num

SALIDA:
INICIO
NUMERO opc , num = 0
HACER
LEER opc
CUANDO (opc) SEA
CASO 1 :
HACER
LEER num
SI ( num <= 0 ) ENTONCES

ESCRIBIR “ Ingrese un número mayor que cero ”
FINSI
MIENTRAS ( num <= 0 )
TERMINAR
CASO 2 :
SI ( num RESTO 3 == 0 ) ENTONCES
ESCRIBIR “ El número es múltiplo de 3 ”
SINO
ESCRIBIR “ El número no es múltiplo de 3 ”
FINSI
TERMINAR
CASO 3 :
ESCRIBIR “ Hasta luego ”
TERMINAR
OTROS :
ESCRIBIR “ Opción incorrecta... Reintente !!! ”
FINCUANDO
MIENTRAS ( opc != 3 )
FIN
Algoritmo PrgMulƟploTres – main ( )
MENU
INICIO [1] Ingresar un número
[2] Mostrar si el número
es múltiplo de 3
[3] Finalizar
NUMERO opc , num = 0 , res
opc
opc
1 2 3 OTROS
res = num RESTO 3 “Fin” “Error”
num VERDADERO
res == 0
VERDADERO FALSO
“si es múltiplo
num <= 0 de 3”
FALSO
“Error”
“no es múltiplo
de 3”
num <= 0
VERDADERO
FALSO
opc <> 3
VERDADERO
FALSO
FIN
Clase PrgMulƟploTres
#include <iostream>
int main ( ) {
int opc , num = 0 ;
do {
cout << “ \n\n-----MENU-----\n” ;
cout << “ [1] Ingresar un número \n” ;
cout << “ [2] Mostrar si el número es múltiplo de 3 \n” ;
cout << “ [3] Finalizar\n\n Seleccione su opción: ” ;
cin >> opc ;
switch ( opc ) {
case 1 :
do {
cout << “ Ingrese un número ” ;
cin >> num ;
if ( num <= 0 ) {
cout << “ Ingrese un número mayor que 0 ” << endl ;
}
} while ( num <= 0 ) ;

break ;
case 2 :
if ( num % 3 == 0 ) {
cout << “ El número ” << num << “ es múltiplo de 3 ” ;
} else {
cout << “ El número ” << num << “ no es múltiplo de 3 ” ;
}
break ;
case 3 :
cout << “ Hasta luego...” << endl ;
break ;
default :
cout << “ Opción incorrecta. Reintente!!! ” << endl ;
}
} while ( opc != 3 ) ;
cout << endl ;

return 0 ;
}
Clase PrgMulƟploTres
class PrgMultiploTres {
int opc , num = 0 ;

boolean valida = false ;
do {
System.out.println ( “ \n\n-----MENU----- ” ) ;
System.out.println ( “ [1] Ingresar un número ” ) ;
System.out.println ( “ [2] Mostrar si el número es múltiplo de 3 ” );
System.out.print ( “ [3] Finalizar\n\n Seleccione su opción: ” ) ;
opc = Lectura.leerInt ( ) ;
switch ( opc ) {
case 1 :
do {
num = Lectura.leerInt ( ) ;
if ( num <= 0 ) {
System.out.println ( “ Ingrese número mayor que 0: ” ) ;
}
} while ( num <= 0 ) ;

break ;
case 2 :
if ( num % 3 == 0 ) {
System.out.println ( “ El número es múltiplo de 3 ” ) ;
} else {
System.out.println ( “ El número no es múltiplo de 3 ” ) ;
}
break ;
case 3 :
System.out.println ( “ Hasta luego... ” ) ;
break ;
default :
System.out.println (“ Opción incorrecta. Reintente!!!!”);
}
} while ( opc != 3 ) ;
}
}
Problema 065
Enunciado: Desarrolle un menú con las siguientes opciones:
[1] Ingresar un nombre

[2] Mostrar la primera letra del nombre en mayúscula
[3] Finalizar
En la solución de este problema, deberá evitar que el usuario seleccione la opción 2 sin antes haber
seleccionado la opción 1.
Defina el nombre del proyecto y luego desarrolle la definición de paquetes, el diagrama de paquetes

En pseudocódigo:
Algoritmo PrgMenu – main ( )
ENTRADA: opc , nombre

SALIDA: letra
INICIO
ENTERO opc
TEXTO nombre = “” , letra
LOGICO valida = FALSO
HACER
LEER opc
CUANDO (opc) SEA
CASO 1 :
HACER
LEER nombre
SI ( LONGITUD nombre <= 1 ) ENTONCES

ESCRIBIR “ El nombre ingresado no es válido ”
FINSI
MIENTRAS ( LONGITUD nombre <= 1 )

nombre = MAYUSCULA nombre
letra = nombre SUBCADENA (0 , 1)
valida = VERDADERO
TERMINAR
CASO 2 :
SI ( valida ) ENTONCES
ESCRIBIR “ La primera letra en mayúscula es: ” + letra
SINO
ESCRIBIR “ Ingrese primero la opción 1”
FINSI
TERMINAR
CASO 3 :
ESCRIBIR “ Hasta luego ”
TERMINAR
OTROS :
ESCRIBIR “ Opción incorrecta... Reintente! ”
FINCUANDO
MIENTRAS ( opc <> 3 )
FIN
|Observe el uso de las pautas o reglas del pseudocódigo y diagrama de flujo que permiten manipular
caracteres y cadenas de texto. En el capítulo uno, puede observar el uso de dichas pautas o reglas.
|Observe el uso de la variable denominada “valida”. Dicha variable está actuando como un
centinela.
INICIO
TEXTO nombre = “”, letra

LOGICO valida = FALSO
ENTERO lon, opc
A
MENU
A [1] Ingresar un nombre
[2] Mostrar la primera letra
del nombre en mayúscula
[3] Finalizar
opc
opc
1 2 3 OTROS
“Fin” “Error”
VERDADERO
Ingreso
num de valida
datos
FALSO
letra
nombre = MAYUSCULA nombre
letra = nombre SUBCADENA (0,1)
“Error”
valida = VERDADERO
opc <> 3
VERDADERO
FALSO
FIN
Ingreso
de datos
nombre
lon = LONGITUD nombre
VERDADERO
lon <= 1
FALSO “Error”
lon <= 1
VERDADERO
FALSO
|Observe el uso del siguiente símbolo:
Ingreso
de datos
Este símbolo permite la ejecución de una parte de un algoritmo que ha sido diseñado en otro lugar,
con la finalidad de hacer más claro y legible el diagrama de flujo respectivo.
También es utilizado para la ejecución de procesos predefinidos, es decir, para la ejecución de otros
algoritmos. La forma de utilizar este símbolo no será tratada en el presente texto.
Clase PrgMenu
#include <iostream>
#include <string>
using std::cout ;
using std::endl ;
using std::cin ;
using std::string ;
int main ( ) {
int opc ;
string nombre = “” , letra ;
bool valida = false ;
do {
cout << “ \n\n -----MENU-----\n ” ;
cout << “[1] Ingresar un nombre \n ” ;
cout << “[2] Mostrar la primera letra en mayúscula \n ” ;
cout << “[3] Finaliza ” << endl ;
cin >> opc ;
switch ( opc ) {
case 1 :
do {
cout << “Ingrese un nombre: ” ;
cin >> nombre ;
if ( nombre.length() <= 1 ) {
cout << “El nombre no es válido ” << endl ;
}
} while (nombre.length() <= 1 ) ;
nombre = nombre.toUpperCase( ) ;
letra = nombre.substring ( 0,1 ) ) ;
valida = true ;
break ;
case 2 :
if ( valida ) {
cout << “ La primera letra en mayúscula es: ”
<< letra << endl ;
} else {
cout << “ Ingrese primero la opción 1 ” << endl ;
}
break ;
case 3 :
cout << “ Hasta luego... ” ;
break ;
default :
cout << “ Opción no válida. Reintente! ” << endl ;
}
} while ( opc != 3 ) ;
cout << endl ;

return 0 ;
}
Clase PrgMenu
class PrgMenu {
int opc ;
String nombre = “” , letra = “ ” ;
do {
System.out.println ( “ \n\n-----MENU----- ” ) ;
System.out.println ( “ [1]Ingresar un nombre ” ) ;
System.out.println ( “ [2]Mostrar la primera letra en mayúsculas ” ) ;
System.out.print ( “ [3]Finalizar \n Seleccione su opción: ” ) ;
opc = Lectura.leerInt( ) ;
switch (opc) {
case 1 :
do {
System.out.print ( “ \n Ingrese un nombre: ” ) ;
if ( nombre.matches ( “ ! [a-zA-Z] * " ) ) {
System.out.println ( “ Nombre no válido ” ) ;
}
} while ( nombre.matches ( “ ! [a-zA-Z] * ” ) ) ;
nombre = nombre.toUpperCase( ) ;
letra = nombre.substring ( 0,1 ) ;
valida = true ;
break ;
case 2 :
if ( valida ) {
System.out.println ( “ La primera letra en mayúsculas
es: ” + letra ) ;
} else {
System.out.println (“Ingrese primero la opción 1”);
}
break ;
case 3 :
System.out.println ( “ Hasta luego... ” ) ;
break ;
default :
System.out.println (“Opción no válida. Reintente!”) ;
}
} while ( opc != 3 ) ;
}
}
Observe el uso de los métodos matches ( ), toUpperCase ( ) y substring ( ) de la clase String de Java. La clase
String de Java no es tratada en el presente libro; sin embargo, dicha información la podrá encontrar en la
página web de los autores.
Problema 066
[1] Ingresar las tres notas de un alumno.

[2] Calcular promedio simple.
[3] Calcular promedio duplicando la mayor nota.
[4] Calcular promedio eliminando la menor nota.
[5] Finalizar.
En la solución de este problema deberá primero visualizar solo la opción 1 y 5. Una vez ingresadas
las notas deberá visualizar todas las opciones.
Defina el nombre del proyecto, luego desarrolle la definición de paquetes, el diagrama de paquetes,
la definición de las clases y diseñe el algoritmo.
Clase PrgMenuCalculoPromedio
#include <iostream>
#include <math.h>
int main ( ) {
int opc ;
double nota1 = 0 , nota2 = 0 , nota3 = 0 , promedio = 0 ;
bool valida = false ;
do {
if ( valida == true ) {
cout << “ \n\n-----MENU---- \n ” ;
cout << “ [1] Ingresar las 3 notas de un alumno \n ” ;
cout << “ [2] Calcular promedio simple \n ” ;
cout << “ [3] Calcular promedio duplicando la mayor nota \n ” ;
cout << “ [4] Calcular promedio eliminando la menor nota \n ” ;
cout << “ [5] Finalizar \n Ingrese su opción : ” ;
} else {
cout << “\n\n -----MENU-----\n ” ;
cout << “ [1] Ingresar las 3 notas de un alumno \n ” ;
cout << “ [5] Finalizar \n Ingrese su opción : ” ;
}
cin >> opc ;
switch ( opc ) {
case 1 :
do {
cout << “ \t Ingrese la primera nota: ” ;
cin >> nota1 ;
if ( nota1 > 20 || nota1 < 0 ) {

cout << “ \n\t ERROR. LA NOTA DEBE ESTAR ENTRE 0 y 20 ”
<< endl ;
}
} while ( nota1 > 20 || nota1 < 0 ) ;
do {
cout << “ \t Ingrese la segunda nota: ” ;
cin >> nota2 ;
if ( nota2 > 20 || nota2 < 0 ) {

cout << “\n\t ERROR. LA NOTA DEBE ESTAR ENTRE 0 y 20”<<endl ;
}
} while ( nota2 > 20 || nota2 < 0 ) ;
do {
cout << “ \t Ingrese la tercera nota: ” ;
cin >> nota3 ;
if ( nota3 > 20 || nota3 < 0 ) {

cout <<“\n\t ERROR.LA NOTA DEBE ESTAR ENTRE 0 y 20 ”<< endl ;
}
} while ( nota3 > 20 || nota3 < 0 ) ;
valida = true ;
break ;
case 2 :
promedio = ( nota1 + nota2 + nota3 ) / 3 ;

cout << “ \t El promedio es: ” << promedio << endl ;
break ;
}
case 3 :
promedio = ( nota1 + nota2 + nota3 + max ( nota1 , max ( nota2 ,
nota3 ) ) ) / 4 ;
cout << “\t El promedio duplicando la mayor nota es: ”
<< promedio << endl ;
break ;
}
case 4 :
promedio = ( nota1 + nota2 + nota3 - min ( nota1 , min ( nota2 ,

nota3 ) ) ) / 2 ;
cout << “\t El promedio anulando la mínima nota es:”<<
promedio << endl ;
break ;
}
case 5 :
if ( opc == 5 ) {
cout << “ \t HASTA LUEGO !!! ” ;
break ;
}
default :
cout << “ \t OPCION INCORRECTA. REINTENTE !!!. ” ;
}
} while ( opc != 5 ) ;
cout << endl << endl ;

return 0 ;
}
Clase PrgMenuCalculoPromedio
class ProyMenuCalculoPromedio {
public static void main ( String args [ ] ) {
int opc ;
double nota1 = 0 , nota2 = 0 , nota3 = 0 , promedio = 0 ;
do {
System.out.println (“\n\n-----MENU---- \n ) ” ;
System.out.println (“[1] Ingresar las 3 notas de un alumno ” ) ;
System.out.println (“[2] Calcular promedio simple ” ;
System.out.println (“[3] Calcular promedio duplicando la mayor
nota ” ) ;
System.out.println (“[4] Calcular promedio eliminando la menor
nota ” ) ;
System.out.print ( “ [5] Finalizar \n Ingrese su opción :”);
} else {
System.out.println ( “ \n\n -----MENU----- ” ) ;
System.out.println ( “ [1] Ingresar las 3 notas de un alumno ” ) ;
System.out.print ( “ [5] Finalizar \n Ingrese su opción : ” );
}
switch ( opc ) {
case 1 :
do {
System.out.print ( “ \t Ingrese la primera nota: ” ) ;
nota1 = Lectura.leerDouble ( ) ;
if ( nota1 > 20 || nota1 < 0 ) {
System.out.println ( “ \n\t ERROR. LA NOTA DEBE
ESTAR ENTRE 0 y 20 ” ) ;
}
} while ( nota1 > 20 || nota1 < 0 ) ;
do {
System.out.print ( “ \t Ingrese la segunda nota: ” ) ;
if ( nota2 > 20 || nota2 < 0 ) {
System.out.println ( “ \n\t ERROR. LA NOTA DEBE ESTAR
ENTRE 0 y 20 ” ) ;
}
} while ( nota2 > 20 || nota2 < 0 ) ;
do {
System.out.print (“ \t Ingrese la tercera nota: ” ) ;
if ( nota3 > 20 || nota3 < 0 ) {
System.out.println (“ \n\t ERROR. LA NOTA DEBE ESTAR
ENTRE 0 y 20 ” ) ;
}
} while ( nota3 > 20 || nota3 < 0 ) ;
valida = true ;
break ;
case 2 :
System.out.println ( “ \t El promedio simple es: ” + promedio ) ;
break ;
}
case 3 :
promedio = ( nota1 + nota2 + nota3 + Math.max ( nota1 , Math.max (
nota2 , nota3 ) ) ) / 4 ;
System.out.println ( “ \t El promedio duplicando la mayor nota es: ”
+ promedio ) ;
break ;
}
case 4 :
promedio = ( nota1 + nota2 + nota3 - Math.min ( nota1 , Math.min (
nota2 , nota3 ) ) ) / 2 ;
System.out.println ( “ \t El promedio anulando la mínima nota es: ”
+ promedio ) ;
break ;
}
case 5 :
if ( opc == 5 ) {
System.out.println ( “ \t HASTA LUEGO !!! ” ) ;
break ;
}
default :
System.out.println ( “ \t OPCIÓN INCORRECTA. REINTENTE! ” ) ;
}
} while ( opc != 5 ) ;
}
}
Observar el uso de los métodos min ( ) y max ( ) de la clase Math de Java. La clase Math de Java no será tratada
en el presente libro; sin embargo, dicha información la podrá encontrar en la página web de los autores.
Problema 067
Enunciado: Desarrollar una solución que permita mostrar los diez primeros números enteros
existentes. No deberá ingresar datos.
Defina el nombre del proyecto y desarrolle la definición de paquetes, el diagrama de paquetes y la


En pseudocódigo:
Algoritmo PrgNumerosEnteros – main ( )
ENTRADA:
SALIDA: lista
INICIO
ENTERO c = 1
TEXTO lista = “”
HACER
lista = lista + “ ” + c
c = c + 1
MIENTRAS ( c <= 10 )
ESCRIBIR “Los 10 primeros números son: ” + lista
FIN
Observar el uso de la variable denominada “c”. Dicha variable está actuando como un contador.
Algoritmo PrgNumerosEnteros – main ( )
INICIO
ENTERO c = 1
TEXTO lista = “ ”
lista = lista + “ ” + c
c=c+1
c <= 10
VERDADERO
FALSO
lista
FIN
Clase PrgNumerosEnteros
public class PrgNumerosEnteros {
public static void main ( String [ ] args ) {
int c = 1 ;
String lista = “” ;
do {
lista = lista + “ ” + c + “\n” ;
c ++ ;
} while ( c <= 10 ) ;
System.out.println ( “ Los 10 primeros números son:\n ” + lista ) ;
}
}

Problema 068
Enunciado: Desarrollar una solución que permita mostrar los números pares comprendidos entre
1000 y 1500. No deberá ingresar datos.
Defina el nombre del proyecto y desarrolle la definición de paquetes, el diagrama de paquetes y la


Algoritmo PrgListaPares – main ( )
INICIO
ENTERO c = 1000 , i = 1 , res

Cálculo de los
números pares entre
1000 y 1500
lista
FIN
Algoritmo PrgListaPares – main ( )
Cálculo de los
números pares
entre 1000 y
1500
lista = lista + c + “ ”
res = i % 5
VERDADERO
res == 0
FALSO
INSERTAR SALTOLINEA
i=i+1
c=c+2
c <=1500
VERDADERO
FALSO
|Observar el uso de la regla o pauta INSERTAR SALTOLINEA. El uso de esta regla es opcional y
generalmente no se utiliza, debido a que al diseñar un algoritmo nos preocupamos por la lógica
de la solución. Cómo se ingresan los datos o cómo se visualiza la información, son temas que se
tratan específicamente al codificar el algoritmo en un lenguaje de programación determinado.
Clase PrgListaPares
public class PrgListaPares {

int c = 1000 , i = 1 ;
String lista = “” ;
do {
lista = lista + c + “ ” ;
if ( i % 5 == 0 ) {
lista = lista + “\n” ;
}
i++ ;
c += 2 ;
} while ( c <= 1500 ) ;
System.out.println ( lista ) ;
}
}
Clase PrgListaPares
#include <iostream>
#include <string>
int main ( ) {
int c = 1000 , i = 1 ;
do {
cout << c << “ ” ;
if ( i % 5 == 0 ) {
cout << endl ;
}
i++ ;
c += 2 ;
} while ( c <= 1500 ) ;
cout << endl ;
return 0 ;
}
Analice esta solución en C++. Identifique las variaciones desarrolladas.

Problema 069
Enunciado: Mostrar los números múltiplos de 3 y la cantidad de números impares comprendidos

entre dos números ingresados por teclado.


En pseudocódigo:
Algoritmo PrgMulƟpos3Impares – main ( )
ENTRADA: num1 , num2

SALIDA: impares , listaMul3
INICIO
NUMERO num1 , num2 , impares = 0 , i = 1
TEXTO listaMul3 = “ ”
LEER num1 , num2
SI ( num1 < num2 )

ENTONCES
HACER
SI ( num1 RESTO 2 <> 0 )
ENTONCES
impares = impares +1
FINSI
SI ( num1 RESTO 3 <> 0 ) ENTONCES
listaMul3 = listaMul3 + “ ” + num1
SI ( i RESTO 5 == 0 ) ENTONCES
INSERTAR SALTOLINEA
FINSI
i = i + 1
FINSI
num1 = num1 + 1
MIENTRAS ( num1 <= num2 )

SINO
HACER

impares = impares +1
FINSI
listaMul3 = listaMul3 + “ ” + num2
SI ( i RESTO 5 == 0 ) ENTONCES
INSERTAR SALTOLINEA
FINSI
i = i + 1
FINSI
num2 = num2 + 1
MIENTRAS ( num2 <= num1 )
FINSI
ESCRIBIR “La cantidad de números impares es : ” + impares

ESCRIBIR “Lista de números múltplos de 3 : ” + listaMul3
FIN
Observar el uso de las variables “impares” e “i”. Ambas variables actúan en la solución como contadores;
por otra parte, la variable denominada “listaMul3” actúa como un acumulador.
Clase PrgMulƟpos3Impares
public class PrgMultiplos3Impares {

int num1 , num2 , impares = 0 , i = 1 ;

String listaMul3 = “” ;
num1 = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el segundo números: ” ) ;

if ( num1 < num2 ) {

do {
if ( num1 % 2 != 0 ) {
impares++ ;
}
if ( num1 % 3 == 0 ) {
listaMul3 = listaMul3 + “ ” + num1 ;
if ( i % 5 == 0 ) {
listaMul3 = listaMul3 + “\n” ;
}
i++ ;
}
num1++ ;
} while ( num1 <= num2 ) ;
} else {
do {
if ( num2 % 2 != 0 ) {
impares++ ;
}
if ( num2 % 3 == 0 ) {
listaMul3 = listaMul3 + “ ” + num2 ;
if ( i % 5 == 0 ) {
listaMul3 = listaMul3 + “\n” ;
}
i++ ;
}
num2++ ;
}
System.out.print ( “\n La cantidad de números impares es: ”

+ impares + “ \n\n Lista de números múltiplos de 3:\n” + listaMul3 ) ;
}
}
Clase PrgMulƟpos3Impares
#include <iostream>
#include <string>
using std::cout ;
using std::string ;
using std::cin ;
using std::endl ;
int main ( ) {
int num1 , num2 , impares = 0 , i = 1 ;

cin >> num1 ;
cin >> num2 ;
cout << “\n\nLista de números múltiplos de 3: ” << endl ;

do {
if ( num1 % 2 != 0 ) {
impares++ ;
}
if ( num1 % 3 == 0 ) {
cout << num1 << “ ” ;

if ( i % 5 == 0 ) {
cout << endl ;
}
i++ ;
}
num1++ ;
} else {
do {
if ( num2 % 2 != 0 ) {
impares++ ;
}
if ( num2 % 3 == 0 ) {
cout << num2 << “ ” ;
if ( i % 5 == 0 ) {
cout << “\n” ;
}
i++ ;
}
num2++ ;
}
cout << “\n\nLa cantidad de números impares es: ” << impares ;
cout << endl ;

return 0 ;
}

Problema 070
Enunciado: Calcular y mostrar la nota final que obtuvieron todos los alumnos de un salón de clase.
El cálculo de la nota final se realiza en base a cuatro notas, utilizando la siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
Ingrese las cuatro notas a través del teclado. No ingrese el total de alumnos.
A. Resultado deseado: Mostrar la nota final de todos los alumnos de un salón de clase.
B. Datos necesarios: Las cuatro notas de cada uno de los alumnos de un salón de clase.
C. Procesamiento: 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 sobre la base de la siguiente 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.
1. Nombre del proyecto: ProyNotasAlumnos

2. Definición de paquetes y desarrollo del diagrama de paquetes
3. Definición de las clases

Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgNotasAlumnos
|leerChar ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgNotasAlumnos – main ( )
ENTRADA: n1, n2, n3, n4

SALIDA: nf
INICIO
REAL n1, n2, n3, n4, nf
CARACTER continua
HACER
LEER n1, n2, n3, n4
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
ESCRIBIR nf
LEER continua
MIENTRAS ( continua = ‘s’ OR continua = ‘S’ )
FIN

Clase PrgNotasAlumnos
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int i = 1 ;
char continua ;
do {
cout << “ Ingrese nota 1 del alumno [” <> n1 ;

cin >> n2 ;

cin >> n3 ;

cin >> n4 ;
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ;
cout << “ \t Nota final del alumno [” <> continua ;
cout << endl ;
i ++ ;
} while ( continua == ‘s’ || continua == ‘S’ ) ;
return 0 ;
Observe el uso de la variable i, la cual actúa como un contador de número de alumnos.

Clase PrgNotasAlumnos
class PrgNotasAlumnos {
public static void main ( String arg[] ) {
int i = 1 ;
char continua ;
do {
System.out.print ( “ \n Ingrese nota 1 del alumno [” + i + “]: ” ) ;

System.out.print ( “ Ingrese nota 2 del alumno [” + i + “]: ” ) ;



nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ;
System.out.println ( “ \t Nota final del alumno [” + i + “]: ” + nf ) ;
System.out.print ( “ \n Desea continuar (s/n): ” ) ;

continua = Lectura.leerChar ( ) ;
i ++ ;
} while ( continua == ‘s’ || continua == ‘S’ ) ;
}
Problema 071
Enunciado: Determinar la suma de sueldos de los obreros (categoría 1), la suma de sueldos de los
empleados (categoría 2) y la suma de sueldos de los gerentes (categoria 3) de una determinada
empresa. Adicionalmente, determinar cuál es el mayor y el menor sueldo en la empresa. No deberá
ingresar el total de trabajadores.
Clase PrgSueldoCategoria
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double sueldoMayor = 0 , sueldoMenor = 0 , sueldo ;

double sumaObr = 0 , sumaEmp = 0, sumaGer = 0 ;
int cat , i = 1 ;
char continua ;
do {
do {
cout << “ Ingrese la categoría [ 1=obreros, 2=empleados,
3=gerentes]: ” ;
cin >> cat ;
if ( cat != 1 && cat != 2 && cat != 3 ) {
cout << “Categoría no válida… Reintente! ” ;
}
} while ( cat != 1 && cat != 2 && cat != 3 ) ;
do {
cout << “ Ingrese el sueldo del trabajador: ” ;
cin >> sueldo ;
if ( sueldo <= 0 ) {
cout << “ Sueldo ingresado no válido..Reintente! ” ;
}
} while ( sueldo <= 0
switch ( cat ) {
case 1 :
sumaObr = sumaObr + sueldo ;
break ;
case 2 :
sumaEmp = sumaEmp + sueldo ;
break ;
case 3 :
sumaGer = sumaGer + sueldo ;
break ;
if ( i == 1 ) {
sueldoMayor = sueldo ;
sueldoMenor = sueldo ;
i=2 ;
} else {
if ( sueldo > sueldoMayor ) {

}
if ( sueldo < sueldoMenor ) {
}
cout << “ \n \n Desea continuar ( s/n ): ” ;

cin >> continua ;
} while ( continua == ‘s' || continua == ‘S' ) ;
cout << “ \n El sueldo mayor es: ” << sueldoMayor << endl ;
cout << “ El sueldo menor es: ” << sueldoMenor << endl ;
cout << “ Suma de sueldos de Obreros: ” << sumaObr << endl ;
cout << “ Suma de sueldos de Empleados: ” << sumaEmp << endl ;
cout << “ Suma de sueldos de Gerentes: ” << sumaGer ;
cout << endl ;

return 0 ;
}
public class PrgSueldoCategoria {

double sueldoMayor = 0 , sueldoMenor = 0 , sueldo ;

double sumaObr = 0 , sumaEmp = 0, sumaGer = 0 ;
int cat , i = 1 ;
char continua ;
do {
do {
System.out.print ( “ Ingrese la categoría [ 1=obreros,
2=empleados, 3=gerentes]: ” ) ;
cat = Lectura.leerInt ( ) ;
if ( cat != 1 && cat != 2 && cat != 3 ) {
System.out.println ( “ Categoría no válida… Reintente!” ) ;
}
} while ( cat != 1 && cat != 2 && cat != 3 ) ;
do {
System.out.print ( “ Ingrese el sueldo del trabajador: ” ) ;
sueldo = Lectura.leerDouble ( ) ;
if ( sueldo <= 0 ) {
System.out.println ( “ Sueldo no válido… Reintente! ” ) ;
}
} while ( sueldo <= 0 ) ;
switch ( cat ) {
case 1 :
sumaObr = sumaObr + sueldo ;
break ;
case 2 :
sumaEmp = sumaEmp + sueldo ;
break ;
case 3 :
sumaGer = sumaGer + sueldo ;
break ;
}
if ( i == 1 ) {
i=2 ;
} else {
if ( sueldo > sueldoMayor ) {
}
if ( sueldo < sueldoMenor ) {
}
}
System.out.print ( “ \n Desea continuar ( s/n ): ” ) ;

continua = Lectura.leerChar ( ) ;
} while ( continua == ‘s' || continua == ‘S' ) ;
System.out.println ( “ \n El sueldo mayor es: ” + sueldoMayor ) ;
System.out.println ( “ El sueldo menor es: ” + sueldoMenor ) ;
System.out.println ( “ Suma de sueldos de Obreros: ” + sumaObr ) ;
System.out.println ( “ Suma de sueldos de Empleados: ” + sumaEmp ) ;
System.out.println ( “ Suma de sueldos de Gerentes: ” + sumaGer ) ;
Problema 072
Enunciado: Calcular y mostrar el número de alumnos que tienen promedio final menor que 10, los
alumnos que tienen promedio final de 10 a 14, los alumnos que tienen promedio final de 15 a 18
y los alumnos que tienen promedio final mayor a 18. Ingresar las cuatro notas de cada alumno y
calcular su promedio final en base a la siguiente fórmula:
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5
Defina el nombre del proyecto, desarrolle la definición de paquetes, el diagrama de paquetes, la

definición de las clases y diseñe el algoritmo.
Clase PrgNotasRango
#include <iostream>
#include <string>
using std::cout ;
using std::endl ;
using std::cin ;
int main ( ) {
int i = 1 , numAlumnos = 0 ;
double n1 ,n2 ,n3 ,n4 ,nf ,total1 = 0 ,total2 = 0 ,total3 = 0 ,total4 = 0 ;
cout << “Ingrese el número de alumnos: ” ;

cin >> numAlumnos ;
do {
do {
cout << “Ingrese nota 1 del alumno (” <> n1 ;
if ( n1 < 0 || n1 > 20 ) {
cout << “Error, nota 1 incorrecta ” << endl ;
}
} while ( n1 < 0 || n1 > 20 ) ;
do {
cin >> n2 ;
if ( n2 < 0 || n2 > 20 ) {
cout << “Error, nota 2 incorecta ” << endl ;
}
} while ( n2 < 0 || n2 > 20 ) ;
do {
cin >> n3 ;
if ( n3 < 0 || n3 > 20 ) {
}
} while ( n3 < 0 || n3 > 20 ) ;
do {
cin >> n4 ;
if ( n4 < 0 || n4 > 20 ) {
}
} while ( n4 < 0 || n4 > 20 ) ;
cout <<endl ;
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ;
if ( nf < 10 ) { total1++ ; }
if ( nf >= 10 && nf <= 14 ) { total2++ ; }
if ( nf >= 15 && nf <= 18 ) { total3++ ; }
if ( nf > 18 ) { total4++ ; }
i ++ ;
} while ( i <= numAlumnos ) ;
cout << “\nAlumnos con promedio menor a 10: ” << total1 << endl ;
cout << “Alumnos con promedio de 10 a 14: ” << total2 << endl ;
cout << “Alumnos con promedio de 15 a 18: ” << total3 << endl ;
cout << “Alumnos con promedio mayor a 18: ” << total4 << endl ;
cout << endl ;

return 0 ;
}
Clase PrgNotasRango
public class PrgNotasRango {
public static void main ( String[ ] args ) {
int i = 1 , numAlumnos = 0 ;
double n1 ,n2 ,n3 ,n4 ,nf ,total1 = 0 ,total2 = 0 ,total3 = 0 ,total4 = 0 ;
System.out.print ( “ Ingrese el número de alumnos: ” ) ;
numAlumnos=Lectura.leerInt ( ) ;
do {
do {
System.out.print ( “ \nIngrese nota 1 del alumno (” + i + “): ” ) ;
if ( n1 < 0 || n1 > 20 ) {
System.out.println ( “ Error, nota 1 incorrecta ” ) ;
}
} while ( n1 < 0 || n1 > 20 ) ;
do {
System.out.print ( “ Ingrese nota 2 del alumno (” + i + “): ” ) ;
if ( n2 < 0 || n2 > 20 ) {
}
} while ( n2 < 0 || n2 > 20 ) ;
do {
if ( n3 < 0 || n3 > 20 ) {
}
} while ( n3 < 0 || n3 > 20 ) ;
do {
if ( n4 < 0 || n4 > 20 ) {
}
} while ( n4 < 0 || n4 > 20 ) ;
nf = ( n1 + n2 + n3 + ( n4 * 2 ) ) / 5 ;
if ( nf < 10 ) { total1++ ; }
if ( nf >= 10 && nf <= 14 ) { total2++ ; }
if ( nf >= 15 && nf <= 18 ) { total3++ ; }
if ( nf > 18 ) { total4++ ; }
i ++ ;
} while ( i <= numAlumnos ) ;
System.out.println ( “Alumnos con promedio menor a 10: ” + total1 ) ;
System.out.println ( “Alumnos con promedio de 10 a 14: ” + total2 ) ;
System.out.println ( “Alumnos con promedio de 15 a 18: ” + total3 ) ;
System.out.println ( “Alumnos con promedio mayor a 18: ” + total4 ) ;
}
}
Problema 073
Enunciado: 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:
A. Al comenzar, se leerá una sola vez el precio de entrada para palco, platea y mezanine.
B. Por cada entrada vendida se leerán los siguientes datos: número de boleto (si el número de boleto
es cero se deberá finalizar) y lugar (puede ser platea, palco o mezanine).
C. Antes de finalizar, se deberá proporcionar la siguiente información:
a. Número total de entradas vendidas durante el día.
b. El total de soles recaudados en el día.
c. Número de entradas vendidas para platea, palco y mezanine en el día.
Clase PrgTeatro
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int numBoleto = 0 , tipo = 0 ;

int totalVendidas = 0 , totalPla = 0 , totalPal = 0 , totalMez = 0 ;
double totalGanancia = 0 , costoPla = 0 , costoPal = 0 ,costoMez = 0 ;
double gananciaPla = 0 , gananciaPal = 0 , gananciaMez = 0 ;
cout << “ Ingrese el costo de la entrada para platea: ” ;

cin >> costoPla ;
cout << “ Ingrese el costo de la entrada para palco: ” ;

cin >> costoPal ;
cout << “ Ingrese el costo de la entrada para mezanine: ” ;

cin >> costoMez ;
do {
do {
cout << “ Ingrese el número de boleto: ” ;

cin >> numBoleto ;
} while ( numBoleto < 0 ) ;
if ( numBoleto != 0 ) {
do {
cout << “ Ingrese el lugar ” ;

cout << “ [1] Platea, [2] Palco, [3] Mezanine ” ;
cin >> tipo ;
} 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 ;

gananciaPla = totalPla * costoPla ;
gananciaPal = totalPal * costoPal ;
gananciaMez = totalMez * costoMez ;
totalGanancia = gananciaPla + gananciaPal + gananciaMez ;
cout << endl ;

cout << “ Número total de entradas: ” << totalVendidas << endl ;
cout << “ Total recaudado S/.: ” << totalGanancia << endl ;
cout << “ Total vendidas platea: ” << totalPla << endl ;
cout << “ Total vendidas palco: ” << totalPal << endl ;
cout << “ Total vendidas mezanine: ” << totalMez << endl ;
cout << endl ;

return 0 ;
}
Clase PrgTeatro
public class PrgTeatro {

int numBoleto = 0 , tipo = 0 ;

int totalVendidas = 0 , totalPla = 0 , totalPal = 0 , totalMez = 0 ;
double totalGanancia = 0 , costoPla = 0 , costoPal = 0 ,costoMez = 0 ;
double gananciaPla = 0 , gananciaPal = 0 , gananciaMez = 0 ;
System.out.print ( “ Ingrese el costo de la entrada para platea: ” ) ;

costoPla = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese el costo de la entrada para palco: ” ) ;
costoPal = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese el costo de la entrada para mezanine: ” ) ;
costoMez = Lectura.leerDouble ( ) ;
do {
do {
System.out.print ( “ \n Ingrese el número de boleto: ” ) ;
numBoleto = Lectura.leerInt ( ) ;
} while ( numBoleto < 0 ) ;
if ( numBoleto != 0 ) {
do {
System.out.println ( “ Ingrese el lugar ” ) ;
System.out.print ( “ [1] Platea, [2] Palco, [3] Mezanine ” ) ;
} while ( tipo < 1 || tipo > 3 ) ;
switch ( tipo ) {
case 1 : totalPla++ ; break ;
case 2 : totalPal++ ; break ;
case 3 : totalMez++ ; break ;
}
}
} while ( numBoleto != 0 ) ;
totalVendidas = totalPla + totalPal + totalMez ;

gananciaPla = totalPla * costoPla ;
gananciaPal = totalPal * costoPal ;
gananciaMez = totalMez * costoMez ;
totalGanancia = gananciaPla + gananciaPal + gananciaMez ;
System.out.println ( “ \n 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 ) ;
}
}
Problema 074
Enunciado: Los empleados de una fábrica trabajan en tres turnos: mañana, tarde y noche. Se
necesita calcular el jornal diario de cada empleado teniendo en cuenta lo siguiente:
A. La tarifa del turno mañana y tarde es de S/. 8.00 por hora.

B. La tarifa del turno noche es de S/. 10.00 por hora.
C. 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.
D. Para el turno tarde se incrementa S/. 10.00 por concepto de movilidad.
Defina el nombre del proyecto y desarrolle la definición de paquetes, el diagrama de paquetes, la

Clase PrgJornal
#include <iostream>
int main ( ) {
int numEmpleados = 0 , i = 0 , horas = 0 , dia = 0 , turno = 0 ;

double tarifa = 0 , jornal = 0 ;
do {
cout << “ Ingrese el número de empleados: ” ;
cin >> numEmpleados ;
if ( numEmpleados <= 0 ) {
cout << “ El número de empleados debe ser mayor a 0 ” << endl ;
}
} while ( numEmpleados <= 0 ) ;
do {
i ++ ;
do {
cout << “\n Ingrese horas trabajadas empleado ( ” <> horas ;
if ( horas <= 0 ) {
cout << “ Número de horas mayor a 0 ” << endl ;
}
} while ( horas <= 0 ) ;
do {
cout << “ \n Seleccione día: ” << endl ;
cout << “ [1] Lunes ” << endl ;
cout << “ [2] Martes ” << endl ;
cout << “ [3] Miércoles ” << endl ;

cout << “ [4] Jueves ” << endl ;
cout << “ [5] Viernes ” << endl ;
cout << “ [6] Sábado ” << endl ;
cout << “ [7] Domingo ” << endl ;
cout << “ \t Opción: ” ;
cin >> dia ;
if ( dia < 1 || dia > 7 ) {
cout << “ La opción no es válida ” << endl ;
}
} while ( dia < 1 || dia > 7 ) ;
do {
cout << “ \n Seleccione turno: ” << endl ;
cout << “ [1] Mañana ” << endl ;
cout << “ [2] Tarde ” << endl ;
cout << “ [3] Noche ” << endl ;
cout << “\t Opción: ” ;
cin >> turno ;
switch ( turno ) {
case 1 :
case 2 :
if ( dia == 7 ) {
tarifa = 1.5 * 8 ;
} else {
tarifa = 8 ;
}
break ;
case 3 :
if ( dia == 7 ) {
tarifa = 1.6 * 10 ;
} else {
tarifa = 10 ;
}
break ;
default :
cout << “ La opción no es válida ” << endl ;
}
} while ( turno != 1 && turno != 2 && turno !=3 ) ;
if ( turno == 2 ) {
jornal = horas * tarifa + 10 ;
} else {
jornal = horas * tarifa ;
}
cout << “ \n El jornal del empleado ( ” << i << “ ) es : ” << jornal ;
cout << endl ;
} while ( i < numEmpleados ) ;
return 0 ;
}
Clase PrgJornal
package dominioDeLaAplicacion;
import biblioteca.Lectura;
public class PrgJornal {

int numEmpleados = 0 , i = 0 , horas = 0 , dia = 0 , turno = 0 ;

double tarifa = 0 , jornal = 0 ;
do {
System.out.print ( “ Ingrese el número de empleados: ” ) ;
numEmpleados = Lectura.leerInt ( ) ;
if ( numEmpleados <= 0 ) {
System.out.println ( “ Número de empleados debe ser mayor a 0” ) ;
}
} while ( numEmpleados <= 0 ) ;
do {
i++ ;
do {
System.out.print ( “ \n Horas trabajadas empleado (”+ i + “):”) ;

horas = Lectura.leerInt ( ) ;
if ( horas <= 0 ) {
System.out.println ( “ Número de horas mayor a 0 ” ) ;
}
} while ( horas <= 0 ) ;
do {
System.out.println ( “ \n Seleccione día: ” ) ;

System.out.println ( “ [1] Lunes ” ) ;
System.out.println ( “ [2] Martes ” ) ;
System.out.println ( “ [3] Miércoles ” ) ;
System.out.println ( “ [4] Jueves ” ) ;
System.out.println ( “ [5] Viernes ” ) ;
System.out.println ( “ [6] Sábado ” ) ;
System.out.println ( “ [7] Domingo ” ) ;
System.out.print ( “ \t Opción: ” ) ;
dia = Lectura.leerInt ( ) ;
if ( dia < 1 || dia > 7 ) {

System.out.println ( “ La opción no es válida" ) ;
}
} while ( dia < 1 || dia > 7 ) ;

do {
System.out.println ( “ \n Seleccione turno: ” ) ;
System.out.println ( “ [1] Mañana ” ) ;
System.out.println ( “ [2] Tarde ” ) ;
System.out.println ( “ [3] Noche ” ) ;
System.out.print ( “ \t Opción: ” ) ;
turno = Lectura.leerInt ( ) ;
switch ( turno ) {
case 1 :
case 2 :
if ( dia == 7 ) {
tarifa = 1.5 * 8 ;
} else {
tarifa = 8 ;
}
break ;
case 3 :
if ( dia == 7 ) {
tarifa = 1.6 * 10 ;
} else {
tarifa = 10 ;
}
break ;
default :
System.out.println ( “ La opción no es válida ” ) ;
}
} while ( turno != 1 && turno != 2 && turno !=3 ) ;
if ( turno ==2 ) {
jornal = horas * tarifa + 10 ;
} else {
jornal = horas * tarifa ;
}
System.out.println ( “ \n El jornal del empleado (” + i +“) es:”

+ jornal ) ;
} while ( i < numEmpleados ) ;
}
}
Problema 075
Enunciado: Desarrollar una solución que permita obtener la siguiente información en un salón de
clase:
A. ¿Cuántas alumnas y cuántos alumnos están matriculados en el curso?

B. ¿Cuántas alumnas son menores de 20 años y cuántos alumnos son mayores de 18 años?
C. ¿Cuántas alumnas están desaprobadas y cuántos alumnos están aprobados?
Clase PrgClase
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int i = 0 , edad = 0 , nota = 0 ;

int matriculadas = 0 , matriculados = 0 , menores = 0 ;
int mayores = 0 , desaprobadas = 0 , aprobados = 0 ;
char sexo = ‘F’ , rpta = ‘ ’ ;
do {
i++ ;
do {
cout << “ Ingrese el sexo del alumno ( ” <> sexo ;
if ( sexo != ‘f’ && sexo != ‘F’ && sexo != ‘m’ && sexo != ‘M’
) {
cout << “Sexo no válido" << endl ;
}
} while (sexo != ‘f’ && sexo !=‘F’ && sexo !=‘m’ && sexo != ‘M’ ) ;
do {
cout << “ Ingrese la edad del alumno ( ” <> edad ;
if ( edad <= 0 ) {
cout << “Edad no válida ” << endl ;
}
} while ( edad <= 0 ) ;
do {
cout << “ Ingrese la nota del alumno ( ” <> nota ;
if ( nota <0 || nota > 20 ) {
cout << “Nota no válida ” << endl ;
}
} while ( nota < 0 || nota > 20 ) ;
switch ( sexo ) {
case ‘f’ :
case ‘F’ :
matriculadas += 1 ;
if ( edad < 20 ) {
menores += 1 ;
}
if ( nota < 10.5 ) {
desaprobadas += 1 ;
}
break ;
case ‘m’ :
case ‘M’ :
matriculados += 1 ;
if ( edad > 18 ) {
mayores += 1 ;
}
if ( nota >= 10.5 ) {
aprobados += 1 ;
}
}
do {
cout << “ \n ¿Desea ingresar datos de otro alumno (S/N)?: ” ;
cin >> rpta ;
if ( rpta != ‘s’ && rpta !=‘S’ && rpta !=‘n’ && rpta !=‘N’) {
cout << “ Respuesta no válida ” << endl ;
}
} while ( rpta !=‘s’ && rpta != ‘S’ && rpta != ‘n’ && rpta !=‘N’);
} while ( rpta == ‘s’ || rpta == ‘S’ ) ;
cout << endl ;

cout << “ Hay ” << matriculadas << “ alumna(s) matriculada(s) ” << endl ;
cout << “ Hay ” << matriculados << “ alumno(s) matriculado(s) ” << endl ;
cout << “ Hay ” << menores << “ alumna(s) menor(es) de 20 ” << endl ;
cout << “ Hay ” << mayores << “ alumno(s) mayor(es) de 18 ” << endl ;
cout << “Hay ” << desaprobadas << “ alumna(s) desaprobada(s) ” << endl;
cout << “Hay ” << aprobados << “ alumno(s) aprobado(s) ” << endl ;
cout << endl ;

return 0 ;
}
Clase PrgClase
public class PrgClase {

int i = 0 , edad = 0 , nota = 0 ;

int matriculadas = 0 , matriculados = 0 , menores = 0 ;
int mayores = 0 , desaprobadas = 0 , aprobados = 0 ;
char sexo = ‘F’ , rpta = ‘ ’ ;
do {
i++ ;
do {
System.out.print ( “ Ingrese el sexo del alumno( ”+ i +“) F/M: ”);

sexo = Lectura.leerChar ( ) ;
if ( sexo != ‘f’ && sexo !=‘F’ && sexo != ‘m’ && sexo != ‘M’){
System.out.println ( “Sexo no válido ” ) ;
}
} while ( sexo != ‘f’ && sexo !=‘F’ && sexo != ‘m’ && sexo !=‘M’);
do {
System.out.print ( “ Ingrese la edad del alumno ( ” + i + “): ” );

if ( edad <= 0 ) {
System.out.println ( “Edad no válida ” ) ;
}
} while ( edad <= 0 ) ;
do {
System.out.print ( “ Ingrese la nota del alumno ( ” + i + “): ” ) ;

nota = Lectura.leerInt ( ) ;
if ( nota < 0 || nota > 20 ) {
System.out.println ( “Nota no válida ” ) ;
}
} while ( nota < 0 || nota > 20 ) ;
switch ( sexo ) {
case ‘f’ :
case ‘F’ :
matriculadas += 1 ;
if ( edad < 20 ) {
menores += 1 ;
}
if ( nota < 10.5 ) {

desaprobadas += 1 ;
}
break ;
case ‘m’ :
case ‘M’ :
matriculados += 1 ;
if ( edad > 18 ) {
mayores += 1 ;
}
if ( nota >= 10.5 ) {
aprobados += 1 ;
}
}
do {
System.out.print ( “ \n ¿Desea ingresar otros datos (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 ( );
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 ” ) ;
System.out.println ( “ Hay ”+ mayores + “ alumno(s) mayor(es) de 18 ” ) ;
System.out.println ( “ Hay ”+ desaprobadas + “ alumnas desaprobadas ” ) ;
System.out.println ( “ Hay ”+ aprobados + “ alumno(s) aprobado(s) ” ) ;
}
}
IMPORTANTE
4.2.4 Estructura lógica de repetición: “MIENTRAS”
A. Definición: Una estructura de repetición “MIENTRAS”, al igual que una estructura de repetición
“DESDE”, permite repetir una instrucción o un bloque de instrucciones, mientras que una condición
se cumpla o esta sea verdadera.
|Estetipo de estructura es útil cuando se necesita repetir una instrucción o bloque de instrucciones
un número de veces no determinado.
B. Representación
En pseudocódigo:
MIENTRAS ( condición )
instrucción 1
.
.
.
instrucción n
FINMIENTRAS
Explicación:
Cuando se ejecuta la estructura MIENTRAS... FINMIENTRAS, lo primero que se realiza es la evaluación

de la condición lógica ubicada junto a la instrucción MIENTRAS, etiquetada con la palabra (condición).
Una vez evaluada la condición lógica, se pueden obtener dos posibles resultados.
Si el resultado de evaluar la condición lógica es verdadero, se procede a ejecutar las instrucciones que
están dentro de la estructura MIENTRAS... FINMIENTRAS, y se evalúa nuevamente la condición lógica.
Si el resultado de evaluar la condición lógica es falso, no se ejecutan las instrucciones que están dentro
de la estructura 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 MIENTRAS... FINMIENTRAS, y solo 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. Observe dónde se

ubica la condición lógica y los flujos “verdadero” y “falso”.
FALSO
condición
VERDADERO
...
instrucciones
...
Fig. 4.4
VERDADERO
condición instrucción
FALSO
Fig. 4.5

while ( condición ) {
sentencias ...
}
Explicación:
En C++ y Java, la estructura de repetición 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 o no la estructura.
Esta condición lógica constituye la prueba en C++ y 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 falsa, se finaliza la ejecución continuando con la siguiente sentencia.
Es importante indicar que el inicio y fin del while se representan con llaves ( { } ).
Problema 076
Enunciado: Mostrar la suma de los números múltiplos de 5 menores a 50. Utilice la estructura de
repetición MIENTRAS.
A. Resultado deseado: Mostrar la suma de los números múltiplos de 5 menores a 50.

C. Procesamiento: Se empieza la evaluación de los números naturales desde el número 0 (num). Si
el número evaluado es múltiplo de 5 se suma dicho número (suma). Se
sumarán los números múltiplos de 5 menores a 50 y la suma resultante
será mostrada.
1. Nombre del proyecto: ProyMulƟplo5

Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgMultiplo5
|leerChar ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

Algoritmo PrgMulƟplo5 – main ( )
ENTRADA: num
SALIDA: suma
INICIO
ENTERO num = 0 , suma = 0
SI ( num RESTO 5 = 0 ) ENTONCES
suma = suma + num
FINSI
num = num + 1
FINMIENTRAS
ESCRIBIR suma
FIN
Algoritmo PrgMulƟplo5 – main ( )
INICIO
ENTERO num = 0
ENTERO suma = 0
FALSO
num <= 50
VERDADERO
num RESTO 5 FALSO

== 0
VERDADERO
suma = suma + num
num = num+1
suma
FIN
Clase PrgMulƟplo5
#include <iostream>
using std::cout ;
int main ( ) {
int suma = 0 ;
int num = 0 ;
while ( num <= 50 ) {

if ( num % 5 == 0 ) {
suma += num ;
}
num++ ;
}
cout << “ La suma es: ” << suma << “ \n \n”;
return 0 ;
}
Clase PrgMulƟplo5
class PrgMultiplo5 {
int suma = 0 ;
int num = 0 ;
while ( num <= 50 ) {

if ( num % 5 == 0 ) {
suma += num ;
}
num++ ;
}
System.out.println ( “ La suma es: ” + suma ) ;

}
}
Problema 077
Enunciado: Calcular y mostrar la cantidad de números pares comprendidos entre dos números
ingresados por teclado. Utilice la estructura de repetición MIENTRAS.
A. Resultado deseado: Mostrar la cantidad de números pares comprendidos entre dos números
ingresados a través del teclado.
B. Datos necesarios: Los dos números.
C. Procesamiento: Los números serán ingresados y almacenados en variables tipo entero
(num1 y num2 respectivamente); luego, se realizará la evaluación de cada
uno de los números comprendidos entre los números ingresados, con
la finalidad de establecer si son números pares. Para esto se utilizará la
siguiente fórmula:
num RESTO 2
Si el número (num) resulta ser par, se suma 1 a una variable (numPar).

Finalmente, se mostrará un mensaje con la cantidad de números pares
encontrados.
1. Nombre del proyecto: ProyPares

Clase de
Clase de biblioteca
Lectura
|leerString ()
PrgPares
|leerChar ()
|leerInt ( )
|main ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgPares – main ( )
ENTRADA: num1, num2

SALIDA: numPar
INICIO
NUMERO num1, num2, num, numPar = 0
LEER num1 , num2

num = num1
MIENTRAS ( num <= num2 )

numPar = numPar + 1
FINSI
num = num + 1
FINMIENTRAS
ESCRIBIR numPar
FIN
INICIO
NUMERO num1,num2
NUMERO num, numPar = 0
num1, num2
num = num1
num = num1
FALSO
num <= num2
VERDADERO
VERDADE
FALSO
num%2 = 0
VERDADERO
VERDAD
numPar = numPar + 1
num = num + 1
numPar
FIN
Clase PrgPares
#include <iostream>
int main ( ) {
int num1 , num2 , num , numPar = 0 ;
cout << “ Ingrese el primero número: ” ; cin >> num1 ;
cout << “ Ingrese el segundo número: ” ; cin >> num2 ;
num = num1 ;
while ( num <= num2 ) {
if ( num % 2 == 0 ) {
numPar ++ ;
}
num ++ ;
}
cout << “ \n La cantidad de números pares es: ” << numPar << “ \n\n ” ;
return 0 ;
}
Clase PrgPares
class PrgPares {
int num1 , num2 , num , numPar = 0 ;

num = num1 ;
while ( num <= num2 ) {
if ( num % 2 == 0 ) {
numPar ++ ;
}
num ++ ;
}
System.out.println ( “ \n La cantidad de números pares es: ” + numPar ) ;
}
}
Problema 078
Enunciado: Calcular y mostrar los números enteros cuadrados perfectos mayores que cero y
menores a un número ingresado por teclado. Un número cuadrado perfecto es aquel cuya raíz
cuadrada es un número entero. Utilice la estructura de repetición MIENTRAS.
A. Resultado deseado: Mostrar los números cuadrados perfectos mayores que cero y menores a
un número ingresado por teclado.
B. Datos necesarios: Un número entero.
C. Procesamiento: Se ingresará un número entero, se almacenará en una variable (num) y se
evaluará cada uno de los números desde el 1 hasta el número ingresado
(i). La evaluación se realiza obteniendo la raíz cuadrada del número (raiz)
y multiplicando el número por 10. Si el resto de dividir a la raíz cuadrado
del número entre 10 es cero, entonces el número es un cuadrado perfecto.
1. Nombre del proyecto: ProyNumerosPerfectos

2. Definición de paquetes y clases
Lectura
PrgNumerosPerfectos |leerString ()
|leerChar ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgNumerosPerfectos – main ( )
ENTRADA: num
SALIDA: i
INICIO
NUMERO num , i = 1 , raiz
LEER num
MIENTRAS ( i <= num )
raiz = i RAIZ 2
raiz = raiz * 10
SI ( raiz RESTO 10 == 0 ) ENTONCES

ESCRIBIR “El número ” + i + “ es un número perfecto”
FINSI
i = i + 1
FINMIENTRAS
FIN
Algoritmo PrgNumerosPerfectos – main ( )
INICIO
NUMERO num , i = 1
NUMERO raiz
num
FALSO
i <= num
VERDADERO
raiz = i RAIZ 2
raiz = raiz * 10
VERDADERO
raiz RESTO 10 = 0
FALS
FALSO
L
i=i+1
FIN

Clase PrgNumerosPerfectos
#include <iostream>
#include <math.h>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int num, i = 1 ;
double raiz ;
cout << “ Ingrese un número entero positivo: ” ;

cin >> num ;
while ( i <= num ) {
raiz = sqrt ( i ) ;
raiz = raiz * 10 ;
if ( (int)(raiz) % 10 == 0 ) {
cout << “ \t El número ” << i << “ es un número perfecto ” << endl;
}
i ++ ;
cout << endl ;

return 0 ;
Clase PrgNumerosPerfectos
class PrgNumerosPerfectos {
int num, i = 1 ;
double raiz ;
System.out.print ( “ Ingrese un número entero positivo: ” ) ;

while ( i <= num ) {
raiz = Math.sqrt ( i ) ;
raiz = raiz * 10 ;
if ( (int)(raiz) % 10 == 0 ) {
System.out.println ( “ \t El número ” + i + “ es perfecto ” ) ;
}
i ++ ;
}
}
Observe el uso de los métodos sqrt ( ) de la clase Math de Java. La clase Math de Java no es tratada en el
presente libro; sin embargo, dicha información la podrá encontrar en la página web de los autores.
Problema 079
Enunciado: Ingresar tres notas de diez alumnos de un salón de clase y calcular el promedio de cada
uno de ellos. Utilice la estructura de repetición MIENTRAS.
A. Resultado deseado: Mostrar el promedio de diez alumnos de un salón de clase.

B. Datos necesarios: Las tres notas de los diez alumnos.
C. Procesamiento: Las notas serán ingresadas por el teclado y almacenadas en las variables
(nota1, nota2, nota3); luego se realizará el cálculo del promedio con la
siguiente fórmula:
promedio = ( nota1 + nota2 + nota3 ) / 3
El promedio se almacenará en una variable (promedio). Finalmente, se

mostrará un mensaje con el resultado. Esto se realizará para cada uno de
los 10 alumnos del salón de clase (numAlu).
1. Nombre del proyecto: ProyPromedios


Lectura
PrgPromedios |leerString ()
|leerChar ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgPromedios – main ( )
ENTRADA: nota1, nota2, nota3

SALIDA: promedio
INICIO
REAL nota1, nota2, nota3, promedio

ENTERO numAlu = 1
MIENTRAS ( numAlu <= 10 )
LEER nota1, nota2 , nota3

ESCRIBIR promedio
numAlu = numAlu + 1
FINMIENTRAS
FIN
Algoritmo PrgPromedios – main ( )
INICIO
REAL nota1, nota2, nota3,

promedio ENTERO numAlu = 1
FALSO
numAlu <= 10
VERDADERO
O
nota1, nota2, nota3
promedio
numAlu = numAlu + 1
FIN
Clase PrgPromedios
#include <iostream>
int main ( ) {
double nota1 , nota2 , nota3 , promedio ;

int numAlu = 1 ;
while ( numAlu <= 10 ) {

cout << “ Ingrese nota1: ” ; cin >> nota1 ;
cout << “ \t Promedio es: ” << promedio << “\n\n” ;
numAlu ++ ;
}
cout << endl ;

return 0 ;
}
Clase PrgPromedios
class PrgPromedios {
double nota1 , nota2 , nota3 , promedio ;

int numAlu = 1 ;

System.out.print ( “Nota1 del alumno [ ” + numAlu + “]: ” ) ;
System.out.print ( “ \t Promedio del alumno [” + numAlu + “]: ”);
System.out.println ( promedio + “\n” ) ;
numAlu ++ ;
}
}
}
Problema 080
Enunciado: Ingrese el promedio de diez alumnos de un salón de clase y calcule el promedio general
obtenido. Para la solución, utilice la estructura de repetición MIENTRAS.
A. Resultado deseado: Mostrar el promedio general obtenido.

B. Datos necesarios: El promedio de cada uno de los diez alumnos.
C. Procesamiento: El promedio de cada uno de los diez alumnos será ingresado a través del
teclado y almacenado en una variable (promedio). Cada vez que se ingrese
un promedio se acumulará en una variable (sumaPromedios). Para el
cálculo del promedio general se utilizará la siguiente formula:
promGen = sumaPromedios / 10
El promedio general se almacenará en una variable (promGen). Finalmente,

se mostrará un mensaje con el resultado.
1. Nombre del proyecto: ProyPromedioG


Lectura
PrgPromedioG |leerString ()
|leerChar ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgPromedioG – main ( )
ENTRADA: promedio
SALIDA: promGen
INICIO
ENTERO numAlu = 1
REAL promedio , sumaPromedios = 0 , promGen = 0
LEER promedio
sumaPromedios = sumaPromedios + promedio
numAlu = numAlu + 1
FINMIENTRAS
ESCRIBIR promGen
FIN
INICIO
ENTERO numAlu = 1
REAL promedio , sumaPromedios = 0 , promGen=0
FALSO
numAlu <= 10
VERDADERO
VERDADE
promedio
sumaPromedios = sumaPromedios + promedio
numAlu = numAlu + 1
promGen
FIN
Clase PrgPromedioG
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
double promedio , sumaPromedios = 0 , promGen ;

int numAlu = 1 ;

cout << “ Ingrese el promedio del alumno [ ” << numAlu << “]: ” ;
cin >> promedio ;
sumaPromedios += promedio ;
numAlu ++ ;
}
promGen = sumaPromedios / 10 ;
cout << “ \t El promedio general es: ” << promGen << “ \n\n ” ;
return 0 ;
}
Clase PrgPromedioG
class PrgPromedioG {
double promedio , sumaPromedios = 0 , promGen 0 ;

int numAlu = 1 ;

System.out.print ( “ Ingrese promedio: ” ) ;
promedio = Lectura.leerDouble ( ) ;
sumaPromedios += promedio ;
numAlu ++ ;
}
promGen = sumaPromedios / 10 ;
System.out.println ( “ \t El Promedio general es: ” + promGen ) ;
}
}
Problema 081
Enunciado: Desarrolle una solución que permita generar y visualizar los diez primeros términos de
la serie siguiente:
2/5, 5/9, 8/13, 11/17, 14/21,…
Utilice la estructura de repetición MIENTRAS.

En pseudocódigo:
Algoritmo PrgSerie – main ( )
ENTRADA:
SALIDA: num, den
INICIO
ENTERO num = 2 , den = 5, cont = 1
MIENTRAS ( cont <= 10 )
SI ( cont == 1 ) ENTONCES
ESCRIBIR num + “ / ” + den
SINO
ESCRIBIR “, ” + num + “ / ” + den
FINSI
num = num + 3
den = den + 4
FINMIENTRAS
FIN

Clase PrgSerie
#include <iostream>
using std::cout ;
int main ( ) {
int cont = 1, num = 2, den = 5 ;
while ( cont <= 10 ) {

if ( cont ==1 ) {
cout << num << “/” << den ;
} else {
cout << “,” << num << “/” << den ;
}
num += 3 ;
den += 4 ;
cont ++ ;
}
cout << “ \n \n” ;

return 0 ;
}
Clase PrgSerie
class PrgSerie {
int cont = 1, num = 2, den = 5 ;
while ( cont <= 10 ) {

if (cont ==1) {
System.out.print ( num + “/” + den ) ;
} else {
System.out.print ( “, ” + num + “/” + den ) ;
}
num += 3 ;
den += 4 ;
cont ++ ;
}
}
}
Problema 082
Enunciado: Ingresar, calcular y mostrar el número de cifras que tiene cierto número. Utilizar la
estructura de repetición MIENTRAS, para resolver el ejercicio.

En pseudocódigo:
Algoritmo PrgNumCifras – main ( )
ENTRADA: numero
SALIDA: numCifras
INICIO
ENTERO numero , numCifras = 0
LEER numero
MIENTRAS ( numero > 0 )
numero = numero / 10
numCifras = numCifras + 1
FINMIENTRAS
ESCRIBIR “La cantidad de cifras es: ” + numCifras
FIN
Clase PrgNumCifras
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int numero , numCifras = 0 ;

cin >> numero ;
while ( numero > 0 ) {
numero = numero / 10 ;
numCifras ++ ;
cout << “ \n La cantidad de cifras es: ” << numCifras ;
cout << “\n \n” ;

return 0 ;
}
Clase PrgNumCifras
class PrgNumCifras {
int numero , numCifras = 0 ;

numCifras ++ ;
System.out.println ( “ \n La cantidad de cifras es: ” + numCifras ) ;
}
Problema 083
Enunciado: Ingresar, calcular y mostrar la suma de las cifras de un número. Utilizar la estructura de
repetición MIENTRAS, para resolver el ejercicio.
Clase PrgSumaCifras
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int numero , cifra , sumaCifras = 0 ;

cin >> numero ;
cifra = numero % 10 ;
sumaCifras += cifra ;
cout << “ \n La suma de cifras es: ” << sumaCifras ;
cout << “ \n \n” ;

return 0 ;
}
Clase PrgSumaCifras
class PrgSumaCifras {
int numero ,cifra , sumaCifras = 0 ;


sumaCifras += cifra ;
}
System.out.println ( “ \n La suma de cifras es: ” + sumaCifras ) ;
}
}
Problema 084
Enunciado: Ingresar un número, luego calcular y mostrar dicho número con las cifras invertidas
(Ejemplo: se ingresa 128, se muestra 821). Utilizar la estructura de repetición MIENTRAS.
Clase PrgInvCifras
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int numero , cifra , numInvertido = 0 ;
cin >> numero ;
numInvertido = numInvertido * 10 + cifra ;
cout << “ \n El número con las cifras invertidas es: ” << numInvertido ;
cout << “\n \n” ;

return 0 ;
Clase PrgInvCifras
class PrgInvCifras {
int numero ,cifra , numInvertido = 0 ;

System.out.print ( “ \n El número con las cifras invertidas es: ” ) ;

System.out.println ( numInvertido ) ;
}
}
Problema 085
Enunciado: Ingresar un número. Determinar si un número es capicúa o no (recuerde que un

número es capicúa cuando se lee igual de izquierda a derecha, y viceversa). Utilice la estructura de
Clase PrgNumCapicua
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int numero , numIngresado , cifra , numInvertido = 0 ;

cin >> numero ;
numIngresado = numero ;
if ( numIngresado == numInvertido ) {
cout << “ \n El número ingresado es capicua ” ;
} else {
cout << “ \n El número ingresado no es capicua ” ;
}
cout << “\n \n” ;

return 0 ;
}
Clase PrgNumCapicua
class PrgNumCapicua {
int numero, numIngresado , cifra , numInvertido = 0 ;

numIngresado = numero ;
if ( numIngresado == numInvertido ) {
System.out.println ( “ \n El número ingresado es capicua ” ) ;
} else {
System.out.println ( “ \n El número ingresado no es capicua ” ) ;
}
}
}
IMPORTANTE
4.2.5 Estructura lógica de repetición: "DESDE" o "PARA"
A. Definición: Una estructura de repetición “DESDE” o “PARA” permite repetir una instrucción o un
bloque de instrucción, un número determinado de veces o hasta que una condición se cumpla. Se
utiliza con frecuencia para iteraciones sencillas, donde se repite un bloque de instrucciones cierto
número de veces y después se detiene.
|Este Ɵpo de estructura es úƟl cuando se necesita repeƟr una instrucción o bloque de instrucciones
un cierto número de veces.
B. Representación
En pseudocódigo:
PARA ( ENTERO valor_inicial ; condición ; valor )
instrucción 1
.
.
.
instrucción n
FINPARA
DESDE <valor_inicial> HASTA <valor_final> INCREMENTA <valor>
instrucción 1
.
.
.
instrucción n
FINDESDE
Explicación:
Esta estructura tiene tres partes:
1. Inicialización: <valor_inicial>
Esta parte se ejecuta una sola vez al momento de iniciar la ejecución del DESDE o PARA, y permite
asignar un valor inicial a una variable índice. Esta variable permite mantener el control sobre el
número de veces que se repiten las instrucciones ubicadas entre el DESDE y el FINDESDE, o el PARA
y el FINPARA, dependiendo del formato que se utilice.
2. Incremento: <valor>
Cada vez que finaliza la ejecución de las instrucciones o bloque de instrucciones ubicadas entre el
DESDE y el FINDESDE, o el PARA y el FINPARA, se ejecuta esta parte y se INCREMENTA (aumenta)
el valor de la variable índice, según se indique en <valor>. También existe la posibilidad de reducir
el valor de la variable índice; en este caso, se utiliza la palabra reservada DECREMENTA (disminuye)
en vez de la palabra INCREMENTA en el formato DESDE.
3. Prueba: <condición> o <valor_final>

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 <valor_final> o si la condición
lógica es falsa.
Si la variable índice no es igual a <valor_final> o la condición lógica es verdadera, se deberán

ejecutar las instrucciones o bloques de instrucciones ubicados entre el DESDE y el FINDESDE, o
el PARA y el FINPARA. En caso la variable índice sea igual a <valor_final> o la condición lógica sea
falsa, se finaliza la ejecución del DESDE o PARA y se continúa con la ejecución de la instrucción
ubicada después del FINDESDE o FINPARA.
El equivalente de esta estructura en diagrama de flujo se muestra a continuación:
PARA… FINPARA
valor_inicial
FALSO
condición
VERDADERO
ADERO
...
instrucciones
...
valor
DESDE… FINDESDE:
FALSO
DESDE i HASTA z
condición
INCREMENTA i en x
VERDADERO
...
instrucciones
...
Explicación:
Las tres partes de esta estructura representada con el formato DESDE, se simbolizan en el diagrama de
flujo a través de las siguientes palabras reservadas:
DESDE i HASTA z
Donde “i” representa la variable índice, y “z” representa el valor que la variable índice “i” debe alcanzar
para finalizar la ejecución.
INCREMENTA i en x
Aquí “x” representa el valor que se incrementará a la variable índice “i” cada vez que finalice la
ejecución de las instrucciones que forman parte de la estructura.
También puede usar:
INCREMENTA x
Se incrementa el valor de “x” a la variable índice.
Ambas palabras se encuentran dentro del símbolo que representa La Estructura Lógica DESDE, la cual
se muestra a continuación:
El fin de las instrucciones o bloque de instrucciones que forman parte de La Estructura Lógica DESDE,
se representa por el siguiente símbolo:
Este último símbolo es equivalente a la palabra reservada FINDESDE, utilizada en pseudocódigo.


for ( inicialización ; condición ; incremento) {
sentencias ...
Explicación:
En C++ y en Java la estructura de repetición DESDE está representada por la sentencia for.
Al igual que en pseudocódigo y diagrama de flujo, en Java y C++ esta estructura está constituida por
tres partes, las cuales están entre paréntesis y separadas por punto y coma.
for ( inicialización ; condición ; incremento) {
Parte 1 Parte 2 Parte 3

}
La parte de inicialización es la que se ejecuta una sola vez (la primera vez que se ejecuta el for) y
permite inicializar la variable índice.
La parte de condición es la condición lógica (ejemplo: i >10), que permite determinar si se vuelve a
ejecutar la estructura de repetición for.
Y la tercera parte permite incrementar o decrementar el valor de la variable índice cada vez que se
ejecuta la estructura de repetición for.
Es importante indicar que el inicio y fin del for se representan con llaves ( { } ).

Problema 086
Enunciado: Calcular y mostrar los 10 primeros números múltiplos del número 7. Utilice la estructura
de repetición DESDE.
A. Resultado deseado: Mostrar los 10 primeros números múltiplos de 7.

C. Procesamiento: Se empieza la evaluación de los números naturales desde el número 1 (num)
hasta el número 10. Cada número evaluado es multiplicado por el número
7 para determinar el número múltiplo de 7, equivalente y almacenado en
una variable (mensaje). Finalmente, se muestran los números múltiplos de
7 equivalentes a cada número evaluado.
1. Nombre del proyecto: ProyMulƟploSiete

PrgMulƟploSiete Clase de biblioteca
Lectura
PrgMultiploSiete |leerString ()
|leerChar ( )
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgMulƟploSiete – main ( )
ENTRADA:
SALIDA: mensaje
INICIO
NUMERO num
DESDE num = 1 HASTA 10 INCREMENTA num en 1

mensaje = mensaje + ( num * 7 ) + “ ”
FINDESDE
ESCRIBIR mensaje
FIN
Algoritmo PrgMulƟploSiete – main ( )
INICIO
NUMERO num
FALSO
DESDE num=1 HASTA 10
INCREMENTA num en 1
VERDADERO
mensaje = mensaje + ( num * 7 ) + “ ”
mensaje
FIN
Clase PrgMulƟploSiete
class PrgMultiploSiete {
String mensaje = “” ;
int num ;
for ( num = 1 ; num <= 10 ; num++ ) {

mensaje += ( num * 7 ) + “ \n ” ;
}
System.out.println ( “ Los 10 primeros números múltiplo de 7 son: ” ) ;

}
}
Clase PrgMulƟploSiete
#include <iostream>
#include <string>
using namespace::std ;
int main ( ) {
int num ;
cout << “Los 10 primeros números múltiplo de 7 son: ” << endl ;
for ( num = 1 ; num <= 10 ; num++ ) {

cout << ( num * 7 ) ;
cout << endl ;
}
cout << “\n \n” ;

return 0 ;

Problema 087
Enunciado: Calcular y mostrar la cantidad de números pares, y la suma de los números múltiplos
de 3 comprendidos entre dos números ingresados por teclado. Utilice la estructura de repetición
DESDE y PARA.
A. Resultado deseado: Mostrar la cantidad de números pares y la suma de los números múltiplos
de 3 comprendidos entre dos números ingresados por teclado.
B. Datos necesarios: Los dos números.
C. Procesamiento: Los números ingresados por teclado se almacenarán en variables tipo
entero (num1 y num2). Luego, se evaluarán los números comprendidos
entre los números ingresados. Para ello se utilizará una variable (num).
Cada número será evaluado con la finalidad de determinar si es par o es
múltiplo del número 3. Si resulta un número par se le suma 1 a la variable
contador (pares), y si es múltiplo de 3 se le suma dicho número en una
variable acumulador (suma). Finalmente, se mostrarán los resultados.
1. Nombre del proyecto: ProyParesSuma

PrgParesSuma Clase de biblioteca
Lectura
PrgParesSuma |leerString ()
|leerChar ()
|leerLong ( )
|leerFloat ( )
|leerDouble ( )

En pseudocódigo:
Algoritmo PrgParesSuma – main ( )
ENTRADA: num1, num2

SALIDA: pares, suma
INICIO
NUMERO num , num1, num2, pares = 0 , suma = 0
LEER num1, num2
DESDE num = num1 HASTA num2 INCREMENTA num en 1
pares = pares + 1
FINSI
suma = suma + num
FINSI
FINDESDE
ESCRIBIR pares, suma
FIN
Observe la estructura lógica de repetición DESDE:
DESDE num = num1 HASTA num2 INCREMENTA num en 1
También puede utilizar:
DESDE num = num1 HASTA num2 INCREMENTA 1
Esto se justifica, ya que se asume que la variable índice esta representada por “num” y es la
variable que se incrementa en 1 cada vez que se ejecuta la estructura lógica de repetición DESDE.
ENTRADA: num1, num2

SALIDA: pares, suma
INICIO
NUMERO num , num1, num2, pares = 0 , suma = 0
LEER num1, num2
PARA ( ENTERO num = num1 ; num <= num2 ; num = num + 1 )
pares = pares + 1
FINSI
suma = suma + num
FINSI
FINPARA
ESCRIBIR pares, suma
FIN
INICIO
NUMERO num, num1,

num2, pares= 0, suma= 0
num1, num2
DESDE num=num1 HASTA num2 FALSO
INCREMENTA 1
VERDADERO
VERDADERO
num RESTO 2 = 0
FALSO
pares = pares + 1
VERDADERO
num RESTO 2 = 0
FALSO
suma = suma + num
pares, suma
FIN
INICIO
NUMERO num, num1,

num2, pares= 0, suma= 0
num1, num2
num = num1
FALSO
num <= num2
VERDADERO
VERDADERO
num RESTO 2 = 0
FALSO pares = pares + 1
VERDADERO
num RESTO 3 = 0
suma = suma + num

FALSO
num = num1 + 1
pares, suma
FIN
Clase PrgParesSuma
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int num , num1 , num2 , suma = 0 , pares = 0 ;
cout << “ Ingrese el número menor: ” ;

cin >> num1 ;
cout << “ Ingrese el número mayor: ” ;

cin >> num2 ;
for ( num = num1 ; num <= num2 ; num++ ) {
if ( num % 2 == 0 ) {
pares ++ ;
}
if ( num % 3 == 0 ) {
suma = suma + num ;
}
cout << “ \n Cantidad de números pares: ” << pares ;

cout << “ \n Suma de números múltiplos de 3: ” << suma ;
cout << “ \n \n” ;

return 0 ;
Clase PrgParesSuma
class PrgParesSuma {
int num , num1 , num2 , suma = 0 , pares = 0 ;

System.out.print ( “ Ingrese el número menor: ” ) ;

System.out.print ( “ Ingrese el número mayor: ” ) ;
for ( num = num1 ; num <= num2 ; num++ ) {
if ( num % 2 == 0 ) {
pares ++ ;
}
if ( num % 3 == 0 ) {
suma = suma + num ;
}
}
System.out.println ( “ \n Cantidad de números pares: ” + pares ) ;
System.out.println ( “ Suma de números múltiplos de 3: ” + suma ) ;
}
}
Problema 088
Enunciado: Ingresar un número y determinar si el número ingresado es o no es un número primo.

Utilice la estructura de repetición DESDE.

En pseudocódigo:
Algoritmo PrgNumeroPrimo – main ( )
ENTRADA: num
SALIDA: num
INICIO
NUMERO num , div = 0 , i

LEER num
DESDE i = 2 HASTA num - 1

SI ( num RESTO i = 0 ) ENTONCES
div = 1
TERMINAR
FINSI
FINDESDE
SI ( div == 1 ) ENTONCES
ESCRIBIR “El número ” + num + “ no es primo. ”

SINO
ESCRIBIR “El número ” + num + “ es primo. ”
FINSI
FIN
Observe que la tercera parte de la estructura lógica de repetición DESDE no ha sido utilizada.
Cuando en el pseudocódigo o diagrama de flujo no se utiliza la tercera parte de la estructura
de repetición DESDE, se asume que la variable índice (representada en este pseudocódigo por la
variable “i”) se incrementará en 1 cada vez que se ejecute la estructura lógica de repetición DESDE.
Algoritmo PrgNumeroPrimo – main ( )
INICIO
NUMERO num , div = 0 , res , i
num
DESDE i = 2 HASTA num-1 FALSO
VERDADERO
res = num RESTO i
VERDADERO
num RESTO 2 = 0 div = 1
FALSO
VERDADERO
div = 1
”es primo” ”no es primo”
FIN
Clase PrgNumeroPrimo
#include <iostream>
int main ( ) {
int num , div = 0 ;

cin >> num ;
for ( int i = 2 ; i < num ; i++ ) {
if ( num % i == 0 ) {
div = 1 ;
break ;
}
}
if ( div == 1 ) {
cout << “ El número ” << num << “ NO es PRIMO ” ;
} else {
cout << “ El número ” << num << “ es PRIMO ” ;
}
cout << “ \n \n” ;

return 0 ;
}
Clase PrgNumeroPrimo
class PrgNumeroPrimo {
int num , div = 0 ;

for ( int i = 2 ; i < num ; i++ ) {
if ( num % i == 0 ) {
div = 1 ;
break ;
}
}
if ( div == 1 ) {
System.out.println ( “ El número ” + num + “ NO es PRIMO ” ) ;
} else {
System.out.println ( “ El número ” + num + “ es PRIMO” ) ;
}
}
}
Problema 089
Enunciado: Determinar y mostrar los términos de una progresión aritmética. Ingrese el valor del
primer término, el valor de la razón y el número de términos que tiene la progresión. Utilice la
estructura de repetición PARA.

Clase PrgProgresionAritmeƟca
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
using std::endl ;
int main ( ) {
int primerT, razon, numeroT, termino ;

cin >> primerT ;
cout << “ Ingrese la razón de la progresión: ” ;
cin >> razon ;
cout << “ Ingrese el número de términos: ” ;
cin >> numeroT ;
termino = primerT ;
cout << endl << “Los términos de la progresión son: ” ;
cout << endl << termino << “ ” ;
for ( int i = primerT ; i <= numeroT ; i++ ) {

termino = termino + razon ;
cout << termino << “ ” ;
}
cout << “ \n \n” ;

return 0 ;
}
Clase PrgProgresionAritmeƟca
class PrgProgresionAritmetica {
int primerT , razon , numeroT ;


primerT = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese la razón de la progresión: ” ) ;

razon = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese el número de términos: ” ) ;

numeroT = Lectura.leerInt ( ) ;
for ( int i = 1 ; i <= numeroT ; i++ ) {
mensaje += ( primerT + ( i - 1 ) * razon ) + “ ” ;
}
}
Analice esta solución en Java e identifique las variaciones desarrolladas.

Problema 090
Enunciado: Determinar y mostrar la suma de los términos de una progresión geométrica. Ingrese el
valor del primer término, el de la razón y el número de términos que tiene la progresión. Utilice la
estructura de repetición PARA y DESDE.


En pseudocódigo:
Algoritmo PrgProgresionGeometrica – main ( )
ENTRADA: primerT , razon , numT

SALIDA: suma
INICIO
ENTERO primerT , numT , i

REAL razon , suma = 0
LEER primerT , razon , numT
PARA ( i = 1 ; i <= numT ; i = i+1 )
suma = suma + primerT * razon * ( razon POTENCIA ( i + 1 ) )
FINPARA
ESCRIBIR suma
FIN
Intente diseñar el algoritmo en pseudocódigo utilizando DESDE.

Algoritmo PrgProgresionGeometrica – main ( )
INICIO
NUMERO primerT , numT , i , razon , suma = 0
primerT , razon , numT
DESDE i = 1 HASTA numT FALSO
VERDADERO
suma = suma + primerT * razon * ( razon * POTENCIA ( i + 1 ) )
suma
FIN
Intente diseñar el algoritmo en diagrama de flujo utilizando PARA.

Clase PrgProgresionGeometrica
class PrgProgresionGeometrica {
int primerT , numT ;

double razon , suma = 0 ;

primerT = Lectura.leerInt ( ) ;
System.out.print ( “ Ingrese la razón de la progresión: ” ) ;

razon = Lectura.leerDouble ( ) ;
System.out.print ( “ Ingrese el número de términos: ” ) ;

numT = Lectura.leerInt ( ) ;
for ( int i = 1 ; i <= numT ; i++ ) {
suma += primerT * razon * Math.pow ( razon , i - 1 ) ;
System.out.println ( “ La suma de términos es: ” + suma ) ;

}
}

Problema 091
Enunciado: Ingresar 50 números, luego determinar y mostrar la cantidad de números pares, la

cantidad de ceros y la cantidad de números negativos ingresados. Utilice la estructura de repetición
DESDE.


Algoritmo PrgNumeros – main ( )
INICIO
NUMERO pares = 0 , ceros = 0 ,

negativos = 0 , num , res , i
Cálculo de
cantidad de
pares, ceros
y negativos.
pares, ceros ,
negativos
FIN

Algoritmo PrgNumeros – main ( )
Cálculo de
cantidad de
pares, ceros y
negativos.
DESDE i = 0 HASTA 49 FALSO
INCREMENTA 1
VERDADERO
num
res = num RESTO 2
VERDADERO
res == 0
FALSO
pares = pares + 1
VERDADERO
num==0
FALSO
ceros = ceros + 1
VERDADERO
num>0
FALSO negativos = negativos + 1

Clase PrgNumeros
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int pares = 0 , ceros = 0 , negativos = 0 ;

int num ;
for ( int i = 0 ; i < 50 ; i++ ) {
cout << “ Ingrese el número ” << ( i + 1 ) << “: ” ;

cin >> num ;
if ( num % 2 == 0 ) {
pares ++ ;
}
if ( num == 0 ) {
ceros ++ ;
}
if ( num < 0 ) {
negativos ++ ;
}
}
cout << “ Cantidad de números pares: ” << pares << endl ;

cout << “ Cantidad de números ceros: ” << ceros << endl ;
cout << “ Cantidad de números negativos: ” << negativos ;
cout << “ \n \n” ;

return 0 ;
}

Problema 092
Enunciado: Ingresar “n” números, luego determinar y mostrar los números pares y la cantidad total
de números impares ingresados. Utilice la estructura de repetición DESDE, para resolver el ejercicio.


En pseudocódigo:
Algoritmo PrgNumerosN – main ( )
ENTRADA: n , num
SALIDA: pares , numImpares
INICIO
NUMERO numImpares = 0 , num , n , i

TEXTO pares
LEER n
DESDE i = 0 HASTA n - 1
LEER num
pares = pares + num + “ ”
SINO
numImpares = numImpares + 1
FINSI
FINDESDE
ESCRIBIR pares
ESCRIBIR numImpares
FIN

Clase PrgNumerosN
class PrgNumerosN {
int numImpares = 0 , num , n ;

String pares = “ ” ;
System.out.print ( “ Ingrese la cantidad de números: ” ) ;

n = Lectura.leerInt ( ) ;
for ( int i = 0 ; i < n ; i++ ) {
System.out.print ( “Ingrese un número: ” ) ;

if ( num % 2 == 0 ) {
pares += num + “ ” ;
} else {
numImpares ++ ;
}
System.out.println ( “ \n Los números pares son: ” + pares ) ;

System.out.print ( “ Cantidad de números impares: ” + numImpares );
}
}
Clase PrgNumerosN
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::string ;
using std::endl ;
int main ( ) {
int numImpares = 0 , num , n ;

string pares = “ ” ;
cout << “ Ingrese la cantidad de números: ” ;

cin >> n ;
for ( int i = 0 ; i < n ; i++ ) {
cout << “Ingrese un número: ” ;

cin >> num ;
if ( num % 2 == 0 ) {
cout << “ \nNúmeros ” << num << “ es par.” ;
} else {
numImpares++ ;
}
cout << “ \n Cantidad de números impares: ” << numImpares ;
cout << “ \n \n” ;

return 0 ;
Analice esta solución en Java. Identifique las variaciones desarrolladas.

Problema 093
Enunciado: Ingresar las tres notas de todos los alumnos de un salón de clase y calcular el promedio
general. Utilice la estructura de repetición PARA, en la solución del problema.

INICIO
NUMERO n , n1 , n2 , n3 , prom , sumaProm = 0 , promGen , i
i=0
FALSO
i<n
VERDADERO
VE
n1 , n2 , n3
prom = ( n1 + n2 + n3 ) / 3
sumaProm = sumaProm + prom
i=i+1
promGen = sumaProm / n
promGen
FIN
Clase PrgPromedioG
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
int n ;
double n1, n2, n3 ;
double prom , sumaProm = 0 , promGen ;
cout << “ Ingrese el número de alumnos: ” ;

cin >> n ;
for ( int i = 0 ; i < n ; i++ ) {
cout << “ \n \t Ingrese nota1: ” ;

cin >> n1 ;
cout << “ \t Ingrese nota2: ” ;
cin >> n2 ;
cout << “ \t Ingrese nota3: ” ;
cin >> n3 ;
prom = ( n1 + n2 + n3 ) / 3 ;
sumaProm += prom ;
}
promGen = sumaProm / n ;
cout << “ \n \t El promedio general es : ” << promGen ;
cout << “ \n \n ” ;
return 0 ;
}

Clase PrgPromedioG
class PrgPromedioG {
int n ;
double n1 , n2, n3 ;
double prom , sumaProm = 0 , promGen ;
System.out.print ( “Ingrese el número de alumnos: ” ) ;

n = Lectura.leerInt ( ) ;
for ( int i = 0 ; i < n ; i++ ) {
System.out.print ( “ \n \t Ingrese nota1: ” ) ;

System.out.print ( “ \t Ingrese nota2: ” ) ;

System.out.print ( “ \t Ingrese nota3: ” ) ;

prom = ( n1 + n2 + n3 ) / 3 ;
sumaProm += prom ;
}
promGen = sumaProm / n ;
System.out.println ( “ \n \t El promedio general es: ” + promGen ) ;
}
}
Problema 094
Enunciado: Ingresar el precio de compra y el precio de venta de todos los artículos de una bodega.
Calcular y mostrar la utilidad de cada uno de los artículos. Utilice la estructura de repetición DESDE,
para la solución del problema.

Clase PrgUƟlidad
#include <iostream>
using std::cout ;
using std::cin ;
int main ( ) {
double precioCompra , precioVenta , utilidad ;
int numArticulos ;
cout << “ Ingrese el número de artículos: ” ;

cin >> numArticulos ;
for ( int i = 0 ; i < numArticulos ; i++ ) {
cout << “ \n\t Ingrese el precio de compra: ” ;
cin >> precioCompra ;
cout << “ \t Ingrese el precio de venta: ” ;

cin >> precioVenta ;
utilidad = precioVenta – precioCompra ;
cout << “ \t La utilidad del producto es: ” << utilidad << “\n” ;
cout << “\n \n” ;

return 0 ;
}
Clase PrgUƟlidad
class PrgUtilidad {
double precioCompra , precioVenta , utilidad ;

int numArticulos ;
System.out.print ( “Ingrese el número de artículos: ” ) ;

numArticulos = Lectura.leerInt ( ) ;
for ( int i = 0 ; i < numArticulos ; i++ ) {
System.out.print ( “ \n\t Ingrese el precio de compra: ” ) ;

precioCompra = Lectura.leerDouble ( ) ;
System.out.print ( “ \t Ingrese el precio de venta: ” ) ;

precioVenta = Lectura.leerDouble ( ) ;
utilidad = precioVenta – precioCompra ;
System.out.println ( “ \t La utilidad del producto es: ” +utilidad ) ;
}
}
Problema 095
Enunciado: Ingresar los nombres de todos los socios de un club y mostrar los nombres, de tal forma
que la primera letra esté en mayúscula y el resto en minúscula. Utilice la estructura de repetición
PARA.
Clase PrgSocios
class PrgSocios {
String nombre , primera , resto , lista = “ ” ;

int numSocios ;
System.out.print ( “ Ingrese el número de socios: ” ) ;

numSocios = Lectura.leerInt ( ) ;
for ( int i = 0 ; i < numSocios ; i++ ) {
System.out.print ( “ \t nombre del socio ” + ( i + 1 ) + “ : ” ) ;

primera = nombre.substring ( 0 , 1 ) ;
primera = primera.toUpperCase ( ) ;
resto = nombre.substring ( 1 ) ;
resto = resto.toLowerCase ( ) ;
nombre = primera + resto ;
lista += nombre + “ \n\t ” ;
}
System.out.println ( “ \n\t Los socios son: \n\t ” + lista ) ;
}
}
IMPORTANTE
Ahora, se recomienda solucionar los problemas propuestos del 31
al 50, que están planteados al final del presente capítulo.
PUNTO A PARTE
4.3 EMPAQUETAR APLICACIONES JAVA UTILIZANDO JAVA ARCHIVES (JAR)

Un Java ARchives o JAR permite empaquetar varios archivos en un solo archivo. Un JAR básico contiene
clases Java (.java o .class) y recursos auxiliares como imágenes y sonidos.
Para explicar cómo se crea y utiliza un JAR nos basaremos en la solución desarrollada para el problema
057, el cual se denominaba ProyNotaFinal2 y tenía los paquetes dominioDeLaAplicacion y biblioteca,
los cuales se muestran a continuación.
El paquete biblioteca contiene

la clase LE.class y el paquete
dominioDeLaAplicacion contiene
la clase PrgNotaFinal2.class.
Estos paquetes pueden contener
también sus archivos fuente
.java respectivos.
En la plataforma MS-Windows
los paquetes se visualizan como
carpetas y las clases Java como
archivos.
4.3.1 CREACIÓN DE UN JAR
Paso 1:
En la carpeta del proyecto creado (donde
están ubicadas las carpetas biblioteca y
dominioDeLaAplicacion) crearemos un
archivo de texto denominado manifiesto.
txt, en el cual colocaremos la siguiente
información:
Este archivo constituye nuestro archivo de manifiesto, el cual contiene una cabecera de propósito
especial denominada Main–Class. Esta cabecera permite indicar la clase que iniciará la ejecución
de la aplicación cuando se ejecute el archivo JAR. Es decir, indica la clase que contiene el método
main (en nuestro caso la clase PrgNotaFinal2.class ubicada en la carpeta dominioDeLaAplicacion).
Finalizada la creación del archivo manifiesto.txt tenemos:
Paso 2:
Creamos un archivo por lotes denominado CrearJar.bat, en el cual colocaremos la siguiente información:
La aplicación JAR permite realizar tareas básicas con archivos de tipo JAR. Esta aplicación es parte del
JDK. Observe que se han incluido las siguientes opciones:
c : Indica que se desea crear un JAR.

f : Indica que la salida se almacena en un archivo.
M: Indica que se deberá incluir información de manifiesto de un archivo de manifiesto existente.
v : Indica que muestre lo que sucede al momento de crear el JAR.
Como se ha incluido la opción m, lo siguiente que se deberá colocar es el nombre del archivo de
manifiesto existente, el cual se creó en el paso 1 con el nombre de manifiesto.txt; después, se coloca
el nombre que se desea tenga el archivo JAR, en nuestro caso PrgNotaFinal2.jar. Finalmente, se
colocan los nombres de los archivos o carpetas que se desean empaquetar en el JAR (observe que
se ha incluido las carpetas dominioDeLaAplicacion y biblioteca). Finalizada la creación del archivo
CrearJar.bat tenemos:
Paso 3:
Ejecutamos el archivo por lotes denominado CrearJar.bat (recuerde que para ejecutar el archivo
bastará con hacer doble clic con el botón izquierdo del mouse de la computadora sobre el nombre del
archivo). Al momento de ejecutar el archivo CrearJar.bat se puede observar una ventana en la cual se
muestra todo lo que sucede durante la creación del JAR denominado PrgNotaFinal2.jar (opción v).
Finalizada la ejecución, tenemos:
Resulta importante indicar que, cuando se crea un JAR, automáticamente se crea un archivo de
manifiesto denominado MANIFEST.MF, el cual se ubica en la carpeta META-INF (con la opción M se
deshabilita). El manifiesto por defecto tiene el siguiente contenido (o similar):
Manifest-Version: 1.0
Created-By: 1.5.0_06 (Sun Microsystems Inc.)
Como se puede observar, las entradas de un archivo de manifiesto tienen la forma "cabecera:valor" (el
nombre de una cabecera está separado de su valor por dos puntos).
Si al momento de crear el JAR se indica que se utilice adicionalmente información de manifiesto desde
un archivo de manifiesto existente (opción m), dicha información será añadida al archivo MANIFEST.
MF. En nuestro ejemplo, la información contenida en el archivo manifiesto.txt creado en el paso 1 se
añade en el archivo MANIFEST.MF (el archivo de manifiesto MANIFEST.MF se empaqueta en el JAR
junto con los demás archivos y/o carpetas). El archivo de manifiesto MANIFEST.MF resultante tendría
el siguiente contenido:
Manifest-Version: 1.0
Created-By: 1.5.0_06 (Sun Microsystems Inc.)
Main-Class: dominioDeLaAplicacion/PrgNotaFinal2
4.3.2. EJECUCIÓN DE UN JAR
Paso 4:
Finalizada la creación del JAR, procedemos a ejecutarlo (recuerde que para ejecutar el archivo
bastará con hacer doble clic con el botón izquierdo del mouse de la computadora sobre el nombre
del archivo). Al momento de ejecutar el archivo PrgNotaFinal2.jar se observa la ejecución de nuestra
aplicación PrgNotaFinal2.class:
Como puede observar, se ejecuta la aplicación sin necesidad de utilizar directamente el JDK (aunque
debe estar instalada la Java Virtual Machine o JVM), o sin necesidad de un IDE (como Eclipse o
JCreator). Recuerde que el archivo JAR ahora contiene todos los paquetes y clases que su aplicación
necesita para ejecutarse, y un archivo de manifiesto denominado MANIFEST.MF.
Si su aplicación se basa en el uso de la consola o tiene problemas para ejecutar su JAR, le

recomendamos crear un archivo por lotes y ejecutar el JAR desde dicho archivo. Como ejemplo,
crearemos el archivo por lotes denominado EjecutarJar.bat, tal y como se muestra a continuación:
Se utiliza la aplicación Java del JDK con la opción –jar para ejecutar el archivo PrgNotaFinal2.jar.
Si su JAR contiene una miniaplicación o Applet de Java, deberá crear un archivo HTML y utilizar los
siguientes TAGS:
< applet
code = NombreApplet.class
archive = "NombreJar.jar"
width = 350
height= 500 >
< /applet >
4.3.3 VISUALIZAR UN JAR
Es posible visualizar el contenido de un JAR. Como ejemplo, crearemos el archivo por lotes
denominado VerJar.bat, tal y como se muestra a continuación
Se utiliza la aplicación JAR del JDK con las opción ƞ para visualizar el archivo PrgNotaFinal2.jar.
t : Indica que se desea visualizar la tabla de contenidos de un JAR.

f : Indica que la información está contenida en un archivo tipo JAR.
Adicionalmente, puede utilizar la siguiente opción:
v : Permite obtener información adicional sobre los archivos empaquetados en el JAR, información
como el tamaño de los archivos y la última fecha de modifcación.
Al ejecutar el archivo por lotes VerJar.jar, se visualiza lo siguiente:

Como puede apreciar, se observan
las carpetas dominioDeLaAplicacion
y biblioteca con los archivos
PrgNotaFinal2.class y LE.class. También
puede observar la carpeta META-INF y
el archivo de manifiesto MANIFEST.MF.
4.3.4 EXTRACCIÓN DE UN JAR
Para explicar cómo se extrae un JAR,

eliminaremos todas las carpetas y
archivos existentes en la carpeta
ProyNotaFinal2, a excepción del JAR
creado.
Paso 1:
Creamos un archivo por lotes
denominado ExtraerJar.bat en el cual
colocaremos la siguiente información:
La aplicación JAR permite realizar tareas básicas con archivos de tipo JAR. Esta aplicación es parte del
JDK. Observe que se han incluido las siguientes opciones:
x : Indica que quieres extraer los ficheros de un JAR.

f : Indica que la extracción se realizará desde un archivo.
Cuando se extrae el contenido de un JAR, la aplicación JAR del JDK copia las carpetas y archivos
deseados y los escribe en el directorio actual, reproduciendo la estructura de directorios. El archivo
JAR original no se modifica. (Cuando se extraen carpetas y archivos, la herramienta JAR sobreescribe
cualquier carpeta o archivo que tenga el mismo nombre y ruta que las carpetas y archivos extraídos).
Finalizada la creación del archivo ExtraerJar.bat, tenemos:
Paso 2:
Ejecutamos el archivo por lotes denominado ExtraerJar.bat (recuerde que para ejecutar el archivo
bastará con hacer doble clic con el botón izquierdo del mouse sobre el nombre del archivo). Finalizada
la ejecución, tenemos:
Observe que se han creado las carpetas biblioteca y dominioDeLaAplicacion, las cuales contienen a
su vez los archivos LE.class y PrgNotaFinal2.class respectivamente. Adicionalmente, se ha creado la
carpeta META-INF, que contiene el archivo de manifiesto MANIFEST.MF.
Finalmente, es importante indicar que en la actualidad existen características más avanzadas ofrecidas
por los archivos JAR (incluyendo la firma electrónica, el control de versiones y el sellado de paquetes). Esto se
ha hecho posibles gracias a los archivos de manifiesto.
4.4 SOFTWARE PARA DECOMPILAR APLICACIONES JAVA
Es común que por error o descuido eliminemos información importante sobre nuestras aplicaciones.
En algunas ocasiones eliminamos las carpetas y archivos relacionados con esta, y solo contamos con el
archivo JAR creado; en otras, solo tenemos los archivos class, generados en la Etapa de Compilación,
pero no el archivo fuente (.java) a través del cual se generó el archivo class. En este contexto, resulta
importante tener herramientas que permitan descompilar los archivos class, con la finalidad de
recuperar los archivos fuente desarrollados en la Etapa de Edición.
La descompilación es el proceso inverso a la compilación. Mientras que esta es la etapa en la que se

genera un archivo class (archivo de código de bytes) en base a un archivo fuente, la descompilación es
la etapa que permite convertir un archivo class en un archivo fuente.
Es importante tener presente que la descompilación de clases puede constituir una violación del
acuerdo de licencia. Antes de utilizar herramientas de descompilación deberá consultar el acuerdo
de licencia de las clases. Recuerde que alrededor del mundo, el software es protegido por leyes de
derechos de autor (Copyrights).
4.4.1 USO DE JAVAP DEL JDK
La aplicación javap del JDK permite descompilar un archivo class, y muestra una versión
medianamente comprensible de dicha clase.
En la carpeta dominioDeLaAplicacion podemos observar el

archivo PrgNotaFinal2.class, pero no tenemos el archivo fuente
del cual se generó este archivo class.
Paso 1:
Creamos un archivo por lotes denominado DeCompilar.bat, en el cual colocaremos la siguiente
información:
Finalizada la creación del archivo DeCompilar.bat, tenemos:
Paso 2:
Ejecutamos el archivo por lotes denominado DeCompilar.bat, y se visualizará una versión general del
archivo fuente de dicha clase.
4.4.2 USO DE OTROS SOFTWARE
En la actualidad, existen diversos soŌwares que permiten descompilar un archivo class de Java. Algunos
ejemplos de descompiladores (decompilers) son:
- JCavaJ
- Jshrink
- DJ Java Decompiler
- FrontEnd Plus
A. JCavaJ: Pequeña y sencilla utilidad que permite generar el archivo fuente (.java) a partir de un
archivo class de Java, y lo reconstruye completamente. Esta utilidad es gratuita y puede bajarla de
Internet sin ningún inconveniente. Es importante mencionar que para que esta utilidad funcione
correctamente deberá tener instalado el JRE 1.4 o superior.
B. Jshrink: Esta utilidad es sencilla y puede adquirirla a través de Internet. Además de descompilar
archivos, genera archivos ejecutables (exe) y permite “camuflar” el código para dificultar su lectura
o que el archivo pueda ser descompilado.
}|Las herramientas que permiten “camuflar” el código también son conocidas como ofuscadores,
y se utilizan conjuntamente con los derechos de autor y patentes, como parte de una estrategia
de “Protección de Ideas”.
C. DJ Java Decompiler: Es un descompilador para Java, que permite reconstruir el código original
o archivo fuente a partir de un archivo class de Java. Este software es capaz de descompilar las
aplicaciones Java más complejas, para luego producir un preciso código. También es un completo
editor de Java que usa un sistema gráfico con syntax-coloring. DJ Java Decompiler es una aplicación
"autosuficiente", por lo que no será necesario tener instalado Java, Java Virtual Machine, ni
ninguna otra SDK de Java. Puede obtener copias de prueba del software en Internet.
En la actualidad, algunos sitios WEB le ofrecen el software libre de virus por un incremento
adicional de su precio normal. Solo recuerde que dicho pago es por la seguridad del sitio y no por
el software. Una vez que obtenga el software, deberá instalarlo en su PC (para este ejemplo se
utilizará la versión 3.9).
Observe la ventana principal del DJ Java Decompiler. En el panel principal se muestra el archivo
PrgNotaFinal2.class descompilado. En el panel inferior se muestran todos los métodos que tiene
la clase descompilada; al efectuar la descompilación, podrá guardar el archivo fuente ( .java)
generado.
Puede utilizar cualquier buscador de Internet para ampliar sus conocimientos sobre estos y otros
softwares; solo tendrá que colocar el nombre del software y podrá observar varios links que le
permitirán inclusive bajar el software a su PC.
4.5 MÉTODO DE LAS 6´D – USO DE CUADROS DE DIÁLOGO

soluciones, utilizando dos paquetes.
ENUNCIADO
DEL
PROBLEMA

información nombre del proyecto. de la solución del
deseada (salida). }|Definir los paquetes problema. Utilizar
}|Determinar los y desarrollar el lenguaje de
datos de entrada el diagrama de programación Java.
(entrada). paquetes respectivo. UƟlice la clase
}|Establecer cómo Establecer la reuƟlizable LE.
se solucionará dependencia. Utilice
el problema UML.
(proceso). }|Definir las clases
que serán parte
de la solución del
problema. Utilice
UML.
ALGORITMO
para el método
principal. UƟlizar
diagrama de
acƟvidades.
Problema 096
Enunciado: Ingresar un número entero. Calcular y mostrar el número factorial del número ingresado.
Adicionalmente, mostrar el proceso de cálculo del número factorial del número ingresado.
Desarrolle el algoritmo y la codificación en el lenguaje de programación Java. Finalmente, utilice la
clase LE para ingresar datos y mostrar información.

Algoritmo PrgFactorial – main ( )
INICIO
mensaje = “ ”,
i=1
LEER num
FALSO
I < num
VERDADERO
LEER num
LEER num
LEER num
FIN
Clase PrgFactorial
class PrgFactorial {
String mensaje = “” ;
long numero, factorial = 1 ;
numero = LE.leerLong ( “Ingrese un número” ) ;
for ( long i = 1 ; i < numero ; i ++ ) {

factorial = factorial * i ;
mensaje = mensaje + i + “ *\n” ;
}
mensaje = mensaje + “\n" + “El factorial es ” + factorial ;
LE.mostrarInformacion ( null, null , mensaje , null, null ) ;

System.exit ( 0 ) ;
}
}
Resultado:
El método mostrarInformacion( ) de la clase LE permite mostrar un cuadro de diálogo con un título

en la ventana, un título al interior de la ventana, información general, cambiar el color de fondo del
lugar donde se muestra la información y cambiar el nombre del botón de acción. En caso que se
desee mostrar gran cantidad de información, no existirá ningún inconveniente, ya que se activarán
los scroll del cuadro donde se muestra la información. Los scroll permiten mover el cuadro interior en
forma vertical o en forma horizontal, según lo desee el usuario, para poder visualizar la información
que no se ha podido ver. Observe la línea de código Java que permite mostrar el cuadro anterior.
LE.mostrarInformacion ( null, null , mensaje , null, null );
El método mostrarInformacion ( ) de la clase LE recibe cinco parámetros. El primero está referido al

título de la ventana. Si coloca una cadena de texto en el primer parámetro, esa cadena de texto será
la que se visualice en el título de la ventana; caso contrario, si coloca null se visualizará la cadena
“Información”. El segundo parámetro está referido a un título al interior de la ventana, que sería
como la cabecera de la información que se desea visualizar. Al igual que en el caso anterior, si coloca
una cadena de texto en el segundo parámetro, esta será la que se visualice como el título al interior
de la ventana o cabecera; caso contrario, si coloca null no se visualizará un título al interior de la
ventana. El tercer parámetro esta referido a la información que desea mostrar en el cuadro al interior
de la ventana. Para el ejemplo, se visualiza la variable mensaje, que contiene la información referida
al factorial de un número. El cuarto parámetro esta referido al nombre del botón. Si coloca null en
el cuarto parámetro, el botón estará etiquetado con la palabra “Aceptar”, y si coloca una cadena de
texto será la que aparecerá como etiqueta del botón. El último parámetro está referido al color del
cuadro al interior de la ventana. Dicho color puede modificarlo utilizando la clase Color del paquete
java.awt de Java. Si no desea modificar el color del cuadro al interior de la ventana, solo deberá
colocar null en el último parámetro.
En las siguientes soluciones podrá apreciar los diferentes usos del método mostrarInformacion (
). Observe que en todo momento deberá colocar dentro de los paréntesis del método los cinco
parámetros definidos.
Problema 097
Enunciado: Ingresar dos números y mostrar todos los múltiplos de 5 comprendidos entre dichos
números. Considerar que el primer número ingresado puede ser mayor que el segundo número, y
que ambos números pueden ser iguales. Desarrolle la codificación en el lenguaje de programación
Java. Utilice la clase LE para ingresar datos y mostrar información.
Clase PrgMulƟplos
class PrgMultiplos {
String mensaje = “” , titulo = “” ;

int num1 , num2 , numMay , numMen ;
num1 = LE.leerInt ( “Ingrese un número” ) ;

num2 = LE.leerInt ( “Ingrese un segundo número” ) ;

numMay = num2 ;
numMen = num1 ;
} else {
numMay = num1 ;
numMen = num2 ;
}
if ( numMay == numMen ) {
mensaje = “Los números ingresados son iguales ” ;
LE.mostrarInformacion ( null, null, mensaje, null, null ) ;
} else {
titulo = “Los números múltiplos de 5 entre los números ”

+ numMen + “ y ” + numMay + “ son: ” ;
for ( int i = numMen ; i < numMay ; i ++ ) {

if ( i % 5 == 0 ) {
mensaje = mensaje + i + “\n” ;
}
}
LE.mostrarInformacion ( null, titulo , mensaje , null, null ) ;

}
System.exit ( 0 ) ;
}
}
Resultado:
Este cuadro de diálogo se obtiene utilizando la siguiente sentencia:
LE.mostrarInformacion ( null, titulo , mensaje , null, null ) ;
Observe que se utiliza el segundo y el tercer parámetro.

Problema 098
Enunciado: Desarrollar una solución que muestre un menú de opciones y permita obtener la
siguiente información en un salón de clase:
A. ¿Cuántas alumnas y cuántos alumnos están matriculados en el curso?

B. ¿Cuántas alumnas son menores de 16 años y cuántos alumnos son mayores de 21 años?
Clase PrgCurso
class PrgCurso {
String tituloVentana = “Información de alumnos” ;

String titulo = “Datos generales”, mensaje = “” ;
String menu , tipoSexo [ ] = { “Masculino” , “Femenino” } ;

int opc , sexo = 0 , edad = 0 ;
long hombres = 0 , homMayores = 0 , mujeres = 0, mujMenores = 0 ;
do {
menu = “***** MENU *****\n”

+ “[1] Ingresar datos de alumnos\n”
+ “[2] Mostrar resultados\n”
+ “[3] Finalizar\n”
+ “---------------------------------\n”
+ “Seleccione la opción desea:” ;
opc = LE.leerInt ( menu ) ;
switch ( opc ) {
case 1 :
edad = LE.leerInt ( “Ingrese la edad del alumno” ) ;

sexo = LE.seleccionarOpcionIndex ( “Ingrese sexo” ,null ,
tipoSexo ) ;
if ( sexo == 0 ) {
hombres++ ;
if ( edad > 21 ) {
homMayores++ ;
}
}
if ( sexo == 1 ) {
mujeres++ ;
if ( edad < 16 ) {
mujMenores++ ;
}
}
break ;
case 2 :
mensaje = “\nNúmero de alumnas matriculadas: ” ;

mensjae += mujeres ;
mensaje += “\nNúmero de alumnos matriculados: ” ;
mensaje += hombres ;
mensaje += “\nAlumnas menores de 16 años: ” ;
mensaje += mujMenores ;
mensaje += “\nAlumnos mayores de 21 años: ” ;
mensaje += homMayores ;
LE.mostrarInformacion ( tituloVentana, titulo , mensaje ,

null , Color.lightGray ) ;
break ;
case 3 :
System.out.println ( “Aplicación finalizada... ” ) ;

break ;
default :
LE.mostrarError ( “Opción no válida... Reintente! ” ) ;

}
} while ( opc != 3 ) ;
System.exit ( 0 ) ;
}
}
Resultado:
El cuadro anterior de diálogo se obtiene utilizando la siguiente sentencia:
LE.mostrarInformacion ( tituloVentana, titulo , mensaje , null , Color.lightGray ) ;
Observe que se utiliza el primer, segundo, tercero y cuarto parámetro.
Problema 099
Enunciado: Desarrollar una solución que permita ingresar la clave o palabra secreta de una persona
y muestre las vocales de dicha clave o palabra secreta. Considerar que al momento de ingresar la
clave o palabra secreta, esta no se deberá visualizar.
Clase PrgClave
class PrgClave {
String tituloVentana = “Información secreta” ;

String titulo = “Vocales de la clave ingresada”, mensaje = “” , clave ;
char letra ;
clave = LE.leerClave ( “Hola ¿cómo estás?” , “Ingresa tu clave” ) ;
if ( clave.length ( ) != 0 ) {
mensaje = “La clave del empleado es secreta...\n ” ;

mensaje += “\nSolo se visualizarán la vocales de la clave: ” ;
mensaje += “\n" ;
for ( int i = 0 ; i < clave.length( ) ; i++ ) {

letra = Character.toLowerCase ( clave.charAt (i) ) ;
if ( letra == ‘a’ || letra == ‘e’|| letra == ‘i’ || letra == ‘o’
|| letra == ‘u’ ) {
mensaje += letra + “\n” ;
} else {
mensaje += “*” + “\n” ;
}
}
mensaje += “\n...Recuerde nunca revelar su clave secreta.” ;
LE.mostrarInformacion ( tituloVentana, titulo , mensaje ,
“Finalizar...” , Color.cyan ) ;
}
System.exit ( 0 ) ;
}
}
Resultado:
El método leerClave( ) de la clase LE, permite mostrar un cuadro de diálogo con un título en la
ventana y un mensaje interno. Observe que cuando el usuario ingresa la clave, esta no se visualiza
y en su lugar aparecen asteriscos. Observe la línea de código Java, que permite mostrar el cuadro
anterior.
clave = LE.leerClave ( “Hola ¿cómo estás?” , “Ingresa tu clave” ) ;
El primer parámetro del método leerClave ( ) de la clase LE está referido al título de la ventana,
mientras que el segundo parámetro está referido al mensaje que se muestra junto a la caja de texto
al interior de la ventana. Otro detalle importante a destacar es que los nombres de los botones han
sido personalizados.
Problema 100
Enunciado: Desarrollar una solución que permita ingresar la clave o palabra secreta de una persona,
y que muestre las vocales de dicha clave. Considerar que al momento de ingresar la clave, esta no
se deberá visualizar.
Clase PrgPrimo
class PrgPrimo {
String mensaje = “Ingrese un número” ;

int num ;
boolean sw = true ;
do {
num = LE.leerInt ( mensaje ) ;
if ( num < 1) {
mensaje = “Error... Ingrese un número mayor que 0 ” ;
}
} while ( num < 1 ) ;
for ( int i = 2 ; i < num ; i++ ) {

if ( num % i == 0 ) {
sw = false ;
break ;
}
}
if ( sw ) {
LE.mostrarInformacion ( “El número ” + num + “ es primo ” ) ;
} else {
LE.mostrarInformacion ( “El número ” + num + “ no es primo ” ) ;
}
System.exit ( 0 ) ;
}
}
Resultado:
IMPORTANTE
Ahora, se recomienda solucionar todos los problemas propuestos
planteados al final del presente capítulo, uƟlizando la clase
reuƟlizable LE.
1. Ingrese un número entero positivo y determine si el número ingresado es múltiplo de 3.

Consistencie la entrada de datos (el número ingresado deberá ser mayor que cero) y utilice la
estructura de repetición HACER.
2. Ingrese un número entero positivo y determine si el número ingresado es un número par y/o
múltiplo de 4. Consistencie la entrada de datos (el número ingresado deberá ser mayor que cero)
y utilice la estructura de repetición HACER.
3. Ingrese el precio de compra, el precio de venta y el stock de un determinado producto. Calcule
y muestre la utilidad en caso se vendieran todos los productos. Consistencie la entrada de datos
(precio de compra mayor que cero, precio de venta mayor que precio de compra y stock mayor
que cero) y utilice la estructura de repetición HACER.
4. Ingrese el nombre de una persona. Muestre las dos primeras letras del nombre ingresado en letra
mayúscula. Consistencie la entrada de datos (nombre tiene que ser de una longitud mayor a 1) y
utilice la estructura de repetición HACER.
5. Ingrese el nombre de una persona. Muestre la primera letra del nombre ingresado en letra
minúscula y la última letra en mayúscula. Consistencie la entrada de datos (nombre tiene que ser
de una longitud mayor a 1) y utilice la estructura de repetición HACER.
6. Desarrolle un menú de opciones con lo siguiente. Utilice la estructura de repetición HACER.
[1] Ingresar un número.
[2] Mostrar si el número es par o no.
[3] Mostrar si el número es múltiplo de 3.
[4] Mostrar si el número es múltiplo de 5.
[5] Finalizar.
En la solución de este problema deberá evitar que el usuario seleccione la opción 2 sin antes
haber seleccionado la opción 1.
7. Desarrolle un menú de opciones con lo siguiente. Utilice la estructura de repetición HACER.

[1] Ingresar un nombre.
[2] Mostrar la primera letra del nombre en mayúscula.
[3] Determinar si la última letra es una vocal o no.
[4] Mostrar las dos primeras letras del nombre.
[5] Finalizar.
En la solución de este problema deberá primero visualizar solo la opción 1 y 5. Una vez ingresadas
las notas, deberá visualizar todas las opciones.
8. Desarrollar una solución que permita mostrar los 125 primeros números enteros existentes. No
deberá ingresar datos. Utilice la estructura de repetición HACER.
9. Desarrollar una solución que permita mostrar los números múltiplos de 6 comprendidos entre los
números 10 y 1230. No deberá ingresar datos. Utilice la estructura de repetición HACER.
10. Mostrar los números pares y la cantidad de números múltiplos de 5 comprendidos entre dos
números ingresados por teclado. Utilice la estructura de repetición HACER.
11. Mostrar la cantidad de números pares y los números múltiplos de 10 comprendidos entre dos
números ingresados por teclado. Utilice la estructura de repetición HACER.
12. Calcular y mostrar la nota final que obtuvieron todos los alumnos de un salón de clase. El cálculo
de la nota final se realiza en base a 3 notas utilizando la siguiente fórmula:
nf = ( n1 + n2 + n3 ) / 3.
Ingrese las 3 notas a través del teclado. No ingrese el total de alumnos. Utilice la estructura de
repetición HACER.
13. Calcular y mostrar la nota final que obtuvieron todos los alumnos de un salón de clase. El cálculo
de la nota final se realiza en base a 3 notas utilizando la siguiente fórmula:
nf = ( ( n1 * 2 ) + n2 + ( n3 * 2 ) ) / 5.
Ingrese las 3 notas a través del teclado. No ingrese el total de alumnos. Utilice la estructura de
repetición HACER.
14. Determinar el promedio de sueldos de los obreros (categoría 1), la suma de sueldos de los
empleados (categoría 2), y el mayor sueldo de los gerentes (categoría 3) de una determinada
empresa. No deberá ingresar el total de trabajadores. Utilice la estructura de repetición HACER.
15. Calcular y mostrar el número de alumnos que tienen promedio final menor a 6, de 6 a 10, de 11 a
14, de 15 a 17, y los alumnos que tienen promedio final mayor a 17. Ingresar las cuatro notas de
cada alumno y calcular su promedio en base a la siguiente fórmula:
nf = ( n1 + n2 + n3 + n4 + nMayor - nMenor ) / 4.
Es decir, se anula la nota más baja y se duplica la nota mayor. Utilice la estructura de repetición
HACER.
16. Calcular y mostrar la cantidad de números múltiplos de 3 y la suma de números múltiplos de 5

menores a 128. Utilice la estructura de repetición MIENTRAS.
17. Calcular y mostrar el promedio de todos los números pares y la suma de todos los números
impares comprendidos entre 120 y 1237. Utilice la estructura de repetición MIENTRAS.
18. Mostrar todos los números múltiplos de 3 y de 5 comprendidos entre dos números ingresados a
través del teclado. Utilice la estructura de repetición MIENTRAS.
19. Ingresar las 4 notas de 50 alumnos de un salón de clase y calcular el promedio de cada uno de
ellos. Para el promedio considere que se duplica la mayor nota. Utilice la estructura de repetición
MIENTRAS.
20. Ingrese el promedio de 50 alumnos de un salón de clase y calcular el promedio general de todos
los alumnos desaprobados y el promedio de todos los alumnos aprobados. Utilice la estructura
de repetición MIENTRAS.
21. Ingresar las cuatro notas de todos los alumnos de un salón de clase. Calcular el promedio de cada
uno de ellos. Para el promedio considere que se elimina la menor nota. Utilice la estructura de
22. Ingresar las cuatro notas de todos los alumnos de un salón de clase. Calcular el promedio de cada
uno de ellos y el promedio general. Utilice la estructura de repetición MIENTRAS.
23. Ingresar un número. Calcular y mostrar el número de cifras pares que tiene dicho número. Utilice
la estructura de repetición MIENTRAS.
24. Ingresar un número. Calcular y mostrar la suma de todas las cifras menores que 5. Utilice la
estructura de repetición MIENTRAS.
25. Ingrese dos números. Calcular y mostrar la suma de todas las cifras impares de ambos números.
Utilice la estructura de repetición MIENTRAS.
26. Calcular y mostrar el porcentaje de alumnos aprobados y el porcentaje de alumnos desaprobados
de un salón de clase. El cálculo de la nota final se realiza en base a tres notas, utilizando la siguiente
fórmula:
nf = ( ( n1 * 2 ) + n2 + ( n3 * 2 ) ) / 5.
Ingrese las tres notas a través del teclado. No ingrese el total de alumnos. Utilice la estructura de
27. Determinar la suma de sueldos de los obreros (categoria 1), el menor sueldos de los empleados
(categoria 2) y el sueldo promedio de los gerentes (categoria 3) de una determinada empresa. No
deberá ingresar el total de trabajadores. Utilice la estructura de repetición MIENTRAS.
28. Desarrollar una solucion que permita obtener la siguiente información de los empleados de una
empresa. Utilice la Estructura de repetición MIENTRAS:
}|¿Cuántas empleadas y cuántos empleados son nombrados?
}|¿Cuántas empleadas y cuántos empleados son contratados?
}|¿Cuántas empleadas son menores de edad y cuántos empleados son mayores de edad?
29. Ingresar un número entero. Calcular y mostrar el factorial del número ingresado. Utilice la
estructura de repetición MIENTRAS.
30. Desarrolle una solución que permita generar 100 números aleatorios de dos cifras, y determine la
cantidad de números aleatorios generados cuyo último dígito es un número 6.
31. Ingresar un número. Calcular y mostrar los números múltiplos del número 4 y del número 6
menores al número ingresado. Utilice la estructura de repetición DESDE o PARA.
32. Desarrollar una solución que permita ingresar el número de términos que tiene una serie y
muestre sus términos, en base a lo siguiente. Utilice la estructura de repetición DESDE o PARA.
2, 5, 8, 11, 15,…
33. Desarrolle un programa que muestre los términos de la serie mostrada. Deberá ingresar el número
de términos que se desea mostrar y deberá tener en cuenta que a partir del tercer término, cada
término es igual a la suma de los dos términos anteriores. Utilice la estructura de repetición
DESDE o PARA.
1, 2, 3, 5, 8, 13,…
34. Desarrolle un programa que muestre los términos de la serie mostrada. Deberá ingresar el número
de términos que se desea mostrar. Utilice la estructura de repetición DESDE o PARA.
1, 1/2, 1/4, 1/6, 1/8, 1/10,…
35. Ingresar 80 números. Determinar y mostrar la suma de números positivos, la cantidad de ceros
y la suma de números negativos ingresados. Utilice la estructura de repetición DESDE o PARA.
36. Ingresar tres números. Determinar y mostrar los números pares que están comprendidos entre
los dos menores números ingresados y los números impares comprendidos entre los dos mayores
números ingresados. Utilice la estructura de repetición DESDE o PARA.
37. Ingresar las tres notas de todos los alumnos de un salón de clase y calcular el promedio de cada
uno de los alumnos, el promedio general, la mayor nota y la menor nota. Utilice la estructura de
repetición DESDE o PARA.
38. Ingresar las cuatro notas de todos los alumnos de un salón de clase y calcular el promedio de
cada uno de los alumnos, el porcentaje de aprobados y el porcentaje de desaprobados. Para el
cálculo del promedio, considerar que se deberá eliminar la menor nota. Utilice la estructura de
repetición DESDE o PARA.
39. Ingresar el nombre de una persona. Determinar y mostrar el número de vocales que tiene el
nombre, la cantidad de letras “a” y la cantidad de letras “p”. Utilice la estructura de repetición
DESDE o PARA.
40. Ingresar el nombre y el apellido de todos los socios de un club. Mostrar los nombres y apellidos
de tal forma que la primera letra este en mayúscula y el resto en minúscula. Utilice la estructura
de repetición DESDE o PARA.
41. Desarrollar una solución que permita ingresar la edad y el sexo de todas las personas que viven
en un distrito, y determine lo siguiente:
}|La suma de todas las edades de las mujeres.
}|El promedio de las edades de los hombres.
}|El número de personas mayores de edad.
Utilice la estructura de repetición DESDE o PARA.
42. Desarrollar una solución que permita ingresar el nombre y la edad de todas las personas que
viven en un distrito, y determine lo siguiente:
}|La cantidad de edades múltiplo de 5.
}|La edad mayor.
}|El nombre de la persona o las personas que tiene la menor edad.
43. Desarrollar una solución que permita ingresar el nombre y el sueldo de todas los empleados de
una empresa, y determine lo siguiente:
}|La cantidad de nombres que comienzan con las letras “a” o “A”.
}|El nombre de la persona o las personas que tiene el sueldo promedio.
44. Desarrollar una solución que permita ingresar un número. Determinar y mostrar el dígito mayor
del número ingresado. Utilice la estructura de repetición DESDE o PARA.
45. Desarrollar una solución que permita ingresar un número. Determinar y mostrar el número de
veces que se repite el menor dígito del número ingresado. Utilice la estructura de repetición
DESDE o PARA.
46. Desarrollar una solución que permita ingresar un número. Determinar y mostrar el menor número
que se puede formar con sus dígitos. Utilice la estructura de repetición DESDE.
47. Desarrollar una solución que permita ingresar un número. Determinar y mostrar el número con el
primer dígito y el último dígito intercambiado. Utilice la estructura de repetición DESDE o PARA.
48. Desarrollar una solución que permita ingresar una palabra. Determinar si la palabra ingresada
es un palíndromo o no (Nota: Palíndromo es una palabra o frase que se lee igual de izquierda a
derecha y viceversa). Utilice la estructura de Repetición DESDE o PARA.
49. Desarrollar una solución que permita ingresar una palabra. Determinar y mostrar qué vocales
existen y cuántas veces se repiten. Utilice la estructura de repetición DESDE o PARA.
50. Desarrollar una solución que permita ingresar el nombre completo de una persona (ingresar los
nombres y apellidos en una sola variable). Mostrar cada nombre y cada apellido de la persona, la
primera letra en mayúscula y las demás letras en minúsculas. Utilice la estructura de repetición
DESDE o PARA.
Cap.
E st r u c t u r a s l ó g i c a s
combinadas
5
CAP. 5: Estructuras lógicas combinadas 437
El presente capítulo es un complemento de los capítulos 2, 3 y 4, y trata sobre el uso de las estructuras
lógicas en forma combinada y el manejo de excepciones en el lenguaje de programación Java.
Con las estructuras lógicas se desarrollan algoritmos, que pueden ser diseñados en pseudocódigo o
diagramas de flujo, y después codificados en un lenguaje de programación.
En este capítulo se emplearán las técnicas para el ingreso de datos y visualización de la información
utilizando la consola (solo caracteres), y las que emplean cuadros de diálogo.
Para iniciar el estudio del quinto capítulo es indispensable el dominio de las estructuras lógicas de
secuencia, estructuras lógicas de decisión y estructuras lógicas de repetición tratadas en los capítulos
anteriores.
Es importante mencionar que la capacidad de poder utilizar las estructuras lógicas en forma combinada,
diferencia la eficiencia de los programadores.
ENUNCIADO
DEL
PROBLEMA
Etapa 02 MARCO DE TRABAJO

Definición
Solución
Etapa 03
Diseño
Solución
Etapa 04
MODELAMIENTO
Desarrollo
ALGORITMO solución
CODIFICACIÓN
En el desarrollo de las primeras veintidós soluciones se puede apreciar el uso de las diferentes
estructuras lógicas, cómo se diseñan los algoritmos utilizando el pseudocódigo o el diagrama de flujo,
y cómo se codifican en el lenguaje de programación C++ o Java. Esto permite mejorar su comprensión
en el uso de las estructuras lógicas.
En las siguientes cuatro soluciones se enfoca el manejo de excepciones en el lenguaje de programación

Java, usando la estructura try/catch, concepto imprescindible que deberá dominar para desarrollar las
aplicaciones profesionales.
En las diecinueve soluciones posteriores, se aprecia el uso de las diferentes estructuras lógicas y cómo
se codifican en el lenguaje de programación Java. Esto permite mejorar el desarrollo de su capacidad
lógica.
Finalmente, para desarrollar las últimas cinco soluciones se utiliza el lenguaje de programación
Java, para codificar la solución utilizando la clase reutilizable LE. En esta parte se utilizan métodos
complementarios de la clase LE, que permiten plantear soluciones más vistosas y amigables para el
usuario, utilizando cuadros de diálogo.
MODELAMIENTO
PROYECTO
CODIFICACIÓN
dominioDeLaAplicación biblioteca
Nombre
Clase
Atributos
Método ( ) ALGORITMO Sentencias

Declaración y
Descripción de datos definición de datos
- Estructuras lógicas de secuencia
- Estructuras lógicas de decisión
- Estructuras lógicas de repetición
ALMACENADOS EN:
- Estructuras de datos (variable)
Contadores
Acumuladores
Centinelas
5.1 UsO COmbinadO dE las EsTRUCTURas lógiCas

Como se ha mencionado antes, existen diferentes estructuras lógicas, las cuales se utilizan en forma
combinada y anidada en la solución de problemas.
Es común que en las soluciones que se planteen se utilice una o más de estas estructuras lógicas. Puede
utilizarse una estructura lógica de decisión doble y una estructura lógica de repetición HACER en una
solución; una estructura lógica de decisión simple, una estructura de decisión doble y dos estructuras
lógicas de repetición DESDE o PARA en otra solución, así como otras combinaciones posibles.
El desarrollador de soluciones debe tener la habilidad y la capacidad para identificar qué estructuras
lógicas debe utilizar para abordar la solución de un determinado problema. No existe una solución
única, pero es importante utilizar las estructuras lógicas en forma correcta para asegurar una adecuada
solución al problema y su posterior facilidad en el mantenimiento.
A continuación, se presentan algunas soluciones que permiten ilustrar el uso combinado de las
estructuras lógicas.
Por motivo de espacio y porque la Etapa 02 (Definición de la solución) es recurrente en todos los
problemas que se han realizado, no se desarrollará en las siguientes soluciones, ni se ha considerado
hacerlo en la parte de Modelamiento de la Etapa 03 (Diseño de la solución) por las mencionadas
razones. Sin embargo, es importante realizar las mencionadas etapas para asegurar una correcta y
eficiente definición de la solución.
Problema 101
Enunciado: Desarrollar una solución que permita ingresar varios números. Determinar y mostrar
los números ingresados que son números primos. Finalmente, constatar el ingreso de los datos.
Definir el nombre del proyecto, luego desarrollar la definición de paquetes, el diagrama de paquetes
y la definición de las clases.
En pseudocódigo:
Algoritmo PrgNumerosPrimos – main ( )
ENTRADA: cantNum , primo

SALIDA: lista
INICIO
NUMERO cantNum , primo , i , j

LOGICO sw = VERDADERO
HACER
LEER cantNum
SI ( cantNum <= 0 ) ENTONCES

ESCRIBIR “Número ingresado no válido”
FINSI
MIENTRAS ( cantNum <= 0 )
DESDE i = 0 HASTA cantNum -1
HACER
LEER primo
SI ( primo <= 0 ) ENTONCES
ESCRIBIR “El número debe ser <= 1”
FINSI
MIENTRAS ( primo <= 0 )
DESDE j = 2 HASTA primo – 1
SI ( primo RESTO j == 0 ) ENTONCES
sw = FALSO
FINSI
FINDESDE
SI ( sw ) ENTONCES
lista = lista + primo + SALTOLINEA
FINSI
sw = VERDADERO
FINDESDE
ESCRIBIR “Los números primos son: ” + lista
FIN
Intente diseñar el algoritmo en diagrama de flujo.
Observe que para diseñar el pseudocódigo se han utilizado estructuras lógicas en forma combinada;
estructuras lógicas de secuencia, una estructura lógica de repetición HACER y una estructura
lógica de repetición DESDE. Dentro de la estructura lógica de repetición DESDE se ha incluido una
estructura lógica de repetición HACER, una estructura lógica de repetición DESDE y una estructura
lógica de decisión SIMPLE; es decir, existen estructuras lógicas combinadas y anidadas, una en
relación con las otras, en la solución.
Esto significa que al diseñar el algoritmo en el diagrama de flujo, se deberá tener en cuenta que
dentro de una de las estructuras lógicas de repetición DESDE, se debe hacer el diagrama de las otras
tres estructuras lógicas.
FALSO Aquí, se debería hacer el

diagrama de otras estructuras
lógicas.
VERDADERO
Etapa 04 - Desarrollo de la codificación
Clase PrgNumerosPrimos
class PrgNumerosPrimos {
int cantNum , primo ;
String lista = “\n\n” ;
boolean sw = true ;
do {
System.out.println ( “Cuántos números va a ingresar ” ) ;
cantNum = Lectura.leerInt ( ) ;
if ( cantNum <= 0 )
System.out.println ( “Número ingresado no válido…” ) ;
} while ( cantNum <= 0 ) ;

for ( int i = 0 ; i < cantNum ; i++ ) {
do {
System.out.println ( “Ingrese número ” + ( i + 1 ) ) ;
primo =Lectura.leerInt ( ) ;
if ( primo <= 0 )
System.out.println (“El número debe ser >=1 ”);
} while ( primo <= 0 ) ;
for ( int j = 2 ; j < primo ; j++ ) {
if ( primo % j == 0 )
sw = false ;
}
if ( sw ) {
lista = lista + primo + “\n” ;
}
sw = true ;
}
System.out.println ( “Los números primos son : \n ” + lista ) ;
}
}
Intente desarrollar la codificación en el lenguaje de programación C++.

Problema 102
Enunciado: Ingresar 10 números a través del teclado y determinar la suma de todos los números
pares y la suma de todos los números impares. Constatar el ingreso de los datos.

En diagrama de flujo
Algoritmo PrgSocios – main ( )
INICIO
NUMERO num , sumPar = 0 , sumImp = 0 , res , i
FALSO
DESDE i = 1 HASTA 10
INCREMENTA i en 1
VERDADERO
Cálculo de la
suma de números
pares e impares
sumPar , sumImp
FIN
Algoritmo PrgSocios – main ( )
Cálculo de la
suma de números
pares e impares.
num
VERDADERO
num <= 0
FALSO “error”
num <= 0
VERDADERO FALSO
res = num RESTO 2
FALSO VERDADERO
res==0
sumImp = sumImp + num sumPar = sumPar + num

Clase PrgSocios
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int num , sumPar = 0 , sumImp = 0 ;
for ( int i = 1 ; i <= 10 ; i++ ) {
do {
cout << “Ingrese un número: ” << endl ;
cin >> num ;
if (num <= 0 ) {
cout << “Número ingresado no válido ” << endl ;
}
} while ( num <= 0) ;
if ( num % 2 == 0 ) {
sumPar = sumPar + num ;
} else {
sumImp = sumImp + num ;
}
cout << “Suma de números pares: ” << sumPar << endl ;

cout << “Suma de números impares: ” << sumImp << endl ;
return 0 ;
}
Intente desarrollar la codificación en el lenguaje de programación Java.

Problema 103
Enunciado: Ingresar las tres notas de todos los alumnos de un salón de clase. Calcular y mostrar el
promedio de notas de cada alumno. Adicionalmente, si el alumno obtiene un promedio final mayor
a 16, se deberá visualizar un mensaje de felicitaciones. Constatar el ingreso de las notas.
Definir el nombre del proyectol, desarrollar la definición de paquetes, el diagrama de paquetes y

la definición de las clases.

En pseudocódigo:
Algoritmo PrgPromedio – main ( )
ENTRADA: numAlu , nota1 , nota2 , nota3

SALIDA: promedio
INICIO
ENTERO numAlu , i
REAL nota1 , nota2 , nota3 , promedio
LEER numAlu
DESDE i = 0 HASTA numAlu - 1
HACER
LEER nota1 , nota2 , nota3
MIENTRAS ( ( nota1 < 0 AND nota1 > 20 ) OR

( nota2 < 0 AND nota2 > 20 ) OR
( nota3 < 0 && nota3 > 20 ) )

ESCRIBIR promedio
SI ( promedio > 16 ) ENTONCES

ESCRIBIR “FELICITACIONES”
FINSI
FINDESDE
FIN

Clase PrgPromedio
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double nota1 , nota2 , nota3 ;

double promedio ;
int numAlum ;
cout << “Ingrese la cantidad de alumnos: ” << endl ;

cin >> numAlum ;
for ( int i = 0 ; i < numAlum ; i++ ) {

do {
cout << “Alumno [ ” << ( i + 1 ) << “ ] ” << endl ;
cout << “Ingrese nota1: ” << endl ;
cin >> nota1 ;
cin >> nota2 ;
cin >> nota3 ;
} while ( ( nota1 < 0 && nota1 > 20 ) || ( nota2 < 0
&& nota2 > 20 ) || ( nota3 < 0 && nota3 > 20 ) ) ;

cout << “Promedio del alumno ” << ( i + 1 ) << “ : ” ;
cout << promedio << “ … ” ;
if ( promedio > 16 ) {
cout << “Felicitaciones ” ;
}
cout << endl ;
}
return 0 ;
}
También puede mejorar la solución. Para ello, consistencie el ingreso del valor de la variable numAlu (utilice
la estructura lógica HACER), y cambie la forma de consistenciar el ingreso de las notas, de tal forma que cada
una de las notas se consistencie en forma independiente (incluya un mensaje si la nota que se ingresa no es
válida).
Problema 104
Enunciado: Calcular y mostrar el sueldo de todos los trabajadores de una empresa conociendo el
número de horas trabajadas y su tarifa horaria, sabiendo que se debe descontar 20 % por concepto
de impuestos si este es mayor a S/. 1600 nuevos soles. Consistenciar el ingreso de los datos.

En diagrama de flujo:
INICIO
NUMERO numT , horas , tarifa , sueldo , i
DESDE i = 0 HASTA numT -1 FALSO
INCREMENTA i en 1
VERDADERO
Cálculo del sueldo

de los trabajadores.
Mostrar sueldo
FIN
Cálculo del sueldo

de los trabajadores.
Mostrar sueldo.
horas
horas < 1
VERDADERO
FALSO
tarifa
tarifa < 1
VERDADERO FALSO
sueldo = tarifa * horas
VERDADERO
sueldo > 1600

FALSO
Sueldo

Clase PrgSueldo
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int horas , numT ;

double tarifa , sueldo ;
cout << “Ingrese la cantidad de trabajadores: ” << endl ;

cin >> numT ;
for ( int i = 0 ; i < numT ; i++ ) {
do {
cout << “Ingrese las horas del trabajador:” <<( i + 1 ) ;
cin >> horas ;
} while ( horas < 1 ) ;
do {
cout << “Ingrese la tarifa del trabajador:” <<( i + 1 ) ;
cin >> tarifa ;
} while ( tarifa < 1 ) ;
sueldo = tarifa * horas ;
if ( sueldo > 1600 ) {

}
cout << “El sueldo del trabajador ” << ( i + 1 ) << “ es: ” ;

cout << sueldo ;
}
return 0 ;
}
Clase PrgSueldo
class PrgSueldo {
int horas , numT ;

double tarifa , sueldo ;
System.out.println ( “Ingrese la cantidad de trabajadores\n ” ) ;

numT = Lectura.leerInt ( ) ;
for ( int i = 0 ; i < numT ; i++ ) {
do {
System.out.println ( “Horas del trabajador ” + ( i + 1 ) ) ;
horas = Lectura.leerInt ( ) ;
} while ( horas < 1 ) ;
do {
System.out.println ( “Tarifa del trabajador ” + ( i + 1 ) ) ;
tarifa = Lectura.leerDouble ( ) ;
} while ( tarifa < 1 ) ;
sueldo = tarifa * horas ;
if ( sueldo > 1600 ) {

}
System.out.println ( “El sueldo del trabajador ” + ( i + 1 ) ;

System.out.println ( “ es: ” + sueldo ) ;
}
}
}
Problema 105
Enunciado: Ingrese la categoría y el sueldo de todos los trabajadores de una empresa. Calcular el
aumento correspondiente, teniendo en cuenta los datos de la tabla. Mostrar el nuevo sueldo de
cada uno de los trabajadores. Finalmente, constatar el ingreso de los datos.
Categoría Aumento
1 25%
2 15%
3 10%
4 05%

En pseudocódigo:
Algoritmo PrgSueldoCategoria – main ( )
ENTRADA: numTrab , categoria , sueldo

SALIDA: sueldo
INICIO
ENTERO categoria , numTrab , i

REAL sueldo
HACER
LEER numTrab
SI ( numTrab <= 0 ) ENTONCES

ESCRIBIR “Número de trabajadores no válido…”
FINSI
MIENTRAS ( numTrab <= 0 )
DESDE i = 0 HASTA numTrab - 1
HACER
LEER categoria
MIENTRAS ( categoria < 1 OR categoria > 4 )
HACER
LEER sueldo
MIENTRAS ( sueldo <= 0 )
CUANDO (categoria) SEA

CASO 1 :
TERMINAR
CASO 2 :
TERMINAR
CASO 3 :
TERMINAR
CASO 4 :
FINCUANDO
ESCRIBIR “El nuevo sueldo es: ” + sueldo
FINDESDE
FIN
Algoritmo PrgSueldoCategoria – main ( )
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int categoria , numTrab ;

double sueldo ;
do {
cout << “Ingrese la cantidad de trabajadores: ” << endl ;
cin >> numTrab ;
if ( numTrab <= 0 ) {
cout << “Número de trabajadores no válido… ” << endl ;
}
} while ( numTrab <= 0 ) ;
for ( int i = 0 ; i < numTrab ; i ++ ) {
do {
cout << “Categoría del trabajador ” << ( i + 1 ) << endl ;
cin >> categoria ;
} while ( categoria < 1 || categoria > 4 ) ;
do {
cout << “Sueldo del trabajador ” << ( i + 1 ) << endl ;

cin >> sueldo ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
}
cout << “El nuevo sueldo es: ” << sueldo << endl ;
}
return 0 ;
}
class PrgSueldoCategoria {

double sueldo ;
do {
System.out.println ( “Ingrese la cantidad de trabajadores: ” ) ;

numTrab = Lectura.leerInt ( ) ;
System.out.println ( “Número de trabajadores no válido” ) ;
}
do {
System.out.println ( “Categoría del trabajador ” + ( i + 1 ) ) ;

categoria = Lectura.leerInt ( ) ;
} while ( categoria < 1 || categoria > 4 ) ;
do {
System.out.println ( “Sueldo del trabajador ” + ( i + 1 ) ) ;

sueldo = Lectura.leerDouble ( ) ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
}
System.out.println ( “El nuevo sueldo es: ” + sueldo ) ;
}
}
}
Problema 106
Enunciado: Calcular y mostrar el costo que representa un paciente y el costo total que representan
todos los pacientes para un hospital de la gran ciudad, según los datos de la tabla. Adicionalmente,
considerar que los pacientes menores de edad que tienen la enfermedad tipo 1, tienen un descuento
del 20 %, y los pacientes mayores de 54 años tienen un incremento del 12 %. Consistenciar el
ingreso de los datos.
Tipo enfermedad Costo / paciente / día

1 200
2 350
3 420

Algoritmo PrgPaciente – main ( )
INICIO
NUMERO numP , tipo , edad , dias , costo = 0 , costoTotal = 0
numP
numP < 1
VERDADERO FALSO
A
Algoritmo PrgPaciente – main ( )
FALSO
DESDE i = 0 HASTA numP -1
INCREMENTA i en 1
VERDADERO
Ingreso de
datos del
paciente
Cálculo del
costo por
paciente
costo
costoTotal = costoTotal + costo
costoTotal
FIN
Diseñe la parte del algoritmo relacionado con el ingreso de datos del paciente y el cálculo del costo por
paciente. Observe que en este último, deberá utilizar una estructura lógica de decisión múltiple.
Clase PrgPaciente
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int numP , tipo , edad , dias ;

double costo = 0 ,costoTotal = 0 ;
do {
cout << “ Ingrese el número de pacientes: ” << endl ;
cin >> numP ;
} while ( numP < 1 ) ;
for ( int i = 0 ; i < numP ; i ++ ) {

cout << “Datos del paciente ” << ( i + 1 ) << endl ;
do {
cout << “Tipo de enfermedad ” << endl ;
cin >> tipo ;
} while ( tipo < 1 || tipo > 4 ) ;
do {
cout << “Edad del paciente ” << endl ;
cin >> edad ;
} while ( edad <= 0 ) ;
do {
cout << “Días de internamiento ” << endl ;
cin >> dias ;
} while ( dias <= 0 ) ;
switch ( tipo ) {
case 1 :
if ( edad < 18 ) {
costo = costo * 0.8 ;
}
break ;
case 2 :
costo = 350 * dias * ;
break ;
case 3 :
}
cout << “El costo del paciente es: ” << costo << endl ;
costoTotal += costo ;
}
cout << “El costo total para el hospital es: ” << costoTotal ;
return 0 ;
}
Clase PrgPaciente
class PrgPaciente {
int numP , tipo , edad , dias ;

double costo = 0 ,costoTotal = 0 ;
do {
System.out.println ( “Ingrese el número de pacientes:” ) ;
numP = Lectura.leerInt ( ) ;
} while ( numP < 1 ) ;
for ( int i = 0 ; i < numP ; i ++ ) {

System.out.println ( “Datos del paciente ” + ( i + 1 ) ) ;
do {
System.out.println ( “Tipo de enfermedad ” ) ;
} while ( tipo < 1 || tipo > 4 ) ;

do {
System.out.println ( “Edad del paciente ” ) ;
} while ( edad <= 0 ) ;
do {
System.out.println ( “Días de internamiento ” ) ;
} while ( dias <= 0 ) ;
switch ( tipo ) {
case 1 :
if ( edad < 18 ) {
costo = costo * 0.8 ;
}
break ;
case 2 :
break ;
case 3 :
}
System.out.println ( “El costo del paciente es: ” + costo ) ;

costoTotal += costo ;
}
System.out.println ( “Costo total para el hospital: ” + costoTotal ) ;

}
}
Problema 107
Enunciado: Ingresar las tres notas de todos los alumnos de un salón de clase. Mostrar las notas
ingresadas ordenadas ascendentemente y el promedio final de cada alumno. Adicionalmente,
mostrar el promedio de notas de todos los alumnos del salón de clase. Finalmente, consistenciar
el ingreso de las notas.
Definir el nombre del proyecto, luego desarrollar la definición de paquetes, el diagrama de

paquetes y la definición de las clases.

En pseudocódigo:
Algoritmo PrgNotas – main ( )
ENTRADA: numAlu , nota1, nota2 ,nota3

SALIDA: notaMa . notaMe , notam , promedio
INICIO
REAL nota1 , nota2 , nota3 , notaMa = 0 , notaMe = 0 , notam = 0

REAL promedio = 0 , sumaTotal = 0
ENTERO numAlu , i
HACER
LEER numAlu
DESDE i = 0 HASTA numAlu - 1 INCREMENTA 1
HACER
LEER nota1
MIENTRAS ( nota1 < 0 OR nota1 > 20 )
HACER
LEER nota2
HACER
LEER nota3
SI ( nota1 > nota2 AND nota1 > nota3 ) ENTONCES

notaMa = nota1
SI ( nota2 > nota3 )

ENTONCES
notaMe = nota3
notam = nota2
SINO
notaMe = nota2
notam = nota3
FINSI
FINSI

notaMa = nota2

ENTONCES
notaMe = nota3
notam = nota1
SINO
notaMe = nota1
notam = nota3
FINSI
FINSI

notaMa = nota3

ENTONCES
notaMe = nota2
notam = nota1
SINO
notaMe = nota1
notam = nota2
FINSI
FINSI
ESCRIBIR notaMA + “ ” + notam + “ ” + notaMe

ESCRIBIR “El promedio del alumno es: ” + promedio
sumaTotal = sumaTotal + promedio
FINDESDE
ESCRIBIR “El promedio general es: ” + ( sumaTotal / numAlu )
FIN

Clase PrgNotas
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double nota1 , nota2 , nota3 , notaMa=0 , notaMe=0 , notam=0 ;

double promedio = 0 , sumaTotal = 0 ;
int numAlum ;
do {
cout << “Ingrese la cantidad de alumnos: ” << endl ;
cin >> numAlum ;
} while (numAlum <= 0 ) ;
for ( int i = 0 ; i < numAlum ; i ++ ) {
do {
cout << “Nota1 del alumno ” << ( i + 1 ) << endl ;
cin >> nota1 ;
} while ( nota1 < 0 || nota1 > 20 ) ;
do {
cin >> nota2 ;
} while ( nota2 < 0 || nota2 > 20 ) ;
do {
cin >> nota3 ;
} while ( nota3 < 0 || nota3 > 20 ) ;
if ( nota1 > nota2 && nota1 > nota3 ) {
notaMa = nota1 ;
if ( nota2 > nota3 ) {

notaMe = nota3 ;
notam = nota2 ;
} else {
notaMe = nota2 ;
notam = nota3 ;
}
}
notaMa = nota2 ;

notaMe = nota3 ;
notam = nota1 ;
} else {
notaMe = nota1 ;
notam = nota3 ;
}
}
notaMa = nota3 ;

notaMe = nota2 ;
notam = nota1 ;
} else {
notaMe = nota1 ;
notam = nota2 ;
}
}
cout << notaMa << “\n” << notam << “\n” << notaMe ;
cout << “\nEl promedio del alumno ” << ( i + 1 ) << “ es: ” ;
cout << promedio << endl ;
sumaTotal += promedio ;
cout << “El promedio general es: ” << ( sumaTotal / numAlum ) ;

return 0 ;
}

Problema 108
[1] Ingresar la base y altura de un rectángulo.

[2] Calcular y mostrar el área del rectángulo.
[3] Calcular y mostrar el perímetro del rectángulo.
[4] Finalizar.
Considere que para la solución de este problema deberá primero visualizar solo las opciónes 1 y
4. Después de haber ingresado la base y altura de un rectángulo, se deberá visualizar todas las
opciones.

Algoritmo PrgMenuAreaPerimetro – main ( )
INICIO
NUMERO opc , sw = 0 , base = 0 , altura = 0

TEXTO menu , menu1 = “Opción 1” , menu2 = “Todas las opciones”
menu = menu1
Menú de
opciones
opc <> 4
VERDADERO
FALSO
FIN
Algoritmo PrgMenuAreaPerimetro – main ( )
MENÚ 1
Menú de
[1] Ingresar base y altura
opciones
[4] Finalizar.
MENÚ 2
opc [1] Ingresar base y altura
[2] Mostrar área
[3] Mostrar perímetro
[4] Finalizar
opc
1 OTROS
2 3 4
1 "Error"
Ingreso de
datos
VERDADERO
VERDADERO
sw = 1 sw = 1
menu = menu2 FALSO FALSO

2 3
Cálculo Cálculo
área perímetro
sw = 1
"Error" "Error"
FIN
Diseñe la parte del algoritmo relacionado con el ingreso de datos, el cálculo del área y el cálculo del
perímetro del rectángulo.
Clase PrgMenuAreaPerimetro
class PrgMenuAreaPerimetro {
int opc , sw = 0 ;
double base = 0 , altura = 0 ;
String menu1 = “[1] Base y altura de un rectángulo \n ” +

“[4] Finalizar \n ” +
“-------------------------------------------\n ” +
“Ingrese su opción : ” ;
String menu2 = “[1] Base y altura de un rectángulo \n ” +

“[2] Calcular y mostrar el área del rectángulo \n ” +
“[3] Calcular y mostrar el perímetro del rectángulo ” +
“-------------------------------------------\n ” +
String menu = menu1 ;
do {
System.out.println ( menu ) ;
opc =Lectura.leerInt ( ) ;
switch ( opc ) {
case 1 :
System.out.println ( “Ingrese base del rectángulo: ” ) ;

base = Lectura.leerDouble ( ) ;
System.out.println ( “Ingrese altura del rectángulo: ” ) ;
altura = Lectura.leerDouble ( ) ;
menu = menu2 ;
sw = 1 ;
break ;
case 2 :
if ( sw == 1 ) {
System.out.print ( “Area del rectángulo: ” ) ;
System.out.println ( base * altura ) ;
} else {
System.out.println ( “Ingrese la opción 1…” ) ;
}
break ;
case 3 :
if ( sw == 1 ) {
System.out.print ( “Perímetro del rectángulo: ” ) ;
System.out.println ( base * 2 + altura * 2 ) ;
} else {
}
break ;
case 4 :
break ;
default :
System.out.println ( “Opción no válida. Reintente! ” ) ;
}
} while ( opc != 4 ) ;
}
}

Problema 109
Enunciado:
Desarrolle un menú con las siguientes opciones:
[2] Determinar el número de cifras del número.
[3] Determinar si el número es par o no.
[4] Finalizar.
Consistenciar el ingreso de todos los datos. Considere que para la solución de este problema deberá
primero visualizar solo la opción 1 y 4. Después de haber ingresado el número, se deberá visualizar
todas las opciones.
4.Diseño del algoritmo

En pseudocódigo:
Algoritmo PrgMenuNumero – main ( )
ENTRADA: opc , num

SALIDA: numCifras , mensaje
INICIO
ENTERO opc , sw = 0 , num = 0 , numCifras , numTmp

TEXTO menu , mensaje = “”
TEXTO menu1 = “[1] Ingrese un número” +

“[4] Finalizar”
TEXTO menu2 = “[1] Ingrese un número” +

“[2] Determinar el número de cifras del número” +
“[3] Determinar si el número es par o no” +
“[4] Finalizar”
menu = menu1
HACER
ESCRIBIR menu
LEER opc
CUANDO (opc) SEA

CASO 1 :
HACER
LEER num
SI ( num <= 0 ) ENTONCES
ESCRIBIR “Número no válido”
FINSI
menu = menu2
sw = 1
TERMINAR
CASO 2 :
SI ( sw == 1 ) ENTONCES
numTmp = 0
numCifras = 0
MIENTRAS ( numTmp > 0 )
numTmp = numTmp / 10
numCifras = numCifras + 1
FINMIENTRAS
ESCRIBIR “El número de cifras es: ” + numCifras
SINO
ESCRIBIR “Ingrese la opción 1”
FINSI
TERMINAR
CASO 3 :
SI ( sw == 1 ) ENTONCES
SI ( num RESTO 2 = 0 ) ENTONCES

mensaje = “El número es par”
SINO
mensaje = “El número es impar”
FINSI
ESCRIBIR mensaje
SINO
ESCRIBIR “Ingrese la opción 1”
FINSI
TERMINAR
CASO 4 :
TERMINAR
OTROS :
ESCRIBIR “Opción no válida. Reintente!”
FINCUANDO
FIN

Clase PrgMenuNumero
class PrgMenuNumero {
int opc , sw = 0 , num = 0 , numCifras , numTmp ;

String menu , mensaje ;
String menu1 = “[1] Ingrese un número \n ” +

“-------------------------------------------\n ” +

“[2] Determinar el número de cifras del número \n ” +
“[3] Determinar si el número es par o no \n ” +
“-------------------------------------------\n ” +
menu = menu1 ;
do {
System.out.println ( menu ) ;
opc =Lectura.leerInt ( ) ;
switch ( opc ) {
case 1 :
do {
System.out.println ( “Ingrese un número: ” ) ;
if ( num <= 0 ) {
System.out.println ( “Número no válido... ” ) ;
}
} while ( num <= 0 ) ;
menu = menu2 ;
sw = 1 ;
break ;
case 2 :
if ( sw == 1 ) {
numTmp = num ;
numCifras = 0 ;
while ( numTmp > 0 ) {

numTmp = numTmp / 10 ;
numCifras ++ ;
}
System.out.print ( “El número de cifras es : ” ) ;

System.out.println ( numCifras ) ;
} else {
}
break ;
case 3 :
if ( sw == 1 ) {
if ( num % 2 == 0 ) {
mensaje = “El número es par ” ;
} else {
mensaje = “El número es impar ” ;
}
} else {
}
break ;
case 4 :
break ;
default :
} while ( opc != 4 ) ;
}
}

Problema 110
Enunciado: Ingresar el nombre, precio de compra, precio de venta y cantidad de artículos de todos
los productos de una bodega. Calcular la utilidad de cada producto y la utilidad total si se vendieran
todos los artículos de cada producto. Finalmente consistenciar el ingreso de los datos.


Algoritmo PrgUtilidad – main ( )
INICIO
TEXTO nombre
REAL pC , pV , util = 0 , utilT = 0
NUMERO total , cant , i
1
Ingreso de la
cantidad de
productos
2
Ingreso de
datos y cálculo
de utilidad
FIN
1
Ingreso de
la cantidad
de productos
total
VERDADERO
total < 1
FALSO
"error"
total < 1
VERDADERO
FALSO
2
Ingreso de
datos y cálculo
de utilidad
FALSO
DESDE i = 0 HASTA total -1
INCREMENTA i en 1
VERDADERO
2.1
Ingreso de
datos
2.2
Cálculo de
utilidad
utilT
2.1
Ingreso de datos
nombre
cant
cant < 1
VERDADERO
FALSO
pC
pC < 1
VERDADERO
FALSO
pV
pC <= pV
VERDADERO
FALSO
2.2
Cálculo de
utilidad
util = pV - pC
util
utilT = utilT + util * cant
#include <iostream>
#include <string>
using std::cout ;
using std::cin ;
using std::endl ;
using std::string ;
int main ( ) {
string nombre ;
double pC , pV , util = 0 , utilT = 0 ;
int total , cant ;
do {
cout << “Ingrese la cantidad de productos: ” << endl ;
cin >> total ;
if ( total < 1 ) {
cout << “Cantidad no válida… ” << endl ;
}
} while ( total < 1 ) ;
for ( int i = 0 ; i < total ; i++ ) {
cout << “Ingrese el nombre del producto: ” << endl ;

cin >> nombre ;
do {
cout << “Ingrese cantidad: ” << endl ;
cin >> cant ;
} while ( cant < 1 ) ;
do {
cout << “Ingrese su precio de compra: ” << endl ;
cin >> pC ;
} while ( pC < 1 ) ;
do {
cout << “Ingrese su precio de venta: ” << endl ;
cin >> pV ;
} while ( pC <= pV ) ;
util = pV – pC ;
cout << “Utilidad del producto ” << ( i + 1 ) << “ es: ” ;

cout << util << endl ;
utilT += util * cant ;
cout << “La utilidad total sería: ” << utilT << endl ;
return 0 ;
}
Clase PrgUtilidad
class PrgUtilidad {
string nombre ;
double pC , pV , util = 0 , utilT = 0 ;
int total , cant ;
do {
System.out.println ( “Ingrese la cantidad de productos: ” ) ;
total = Lectura.leerInt ( ) ;
if ( total < 1 ) {
System.out.println ( “Cantidad no válida… ” ) ;
}
} while ( total < 1 ) ;
for ( int i = 0 ; i < total ; i++ ) {

System.out.println ( “Ingrese el nombre del producto: ” ) ;

do {
System.out.println ( “Ingrese cantidad: ” ) ;
cant = Lectura.leerInt ( ) ;
} while ( cant < 1 ) ;
do {
System.out.println ( “Ingrese su precio de compra: ” ) ;
pC = Lectura.leerDouble ( ) ;
} while ( pC < 1 ) ;
do {
System.out.println ( “Ingrese su precio de venta: ” ) ;
pV = Lectura.leerDouble ( ) ;
} while ( pC <= pV ) ;
util = pV – pC ;
System.out.print ( “Utilidad del producto ” + ( i + 1 ) + “ es: ” ) ;

System.out.println ( util ) ;
utilT += util * cant ;
}
System.out.println ( “La utilidad total es: ” + utilT ) ;
}
}
Problema 111
Enunciado: Desarrollar un menú con las siguientes opciones:
[1] Ingresar el radio de una esfera.

[2] Calcular y mostrar el área de la esfera.
[3] Calcular y mostrar el perímetro de la esfera.
[4] Calcular y mostrar el volumen de la esfera.
[5] Finalizar.

En pseudocódigo:
Algoritmo PrgMenuEsfera – main ( )
ENTRADA: opc , radio

SALIDA: area , perimetro , volumen
INICIO
ENTERO opc
REAL radio = 0 , area , perimetro , volumen
TEXTO menu = “[1] Ingrese el radio de una esfera” +

“[2] Calcular y mostrar el área de la esfera” +
“[3] Calcular y mostrar el perímetro de la esfera” +
“[4] Calcular y mostrar el volumen de la esfera” +
“[5] Finalizar”
HACER
ESCRIBIR menu
LEER opc
CUANDO (opc) SEA
CASO 1 :
LEER radio
TERMINAR
CASO 2 :
area = 4 * Math.PI * Math.pow ( radio , 2 )
ESCRIBIR “ El área de la esfera es: ” + area
TERMINAR
CASO 3 :
perimetro = 8 * Math.PI * radio
ESCRIBIR “ El perímetro de la esfera es: ” + perimetro
TERMINAR
CASO 4 :
volumen = 4 * Math.PI / 3 * Math.pow ( radio , 3 )
ESCRIBIR “ El volumen de la esfera es: ” + volumen
TERMINAR
OTROS :
SI ( opc <> 5 ) ENTONCES

FINSI
FINCUANDO
FIN
Clase PrgMenuEsfera
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int opc ;
double radio = 0 , area , perimetro , volumen ;
string menu = “[1] Ingresar el radio de una esfera\n ” +

“[2] Calcular y mostrar el área de la esfera\n ” +
“[3] Calcular y mostrar el perímetro de la esfera\n ” +
“[4] Calcular y mostrar el volumen de la esfera\n ” +
“[5] Finalizar\n ” +
“------------------------------------------------- \n ” +
“Ingrese su opción: ” ;
do {
cout << menu << endl ;

cin >> opc ;
switch ( opc ) {
case 1 :
cout << “Ingrese el radio de la esfera: ” << endl ;
cin >> radio ;
break ;
case 2 :
area = 4 * Math.PI * Math.pow ( radio , 2 ) ;
cout << “El área de la esfera es: ” ;
cout << area << endl ;
break ;
case 3 :
perimetro = 8 * Math.PI * radio ;
cout << “El perímetro de la esfera es: ” ;
cout << perimetro << endl ;
break ;
case 4:
volumen = 4 * Math.PI / 3 * Math.pow ( radio , 3 ) ;
cout << “El volumen de la esfera es: ” ;
cout << volumen << endl ;
break ;
default :
if ( opc != 5 ) {
cout << “Opción no válida ” << endl ;
}
}
} while ( opc != 5 ) ;
return 0 ;
}

Problema 112
Enunciado: Desarrollar una solución que permita mostrar el término enésimo de la serie de
FIBONACCI. Recordar:
FIBONACCI: 1, 1, 2, 3, 5, 8, 13, 21, 34.

F0 = 1
F1 = 1
FN = FN-1 + FN-2
Tener en cuenta la validación del término solicitado.
Definir el nombre del proyecto, desarrollar la definición de paquetes, el diagrama de paquetes y la

definición de las clases.

Algoritmo PrgFibonacci – main ( )
INICIO
NUMERO serie = 0 , f0 = 1, f1 = 1 , fn = 0 , i
1
Ingreso de un
número
2
Cálculo de la
serie Fibonacci
del número
fn
FIN
1
Ingreso de un
número
serie
VERDADERO
serie < 1
FALSO
“error”
serie < 1
VERDADERO
FALSO
2
Cálculo de la
serie Fibonacci
del número
serie
1 2 OTROS
fn = f0 fn = f1 DESDE i = 2 HASTA serie FALSO
INCREMENTA i en 1
VERDADERO
fn = f0 + f1
f0 = f1
f1 = fn

Clase PrgFibonacci
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int serie = 0, f0 = 1, f1 = 1, fn = 0 ;
do {
cout << “Ingrese número para calcular la serie Fibonacci: ” ;

cin >> serie ;
if ( serie < 1 ) {
cout << “Ingrese un número mayor que cero. ” << endl ;
}
} while ( serie < 1 ) ;
switch ( serie ) {
case 0 :
fn = f0 ;
break ;
case 1 :
fn = f1 ;
break ;
default :
for ( int i = 2 ; i <= serie ; i ++ ) {
fn = f0 + f1 ;
f0 = f1 ;
f1 = fn ;
}
}
cout << “El valor, ” << serie << “ de la serie de Fibonacci es: ” << fn ;
return 0 ;
}
Clase PrgFibonacci
class PrgFibonacci {
int serie = 0 , f0 = 1 , f1 = 1 , fn = 0 ;
do {
System.out.println ( “Ingrese número que desea calcular serie

Fibonacci: ” ) ;
serie = Lectura.leerInt ( ) ;
if ( serie < 1 ) {
System.out.println ( “Ingresar número mayor que cero.” ) ;
}
} while ( serie < 1 ) ;
switch ( serie ) {
case 0 :
fn = f0 ;
break ;
case 1 :
fn = f 1 ;
break ;
default :
for ( int i = 2 ; i <= serie ; i ++ ) {
fn = f0 + f1 ;
f0 = f1 ;
f1 = fn ;
}
}
System.out.println ( “El valor, ” + serie + “ de la serie de

Fibonacci es: \t ” + fn ) ;
}
}
Problema 113
Enunciado: Ingrese la categoría y el precio de todos los productos de un supermercado. Calcular el

descuento correspondiente teniendo en cuenta la siguiente tabla. Mostrar el nuevo precio de cada
uno de los productos. Finalmente, constatar el ingreso de los datos.
Categoría Descuento
1 25%
2 15%
3 10%
4 10%

Algoritmo PrgSupermercado – main ( )
INICIO
NUMERO cat , cant , pC , i
1
Ingreso de la
cantidad de
productos
2
Ingreso de
datos y cálculo
de precio
FIN
1
Ingreso de la
cantidad de
productos
cant
cant <= 0
VERDADERO
FALSO
2
Ingreso de
datos y cálculo
de precio
DESDE i = 0 HASTA cant -1 FALSO
INCREMENTA i en 1
VERDADERO
2.1
Ingreso de
datos
2.2
Cálculo de
precio
Algoritmo PrgSupermercado - main ( )
2.2
Cálculo de
precio
cat
1 2 3 4
pC = pC * 0.75 pC = pC * 0.85 pC = pC * 0.90 pC = pC * 0.95
pC

Diseñe la parte del algoritmo relacionado con el ingreso de datos.
Clase PrgSupermercado
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int cat , cant ;
double pC ;
do {
cout << “Ingrese la cantidad de productos: ” << endl ;
cin >> cant ;
} while ( cant <= 0 ) ;
for ( int i = 0 ; i < cant ; i ++ ) {
do {
cout << “Ingrese la categoría: ” << endl ;
cin >> cat ;
} while ( cat < 1 && cat > 4 ) ;
do {
cout << “Ingrese el precio: ” << endl ;
cin >> pC ;
} while ( pC <= 0 ) ;
switch ( cat ) {
case 1 :
pC = pC * 0.75 ;
break ;
case 2 :
pC = pC * 0.85 ;
break ;
case 3 :
pC = pC * 0.9 ;
break ;
case 4 :
pC = pC * 0.95 ;
break ;
}
cout << “El nuevo precio es: ” << pC ;
}
return 0 ;
}
Clase PrgSupermercado
class PrgSupermercado {
int cat , cant ;

double pC ;
do {
System.out.println ( “Ingrese la cantidad de productos: ” ) ;
} while ( cant <= 0 ) ;
for ( int i = 0 ; i < cant ; i ++ ) {

do {
System.out.println ( “Ingrese la categoría: ” ) ;
cat = Lectura.leerInt ( ) ;
} while ( cat < 1 && cat > 4 ) ;
do {
System.out.println ( “Ingrese el precio: ” ) ;
pC = Lectura.leerDouble ( ) ;
} while ( pC <= 0 ) ;
switch ( cat ) {
case 1 :
pC = pC * 0.75 ;
break ;
case 2 :
pC = pC * 0.85 ;
break ;
case 3 :
pC = pC * 0.9 ;
break ;
case 4 :
pC = pC * 0.95 ;
break ;
}
System.out.println ( “El nuevo precio es: ” + pC ) ;
}
}
}
Problema 114
Enunciado: Desarrollar una solución que permita ingresar un valor “n” mayor o igual que 1, y un valor
“x” cualquiera para el cálculo de la ecuación mostrada. Tener en cuenta que la division entre 0 no está
definida.
 3 π 
x − 
n
x +5
∑ x1+ 2 +x1−1+
i=1 x3
n
∑ x − i + 32
i=1

En pseudocódigo:
Algoritmo PrgSumatoria – main ( )
ENTRADA: n , x
SALIDA: resultado
INICIO
ENTERO n = 0 , i
REAL x , numerador = 0 , denominador = 0 , resultado , pi = 3.1416
HACER
LEER n
SI ( n < 1 ) ENTONCES
ESCRIBIR “Valor ingresado no válido… Reintente! ”
FINSI
MIENTRAS ( n < 1 )
HACER
LEER x
SI ( x == 0 ) ENTONCES
ESCRIBIR “Valor ingresado no válido… Reintente! ”
FINSI
MIENTRAS ( x == 0 )
DESDE i = 0 HASTA n
numerador = numerador +
( x POTENCIA ( i + 2 ) + x POTENCIA ( i - 1 ) +
( ( x POTENCIA 3 ) – ( pi / x + 5 ) )
/ ( x POTENCIA 3 ) ) ) )
denominador = denominador + ( x – i + x POTENCIA 3 + 32 )
FINDESDE
resultado = numerador / denominador
ESCRIBIR “El resultado de la sumatoria es: ” + resultado
FIN

Clase PrgSumatoria
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
int n = 0 , i ;
double x , numerador = 0 , denominador = 0 , resultado ;
do {
cout << “Ingrese el valor de n para la sumatoria: \n ” << endl ;
cin >> n ;
if ( n < 1 ) {
cout << “Valor ingresado no válido… Reintente! ” << endl ;
}
} while ( n < 1 ) ;
do {
cout << “Ingrese un valor para la variable X : ” << endl ;
cin >> x ;
if ( x == 0 ) {
cout << “Valor ingresado no válido… Reintente! ” << endl ;
}
} while ( x == 0 ) ;
for ( i = 1 ; i <= n ; i ++ ) {
numerador += ( Math.pow ( x , i + 2 ) + Math.pow ( x , i - 1 )

+ ( ( Math.pow ( x , 3 ) - ( pi / x + 5 ) )
/ ( Math.pow ( x , 3 ) ) ) ) ;
denominador += ( x - i + Math.pow ( x , 3 ) + 32 ) ;
resultado = numerador / denominador ;
cout << “El resultado es: \n ” ;

cout << resultado << endl ;
return 0 ;

Problema 115
Enunciado: Desarroller un menu con las siguientes opciones:
[1] Ingresar la longitud en metros

[2] Calcular y mostrar la longitud en pies
[3] Calcular y mostrar la longitud en pulgadas
[4] Calcular y mostrar la longitud en millas
[5] Finalizar
}|Nota: 3.28 pies = 1 m; 39.37 pulg. = 1m; 5280 pies = 1 milla.

En pseudocódigo:
Algoritmo PrgMenuMetros – main ( )
ENTRADA: opc , radio

SALIDA: area , perimetro , volumen
INICIO
REAL longitud = 0 , conversion

ENTERO opc
TEXTO menu = “[1] Ingrese la longitud en metros” +

“[2] Calcular y mostrar la longitud en pies” +
“[3] Calcular y mostrar la longitud en pulgadas” +
“[4] Calcular y mostrar la longitud en millas” +
“[5] Finalizar”
HACER
ESCRIBIR menu
LEER opc
CUANDO (opc ) SEA
CASO 1 :
LEER longitud
TERMINAR
CASO 2 :
conversion = longitud / 3.28
ESCRIBIR “ La longitud en pies es: ” + conversion
TERMINAR
CASO 3 :
conversion = longitud / 39.37
ESCRIBIR “ La longitud en pulgadas es: ” + conversion
TERMINAR
CASO 4 :
conversion = longitud / ( 1.6093 / 1000 )
ESCRIBIR “ La longitud en millas es: ” + conversion
TERMINAR
OTROS :
SI ( opc <> 5 ) ENTONCES
FINSI
FINCUANDO
FIN
Clase PrgMenuMetros
#include <iostream>
using std::cout ;
using std::cin ;
using std::endl ;
int main ( ) {
double longitud = 0 , conversion ;

int opc ;
string menu = “[1] Ingresar la longitud en metros n ” +
“[2] Calcular y mostrar la longitud en pies \n ” +
“[3] Calcular y mostrar la longitud en pulgadas \n ” +
“[4] Calcular y mostrar la longitud en millas \n ” +
“[5] Finalizar\n ” +
“------------------------------------------------- \n ” +
“Ingrese su opción: ” ;
do {
cout << menu << endl ;

cin >> opc ;
switch ( opc ) {
case 1 :
cout << “Ingrese la longitud: \n\n ” << endl ;
cin >> longitud ;
break ;
case 2 :
conversion = ( longitud / 3.28 ) ;
cout << “La longitud en pies es: ” << conversion << endl ;
break ;
case 3 :
conversion = longitud / 39.37 ;
cout << “La longitud en pulgadas es: ” << conversion ;
cout << endl ;
break ;
case 4 :
conversion = longitud / ( 1.6093 / 1000 ) ;
cout << “La longitud en millas es: ” << conversion ;
cout << endl ;
break ;
default :
if ( opc != 5 ) {
cout << “Opción no válida… Reintente!. ” << endl ;
}
}
} while ( opc != 5 ) ;
return 0 ;
}

Problema 116
Enunciado: En una dulcería se venden diferentes postres, de acuerdo a la tabla siguiente:
Tipo Costo x porción

Mazamorra 1.5
Gelatina 1.2
Keke 2.0
Helado 3.2
A. Por la compra de más de 10 porciones de cualquier tipo de producto se le otorga un descuento

del 10 %.
B. Por la compra de cada 20 porciones de gelatina se le otorga un vale de descuento para ser utilizado
en la próxima compra.
C. Desarrolle una solución que permita determinar el monto de compra, el monto del descuento y
la cantidad de vales de descuento para una determinada compra.
D. Ingrese el tipo de producto y la cantidad de porciones que se desea comprar.
E. Asumir que se pueden realizar varios pedidos en la misma compra.


En pseudocódigo:
Algoritmo PrgPostres – main ( )
ENTRADA: tipo , cantidad

SALIDA: precio , vales , descuento
INICIO
ENTERO tipo , cantidad , vales , canGel = 0 , canTotal = 0

REAL precio , descuento
CARACTER rpta
TEXTO menu = “Ingrese el tipo de producto a comprar:” +

“[1] Mazamorra” +
“[2] Gelatina” +
“[3] Keke” +
“[4] Helado”
HACER
ESCRIBIR menu
LEER tipo , cantidad
CUANDO (tipo) SEA
CASO 1 :
precio = precio + cantidad * 1.5
TERMINAR
CASO 2 :
canGel = canGel + cantidad
TERMINAR
CASO 3 :
precio = precio + cantidad * 2
TERMINAR
CASO 4 :
TERMINAR
OTROS :
FINCUANDO
canTotal = canTotal + cantidad

LEER rpta
MIENTRAS ( rpta == ‘s’ OR rpta== ‘S’ )
SI ( canGel >= 20 ) ENTONCES

vales = cantidad / 20
FINSI
SI ( canTotal > 10 ) ENTONCES
descuento = precio * 0.1
FINSI
ESCRIBIR “Monto de compra: ” + precio
ESCRIBIR “Descuento: ” + descuento
ESCRIBIR “Cantidad de vales: ” + vales
FIN
Clase PrgPostres
class PrgPostres {
int tipo , cantidad , vales = 0 , canGel = 0 , canTotal = 0 ;

double precio = 0 , descuento = 0 ;
char rpta ;
do {
System.out.println ( “Ingrese el tipo de roduto a comprar: \n ” +

“[1] Mazamorra\n ” + “[2] Gelatina\n ”+
“[3] Keke \n ” + “[4] Helado ” ) ;
System.out.println (“Ingrese la cantidad de porciones a llevar:”);

switch ( tipo ) {
case 1 :
precio = precio + cantidad * 1.5 ;
break ;
case 2 :
canGel = canGel + cantidad ;
break ;
case 3 :
precio = precio + cantidad * 2 ;
break ;
case 4 :
break ;
default :
System.out.println ( “Opcion no válida!.” ) ;
}
canTotal = canTotal + cantidad ;

System.out.println ( “Desea ordenar otro producto (S/N) ¿ ” ) ;
rpta = Lectura.leerChar( ) ;
} while ( rpta == ‘S’ || rpta == ‘s’ ) ;
if ( canGel >= 20 ) {
vales = vales + cantidad / 20 ;
}
if ( canTotal > 10 ) {
descuento = precio * 0.1 ;
}
System.out.println ( “Monto de compra: ” + precio + “\nDescuento: ” +

descuento + “\nCantidad de vales: ” + vales ) ;
}
}

Problema 117
Enunciado: En una dulcería se venden diferentes postres y se aplican diferentes descuentos, de

acuerdo a la tabla siguiente:
Tipo Costo x porción Descuento

Mazamorra 1.5 12 %
Gelatina 1.2 10 %
Keke 2.0 15 %
Helado 3.2 17 %
Tener en cuenta que por la compra de más de 10 porciones de cualquier tipo de producto, se le
otorga el descuento de acuerdo a la tabla. Desarrolle una solución que permita determinar el monto
de compra de cada tipo de producto, el monto del descuento de cada tipo de producto y el monto
total a pagar por una determinada compra. Ingrese el tipo de producto y la cantidad de porciones
que se desea comprar. Finalmente, asumir que se puede realizar varios pedidos en la misma compra.

En pseudocódigo:
Algoritmo PrgPostre2 – main ( )

ENTRADA: tipo, cantidad
SALIDA: precio1 , precio2 , precio3 , precio4 , precioT , descuento1 ,
descuento2 , descuento3 , descuento4
INICIO
ENTERO tipo , cantidad

REAL precio1 = 0 , precio2 = 0 , precio3 = 0 , precio4 = 0 , precioT = 0
REAL canMaz = 0 , canGel = 0 , canKek = 0 , canHel = 0
REAL descuento1 = 0 , descuento2 = 0 , descuento3 = 0 , descuento4 = 0
TEXTO rpta
TEXTO menu = “Ingrese el tipo de producto a comprar:” +

“[1] Mazamorra” +
“[2] Gelatina” +
“[3] Keke” +
“[4] Helado”
HACER
ESCRIBIR menu
LEER tipo , cantidad
CUANDO (tipo) SEA

CASO 1 :
precio1 = precio1 + cantidad * 1.5
canMaz = canMaz + cantidad
TERMINAR
CASO 2 :
canGel = canGel + cantidad
TERMINAR
CASO 3 :
precio3 = precio3 + cantidad * 2
canKek = canKek + cantidad
TERMINAR
CASO 4 :
canHel = canHel + cantidad
TERMINAR
OTROS :
FINCUANDO
LEER rpta
SI ( canMaz > 10 ) ENTONCES

descuento1 = precio1 * 0.12
FINSI
SI ( canGel > 10 ) ENTONCES
FINSI
SI ( canKek > 10 ) ENTONCES
FINSI
SI ( canHel > 10 ) ENTONCES
FINSI
precioT = precio1 + precio2 + precio3 + precio4
ESCRIBIR “ Monto de compra: ” + precioT + “\nMazamorra: ” + precio1

+ “ Descuento: ” + descuento1 + “ Gelatina: ” + precio2 + “ Descuento: ”
+ descuento2 + “ Keke: ” + precio3 + “ Descuento: ” + descuento3 +
“ Helado: ” + precio4 + “ Descuento: ” + descuento4
FIN

Clase PrgPostre2
class PrgPostre2 {
int tipo , cantidad ;

double precio1 = 0 , precio2 = 0 , precio3 = 0 , precio4 = 0 ;
double canMaz = 0 , canGel = 0 , canKek = 0 , canHel = 0 ;
double descuento1 = 0 , descuento 2 = 0 , descuento3 = 0 ;
double descuento4 = 0 , precioT = 0 ;
String rpta ;
do {
System.out.println ( “Ingrese tipo de producto a comprar: \n ” +

“[1] Mazamorra \n ” +
“[2] Gelatina \n ” +
“[3] Keke \n ” +
“[4] Helado ” ) ;
System.out.println ( “Ingrese cantidad de porciones a llevar: ” ) ;
switch ( opc ) {
case 1 :
precio1 = precio1 + cantidad * 1.5 ;
canMaz = canMaz + cantidad ;
break ;
case 2 :
canGel = canGel + cantidad ;
break ;
case 3 :
precio3 = precio3 + cantidad * 2 ;
canKek = canKek + cantidad ;
break ;
case 4 :
canHel = canHel + cantidad ;
break ;
default :
System.out.println ( “Opcion no válida!. ” ) ;
}
System.out.println ( “Desea ordenar otro producto (S/N) ? ” ) ;

rpta = Lectura.leerChar( ) ;
} while ( rpta == ‘S’ || rpta == ‘s’ ) ;
if ( canMaz > 10 ) {
descuento1 = precio1 * 0.12 ;
}
if ( canGel > 10 ) {
}
if ( canKek > 10 ) {
}
if ( canHel > 10 ) {
}
precioT = precio1 + precio2 + precio3 + precio4 ;
System.out.println ( “Monto de compra: ” + precioT ) ;

System.out.print ( “Mazamorra: ” + precio1 ) ;
System.out.println ( “\tDescuento: ” + descuento1 ) ;
System.out.print ( “Gelatina: ” + precio2 ) ;
System.out.print ( “Keke: ” + precio3 ) ;
System.out.print ( “Helado: ” + precio4 ) ;
}
}

Problema 118
Enunciado: En un puesto de periódicos se venden periódicos de tres empresas (A, B, y C). Cada una
de las empresas cuenta con tres tipos diferentes de periódicos (popular, normal y especializado). El
costo de cada periódico según el tipo de periódico se muestra en la siguiente tabla:
Empresa Tipo de periódico

Popular Normal Especializado
A S/. 0.5 S/. 1.0 S/. 2.0
B S/. 0.5 S/. 1.2 S/. 2.5
C S/. 0.7 S/. 1.2 S/. 3.6
Desarrollar una solución que permita determinar cuántos periódicos se vendieron de cada empresa
y cuál fue el monto obtenido por la venta de cada tipo de periódico de cada empresa. Por cada
venta, ingrese el tipo de empresa y el tipo de periódico.

Algoritmo PrgPeriodicos – main ( )
INICIO
NUMERO tipo, c1, c2, c3, m1A, m2A, m3A, m1B, m2B,
m3B, m1C, m2C, m3C
CARACTER emp, rpta
Ingreso de
datos, cálculo
y resultado
FIN
Algoritmo PrgPeriodicos – main ( )
Ingreso de
datos, cálculo y
resultado
1
Ingreso de
datos
2
Cálculo de
resultados
rpta
rpta == ‘s’
VERDADERO
FALSO
c1, c2, c3, m1A, m2A,

m3A, m1B, m2B, m3B,
m1C, m2C, m3C
Diseñe la parte del algoritmo relacionado con el ingreso de datos y el cálculo de resultados.
Clase PrgPeriodicos
class PrgPeriodicos {
int tipo , c1 = 0 , c2 = 0 , c3 = 0 ;
double m1A = 0 , m2A = 0 , m3A = 0 , m1B = 0 , m2B = 0 ;
double m3B = 0 , m1C = 0 , m2C = 0 , m3C = 0 ;
char emp , rpta ;
do {
System.out.println ( “Ingrese tipo de empresa: \n ”

+ “[A] Empresa A \n ”
+ “[B] Empresa B \n ”
+ “[C] Empresa C \n ” ) ;
emp = Lectura.leerChar ( ) ;
System.out.println ( “Ingrese tipo de periódico a comprar: \n ”

+ “[1] Popular \n ”
+ “[2] Normal \n ”
+ “[3] Espercializado \n ” ) ;
switch ( emp ) {
case ‘A’ :
c1++ ;
if ( tipo == 1 )
m1A = m1A + 0.5 ;
if ( tipo == 2 )
m2A = m3A + 1 ;
if ( tipo == 3 )
m3A = m3A + 2 ;
break ;
case ‘B’ :
c2++ ;
if ( tipo == 1 )
m1B = m1B + 0.5 ;
if ( tipo == 2 )
m2B = m2B + 1.2 ;
if ( tipo == 3 )
m3B = m3B + 2.5 ;
break ;
case ‘c’ :
c3++ ;
if ( tipo == 1 )
m1C = m1C + 0.7 ;
if ( tipo == 2 )
m2C = m2C + 1.2 ;
if ( tipo == 3 )
m3C = meC + 3.6 ;
break ;
default :
System.out.println ( “Opción mal ingresada” ) ;
}

rpta = Character.toUpperCase ( rpta ) ;
} while ( rpta == ‘S’ ) ;
System.out.println ( “De la empresa A: ” ) ;

System.out.println ( “Se vendieron: ” + c1 + “ periódicos ” ) ;
System.out.println ( “Monto total venta Popular: ” + m1A ) ;
System.out.println ( “Monto total venta Normal: ” + m2A ) ;
System.out.println ( “Monto recaudado Especializado: ” + m3A ) ;
System.out.println(“------------------------------------------------- ”);
System.out.println ( “De la empresa B: ” ) ;

System.out.println ( “Monto total venta Popular: ” + m1B ) ;
System.out.println ( “Monto total venta Normal: ” + m2B ) ;
System.out.println ( “Monto recaudado Especializado: ” + m3B ) ;
System.out.println (“------------------------------------------------ ”);
System.out.println ( “De la empresa C: ” ) ;

System.out.println ( “Monto total venta Popular: ” + m1C ) ;
System.out.println ( “Monto total venta Normal: ” + m2C ) ;
System.out.println ( “Monto recaudado Especializado: ” + m3C ) ;
}
}

Problema 119
Enunciado: Una determinada empresa tiene tres productos en oferta (A, B y C). Cada uno de los
productos cuenta con tres diferentes calidades (X1, X2 y X3). El costo de cada producto según la
calidad se muestra en la tabla siguiente:
Producto Calidad de producto

X1 X2 X3
A S/. 50 S/. 45 S/. 19
B S/. 89 S/. 55 S/. 34
C S/. 9 S/. 89 S/. 76
Desarrolle una solución que permita determinar el monto total a pagar por la compra de cada
producto. Mostrar cuántos productos de una misma calidad se vendieron. Ingrese el producto a
comprar y la calidad del mismo.

En pseudocódigo:
Algoritmo PrgOfertas – main ( )
ENTRADA: proa , cal

SALIDA: montoT, mAX1, mAX2, mAX3, mBX1, mBX2, mBX3, mCX1,
mCX2, mCX3
INICIO
ENTERO cal
CARACTER prod
REAL mAX1 = 0, mAX2 = 0, mAX3 = 0, mBX1 = 0, mBX2 = 0
REAL mBX3 = 0, mCX1 = 0, mCX2 = 0, mCX3 = 0
TEXTO rpta
TEXTO menu = “Ingrese el tipo de producto a comprar: ” +
“[A] Producto A ” +
“[B] Producto B ” +
“[C] Producto C ”
HACER
ESCRIBIR menu
LEER prod, cal
CUANDO (prod) SEA
CASO 1 :
SI ( cal == 1 ) ENTONCES
mA = mA + 50
c1 = c1 + 1
FINSI
mA = mA + 89
c2 = c2 + 1
FINSI
mA = mA + 94
c3 = c3 + 1
FINSI
TERMINAR
CASO 2 :
mB = mB + 45
c1 = c1 + 1
FINSI
mB = mB + 55
c2 = c2 + 1
FINSI
mB = mB + 89
c3 = c3 + 1
FINSI
TERMINAR
CASO 3 :
mC = mC + 19
c1 = c1 + 1
FINSI
mC = mC + 39
c2 = c2 + 1
FINSI
mC = mC + 76
c3 = c3 + 1
FINSI
TERMINAR
OTROS :
FINCUANDO
LEER rpta
ESCRIBIR “Monto total a pagar: ”
ESCRIBIR “Producto A: ” + mA
ESCRIBIR “Producto B: ” + mB
ESCRIBIR “Producto C: ” + mC
ESCRIBIR “Cantidad de productos de la misma calidad vendidos: ”
ESCRIBIR “Calidad X1: ” + c1
FIN

Clase PrgOfertas
class PrgOfertas {
int cal ;
char prod ;
double mAX1 = 0, mAX2 = 0, mAX3 = 0, mBX1 = 0, mBX2 = 0 ;
double mBX3 = 0, mCX1 = 0, mCX2 = 0, mCX3 = 0 ;
String rpta ;
do {
System.out.println ( “Ingrese el tipo de producto a comprar: \n ”

+ “[1] Producto A \n ”
+ “[2] Producto B \n ”
+ “[3] Producto C \n ” ) ;
prod = Lectura.leerInt ( ) ;
System.out.println("Ingrese la calidad del producto: \n ”

+ “[1] Calidad X1 \n ”
+ “[2] Calidad X2 \n ”
+ “[3] Calidad X3 \n ” ) ;
cal = Lectura.leerInt ( ) ;
switch ( opc ) {
case 1 :
if ( cal == 1 ) {
mA = mA + 50 ;
c1 = c1 + 1 ;
}
if ( cal == 2 ) {
mA = mA + 89 ;
c2 = c2 + 1 ;
}
if ( cal == 3 ) {
mA = mA + 94 ;
c3 = c3 + 1 ;
}
break ;
case 2 :
if ( cal == 1 ) {
mB = mB + 45 ;
c1 = c1 + 1 ;
}
if ( cal == 2 ) {
mB = mB + 55 ;
c2 = c2 + 1 ;
}
if ( cal == 3 ) {
mB = mB + 89 ;
c3 = c3 + 1 ;
}
break ;
case 3 :
if ( cal == 1 ) {
mC = mC + 19 ;
c1 = c1 + 1 ;
}
if ( cal == 2 ) {
mC = mC + 39 ;
c2 = c2 + 1 ;
}
if ( cal == 3 ) {
mC = mC + 76 ;
c3 = c3 + 1 ;
}
break ;
default :
}

rpta = Character.toUpperCase ( rpta ) ;
} while ( rpta == ‘S’ ) ;
System.out.println ( “Monto total a pagar: ” ) ;

System.out.println ( “Producto A: ” + mA ) ;
System.out.println ( “Producto B: ” + mB ) ;
System.out.println ( “Producto C: ” + mC ) ;
System.out.println ( “Total de productos vendidos por calidad: ” ) ;

System.out.println ( “Calidad X1: ” + c1 ) ;
}
}

Problema 120
Enunciado: Desarrollar una solución que permita leer los datos de todos los alumnos de un salón
de clase. Los datos de los alumnos son: nombre, fecha de nacimiento (dd/ mm/ aaaa) y nota final.
Se solicita:
A. Ingresar datos realizando las validaciones a la fecha de nacimiento.

B. Calcular y mostrar la edad de cada alumno. Hallar:
a. La nota promedio de todos los alumnos.
b. Nombre del alumno con mayor nota.
c. Cantidad de alumnos cuyo nombre comienza con la letra a y p.
d. Crear un menú de opciones para acceder a la solución.

Algoritmo PrgMenuAlumnos – main ( )
INICIO
NUMERO cantAp = 0, edad, cant = 0, opc

NUMERO nf = 0, prom = 0, notaMayor = 100
TEXTO nom = “”, fecNac = “”, nombreMayor = “”
Ingreso
de datos y
cálculo de
resultados
FIN
Algoritmo PrgMenuAlumnos – main ( )
Ingreso de datos
y cálculo de
resultados
opc
Menu de
opciones
Opc!=6
VERDADERO FALSO
Algoritmo PrgMenuAlumnos - main ( )
Menú de
opciones
opc
1 2 3 4 5
1 2 3 4 5
Ingresar Calcular Mostrar Mostrar Mostrar
datos. Hacer y mostrar promedio mejor nombres con
cálculos edad alumno letra a y p
Diseñe la parte del algoritmo relacionado con las opciones del menú.
Clase PrgMenuAlumnos
class PrgMenuAlumnos {
String nom = “”, fecNac = “”, nombreMayor = “” ;

double nf = 0, prom = 0 ;
double notaMayor = java.lang.Double.MIN_VALUE ;
int cantAP = 0, edad, cant = 0, opc ;
do {
System.out.println ( “Ingrese su opcion:\n
[1] Ingreso de datos \n
[2] Calcular y mostrar Edad \n
[3] Nota promedio \n
[4] Nombre del alumno con mayor nota \n
[5] Cantidad de nombres que empiezan con a y p \n
[6] Salir \n ” ) ;
switch ( opc ) {
case 1 :
cant ++ ;
System.out.println ( “Ingrese nombre del alumno: ” ) ;
nom = Lectura.leerString ( ) ;
nom = nom.toUpperCase ( ) ;
System.out.println ( “Ingrese nota final: ” ) ;

nf = Lectura.leerDouble ( ) ;
// Desarrolle la validación de la fecha ingresada.

System.out.println ( “Ingrese fecha de nacimiento: ” ) ;
fecNac = Lectura.leerString ( ) ;
prom = prom + nf ;
if ( nf > notaMayor ) {
notaMayor = nf ;
nombreMayor = nom ;
}
if ( nom.charAt (0) == ‘A’ || nom.charAt (0) == ‘P’ ) {
cantAP ++ ;
}
break ;
case 2 :
edad = 2006 - Integer.parseInt ( fecNac.substring(6)) ;
System.out.println ( “Edad: ” + edad ) ;
break ;
case 3 :
prom = prom / cant ;

System.out.println ( “Nota promedio: ” + prom ) ;
break ;
case 4 :
System.out.println (“El alumno con mayor nota es: ”) ;

System.out.println ( nombreMayor ) ;
break ;
case 5 :
System.out.println ( “La cantidad de alumnos es: ” ) ;

System.out.println ( cantAP ) ;
break ;
default :
System.out.println ( “Opcion mal ingresada ” ) ;
}
} while ( opc != 6 ) ;
}
}

Problema 121
Enunciado: Desarrollar un programa que permita ingresar un número entero menor que 100 y
permita mostrar su equivalente en letras.
Clase PrgNumALetras01
class PrgNumALetras01 {
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” ;
int num, dec, uni ;
do {
System.out.println ( “Ingrese un número entero menor que 100: ” ) ;
if ( num < 0 || num > 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 ;
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 :
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 ) ;
}
}
Problema 122
Enunciado: En base al programa anterior, desarrollar otro programa que permita ingresar un
número entero menor que 1000, y que permita mostrar su equivalente en letras.
Clase PrgNumALetras02
class PrgNumALetras02 {
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: ” ) ;
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 ;
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 :
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
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 ) ;
}
}
5.2 manEjO dE ExCEPCiOnEs En El lEngUajE dE PROgRamaCión java

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:
try {
// Código de la aplicación
… Tipo de excepción
… capturada por la
… sentencia catch,
… con la finalidad de
… manejarla.
} 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”.
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, solo si se ha 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 manejará
un excepción.
try {
/* Código de la aplicación que se prevé
que puedan lanzar una excepción.*/
…
…
} catch ( ArithmeticException e ) {
/* Código de tratamiento de la excepción
ArithmeticException. */
…
…
} catch ( NumberFormatException e ) {
/* Código de tratamiento de la excepción
NumberFormatException. */
…
…
}
En el ejemplo anterior, se ha especificado capturar dos excepciones en caso de que estás se

lancen (ArithmeticException y NumberFormatException).
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 ocurrió.
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 Problemas al realizar operaciones de entrada y salida de
datos.
ArrayIndexOutOfBoundException Un arreglo fue accedido con un índice ilegal (fuera de los
límites permitidos).
NullPointerException Se intentó utilizar null donde se requería un objeto.
Problema 123
Enunciado: 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 de que el
divisor sea igual a cero.

Clase PrgDivisionSinExcepcion
package dominioDeLaAplicacion;
import biblioteca.Lectura;
class PrgDivisionSinExcepcion {
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.
Clase PrgDivisionConExcepcion
class PrgDivisionConExcepcion {
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 ” ) ;
}
}
}
Problema 124
Enunciado: 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.
Clase PrgHoraConExcepcion
class PrgHoraConExcepcion {
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 ;
}
}
}
} 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 se sugiere revisar en el anexo la clase Integer (Clase Wrapper)
y la clase String.
Problema 125
Enunciado: 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 y manejar excepciones.
Clase PrgFechaConExcepcion
class PrgFechaConExcepcion {
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 ;
}
} else
valido = true ;
if ( valido )
System.out.println (“ Error... Ingrese la fecha según formato!!!”);
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 sugerimos que revise en el anexo, la clase Integer (Clase
Wrapper) y la clase String.
Problema 126
Enunciado: Desarrollar una solución que permita ingresar dos números de tres dígitos 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. Finalmente, manejar excepciones.
Clase PrgNumeroConExcepcion
class PrgNumeroConExcepcion {
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 ;
}
} 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!!!”);
}
}
}
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, se sugiere revisar en el anexo la clase Integer (clase Wrapper)
y la clase String.
IMPORTANTE
planteados al final del presente capítulo.
5.3 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, los lenguajes de
programación C++ y Java utilizados en el presente texto. Aunque en los siguientes problemas solo se
desarrollan soluciones utilizando el lenguaje de programación Java, se sugiere al lector que intente
desarrollarlas también en el lenguaje de programación C++.
Existen problemas que por su naturaleza contribuyen de manera significativa para lograr este objetivo,
los cuales se desarrollan en esta última parte del presente capítulo. Es importante analizar cada una de
las soluciones siguiendo paso a paso el desarrollo de las mismas y desarrollar los problemas propuestos.
Problema 127
Enunciado: 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. Asumir 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 en Java
Clase PrgCuadrado01
import biblioteca.* ;
public class PrgCuadrado01 {

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 <= totalFilas; i++ ) {
for ( j = 1 ; j <= totalFilas; j++ ) {

// Se muestra un asterisco.
System.out.print ( “*”) ;
}
// Se realiza un salto de línea.

}
}
}
Se ingresa el número de filas que va a tener la figura y se almacena en la variable totalFilas, la cual
puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5.
Entonces, la condición de la primera sentencia for va ser verdadera para valores de i=1 hasta
i=totalFilas (en el caso de totalFilas=5; los valores válidos para i son i=1, i=2, i=3, i=4 e i=5). Los
valores válidos de i coinciden con el número de filas que nuestra figura va a tener, por lo cual
podemos afirmar que para cada valor de i, corresponde una fila de la figura.
Para fila=5:
1ra fila ( i=1 ) * * * * *

2da fila ( i=2 ) * * * * *
3ra fila ( i=3 ) * * * * * for ( i = 1 ; i <= totalFilas; i++ ) {
4ta fila ( i=4 ) * * * * *
5ta fila ( i=5 ) }
* * * * *
Ahora, necesitamos mostrar un número determinado de asteriscos en cada una de las filas y ese
número de asteriscos a mostrar coincide con el número de filas de la figura (para nuestro caso
totalFilas=5).
Esta situación determina la existencia de la segunda sentencia for, dentro de la primera sentencia
for (for interno).
for ( i = 1 ; i <=totalFilas; i++ ) {
…
}
…
}
Para cada una de las filas (en el caso de totalFilas=5; para i=1, i=2, i=3, i=4 e i=5), el for interno se
ejecuta la misma cantidad de veces que el número de filas de la figura, y cada vez que se ejecuta
muestra un asterisco (en el caso de totalFilas=5, el for interno se ejecuta 5 veces y mostrará en
total 5 asteriscos en cada una de las filas). Cada vez que finaliza el for interno, la sentencia System.
out.println ( ); nos permite hacer un salto de línea y continuar con la ejecución de la solución, si la
condición del primer for es verdadera.
Los siguientes dos problemas son una variación de este problema. Analice sus respectivas soluciones
y desarrolle sus propias observaciones.
Problema 128
Enunciado:
Desarrollar la codificación de una solución que permita mostrar la siguiente figura:
1 2 3 4 5
Nota: En la figura mostrada, el número de filas = 5.
1 2 3 4 5
Asumir que el número de filas puede variar desde 2
1 2 3 4 5
hasta 9 y que entre los números no existen espacios
1 2 3 4 5 en blanco.
1 2 3 4 5
Clase PrgCuadrado03

do {

System.out.println ( “ Valor de fila no válido… Reintente!. ”);
}

// Se muestra el valor de la variable i.
System.out.print ( i ) ;
}

}
}
}
Problema 129
1 1 1 1 1
2 2 2 2 2 Nota: En la figura mostrada, el número de filas
3 3 3 3 3 = 5. Asumir que el número de filas puede variar
desde 2 hasta 9 y que entre los números no
4 4 4 4 4
existen espacios en blanco.
5 5 5 5 5
Clase PrgCuadrado03

do {

System.out.println ( “ Valor de fila no válido… Reintente!. ” );
}

}

}
}
}
Problema 130
* Nota: En la figura mostrada, el número

* * de filas = 5. Asumir que el número de filas
* * * puede variar desde 2 hasta 20 y que entre
* * * * los asteriscos no existen espacios en blanco.
* * * * *
Clase PrgTriangulo01
public class PrgTriangulo01 {

do {
System.out.println ( “ Ingresar el número de filas de la figura ”);

System.out.println (“ Valor de fila no válido… Reintente!. ”);
}
for ( j = 1 ; j <= i ; j++ ) {

}

}
}
}
puede variar desde 2 hasta 20. Para nuestra explicación, asumiremos que el valor de totalFilas=5.
Entonces, la condición de la primera sentencia for será verdadera para valores de i=1 hasta
i=totalFilas (en el caso de totalFilas=5; los valores válidos para i son i=1, i=2, i=3, i=4 e i=5). Los
valores válidos de i coinciden con el número de filas que nuestra figura va a tener, por lo cual
podemos afirmar que para cada valor de i, corresponde una fila de la figura.
Para fila=5:
1ra fila ( i=1 ) *

2da fila ( i=2 ) **
3ra fila ( i=3 ) for ( i = 1 ; i <= totalFilas; i++ ) {
***
4ta fila ( i=4 ) ****
5ta fila ( i=5 ) }
*****
Ahora, necesitamos mostrar un asterisco en la primera fila (i=1), 2 asteriscos en la segunda fila (i=2)
y asi sucesivamente hasta llegar a la última fila (para nuestro caso hasta la quinta fila → i=5).
Esta situación determina la existencia de la segunda sentencia for dentro de la primera sentencia
for (for interno).
for ( j = 1 ; j <= i ; j++ ) {
…
}
…
}
En la primera fila (i=1) se necesita mostrar un asterisco. Esto se cumple porque para i=1 el único
valor válido para j sería j=1, por lo que el for interno se ejecutaría una sola vez y se mostraría solo
un asterisco. Finalizada la ejecución del for interno, la sentencia System.out.println ( ); nos permite
hacer un salto de línea, es decir, pasar a la segunda fila.
En la segunda fila (i=2) se necesita mostrar dos asteriscos. Esto se cumple porque para i=2 los
valores válidos para j serían j=1 y j=2, por lo que el for interno se ejecutaría dos veces y en cada una
de las ejecuciones del for interno se mostrarían dos asteriscos (en consecuencia se mostrarían en
total dos asteriscos). Finalizada la ejecución del for interno, la sentencia System.out.println ( ) nos
permite hacer un salto de línea, es decir, pasar a la tercera fila y así sucesivamente hasta llegar a la
última fila.
En nuestro caso la última fila es 5 (i=5) y se necesita mostrar 5 asteriscos.Esto se cumple, ya que para
i=5, los valores válidos para j serían j=1, j=2, j=3, j=4 y j=5, por lo que el for interno se ejecutaría cinco
veces y en cada una de las ejecuciones del for interno se mostraría un asterisco (en consecuencia
se mostrarían en total cinco asteriscos). Luego se hace un salto de línea y se finaliza la ejecución.
Los siguientes siete problemas son una variación de este problema. Analice sus respectivas
soluciones y desarrolle sus propias observaciones.
Problema 131
1
1 2 Nota: En la figura mostrada, el número de filas
= 5. Asumir que el número de filas puede variar
1 2 3
desde 2 hasta 9 y que entre los números no
1 2 3 4 existen espacios en blanco.
1 2 3 4 5

do {
System.out.println ( “ Ingresar el número de filas de la figura”);

System.out.println ( “ Valor de fila no válido… Reintente!.”);
}
for ( j = 1 ; j <= i ; j++ ) {

// Se muestra el valor de la variable j.
System.out.print ( j ) ;
}

}
}
}
Problema 132
Enunciado:
Desarrollar la codificación de una solución que permita mostrar la siguiente figura:
1
Nota: En la figura mostrada, el número de filas = 5.
2 2
Asumir que el número de filas puede variar desde 2
3 3 3 hasta 9 y que entre los números no existen espacios
4 4 4 4 en blanco.
5 5 5 5 5

do {

System.out.println ( “ Valor de fila no válido… Reintente!.”);
}
for ( j = 1 ; j <= i ; j++ ) {

}

}
}
}
Problema 133
5
Nota: En la figura mostrada, el número de filas
5 4
= 5. Asumir que el número de filas puede variar
5 4 3 desde 2 hasta 9 y que entre los números no
5 4 3 2 1

do {
System.out.println (“ Ingresar el número de filas de la figura ”);

}
for ( i = totalFilas; i >= 1 ; i-- ) {
for ( j = totalFilas; j >= i ; j-- ) {

// Se muestra el valor de la variable j.
System.out.print ( j ) ;
}

}
}
}
Problema 134
5 Nota: En la figura mostrada, el número

4 4 de filas = 5. Asumir que el número de
3 3 3 filas puede variar desde 2 hasta 9 y que
2 2 2 2 entre los números no existen espacios en
1 1 1 1 1 blanco.

do {
System.out.print ( “ Valores válidos desde 2 hasta 9: ” );

}
for ( i = totalFilas; i >= 1 ; i-- ) {
for ( j = totalFilas; j >= i ; j-- ) {

}

}
}
}
Problema 135

2 3 de filas = 5. Asumir que el número de filas
4 5 1 puede variar desde 2 hasta 9 y que entre los
2 3 4 5 números no existen espacios en blanco.
1 2 3 4 5

int totalFilas = 0 , i = 0 , j = 0 , k = 0 ;
do {
System.out.print (“ Valores válidos desde 2 hasta 9: ” ) ;

System.out.println (“ Valor de fila no válido… Reintente!.”);
}

for ( j = 1 ; j <= i ; j++ ) {
if ( k == totalFilas) {
k = 1 ;
} else {
k ++ ;
}
System.out.print ( k ) ;
}
}
}
}
Problema 136
1 Nota: En la figura mostrada, el número de filas

2 3 = 5. Asumir que el número de filas puede variar
4 5 6 desde 2 hasta 20 y que entre los números no
1 2 3 4 5

do {

System.out.println (“Valor de fila no válido… Reintente!.”);
}

for ( j = 1 ; j <= i ; j++ ) {
if ( k == 9 ) {
k = 0 ;
} else {
k ++ ;
}
}
}
}
}
Problema 137

4 3 de filas = 5. Asumir que el número de filas
2 1 5 puede variar desde 2 hasta 9 y que entre los
4 3 2 1 números no existen espacios en blanco.
5 4 3 2 1

int totalFilas = 0 , i = 0 , j = 0 , k = 0 ;
do {

}

k=totalFilas+1;

for ( j = 1 ; j <= i ; j++ ) {
if ( k == 1 ) {
k = totalFilas ;
} else {
k-- ;
}
}
}
}
}
Problema 138
* * * * * Nota: En la figura mostrada, el número

* * * * de filas = 5. Asumir que el número de filas
* * * puede variar desde 2 hasta 20 y que entre
* * los asteriscos no existen espacios en blanco.
*

do {
System.out.print ( “ Valores válidos desde 2 hasta 20: ”);
if ( totalFilas < 2 || totalFilas > 20 ) {

}
} while ( totalFilas < 2 || totalFilas > 20 ) ;
for ( i = 1 ; i <= totalFilas; i ++ ) {
for ( j = 1 ; j < i ; j ++ ) {
System.out.print ( “ ” ) ;
}
for ( j = i ; j <= totalFilas ; j ++ ) {
System.out.print ( “*” ) ;
}
}
}
}
Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos); si no lo consigue,
analice la siguiente solución.
Clase PrgTriangulo09Mejorado
public class PrgTriangulo09Mejorado {

do {
System.out.println ( “ Valor de fila no válido… Reintente!.” ) ;
}
for ( j = 1 ; j < = totalFilas ; j ++ ) {

if ( i < = j ) {
} else {
}
}
}
}
}
Problema 139
*
* * Nota: La cantidad de asteriscos que tiene la figura al
* * * lado derecho es el dato que se debe ingresar. Dicho
dato debe tener un valor entre 2 y 20. En la figura,
* * * *
el lado = 5. No existen espacios en blanco entre los
* * * * * asteriscos.
Etapa 04 - Desarrollo de la codificación en Java

do {
}
for ( j = totalFilas ; j > = 1 ; j - - ) {

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

…
…
…
}
Si no lo consigue, analice la siguiente solución:

do {

System.out.print (“Valor de fila no válido… Reintente!.”);
}

for ( j = 1 ; j < = totalFilas ; j++ ) {
if ( j <= totalFilas - i ) {
} else {
}
}
}
}
}
Es importante indicar que un problema puede ser solucionado de diferentes formas.

Problema 140
*
* * Nota: En la figura mostrada, el número
* * * de filas = 5. Asumir que el número de filas
puede variar desde 2 hasta 20 y que entre los
* * * *
asteriscos existe un espacio en blanco.
* * * * *

do {
totalFilas = Lectura.leerInt() ;

System.out.println ( “ Valor de fila no válido… Reintente!. ” ) ;
}
for ( i = 1 ; i <= totalFilas ; i++ ) {

for ( j = i ; j < totalFilas ; j++ ) {
// Se muestra un espacio en blanco.
System.out.print ( “ ”) ;
}
for ( j = 1 ; j <= i ; j++ ) {
// Se muestra un asterisco y un espacio en blanco.
System.out.print ( “* ”) ;
}
// Se realiza un salto de linea.
}
}
}
puede variar desde 2 hasta 20. Para nuestra explicación asumiremos que el valor de totalFilas=5.
El primer for (como en todos los casos anteriores) está justificado y se ejecuta la misma cantidad de
veces que el número de filas de la figura. Cada vez que se ejecute el primer for se debe asegurar que
se muestren los asteriscos necesarios.
Para fila=5:
1ra fila ( i=1 ) *

2da fila ( i=2 ) * * for ( i = 1 ; i <= totalFilas ; i++ ) {
3ra fila ( i=3 ) * * *
4ta fila ( i=4 ) * * * * }
5ta fila ( i=5 ) * * * * *
Es necesario mostrar un asterisco en la primera fila (i=1), un asterisco, un espacio en blanco y otro
asterisco en la segunda fila (i=2) y así sucesivamente hasta llegar a la última fila (para nuestro caso
hasta la quinta fila → i=5). Pero si se observa bien la figura, se debe tener en cuenta la ubicación de
los asteriscos en cada fila, lo cual complica la lógica de la solución.
Es necesario encontrar algunos parámetros para establecer una constante matemática (una relación
matemática) que permita mostrar adecuadamente la figura. Para realizar un mejor análisis, se van
a representar los espacios en blanco de la figura con un guión - (esto para visualizar la cantidad de
espacios en blanco necesarios en cada fila).
*
- - - *- * Nota: Los guiones representan
- - *- *- * espacios en blanco. Entre un guión y un
- -* -* -* * asterisco no hay ningún símbolo.
- * *- *- *- *
- - - -
Ahora, se realizará una división imaginaria en la figura y se separarán los espacios en blanco ubicados
a la izquierda del primer asterisco de cada fila.
* Nota: Se determina que existe una relación en la

- - - *- * parte donde están los espacios en blanco. En la
- - -* -* * primera fila (i=1) se muestran fila - 1 espacio en
- -* -* -* * blanco y luego se muestra un espacio en blanco
- * *- *- *- * menos cada vez que se muestra una nueva fila,
- - - - hasta llegar a la última fila donde no se muestra
ningún espacio en blanco.
En la parte donde están ubicados los asteriscos y los espacios en blanco entre los asteriscos, es
necesario buscar una relación matemática. Para esto, se debe incluir un espacio en blanco al final de
cada una de las filas de la figura.
*
- - - *- -*
- - -* -* *-
- -* -* -* *-
- * *- *- *- -* Una pareja (formada por un asterisco y un
- - - - - espacio en blanco).
Nota: Se determina que existe una relación en la parte donde están ubicados los asteriscos y espacios en
blanco entre los asteriscos. En la primera fila (i=1) se muestra un asterisco y un espacio en blanco (una pareja
“*-”), en la segunda fila dos parejas y así sucesivamente hasta llegar a la última fila donde se muestran cinco
parejas.
Al analizar la figura, se determina que hay dos partes independientes, por lo que se necesita emplear
dos for internos.
El primer for interno permite mostrar los espacios en blanco ubicados antes del primer asterisco de
cada una de las filas.
Para fila=5:
1ra fila ( i=1 ) - - - - for ( j = 1 ; j < totalFilas ; j++) {

2da fila ( i=2 ) - - - System.out.print ( “ ”) ;
3ra fila ( i=3 ) - - }
4ta fila ( i=4 ) -
5ta fila ( i=5 )
El segundo for interno permite mostrar los asteriscos y los espacios en blanco ubicados después de
cada uno de los asteriscos en cada una de las filas:
Para fila=5:
1ra fila ( i=1 ) *

* -*
2da fila ( i=2 ) for ( j = 1 ; j <= i ; j++ ) {
3ra fila ( i=3 ) * *- *- System.out.print ( “* ”) ;
4ta fila ( i=4 ) * *- *- *- }
5ta fila ( i=5 ) * *- *- *- *-

- - - - -
Intente mejorar la solución anterior (en lugar de usar tres sentencias for utilice solo dos), sino lo consigue
analice la siguiente solución.

int totalFilas = 0, i = 0, j = 0, cont = 0 ;
do {
totalFilas = Lectura.leerInt() ;
System.out.println ( “ Valor de fila no válido… Reintente!. ”);
}

for ( j = 1 ; j < totalFilas * 2 ; j++ ) {
if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont )) {
j ++ ;
} else {
}
}
cont ++ ;
}
}
}
Imagínese ahora al triángulo como si este fuera un rectángulo (complete con guiones los espacios
en blanco que tendría la figura si fuera un rectángulo). La variable i va a representar cada una de las
filas, mientras que la variable j va a representar cada una de las columnas.
j
*
- - - *- -* - - -
Nota: Los guiones representan espacios en blanco.
- - *- *- *- - -
Entre un guión y un asterisco no hay ningún símbolo.
i - -* *- *- * -
- * *- *- *- *-
- - - -
El primer for controla el número de filas que se mostrarán (desde i=1 hasta i=totalFilas).
El segundo for (for interno) se ejecuta para cada una de la filas y controla el número de símbolos
(asteriscos o espacios en blanco) que se van a mostrar (en total se deben mostrar totalFilas * 2 –
1 símbolos). En el for interno hay una sentencia if que nos permite determinar el símbolo que se
mostrará.
if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) {

j ++ ;
} else {
}
Ahora, intente mejorar la solución. Utilice el primer planteamiento desarrollado. Analice nuevamente
el siguiente gráfico:
*
- - - *- -*
- - -* -* *-
- -* -* -* *-
- * *- *- *- -*
- - - - -

for ( j = 1 ; j <= totalFilas ; j++ ) {
if ( j <= totalFilas - i ) {
} else {
}
}
}
También:

for ( j = 1 ; j <= totalFilas ; j++ ) {
if ( j > totalFilas - i ) {
} else {
}
}
}
Problema 141
*
Nota: Desarrollar la figura con la estructura
* * de repetición MIENTRAS (while). El lado del
* * * rombo debe tener un valor entre 2 y 10. En la
* * * * figura, el lado = 4.
* * *
* *
*
Clase PrgRombo01
public class PrgRombo01 {
int totalFilas = 0, diagonal = 0, cont = 0, i = 1, j = 1 ;
System.out.println (“ Programa que realiza un rombo de *s con la estructura

\“WHILE\” \n” ) ;
System.out.print ( “ Ingrese el lado del rombo entre [2,10]: ” ) ;
do {

System.out.println ( “\nValor fuera de rango. Ingrese entero
entre [2,10]: ” ) ;
}
diagonal = totalFilas * 2 - 1 ;
while ( i <= diagonal ) {
j = 1 ;
while ( j <= diagonal ) {
if ( j < totalFilas - cont || j > totalFilas + cont )
else {
System.out.print ( “* ” ) ;
j ++ ;
}
j ++ ;
}
if ( i < totalFilas )
cont ++ ;
else
cont - - ;
i ++ ;
}
}
}
Analice la solución del problema y anote sus conclusiones. Intente resolverlo utilizando la sentencia for de
Java.
Problema 142
1
2 2 Nota: La figura mostrada es un rombo de
3 3 3 número. Ingresar un valor entero desde 2 hasta 9
4 4 4 4 que representa el número de elementos de la fila
3 3 3 central. En la figura, el dato = 4
2 2
1
Clase PrgRombo02
int num = 0, diagonal = 0, cont = 0, n = 0, i = 1, j = 1 ;
System.out.println ( “ Programa que realiza un rombo de números ” ) ;

System.out.print ( “ Ingrese el número máximo de la figura entre [2,9]: ” ) ;
do {
if ( num < 2 || num > 9 ) {

System.out.println ( “\nValor fuera de rango. Ingrese enteros entre
[2...9]:” ) ;
}
} while ( num < 2 || num > 9 ) ;

diagonal = 2 * num - 1 ;
for ( i = 1 ; i <= diagonal ; i ++ ) {
n = cont + 1 ;
for ( j = 1 ; j <= diagonal ; j ++ ) {
if ( j >= num - cont && j <= num + cont ) {
//Se muestra el contenido de la variable n y un espacio en blanco.
System.out.print ( n + “ ” ) ;
j ++ ;
} else
}
if ( i < num )
cont ++ ;
else
cont - - ;
}
}
}
Modifique está solución utilizando la estructura de repetición while en lugar de la estructura for.
Problema 143
* * * * *
* * Nota: En la figura mostrada, el número de
* * filas = 5. Asumir que el número de filas puede
* * variar desde 2 hasta 15.
* * * * *
Clase PrgFiguraA
public class PrgFiguraA {

int lado = 0;
System.out.println ( “ Programa que realiza un cuadrado hueco\n ” ) ;
System.out.print ( “ Ingrese lado del cuadrado entre [2,15]: ” ) ;
do {
if ( lado < 2 || lado > 15 ) {

System.out.println ( “\nValor fuera de rango. Ingrese entero
entre [2,15]: ” ) ;
}
} while ( lado < 2 || lado > 15 ) ;
for ( int fil = 1 ; fil <= lado ; fil ++ ) {
for ( int col = 1 ; col <= lado ; col ++ ) {
if ( ( 1 < fil && fil < lado ) && ( 1 < col && col < lado ) ) {
// Se muestran dos espacios en blanco.
} else {
System.out.print ( “* ” ) ;
}
}
}
}
}
Problema 144
* Nota: La cantidad de asteriscos que tiene la

* * figura al lado izquierdo es el dato que se debe
* * ingresar. Dicho dato debe tener un valor entre
* * 2 y 20. En la figura, el lado = 5.
* * * * *
Clase PrgFiguraB
public class PrgFiguraB {

int lado = 0 ;
System.out.println ( “ Programa que realiza un triángulo de asteriscos: ”);

System.out.print ( “ Ingrese el lado del triángulo entre [2,20]: ” ) ;
do {
if ( lado < 2 || lado > 20 ) {

System.out.println ( “\nValor fuera de rango. Ingrese
entero entre [2,20]: ” ) ;
}
} while ( lado < 2 || lado > 20 ) ;
for ( int fil = 1 ; fil <= lado ; fil ++ ) {

for ( int col = 1 ; col <= fil ; col ++ ) {
if ( ( col == 1 ) || ( fil == col ) || ( fil == lado ) )
System.out.print ( “* ” ) ; // Un asterisco y un espacio.
else
System.out.print ( “ ” ) ; // Dos espacios.
}
}
}
}
Problema 145
*
Nota: El dato de ingreso debe ser la cantidad de
* *
asteriscos que tiene la base. La base debe tener un
* * valor impar entre 3 y 25. En la figura, la base = 9.
* *
* * * * * * * * *
Clase PrgFiguraC
public class PrgFiguraC {

int base = 0, medio = 0 ;

System.out.println ( “ Programa que realiza un triángulo hueco de base
impar \n ” ) ;
System.out.print (“ Ingrese la base impar del triángulo entre [3,25]: ” );
// valide el ingreso de la base.

base = Lectura.leerInt ( ) ;
medio = base / 2 + 1 ;
for ( int fil = 0 ; fil < medio ; fil++ ) {

for ( int col = 1 ; col <= base ; col++ ) {
if ( col == medio + fil || col == medio - fil || fil + 1 == medio )
System.out.print ( “* ” ) ; // Un asterisco y un espacio.
else
System.out.print ( “ ” ) ; // Dos espacios.
}
}
}
}
IMPORTANTE
Se recomienda solucionar los problemas del 61 al 70, planteados
al final del presente capítulo.
PUNTO APARTE
5.4 dEsaRROllO dE miniaPliCaCiOnEs java (aPPlET) UTilizandO java dEvElOPmEnT KiT ( jdK )
Se pueden ejecutar los applets Swing (JApplet) en cualquier navegador que tenga instalado el Java
Plug-in (http://java.sun.com/products/plugin/). Si tiene instalado dicho plug-in, solo deberá crear una
pequeña página HTML que cargue el applet Swing en el navegador.
A continuación, se muestra un ejemplo de cómo crear la página HTML que permita cargar la clase
PrgBienvenida2.class creada en el problema 7.
Se crea un archivo denominado “PrgBienvenida2.htm” y se coloca lo siguiente:
<HTML>
<HEAD>
</HEAD>
<BODY>
Applet del PROBLEMA 048

<APPLET CODE=“PrgBienvenida2.class” WIDTH=320 HEIGHT=350
</APPLET>
</BODY>
Luego, deberá hacer doble clic con el botón izquierdo del mouse de la computadora sobre este archivo y se
ejecutará el navegador de internet que tenga en su computadora y cargará el applet cuyo nombre este en el
TAG <APPLET CODE con el ancho y altura especificado en los TAG WIDTH y HEIGHT.
Otras opciones para ejecutar los applets Swing (JApplet) es utilizar un navegador que sea complatible
con el JDK 1.1 y que utilice las clases Swing (Los dos navegadores Java distribuidos con el JDK 1.1 son
HotJava browser [http://java.sun.com/products/hotjava/] y el AppletViewer) o un navegador que sea
compatible con el JDK 1.2 (El navegador Java distribuido con el JDK 1.2 es el AppletViewer versión 1.2).
En el presente texto se ha utilizado el AppletViewer 1.2 (Por esta razón, en el título de las ventanas
de los diferentes problemas resueltos se puede apreciar el nombre de la utilidad AppletViewer.
Debe comprender que el applet solo es lo que se muestra al interior de la ventana, de la utilidad
AppletViewer).
Para ejecutar el AppletViewer puede crear un archivo por lotes. Dicha aplicación también se encuentra
almacenada en la carpeta bin, de la carpeta donde se instaló el JDK. Recuerde solo invocar el archivo
HTML cuando ejecuta el AppletViewer.
Por ejemplo, si quiere ejecutar la miniaplicación creada en Java para la solución del problema 79,
deberá crear el siguiente archivo HTML:
Archivo denominado “PrgPromedio.htm”:
<HTML>
<HEAD>
</HEAD>
<BODY>
Applet del PROBLEMA 079

<APPLET CODE=“PrgPromedio.class” WIDTH=320 HEIGHT=370
</APPLET>
</BODY>
</HTML>
Segundo, deberá ejecutar el archivo HTML creado, utilizando el AppletViewer. En este punto es
recomendable crear un archivo por lotes.
Observe la creación de un archivo por lotes en la plataforma MS-Windows y cómo se utilizan los programas
javac.exe para compilar el archivo “PrgPromedio.java” y appletviewer.exe para ejecutar el archivo “PrgPromedio.
htm”, ambos almacenados en la carpeta “C:\aplicaciones\dominioDeLaAplicacion” en la etapa de EDICIÓN. Como
ejemplo; el archivo por lotes será grabado con el nombre “PrgPromedio.bat” en la carpeta “C:\aplicaciones”.
Observe, además que al ejecutar este archivo por lotes de Windows (se ejecuta haciendo doble clic sobre el archivo),
se crea el archivo class en la carpeta “C:\aplicaciones\dominioDeLaAplicacion” y se ejecuta la miniaplicación en
el AppletViewer.
5.5 méTOdOs dE las 6´d – UsO dE cUadROs dE diálOgO

A continuación, se definen formalmente los pasos del Método de las 6’D para el desarrollo de
ENUNCIADO
DEL
PROBLEMA

Definición Definición Definición
MODELAMIENTO MODELAMIENTO
}|Determinar la }|Determinar el }|Codificar el diseño
información deseada nombre del proyecto. de la solución del
(salida). }|Definir el paquete problema. Utilizar
}|Determinar los datos y las clases que el lenguaje de
de entrada (entrada). formarán parte programación Java.
de la solución del Utilice la clase
}|Establecer como
problema. Utilice reutilizable LE.
se solucionará el
problema (proceso). UML.
}|Definir las clases
que serán parte
de la solución del
problema. Utilice
UML.
ALGORITMO
para el método
principal. Utilizar
el diagrama de
actividades.
Problema 146
Enunciado: En base al enunciado del problema 103, ingresar las tres notas de los alumnos de un
salón de clase. Calcular y mostrar el promedio de notas de cada alumno. Adicionalmente, si el
alumno obtiene un promedio final mayor a 16, se deberá visualizar un mensaje de felicitaciones.
Consistenciar el ingreso de las notas y desarrollar la codificación en el lenguaje de programación
Java. Finalmente, utilice la clase LE para ingresar datos y mostrar la información.
Definir el nombre del proyecto, luego desarrollar la definición del paquete y las clases, y el diagrama
de actividad.
Clase PrgPromedio
class PrgPromedios {
String mensaje ;
double nota1 , nota2 , nota3 ;
double promedio ;
int numAlu ;
do {
numAlu = LE.leerInt ( “Ingrese la cantidad de alumnos” ) ;
if ( numAlu < 1 ) {
LE.mostrarInformacion ( “Cantidad no válida” ) ;
}
} while ( numAlu < 1 ) ;

for ( int i = 0 ; i < numAlu ; i++ ) {
do {
nota1 = LE.leerDouble ( "Ingrese nota1” ) ;

} while ( ( nota1 < 0 && nota1 > 20 ) || ( nota2 < 0 &&

nota2 > 20 ) || ( nota3 < 0 && nota3 > 20 ) ) ;

mensaje = “Promedio del alumno [” + ( i + 1 ) + “] es ” ;

mensaje += promedio ;
if ( promedio > 16 ) {
mensaje += “\n\nFelicitaciones” ;
} else {
mensaje += “ ” ;
}
LE.mostrarInformacion ( mensaje ) ;
System.exit ( 0 ) ;
}
}
Resultado:
Problema 147
Enunciado: En base al enunciado del problema 105, ingresar la categoría y el sueldo de todos los
trabajadores de una empresa. Calcular el aumento correspondiente teniendo en cuenta la siguiente
tabla. Mostrar el nuevo sueldo de cada uno de los trabajadores. Consistenciar el ingreso de los
datos. Desarrollar la codificación en el lenguaje de programación Java. Finalmente, utilzar la clase
LE para ingresar datos y mostrar información.
Categoría Aumento
1 25%
2 15%
3 10%
4 05%
de actividad.
class PrgSueldoCategoria {
String opcs [ ] = { “Seleccione” , “1” , “2” , “3” , “4” } ;

double sueldo ;
do {
numTrab = LE.leerInt ( “Ingrese la cantidad de trabajadores” ) ;
LE.mostrarError ( “Cantidad no válido” ) ;
}

do {
categoria = LE.seleccionarOpcionIndex (
“Categoría del trabajador ” + ( i + 1 ) , “” , opcs ) ;
} while ( categoria <= 0 ) ;
do {
sueldo = LE.leerDouble ( “Sueldo del trabajador ” + ( i + 1 ) ) ;
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
}
LE.mostrarInformacion ( “El nuevo sueldo es: ” + sueldo ) ;
}
System.exit ( 0 ) ;
}
}
Resultado:
Problema 148
Enunciado: En base al enunciado del problema 107, ingresar las tres notas de los alumnos de
un salón de clase. Mostrarlas ordenadas ascendentemente y el promedio final de cada alumno.
Adicionalmente, mostrar el promedio de notas de todos los alumnos, consistenciar el ingreso de las
notas y desarrollar la codificación en el lenguaje de programación Java. Finalmente, utilice la clase
LE para ingresar los datos y mostrar la información.
de actividad.
Clase PrgNotas
class PrgNotas {
String opcs [ ] = { “0” , “1” , “2” , “3” , “4” , “5” , “6” , “7” ,
“8” , “9” , “10” , “11” , “12” , “13” , “14” , “15” , “16” , “17” ,
“18” , “19” , “20” } ;
String mensaje ;
double nota1 , nota2 , nota3 , notaMa=0 , notaMe=0 , notam=0 ;

double promedio = 0 , sumaTotal = 0 ;
int numAlu = 1 ;
do {
numAlu = LE.leerInt ( “Ingrese la cantidad de alumnos” ) ;
} while (numAlu <= 0 ) ;

for ( int i = 0 ; i < numAlu ; i ++ ) {
do {
nota1 = LE.seleccionarOpcionIndex ( “Nota1 del alumno ” +
( i + 1 ) , “” , opcs ) ;
} while ( nota1 == -1 ) ;
do {
( i + 1 ) , “” , opcs ) ;
} while ( nota2 == -1 ) ;
do {
( i + 1 ) , “” , opcs ) ;
} while ( nota3 == -1 ) ;

notaMa = nota1 ;
notaMe = nota3 ;
notam = nota2 ;
} else {
notaMe = nota2 ;
notam = nota3 ;
}
}

notaMa = nota2 ;
notaMe = nota3 ;
notam = nota1 ;
} else {
notaMe = nota1 ;
notam = nota3 ;
}
}

notaMa = nota3 ;
notaMe = nota2 ;
notam = nota1 ;
} else {
notaMe = nota1 ;
notam = nota2 ;
}
}
mensaje = notaMa + “\n” + notam + “\n” + notaMe ;

mensaje += “\nEl promedio del alumno ” + ( i + 1 ) + “ es ” ;
mensaje += promedio ;
sumaTotal += promedio ;
LE.mostrarInformacion (“El promedio general es ” + (sumaTotal/numAlu ) );

System.exit ( 0 ) ;
}
}
Resultado:
Problema 149
Enunciado: En base al enunciado del problema 109, desarrollar un menú con las siguientes opciones:

[2] Determinar el número de cifras del número.
[3] Determinar si el número es par o no.
[4] Finalizar.
Consistenciar el ingreso de todos los datos. Considerar que para la solución de este problema,
primero se deberá visualizar solo las opciónes 1 y 4. Después de ingresar el número, se deberá
visualizar todas las opciones.
Desarrollar la codificación en el lenguaje de programación Java. Luego utilizar la clase LE para

ingresar los datos y mostrar la información.
de actividad.
Clase PrgMenuNumero
class PrgMenuNumero {
int opc , sw = 0 , num = 0 , numCifras , numTmp ;

String menu , mensaje ;

“------------------------------------------- \n” +

“[2] Determinar el número de cifras del número \n ” +
“[3] Determinar si el número es par o no \n ” +
“------------------------------------------- \n” +
menu = menu1 ;
do {
opc = LE.leerInt ( menu ) ;
switch ( opc ) {
case 1 :
do {
num = LE.leerInt ( “Ingrese un número: ” ) ;
if ( num <= 0 ) {
LE.mostrarError ( “Número no válido... ” ) ;
}
} while ( num <= 0 ) ;
menu = menu2 ;
sw = 1 ;
break ;
case 2 :
if ( sw == 1 ) {
numTmp = num ;
numCifras = 0 ;
while ( numTmp > 0 ) {

numTmp = numTmp / 10 ;
numCifras ++ ;
}
mensaje = “El número de cifras es : ” ;
LE.mostrarInformacion ( mensaje + numCifras ) ;
} else {
LE.mostrarError ( “Ingrese la opción 1” ) ;
}
break ;
case 3 :
if ( sw == 1 ) {
if ( num % 2 == 0 ) {
mensaje = “El número es par ” ;
} else {
mensaje = “El número es impar ” ;
}
} else {
LE.mostrarError ( “Ingrese la opción 1” ) ;
}
break ;
case 4 :
break ;
default :
LE.mostrarError ( “Opción no válida. Reintente! ” ) ;
}
} while ( opc != 4 ) ;
System.exit ( 0 ) ;
}
}
Problema 150
Enunciado: En base al enunciado del problema 141. Desarrollar la codificación de una solución que
permita mostrar la siguiente figura:
*
* * Nota: Desarrollar la figura con la estructura
* * * de repetición MIENTRAS (while). El lado del
* * * * rombo debe tener un valor entre 2 y 10. En
la figura, el lado = 4.
* * *
* *
*
de actividad.

Clase PrgRombo01

int totalFilas = 0, diagonal = 0, cont = 0, i = 1, j = 1 ;

String texto , figura = “” ;
texto = “ Programa que realiza un rombo con la estructura\“WHILE\” \n ”;

texto = texto + “\n Ingrese el lado del rombo entre [2,10]: ” ;
do {
totalFilas = LE.leerInt ( texto ) ;
if ( totalFilas < 2 || totalFilas > 10 ) {

LE.mostrarError ( “Valor ingresado no válido ” ) ;
}
} while ( totalFilas < 2 || totalFilas > 10 ) ;

figura = “\n” ;
diagonal = totalFilas * 2 - 1 ;
while ( i <= diagonal ) {

j = 1 ;
while ( j <= diagonal ) {
if ( j < totalFilas - cont || j > totalFilas + cont )

// Se incluye un espacio en blanco.
figura = figura + “ ” ;
else {
// Se incluye un asterisco y un espacio en blanco.
figura = figura + “* ” ;
j++ ;
}
j++ ;
}
if ( i < totalFilas )
cont++ ;
else
cont-- ;
figura = figura + “\n” ;

i++ ;
}
LE.mostrarInformacion( “Figuras” , “Mostrando el rombo:” , figura , null ,
null ) ;
System.exit ( 0 ) ;
}
}
Resultado:
IMPORTANTE
Ahora, se recomienda solucionar los problemas planteados al
final del capítulo, utilizando la clase reutilizable LE.
1. Ingresar dos números y determinar cuántos son primos y cuántos son múltiplos de 3. Consistenciar
el ingreso de los datos.
2. Ingresar diez números y determinar el promedio de los números que tienen menos de tres cifras.
Consistenciar el ingreso de los datos.
3. Ingresar cinco números a través del teclado. Intercambiar la primera cifra con la última cifra y
mostrar los nuevos números. Consistenciar el ingreso de los datos.
4. Ingresar diez números a través del teclado y determinar cuántos números tienen una cifra, cuántos
números tienen dos cifras y cuántos tienen más de dos cifras. Consistenciar el ingreso de los datos.
5. Ingresar las cinco notas de todos los alumnos de un salón de clase. Calcular y mostrar el promedio
de notas de cada alumno. Adicionalmente, si el alumno obtiene un promedio final mayor a 14 se
deberá visualizar un mensaje de felicitaciones. Si está aprobado y tiene un promedio final menor
o igual a 14, un mensaje de aprobado. Consistenciar el ingreso de las notas.
6. Ingresar todas las notas de todos los alumnos de un salón de clase. Calcular y mostrar el promedio
de notas de cada alumno. Adicionalmente, si el alumno obtiene un promedio final menor a 11 se
deberá visualizar un mensaje de desaprobado. En caso que el alumno obtenga un promedio final
de 20, mostrar un mensaje de felicitaciones por excelencia. Consistenciar el ingreso de las notas.
7. Calcular y mostrar el sueldo de todos los trabajadores de una empresa conociendo el número de
horas trabajadas y su tarifa horaria. Se sabe que se descontará 15 % por concepto de impuestos si
este es mayor a S/. 2600.00. Consistenciar el ingreso de los datos.
8. Calcular y mostrar el sueldo de todos los trabajadores de una empresa conociendo el número de
horas trabajadas y su tarifa horaria. Se sabe que se aumentará el 12 % por reintegros varios y se
debe descontar 18 % por concepto de impuestos, si el sueldo es mayor a S/. 3200.00. Consistenciar
9. Calcular el sueldo de todos los trabajadores de una empresa si se conoce el número de horas
trabajadas y su tarifa horaria. Ingresar la categoría de cada trabajador de la empresa y calcular el
aumento correspondiente, teniendo en cuenta la siguiente tabla. Mostrar el sueldo, el aumento y
el nuevo sueldo de cada uno de los trabajadores. Consistenciar el ingreso de los datos.
Categoría Aumento
1 23 %
2 18 %
3 13 %
10. Calcular el sueldo de todos los trabajadores de una empresa conociendo el número de horas
trabajadas (la tarifa por hora es de S/. 15.00). Ingresar la categoría de cada trabajador de la
empresa y calcular el descuento correspondiente teniendo en cuenta la siguiente tabla.
Mostrar el sueldo, el descuento y el nuevo sueldo de cada uno de los trabajadores. Consistenciar
1 2%
2 6%
3 9%
4 11 %
5 12 %
11. Desarrollar una solución que permita determinar el sueldo bruto (sueldo antes del descuento),
el descuento y el sueldo neto (sueldo – descuento) de todos los vendedores de una empresa. La
empresa paga a sus vendedores por horas trabajadas. Hasta por 30 horas trabajadas se paga una
tarifa normal y sobre las 30 horas se paga un adicional de 18 %. Por otro lado, si el sueldo bruto es
superior a S/. 1820.00, el sueldo del trabajador estará sujeto a un descuento de 12 %. Ingresar las
horas trabajadas y la tarifa de cada vendedor.
12. Calcular y mostrar el costo que representa un paciente y el costo total que representan todos
los pacientes para un hospital de la gran ciudad, según los datos de la tabla. Adicionalmente,
considerar que los pacientes mayores de edad que tienen la enfermedad tipo 3 tienen un
descuento de 12 % y los pacientes de sexo femenino tienen un descuento de 10 %. Consistenciar
Tipo enfermedad Costo / paciente / día

A 120
B 216
C 297
13. Calcular y mostrar el costo que representa un paciente y el costo total que representan todos los
pacientes para una clínica prestigiosa, según los datos de la tabla. Adicionalmente, considerar
que los pacientes menores de 30 años tienen un descuento de 23 % si se realizan las operaciones
tipo 1 y 3. Los pacientes mayores de 60 años tienen un recargo de 20 % por cualquiera de las
operaciones y los pacientes de sexo femenino tienen un descuento de 10 % solo en el tipo de
operación 4. Consistenciar el ingreso de los datos.
Tipo de operación Costo por paciente
1 1200
2 2400
3 3200
4 5400
5 12 000
14. Ingresar la categoría y el precio de todos los productos de un supermercado. Calcular el descuento
correspondiente teniendo en cuenta la siguiente tabla. Mostrar el nuevo precio de cada uno de los
productos. Consistenciar el ingreso de los datos.
1 13 %
2 11 %
3 09 %
15. Ingresar el precio de compra y el precio de venta de todos los productos de un supermercado.
Calcular el descuento en base a la utilidad de cada producto teniendo en cuenta la siguiente tabla
y mostrar el nuevo precio de cada uno de los productos. Finalmente, verificar el ingreso de los
datos.
Utilidad Descuento
Menor o igual que 100 5%
Mayor que 100 y menor que 1000 9%
Mayor o igual que 1000 12 %
16. Desarrollar un menú con las siguientes opciones:

[1] Ingresar la base y altura de un triángulo rectángulo.
[2] Calcular y mostrar el área del triángulo.
[3] Calcular y mostrar el perímetro del triángulo.
[4] Finalizar.
Considerar que para la solución del problema, primero se deberá visualizar solo la opción 1 y 4.
Una vez ingresada la base y altura de un triángulo se deberá visualizar todas las opciones
17. Desarrollar un menú con las siguientes opciones:

[1] Ingresar un número entero mayor que 10.
[2] Calcular y mostrar si es múltiplo de 6.
[3] Calcular y mostrar el número de cifras.
[4] Calcular y mostrar si es primo o no.
[5] Calcular y mostrar si es par o no.
[6] Calcular y mostrar si es capicúa.
[7] Finalizar.
Considerar que para la solución de este problema, primero se deberá visualizar solo la opción 1 y
7. Después de ingresar el número se deberá visualizar todas las opciones.
18. Desarrolle un menú con las siguientes opciones:

[1] Ingresar el nombre de su mascota.
[2] Calcular y mostrar las vocales del nombre.
[3] Calcular y mostrar el número de letras “a” que hay en el nombre.
[4] Calcular y mostrar la primera letra en mayúscula y el resto en minúscula.
[5] Calcular y mostrar el nombre al revés.
[6] Finalizar.
Considerar que para la solución de este problema, previamente se deberá visualizar solo la opción
1 y 6. Después de ingresar el nombre, se deberá visualizar todas las opciones.
19. En una frutería se venden productos de calidad de exportación, en base a la siguiente tabla , hallar
lo siguiente:
Tipo Precio / kilogramo

Mandarina 1.0
Guanábana 4.2
Mango 3.5
Fresa 6.0
Naranja 0.9
Melocotón 2.5
Uvas 1.5
Por la compra de más de 20 kilos de un determinado producto se le otorga un descuento de 12 % del

valor de la compra. Por la compra de 5 kilos de fresa u 8 kilos de guanábana, recibe gratis un kilo de
naranja. Desarrollar una solución que determine el monto de la compra, el monto del descuento y
la cantidad de kilos de naranja de obsequio. Ingrese el tipo de fruta y la cantidad de kilos que desea
comprar. El usuario podrá realizar varios pedidos en la misma compra.
20. En una tienda de autopartes para automóviles se venden diversos productos. Los descuentos se
aplican de acuerdo a la siguiente tabla:
Tipo Costo / unidad Descuento

Espejo S/. 25 10 %
Fundas S/. 60 15 %
Porta vaso S/. 18 5%
Seguro S/. 2.5 0%
Llantas S/. 175 25 %
Desarrollar una solución que fije el monto de compra de cada tipo de producto, el monto del descuento
de cada tipo de producto y el monto total a pagar por la compra. Ingresar el tipo de producto y la
cantidad de porciones que se quiere comprar. El usuario podrá realizar varios pedidos en la misma
compra. Adicionalmente, determinar el monto total pagado por todos los clientes.
21. Desarrollar una solución para el siguiente problema. Se desea hacer una estadística de las estaturas
de 1000 alumnos de un colegio, de acuerdo a lo siguiente:
}|Alturas hasta 1,60 metros.
}|Alturas entre 1,60 metros y 1,70 metros.
}|Alturas entre 1,70 metros y 1,80 metros.
}|Alturas mayores de 1,80 metros.
22. Calcular y mostrar el número de alumnos que tienen como promedio final menos de 11; los que
tienen un promedio final entre 11 y 14; aquellos que tienen un promedio final entre 15 y 17; y los
que tienen un promedio final mayor de 17. Ingresar las cuatro notas y calcular el promedio del
alumno en base a la siguiente fórmula: nf = (n1 + n2 + n3 + (n4 * 2)) / 5.
23. Calcular la nota media de los alumnos de una clase considerando “n” alumnos y “c” notas.
24. Un canillita vende cuatro tipos de loterías. Calcular el total de loterías vendidas de cada tipo, según
se muestra en el cuadro.
Tipo lotería Costo

1 2
2 4
3 6
4 8
25. En una empresa se decide hacer una colecta de dinero, con la finalidad de ayudar a uno de los
empleados de la empresa que ha sufrido un accidente automovilístico. Se determina que los
gerentes contribuirán con S/. 35.00, los profesionales con S/. 25.00 y el resto de empleados de
acuerdo a sus posibilidades. Determinar el total recaudado.
26. Desarrollar una solución que permita emitir la factura correspondiente a la compra de varios
artículos. El IGV a aplicar es de 18 % y si el monto total de la factura incluido el IGV es mayor a S/.
3000.00, se aplicará un descuento de 12 %.
27. Desarrollar una solución para el siguiente menú con las opciones solicitadas.
}|[1] Ingreso de datos (base y altura de un rectángulo).
}|[2] Proceso (determinar área y perímetro del rectángulo).
}|[3] Resultado (Mostrar el valor de área y perímetro obtenidos).
}|[4] Terminar.
28. Desarrollar una solución para el siguiente 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 por hora.
}|La tarifa del turno noche es de S/. 10.00 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 por concepto de movilidad.
29. Desarrollar 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 de las zonas palco, platea y mezanine.
}|Por cada entrada vendida se leerán los siguientes datos: número de boleto y lugar (puede ser
platea, palco o mezanine).
}|El programa terminará cuando el número de boletos 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 dinero recaudado durante el día.

||Número de entradas de todas las zonas vendidas durante el día.
30. Desarrollar una solución que permita obtener la siguiente información en un salón de clase:
}|¿Cuántas alumnas están matriculadas en el curso?
}|¿Cuántos alumnos están matriculados en el curso?
}|¿Cuántas alumnas son menores de 20 años?
}|¿Cuántos alumnos son mayores de 18 años?
}|¿Cuántos alumnos están aprobados?
}|¿Cuántas alumnas están desaprobadas?
31. Desarrollar una solución que permita ingresar los nombres y las edades de “n” alumnos. Determinar
la suma de las edades, el nombre del alumno con la mayor ........... y el nombre del alumno con la
menor ..........
32. Desarrollar una solución que permita determinar la nota final obtenida por cada uno de los
alumnos del curso de álgebra del colegio “La Excelencia” (considere tres notas). Adicionalmente,
deberá indicar el porcentaje de alumnos aprobados, desaprobados, la nota final más baja y la más
alta. Ingresar la cantidad de alumnos y las tres notas de cada alumno.
33. Desarrollar una solución que permita determinar el costo de cada uno de los artículos que se
venden en la bodega “La china” (considere el precio de venta y la utilidad obtenida por el artículo).
Adicionalmente, deberá indicar el promedio del costo de todos los artículos, el articulo más costoso
y el más barato. Finalmente ingresar el nombre, el precio de venta y la utilidad de cada artículo.
34. Desarrollar una solución para el siguiente problema. En la fábrica “La Clonación S.A.” trabajan
unos miles de obreros y se desea determinar cuántos tienen un salario menor a S/. 500.00, entre
S/. 500 00 y S/. 2200.00 (incluidos S/. 500.00 y S/. 2200.00) y cuántos tienen un salario mayor a
S/. 2200.00.
35. Desarrollar una solución que permita calcular y mostrar el costo total que representan los pacientes
de un hospital de acuerdo al tipo de enfermedad, según los datos de la tabla. Adicionalmente,
deberá considerar que los pacientes menores de 18 años implican un costo adicional de 35 % y las
mujeres un costo adicional de 12 %.
Enfermedad Tipo Costo diario

1 100
2 150
3 300
4 450
36. Desarrollar una solución para el siguiente problema. El cine “Pantalla Láser” cuenta con tres salas y
atiende en horarios de matiné, vermouth y noche. Calcular el número de personas que ingresaron
a cada una de las salas, en cada uno de los horarios en un determinado día. (Ingresar solo los
siguientes datos: número de sala y el horario al cual el cliente ingresa).
37. Desarrollar una solución para el siguiente problema. Una empresa cuenta con cuatro almacenes
de productos. ¿Cuál sería la ganancia por cada almacén si el dueño de la empresa decide vender
todos sus productos? (Ingresar solo los siguientes datos: el precio de compra de cada producto, el
precio de venta, la cantidad existente y el almacén donde están ubicados).
38. Desarrollar una solución que permita determinar cuántas hamburguesas de cada tipo fueron
vendidas (considere tres tipos) en cada uno de los tres locales de la empresa “El Rápido”. Deberá
ingresar el tipo de hamburguesa y el local en el que fue vendida.
39. Desarrollar una solución que permita determinar cuántos tipos de productos de cada empresa
de apoyo social fueron vendidos por la comunidad “La buena venta” durante el presente año
(considere solo tres empresas de apoyo social y asuma que cada empresa fabrica tres tipos de
productos; chocolate, caramelo y gaseosa). Ingresar el producto vendido y la empresa que lo
fabricó.
40. Desarrollar una solución que permita determinar cuántos tipos de periódicos de cada empresa
fue vendido por José Luis Candado, quien ganó el premio al mejor canillita 1999 otorgado por
un diario de la capital (considerar solo tres empresas periodísticas y asumir que cada empresa
desarrolla tres tipos de diario: popular, normal y especializado). Ingresar el tipo de diario vendido
y la empresa a la cual pertenece.
41. Desarrollar una solución que permita mostrar un menú con las siguientes opciones:
}|Determinar si un número es par o impar.
}|Determinar si un número es primo o no.
}|Salida.
42. Desarrollar una solución que permita mostrar un menú con las siguientes opciones.
}|Suma, resta y multiplicación de dos números.
}|Determinar el número inverso de un número.
}|Determinar el área y perímetro de un círculo.
}|Salida.
43. Desarrollar una solución que permita ingresar las edades de 10 alumnos. Determinar lo siguiente:
}|La suma de todas las edades.
}|La cantidad de edades impares.
}|El promedio de edades.
}|El promedio de edades pares.
}|La edad mayor.
}|La edad menor.

}|El nombre de la alumna que tiene la mayor edad.
44. Desarrollar una solución que permita ingresar los nombres y sueldos de cinco empleados y
determinar lo siguiente:
}|Sueldo promedio.
}|Menor sueldo.
}|Nombre del empleado con mayor sueldo.
}|Cantidad de nombre que comiencen entre “c y p”.
45. Desarrollar una solución que permita ingresar los valores de una matriz de 4*4. Calcular la suma
de la diagonal y la suma de la diagonal inversa.
46. Desarrollar una solución que permita ingresar los valores de una matriz de 5*4. Intercambiar la
primera columna por la tercera columna e intercambiar la segunda fila por la cuarta fila.
47. Desarrollar una solución que permita almacenar el nombre, la edad y el estado civil de 15
empleados. Elaborar un listado con los datos de los empleados entre 18 y 30 años y otro con los
datos de los empleados solteros.
48. Desarrollar una solución que permita ingresar un número entero de cualquier número de cifras.
Determinar y mostrar el dígito mayor del número ingresado. Finalmente validar el número
ingresado.
49. Desarrollar una solución que permita ingresar 10 nombres. Determinar el número de nombres
cuya primera letra es una letra “c” o una letra “x”. Determinar el nombre que tiene el menor
número de caracteres.
50. Desarrollar una solución que permita leer 10 apellidos, luego determinar cuál es el primer apellido
(según el orden alfabético).
51. Desarrollar una solución que permita leer 10 nombres y determinar cuántos nombres comienzan
entre las letras ‘z’ y ‘p’. Finalmente utilizar un vector.
52. Desarrollar una solución que reciba la fecha con el siguiente formato: 09-30-2004 (mm-dd-aaaa)
y lo convierta a este formato: 30 de septiembre de 2004.
53. Desarrollar una solución que reciba la fecha y hora con el siguiente formato: “dd/mm/aaaa
hh:mm:ss”. Ejemplo: 30/09/2004 18:10:10. Validar que la fecha y la hora tenga el número de
caracteres correctos, así como los símbolos indicados. Finalmente, mostrar los datos de la
siguiente manera: Hoy es 30 de septiembre y son las 6 y 10 de la tarde.
54. Desarrollar una solución que permita leer cuatro números de tres cifras y mostrar su categoría.
Si el número está entre 100 y 300 pertenece a la categoría A, está entre 301 y 600 pertenece a la
categoría B y si está entre 601 y 999 pertenece a la categoría C. Utilizar un vector y validar que el
número ingresado sea de tres cifras.
55. Desarrollar una solución que permita leer los datos de “n” alumnos. Los datos de los alumnos son:
nombre, fecha de nacimiento (dd/mm/aaaa) y nota.
Se solicita:
}|Ingresar los datos haciendo las validaciones a la fecha (tamaño de fecha y que contenga los
símbolos “/”) y nota.
}|Calcular y mostrar la edad de cada alumno.
}|Hallar:
||La nota promedio de todos los alumnos ingresados.

||Nombre del alumno con mayor nota.
||Cantidad de alumnos cuyo nombre comience entre las letras a y p.
}|Crear un menú de opciones para acceder al programa.
56. Desarrollar una solución que permita leer los datos de cinco empleados. Los datos de los
empleados son; nombre, fecha de ingreso (dd/mm/aaaa) y sueldo.
Se solicita:
}|Ingresar los datos haciendo las validaciones a la fecha (tamaño de fecha y que contenga los
símbolos “/”) y sueldo.
}|Calcular los años de servicio que tiene trabajando.
}|Hallar:
||El sueldo promedio.

||Nombre del empleado con menos años de servicio.
||Cantidad de empleados que ingresaron entre 1980 y 2004.
57. Desarrollar una solución que permita leer los datos de “n” alumnos. Los datos de los alumnos son;
nombre, edad y sexo.
Se solicita:
}|Ingresar los datos validando el sexo y la edad.
}|Por cada alumno mostrar:
||Nombre al revés.
||Ultimo carácter.
||Las tres últimas letras.
}|Cálculos:
||La edad promedio.

||Nombre de la persona con mayor edad.
||Nombre de la mujer con menor edad.
}|Crear un menú para acceder al programa.
nombre, fecha de nacimiento (dd/mm/aaaa) y nota.
Se solicita:
}|Ingresar los datos validando la fecha de nacimiento y la nota.

}|Mostrar por cada alumno la edad exacta (años y meses cumplidos a la fecha de hoy).
}|Calcular:
||La edad promedio.

||Nombre y la edad de la persona con mayor nota.
||Nombre de mujer con menor edad.
59. Desarrollar una solución que permita leer los datos de “n” empleados. Los datos de los empleados
son: nombre, AFP (Integra, Unión y ProFuturo), sueldo básico y fecha de ingreso (dd-mm-aaaa).
Se solicita:
}|Ingresar los datos validando AFP, sueldo y fecha de ingreso.
}|Calcular y mostrar el sueldo total por cada empleado ( sueldo total = sueldo básico – descuentos).
||Si tiene 4 años o más de antigüedad se le descuenta 8 %, además del descuento de la AFP.
||Si tiene menos de 4 años se le descuenta 10 %, además del descuento de la AFP.
||El descuento de la AFP se muestran en la siguiente tabla:
AFP Descuento
Integra 12 %
Unión 13 %
ProFuturo 14 %
}|Cálculos:
||Mostrar el nombre y la AFP de la persona con mayor sueldo.

||Mostrar el nombre de la persona que lleva menos tiempo de servicio.
sexo (M/F), edad y nombre.
Se solicita:
}|Ingresar los datos validando que en el sexo hay dos opciones; “M” o “F” y la edad sea un número
positivo.
}|Mostrar lo siguiente por cada alumno:
||Si es mayor o menor de edad.
||Cantidad de vocales del nombre.
}|Calcular:
||La edad promedio.

||Nombre de la persona de mayor edad.
||Nombre de hombre de menor edad.
PROBLEMAS PROPUESTOS SOBRE FIGURAS
61. Desarrollar la codificación de una solución que permita mostrar la siguiente figura:
1 2 3 4 5
6 7 8 9 0
1 2 3 4 5
6 7 8 9 0
1 2 3 4 5
Nota: En la figura mostrada, el número de filas = 5. Asumir que el número de filas puede variar desde 2 hasta
20 y que entre los números no existen espacios en blanco.
5 4 3 2 1
5 4 3 2 1
5 4 3 2 1
5 4 3 2 1
5 4 3 2 1
20, y que entre los números no existen espacios en blanco.
&
* *
& & &
* * * *
& & & & &
20, y que entre los números no existen espacios en blanco.
* * * * *
* * * *
* * *
* *
*
20, y que entre los asteriscos no existen espacios en blanco.
- - - - -
* *- *- *- *-
* *- *- *-
* *- *-
* -*
*
20 y que entre los asteriscos no existen espacios en blanco.
*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
Observar que en la primera fila se desea mostrar un asterisco y en las siguientes filas; 3, 5, 7… y así
sucesivamente (no hay espacios en blanco entre los asteriscos). Relación: el número de asteriscos a mostrar
en cada fila está dado por la fórmula: totalFilas * 2 - 1.
// Se muestra la última parte de la solución:

for ( j = 1 ; j < totalFilas * 2 ; j++ ) {
if ( ( j >= totalFilas – cont ) && ( j <= totalFilas + cont ) ) {
} else {
}
}
cont ++ ;
}
* * * * * * * * *
* * * * * * *
* * * * *
* * *
*
1
2 3
4 5 6
7 8 9 1
2 3 4 5 6
7 8 9 1
2 3 4
5 6
7
20, y que entre los números existen espacios en blanco.
2
4 6
8 0 2
4 6 8 0
2 4 6 8 0
2 4 6 8
0 2 4
6 8
0
Nota: En la figura mostrada el número de filas = 5. Asumir que el número de filas puede variar desde 2 hasta
20, y que entre los números existen espacios en blanco.
*
& &
* * *
& & & &
* * * * *
& & & &
* * *
& &
*
20, y que entre los símbolos existen espacios en blanco.
CAP.
Introducción al
desarrollo de soluciones
6
o r i e n t a d a s a o b j e to s y a l
u s o d e I n te r f a z G r á f i c a
de Usuario
CAP. 6: INTRODUCCIÓN AL DESARROLLO DE SOLUCIONES ORIENTADAS A OBJETOS Y AL USO DE I NTERFAZ GRÁFICA DE U SUARIO 585
La clase constituye la base de la programación orientada a objetos, y es el núcleo o unidad fundamental

de encapsulación en Java. Cualquier concepto que se desarrolle en Java debe encapsularse en una
clase que utilice el mecanismo de herencia para crear objetos. Las clases creadas pueden comportarse
como una aplicación basada en ventanas (aplicaciones con Interfaz Gráfica de Usuario o GUI) o una
aplicación para la web.

DEL PROBLEMA
Etapa 02
Definición
Solución
Etapa 03
Diseño
Solución
MODELAMIENTO Etapa 04
ALGORITMO Desarrollo
Solución
CODIFICACIÓN
En los capítulos anteriores, se ha utilizado la clase en su forma más simple. Las clases creadas se
utilizaban simplemente para encapsular el método main(), lo que ha permitido mostrar la base de la
sintaxis de Java, las estructuras de datos, las estructuras lógicas y las instrucciones de bifurcación. En
el presente capítulo se presentan las clases en su forma general, describiendo los atributos y métodos,
así como otros conceptos importantes y relacionados a estos temas.
Observe la solución del siguiente problema utilizando el método de las 6’D.

Enunciado: Calcular el promedio final de un alumno. Utilice la siguiente fórmula: prom = (nota1 +
nota2 + nota3) / 3. Ingrese las notas nota1, nota2 y nota3 a través del teclado.

B. Datos necesarios: Las notas del alumno (en esta caso tenemos tres notas).
C. Procesamiento: Las tres notas serán ingresadas a través del teclado y almacenadas en las
variables nota1, nota2 y nota3. Luego, se realizará el cálculo de la nota
final sobre la base de la siguiente fórmula:
prom = (nota1 + nota2 + nota3) / 3.
El resultado se almacenará en una variable (prom) para luego ser mostradas

por pantalla.
1. Nombre del proyecto: ProyAlumno


LE
(from biblioteca)
PrgAlumno ||leerString ()
||leerChar ()
||main ()
||leerInt ()
||leerLong ()
||leerFloat ()
||leerDouble ()
||mostrarResultado ()
||mostrarError ()
ENTRADA: nota1, nota2, nota3

SALIDA: prom
INICIO
NUMERO nota1, nota2, nota3, prom

LEER nota1, nota2, nota3
prom = ( nota1 + nota2 + nota3) / 3
ESCRIBIR prom
FIN
Clase PrgPromedio
class PrgAlumno {
double nota1, nota2, nota3, prom ;
nota1 = LE.leerDouble( “Ingrese la nota 1 del alumno ” ) ;
prom = ( nota1 + nota2 + nota3 ) / 3 ;
LE.mostrarInformacion ( “ El promedio obtenido por el alumno es ”+prom);
}
}
En este proyecto ProyAlumno se crea un paquete dominioDeLaAplicación con una clase PrgAlumno, que se utiliza
en su forma más simple. En la clase PrgAlumno se define un método main() y dentro del mismo se codifica toda
la solución.
A partir de este punto, se ampliará el conocimiento sobre las clases. Para ello, se revisarán algunos
conceptos básicos y se presentarán en forma progresiva nuevos conceptos hasta llegar al concepto
de ocultamiento de atributos de instancia.
Los nuevos conceptos presentados se incorporarán progresivamente en el ejemplo planteado.

Luego, se formalizará el Método de las 6’D. Finalmente, se presentarán algunas soluciones con
clases que incorporen una Interfaz Gráfica de Usuario (GUI). Todo esto como marco introductorio.
6.1 CONCEPTOS BÁSICOS
6.1.1 CLASE
Una clase es una implantación de un tipo de objeto. Especifica una estructura de datos (atributos)
y los métodos operativos permisibles que se aplican a cada uno de sus objetos. El mundo real se
modela mediante clases. Una clase es una abstracción que no refiere a ningún objeto en particular;
además, también define un nuevo tipo de objeto.
En Java, una clase se declara utilizando la palabra reservada class. Las clases que se han utilizado
anteriormente son ejemplos muy limitados en los que no aparece su formato general.
El formato general de una clase en Java es el siguiente:
class NombreClase {
// ATRIBUTOS
tipo variableInstancia1 ;
tipo variableInstancia2 ;
// ...
tipo variableInstanciaN ;
// METODOS
tipo nombreMetodo1 (listaDeParámetros) {
// cuerpo del método1.
}
tipo nombreMetodo2 (listaDeParámetros) {

// cuerpo del método2.
}
//...
tipo nombreMetodoN (listaDeParámetros) {

// cuerpo del métodoN.
}
}
Los datos o variables definidos en una clase son llamados atributos. El código está contenido en los
métodos. Los métodos y atributos definidos dentro de una clase son los miembros de la clase.
Los atributos definidos dentro de una clase permiten que los objetos o instancias de una clase
puedan almacenar datos.
Todos los métodos tienen el mismo formato que el método main(), utilizado en los ejemplos
anteriores. Sin embargo, es importante mencionar que muchos métodos, como public, staƟc o
public staƟc no se especificarán.
En el formato general de una clase no se especifica un método main(), fundamentalmente porque

no necesitan tenerlo, solo aquellas cuya función principal sea iniciar la ejecución del proyecto.
En el proyecto de solución ProyAlumno se tiene la clase llamada PrgAlumno. Dicha clase tendrá un
método main(). La declaración de esta clase en Java, incluido su método main() es la siguiente:
class PrgAlumno {
}
}
Entonces, el proyecto de solución ProyAlumno tiene definida la clase PrgAlumno con un método
main() en el paquete dominioDeLaAplicacion.
6.1.2 OBJETO (Modelos de entes del mundo)
Un objeto de soŌware es cualquier cosa real o abstracta en el cual almacenamos datos y los métodos
que los controlan. La definición de un objeto en Java comprende la declaración y la creación del mismo.
Se realiza utilizando la siguiente sentencia:

NombreClase nombreObjeto = new NombreClase ( ) ;
Donde:
}|nombreObjeto es el nombre del objeto que se desea crear.
}|nombreClase es el nombre de la clase que está siendo instanciada. El nombre de la clase seguida
por los paréntesis especifica el método constructor de la clase. Un constructor define que
ocurre cuando se crea un objeto de una clase. La mayoría de las clases del mundo real definen
explícitamente sus propios constructores dentro de la definición clase.
Si no se especifica explícitamente el constructor, Java automáticamente utiliza un constructor por

defecto (es decir, cuando se crea un objeto no ocurre nada). En el ejemplo, la clase Alumno no
define explícitamente un constructor, es decir, se le utiliza por defecto. Más adelante, se verá la
forma de definir métodos constructores en una clase.
}|new es un operador en Java que permite crear un objeto.
En el proyecto de solución ProyAlumno se definirán objetos de tipo PrgAlumno01 a través de la

siguiente sentencia:
PrgAlumno objAlumno01 = new PrgAlumno ( ) ;
En dicha sentencia, se define el objeto objAlumno01 de la clase PrgAlumno. Para definir otros objetos
de la clase PrgAlumno, solo se tendría que repetir la sentencia y cambiar el nombre del objeto.
Es importante recordar que la definición de una clase solo crea un molde, modelo o patrón a partir del
cual se pueden crear objetos. En cambio, la definición de un objeto crea un objeto real o una instancia
de una clase.
6.1.3 ATRIBUTO
Hasta este punto se tiene definida la clase PrgAlumno sin atributos, y con solo un método (el método
main()). Ahora, es necesario conocer algunos conceptos básicos sobre los atributos, para luego
definirlos dentro de la clase PrgAlumno.
Los atributos, en principio, sirven para almacenar valores de los objetos que se instancian a partir de
una clase.
Los atributos se clasifican en dos categorías:
A. Atributos de Instancia: Llamados también atributos de objeto; son variables, arreglos u objetos que
almacenan valores distintos para los objetos de una misma clase.
B. Atributos de Clase: Son variables, arreglos u objetos que almacenan el mismo valor para los objetos
de una misma clase.
Es decir que, a partir de un atributo de instancia, se crea una copia por cada objeto que se instancia;
a partir de un atributo de clase, solo se crea una copia de ese atributo para todos los objetos que se
instancien. Si no se especifica lo contrario, los atributos son de instancia. Para declarar un atributo
de clase en Java, se utiliza la palabra reservada staƟc.
La forma mínima de un atributo es la siguiente:
tipo nombreAtributo;
Donde:
}|Ɵpo, especifica el tipo de dato que el atributo almacenará. Puede ser cualquier tipo válido,
incluido los tipos de clase.
}|nombreAtributo, especifica el nombre del atributo, que puede ser cualquier identificador válido
diferente a los que se está utilizando en el mismo ámbito.
En el proyecto de solución ProyAlumno, en la clase PrgAlumno se definirá dos atributos de instancia

llamados nota1 y nota2.
class PrgAlumno {
double nota1 ;
double nota2 ;
}
}
En la clase PrgAlumno solo se han definido dos atributos y el método main(); sin embargo, aún no se
han definido otros métodos. Se agregarán otros métodos a la clase PrgAlumno más adelante.
También, se definirá el objeto objAlumno01 de la clase PrgAlumno, dentro de su método main().

class PrgAlumno {
double nota1 ;
double nota2 ;
PrgAlumno objAlumno01 = new PrgAlumno( ) ;
}
}
Cada vez que se define un objeto de una clase, se declara y crea un objeto que contiene una copia de
todos los atributos de instancia definidos para la clase.
En el proyecto de solución ProyAlumno, cada objeto que se defina de la clase PrgAlumno tendrá su
propia copia de los atributos de instancia nota1 y nota2. En consecuencia, el objeto objAlumno01 de
la clase PrgAlumno tendrá su propia copia de los atributos de instancia nota1 y nota2 con un valor
para cada uno de ellos, distinto al valor de las copias de los atributos de instancia que otros objetos
definidos puedan tener.
Cuando se desea acceder a la copia de los atributos de instancia de un objeto se utiliza el operador
punto (.). Este relaciona el nombre del objeto con el nombre de un atributo de instancia.
Por ejemplo, si se desea asignar el valor 15 y 19 a los atributos de instancia nota1 y nota2 del
objeto objAlumno01, se utilizarían las siguientes sentencias:
objAlumno.nota1 = 15 ;
objAlumno.nota2 = 19 ;
Estas sentencias permiten asignar a las copias de los atributos de instancia nota1 y nota2 que
están contenidas en el objeto objAlumno01 los valores 15 y 19 respectivamente.
Si se desea mostrar el valor del atributo de instancia nota1 del objeto objAlumno01 se utilizaría la
System.out.println ( “ La nota del alumno es: ” + objAlumno01.nota1 ) ;
Esta sentencia permite que se muestre el mensaje “La nota del alumno es:” y el valor del atributo
nota1 del objeto objAlumno01.
En el proyecto de solución ProyAlumno se necesita calcular y mostrar el promedio del alumno,

para lo cual se utilizarían las siguientes sentencias:
double prom = ( objAlumno01.nota1 + objAlumno01.nota2 ) / 2 ;

System.out.println ( “ El promedio final del alumno es: ” + prom ) ;
Estas sentencias permiten obtener el valor de los atributos nota1 y nota2 del objeto objAlumno01
para calcular el promedio de las notas y almacenarlo en la variable prom, para luego mostrar el
mensaje “El promedio final del alumno es:” y el valor de la variable prom calculada.
Según lo mencionado anteriormente, el proyecto de solución ProyAlumno se desarrollaría de la

siguiente manera:
class PrgAlumno {
double nota1 ;
double nota2 ;
// Primero declaramos y creamos un objeto de la clase PrgAlumno.

// Ahora asignamos valores a las variables de instancia del objeto creado.

objAlumno01.nota1 = 15 ;
// Finalmente, calculamos el promedio de notas del alumno objAlumno01.

double prom = ( objAlumno01.nota1 + objAlumno01.nota2 ) / 2 ;
}
}
Al ejecutar el proyecto, se ejecuta el método main() de la clase PrgAlumno y se obtiene el siguiente

resultado:
El promedio final del alumno es: 17
Es común que en todo proyecto de solución solo exista un método main(). Dicho método main() inicia
la ejecución del proyecto, y está definido en una de las clases que pertenecen al proyecto.
Ahora, se realizarán algunos cambios en el proyecto de solución ProyAlumno. Se agregará un atributo

de instancia en la definición de la clase PrgAlumno, de tal forma que se definan los atributos de
instancia nota1, nota2 y nota3. Es importante mencionar que si existen varios atributos del mismo
tipo en una misma clase, se puede separar sus nombres mediante comas (,) y declararlos con una sola
sentencia.
En base a esto, se modificará el método main() de la clase PrgAlumno para utilizar el atributo de
instancia nota3 y los conceptos tratados de la siguiente manera:
class PrgAlumno {
double nota1, nota2, nota3 ;
double prom ;
// Declaramos y creamos un objeto de la clase PrgAlumno.

// Asignamos valores a las variables de instancia del objeto creado.

// Finalmente, calculamos el promedio de notas del alumno objAlumno01.

prom = ( objAlumno01.nota1 + objAlumno01.nota2 + objAlumno.nota3 ) / 3 ;
}
}
Aquí el objeto objAlumno01 de la clase PrgAlumno creado en el método main( ) tiene su propia copia
de los atributos de instancia nota1, nota2 y nota3.
Es importante mencionar que los cambios que se realicen en los atributos de instancia de un objeto
no deben afectar a los atributos de instancia de los otros objetos. Porque cada objeto tiene un valor
distinto para cada atributo de instancia, independiente de los valores que pueden tener los otros
objetos.
Esto se puede comprobar fácilmente definiendo más de un objeto en el proyecto de solución

ProyAlumno. Para esto, se definirán dos objetos más denominados objAlumno02 y objAlumno03 en
el método main(). Luego, se les asignará valores a cada copia de los atributos de instancia nota1,
nota2 y nota3, para finalmente calcular y mostrar el promedio de las notas de cada uno de los objetos
de la clase PrgAlumno. Según lo mencionado anteriormente, el proyecto de solución ProyAlumno se
desarrollaría de la siguiente manera:
class PrgAlumno {
double prom ;
// Primero declaramos y creamos tres objetos de la clase PrgAlumno.
// Asignamos valores a variables de instancia del objeto objAlumno01.
// Asignamos valores a variables de instancia del objeto objAlumno02.
// y a las variables de instancia del objeto objAlumno03.
// Calculamos el promedio de notas del objeto objAlumno01.

prom = ( objAlumno01.nota1 + objAlumno01.nota2 + objAlumno01.nota3 ) / 3 ;
// También calculamos el promedio de notas del objeto objAlumno02.

// Finalmente, calculamos el promedio de notas del objeto objAlumno03.

}
}
Al ejecutar el proyecto se obtiene el siguiente resultado. Recordar que al ejecutar un proyecto, se está
ejecutando el método main():

Se puede comprobar que cada objeto de la clase PrgAlumno tiene una copia de los atributos de
instancia nota1, nota2 y nota3, y que los valores de un objeto son independientes de los otros valores
que tienen los otros objetos.
Finalmente, es importante especificar que solo se definirán como atributos a los datos de entrada.
A pesar de que podemos definir cualquier dato como atributo (datos de salida o calculados), solo se
definirán como una buena práctica de programación los datos de entrada como atributos. Por tanto,
esto contribuirá de manera significativa a entender correctamente el uso de atributos y métodos en las
soluciones. Los métodos serán tratados a continuación.
6.1.4 MÉTODO
Hasta este punto se ha definido la clase PrgAlumno con tres atributos de instancia y el método
main(). Ahora, es necesario conocer aspectos básicos sobre los diferentes tipos de métodos para
poder definirlos en la clase PrgAlumno.
Un método representa un pequeño subprograma encapsulado dentro de una clase y contribuye a
definir el comportamiento típico de los objetos, y especifican la forma en que se controlan los datos
(almacenados en atributos) de un objeto.
Los métodos se clasifican en dos categorías:
A. Métodos de Instancia: Son conocidos también como métodos de objetos que pueden ser llamados
(ejecutados) a través de un objeto. Este método se ejecuta utilizando el siguiente formato:
nombreObjeto.nombreMétodoInstancia ( ) ;
B. Métodos de Clase: Son llamados a través de un objeto o utilizando directamente la clase. Para
ejecutar un método de clase, generalmente se utiliza el siguiente formato:
NombreClase.nombreMétodoClase ( ) ;
En resumen:
Para ejecutar un método de instancia se requiere crear primero un objeto de la clase donde está
definido el método.
Para ejecutar un método de clase no se requiere crear un objeto porque se puede hacer
directamente utilizando el nombre de la clase, donde está definido el método. Para declarar un
método de clase se utiliza la palabra reservada staƟc.
A través de los métodos de clase, se puede manipular solo atributos de clase. Mientras que a
través de los métodos de instancia, se puede manipular atributos de clase y de instancia.
La forma mínima de un método es la siguiente;
tipo nombreMétodo ( listaDeParámetros ) {

// Cuerpo del método ;
]
Donde:
}|Ɵpo: Especifica el tipo de dato devuelto por el método. Puede ser cualquier tipo válido, incluido los
tipos de clase. Si el método no devuelve ningún valor, el tipo devuelto debe ser void. Los métodos
que devuelven un tipo distinto de void, devuelven un valor a la sentencia que ejecuta el método
utilizando la siguiente forma de la sentencia return:
return valor ;
Aquí valor es el dato que el método devuelve a la sentencia que lo ejecutó. Generalmente, la
sentencia return se coloca al final del cuerpo del método.
}|nombreMétodo: Especifica el nombre del método, que puede ser cualquier identificador válido
diferente de los que se están utilizando en el mismo ámbito.
}|listaDeParámetros: Es una secuencia de parejas de tipo e identificador separado por comas. Los
parámetros son variables que reciben el valor de los argumentos que se pasan al método cuando
este es ejecutado. Si el método no tiene parámetros, entonces la lista de parámetros estará vacía.
Los métodos de instancia y los métodos de clase pueden ser de cuatro tipos.
La idea fundamental de los métodos es que no se codifique la misma parte más de una vez en
una determinada solución. Conforme se modifique el proyecto de solución ProyAlumno, podrá
comprenderse mejor.
Tipos de métodos de instancia y clase
}|Método que no devuelven valor y no reciben parámetros

Ahora, se definirá un método dentro de la clase PrgAlumno. El método se llamará promedio( ) y
permitirá calcular y mostrar el promedio de notas de un alumno. Aunque anteriormente esto se
había realizado en el método main() de la clase PrgAlumno, es perfectamente válido haber pensado
que esto había que hacerlo en otro método.
class PrgAlumno {
void promedio ( ) {
System.out.print ( “ El promedio final del alumno es: ” ) ;
System.out.println ( (nota1 + nota2 + nota3 ) / 3 ) ;
}
double prom ;

// Ahora asignamos valores a las variables de instancia del objeto objAlumno01.

// También asignamos valores a las variables de instancia del objeto objAlumno02.


// Calculamos el promedio de notas para cada alumno.

objAlumno01.promedio ( ) ;
}
Al ejecutar el proyecto se obtiene el siguiente resultado, el cual es igual al resultado anterior:

Las tres líneas siguientes, ubicadas dentro del método main( ) de la clase PrgAlumno, permiten
ejecutar el método promedio( ) definido en la clase Alumno:
objAlumno01.promedio( ) ;
Al igual que para acceder a las variables de instancia, para acceder a los métodos se utiliza el operador
punto (.), el cual relaciona el nombre del objeto con el nombre de un método.
Analicemos la siguiente sentencia:
Esta sentencia es parte del método main( ) de la clase PrgAlumno y permite que se ejecute el método
promedio( ) del objeto objAlumno01 definido en la clase Alumno; es decir, se ejecuta el método
promedio( ) utilizando el nombre de un objeto de la clase Alumno seguido por el operador punto. Así,
cuando se ejecuta:
}|objAlumno01.promedio ( ) ; Se calcula y visualiza el promedio de notas del objeto objAlumno01

en base a los valores de su copia de los atributos de instancia ( nota1 = 15, nota2 = 19 y nota3
= 11 ).

= 11 ).

= 15 ).
Ahora, se analizará la definición del método promedio() de la clase Alumno;
void promedio ( ) {
}
El método promedio() no devuelve ningún valor porque tiene definido como tipo de retorno void.
Todos los métodos definidos con void no devuelven valor, por lo que no es necesario especificar una
sentencia return al final de este método. El método promedio(), tampoco tiene parámetros ya que al
final del nombre del método los paréntesis se encuentran vacíos.
No devuelve No tiene
valor. parámetros.
void promedio ( ) {
}
La llave de apertura “{”, ubicada después del paréntesis y la llave de cierre “}” ubicada en la última línea
definen el ámbito del método promedio(). El ámbito de un método define todas las sentencias que se
ejecutarán cuando el método se ejecute. En el caso anterior, cuando se ejecute el método promedio()
se ejecutarán las dos sentencia que están dentro de su ámbito (es decir, entre las llaves).
En el ámbito del método promedio() se puede observar que las variables de instancia nota1, nota2
y nota3 se utilizan directamente sin estar precedidas del nombre del objeto y el operador punto (.).
Cuando un método utiliza una variable de instancia que ha sido definida en su misma clase, se puede
referir a ella en forma directa utilizando solo su nombre.
}|Métodos que devuelven valor y no reciben parámetros

Aunque en el método promedio() se realiza el cálculo y visualización del promedio de notas, esto
no constituye la mejor forma o alternativa de desarrollar dicho método. Esto se debe a que en
muchos casos, otras partes del método main() u otros métodos necesitarán que se ejecute el método
promedio() para que se realice el cálculo del promedio de notas, pero no todos necesitarán que una
vez calculado el promedio de notas, este se visualice. Con la finalidad de mejorar la implementación
del método promedio(), se puede realizar solo el cálculo del promedio de notas y devolver dicho valor
para que este pueda ser utilizado de diferentes formas.
A continuación, se modificará el proyecto de solución ProyAlumno con la finalidad de mejorar la

implementación del método promedio( ):
class PrgAlumno {
double promedio ( ) {
return ( nota1 + nota2 + nota3 ) / 3 ;
}
double prom ;
// Ahora asignamos valores a las variables de instancia del objeto
objAlumno01.
//Asignamos valores a las variables de instancia del objeto objAlumno02
// Calculamos el promedio de notas para cada alumno.
prom = objAlumno01.promedio ( ) ;
System.out.println ( “ Nota final de Luis: ” + prom ) ;
prom = prom + 1 ;
System.out.println ( “ Nota final de María: ” + prom ) ;
System.out.println (“Nota final de Pedro:” + objAlumno03.promedio( ));
}
}
Para ejecutar un método que devuelve un valor se utiliza de igual forma el nombre del objeto, el
operador punto (.) y el nombre del método. El valor devuelto por el método deberá ser asignado a una
variable del mismo tipo.
En el ejemplo tenemos la siguiente sentencia:
Esta sentencia es parte del método main() de la clase PrgAlumno y permite que se ejecute el método
promedio() del objeto objAlumno01. Como el método promedio() devuelve un valor, este se almacena
en la variable prom. Observe que la variable prom es del mismo tipo que el valor devuelto por el
método promedio().
Sentencia definida en el método main() de la Método definido en la clase PrgAlumno.

clase PrgAlumno.
return (nota1 + nota2 + nota3)/3;
1
Ejecuta
2
Se calcula y devuelve
el promedio de notas
3
El valor se asigna
a la variable prom
Una vez que se almacena en prom, el valor devuelto por el método promedio(), se puede procesar
dicho valor según sea necesario. Por ejemplo, en el primer caso se muestra el valor de prom y en el
segundo caso, antes de mostrar el valor de prom se le suma 1.
Primer caso:
Se obtiene el promedio de notas y se

muestra el resultado:
System.out.println ( “ La nota final de Luis es ” + prom + “.” ) ;
Segundo caso:
Se obtiene el promedio de notas, se

aumenta 1 y se muestra el resultado:
prom = prom + 1 ;
System.out.println ( “ La nota final de María es ” + prom + “.” ) ;
Es preciso mencionar que se puede escribir estas sentencias de una manera más eficiente. Observe la
System.out.println ( “ Nota final de Pedro: ” + objAlumno03.promedio ( ) ) ;
Aquí no se hace uso de la variable prom. La ejecución del método promedio() se realiza directamente
en la sentencia System.out.println(). Es decir, al ejecutar System.out.println() se ejecuta a su vez el
método promedio() y el valor devuelto se muestra a través de la pantalla.
Existen dos puntos importantes relacionados con los métodos que devuelven valor:
1. El tipo de dato que un método devuelve (con la sentencia return), debe ser compatible con el tipo
de dato especificado por el método.
Especifica que se debe

devolver un valor No tiene
double. parámetros.
return (nota1 + nota2 + nota3 ) / 3 ;
}
2. La variable que recibe el valor devuelto por el método debe también ser compatible con el tipo de
dato especificado por el método.
Declarada como double. Lo cual

es compatible con el tipo de dato
especificado por el método.
}|Métodos que no devuelven valor y reciben parámetros
Ahora, se definirán dos métodos dentro en la clase PrgAlumno. Los métodos se llamarán setNotas()
y mostrarPromedio(). El método setNotas() permitirá asignar valores a las variables de instancia
nota1, nota2 y nota3. Esto debido, fundamentalmente, a que en soluciones Java bien diseñadas, las
variables de instancia deberían ser accesibles solo a través de los métodos definidos por sus clases
y no en forma directa. El método mostrarPromedio() permitirá mostrar el promedio de notas de un
alumno.
El método setNotas() recibirá, a través de sus parámetros, las notas de un alumno y las asignará
a los atributos de instancia correspondientes. Los parámetros permiten generalizar el uso de un
método, permitiendo trabajar con diversos datos y utilizarlos en diferentes situaciones. El método
mostrarPromedio() recibirá, a través de su parámetro, el promedio del alumno y lo mostrará en
pantalla.
A continuación, se modificará el proyecto de solución ProyAlumno, de tal forma que se defina

solo el objeto objAlumno01 de la clase PrgAlumno en el método main(); esto con la finalidad de
implementar nuevos conceptos en un proyecto de solución sencillo y pequeño.
class PrgAlumno {
void setNotas ( double a, double b, double c ) {

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
}
void mostrarPromedio ( double prom) {

System.out.println ( “ Nota final es: ” + prom ) ;
}
objAlumno01.setNotas ( 15,19,11 ) ;
double prom = objAlumno01.promedio ( ) ;
objAlumno01.mostrarPromedio ( ) ;
Para ejecutar un método que tiene parámetros se utiliza el nombre del objeto, el operador punto (.),
el nombre del método a ejecutar y los argumentos necesarios.
En el ejemplo anterior tenemos:
Esta sentencia es parte del método main() de la clase PrgAlumno(), y permite ejecutar el método
setNotas() del objeto objAlumno01 definido en su clase. Como el método setNotas() tiene definido
tres parámetros, es necesario que al momento de ejecutar el método se incluya entre los paréntesis
los tres argumentos que se enviarán al método.
Sentencia definida en el método main() de la Método definido en la clase PrgAlumno.

clase PrgAlumno.
a = 15
objAlumno.setNotas (15,19,11 ) ;
void setNotas ( double a,double b,

1 double c) {
Ejecuta nota1 = a ;
nota2 = b ;
nota3 = c ;
}
3 ARGUMENTOS 3 PARÁMETROS
Un argumento es un valor que se envía a un Un parámetro es una variable definida por

método cuando este es ejecutado. un método, que recibe un valor cuando se
ejecuta dicho método.
Existen dos puntos importantes relacionados con los métodos que tienen parámetros.
1. Un método que tiene parámetros debe recibir un valor por cada parámetro definido. El valor
recibido debe ser compatible con el tipo de dato definido por el parámetro al cual será asignado.
No devuelve valor. Especifica que se tienen definidos tres

parámetros de tipo double.
nota1 = a ;
nota2 = b ;
nota3 = c ;
}
2. Cuando se ejecuta un método que tiene parámetros, se debe pasar al método un valor por
cada parámetro definido (es decir, se deben pasar los argumentos). Cada argumento deberá ser
compatible con el tipo de dato definido por el parámetro al cual será asignado.
Especifica que se envían 3 valores

(argumentos) de tipo double al método
setNotas().
objAlumno.setNotas(15,19,11) ;
En conclusión, se puede afirmar lo siguiente:
1. Un método puede no devolver valor y no tener definido parámetros.
No devuelve valor. No tiene parámetros.
void promedio ( ) {
}
2. Un método puede no devolver un valor y tener definido uno o más parámetros.
Especifica que se tiene definido 3

No devuelve valor. parámetros de tipo double.

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
3. Un método puede devolver un valor y no tener definido parámetros.
Especifica que se debe

devolver un valor double. No tiene parámetros.
return (nota1 + nota2 + nota3 ) / 3 ;
}
4. Un método puede devolver un valor y tener definido uno o más parámetros. (Este tipo de métodos
todavía no han sido tratados).
C. Método constructor: En Java, la inicialización de objetos no se puede realizar en el momento en

que estos son definidos. Por ello, se tiene la característica de disponer del método constructor, que
permite inicializar objetos inmediatamente después de que se crean.
Un constructor es un método especial que sirve para construir o inicializar objetos. Cada vez que se
crea un objeto, se ejecuta en forma automática dicho método que permite que se inicialice la copia
de los atributos de instancia de los objetos, inmediatamente después de su creación. Este método
tiene el mismo nombre que la clase en la cual está definido. Además; puede tener parámetros al
igual que otros métodos, pero no devuelven ningún valor ni siquiera void.
A continuación, se modificará el proyecto de solución ProyAlumno y se incluirá un método

constructor en la clase PrgAlumno que permita inicializar la copia de los atributos de instancia
nota1, nota2 y nota3 para el objeto objAlumno01:
class PrgAlumno {
PrgAlumno ( ) {
nota1 = nota2 = nota3 =0 ;
}

nota1 = a ;
nota2 = b ;
nota3 = c ;
}
}
void mostrarPromedio ( double prom) {

System.out.println ( “ Nota final es: ” + prom ) ;
}

objAlumno01.mostrarPromedio ( ) ;
}
}
Cuando se ejecuta la siguiente sentencia:
PrgAlumno objAlumno01 = new PrgAlumno() ;

Se declara y crea el objeto objAlumno01 de la clase PrgAlumno. Después de que se crea el objeto
objAlumno01 se ejecuta en forma automática al método constructor PrgAlumno(). El método
constructor PrgAlumno() permite inicializar la copia de los atributos de instancia nota1, nota2 y nota3
del objeto objAlumno01 con el valor cero.
El método constructor puede tener definidos parámetros. En ese caso, podemos enviar al método
constructor PrgAlumno() los valores de la copia de los atributos de instancia nota1, nota2 y nota3 del
objeto creado y eliminar el método setNotas(). También podemos reemplazar el método setNotas()
por un método que permita ingresar las notas y almacenarlas en la copia de los atributos de instancia
nota1, nota2 y nota3 del objeto de la clase PrgAlumno.
Con la finalidad de hacer soluciones simples utilizando métodos, se reemplaza el método setNotas()
por un método que permita el ingreso de las notas desde el teclado. El uso del método setNotas() será
retomado nuevamente en el capítulo nueve, del presente texto.
Ingreso de datos a través del teclado
Ahora, se modificará el proyecto de solución ProyAlumno, de tal forma que los datos sean ingresados
a través del teclado de la computadora. Para ello, se definirá el método ingresarNotas(), el cual tendrá
la finalidad de ingresar las notas utilizando la clase LE. Observar la definición de la clase PrgAlumno.
class PrgAlumno {
PrgAlumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
void ingresarNotas ( ) {
nota1 = LE.leerInt ( “ Ingrese la nota de prácticas del alumno ” ) ;
nota2 = LE.leerInt ( “ Ingrese la nota del examen parcial: ” ) ;
nota3 = LE.leerInt ( “ Ingrese la nota de examen final: ” ) ;
}
}
void mostrarPpromedio ( double prom ) {

LE.mostrarInformacion ( “ Nota final de Luis: ” + prom ) ;
}
objAlumno01.ingresarNotas ( ) ;
objAlumno01.mostrarPromedio (prom) ;
}
}
package biblioteca ;
public class LE {
// Cuerpo de la clase LE definida en capítulos anteriores.

}
El proyecto de solución ProyAlumno tiene dos paquetes. Un paquete denominado biblioteca que
contiene a la clase LE y un paquete denominado dominioDeLaAplicacion que contiene la clase
PrgAlumno.
Cada clase tiene funciones específicas que se detallan a continuación.
}|Clase PrgAlumno (clase control):
Tiene el método main() que permite que el proyecto se ejecute. Dentro del método main() se crea
al objeto objAlumno01 de la clase PrgAlumno y se ejecutan los otros métodos.
También, define los atributos de instancia para almacenar las notas y los métodos que permiten
manipular dichos atributos de instancia; es decir, el método para ingresar las notas, el método para
realizar el cálculo del promedio y el método para mostrar el promedio.
}|Clase Lectura (clase utilidad):
Define métodos que facilitan el ingreso de datos con cuadros de diálogo, utilizando el teclado.
Finalmente, se ha realizado una solución que permita el ingreso de datos, el proceso y salida de la
información utilizando atributos y métodos.
6.2 MÉTODO DE LAS 6’D: REDEFINICIÓN DE PASOS

El proyecto de solución ProyAlumno se ha modificado poco a poco con la finalidad de tratar nuevos
conceptos relacionados a la POO utilizando Java. Con la última solución desarrollada para el proyecto
ProyAlumno, se pretende dar un paso importante para acercarnos al desarrollo de soluciones
orientadas a objetos.
Es un buen momento para ajustar los pasos definidos en las etapas del método de las 6’D, y poder
desarrollar un proyecto que permita al lector familiarizarse con este tipo de soluciones.
6.2.1 Ajuste de los pasos definidos para las etapas del método
En la solución del problema anterior, se utilizaron dos paquetes. Los mayores cambios los
desarrollamos en la clase del paquete dominioDeLaAplicacion. En dicha clase se definirá el método
main(), en el cual se crearán objetos y se definirán los atributos de instancia, los métodos de instancia
y el método constructor válido para los objetos.
En base a esto, el Método de las 6’D se definirá según se muestra a continuación:
ENUNCIADO
DEL
PROBLEMA
}|Definición del }|Diseño del diagrama }|Codificar el diseño
proyecto de de paquetes de la solución del
solución. respectivo. Establecer problema utilizando
}|Definición del la dependencia el lenguaje de
algoritmo. (Utilice UML). programación Java.
}|Definición del }|Definición de la clase
paquete Aplicación. que serán parte
||Definición de clase del paquete de
con sus atributos y aplicación (Utilice
métodos. UML).
}|Diseño del diagrama
}|Definición del
de secuencia
paquete biblioteca. respectivo (Utilice
||Uso de la clase LE
UML).
con sus métodos
definidos.
ALGORITMO
}|Diseño del algoritmo
para los método
definidos. Utilizar
pseudocódigo.
Problema 151
Enunciado: Calcular el promedio final de un alumno. Utilice la siguiente fórmula:
prom = (nota1+ nota2+nota3) / 3.
Ingrese las notas; nota1, nota2 y nota3 a través del teclado. Luego, utilice atributos y métodos de
instancia.
1. Definición del proyecto de solución

Para solucionar el problema se creará un proyecto denominado ProyAlumno, dentro del cual se
definirá el paquete dominioDeLaAplicacion y se incluirá el paquete biblioteca (con la clase LE para
el ingreso de datos).
2. Definición del algoritmo

B. Datos necesarios: Las notas del alumno (en esta caso son tres).
C. Procesamiento: Las tres notas serán ingresadas a través del teclado y almacenadas en las
variables nota, nota2 y nota3. Luego, se realizará el cálculo de la nota final
sobre la base de la siguiente fórmula:
prom = ( nota1 + nota2 + nota3 ) / 3.
El resultado se almacenará en una variable (prom), para luego ser mostrada por pantalla.
3. Definición del paquete Aplicación

En el paquete dominioDeLaAplicacion definiremos una clase. La función de la clase será solucionar
el problema. Se desarrollará el ingreso de datos, el almacenamiento, el procesamiento y se mostrará
la información solicitada. Para esto, se utilizarán atributos, métodos y los mismos nombres para
referirnos a variables locales y a los atributos de instancia. Su definición será la siguiente:
A. Clase: PrgAlumno
B. Atributos: Como atributos de instancia definiremos las variables de entrada nota1, nota2 y nota3.
C. Métodos: Necesitamos los siguientes métodos:
a. Método main() para iniciar la ejecución del proyecto, crear el objeto objAlumno01 y ejecutar los
diferentes métodos.
b. Método constructor para inicializar los atributos de instancia (método PrgAlumno()).
c. Método para ingresar las notas ( método ingresartNotas() ).
d. Método para calcular el promedio de las notas (método promedio(), devuelve el valor del cálculo
del promedio de las notas).
e. Método para mostrar el promedio de notas del alumno (método mostrarPromedio(), recibe el
valor del promedio de las notas).
4. Definición del paquete biblioteca

En el paquete biblioteca se tendrá la clase LE para poder utilizar sus métodos que permitirá el ingreso
de datos y la visualización de la información.
1. Diseño del diagrama de paquetes
Clase de dominioDeLaAplicacion Clase de biblioteca
PrgAlumno LE
(from biblioteca)
nota1 : double
nota2 : double ||leerString ()
nota3 : double
||leerChar ()
||PrgAlumno () ||leerInt ()
||ingresarNotas ( ) : void ||leerLong ()
||promedio ( ) : double ||leerFloat ()
||mostrarPromedio (prom : double) : void ||leerDouble ()
||main ( args : String[ ] ) : void ||mostrarResultado ()
||mostrarError ()
…
3. Diseño del diagrama de secuencia
Diagrama de secuencia
objAlumno01: PrgAlumno
: usuario
1:main(String )
2: PrgAlumno( )
3: ingresarNotas( )
4:promedio()
5 mostrarPromedio(double)
4. Diseño del algoritmo para la clase PrgAlumno
Algoritmo PrgAlumno
ATRIBUTOS
NUMERO nota1, nota2, nota3
METODO CONSTRUCTOR PrgAlumno
PARAMETRO:
INICIO
nota1 = 0
nota2 = 0
nota3 = 0
FIN
METODO ingresarNotas
PARAMETRO:
RETORNO:
INICIO
LEER nota1, nota2, nota3
FIN
METODO promedio
PARAMETRO:
RETORNO: prom
INICIO
NUMERO prom
prom = ( nota1 + nota2 +nota3 ) / 3
RETORNAR prom
FIN
METODO mostrarPromedio
PARAMETRO: prom
RETORNO:
INICIO
ESCRIBIR prom
FIN
METODO PRINCIPAL
ENTRADA: n1, n2, n3

SALIDA: prom
INICIO
NUMERO prom
CREAR OBJETO objAlumno01 CLASE PrgAlumno EJECUTAR PrgAlumno
EJECUTAR objAlumno01.ingresarNotas
prom = EJECUTAR objAlumno01.promedio
EJECUTAR objAlumno01mostrar.Promedio (prom )
FIN
Observe que en esta Etapa 03 – Diseño de la lógica, se han utilizado nuevas reglas de pseudocódigo,
las cuales describimos a continuación:
1. Crear objeto
Se utiliza para indicar la creación de un determinado objeto. El formato completo se muestra con el
siguiente ejemplo:
CREAR OBJETO objAlumno01 CLASE PrgAlumno EJECUTA PrgAlumno ( )
A través de esta instrucción, se crea un objeto denominado objAlumno01 de la clase PrgAlumno y

se ejecuta el método constructor especificado.
2. Ejecutar
Se utiliza para ejecutar un método. Se debe tener en cuenta que si el método es de clase, se deberá
anteponer el operador punto (.) y el nombre de la clase antes de colocar el nombre del método
que se desea ejecutar. Si el método es de instancia, se deberá anteponer el operador punto (.) y el
nombre del objeto antes de colocar el nombre del método que se desea ejecutar.
EJECUTAR objAlumno01.mostrarPromedio ( prom)
Se ejecuta el método mostrarPromedio() del objeto objAlumno01 y se le envía el valor a la variable

prom.
prom = EJECUTAR objAlumno01.promedio ( )
Se ejecuta el método promedio del objeto objAlumno01. El método promedio devuelve un resultado
que se almacena en la variable prom.
3. Parámetro
Se utiliza para especificar las variables que se usan para recibir los valores enviados a un determinado
método.
PARAMETRO: prom
La variable prom se utiliza para recibir los valores que se envían al método que pertenece la
instrucción.
4. Retorno
Se utiliza para especificar la variable que se usa para devolver o retornar una respuesta de un
determinado método.
RETORNO:prom
El valor almacenado en la variable prom será devuelto como respuesta cuando se ejecuta el método
al cual pertenece la instrucción.
5. Atributo
Se utiliza para diferenciar un atributo de una variable local, cuando tienen el mismo nombre y se
utilizan en un mismo método.
ATRIBUTO.nota1 = nota1
Para referirnos al atributo nota1 se utiliza la regla ATRIBUTO, la cual antecede al operador punto (.)
y al nombre del atributo, tal como se muestra en el ejemplo anterior.
Clase PrgAlumno
class PrgAlumno {
PrgAlumno ( ) {
nota1 = 0 ;
nota2 = 0 ;
nota3 = 0 ;
}
void ingresarNotas ( ) {
nota1 = LE.leerInt ( “ Ingrese la nota de prácticas del alumno ” );
nota2 = LE.leerInt ( “ Ingrese la nota del examen parcial ” ) ;
nota3 = LE.leerInt ( “ Ingrese la nota de examen final ” ) ;
}
}
void mostrarPromedio ( double prom ) {

LE.mostrarInformacion ( “ Nota final de Luis: ” + prom ) ;
}
objAlumno01.ingresarNotas ( ) ;
objAlumno01.mostrarPromedio (prom) ;
}
}
PUNTO A PARTE
6.3 SOFTWARE PARA GENERAR EJECUTABLES EN MS-WINDOWS BASADO EN APLICACIONES JAVA

Un archivo ejecutable o EXE (EXEcutable) es un programa que puede ejecutarse en un sistema
operativo como MS-DOS o MS-Windows, es decir, es un archivo cuyo contenido se interpreta por el
ordenador como un programa.
Generalmente, contiene instrucciones en código-máquina de un procesador en concreto, pero también

puede contener bytecode, que requiera un intérprete para ejecutarlo. Generalmente contiene llamadas
a funciones específicas de un sistema operativo (llamadas al sistema).
6.3.1 Uso de software
En la actualidad existen diversos software que permiten generar un archivo ejecutable para la
plataforma MS-Windows. Algunos ejemplos de este tipo de software son:
JSmooth (gratuito)
h p://jsmooth.sourceforge.net/
Launch4j (gratuito)
h p://launch4j.sourceforge.net/
NaƟveJ
h p://nativej.softonic.com/ie/57844
Estos software permiten generar un archivo ejecutable para MS-Windows desde un archivo JAR. Los
archivos ejecutables facilitan la distribución de las aplicaciones Java, puesto que dichos archivos se
encargan de buscar la JVM (Java Virtual Machine) o en su defecto el JRE (Java RunƟme Environment),
que incluya los archivos necesarios para la ejecución de las aplicaciones Java. También puede incluir
en su capeta el JRE lo que facilitaría la grabación de todo su proyecto en un CD y pueda ejecutarlo en
otra computadora con MS-Windows sin ningún problema.
Es importante mencionar que la ventaja de generar un archivo ejecutable sobre un JAR es la

velocidad de ejecución. Un archivo EXE se ejecuta con mayor rapidez que un archivo JAR, pero la
desventaja es que al generar un EXE para una determinada plataforma se pierde la característica de
multiplataforma de las aplicaciones Java.
A continuación vamos a generar un archivo ejecutable EXE para la plataforma MS-Windows desde
un archivo JAR utilizando el JSmooth.
Paso 1: Obtener el software en h p://jsmooth.sourceforge.net/.

Paso 2: Instalar el software obtenido en su computadora. Con este punto no tendrá problemas, porque
el programa de instalación lo guía paso a paso.
Paso 3: En la carpeta donde está ubicada nuestra aplicación Java copiamos el JRE del JDK. Si no se tiene
el JRE, puede obtenerlo en la página Web de Sun (java.sun.com). Para nuestro ejemplo tendríamos la
carpeta del proyecto ProyNotaFinal2, en la cual hemos generado el JAR de la aplicación Java y se ha
copiado el JRE.
Paso 4: Ejecutamos el JSmooth y configuramos cada una de las opciones para generar nuestro archivo
ejecutable para MS-Windows. Incluso puede asociarle un icono.
Paso 4.1 Seleccionar el esqueleto.
Paso 4.2 Configurar el ejecutable.
Paso 4.3 Configurar la aplicación Java.
Paso 4.4 Seleccionar la ubicación de la JVM.
Paso 4.5 Configurar la JVM (solo si es necesario).
Finalmente, luego de configurar adecuadamente las cinco opciones, podrá generar su archivo
ejecutable para MS-Windows.
Internet puede encontrar excelentes manuales para configurar cada una de las opciones del JSmooth. Además,
cuando instale el producto, encontrará un buen manual de usuario.
Puede utilizar cualquier buscador de Internet para ampliar sus conocimientos sobre estos y otros
software, sólo tendrá que colocar el nombre del software y podrá observar varios links que le permitirán
inclusive bajar dicho software a su PC.
6.4 INTRODUCCIÓN A LAS SOLUCIONES UTILIZANDO INTERFAZ GRÁFICA DE USUARIO (GUI)
6.4.1 Introducción
La Interfaz del Usuario es la parte del programa o aplicación que permite a esta interactuar con el
usuario. Puede adoptar muchas formas, como utilizar de manera sencilla la consola hasta sofisticadas
Interfaces Gráficas de Usuario.
La programación visual nos permite desarrollar programas amigables, teniendo la ventaja de poder
utilizar todos los componentes y características de una Interfaz Gráfica de Usuario (GUI).
6.4.2 Definición
La Interfaz Gráfica de Usuario o GUI (por sus siglas en ingles Graphical User Interface) es un conjunto
de elementos gráficos tales como ventanas, botones, menús, cajas de texto, listas desplegables,
entre otros, que permiten la interacción entre el usuario y un programa de computadora.
La GUI puede ser una de las partes más importantes de un programa de computadora de tipo
comercial. Independientemente de lo rápido, eficiente o poderoso que sea un programa de
computadora, si no tiene una interfaz gráfica de usuario que sea sencilla de utilizar y estimule
visualmente, entonces no tiene ninguna base. Simplemente no sobrevivirá en el mercado.
La siguiente figura muestra un ejemplo de un GUI:
6.4.3 Etapas para el desarrollo de GUI
Es importante comprender que el desarrollo de una GUI se realiza en dos etapas:
A. Diseño de la GUI: Consiste en crear una interfaz y colocar sobre ella los elementos gráficos
necesarios, dispuestos en un determinado orden, de tal forma que se cumpla con los requerimientos
mínimos de entrada y salida de datos. Se utilizan clases de tipo contenedores, componentes y
administradores de diseño.
B. Programación de la GUI: Consiste en la programación de los eventos de la GUI y en asociar los
métodos desarrollados con los elementos gráficos colocados en la interfaz al momento de diseñar
la GUI. Se utilizan clases de tipo manejadores de evento.
Ejemplo de un contenedor de tipo JApplet con cuatro componentes. Al hacer clic con el botón
izquierdo del mouse de la computadora sobre el botón “Bienvenida”, se espera que suceda algo.
Los lenguajes de programación orientados a objetos proporcionan las clases necesarias para el
desarrollo de sofisticadas GUI, las cuales están almacenadas en diferentes paquetes y organizadas a
través de una jerarquía de clase.
El lenguaje de programación Java incorpora diferentes clases, organizadas principalmente en dos

paquetes llamados java.awt y javax.swing, que facilitan el diseño de la GUI; y un paquete llamado
java.awt.event, que contiene clases que facilitan la programación de la GUI y están organizadas a
través de la jerarquía de clases Java.
En la actualidad, para diseñar GUI en Java existen herramientas de tercera generación llamadas SWT
(Standard Widget Toolkit) que mejoran las herramientas de primera y segunda generación de Sun
(AWT y Swing, respectivamente).
6.4.4 Contenedores y componentes de la GUI
Los contenedores más utilizados del paquete javax.swing de Java para el diseño de la GUI son:
C½ÝÝ T®ÖÊ DÝÙ®Ö®ÌÄ

Miniaplicación Un Applet es un contenedor
que se visualiza en una
página html.
Aplicación Un Frame es un contenedor

utilizado para el desarrollo
de aplicaciones. Se visualiza
como una ventana con todas
sus características.
Panel Un Panel es un contenedor
que se utiliza dentro de otro
contenedor, con la finalidad
de agrupar componentes.
Cuadro de diálogo Un Dialog es un contenedor
que nos permite mostrar
información o ingresar un
dato puntual.
Los componentes más utilizados del paquete javax.swing de Java para el diseño de la GUI son:
C½ÝÝ T®ÖÊ DÝÙ®Ö®ÌÄ
Permite ejecutar un conjunto de

Botón
instrucciones al hacer clic sobre él.
Permite seleccionar una o varias

Aplicación opciones de un conjunto de
opciones.
Permite mostrar un número
Lista desplegable determinado de opciones, de las
cuales podemos seleccionar una.
Etiqueta Permite mostrar un texto.
Permite mostrar datos en forma de

Lista
listado.
Permite seleccionar una sola opción

Botones de radio
entre un conjunto de estas.
Caja de texto de una línea Permite ingresar o mostrar datos.
Caja de texto de múltiples

Permite ingresar o mostrar datos.
líneas
6.4.5 Administradores de diseño de la GUI
Los Administradores de Diseño más utilizados del paquete java.awt de Java para el diseño de la GUI
son:
C½ÝÝ
BorderLayout BoxLayout
CardLayout FlowLayout
GridLayout GridBagLayout
6.4.6 Manejadores de evento de la GUI
Los Manejadores de Evento más utilizados del paquete java.awt.event de Java para el diseño de la
GUI son:
C½ÝÝ DÝÙ®Ö®ÌÄ
ActionListener WindowListener
ItemListener MouseListener
6.5 MÉTODO DE LAS 6´D – DESARROLLO DE SOLUCIONES CON GUI

soluciones, utilizando GUI.
ENUNCIADO
DEL
PROBLEMA

}|Determinar la }|Determinar el nombre }|Codificar el diseño
información deseada del proyecto. de la solución del
(salida). }|Definir los paquetes problema. Utilice
}|Determinar los datos y desarrollar el paquete javax.
de entrada (entrada). el diagrama de swing de Java para
}|Establecer como paquetes respectivo. el diseño de la
Establecer la GUI y el paquete
se solucionará el
dependencia. Utilice java.awt.event
problema (proceso).
UML. de Java para la
programación de la
GUI.
que serán parte
de la solución del
problema. Desarrolle
el diagrama de clases.
Establecer la herencia
y agregación. Utilice
UML.
}|Diseñe la Interfaz
Gráfica de Usuario
(GUI).
ALGORITMO
para el método
principal. Desarrolle
el diagrama de
actividades. Utilice
UML.
Problema 152
Enunciado: Ingrese el nombre de una persona y luego muéstrelo junto con un mensaje de bienvenida.
Desarrolle el modelamiento y la codificación en el lenguaje de programación Java. Utilice el paquete
javax.swing de Java para crear una GUI.
1. Nombre del proyecto: ProyBienvenida2

2. Definición de paquete y diagrama de paquete
event
(from awt)
swing
(from javax)
3. Definición de clase y diagrama de clases
JApplet
(from swing)
ActionListen
er
(from event)
actionPerformed
PrgBienvenida2
+txaResultado
+lblNombre
JLabel +btnBienvenida +txtNombre JTextArea
(from swing) (from swing)
JBu on JTextField
(from swing) (from swing)
4. Diseño de la Interfaz Gráfica de Usuario (GUI)

INICIO
Mensaje = “bienvenido”.
¿Cómo estás?
LEER nombre
ESCRIBIR nombre, mensaje
FIN
Este algoritmo diseñado en Diagrama de Actividades se ejecutará cuando el usuario presione el botón de
bienvenida en la GUI.
import java.awt.event.* ;
import javax.swing.* ;
public class PrgBienvenida2 extends JApplet implements ActionListener {
// Declaración de componentes de la interfaz gráfica de usuario

JLabel lblNombre ;
JTextField txtNombre ;
JButton btnBienvenida ;
JTextArea txaResultado ;
// DISEñO DE LA GUI.
public void init( ) {
getContentPane().setLayout( null ) ;
// Etiqueta lblNombre
lblNombre = new JLabel ( “Nombre” ) ;
lblNombre.setBounds ( 15, 15, 55, 25 ) ;
getContentPane().add ( lblNombre ) ;
// Caja de texto de una línea txtNombre

txtNombre = new JTextField ( 100 ) ;
txtNombre.setBounds ( 75, 15, 100, 25 ) ;
getContentPane().add ( txtNombre ) ;
// Botón de acción btnBienvenida

btnBienvenida = new JButton ( “Bienvenida” ) ;
btnBienvenida.setBounds ( 200, 15, 100, 25 ) ;
btnBienvenida.addActionListener ( this ) ;
getContentPane().add ( btnBienvenida ) ;
// Caja de texto de múltiples líneas txaResultado

txaResultado = new JTextArea( ) ;
txaResultado.setBounds ( 15, 60, 285, 25 ) ;
getContentPane().add ( txaResultado ) ;
}
// PROGRAMACIÓN DE LA GUI
public void actionPerformed ( ActionEvent e ) {
// Declaración de variables
String nombre, mensaje ;
// Ingreso de datos
mensaje = “bienvenido. ¿Cómo estás?” ;
nombre = txtNombre.getText( ) ;
// Mostrar información
txaResultado.setText ( nombre + “ ” + mensaje ) ;
txtNombre.setText ( “” ) ;
}
}
Resultado:
Se ingresa el nombre “Rodrigo” en la caja de texto y se presiona el botón de bienvenida.
Una vez que se presiona el botón de bienvenida, se ejecuta el método acƟonPerformed(). En dicho
método está programado el algoritmo que permite mostrar un mensaje de bienvenida.
Problema 153
Enunciado: Ingresar un número y determinar si el número ingresado es un número par o impar.

Desarrolle la GUI y la codificación en el lenguaje de programación Java. Utilice el paquete javax.
swing de Java para crear la GUI.
1. Nombre del proyecto: ProyNumero

2. Definición de paquete y diagrama de paquete
event
(from awt)
dominioDeLaAplicacion swing
(from javax)
swing
(from javax)
3. Definición de clase y diagrama de clases
JFrame
(from swing)
WindowListener
ActionListener
(from event)
(from event)
}|actionPerformed()
}|windowOpened()
}|windowClosing()
}|windowClosed()
PrgNumero }|windowIconified()
(from dominioDeLaAplicacion) }|windowDeiconified()
}|PrgNumero() }|windowActivated()
}|main() }|windowDeactivated()
+lblTitulo +txtNumero
+btnProcesar +txaResultado
+lblNumero
JLabel JTextField JBu on JTextArea

(from swing) (from swing) (from swing) (from swing)
4. Diseño de la Interfaz Gráfica de Usuario (GUI)
Diseñe el algoritmo en diagrama de tividades.

d acti id d

Clase PrgNumero
import java.awt.event.* ;
import javax.swing.* ;
import java.awt.* ;
public class PrgNumero extends JFrame implements ActionListener, WindowListener {
// Declaración de componentes de la interfaz gráfica de usuario

JLabel lblTitulo, lblNumero ;
JTextField txtNumero ;
JButton btnProcesar ;
JTextArea txaResultados ;
// DISEñO DE LA GUI
public PrgNumero ( ) {
getContentPane().setLayout ( null ) ;
// Etiqueta lblTitulo
lblTitulo = new JLabel ( “ Determine si un número es par o impar ” );
lblTitulo.setBounds( 15, 15, 350, 25 ) ;
lblTitulo.setForeground ( Color.RED ) ;
getContentPane().add ( lblTitulo ) ;
// Etiqueta lblNumero
lblNumero = new JLabel ( “Número” ) ;
lblNumero.setBounds ( 15, 50, 55, 25 ) ;
getContentPane().add ( lblNumero ) ;
// Caja de texto de una línea

txtNumero = new JTextField ( 100 ) ;

txtNumero.setBounds ( 65, 50, 100, 25) ;
getContentPane().add ( txtNumero ) ;
// Botón de acción
btnProcesar = new JButton ( “Procesar” ) ;
btnProcesar.setBounds ( 200, 50, 100, 25 ) ;
btnProcesar.addActionListener ( this ) ;
getContentPane().add ( btnProcesar );
// Caja de texto de múltiples líneas

txaResultados = new JTextArea( ) ;
txaResultados.setBounds ( 15, 90, 285, 150 ) ;
txaResultados.setBackground ( Color.CYAN ) ;
getContentPane().add ( txaResultados ) ;
// Contenedor de tipo ventana
this.addWindowListener ( this ) ;
this.setTitle ( “Número” ) ;
this.setSize( 320, 300 ) ;
this.setLocationRelativeTo ( null ) ;
this.setResizable ( false ) ;
this.setVisible ( true ) ;
// PROGRAMACIÓN DE LA GUI
public void actionPerformed ( ActionEvent e ) {
// Declarar variables
String sNumero, mensaje ;
int numero ;
// Ingreso de datos
sNumero = txtNumero.getText( ) ;
// Procesamiento
numero = Integer.parseInt ( sNumero ) ;
if ( numero % 2 == 0 ) {
mensaje = “ El número ingresado es par ” ;
} else {
mensaje = “ El número ingresado es impar ” ;
}
// Mostrar Información
txaResultados.setText ( mensaje + “\n” ) ;
txaResultados.append ( “...\nFin. ” ) ;
txtNumero.setText ( “” ) ;
txtNumero.requestFocus( ) ;
}
public void windowClosed( WindowEvent evt ) { }
public void windowIconified( WindowEvent evt ) { }
public void windowOpened( WindowEvent evt ) { }
public void windowClosing( WindowEvent evt ) {

System.exit(0) ;
}
public void windowDeiconified( WindowEvent evt ) { }
public void windowActivated( WindowEvent evt ) { }
public void windowDeactivated( WindowEvent evt ) { }
// EJECUCIÓN DE LA APLICACIÓN
public static void main(String[] args) {
PrgNumero ventana = new PrgNumero ( ) ;

}
}
Bibliograİa
Cay, H. y Cornell, G. (2012). Core Java Volume I—Fundamentals. 9th. ed. Core Series. United States:
Unabridged.
Deitel, H. y Deitel, P. (2010). Java How to Program. 8th. ed. United States: Prentice Hall.
Deitel, H. y Deitel, P. (2004). Cómo programar en Java. 5th. ed. México: Prentice Hall.
Deitel, H. y Deitel, P. (2003). Cómo programar en C++. 4th. ed. United States: Prentice Hall.
Drozek, A (2007). Estructura de Datos y Algoritmos en Java. 2th. ed. México: Thomson.
Flores, J. y Bertolotti, C. (2008). Método de la 6’D. Modelamiento – Algoritmo – Programación

(Enfoque orientado a las estructuras lógicas). 2da. ed. Lima: Facultad de Ingeniería y Arquitectura.
Universidad de San Martín de Porres.
Hoffman, B. (2013). C++ Programming for Beginners. United States: Kindle Edition - Elms College.
Schildt, H. (2014). Java: A Beginner's Guide. 6th. ed. United States: McGraw-Hill.
Schildt, H. (2011). Java: A Beginner's Guide. 5th. ed. United States: McGraw-Hill.
Stroustrup, B. (2013). The C++ Programming Language. 4th. ed. United States: Lay Flat.
Referencias electrónicas
}|Flores,
J. y Bertolotti, C. (2009). Diagrama de Clase, Perú. InfoFIA 67, USMP. Recuperado de:
h p://www.usmp.edu.pe/publicaciones/boletin/fia/info67/uml.html
}|Flores, J. y Bertolotti, C. (2009). Herramientas de software para gestionar sus aplicaciones Java.
Perú. InfoFIA 66, USMP. Recuperado de:
h p://www.usmp.edu.pe/publicaciones/boletin/fia/info66/herramientas.html
}|Flores, J. y Bertolotti, C. (2008). Empaquetar aplicaciones Java utilizando Java Archives (JAR).
InfoFIA, USMP Perú. (64). Recuperado en abril 2008 de: h p://www.usmp.edu.pe/publicaciones/
boletin/fia/info64/empaquetarJAR.html
Impreso en los talleres gráficos de
Surquillo
Apéndice
Clases creadas e
i n c o rp o r a d a s e n J ava
APÉNDICE - c lasEs crEadas E incorporadas En Java 635
ClasEs inCORPORadas En El lEngUajE java
Clase Lectura
package biblioteca;
import java.io.*;
/*
* Clase que permite capturar literales desde el teclado.
*
*/
public class Lectura {
/**
* Retorna el char capturado desde el teclado.
*/
public static char leerChar() {
char c = ' ';
char[] c1 = leerString().toCharArray();
if (c1.length == 1)
c = c1[0];
return c;
}
/**
* Retorna un literal double capturado desde el teclado.
*/
public static double leerDouble() {
try {
return Double.valueOf(leerString()).doubleValue();
} catch (NumberFormatException e) {
System.out.print("ERROR...\n Ingrese de nuevo: ");
return leerDouble();
}
}
/**
* Retorna un literal float capturado desde el teclado.
*/
public static float leerFloat() {
try {
return Float.valueOf(leerString()).floatValue();
return leerFloat();
}
}
/**
* Retorna un literal int capturado desde el teclado.
*/
public static int leerInt() {
try {
return Integer.parseInt(leerString());
return leerInt();
}
}
/**
* Retorna un literal long capturado desde el teclado.
*/
public static long leerLong() {
try {
return Long.valueOf(leerString()).longValue();
return leerLong();
}
}
/**
* Retorna un literal short capturado desde el teclado.
*/
public static short leerShort() {
try {
return Short.valueOf(leerString()).shortValue();
return leerShort();
}
}
/**
* Retorna una cadena capturada desde el teclado.
*/
public static String leerString() {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String cadena = "";
try {
cadena = in.readLine();
} catch (IOException e) {
System.out.println(e);
}
return cadena;
}
}
Clase LE (versión 2.2)
package biblioteca;
import java.awt.*;
import javax.swing.*;
/**
* La clase <code>LE</code> facilita la Lectura y Escritura de datos a través
* de cuadros de diálogos.
*
* @author Ing. Juan José Flores Cueto

* @version 2.2
* @Date Octubre 2006
* @version 2.1
* @Date Agosto 2006
*
* @author Ing. Jessica Paulino Torre
* @author Ing. Gissela Guzman Mariluz
* @version 1.0
* @Date Enero 2004
*
* Clase LE utilizada con fines académicos.
*
*/
public class LE {
/**
* Muestra un cuadro de diálogo solicitando el ingreso de un caracter.
*
* @param mensaje
* especifica la solicitud del caracter a ingresar.
*/
public static char leerChar(String mensaje) {
String cadena;
do {
cadena = JOptionPane.showInputDialog(mensaje);
if (cadena == null)
mostrarError("Error... no se ha ingresado valor");
if (cadena.length() > 1)
mostrarError("Error... debe ingresar sólo un caracter");
} while (cadena == null || cadena.length() > 1);
char c = cadena.charAt(0);
return c;
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de un valor real
* double.
*
* @param mensaje
* especifica la solicitud del valor a ingresar.
*
*/
public static double leerDouble(String mensaje) {
String cadena = leerString(mensaje);
try {
return Double.parseDouble(cadena);
mostrarError("Error... debe ingresar un número ");
return leerDouble(mensaje);
}
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de un valor real
* float.
*
* @param mensaje

*/
public static float leerFloat(String mensaje) {
try {
return Float.parseFloat(cadena);
return leerFloat(mensaje);
}
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de un valor entero
* int.
*
* @param mensaje
*/
public static int leerInt(String mensaje) {
try {
return Integer.parseInt(cadena);
return leerInt(mensaje);
}
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de un valor entero
* long.
*
* @param mensaje
*/
public static long leerLong(String mensaje) {
try {
return Long.parseLong(cadena);
return leerLong(mensaje);
}
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de una cadena.
*
* @param mensaje
* especifica la solicitud de la cadena a ingresar.
*/
public static String leerString(String mensaje) {
String cadena;
do {
cadena = JOptionPane.showInputDialog(mensaje);
if (cadena == null)
mostrarError("Error... no se ha ingresado valor");
} while (cadena == null);
return cadena;
}
/**
* Muestra un cuadro de diálogo solicitando el ingreso de una clave seceta
*
* Método leerClave. El método leerClave de la clase LE es un método
* incorporado en la versión 2.0 ha sido creado sobrecargado. Puede utilizar
* tres versiones. El método que no recibe parámetros coloca un titulo y un
* mensaje por default. El método que recibe un parámetro muestra el titulo
* especificado y un mensaje por default y el método que recibe dos
* parámetros muestra el título y el mensaje especificado. Observe como se
* reusa el método.
*
* @return un string con la clave ingresada. Si cierra la ventana o cancela
* retorna una cadena vacia
*
*
*/
public static String leerClave() {

return leerClave("", "");
}
public static String leerClave(String titulo) {

return leerClave(titulo, "");
}
public static String leerClave(String tituloVentana, String mensaje) {

if (tituloVentana.equalsIgnoreCase("")) {
tituloVentana = "Bienvenido";
}
if (mensaje.equalsIgnoreCase("")) {
mensaje = "Ingrese su clave";
}
JPanel panel = new JPanel();

JLabel etiqueta = new JLabel(mensaje);
JPasswordField jpfClave = new JPasswordField(10);
panel.add(etiqueta);
panel.add(jpfClave);
Object[] nombres = { "Clave ok", "Cancela clave" };

int rpta = JOptionPane.showOptionDialog(null, panel, tituloVentana,
JOptionPane.YES_NO_OPTION, JOptionPane.PLAIN_MESSAGE, null,
nombres, nombres[0]);
if (rpta != 0) {
return "";
} else {
return String.valueOf(jpfClave.getPassword());
}
}
/**
* Muestra un cuadro de diálogo con algún tipo de mensaje. No presenta
* ícono.
*
* @param mensaje
* es el mensaje a mostrar.
*/
public static void mostrarResultado(String mensaje) {
JOptionPane.showMessageDialog(null, mensaje, "Resultado",
JOptionPane.PLAIN_MESSAGE);
}
/**
* Muestra un cuadro de diálogo con una advertencia especificada en el
* argumento.
*
* @param mensaje
* es la advertencia a mostrar.
*/
public static void mostrarAdvertencia(String mensaje) {
JOptionPane.showMessageDialog(null, mensaje, "Advertencia",
JOptionPane.WARNING_MESSAGE);
}
/**
* Muestra un cuadro de diálogo con un mensaje de error especificado en el
* argumento.
*
* @param mensaje
* es el error a mostrar.
*/
public static void mostrarError(String mensaje) {
JOptionPane.showMessageDialog(null, mensaje, "Error",
JOptionPane.ERROR_MESSAGE);
}
/**
* Muestra un cuadro de diálogo con un mensaje de información especificado
* en el argumento.
*
* Método mostrarInformacion: Método sobrecargado, creandose el segundo
* método. El método mostrarInformación de la clase LE ha sido sobrecargado.
* Ahora Ud. puede utilizar dos versiones. El método que recibe un parámetro
* muestra la información en forma tradicional. El método que recibe cinco
* parámetros tienen la posibilidad de incluir un título en la ventana, un
* texto de titulo al interior del cuadro, mostrar la información en una
* área de texto con la posibilidad de hacer scroll cuando se necesita
* mostrar gran cantidad de información, cambiar la etiqueta del botón que
* se muestra en la parte inferior del cuadro y cambiar el color de fondo
* del área de texto.
*/
public static void mostrarInformacion(String mensaje) {

JOptionPane.showMessageDialog(null, mensaje, "Información",
JOptionPane.INFORMATION_MESSAGE);
}
public static void mostrarInformacion(String tituloVentana,
String tituloInterno, String mensaje, String nombreBoton,Color
color) {
JPanel panel = new JPanel();

panel.setLayout(new java.awt.BorderLayout(15,15));
JLabel cabecera = new JLabel("");
JTextArea muestraInformacion = new JTextArea(10, 30);

muestraInformacion.setEditable(false);
if (tituloVentana == null)
tituloVentana = "Información";
if (tituloInterno != null)
cabecera.setText(tituloInterno);
if (mensaje == null)
mensaje = "No hay datos para visualizar";
if (color != null)
muestraInformacion.setBackground(color);
muestraInformacion.append(mensaje);
JScrollPane desplazaInformacion = new JScrollPane(muestraInformacion);
panel.add( "North",cabecera);
panel.add( "Center", new Canvas());
panel.add( "South",desplazaInformacion);
if (nombreBoton != null) {
Object[] nombres = {nombreBoton};
JOptionPane.showOptionDialog(null, panel, tituloVentana,
JOptionPane.YES_NO_OPTION, JOptionPane.INFORMATION_
MESSAGE,
null, nombres, nombres[0]);
} else {
JOptionPane.showMessageDialog(null, panel, tituloVentana,
JOptionPane.INFORMATION_MESSAGE);
}
}
/**
* Muestra un cuadro de diálogo con una pregunta especificada en el
* argumento.
*
* @param mensaje
* es la pregunta a mostrar.
*/
public static void mostrarPregunta(String mensaje) {
JOptionPane.showMessageDialog(null, mensaje, "Pregunta",
JOptionPane.QUESTION_MESSAGE);
}
/**
* argumento y 2 opciones de respuesta a elegir.
*
* @param mensaje
* @return el entero 0 o 1 si se presionó el botón con la opción YES o NO
* respectivamente. Si se cierra este cuadro de diálogo sin
* presionar algún botón, retorna el entero -1.
*/
public static int mostrarPreguntaOpcion2(String mensaje) {
return JOptionPane.showOptionDialog(null, mensaje, "Pregunta",
JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_
MESSAGE, null,
null, null);
}
/**
* argumento y 3 opciones de respuesta a elegir.
*
* @param mensaje
* @return el entero 0, 1 o 2 si se presionó el botón con la opción YES, NO
* o CANCEL respectivamente. Si se cierra este cuadro de diálogo sin
* presionar algún botón, retorna el entero -1.

*/
public static int mostrarPreguntaOpcion3(String mensaje) {
return JOptionPane.showOptionDialog(null, mensaje, "Pregunta",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
null, null, null);
}
/**
* Muestra un cuadro de diálogo con un combo para selecciona una opción de
* múltiples opciones.
*
* @param opciones
* es un arreglo de cadenas con las opciones a mostrar.
* @return un string con la opción seleccionada. Si cierra la ventana o
* cancela retorna una cadena vacia.
*
*/
public static String seleccionarOpcion(String tituloVentana,
String mensaje, String[] opciones) {
String rpta = (String) JOptionPane.showInputDialog(null, mensaje,
tituloVentana, JOptionPane.QUESTION_MESSAGE, null,
opciones,
opciones[0]);
if (rpta == null) {
rpta = "";
}
return rpta;
}
/**
* Muestra un cuadro de diálogo con un combo para selecciona una opción de
* múltiples opciones.
*
* @param opciones
* es un arreglo de cadenas con las opciones a mostrar.
* @return un entero con la posición de la opción seleccionada. Si cierra
* la ventana o cancela retorna -1.
*
*/
public static int seleccionarOpcionIndex(String tituloVentana,
String mensaje, String[] opciones) {
String rpta = (String) JOptionPane.showInputDialog(null, mensaje,
tituloVentana, JOptionPane.QUESTION_MESSAGE, null,
opciones,
opciones[0]);
if (rpta != null) {
for (int i=0; i<opciones.length; i++) {
if (opciones[i] == rpta) {
return i;
}
}
}
return -1;
}
}
El paquete del lenguaje Java
El paquete del lenguaje Java, conocido también como java.lang, es uno de los paquetes más
importantes de la API1 de Java, y contiene las clases que constituyen el corazón del lenguaje de
programación Java.
El paquete java.lang, debido a su importancia, no requiere ser importado por las aplicaciones para
usar las clases que contiene; es decir, está automáticamente importado para todos los programas,
por lo que la siguiente sentencia no será necesaria:
import java.lang.* ;
El paquete java.lang contiene clases que encapsulan los tipos primitivos de datos, una clase que
proporciona los objetos2 para manipular la entrada y la salida estándar, clases que manipulan cadenas
de caracteres y otra que proporciona métodos3 correpondientes a las funciones matemáticas, etc.
Entre las clases más importantes están las siguientes:
Boolean Double Object StringBuffer

Byte Float Package System
Character Integer Process Thread
Class Long Runtime Trowable
ClassLoader Math Short
Compiler Number String
1
API: Aplication Program Interface. Una API es un conjunto de normas que determinan como debe usarse una
determinada función de un lenguaje de programación en una aplicación.
2
Objetos: Modelos de entes del mundo. Un objeto de software es cualquier cosa, real o abstracta, acerca del
cual almacenamos datosy los métodosque controlan dichos datos.
3
Métodos: Desarrollo de algoritmos. Los métodos especifican la forma en que se controlan los datos de un
objeto y es donde se define el comportamiento del mismo. En palabras sencillas; en los métodos se desarrollan
o codifican los algoritmos.
Entre las clases que serán tratadas en esta primera parte del apéndice se tienen:
1.- Clases que envuelven los tipos de datos primitivos, conocidas como las clases wrappers (envol-
torios). Cada una de estas clases (consideradas subclases4), a excepción de la clase Character, se
derivan de la clase abstracta 5Number (considerada superclase).
||Boolean
||Byte
||Character
||Double
||Float
||Integer
||Long
||Short
2.- Clase que proporciona métodos correspondientes a las funciones matemáticas básicas.
||Math
3.- Clase que proporciona los objetos necesarios para manipular y tratar cadenas de caracteres.
||String
En Java, los métodos siempre están dentro de una clase. Algunos métodos pueden ser invocados o
ejecutados utilizando directamente el nombre de la clase en la cual están definidos, tal es el caso de
los métodos de la clase Math de Java. Estos métodos son conocidos como métodos estáticos o de
clase.
Por otro lado, otros métodos son invocados o ejecutados utilizando un objeto o instancia6 de la clase
en la cual están definidos; tal es el caso de los métodos de la clase String de Java, que son conocidos
como métodos de instancia o de objeto.
También serán tratadas otras clases incorporadas en el lenguaje de programación Java, tales como:
}|Clase Calendar
}|Clase GregorianCalendar
}|Clase SimpleDateFormat
4
Herencia: SubClase y SuperClase. La Herencia es uno de los conceptos más importantes de la Programación
Orientada a Objetos (POO). Utilizando la Herencia se puede derivar una nueva clase a partir de otra clase
existente, donde la nueva clase derivada heredará todos los atributos y métodos de la clase existente. La
nueva clase se llama clase derivada (o SubClase) y la clase original se llama clase base (o SuperClase).
5
Clase abstracta: clase tratada como SuperClase. Una clase abstracta es un tipo de clase de la cual no se
pueden crear o instanciar objetos. En su lugar, se debe derivar una nueva clase a partir de la clase abstracta,
codificar los métodos que son declarados como abstractos en la clase abstracta y crear o instanciar objetos
a partir de la clase derivada. Las clases abstractas se utilizan para forzar a los programadores a desarrollar
algunos o todos los métodos de una clase.
6
Instancia: Representación concreta de una clase. Una Instancia viene a ser lo mismo que un objeto. Crear un
objeto o instanciar una clase se refiere a poder tener una representación real de una clase.
COnvERsión dE daTOs
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, porque de lo contrario el programa indicará un error al compilar.
Problema 156
Clase PrgTipoDato01
class PrgTipoDato01 {
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).
Problema 157
Clase PrgTipoDato02
packagedominioDeLaAplicacion ;
double numRealDouble = 2.3 ;

float numRealFloat ;

numRealFloat = numRealDouble ;
System.out.println ( numRealFloat ) ;
}
}
Observación: No se puede almacenar un número real grande (double) en una variable real (float).
Problema 158
Clase PrgTipoDato03
boolean estado = true ;

char caracter ;

caracter = estado ;
System.out.println ( caracter ) ;
}
}
Observación: No se puede almacenar un valor lógico (boolean) en una variable carácter (char).
Como se mencionó, solo se puede almacenar un valor en una variable y dicho valor debe ser del tipo
de dato con el que la variable fue declarada; sin embargo, la excepción para este caso 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. Dicha conversión es un tema propio de los lenguajes de
programación que se aplica generalmente sobre los tipos de datos numéricos, aunque también, sobre
el tipo de dato CARACTER.
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 uno de mayor
precisión (más amplio, más grande), y son generadas automáticamente por el compilador Java.
A continuación, se muestran los tipos de datos numéricos ubicados desde el tipo de dato de menor
precisión al de mayor precisión:
byte, short, int, long, float y double

Problema 159
Clase PrgTipoDato04
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, puesto que el tipo de dato
(long) en Java es de mayor precisión que el tipo de dato (int).
Problema 160
Clase PrgTipoDato05
public static void main ( Stringarg [ ] ) {
char caracter = ‘a’ ;

double numReal ;

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 tiene un tipo de dato más amplio que el izquierdo, al 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 explícita de datos en Java (casting)
Las conversiones de un tipo de dato de mayor precisón a otro de menor requieren que se coloque
en forma explícita en los programas. Estas conversiones son inseguras, por lo que podrían generarse
errores.
A este tipo de conversión de datos se le denomina también cast (casting). Este se realiza colocando
entre paréntesis el tipo de dato al que se desea convertir el resultado de una expresión.
Problema 161
Clase PrgTipoDato06
packagedominioDeLaAplicacion ;
double num1 = 20, num2 = 3 ;
int div ;

div = num1 / num2 ;
System.out.println ( div ) ;
}
}
Problema 162
Clase PrgTipoDato07
double num1 = 20, num2 = 3 ;
int div ;

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 números reales (double) en una variable entera
(int).
Las clases wrappers tratadas a continuación permiten envolver los tipos de datos simples y realizar
operaciones de conversión, entre otras.
Envoltorios de los tipos de datos primitivos: clases wrappers
A. Introducción: Los tipos de datos primitivos (boolean, byte, char, double, float, int, long, short),
o tipos de datos simples, son los únicos elementos del lenguaje de programación Java que se
representan internamente a través de valores, como en un lenguaje de programación convencional.
Esto significa que dicho tipo de datos no son objetos y se sitúan fuera de la jerarquía de clases7 de
Java, lo cual tiene algunas ventajas desde el punto de vista de la eficiencia.
En ocasiones, es conveniente sacrificar parte de la eficiencia por la flexibilidad, por lo que en Java se
ha creado la clase wrapper (envoltorios), que permite integrar los tipos de datos primitivos dentro
de la jerarquía de clases.
Los wrappers se diseñaron para ser un complemento de los tipos de datos primitivos y proporcionar
métodos para realizar diferentes tareas con el tipo de primitivo, como la conversión con cadenas de
caracteres, comprobación, traslación, entre otras.
Existe una clase wrapper para cada uno de los tipos de datos primitivos, que permiten tratarlos
como objetos. Dichas clases se muestran a continuación:
TIPO DE DATO CLASES

PRIMITIVO WRAPPERS
boolean Boolean
byte Byte
char Character
double Double
TIPO DE DATO CLASES

PRIMITIVO WRAPPERS
float Float
int Integer
Long Long
Short Short
Cada una de estas clases wrappers (a excepción de Character) tiene un método que permite
convertir desde una cadena (String) al tipo primitivo. Simplemente hay que ejecutar el método de la
clase wrappers adecuada y el string se convierte al tipo de dato primitivo asociado.
java.lang.Object
java.lang.Boolean java.lang.Character java.lang.Number
Byte Byte Byte Byte Byte Byte
Las clases Java, en general, tienen métodos estáticos y de instancia. Para ejecutar un método de
instancia es necesario crear un objeto de la clase donde está definido dicho método. Para crear un
objeto en Java se usa la sentencia new, a excepción de los objetos como los de la clase string, que no
necesariamente se crean con dicha sentencia.
Por ejemplo, para crear un objeto de la clase Integer utilizamos:
int i = 5;
Integer I = new Integer ( i )
Donde el objeto I es un objeto de la clase Integer, que tiene un valor igual a 5 y métodos para
manipular dicho valor.
7
Jerarquía de clases: Forma de ordenar las clases. La jerarquía de clases es una forma de ordenar las clases
existentes en un lenguaje de Programación Orientado a Objetos (POO). Una jerarquía de clases define conceptos
abstractos en la parte superior de la jerarquía, y conforme se desciende en la jerarquía los conceptos se tornan
cada vez más concretos. Java tiene su propia jerarquía de clases, en cuya parte superior se encuentra la clase
Object (pertenece al paquete java.lang).
B. Métodos: Con la finalidad de resumir los métodos de las clases wrappers que permiten la
conversión, comprobación y traslación de datos, se utilizarán algunos objetos de dichas clases. Se
asume que los objetos han sido creados previamente. Dichos objetos son:
OBJETO CLASE AL QUE

PERTENECE
S String
I Integer
L Long
F Float
D Double
C Character
También se utilizarán algunas variables, para lo cual se deberá asumir que estas han sido declaradas
previamente. Las variables son:
VARIABLE TIPO DE DATO

PRIMITIVO
i int
l long
f float
d double
b boolean
c char
Para referirnos a objetos se utilizará una letra en mayúscula, mientras que para referirnos a las
variables se utilizará una letra minúscula.
A. Conversión de tipo de dato primitivo a objeto String

Se puede convertir el valor de un tipo de dato primitivo o simple, a un valor de tipo cadena contenido
en un objeto String. Para realizar esta conversión, se pueden utilizar clases wrappers y variables, o
utilizar objetos de las clases wrappers. Esto depende de si se tiene disponible la variable (con el tipo
de dato primitivo) o el objeto de la clase wrapper (que contiene el valor).
Conversión de tipo de dato primitivo a objeto String utilizando clases wrappers y variables:
OBJETO STRING CLASES WRAPPERS Y

VARIABLES
S = Integer.toString (i ) ;
S = Long.toString ( l )
S = Float.toString ( f ) ;
S = Double.toString ( d ) ;
Observe que se utiliza el método toString ( ) para convertir el valor de una variable a un valor de
tipo cadena contenido en un objeto String. El método toString ( ) es un método estático o de clase,
porque se utiliza directamente el nombre de la clase para ejecutar el método.
Conversión de tipo de dato primitivo a objeto String utilizando objetos wrappers:
OBJETO STRING OBJETOS WRAPPERS

S = I.toString ( ) ;
S = L.toString ( ) ;
S = F.toString ( ) ;
S = D.toString ( ) ;
Observe que se utiliza el método toString() para convertir el valor contenido en el objeto wrappers
a un valor de tipo cadena contenido en un objeto String. A pesar de que el método toString() es un
método estático o de clase, también puede ejecutarse utilizando un objeto.
Todas las clases wrappers tienen en común el método estático o de clase toString( ). Esto se debe a
que este método no pertenece a dichas clases, sino a la clase Object.
La clase Object es la clase principal en la Jerarquía de Clases de Java (se puede decir que es la clase
padre de todas las clases). Todas las clases en Java pueden utilizar los métodos definidos en la clase
Object (debido fundamentalmente a la herencia) y uno de los métodos definidos en esta clase, es el
método toString ( ).
B. Conversión de objetos String a tipo de dato primitivo

Se puede convertir un objeto String a un tipo de dato primitivo, si el objeto String contiene un dato
equivalente al tipo de dato primitivo que se desea convertir.
Conversión de objetos String a tipos de dato primitivo, utilizando clases wrappers y objeto String.
VARIABLE WRAPPERS Y OBJETO STRING

Integer.valueOf (S) ;
I =
Integer.parseInt (S) ;
Long.valueOf (S) ;
L =
Long.parseLong (S) ;
Float.valueOf (S) ;
F =
Float.parseFloat (S) ;
Double.valueOf (S) ;
D =
Double.parseDouble (S) ;
Observe que se utiliza el método valueOf ( ) para convertir el valor contenido en el objeto String S a
un dato de tipo primitivo o valor de una variable. Este método es estático o de clase. También existe
la posibilidad de utilizar los métodos parseInt (),parseLong ( ), parseFloat ( ) y parseDouble ( ) para
los wrappers Integer, Long, Float y Double respectivamente.
C. Conversión de objetos wrappers a tipos de datos primitivos

Se puede convertir un valor de tipo cadena contenido en un objeto String a un valor de un tipo de
dato primitivo o simple, solo si el objeto String contiene un valor equivalente al valor del tipo de dato
primitivo que se desea convertir.
Conversión de objetos wrappers a tipos de dato primitivo, utilizando clases wrappers:

VARIABLE CLASES WRAPPERS

I I.intValue ( ) ;
L.intValue ( ) ;
I =
F.intValue ( ) ;
D.intValue ( ) ;
I.longValue ( ) ;
L.longValue ( ) ;
L =
F.longValue ( ) ;
D.longValue ( ) ;
.floatValue ( ) ;
L.floatValue ( ) ;
F =
F.floatValue ( ) ;
D.floatValue ( ) ;
I.doubleValue ( ) ;
L.doubleValue ( ) ;
d =
F.doubleValue ( ) ;
D.doubleValue ( ) ;
Observe que todas las clases wrappers tienen en común los métodos de instancia intValue ( ),
longValue ( ), floatValue ( ) y doubleValue ( ).
Todas las clases wrappers tienen en común los métodos de instancia intValue( ), longValue( ),
floatValue( ) y doubleValue( ). Estos métodos pertenecen en realidad a la clase Number.
La clase Number es la superclase de las clases wrappers (a excepción de la clase wrapper Character).
Estas clases pueden utilizar los métodos definidos en la clase Number a través de la herencia.
D. Comprobaciones del valor Not-a-Number

Comprobación del valor Not-a-Number utilizando clases wrappers y variables.
VARIABLE CLASES WRAPPERS Y

VARIABLES
Float.isNaN ( f ) ;
b =
Double.isNaN ( d );
Comprobación del valor Not-a-Number utilizando clases wrappers y variables.
VARIABLE OBJETOS WRAPPERS

F.isNaN ( ) ;
b = D.isNaN ( );
Observe que se utiliza el método isNaN ()para determinar si la variable es o no un número. El método
devuelve true si el valor de la variable no es un número.
Los valores Not-a-Number proceden de indeterminaciones tales como el resultado de la siguiente

operación: 0.0 / 0.0.
E. Comprobaciones del valor infinito

Comprobación del valor infinito utilizando clases wrappers y variables:
VARIABLE CLASES WRAPPERS Y

VARIABLES
Float.isInfinite ( f ) ;
b = Double.isInfinite ( d );
Comprobación del valor infinito utilizando objetos wrappers:
VARIABLE OBJETOS WRAPPERS

F.isInfinite ( ) ;
b =
D.isInfinite ( );
Observe que se utiliza el método isInfinite() para determinar si la variable es o no un número infinito.
El método devuelve true, si el valor de la variable es un número infinito.
Los valores Infinite proceden normalmente de la división por cero de un valor finito. Por ejemplo el
resultado de la siguiente operación: 10.5 / 0.0.
F. Comprobaciones de caracteres
Comprobación de caracteres utilizando la clase Character y la variable tipo char:
VARIABLE CLASE Character Y VARIABLE char
“Devuelve true si el carácter es una
Character.isLowerCase (c)
letra minúscula”.
“Devuelve true si el carácter es una
Character.isUpperCase (c) ;
letra mayúscula”.
b
“Devuelve true si el carácter es un
Character.isDigit (c) ;
dígito decimal”.
“Devuelve true si el carácter es un
Character.isSpace (c) ;
espacio en blanco”.
}|Traslación de caracteres
Traslación de caracteres utilizando la clase Character y la variable tipo char:
VARIABLE CLASE Character Y VARIABLE char

“Convierte el carácter a una letra
Character.toLowerCase (c);
minúscula”.
C =
“Convierte el carácter a una letra
Character.toUpperCase (c);
mayúscula”.
Problema 163
Desarrollar un programa en Java que permita convertir valores de diferentes tipos de datos en
valores de tipo cadena.

Clase PrgConvertirAString
class PrgConvertirAString {
boolean estado = true;

char letra = ‘z’;
int numEntero = 10;
long numEnteroLargo = 100000000;
float numReal = 15.5f;
double numRealDoble = 10000.98;
String cadena = “ ”;
cadena = String.valueOf ( estado ) ;

System.out.println ( “ Tipo boolean en String: ” + cadena ) ;
cadena = String.valueOf ( letra ) ;
System.out.println ( “ Tipo char en String: ” + cadena ) ;
cadena = String.valueOf ( numEntero ) ;
System.out.println ( “ Tipo int en String: ” + cadena ) ;
cadena = String.valueOf ( numEnteroLargo ) ;
System.out.println( “ Tipo long en String: ” + cadena ) ;
cadena = String.valueOf ( numReal ) ;
System.out.println ( “ Tipo float en String: ” + cadena ) ;
cadena = String.valueOf ( numRealDoble ) ;
System.out.println ( “ Tipo double en String: ” + cadena ) ;
}
}
Observe que es posible convertir cualquier tipo de dato a cadena (String), utilizando el método
valueOf() de la clase String. En ciertas ocasiones esto es necesario, porque las cadenas pueden
ser manipuladas. Analice cómo se pueden manipular las variables de tipo cadena (String), más
adelante en este mismo capítulo.
Problema 164
Desarrollar un programa en Java que permita obtener la fecha del sistema y la convierta en un valor
de tipo cadena.

Clase PrgConvertirFecha
import java.util.Date ;
class PrgConvertirFecha {
Date hoy = new Date() ;

String cadena = “ ”;
cadena = hoy.toString ( ) ;
System.out.println ( “ Fecha: ” + cadena ) ;
}
}
La clase Date es una clase propia de Java y está incluida en el paquete java.util. En este paquete
podrá encontrar clases de utilidad para sus aplicaciones. Este paquete está fuera del alcance del
presente texto (Se sugiere investiguar las clases que forman parte de este paquete).
El ejecutar esta aplicación se visualizará algo parecido a lo siguiente:
Fecha: Sat Mar 20 11:38:46 GMT-05:00 2004
Observe como se convierte la fecha almacenada en un objeto (llamado hoy) de la clase Date en una
cadena (String), utilizando el método toString() de la clase String. Esta cadena de texto podrá ser
manipulada para obtener otros datos, tales como; el día, el mes, el año actual o la hora del sistema.
Mas adelante, se podrá analizar cómo se pueden manipular las variables de tipo cadena (String).
Problema 165
Desarrollar un programa en Java que permita convertir una cadena en un número entero y en un
objeto de tipo Integer. Calcular y mostrar la suma de ambos valores.

Clase PrgCadenaAEntero
class PrgCadenaAEntero {
int numEntero = 0 ;
String cadena = “10" ;
numEntero = Integer.parseInt ( cadena ) ;

Integer objInteger = Integer.valueOf ( cadena ) ;
System.out.println (“Valores enteros:” + numEntero + “ "+ objInteger ) ;

System.out.println (“La suma es: ” +(numEntero + objInteger.intValue ()));
}
}
Observe que es posible convertir una cadena (String) en un valor entero (int) o en un objeto de la
clase Integer. Recuerde que deberá asegurarse que la cadena contenga un valor válido, para que
pueda ser almacenado en un tipo de dato determinado.
Puede utilizar el método parseInt( ) de la clase String para convertir una cadena en un número
entero (numEntero), y también el método valueOf( ) de la clase Integer para convertir una cadena
en un un objeto (objInteger) de la clase Integer. El método intValue( ) nos permite obtener el valor
entero del objeto (objInteger) de la clase Integer.
Como sugerencia, desarrolle un programa en Java que realice lo mismo que este programa pero
utilice una variable long y la clase Long.
Problema 166
Desarrollar un programa en Java que permita convertir una cadena en un número real y en un
objeto de tipo Double. Calcular y mostrar la suma de ambos valores.
Clase PrgCadenaAReal
class PrgCadenaAReal {
double numRealDoble = 0 ;
String cadena = “10.5” ;
numRealDoble = Double.parseDouble ( cadena ) ;

Double objDouble = Double.valueOf ( cadena ) ;
System.out.println(“Valores enteros:” + numRealDoble + “” + objDouble);

System.out.print ( “ La suma es: ” ) ;
System.out.println ( numRealDoble + objDouble.doubleValue ( ) ) ;
}
}
Observar que es posible convertir una cadena (String) en un valor entero (double) o en un objeto de
la clase Double. Se recuerda que deberá asegurar que la cadena contenga un valor que sea válido
para poderlo almacenar en un tipo de dato determinado.
Puede utilizar el método parseDouble( ) de la clase Double para convertir una cadena en un número
real (numRealDoble) y también el método valueOf( ) de la clase Double para convertir una cadena
en un objeto (objDouble) de la clase Double. El método doubleValue ( ) nos permite obtener el
valor real del objeto (objDouble) de la clase Double.
Se sugiere desarrollar un programa en Java que realice lo mismo que este programa, pero que
utilice una variable float y la clase Float.
FUnCiOnEs maTEmáTiCas: ClasE maTh
Introducción
La clase Math viene incorporada en el lenguaje de programación Java, incluida en el paquete java.lang,
la cual nos proporciona métodos y atributos para implementar diversas funciones mátemáticas.
JERARQUÍA DE CLASES Y HERENCIA
java.lang.Object
java.lang.Object
El paquete java.lang es el principal del lenguaje Java, por lo cual no se necesita importar ninguna
clase incluida en dicho paquete. En consecuencia, no será necesario importar el paquete java.lang
cada vez que se necesite utilizar la clase Math de Java.
La clase Math contiene métodos de cálculo básico como; exponencial, logaritmo, raíz cuadrada
y funciones trigonométricas. La clase Math a diferencia de otras clases, es una clase final8. Esto
significa que no puede ser instanciada (es decir; no se pueden crear objetos de la clase Math). Los
métodos de la clase Math son métodos estáticos (llamados también métodos de clase) y para poder
utilizarlos solo se debe colocar el nombre de la clase, el operador punto y el nombre del método a
utilizar.
Ejemplo:
Math.pow (a, b) ;
8
Clase Final: No puede ser una SuperClase. Una clase final, o declarada como final, es una clase que no puede
ser una SuperClase. Es decir, las clases finales no pueden heredarse. Todos los métodos de una clase final son
implícitamente finales.
Métodos
La clase Math presenta los siguientes atributos y métodos de clase:
A. Atributos de clase:
1.- E.
2.- PI.
B. Métodos de clase:
1.- abs( ).
2.- acos( ).
3.- asin( ).
4.- atan( ).
5.- ceil( ).
6.- cos( ).
7.- exp( ).
8.- floor( ).
9.- log( ).
10.- max( ).
11.- min( ).
12.- pow( ).
13.- random( ).
14.- round( ).
15.- sin( ).
16.- sqrt( ).
17.- tan( ).
18.- toDegrees( ).
19.- toRadians( ).
Para trabajar con los métodos de clase, de la claseMath no será necesario crear previamente un
objeto de dicha clase (esto se cumple para todas las clases que implementen métodos de clase).
Para ejecutar un método de clase, de la clase Math, es necesario colocar la palabra Math (que es
el nombre de la clase), el operador punto (.) y el nombre del método de clase que desea ejecutar.
Asimismo, para ejecutar un método de la clase Math, debemos tener en cuenta que si el método
necesita algunos datos, estos deben ser necesariamente proporcionados en la cantidad y tipos
requeridos. En caso de que el método devuelva un resultado, deberá almacenarlo en una variable
del mismo tipo que el resultado proporcionado o mostrarlo a través de la pantalla.
A continuación, se presenta una breve descripción del uso de cada uno de los métodos de la clase
Math:
CLASE Math
ATRIBUTOS DE DESCRIPCIÓN USO

CLASE
double e = Math.E ;
Almacena el valor de E. Es decir, nos System.out.print( e) ;
proporciona la base de un logaritmo
E
natural. El valor es equivalente a Resultado:
2.718281828459045. e = 2.718281828459045.
double pi = Math.PI ;
System.out.print( pi) ;
Almacena el valor de PI. Es decir,
PI almacena el valor equivalente a
Resultado:
3.141592653589793.
pi = 3.141592653589793.
MÉTODOS DE DESCRIPCIÓN USO

CLASE
abs (float)
int x = -5 ;
abs (double) Retorna el valor absoluto de un System.out.print( Math.abs( x)) ;
número (que puede ser float, double,
abs (int) int, long) dado como parámetro. Resultado:
x = 5.
abs (long)
double angulo = 45.0 * Math.

PI/180.0;
double result ;
Retorna un valor double con el
result = Math.acos( angulo ) ;
arcocoseno de un ángulo expresado
System.out.print( result ) ;
acos (double) en radianes. El ángulo expresado en
radianes debe ser un valor double
Resultado :
enviado al método como parámetro.
result = 0.6674572160283838

PI/180.0 ;
double result ;
result = Math.asin( angulo ) ;
arcoseno de un ángulo expresado
asin (double) en radianes. El ángulo expresado en
Resultado :
result = 0.9033391107665127

PI/180.0 ;
double result ;
arcotangente de un ángulo expresado
result = Math.atan( angulo ) ;
atan (double) en radianes. El ángulo expresado en
Resultado
result = 0.6657737500283538
MÉTODOS DE
DESCRIPCIÓN USO
CLASE
double n = 0.65 , result ;
result = Math.ceil( n ) ;
Retorna un valor double con el valor
más corto no menor que el parámetro
ceil (double)
dado. El parámetro dado debe ser
Resultado:
double.
result = 1.0

PI/180.0 ; double result ;
result = Math.cos( angulo ) ;
coseno de un ángulo expresado en
System.out.println( result ) ;
cos (double) radianes. El ángulo expresado en
Resultado :
result = 0.8660254037844387
double exponente=1.0 , result ;

result = Math.exp(exponente) ;
Retorna un valor double con el valor
System.out.println(result) ;
exponencial de Euler del parámetro
exp (double)
dado. El parámetro dado debe ser
Resultado:
double.
result = 2.7182818284590455
double n = 5.65 , result ;

result = Math.floor(n) ;
System.out.print(result) ;
valor más grande no mayor que el
floor (double)
parámetro dado. El parámetro dado
Resultado:
debe ser double.
resutl = 5.0
double logaritmo = 3.0 , result ;

result = Math.log(logaritmo) ;
System.out.println( result ) ;
logaritmo natural (base e) de un
log (double)
Resultado:
debe ser double.
result = 1.0986122886681096
max (float, float)

double x = 10, y = 15, mayor ;
Retorna el valor del número mayor
max (double, double) Mayor = Math.max(x , y) ;
(que puede ser float, double, int,
System.out.print ( mayor) ;
long) de dos números, dados como
max (int, int) parámetros.
Resultado:
max (long, long)
min (float, float) double x = 10 , y = 15 , menor ;

menor = Math.min( x , y ) ;
Retorna el valor del número menor
min (double, double) System.out.print ( menor ) ;
(que puede ser float, double, int,
min (int, int) long) de dos números dados como
Resultado:
parámetros.
min (long, long) menor = 10.

CLASE
double x = 2 , y = 4 , result ;
Retorna un valor double con la
result = Math.pow( x , y ) ;
potencia de un número (dado
System.out.print ( result ) ;
como primer parámetro) elevado a
pow (double, double)
otro número (dado como segundo
Resultado:
parámetro). Los dos parámetros
dados deben ser double.
result = 16.
Retorna un valor double con un

double num ;
número generado aleatoriamente (al
random () num = Math.random( ) ;
azar) mayor o igual que 0.0 y menor
System.out.print ( num ) ;
que 1.0.
double x = 10.53 , result ;

round (float)
result = Math.round( x ) ;
Retorna un valor (que puede ser float
o double) con el valor redondeado del
Resultado:
round (double) puede ser un valor float o double.
result = 11.

PI/180.0; double result ;
Retorna un valor double con el seno
result = Math.sin(angulo) ;
de un ángulo expresado en radianes.
System.out.println(result) ;
sin (double) El ángulo expresado en radianes
debe ser un valor double enviado al
Resultado:
método como parámetro.
result = 0.6018150231520483
double x = 16 , result ;
result = Math.sqrt( x ) ;
Retorna un valor double con la raiz
cuadrada del parámetro dado. El
sqrt (double)
parámetro dado debe ser un valor
Resultado:
double.
result = 4.

PI/180.0 ;
Retorna un valor double con la double result ;
tangente de un ángulo expresado result = Math.tan(angulo);
tan (double) en radianes. El ángulo expresado en System.out.println( result ) ;
enviado al método como parámetro. Resultado:
result = 1.3270448216204098
double angulo = Math.PI/3, result ;

Retorna un valor double. Permite result = Math.toDegrees(angulo) ;
convertir un ángulo expresado en System.out.println(result) ;
toDegrees (double) radianes (enviado como parámetro
double) en un ángulo expresado en Resultado:
sexagesimal.
result = 59.99999999999999

CLASE
double angulo = 60, result ;
Retorna un valor double. Permite result = Math.toRadians(angulo) ;
convertir un ángulo expresado en System.out.println( result ) ;
sexadecimal (enviado como parámetro
toRadians (double)
double) en un ángulo expresado en Resultado:
radianes.
result = 1.0471975511965976
A continuación, con la finalidad de mejorar la comprensión del tema tratado, se presentan algunas
soluciones a problemas planteados utilizando algunos de los métodos de la clase Math. Analice cada
una de las siguientes soluciones.
Problema 167
Desarrollar un programa en Java que permita ingresar tres números enteros a través del teclado.
Determinar y mostrar cuál de ellos es el número mayor.
Clase PrgNumeroMayor
class PrgNumeroMayor {
int num1, num2, num3, resultado ;
System.out.println ( “ Ingresar el primer número: ” ) ;

System.out.println ( “ Ingresar el segundo número: ” ) ;

System.out.println ( “ Ingresar el tercer número: ” ) ;

resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;
System.out.println ( “ El número mayor es: ” + resultado ) ;

}
}
¿Qué hay de nuevo en la codificación?
Observe el uso del método max( ) de la clase Math:
Math.max ( num2, num3 )
Parámetros
Nombre del método
Operador punto
Nombre de la Clase
El método max ( ) nos permite determinar el número mayor entre dos números (en nuestro caso el
número mayor entre num2 y num3).
En esta solución se emplea una estrategia mas simple para determinar el número mayor entre tres
números. El método max ( ) de la clase Math retorna el valor del número mayor (puede ser un
número float, double, int o long) de dos números dados como parámetros. En nuestro ejemplo
determinamos el mayor de los dos últimos números ingresados y en la misma línea de código
evaluamos el mayor de estos dos números con el primer número ingresado, tal y como se muestra
a continuación:
resultado = Math.max ( num1, Math.max ( num2, num3 ) ) ;
Es importante tener presente que el método max ( ) es un método que solo podemos utilizar con la
clase Math y su función es determinar el número mayor entre dos números dados como parámetros.
Problema 168
Desarrollar un programa en Java que permita ingresar tres números enteros a través del teclado.
Determinar y mostrar cuál de ellos es el número menor.
Clase PrgNumeroMenor
class PrgNumeroMenor {
int num1, num2, num3, resultado ;
System.out.println ( “ Ingresar el primer número: ” ) ;

System.out.println ( “Ingresar el segundo número: ” ) ;

System.out.println ( “Ingresar el tercer número: ” ) ;

resultado = Math.min ( num1, Math.min ( num2, num3 ) ) ;
System.out.println ( “ El número menor es:" + resultado ) ;

}
}
Observe el uso del método min( ) de la clase Math. En la codificación de esta solución se emplea
una nueva estrategia para hallar el menor de tres números, ingresados a través del teclado
(anteriormente se utilizaban sentencias if anidadas).
Observe que Math.min( ) retorna el valor del número menor (que puede ser float, double, int,
long) de dos números dados como parámetros. En nuestro ejemplo, hallamos el menor de los dos
últimos números ingresados, y en la misma línea evaluamos el menor de estos dos números con el
primer número ingresado, tal como se muestra a continuación:
resultado= Math.min ( num1, Math.min ( num2, num3 ) ) ;

Problema 169
Desarrollar un programa en Java que permita generar una cantidad determinada de números
aleatorios. Los números aleatorios generados deberán estar entre 1 y 6. Mostrar el número
generado aleatoriamente y la suma de dichos números.
Clase PrgNumerosAleatorios
class PrgNumerosAleatorios {
int x, cant, num, suma=0 ;
System.out.print ( “Ingresar la cantidad de números aleatorios a

generar: ” ) ;
cant = Lectura.leerInt( ) ;
for ( x = 1; x <= cant; x++) {
num = 1 + (int) ( Math.random( ) * 6 ) ;

System.out.println (“El número aleatorio generado es:” + num) ;
suma = suma + num ;

}
System.out.println (“La suma de los números aleatorios es: ” + suma);

}
}
Observe el uso del método random( ) de la clase Math:
num = 1 + (int) (Math.random ( ) * 6 ) ;
En la codificación de esta solución se utiliza una sentencia for con la finalidad de generar la cantidad
de números aleatorios (al azar) que el usuario desee. Cada vez que se ejecuta la sentencia for, se
genera y muestra un número aleatorio (un número entre 1 y 6), el cual es acumulado en la variable
suma. Finalizada la ejecución de la sentencia for se muestra el contenido de dicha variable (es decir,
se muestra la suma de los números aleatorios generados).
Recuerde que para generar números aleatorios entre dos números (entre un intervalo o rango),
utilizando el método random ( ) de la clase Math, se emplea la siguiente fórmula:
min + (int) ( Math.random( ) * (max – min + 1 ) ) ;
Para nuestro ejemplo tenemos:
1 + (int) ( Math.random( ) * ( 6 – 1 + 1 ) ) ;
1 + (int) ( Math.random( ) * ( 6 ) ) ;
Problema 170
aleatorios. Los números aleatorios generados deberán estar entre 1 y 10. Mostrar los números
aleatorios que son números pares.

Clase PrgNumAleatoriosPares
class PrgNumAleatoriosPares {
int x, cant, num, cont = 0 ;

generar: ” ) ;
do {
if (num % 2 == 0) {
cont++;
System.out.print ( num + “ \t ” ) ;
}
} while (cant != cont) ;

}
}
En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.
Si el número generado es par se le aumenta uno a la variable cont(que esta trabajando como contador de
números pares generados al azar) y se muestra el número generado.
Problema 171
aleatorios que son números impares.
Clase PrgNumAleatoriosImpares
class PrgNumAleatoriosImpares {
int x, cant, num, cont = 0 ;

generar:” ) ;
do {
if ( num % 2 == 1 ) {
cont ++;
System.out.print ( num + “ \t ” ) ;
}
} while ( cant != cont ) ;

}
}
En la codificación de esta solución se utiliza una sentencia do con la finalidad de generar números aleatorios.
Si el número generado es impar se le aumenta uno a la variable cont(que esta trabajando como contador de
números impares generados al azar) y se muestra el número generado.
Problema 172
Desarrollar un programa en Java que permita ingresar por teclado el radio de una esfera. Calcular y
mostrar el volumen de dicha esfera.
Clase PrgRadioEsfera
class PrgRadioEsfera {
double radio, volume ;
System.out.println ( “Ingresar el radio de la esfera: ” ) ;

radio = Lectura.leerDouble();
volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ;
System.out.println ( “El volumen de la esfera es: ” + volume ) ;

}
}
Observe el uso del método pow( ) y del atributo PI de la clase Math:
volume = (4 / 3) * Math.PI * Math.pow ( radio, 3 ) ;
El método pow ( ) retorna un valor double con la potencia de un número (dado como primer
parámetro) elevado a otro número (dado como segundo parámetro). En nuestro caso el método
pow ( ) eleva a la potencia 3 el radio del círculo.
Para hallar el volumen de la esfera se tendrá que utilizar la fórmula v=4/3*PI*R3. La clase Math
define un atributo (constante) muy útil, que contiene el valor del número PI(Math.PI).
Problema 173
Desarrollar un programa en Java que permita ingresar un número decimal. Mostrar el número
ingresado redondeado.
Clase PrgNumRedondeado
class PrgNumRedondeado {
double num, resultado ;
System.out.println ( “Ingrese un número decimal: ” ) ;

num = Lectura.leerDouble( ) ;
resultado = Math.round(num) ;
System.out.println ( “El número redondeado es: ” + resultado ) ;
}
}
Observe el uso del método round( ) de la clase Math:
resultado = Math.round(num) ;
El método round( ) permite redondear un número dado como parámetro.
En esta solución se ingresa un número y se almacena en la variable num. Luego, dicho número es
redondeado utilizando el método round( ) y se almacena en la variable resultado.
Problema 174
Desarrollar un programa en Java que permita ingresar un número entero y un exponente. Mostrar
el resultado del cálculo de la potencia de todos los números menores que el número ingresado,
elevado al exponente ingresado.
Clase PrgNumPotencia
class PrgNumPotencia {
int cant, expo ;

double rpta ;
System.out.println ( “Ingresar un número entero: ” ) ;

System.out.println ( “Ingresar el exponente: ” ) ;

expo = Lectura.leerInt( ) ;
for ( int x = 1; x < cant; x++) {
rpta = Math.pow ( x, expo ) ;

System.out.println (“El Exponencial de ” + x + “ es:” + rpta);
}
}
}
¿Que hay de nuevo en la codificación?
Observe el uso del método pow ( ) de la clase Math:
El método pow ( ) permite elevar a la potencia un número determinado. En la presente solución se utiliza
una sentencia for con la finalidad de elevar a la potencia todos los números menores que la variable cant y
mostrarlos por pantalla. La variable cant y el exponente expo se ingresan a través del teclado.
Recordar que el método pow ( ) de la clase Math, retorna un valor double, por lo que dicho valor deberá ser
almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.
Problema 175
Desarrollar un programa en Java que permita ingresar un número entero. Mostrar el resultado del
cálculode la raíz cuadrada de todos los números menores que el número ingresado.

Clase PrgNumRaiz
class PrgNumPotencia {
int cant, expo ;

double rpta ;
System.out.println ( “Ingresar un número entero: ” ) ;

System.out.println ( “Ingresar el exponente: ” ) ;

expo = Lectura.leerInt( ) ;
for ( int x = 1; x < cant; x++) {

System.out.println (“El Exponencial de ” + x + “ es:” + rpta);
}
}
}
Observar el uso del método sqrt ( ) de la clase Math:
rpta = Math.sqrt ( x ) ;
El método sqrt ( ) permite obtener la raíz cuadrada de un número determinado.
En esta solución se utiliza una sentencia for con la finalidad de obtener la raíz cuadrada de todos los números
menores que la variable cant, y mostrarlos por pantalla. La variable cant se ingresa a través del teclado.
Recuerde y siempre tenga presente que el método sqrt () de la clase Math, retorna un valor double, el cual
deberá ser almacenado en una variable del mismo tipo o deberá mostrarse por la pantalla.
Problema 176
generados aleatoriamente elevados al cuadrado.

Clase PrgNumAleatorioCuad
class PrgNumAleatorioCuad {
int cant, num ;

double rpta ;

generar: ” ) ;
for ( int x = 1; x <= cant; x++ ) {
num = (int) ( 1 + ( Math.random() * 10 ) ) ;

rpta = Math.pow (num, 2) ;
System.out.println ( num + “elevado al cuadrado es:” + rpta);
}
}
}
Observe el uso de los métodos random ( ) y sqrt ( ) de la clase Math:
num = (int) ( 1 + ( Math.random() * 10 ) ) ;

rpta = Math.pow (num, 2) ;
En la presente solución se utiliza una sentencia for con la finalidad de obtener números aleatorios, elevarlos al
cuadrado y mostrarlos por pantalla. La variable cant se ingresa a través del teclado.
Problema 177
Desarrollar un programa en Java que permita determinar y mostrar el área de un tríangulo en base
a las longitudes de sus lados. Considerar el valor absoluto de la diferencia entre el semiperímetro y
cada uno de los lados. Utilizar las siguientes fórmulas:
area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2).

p = (a+b+c) / 2.
Donde:
p = Semiperímetro.
a, b, c = Lados del triángulo.
Clase PrgTriangulo
class PrgTriangulo {
double a, b, c, p, tmp, area ;
System.out.println ( “Valor del primer lado del triángulo (a): ” ) ;

a = Lectura.leerDouble( ) ;
System.out.println ( “Valor del segundo lado del triángulo (b): ” ) ;

b = Lectura.leerDouble( ) ;
System.out.println ( “Valor del terecr lado del triángulo (c): ” ) ;

c = Lectura.leerDouble( ) ;
p = (a + b + c) / 2 ;
tmp = (p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b)));
area = Math.sqrt ( tmp ) ;
System.out.println ( “El área del triángulo es: ” + area ) ;

}
}
Observe el uso de los métodos abs ( ) y sqrt ( ) de la clase Math:
tmp = ( p * (Math.abs(p - a)) * (Math.abs(p - c)) * (Math.abs(p - b) ) ) ;

area = Math.sqrt ( tmp ) ;
En esta solución se ingresan los valores de los tres lados de un triángulo y se obtiene el valor del
semiperímetro del triángulo.
Luego, se procede a calcular el área del triángulo en base a la siguiente fórmula:
area = ( p * (|p-a|)*(|p-b|)*(|p-c|)) RAIZ (2)
Primero, se hace uso del método abs ( ) de la clase Math para calcular el valor absoluto de la
diferencia entre el semiperímetro y cada uno de los lados del triángulo. Luego, se multiplican los
valores resultantes con el valor del semiperímetro del triángulo y finalmente se obtiene la raíz
cuadrada del valor resultante utilizando el método sqrt ( ) de la clase Math.
Problema 178
Desarrollar un programa en Java que permita determinar y mostrar el perímetro y el área de un

círculo. Utilizar las siguientes fórmulas:
perímetro = 2 * PI * radio.
área = PI * radio * radio.

Clase PrgCirculo
class PrgCirculo {
double radioCirculo, areaCirculo, perimetroCirculo ;
System.out.println ( “ Ingrese el valor del radio del círculo: ” ) ;

radioCirculo = Lectura.leerDouble( ) ;
areaCirculo = Math.PI * Math.pow (radioCirculo, 2) ;

perimetroCirculo = 2 * Math.PI * radioCirculo ;
System.out.println ( “ El área del círculo es: ” + areaCirculo ) ;

System.out.println ( “ El perímetro del círculo es : ” +
perimetroCirculo ) ;
}
}
Problema 179
Desarrollar un programa en Java que permita ingresar un ángulo expresado en grados. Determinar
el tipo de ángulo ingresado y su equivalente en radianes. Los ángulos expresados en grados se
clasifican de la siguiente manera:
0 grados = Nulo
Entre 0 y 90 grados = Agudo
90 grados = Recto
Entre 90 y 180 grados = Obtuso
180 grados = Llano
Entre 180 grados y 360 grados = Cóncavo
360 grados = Completo
Clase PrgConversionAngulo
class PrgConversionAngulo {

double anguloGrados, anguloRadianes ;
String tipoAngulo = “” ;
System.out.println ( “ Ingrese un ángulo en grados (entre 0 y 360): ” );

anguloGrados = Lectura.leerDouble( ) ;
if (anguloGrados == 0)
tipoAngulo = “Nulo” ;
if (anguloGrados > 0 && anguloGrados < 90)
tipoAngulo = “Agudo” ;
tipoAngulo = “Recto” ;
tipoAngulo = “Obtuso” ;
tipoAngulo = “Llano” ;
tipoAngulo = “Concavo” ;
tipoAngulo = “Completo” ;
anguloRadianes = Math.toRadians (anguloGrados) ;

System.out.println ( “ Tipo de ángulo: ” + tipoAngulo ) ;
System.out.println ( “ Ángulo expresado en radianes: ” + anguloRadianes);
}
}
Observe el uso del método toRadians ( ) de la clase Math:
anguloRadianes = Math.toRadians (anguloGrados) ;
Para el desarrollo de esta solución se hace uso de sentencias if múltiples, con la finalidad de
determinar el tipo de ángulo ingresado por teclado. El tipo de ángulo es almacenado en una variable
String (tipoAngulo) y mostrado por pantalla.
Para realizar la conversión del ángulo ingresado en el sistema sexagesimal al sistema radial, se utiliza
el método toRadians ( ) de la clase Math.
Problema 180
Desarrollar un programa en Java que permita determinar y mostrar las raíces de una ecuación de
segundo grado. Tipo:
Ax2 + Bx + C = 0
Considerar que la solución puede tener raíces imaginarias. Utilizar la siguiente fórmula:
x = ( - B + - ( ( B ** 2 – 4 * A * C ) RAIZ ( 2 ) ) ) / 2 * A.
Clase PrgEcuacion2Grado
class PrgEcuacion2Grado {

int a, b, c ;
double tmp, x, x1, x2 ;
System.out.println ( “ Ingrese el coeficiente A: ” ) ;

a = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente B: ” ) ;
b = Lectura.leerInt( ) ;
System.out.println ( “ Ingrese el coeficiente C: ” ) ;
c = Lectura.leerInt( ) ;
if (a == 0 && b == 0) {
System.out.println ( “ La ecuación no tiene solución ” ) ;
} else {
tmp = Math.pow (b, 2) - (4 * a * c) ;
if (tmp < 0) {
System.out.println ( “ La ecuación tiene raices imaginarias ”);

} else {
if (a == 0) {
x = c / b * (-1) ;
System.out.println (“El valor para x es: ” + x);
} else {
x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a) ;
System.out.println (“El primer valor para x es:” + x1);
System.out.println (“El segundo valor para x es:” + x2);
}
}
}
}
}
Observe el uso de los métodos pow ( ) y sqrt ( ) de la clase Math:
En esta solución se ingresan los coeficientes de una ecuación de segundo grado (a, b y c). Si los coeficientes a y
b son iguales a cero, se muestra un mensaje por la pantalla: “La ecuación no tiene solución”. Caso contrario, se
determina el valor de la discriminante, el cual se almacena en la variable tmp utilizando la siguiente fórmula:
tmp = Math.pow (b, 2) - (4 * a * c) ;
En caso que el valor de tmp sea igual a cero, se muestra el siguiente mensaje por pantalla; “La ecuación tiene
raices imaginarias”. Caso contrario, si el coeficiente a es igual a cero la ecuación tendría una sola solución, la
cual se calcularía utilizando:
x = c / b * (-1) ;
Si el coeficiente a es diferente de cero la ecuación tendría dos soluciones, las cuales se calcularían utilizando:
x1 = ( - b + Math.sqrt (tmp)) / (2 * a) ;
x2 = ( - b - Math.sqrt (tmp)) / (2 * a)
Problema 181
Desarrollar un juego en Java que permita generar un número aleatorio. Se debe intentar adivinar
qué número es el que generó la computadora. El rango de números válidos en el juego es de 1 a
100, y cada vez que intente adivinar le indicará si el número buscado es menor o mayor.
Clase PrgJuego
class PrgJuego {

int maximo = 100, num, numAzar, inten = 1 ;
double tmp;
System.out.println ( “ Bienvenido al juego: ¿Que número es? ” ) ;

System.out.println ( “ ----------------------------------------” ) ;
System.out.println ( “ - La computadora genera un -” ) ;
System.out.println ( “ - numero aleatorio y ud. tratara -” ) ;
System.out.println ( “ - de adivinar que número es -” ) ;
System.out.println ( “ - Trate de adivinar el número en -” ) ;
System.out.println ( “ - el menor número de intentos -” ) ;
do {
System.out.println ( “ Ingrese un número entre 0..100: ” ) ;
} while (num < 0 || num > 100 ) ;
tmp = maximo * Math.random( ) ;

numAzar = (int) Math.round(tmp) ;
while (num != numAzar) {

inten++ ;
if (num < numAzar)
System.out.println ( “ El número buscado es mayor ” ) ;
else
System.out.println ( “ El número buscado es menor ” ) ;
do {
System.out.println ( “ Ingrese otro número entre 0..100: ”) ;
} while (num < 0 || num > 100) ;
}
System.out.println (“Ud. encontró el número en:” + inten + “intento(s)”;
}
}
Observe el uso de los métodos random ( ) y round ( ) de la clase Math:
Utilizando el método random ( ) generamos un número aleatorio (al azar) entre el número 0 y el número 100,
utilizando la siguiente fórmula:
tmp = maximo * Math.random( ) ;
El número generado aleatoriamente es almacenado en la variable tmp. Luego es redondeado, utilizando el

método round ( ) y convertido a un número entero utilizando la siguiente sentencia:
numAzar = (int) Math.round(tmp) ;
Este número generado al azar es almacenado en la variable numAzares, comparado con un número previamente
ingresado por teclado y almacenado en la variable num. Si ambos son iguales, se mostrará un mensaje indicando
que el número numAzar fue encontrado. Si no son iguales, se mostrará un mensaje indicando si el número buscado
es mayor o menor (en relación al número ingresado), y se solicitará otro número hasta encontrar el número que
se generó en forma aleatoria.
Intente modificar la codificación de la solución. Utilice la sentencia do y optimice el código.
Problema 182
Desarrollar un programa en Java que permita ingresar seis números a tráves del teclado. Determinar
y mostrar cuál de ellos es el número mayor y menor.
Clase PrgNumeroMayorMenor
class PrgNumeroMayorMenor {

int n1, n2, n3, n4, n5, n6 ;
double mayor, meno r;
System.out.println ( “ Ingrese el primer número: ” ) ;

n1 = Lectura.leerInt();
System.out.println ( “ Ingrese el segundo número: ” ) ;
System.out.println ( “ Ingrese el tercer número: ” ) ;
System.out.println ( “ Ingrese el cuarto número: ” ) ;
n4 = Lectura.leerInt( )
System.out.println ( “ Ingrese el quinto número: ” ) ;

System.out.println ( “ Ingrese el sexto número: ” ) ;
mayor = Math.max (n1,n2) ;

mayor = Math.max (mayor,n3) ;
menor = Math.min (n1,n2) ;
menor = Math.min (menor,n3) ;
System.out.println ( “ El mayor número es: " + mayor ) ;
System.out.println ( “ El menor número es: " + menor ) ;
}
}
Modificar la codificación de la solución, de tal forma que pueda optimizar el código. Utilice una
sentencia for.
Problema 183
Desarrollar un programa en Java que permita ingresar las notas de todos los alumnos de un
determinado salón de clase. Calcular y mostrar el promedio final de cada alumno en base a la
siguiente fórmula:
pf = ( pp + ep + ( ef * 2 ) ) / 4.
Donde:
pf = Promedio final.
pp = Promedio de prácticas.
Son 4 prácticas de las cuales se elimina la más baja
pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3
ep = Examen parcial.
ef = Examen final.

Clase PrgPromedioNotas
class PrgPromedioNotas {

double pf, pp, ep, ef, p1, p2, p3, p4, notaMenor ;
char opc ;
do {
System.out.println ( “ Ingrese la nota de la práctica 1: ” ) ;

p1 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota del examen parcial: ” ) ;
ep = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la nota del examen final: ” ) ;
ef = Lectura.leerDouble( ) ;
notaMenor = Math.min (p1,p2) ;

notaMenor = Math.min (notaMenor,p3) ;
notaMenor = Math.min (notaMenor,p4) ;
pp = ( p1 + p2 + p3 + p4 – notaMenor ) / 3 ;
pf = ( pp + ep + ef ) / 3 ;
pf = Math.round (pf) ;
System.out.println ( “ El promedio final del alumno es: ” + pf ) ;

System.out.println ( “ Desea continuar (si=s/ no=n)?: ” ) ;
opc=Lectura.leerChar( ) ;
} while ( opc=='s' || opc=='S' ) ;
}
}
Modificar la codificación de la solución de tal forma que se elimine la práctica con la nota más baja y se
duplique la nota de la práctica más alta. Muestre el promedio de las notas redondeado a dos decimales.
Problema 184
Desarrollar un programa en Java que permita ingresar seis números a tráves del teclado. Determinar
y mostrar cuál de ellos es el número mayor y menor.
Clase PrgRedondearNumero
class PrgRedondearNumero {

double numero ;
System.out.println ( “ Ingrese un número con decimales: ” ) ;

numero=Lectura.leerDouble( ) ;
System.out.println ( “ -----------------------------------” ) ;
System.out.println ( “ La parte entera del número es: ” ) ;
System.out.println ( Math.floor (numero) ) ;
System.out.println ( “ El número redondeado es: ” ) ;

System.out.println ( Math.floor (numero+0.5) ) ;
System.out.println ( “ El número redondeado a un decimal es: ” ) ;

System.out.println ( Math.floor (numero * 10 + 0.5 ) / 10 ) ;
System.out.println ( “ El número redondeado a dos decimales es: ” ) ;

System.out.println ( “ El número redondeado a tres decimales es: ” ) ;

}
}
Observe el uso del método floor ( ) de la clase Math:
El método floor ( ) retorna un valor double con el valor más grande no mayor que el parámetro dado,
el cual debe ser double. Nótese que si ingresamos un número cuya parte decimal es mayor que 5,
solo retorna la parte entera. Para tal caso se le agrega 0.5, para que en el segundo cálculo tenga
efecto de redondeo perfecto. Nótese cómo se redondea un número con uno, dos y tres decimales
utilizando el método floor ( ).
Problema 185
Desarrollar un programa en Java que permita realizar un sorteo en base a un número determinado
de boletos.
||Sugerencia: Utilice el método random ( ) de la clase Math para generar el número del boleto
ganador.

Clase PrgSorteo
class PrgSorteo {

double num ;
int boletos, ganador ;
do {
System.out.println ( “ Ingrese el total de boletos: ” ) ;

boletos = Lectura.leerInt( ) ;
if (boletos > 0) {
do {
num = boletos * Math.random( ) ;

ganador = (int) Math.round(num) ;
} while (ganador == 0) ;
System.out.println (“ El número ganador es:” + ganador);

}
} while ( boletos < 0 ) ;

}
}
Problema 186
Desarrollar un programa en Java que permita calcular la suma de cuadrados y la suma de cubos
de los “n” primeros números. Se deberá ingresar un número por teclado y mostrar los resultados.
Clase PrgSumaCuadradosCubos
class PrgSumaCuadradosCubos {
long num, sumaCuad = 0, sumaCubos = 0 ;
System.out.println ( “ Ingrese un numero cualquiera: ” ) ;

num = Lectura.leerLong( ) ;
for ( int i=1; i <= num; i++ ) {
sumaCuad += Math.pow (i,2) ;

sumaCubos += Math.pow (i,3) ;
}
System.out.print (“ La suma de cuadrados de 1 hasta ” + num + “ es:”);

System.out.println ( sumaCuad ) ;
System.out.print ( “ La suma de cubos de 1 hasta ” + num + “ es: ”);

System.out.println ( sumaCubos ) ;
}
}
Problema 187
Desarrollar un programa en Java que permita ingresar un ángulo no mayor de 360, grados ni menor
de 0 grados. Mostrar como resultado el seno y el coseno del ángulo ingresado.
Clase PrgSenCos
class PrgSenCos {
double anguloGrados, anguloRadianes, seno = 0, coseno = 0 ;
do{
System.out.println (“Ingrese un ángulo en grados entre 0 y 360:”);

if (anguloGrados < 0 || anguloGrados > 360 ){
System.out.println (“El dato ingresado es incorrecto, intente otra vez:”);

}
}while(anguloGrados < 0 || anguloGrados > 360) ;
anguloRadianes = Math.toRadians( anguloGrados ) ;
seno = Math.sin( anguloRadianes ) ;

coseno = Math.cos( anguloRadianes ) ;
System.out.println ( “ El sen [” + anguloGrados + “ ] = ” + seno ) ;

System.out.println ( “ y el cos [” + anguloGrados + “ ] = ” + coseno) ;
}
}
Observe el uso de los métodos toRadians ( ), sin ( ) y cos ( ) de la clase Math:
Es importante mencionar que Java trabaja con el sistema radial, y para obtener las razones
trigonométricas seno y coseno de un ángulo ingresado por teclado, hay que convertirlo primero al
sistema radial. Para esto, utilizamos el método toRadians ( ) de la clase Math. Este método retorna
un valor double y permite convertir un ángulo expresado en el sistema sexagesimal (enviado como
parámetro double) en un ángulo expresado en radianes. Cuando el ángulo está convertido en
radianes, podemos utilizar los métodos sin ( ) y cos ( ) de la clase Math, para obtener el seno y el
coseno del ángulo ingresado por teclado.
Problema 188
Desarrollar un programa en Java que permita ingresar un ángulo de inclinación de la recta con
respecto al eje x. Mostrar como resultado la pendiente de la recta.

Clase PrgTangente
class PrgTangente {
double anguloGrados, anguloRadianes, tangente = 0 ;
System.out.println ( “ Ingrese ángulo de inclinación de la recta: ” ) ;

anguloRadianes = Math.toRadians(anguloGrados) ;
tangente = Math.tan(anguloRadianes) ;
System.out.println ( “ La pendiente de la resta es = ” + tangente ) ;
}
}
Observe el uso del método tan ( ) de la clase Math:
El método tan ( ) permite hallar la pendiente de una recta con respecto al eje X. Para ello utiliza el ángulo de
inclinación de la recta, expresado en el sistema radial, tal y como se muestra:
tangente = Math.tan(anguloRadianes) ;
Problema 189
Desarrollar un programa en Java que permita ingresar los catetos de un triángulo perpendicular.
Calcular y mostrar la hipotenusa del triángulo.

Clase PrgHipotenusa
class PrgHipotenusa {
double cateto1, cateto2, hipotenusa ;
System.out.println ( “ Ingrese el primer cateto: ” ) ;

cateto1 = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese el segundo cateto: ”) ;

cateto2 = Lectura.leerDouble( ) ;
hipotenusa = Math.sqrt ( Math.pow (cateto1, 2) + Math.pow (cateto2, 2));
System.out.println ( “ La hipotenusa del triángulo es: ” + hipotenusa);
}
}
La fórmula para este caso sería: (hipotenusa)2 = (cateto1)2 + (cateto2)2 . Se ingresan los catetos por
el teclado y son elevados al cuadrado con Math.pow( ). El resultado obtenido al elevar al cuadrado
cada uno de los catetos, se suma. Luego se obtiene la raíz cuadrada con Math.sqrt( ) y finalmente
se muestra el resultado almacenado en la variable hipotenusa. Ejemplo:
Ingrese el primer cateto: 2

Ingrese el segundo cateto: 3
La hipotenusa del triángulo es: 3.605551275463989

Problema 190
Desarrollar un programa en Java que permita ingresar la ordenada y la abscisa de un punto. Calcular
y mostrar el ángulo de las coordenadas del punto en grados.

Clase PrgPunto
class PrgPunto {
double ordenada, abscisa, anguloGrados, anguloRadianes ;
System.out.println ( “ Ingrese la ordenada(y) del punto: ” ) ;

ordenada = Lectura.leerDouble( ) ;
System.out.println ( “ Ingrese la abscisa(x) del punto: ” ) ;

abscisa = Lectura.leerDouble( ) ;
anguloRadianes = Math.atan2(ordenada, abscisa) ;

anguloGrados = Math.toDegrees(anguloRadianes) ;
System.out.print ( “ El ángulo en grados de [” + ordenada + “,” ) ;

System.out.println ( abscisa + “] es: ” + anguloGrados) ;
}
}
Observe el uso de los métodos atan2 ( ) y toDegress ( ) de la clase Math:
anguloRadianes = Math.atan2(ordenada, abscisa) ;

anguloGrados = Math.toDegrees(anguloRadianes) ;
Sabemos que Math.atan ( ) retorna un valor double con el arcotangente de un ángulo expresado
en radianes. Dicho ángulo expresado en radianes debe ser un valor double enviado al método como
parámetro.
En este caso, se ingresan por teclado la ordenada y la abcisa de un punto cualquiera en el sistema de
coordenadas, por lo que el método atan ( ) de la clase Math no nos serviría (este método necesita
el valor de un ángulo expresado en radianes y no los valores de las coordenadas de un punto).
En este caso, se utiliza el método atan2 ( ) de la clase Math. Este método nos permite obtener el
valor del arcotangente de un par ordenado.
Es importante mencionar que el método atan2 ( ) nos devuelve el arcotangente de un ángulo

expresado en radianes, por lo cual dicho ángulo se tendrá que convertir al sistema sexagesimal,
utilizando el método toDegrees ( ) de la clase Math.
Problema 191
Desarrollar un programa en Java que permita ingresar un número cualquiera. Calcular y mostrar el
número “e” elevado al número ingresado, y el logaritmo natural (de base e) del número ingresado.

Clase PrgExpLog
class PrgExpLog {
double num, exponencial, logaritmo ;
System.out.println ( “ Ingrese un número: ” ) ;

num=Lectura.leerDouble();
exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;
System.out.print ( “ El valor del número [e] elevado a [” + num ) ;

System.out.println ( “] es: ” + exponencial ) ;
System.out.print (“ El valor del logaritmo [en base e] del número [”) ;

System.out.println ( num + “] es: ” + logaritmo) ;
}
}
Observe el uso de los métodos exp ( ) y log ( ) de la clase Math:
exponencial = Math.exp(num) ;
logaritmo = Math.log(num) ;
En esta solución se hace necesario el uso del método exp ( ) para obtener el número e elevado al
número ingresado por teclado:
enum
También se hace necesario el uso del método log ( ) para obtener el logaritmo natural del número
ingresado en base e:
logenum
Tenga presente que Java solo resuelve logaritmos en base e y no en base 10.
A continuación se presentan algunas soluciones de problemas, utilizando básicamente el método

random ( ) de la clase Math, desarrollados con la finalidad de mejorar su comprensión del tema y sus
capacidades lógicas.
Analizar cada una de las soluciones y desarrolle sus propias conclusiones.
Problema 192
Un jugador lanza dos dados, cada uno de los cuales tiene seis caras, las caras contienen 1, 2, 3, 4 ,5 y
6 puntos. Una vez que los dados quedan en reposo, se suman los puntos de las dos caras que quedan
hacia arriba. Si la suma es 7 u 11 en el primer lanzamiento, el jugador gana. Si la suma es 2, 3 o 12 en
el primer lanzamiento (resultado que en los casinos reciben el nombre de “craps”), el jugador pierde
(es decir, la casa gana). Si la suma es 4, 5, 6, 8, 9, 10 en el primer lanzamiento, esta suma se convierte
en el punto del jugador. Para ganar, el jugador debe seguir tirando los dados hasta “lograr su punto”.
El jugador perderá si tira un 7 antes de lograr su punto.

Clase PrgLanzarDados1
class PrgLanzarDados1 {

int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ;
String opc1 = “ ”, opc2 = “ ” ;
do {
System.out.println ( “Lanzar dados” ) ;

Lectura.leerString ( ) ;
dado1 = ( int ) (1 + ( Math.random ( ) * 6 ) ) ;

suma1 = dado1 + dado2 ;
System.out.println ( “Dado1 : ” + dado1 ) ;

if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;
} else
if ( suma1 == 2 || suma1 == 3 || suma1 == 12 ) {
opc1 = “s” ;
estado = 0 ;
} else {
do {


if ( suma1 == suma2 ) {
estado = 1 ;
opc1 = “s” ;
opc2 = “s” ;
} else
if ( suma2 == 7 ) {
estado = 0 ;
opc1 = “s” ;
opc2 = “s” ;
}
} while ( opc2 != “s” ) ;
}
}while ( opc1 != “s” ) ;
if ( estado == 1 )
System.out.println ( “El jugador gana” ) ;
else
System.out.println ( “El jugador pierde ” ) ;
}
}
Problema 193
Modificar el programa del problema anterior, de tal forma, que se muestre un mensaje preguntando
si desea volver a tirar los dados.
Clase PrgLanzarDados2
class PrgLanzarDados2 {

int dado1 = 0, dado2 = 0, suma1 = 0, suma2 = 0, estado = 0 ;

String opc1 = “ ”, opc2 = “ ” ;
char opc3 = ‘n’ ;
do {
opc1 = “ ” ;
opc2 = “ ” ;
do {



if ( suma1 == 7 || suma1 == 11 ) {
opc1 = “s” ;
estado = 1 ;
} else
if (suma1 == 2 || suma1 == 3 || suma1 == 12) {
opc1 = “s” ;
estado = 0 ;
} else {
do {
System.out.println (“Lanzar dados”);
dado1=(int)(1+(Math.random ()*6 ));

dado2=(int)(1+(Math.random ()*6 ));

if ( suma1 == suma2 ) {
estado = 1 ;
opc1 = “s” ;
opc2 = “s” ;
} else
if ( suma2 == 7 ) {
estado = 0 ;
opc1 = “s” ;
opc2 = “s” ;
}
} while ( opc2 != “s” ) ;
}
} while ( opc1 != “s” ) ;
if ( estado == 1 )
System.out.println ( “ El jugador gana ” ) ;
else
System.out.println ( “ El jugador pierde ” ) ;
System.out.println ( “Desea volver a jugar [s/n] ” ) ;
opc3 = Lectura.leerChar ( ) ;
} while ( opc3 != ‘n’ ) ;
}
}
Problema 194
Elaborar un programa que simule el lanzamiento de una moneda. Solicitar el número de veces que
se lanzará la moneda, contar el número de veces que aparece cada lado de la moneda y mostrar
los resultados.
Clase PrgLanzarMoneda
class PrgLanzarMoneda {
int moneda, cont1 = 0, cont2 = 0, cant ;
System.out.println ( “Cuántas veces desea Lanzar moneda ? ” ) ;

for ( int x = 1; x <= cant; x++ ) {
moneda = ( int ) (1 + ( Math.random ( ) * 2 ) ) ;
if (moneda == 1)
cont1 ++ ;
else
cont2 ++ ;
System.out.println ( “La cantidad de veces que a salido la cara es : ”

+ cont1 ) ;
System.out.println ( “La cantidad de veces que a salido el sello es :
” + cont2 ) ;
}
}
Problema 195
Elaborar un programa que simule el juego de tragamonedas, las opciones para ganar son los
números: 1, 2, 3, 4, 5 ,6 y 7. El jugador gana cuando el número se repita tres veces. Los números
deberán ser generados aleatoriamente. El premio mayor se obtiene con el número 7.

Clase PrgTragamoneda1
class PrgTragamoneda1 {
int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0 ;

char s, opc1 ;
do {
System.out.println( “Presionar enter para empezar” ) ;

valor1 = ( int ) (1 + ( Math.random ( ) * 7 ) ) ;

System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ;
if ( valor1 == valor2 && valor1 == valor3 ) {
s = (char) valor1 ;
switch (s) {
case 1 :
monto = 100 ;
break ;
case 2 :
monto = 200 ;
break ;
case 3 :
monto = 300 ;
break ;
case 4 :
monto = 400 ;
break ;
case 5 :
monto = 500 ;
break ;
case 6 :
monto = 600 ;
break ;
case 7 :
monto = 1000 ;
break ;
}
System.out.println ( “Usted gana : ” + monto + “Soles ” ) ;

} else
System.out.println ( “La casa gana” ) ;
monto = 0 ;
System.out.println ( “Desea volver a jugador [s/n] : ” ) ;
} while ( opc1 != ‘n’ ) ;

}
}
Problema 196
Modificar el programa del problema anterior, de tal forma que se muestre la cantidad acumulada
del dinero ganado en el tragamoneda.
Clase PrgTragamoneda2
class PrgTragamoneda2 {
int valor1 = 0, valor2 = 0, valor3 = 0, monto = 0, acumonto = 0 ;

char s,opc1 ;
do {
System.out.println ( “Presionar enter para empezar” ) ;

valor1=( int ) (1 + ( Math.random ( ) * 7 ) ) ;

System.out.println ( valor1 + “ ” + valor2 + “ ” + valor3 ) ;
if ( valor1 == valor2 && valor1 == valor3 ) {
s= (char) valor1 ;
switch ( s ) {
case 1 :
monto=100 ;
break ;
case 2 :
monto=200 ;
break ;
case 3 :
monto=300 ;
break ;
case 4 :
monto=400 ;
break ;
case 5 :
monto=500 ;
break ;
case 6 :
monto=600 ;
break ;
case 7 :
monto=1000 ;
break ;
}
acumonto = acumonto + monto ;

System.out.println ( “Usted gana :” + monto );
System.out.println (“El dinero acumulado ganado es:”+acumonto);
} else
System.out.println ( “La casa gana” ) ;
monto = 0 ;
System.out.println ( “Desea volver a jugador [s/n] : ” ) ;
opc1=Lectura.leerChar ( ) ;
} while ( opc1! = ‘n’ ) ;

}
}
Problema 197
Las computadoras están desempeñando un papel cada vez más importante en la educación.
Desarrolle un programa que ayude a un estudiante de primaria a aprender a multiplicar. Utilice

números aleatorios para producir dos enteros positivos de un solo dígito. El programa deberá
preguntar: ¿Cuánto es 6 por 7? El estudiante deberá ingresar la respuesta. El programa verificará si
la respuesta es correcta. Si es correcta mostrará un mensaje: ¡Muy bien! y si es incorrecto mostrará
el mensaje: ¡No es correcto, por favor intente otra vez!
Clase PrgMultiplicacion
class PrgMultiplicacion {

int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ;

char s, opc1 ;
do {
System.out.println ( “Aprendiendo a Multiplicar” ) ;
valor1 = ( int ) (1 + ( Math.random() * 9 ) ) ;

valor2 = ( int ) (1 + ( Math.random() * 9 ) ) ;
resul1 = valor1 * valor2 ;
System.out.println (“¿Cuánto es ” + valor1 + “por” + valor2 + “?”);

System.out.println ( “Ingresar resultado de la multiplicación :”) ;
resul2 = Lectura.leerInt ( ) ;
if ( resul1 == resul2 )
System.out.println ( “Respuesta correcta… Muy bien” ) ;
else
System.out.println (“No es la respuesta correcta… Vuelva a
intentarlo”);
System.out.println ( “Desea volver a intentarlo [s/n] : ” ) ;

} while ( opc1 != ‘n’ ) ;

}
}
Problema 198
Modificar el programa del problema anterior, de tal forma que se muestre un menú de opciones
que permita sumar, restar, multiplicar y dividir dos números generados al azar. El estudiante podrá
contestar la misma pregunta ilimitadamente hasta que responda correctamente.
Clase PrgMenuOperaciones1
class PrgMenuOperaciones1 {
int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0, op ;

String operacion = “ ” ;
char opc, signo = ‘ ’ ;
do {
System.out.println ( “Menú de operaciones” ) ;

System.out.println ( “-----------------------------” ) ;
System.out.println ( “[1] Sumar ” ) ;
System.out.println ( “[2] Restar ” ) ;
System.out.println ( “[3] Multiplicar ” ) ;
System.out.println ( “[4] Dividir ” ) ;
System.out.println ( “[5] Salir ” ) ;
System.out.println ( “Elegir opcion : ” ) ;

op=Lectura.leerInt ( ) ;

switch ( op ) {
case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;
case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
operacion = “Multiplicación” ;
signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;
signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}
System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” +

valor2 + “ ? ” ) ;
do {
System.out.println ( “Ingresar resultado de la ” + operacion + “ :”);

resul2 = Lectura.leerInt ( );
if ( resul1 != resul2 )
System.out.println (“No es, por favor trata otra vez”);
} while ( resul1 != resul2 ) ;

System.out.println ( “Muy bien” ) ;
} while ( op != 5 ) ;
}
}
Problema 199
Modificar el programa del problema anterior, de tal forma que se muestre un menú de opciones que
permita sumar, restar, multiplicar y dividir dos números al azar. Mostrar la cantidad de preguntas
correctas y la cantidad de preguntas incorrectas.

Clase PrgMenuOperaciones2
class PrgMenuOperaciones2 {
int valor1 = 0, valor2 = 0, resul1 = 0, resul2 = 0 ;

int op, cont1 = 0, cont2 = 0 ;
String operacion = “ ” ;
char opc, signo = ‘ ’ ;
do {
System.out.println ( “Menú de operaciones” ) ;

System.out.println ( “-----------------------------” ) ;
System.out.println ( “[1] Sumar ” ) ;
System.out.println ( “[2] Restar ” ) ;
System.out.println ( “[3] Multiplicar ” ) ;
System.out.println ( “[4] Dividir ” ) ;
System.out.println ( “[5] Salir ” ) ;
System.out.println ( “Elegir opcion : ” ) ;

op = Lectura.leerInt ( ) ;

switch ( op ) {
case 1 :
resul1 = valor1 + valor2 ;
operacion = “Suma” ;
signo = ‘+’ ;
break ;
case 2 :
resul1 = valor1 - valor2 ;
operacion = “Resta” ;
signo = ‘-’ ;
break ;
case 3 :
operacion = “Multiplicación” ;
signo = ‘*’ ;
break ;
case 4 :
resul1 = valor1 / valor2 ;
operacion = “División” ;
signo = ‘/’ ;
break ;
case 5 :
System.exit (0) ;
break ;
}
System.out.println ( “¿Cuánto es ” + valor1 + “ ” + signo + “ ” + valor2 +

“ ?” ) ;
System.out.println ( “Ingresar resultado de la ” + operacion + “: ” ) ;

resul2 = Lectura.leerInt ( ) ;
if ( resul1 != resul2 ) {
System.out.println ( “No es, por favor trata otra vez” ) ;
cont1 ++ ;
} else {
System.out.println ( “Muy bien” ) ;
cont2 ++ ;
}
} while ( op != 5 ) ;
System.out.println ( “La cantidad de respuesta correctas fueron : ” + cont1 ) ;

System.out.println ( “La cantidad de respuestas incorrectas fueron : ” +cont2);
}
}
Problema 200
Elaborar un programa que permita adivinar cuál es el número entero generado al azar entre 1 y
1000. El jugador ingresará una primera estimación; si es incorrecta, el programa deberá indicar
si el número ingresado fue mayor o menor al número generado al azar. Cuando la respuesta sea
correcta, se mostrará el mensaje de felicitaciones.
Clase PrgAdivinarNumero1
class PrgAdivinarNumero1 {

int valor = 0, num = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;
do {
System.out.println ( “Ingresar número : ” ) ;
if ( num < valor )
System.out.println ( “Número muy pequeño.Intente otra vez”) ;
else
if ( num > valor )
System.out.println (“Numero muy grande.Intente otra vez”);
else
System.out.println (“Felicidades adivinaste el número ”);
} while (num != valor ) ;

System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc = Lectura.leerChar ( ) ;
} while ( opc != ‘n’ ) ;

}
}
Problema 201
Modificar el programa del problema anterior, de tal forma que se pueda ingresar la cantidad de
intentos que se tiene para adivinar el número.

Clase PrgAdivinarNumero2
Import biblioteca.* ;
class PrgAdivinarNumero2 {
int valor = 0, num = 0, intentos, cont = 0 ;

char opc = ‘ ’ ;
do {
System.out.println ( “Adivine el número” ) ;
System.out.println ( “Ingrese la cantidad de intentos : ” ) ;
intentos=Lectura.leerInt ( ) ;
valor = ( int ) (1 + ( Math.random ( ) * 1000 ) ) ;
do {
System.out.println ( “Ingresar número : ” ) ;
if (cont >= intentos ) {
System.out.println (“Deberías haberlo hecho mejor”) ;

valor = num ;
}
else if ( num < valor )
System.out.println (“Número pequeño.Intente otra vez”);
else if ( num > valor )

System.out.println ( “Número muy grande.Intente otra vez”);
else
System.out.println (“Felicidades adivinaste el número”);
cont ++ ;
} while ( num != valor ) ;
System.out.println ( “Desea Continuar [s/n]: ” ) ;
opc=Lectura.leerChar ( ) ;
} while ( opc != ‘n’ ) ;
}
}
manEjO dE CadEnas: ClasE sTRing
Introducción
Una cadena es un conjunto de caracteres, números y símbolos especiales almacenados en una

variable de tipo texto o cadena.
La clase String es una clase que viene incorporada en el lenguaje de programación Java, incluida
en el paquete java.lang, la cual 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).
Ejemplo:
String nom = “Danae” ;
JERARQUÍA DE CLASES Y HERENCIA
java.lang.Object
java.lang.Object
El paquete java.lang es el paquete principal del lenguaje Java, por lo cual no se necesita importar
ninguna clase incluida en dicho paquete. En consecuencia, no será necesario importar el paquete
java.lang cada vez que se necesite utilizar la clase String de Java.
La clase String permite manipular las variables de tipo texto o cadena a través de los métodos que
implementa (la clase String tiene métodos de instancia y métodos de clase). La clase String incluye
métodos que permiten examinar los caracteres individuales de una cadena para compararlos,
ubicarlos o extraerlos como subcadenas y para crear copias de una cadena convirtiendo todos sus
caracteres en letra mayúscula o minúscula.
Las conversiones son realizadas a través del método toString ( ), método definido en la clase Object,
el cual puede ser utilizado por todas las clases Java a través de la herencia.
Métodos
La clase String presenta los siguientes métodos:
A. Métodos de instancia:
1.- charAt( ).
2.- compareTo( ).
3.- concat( ).
4.- endsWith( ).
5.- equals( ).
6.- equalsIgnoreCase( ).
7.- indexOf( ).
8.- lastIndexOf( ).
9.- length( ).
10.- matches().
11.- replace( ).
12.- split( ).
13.- startsWith( ).
14.- substring( ).
15.- toCharArray( ).
16.- toLowerCase( ).
17.- trim( ).
18.- toUpperCase( ).
B. Métodos de clase:
19.- valueOf( ).
Para trabajar con los métodos de instancia de la clase String, es necesario previamente haber
declarado y asignado un valor a una variable de tipo texto o cadena. Para el caso de los métodos de
clase esto no será necesario.
Para ejecutar un método de instancia de la clase String es necesario colocar el nombre de la variable
(que debe ser de tipo texto o cadena), el operador punto (.) y el nombre del método de instancia que
se desea ejecutar. Para el caso de los métodos de clase deberá colocar la palabra String, el operador
punto (.) y el nombre del método de clase que se desea ejecutar.
Asimismo, para ejecutar cualquiera de los métodos de la clase String, se debe tener en cuenta que si
el método necesita algunos datos, estos deben ser necesariamente proporcionados en la cantidad y
tipos requeridos. En caso de que el método devuelva un resultado, este deberá almacenarse en una
variable del mismo tipo o mostrarse a través de la pantalla.
A continuación, se presenta una breve descripción del uso de cada uno de los métodos de la clase
String:
CLASE String

INSTANCIA
Devuelve el carácter que encuentre
en la posición indicada por la variable
String cad1 = “Hola Danae”;
entera o número entero colocado
char x = cad1.charAt(5);
como parámetro.
charAt(int)
Es importante mencionar que en Java,
resultado:
el primer carácter de una cadena se
x = ‘D’.
encuentra ubicado en la posición 0
(cero).
Si la cadena es alfabéticamente
menor que la cadena colocada como
parámetro, el método devuelve un String cad1 = “Hola Danae”;
número entero menor que cero. Si String cad2 = “Hola Pedro”;
las dos cadenas son alfabéticamente int x = cad1.compareTo(cad2);
compareTo(String)
iguales devuelve un número cero,
y si la cadena es alfabéticmente Resultado:
mayor que la cadena colocada como x < 0 (cad1<cad2).
parámetro, el método devuelve un
número entero mayor que cero.
String cad1, cad2, cadena;

cad1 = "Hola";
cad2 = " a todos";
Este método permite juntar dos
concat(String) cadena = cad1.concat (cad2);
cadenas en una sola cadena.
Resultado:
cadena = "Hola a todos”

String cad2 = “Danae”;
Devuelve true (verdadero) si el final
boolean x = cad1.
de la cadena coincide con la cadena
endsWith(String) endsWith(cad2);
colocada como parámetro. Caso
contrario, devuelve false (falso).
Resultado:
x = true.

Devuelve true (verdadero) si la cadena String cad2 = “Danae”;
coincide con la cadena colocada boolean x = cad1.equals(cad2);
equals(String)
como parámetro. En caso contrario,
devuelve false (falso). Resultado:
x = true.

INSTANCIA
String cad1 = “DANAE”;

Este método realiza la misma función
boolean x;
que el método equals ( ), pero la
x = cad1.
equalsIgnoreCase(String) comparación la realiza sin tener
equalsIgnoreCase(cad2);
en cuenta las letras minúsculas o
mayúsculas.
Resultado:
x = true.

int x = cad1.indexOf(‘D’);
indexOf(char)
Resultado:
x = 5.

int x = cad1.indexOf(‘a’,6);
indexOf(char,int) Devuelve la posición de la cadena
en la que aparece por primera vez el Resultado:
carácter colocado como parámetro. x = 8.
También se puede especificar un
segundo parámetro, a partir del cual String cad1 = “Hola Danae”;
se empieza a buscar hacia delante. int x = cad1.indexOf( “ana” );
indexOf(String)
Resultado:
x = 6.

int x = cad1.indexOf( “Dan”,3 );
indexOf(String, int)
Resultado:
x = 5.

int x = cad1.lastIndexOf(‘a’);
lastIndexOf(char)
Resultado:
x = 8.

int x = cad1.lastIndexOf(‘a’,5);
lastIndexOf(char,int)
Devuelve la posición de la cadena Resultado:
en la que aparece por última vez el x = 3.
carácter colocado como parámetro.
También se puede especificar un String cad1 = “Hola Danae”;
segundo parámetro, a partir del cual int x = cad1.lastIndexOf( “ana” );
lastIndexOf(String) se empieza a buscar hacia atrás.
Resultado:
x = 8.

int x = cad1.lastIndexOf( “lo”,5 );
lastIndexOf(String,int)
Resultado:
x = 2.

INSTANCIA

Devuelve la longitud de una cadena, int x = cad1.length();
length() es decir, el número de caracteres que
tiene la cadena. Resultado:
x = 10.
String nom = "Rodrigo Jose" ;

boolean x ;
Permite determinar si una cadena
x = nom.matches("[a-zA-Z ]*") ;
contiene solo los caracteres que
matches()
se han definido en un determinado
rango. Devuelve un valor lógico.
Resultado:
x = true.
Permite reemplazar todos los String cad1 = “Hola Danae”;

caracteres iguales al carácter String x = cad1.replace(‘a’, ‘o’);
replace(char,char) colocado como primer parámetro, con
el carácter colocado como segundo Resultado:
parámetro. x = “Holo Donoe”.
String nombre = "Rodrigo José”;

String[] palabras;
palabras = nombre.split(" ");
Permite separar una cadena en varias
subcadenas en base al separador
Split ()
indicado. Las subcadenas se
almacenan en un arreglo de cadenas.
Resultado:
palabras[0] = “Rodrigo”
palabras[1] = “José”

String cad2 = “Hola”;
Devuelve un valor true (verdadero) si
boolean x;
el comienzo de la cadena coincide con
startsWith(String) x = cad1.startsWith(cad2);
la cadena colocada como parámetro,
caso contrario devuelve false (falso).
Resultado:
x = true.

String x = cad1.substring(5);
substring(int)
Devuelve una subcadena a partir de
la cadena especificada, empezando Resultado:
desde la posición indicada en el x = “Danae”.
primer parámetro hasta el final o hasta
una posición anterior a la indicada en String cad1 = “Hola Danae”;
el segundo parámetro del método. String x = cad1.substring(6,9);
substring(int,int)
Resultado:
x = “ana”.

Convierte una cadena específica en char[ ] x = cad1.toCharArray();
toCharArray() un vector de caracteres. (Los vectores
serán tratados en el capítulo IV). Resultado:
x = {‘H’,‘o’,‘l’,‘a’,‘ ’, ‘D’, ‘a’, ‘n’, ‘a’,‘e’}.

INSTANCIA

String x = cad1.toLowerCase();
Convierte las letras de una cadena en
toLowerCase()
letras minúsculas.
Resultado:
x = “hola danae”.
String cad1 = “ Hola Danae ”;

Permite eliminar los espacios en String x = cad1.trim();
trim() blanco del inicio y del final de una
cadena. Resultado:
x = “Hola Danae”.

String x = cad1.toUpperCase();
Convierte las letras de una cadena en
toUpperCase()
letras mayúsculas.
Resultado:
x = “HOLA DANAE”.
MÉTODO DE CLASE DESCRIPCIÓN USO
String.valueOf(boolean)
String.valueOf(int)
double pi = 3.1416;
String.valueOf(long)
Método de clase que permite String x = String.valueOf(pi);
String.valueOf(float)
convertir los valores de otros tipos
String.valueOf(double)
de datos o variables a una cadena. resultado:
String.valueOf(Object)
x = “3.1416”.
String.valueOf(char[ ])
String.valueOf(char[ ], int,int)
A continuación, con la finalidad de mejorar la comprensión del tema tratado, se presentan algunas
soluciones de los problemas planteados, utilizando algunos de los métodos de la clase String. Analice
cada una de las siguientes soluciones:
Problema 202
Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el nombre
del alumno en letra mayúscula.
Clase PrgConvertirMayuscula
public class PrgConvertirMayuscula {
public static void main(String [ ] args) {
String nom ;
System.out.print ( “ Ingresar el nombre: ” ) ;

nom = Lectura.leerString( ) ;
nom = nom.toUpperCase( ) ;
System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;

}
}

Observe el uso del método toUpperCase ( ) de la clase String:
nom.toUpperCase ( ) ;
Nombre del método
Operador punto
Nombre de la variable (objeto)
El método toUpperCase ( ) se utiliza con variables de tipo String y permite convertir en letras
mayúsculas el contenido de la variable que antecede al nombre del método y al operador punto (en
nuestro caso la variable nom). Como el método toUpperCase ( ) devuelve un valor de tipo String (el
contenido de la variable en letra mayúscula), se puede mostrar el resultado utilizando System.out.
println o almacenarlo en una variable (que puede ser la variable que contenía la cadena original),
tal y como se ha realizado en el ejemplo:
nom = nom.toUpperCase ( ) ;
* Importante: Tener presente que el método toUpperCase ( ) solo se puede utilizar con variables de
tipo String y su función es convertir el contenido de una variable en letras mayúsculas.
Problema 203
del alumno en letras minúsculas.
Clase PrgConvertirMinuscula
public class PrgConvertirMinuscula {
String nom ;
System.out.print ( “ Ingresar el nombre: ” ) ;

nom = nom.toLowerCase( ) ;
System.out.println ( “ El nombre en Minúscula es: ” + nom ) ;

}
}
Observe el uso del método toLowerCase( ) de la clase String:

nom.toLowerCase ( ) ;
Nombre del método.
Operador punto.
Nombre de la variable (objeto).
El método toLowerCase ( ) se utiliza con variables de tipo String y permite convertir en letras
minúsculas el contenido de la variable que antecede al nombre del método y al operador punto
(en nuestro caso la variable nom). Como el método toLowerCase ( ) nos devuelve un valor de tipo
String (el contenido de la variable en letra minúscula), podemos mostrar el resultado utilizando
System.out.println o almacenarlo en una variable (que puede ser la variable que contenía la cadena
original), tal y como se ha realizado en el siguiente ejemplo:
nom = nom.toLowerCase ( ) ;
Es importante tener presente que el método toLowerCase ( ) es un método que solo podemos
utilizar con variables de tipo String, y su función es convertir el contenido de una variable en letras
minúsculas.
Problema 204
Desarrollar un programa en Java que permita ingresar el primer nombre y el segundo nombre de un
alumno. Concatenar y mostrar los nombres del alumno en letras mayúsculas y minúsculas.
Clase PrgConcatenarNombres
public class PrgConcatenarNombres {
String nom1, nom2, nombre, espacio = “ ” ;
System.out.println ( “ Ingresar el primer nombre del alumno: ” ) ;

nom1 = Lectura.leerString( ) ;
System.out.println ( “ Ingresar el segundo nombre del alumno: ” ) ;

nom1 = nom1.concat(espacio) ;
nombre = nom1.concat(nom2) ;
System.out.println (“ El nombre en Mayúscula es:”"+ nombre.toUpperCase());

System.out.println (“ El nombre en Minúscula es:”+ nombre.toLowerCase());
}
}
Observe el uso del método concat( ) de la clase String:
nom = nom.concat (espacio) ;
El método concat ( ) se utiliza para juntar o concatenar el contenido de dos variables de tipo String
(la misma función cumple el signo “+ “cuando trabaja con variables de tipo String). Es decir, el
contenido de la variable nom1 y el contenido de la variable espacio se juntan (o concatenan) y el
resultado se almacena en la variable que antecede al signo = (en nuestro caso la misma variable
nom1). Luego el contenido de la variable nom1 se junta con el contenido de la variable nom2 y el
resultado se almacena en la variable nombre.
nom1 = nom1.concat (espacio) ;

nombre = nom1.concat(nom2) ;
Esto permite concatenar los nombres del alumno con un espacio en blanco entre ellos, en una única
variable de tipo String.
También podría visualizarse directamente el resultado de concatenar dos variables de tipo String
(cadenas) utilizando System.out.println, como se muestra a continuación:
System.out.println (nom1.concat (nom2) ) ;
Finalmente, se utilizan los métodos toUpperCase( ) y toLowerCase ( ), explicados en los problemas

anteriores, directamente con System.out.println para mostrar el nombre del alumno en letra
minúscula y mayúscula.
Problema 205
Desarrollar un programa en Java que permita ingresar el nombre de un alumno, mostrar el número
de caracteres del nombre ingresado por teclado y consistenciar el nombre del alumno al momento
de ingresarlo.
Clase PrgLongitudCadena
public class PrgLongitudCadena {
int cant ;
String nom ;
do {
System.out.println ( “ Ingresar el nombre: ” ) ;
nom = nom.trim( ) ;
if ( nom.length( ) < 2 ) {
System.out.println (“ Nombre ingresado no válido… Reintente! ”);
}
} while (nom.length( ) < 2 ) ;
cant = nom.length( ) ;
System.out.println (“ La cantidad de caracteres del nombre es:” +cant);

}
}
Observe el uso del método trim( ) de la clase String:
nom = nom.trim ( ) ;
El método trim( ) permite eliminar los espacios en blanco que pueden existir al inicio y/o al final de
una cadena contenida en una variable (en nuestro caso la cadena contenida en la variable nom).
Esto se realiza como precaución porque el usuario podría presionar la barra espaciadora antes de
ingresar el nombre del alumno, y esto se almacena en la variable como espacios en blanco.
También observe el uso del método length ( ) de la clase String:
cant = nom.length ( ) ;
El método length ( ) se utiliza con variables de tipo String y nos permite contar la cantidad de
caracteres que almacena una variable (en nuestro caso, la cantidad de caracteres que almacena la
variable nom). Como el método length ( ) devuelve la cantidad de caracteres que tiene una variable
(incluidos los espacios en blanco), podemos mostrar el resultado utilizando System.out.println(),
utilizarlo en una condición lógica o almacenarlo en una variable. En el ejemplo se utiliza como
condición lógica y para almacenarlo en una variable.
En las líneas de código mostradas a continuación, se consistencia el ingreso del nombre, de tal
forma que no se permita ingresar un nombre que tenga menos de dos caracteres (se asume que
puede haber nombres de dos caracteres o más, como por ejemplo; Lu, Ana, José, Pedro; que tienen
2, 3, 4 y 5 caracteres respectivamente).
do {
nom = nom.trim ( ) ;
if ( nom.length ( ) < 2 ) {
System.out.println ( “Nombre ingresado no válido… Reintente! ” ) ;
}
} while (nom.length ( ) < 2) ;
Problema 206
del alumno en letras mayúsculas. Consistenciar el nombre del alumno al momento de ingresarlo.
Clase PrgConvertirMayuscula2
public class PrgConvertirMayuscula2 {

String nom ;
do {
nom = nom.trim( ) ;
System.out.println ( “ Nombre ingresado no válido… Reintente! ” ) ;
}
} while ( nom.length( ) < 2 ) ;
nom = nom.toUpperCase( ) ;
System.out.println ( “ El nombre en Mayúscula es: ” + nom ) ;
}
}
Observar el uso de los métodos trim ( ), length ( ) y toUpperCase ( ) de la clase String.
En la codificación de este programa se deben eliminar los espacios en blanco que la variable nom
pueda tener al inicio y al final del dato que contiene. Luego se consistencia que tenga por lo menos
dos caracteres. Después se convierte el contenido de la variable nom en letra mayúscula, para
finalmente mostrar su contenido en pantalla.
En consecuencia, se puede afirmar que esta solución es óptima en comparación con la presentada
en el problema 100.
Problema 207
Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer
carácter del nombre ingresado en mayúscula.
Clase PrgPrimeroMayuscula
public class PrgPrimeroMayuscula {
String nom, cadena1= “”, cadena2= “” ;
do {
nom = nom.trim( ) ;
}
cadena1 = nom.substring(0,1) ;
cadena1 = cadena1.toUpperCase( ) ;
cadena2 = nom.substring(1) ;
nom = cadena1.concat(cadena2) ;
System.out.println ( “ El nombre del alumno es: ” + nom ) ;

}
}
Observe el uso del método substring( ) de la clase String:
El método substring( ) se utiliza de dos formas. La primera forma nos permite obtener una subcadena
desde una posición inicial hasta un carácter antes de la posición final indicada. La segunda forma
nos permite obtener una subcadena desde una posición determinada hasta el final de la cadena.
Imagínese que la variable nom contiene el nombre “danae”, tal y como se muestra a continuación:
nom = “danae”.
Cuando manipulamos cadenas con el método substring( ) debemos tener en cuenta que cada
carácter de la cadena tiene una determinada posición, empezando por la posición cero (0).
nom = “danae”.
posición 0 (la letra "d")
Entonces, si se quiere obtener la primera letra de la cadena utilizamos la siguiente sentencia:
Donde, el primer número del método substring ( ) indica la posición de la cadena nom (desde el
inicio de la subcadena), y el segundo número indica la posición final de la cadena (es importante
mencionar que se debe incluir hasta un carácter antes de la posición final indicada). Esto nos permite
solo obtener el primer carácter de nom (la letra “d”).
Suponiendo que se quiere obtener la subcadena “ana” de la cadena “danae” contenida en la variable
nom, utilizaríamos la siguiente sentencia:
cadena1 = nom.substring (1,4) ;
Continuando con nuestro ejemplo, una vez obtenida la primera letra del nombre se convierte a
mayúscula, utilizando:
cadena1 = cadena1.toUpperCase ( ) ;
Ahora es necesario obtener el resto del contenido de la variable nom. Esto lo realizamos utilizando:
cadena2 = nom.substring (1) ;
Esta es la segunda forma de utilizar el método substring ( ), donde el número (en nuestro caso el
número 1) indica la posición de la cadena nom, donde va a comenzar la subcadena (la primera letra
“a”) hasta el final de la cadena.
Ahora en la variable cadena1 tenemos almacenada la letra “D” y en la variable cadena2 tenemos
almacenadas las letras “anae”. Para finalizar, solo será necesario concatenar ambas variables en la
variable original nom, utilizando el método concat ( ).
nom = cadena1.concat (cadena2) ;
El resultado que se obtiene es el nombre ingresado con la primera letra en mayúscula.

Problema 208
Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el primer
carácter del nombre ingresado en mayúscula y el resto en minúsculas.
Clase PrgMayusculaMinuscula
public class PrgMayusculaMinuscula {
int cant ;
String nom, cadena1 = “” , cadena2 = “” ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
}
cadena2 = cadena2.toLowerCase( ) ;
}
}
Observe el uso de los métodos trim ( ), length ( ), substring ( ) en sus dos formas, toUpperCase ( ),
toLowerCase ( ) y concat ( ) de la clase String.
En la codificación de este programa, se convierte en mayúscula la primera letra del nombre y el resto
se convierte en minúscula. Esto como precaución de que se ingrese todo el nombre en mayúscula,
o en forma combinada entre letras mayúsculas y minúsculas. Finalmente siempre el nombre tendrá
la primera letra en mayúscula y el resto en letra minúscula.
En consecuencia, se puede afirmar que esta solución es óptima en comparación con la presentada
en el problema 104.
Problema 209
Desarrollar un programa en Java que permita ingresar el nombre completo de un alumno (nombres
y apellidos en una sola variable). Mostrar el primer carácter de cada palabra del nombre en
mayúsculas y el resto de cada palabra en minúscula.
Clase PrgNombreCompleto
public class PrgNombreCompleto {

int cant ;
String nom, cadena1 = “”,cadena2 = “”, caracter ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) < 2) {
}
} while (nom.length( ) < 2) ;
for (int x=0; x<cant; x++) {
if ( x==0) {
} else {
caracter = nom.substring(x, x+1) ;
if (caracter.equals ( “ ” ) ) {
cadena1 = nom.substring(0,x+1) ;
caracter = nom.substring(x+1, x+2) ;
caracter = caracter.toUpperCase( );
cadena2 = nom.substring(x+2) ;
nom = cadena1 + caracter + cadena2 ;
}
}
}
}
}
Observe el uso del método equals( ) de la clase String:
if (caracter.equals (“ “)) { }
El método equals ( ) se utiliza con variables de tipo String y nos permite comparar el contenido
de dos cadenas (en nuestro caso la variable caracter con un espacio en blanco). Si al comparar el
contenido de las dos cadenas resulta que ambas variables son iguales, el método equals ( ) nos
devuelve un valor verdadero (true), en caso contrario nos devuelve un valor falso (false). Este valor
devuelto se evalúa en la estructura de decisión if.
Imagínese que la variable nom contiene el siguiente nombre:
nom = “danae alessandra flores bertolotti” ;
Nosotros desearíamos que la primera letra de cada nombre y apellido de un alumno estén en letra
mayúscula y el resto en minúsculas.
Al inicio utilizamos parte de la solución del problema 105. Después obtenemos carácter por carácter
y evaluamos si el carácter obtenido es un espacio en blanco. Si el carácter resulta ser un espacio
en blanco, entonces se almacena y se convierte en letra mayúscula, y la siguiente letra al espacio
en blanco. El siguiente esquema muestra cómo se debe almacenar parcialmente el nombre del
ejemplo en la variable nom.
Danae a lessandra flores bertolotti
cadena 1 carácter cadena 2
Después se concatenan las tres variables y se almacenan en la variable nom. El proceso se repite
hasta llegar al final de la cadena.
Ahora considere si entre los nombres existe más de un espacio en blanco. ¿Qué sucede? Modificando
la solución anterior para poder considerar la problemática, tendríamos la siguiente variación:
sw = false ;
for (int x=0; x<cant; x++) {
if (x==0) {
} else {
if (caracter.equals( “ ” ) ) {
,
sw = true ;
} else {
if (sw) {
cadena1 = nom.substring(0,x) ;
caracter = caracter.toUpperCase( );
cadena2 = nom.substring(x+1) ;
nom = cadena1 + caracter + cadena2 ;
sw = false ;
}
}
}
}
En esta parte modificada de la solución se utiliza un centinela (o flag), que nos permite indicar
el momento preciso para realizar la conversión de la primera letra del nombre o apellido a letra
mayúscula, sin preocuparnos de la cantidad de espacios en blanco que pueda existir entre dos
nombres.
Problema 210
Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en una
sola variable). Mostrar el número de caracteres blancos o espacios en blanco que existan.
Clase PrgLongitudCadenaBlanco
public class PrgLongitudCadenaBlanco {
int x,cant,cont=0 ;
String nom,caracter ;
do {
nom = nom.trim( ) ;
}
for (x=0;x<cant;x++) {
caracter = nom.substring(x,x+1) ;
cont ++ ;
}
}
System.out.println ( “ La cantidad de espacios: ” + cont ) ;
}
}
Observe el uso de los métodos trim ( ), length ( ), substring ( ) y equals ( ) de la clase String.
En la codificación de este programa, se evalúa carácter por carácter (de la variable nom). Si el carácter
es igual a un espacio en blanco (“ “), se le aumenta uno a la variable cont (que está trabajando como
contador de espacios encontrados en la variable nom).
Problema 211
Desarrollar un programa en Java que permita ingresar los apellidos y nombres de un obrero (en
una sola variable). Mostrar el número de caracteres del nombre ingresado por teclado que no sean
espacios en blanco.
Clase PrgLongitudCadenaNoBlanco
public class PrgLongitudCadenaNoBlanco {

int cant,x;
String nom, cadena = “”, caracter ;
do {
nom = nom.trim( ) ;
System.out.println (“Nombre ingresado no válido… Reintente!”);
}
for (x=0; x<cant; x++) {
if ( !caracter.equals ( “ ” ) ) {
cadena = cadena.concat(caracter) ;
}
}
cant = cadena.length( ) ;
System.out.println ( “ La cantidad de caracteres sin contar espacios: ”+cant);
}
}
En la codificación de este programa, se evalúa carácter por carácter (de la variable nom). Si el
carácter no es un espacio en blanco, se concatena con los caracteres de la variable cadena (al inicio
no contiene ningún carácter). Al final se obtiene la longitud de la variable cadena, que equivale a la
cantidad de caracteres de la variable nom, diferentes a espacios en blanco.
Problema 212
Desarrollar una solución que permita ingresar los apellidos y nombres de un obrero (en una sola
variable). Mostrar el número de caracteres que no son espacios en blanco y el número de caracteres
que son espacios en blanco.
Clase PrgLongitudCadenaBlancoNoBlanco
public class PrgLongitudCadenaBlancoNoBlanco {
int x, cant, cont = 0 ;

String nom, caracter ;
do {
nom = nom.trim( ) ;
}
fo r(x=0; x<cant; x++) {

cont ++ ;
}
}
System.out.println (“ La cantidad de espacios: ” + cont ) ;

System.out.println (“ La cantidad de caracteres sin contar espacios:”+
(cant - cont ) ) ;
}
}
En la codificación de este programa se emplea la misma estrategia que la utilizada en la solución del
problema 108, para obtener el número de espacios en blanco contenidos en la variable nom. Al final
se obtiene la longitud total de la cadena nom y realizando una simple resta se obtiene el número de
caracteres de la variable nom que no son espacios en blanco.
Problema 213
Desarrollar una solución que permita ingresar el nombre de un alumno. Mostrar el número de
vocales que hay en el nombre ingresado.
Clase PrgTotalVocales1
public class PrgTotalVocales1 {
int cant, cont = 0, d = 0, x ;

String nom ;
char c = ‘ ’ ;
do {
nom = nom.trim( ) ;
if ( nom.length( ) == 0 ) {
}
} while (nom.length( ) == 0 ) ;

c = nom.charAt(x) ;
d = (int) (c) ;
switch (c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println ( “ El Total de Vocales es: ” + cont ) ;
}
}
Observe el uso del método charAt( ) de la clase String:
nom.charAt (x) ;
El método charAt( ) se utiliza con variables de tipo String y nos permite obtener un carácter de
una cadena. En nuestro caso, obtenemos un carácter de la variable nom y lo almacenamos en una
variable de tipo char (el método charAt ( ) devuelve un carácter).
c = nom.charAt (x) ;
El carácter obtenido es evaluado para determinar si es o no una vocal. Esta evaluación se realiza a
través de los códigos ASC correspondientes a las vocales (Importante: la evaluación de una variable
de tipo char se puede realizar utilizando los códigos ASC equivalentes a los caracteres especiales,
letras y números).
Antes de iniciar la evaluación de cada uno de los caracteres de la variable nom, se utiliza el método
toLowerCase ( ) para asegurarnos de convertir a letras minúsculas todos los caracteres de la variable
nom, y luego utilizar los códigos ASC equivalentes a las vocales en minúscula.
Modifique la solución anterior de tal forma que pueda determinar cuántas vocales almacenadas en
la variable son; a, e, i, o y u (en forma independiente).
Problema 214
Desarrollar un programa en Java que permita ingresar el nombre de un alumno. Mostrar el número
de vocales y el número de caracteres que no son vocales, que hay en el nombre ingresado.

Clase PrgTotalVocalesNoVocales
public class PrgTotalVocalesNoVocales {
int cant, cont = 0 , d = 0 , x ;

String nom ;
char c = ‘ ’ ;
do {
nom = nom.trim( ) ;
System.out.println (“Nombre ingresado no válido… Reintente!”);
}
} while (nom.length( ) == 0 ) ;

c = nom.charAt(x) ;
d = (int) (c) ;
switch (c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println (“ El Total de Vocales es: ” + cont ) ;
System.out.println (“ El Total de caracteres que no son vocales es: ” +
(cant – cont) ) ;
}
}
Este programa es similar al programa desarrollado en el problema 111. La diferencia es que se

obtiene el total de caracteres que tiene la variable y se le resta el total de vocales para obtener el
total de caracteres que no sean vocales.
Modifique la solución anterior de tal forma que pueda determinar cuántas vocales almacenadas en
la variable nom son mayúsculas y cuántas son minúsculas. También, puede modificar la solución de
tal forma que permita determinar cuántas consonantes contiene la variable nom. Recuerde utilizar
los equivalentes en código ASC de las consonantes en letra minúscula o mayúscula.
Problema 215
Desarrollar un programa en Java que permita ingresar dos cadenas. Contar y mostrar cuántas veces
se repite la segunda cadena en la primera cadena ingresada.
Clase PrgCadenaSubcadena
public class PrgCadenaSubcadena {

String cad1, cad2, subcad ;
int total, i, cont = 0 ;
do {
System.out.println ( “ Ingresar una cadena: ” ) ;
cad1 = Lectura.leerString( ) ;
cad1 = cad1.trim( ) ;
if (cad1.length( ) == 0 ) {
System.out.println ( “ Cadena ingresada no válido... Reintente! ” ) ;
}
} while (cad1.length( ) == 0 ) ;
do {
System.out.println ( “ Ingresar una subcadena de la primera cadena: ” ) ;
cad2 = Lectura.leerString( ) ;
cad2 = cad2.trim( ) ;
if (cad2.length( ) == 0) {
System.out.println ( “ Cadena ingresada no válida... Reintente! ” ) ;
}
} while (cad2.length( ) == 0 ) ;
if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring (i, i + cad2.length( ) ) ;
if (cad2.equals(subcad) ) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” ) ;
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;
} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println (“la segunda cadena no debe tener una longitud”);
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}
}
}
La parte central de la solución radica en las siguientes líneas de código:
if (cad1.length( ) > cad2.length( ) ) {

total = cad1.length( ) - cad2.length( ) ;
for (i = 0; i <= total; i++) {
subcad = cad1.substring(i, i + cad2.length( ) ) ;
if (cad2.equals (subcad)) {
cont ++ ;
}
}
System.out.println ( “ El número de veces que se repite ” );
System.out.println ( “ la subcadena en la cadena es: ” + cont ) ;
} else {
if (cad1.equals (cad2) ) {
System.out.println ( “ las cadenas son iguales ” ) ;
} else {
System.out.println ( “ la segunda cadena no debe tener una longitud ” ) ;
System.out.println ( “ mayor que la primera cadena ” ) ;
}
}
En primer lugar, se verifica que la primera cadena (cad1) tenga una longitud mayor que la segunda
cadena (cad2). Luego, se obtiene la diferencia entre las longitudes de cad1 y cad2 y se almacena en
la variable total. El límite para la evaluación del número de veces que se repite cad2 en cad1, es el
carácter ubicado en la posición total de cad2.
Después, empezando desde el primer carácter de cad1 se extrae una subcadena (subcad) del mismo
tamaño que cad2 y se comparan para ver si son iguales utilizando el método equals ( ). Si son iguales
el contador cont aumenta en 1. Este proceso se repite utilizando el siguiente carácter de cad1.
Como ejemplo utilizaremos las siguientes cadenas:
cad1 = “Danae” cad2 = “ana”
En primer lugar determinamos que cad1 tiene una longitud mayor que cad2. Luego, calculamos el
valor de la variable total (total = 5-3 = 2).
El límite para la evaluación del número de veces que se repite cad2 en cad1 es el carácter ubicado
en la posición 2 de cad2.
cad1 = “Danae”
012
Observe que cad2 tiene una longitud=3

por lo que la última evaluación será:
Límite para la
evaluación
cad2 = “ana” y subcad= “nae”
Primera evaluación:
cad2 = “ana” y subcad = “Dan”
Resultado: falso.
Segunda evaluación:
cad2 = “ana” y subcad = “ana”
Resultado: verdadero (cont =1).
Tercera evaluación:
cad2 = “ana” y subcad = “nae” Finalmente, se concluye que cad2 se
Resultado: falso. repite una vez en cad1.
Problema 216
Desarrollar un programa en Java que permita ingresar el nombre de dos alumnos y mostrar si los
nombres ingresados son iguales o no.
Clase PrgNombresIguales
public class PrgNombresIguales {
String nom1, nom2 ;
do {
System.out.println ( “ Ingresar el nombre del primer alumno: ” ) ;
nom1 = nom1.trim( ) ;
if ( nom1.length( ) < 2 ) {
System.out.println("Nombre ingresado no válido… Reintente! ");
}
} while ( nom1.length( ) < 2 ) ;
do {
System.out.println ( “ Ingresar el nombre del segundo alumno: ” ) ;

nom2 = nom2.trim( ) ;
if ( nom2.length( ) < 2 ) {
}
} while ( nom2.length( ) < 2 ) ;
if ( nom1.equals (nom2) ) {
System.out.println ( “ Los nombres ingresados son iguales ” ) ;
} else {
System.out.println ( “ Los nombres ingresados son diferentes ” ) ;
}
}
}
Observe el uso de los métodos trim ( ), length ( ) y equals ( ) de la clase String.
Se comparan dos variables de tipo cadena (nom1 y nom2 respectivamente) y se determinan si ambas cadenas
son iguales o no.
Problema 217
Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos y mostrar los
nombres ordenados alfabéticamente.

Clase PrgOrdenados1
public class PrgOrdenados1 {
String nombre1, nombre2, nombreMayor, nombreMenor;
System.out.println ( “ Ingrese el nombre de una persona: ” ) ;

nombre1 = Lectura.leerString( ) ;
System.out.println ( “ Ingrese el nombre de otra persona: ” ) ;

if (nombre1.compareTo(nombre2) < 0 ) {
nombreMenor = nombre1 ;
nombreMayor = nombre2 ;
} else {
System.out.println ( “ ------------------------------------- ” ) ;
System.out.println ( “ Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “ ------------------------------------- ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}
Observe el uso del método compareTo ( ) de la clase String:
nombre1.compareTo (nombre2) ;
El método compareTo ( ) permite comparar dos variables de tipo String. El método compareTo (
) nos devuelve un valor entero. Si el valor devuelto es igual a cero (0), entonces las cadenas son
iguales; es decir, las variables nombre1 y nombre2 contiene cadenas iguales. Si el valor devuelto es
mayor que cero (0), entonces la variable nombre1 es mayor que la variable nombre2. Finalmente,
si el valor devuelto es menor que cero, entonces la variable nombre1 es menor que la variable
nombre2.
Cuando se comparan dos cadenas, se realiza una comparación alfabética en la cual tienen significado
las letras mayúsculas, las letras minúsculas, los caracteres especiales y los espacios en blanco.
Por ejemplo, comparemos las siguientes cadenas:
1. nombre1 = “Pedro” y nombre2 = “Luis”. nombre1>nombre2
2. nombre1 = “Danae” y nombre2 = “Danae”. nombre1 = nombre2
3. nombre1 = “Carmen” y nombre2 = “Juan”. nombre1<nombre2
En base a esto mejore la solución, de tal forma que se pueda realizar la consistencia de los nombres
ingresados.
Problema 218
Desarrollar un programa en Java que permita ingresar los nombres de dos alumnos (no permite el
ingreso de solo espacios en blanco) y mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados2
String nombre1, nombre2, nombreMayor, nombreMenor ;
do {
System.out.println ( “ Ingrese el nombre de la primera persona: ” ) ;
nombre1 = Lectura.leerString( );
nombre1 = nombre1.trim( ) ;
if (nombre1.length( ) < 2 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while (nombre1.length( ) < 2 ) ;
do {
System.out.println ( “ Ingrese el nombre de la segunda persona:” ) ;
if ( nombre2.length( ) < 2 ) {
System.out.println (“ Nombre ingresado no válido...Reintente!!! ” ) ;
}
} while ( nombre2.length( ) < 2 ) ;
if ( nombre1.compareTo(nombre2) < 0 ) {
} else {
}
System.out.println ( “------------------------------------------------- ” ) ;
System.out.println ( “Nombres ordenados alfabéticamente ” ) ;
System.out.println ( “------------------------------------------------- ” ) ;
System.out.println (nombreMenor) ;
System.out.println (nombreMayor) ;
}
}
Mejore la codificación del programa, de tal forma que se contemple la posibilidad de que los
nombres ingresados sean iguales.
Problema 219
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres
no deben ser iguales) y mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados3
String nombre1, nombre2, nombre3 ;

String nom01 = “ ”, nom02 = “”, nom03 = “” ;
do {
if ( nombre1.length( ) == 0 ) {
System.out.println (“ Nombre ingresado no válido...Reintente!!!”) ;
}
} while ( nombre1.length( ) == 0 ) ;
do {
System.out.println ( “ Ingrese el nombre de la segunda persona: ” ) ;
System.out.println (“ Nombre ingresado no válido...Reintente!!!”) ;
}
} while (nombre2.length( ) == 0 ) ;
do {
System.out.println ( “ Ingrese el nombre de la tercera persona: ” ) ;
System.out.println (“ Nombre ingresado no válido...Reintente!!! ”);
}
if (nombre1.compareTo(nombre2) < 0 && nombre1.compareTo(nombre3) < 0 ) {
nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
}
if (nombre2.compareTo(nombre1) < 0 && nombre2.compareTo(nombre3) < 0) {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
}
if (nombre3.compareTo(nombre1) < 0 && nombre3.compareTo(nombre2) < 0 ) {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
} else {
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
System.out.println ( “ ------------------------------------------------- ” ) ;
System.out.println (nom01) ;
}
}
Desarrolle la siguiente prueba:
1. Ejecute el programa, ingrese los siguientes datos y compruebe lo que sucede.

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Beto”.
2. Luego ingrese los siguientes datos y compruebe nuevamente lo que sucede.

nombre1 = “Armando”. nombre2 = “Beto”. nombre3 = “Beto”.
3. Finalmente ingrese los siguientes datos. Compruebe lo que sucede.

nombre1 = “Armando”. nombre2 = “Armando”. nombre3 = “Armando”.
Modifique la codificación de la solución, de tal forma que pueda mejorarla.

Problema 220
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos (los nombres
pueden ser iguales) y mostrar los nombres ordenados alfabéticamente.
Clase PrgOrdenados4
String nombre1, nombre2, nombre3 ;

String nom01 = “”, nom02 = “”, nom03 = “”;
do {
if (nombre1.length( ) == 0 ) {
System.out.println ( “ Nombre ingresado no válido...Reintente!!! ” );
}
do {
if (nombre2.length( ) == 0) {
}
do {
}
} while (nombre3.length( ) == 0 ) ;
nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
}
}
Desarrolle la siguiente prueba:
Ingrese los nombres con letras mayúsculas y minúsculas, por ejemplo:
nombre1 = “armando”. nombre2 = “Beto”. nombre3 = “Armando”.
Compruebe lo que sucede. Se ordenarán, primero, los nombres que comiencen con mayúscula, y
luego los que comiencen con minúscula.
Modifique el programa, de tal forma que se cambie la primera letra del nombre ingresado a
mayúscula.
Problema 221
Desarrollar un programa en Java que permita ingresar los nombres de tres alumnos. Asegúrese de
que los nombres ingresados empiecen con una letra mayúscula y finalmente, mostrar los nombres
ordenados alfabéticamente.
Clase PrgOrdenados5
String nombre1, nombre2, nombre3, letra, resto ;

String nom01 = “”, nom02 = “”, nom03 = “” ;
do {
} else {
nombre1 =
((nombre1.substring(0,1)).toUpperCase()).concat(nombre1.substring(1));
}
do {
} else {
nombre2 =
((nombre2.substring(0, 1)).toUpperCase()).concat(nombre2.substring(1));
}
do {
} else {
nombre3 =
((nombre3.substring(0,1)).toUpperCase()).concat(nombre3.substring(1));
}
nom01 = nombre1 ;
nom02 = nombre2 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre1 ;
nom03 = nombre2 ;
}
} else {
nom01 = nombre2 ;
nom02 = nombre1 ;
nom03 = nombre3 ;
} else {
nom02 = nombre3 ;
nom03 = nombre1 ;
}
} else {
nom01 = nombre3 ;
nom02 = nombre2 ;
nom03 = nombre1 ;
}
}
}
}
Mejore la solución desarrollando un programa que permita ingresar tres nombres de alumnos.
Asegúrese de que los nombres ingresados empiecen con una letra mayúscula y que el resto estén
en minúscula. Finalmente, muestre los nombres ordenados alfabéticamente.
Luego, complemente la solución, permitiendo el ingreso de los nombres de todos los alumnos de
un determinado salón de clase.
Problema 222
Desarrollar un programa en Java que permita ingresar el nombre de una persona, un carácter que
esté contenido en el nombre ingresado y otro carácter por el cual se reemplazará el primer carácter
ingresado. Finalmente, mostrar el nombre modificado.

Clase PrgCadenaModifcada
public class PrgCadenaModifcada {
int cant ;
String nom, dato1, dato2, caracter, cadena= “” ;
System.out.print ( “ Ingresar el nombre de una persona: ”) ;

System.out.print ( “ Ingrese el caracter que se va buscar: ” ) ;

dato1 = Lectura.leerString( ) ;
System.out.print ( “ Ingrese el caracter por el cual se va reemplazar: ” ) ;

dato2 = Lectura.leerString( ) ;
for (x=0; x<cant; x++ ) {

if ( dato1.equals(caracter) == true )
cadena = cadena + dato2 ;
else
cadena = cadena + caracter ;
}
System.out.println ( “ El resultado es: ” + cadena ) ;
}
}
Observe el uso del método equals ( ) de la clase String:
nombre1.equals (nombre2) ;
El método equals ( ) devuelve true (verdadero) si la cadena coincide con la cadena colocada como
parámetro del método equals ( ); caso contrario, devuelve false (falso).
Por lo que, en este caso el método equals ( ) evalúa a la variable dato1 y a la variable caracter. La
variable caracter tuvo que declararse como String para poder ser utilizada por el método equals (
) de esta forma:
caracter = nom.substring (x , x+1) ;
Un punto muy importante es el análisis de la siguiente línea de código:
if ( dato1.equals (caracter) == true )
La sentencia if puede evaluar una condición lógica, una variable booleana o el resultado de
una operación. En nuestro caso, el método equals ( ) devuelve true (verdadero) o false (falso),
dependiendo del resultado de la comparación entre las variables dato1 y caracter.
En base a esto, podemos afirmar que las siguientes sentencias en Java son equivalentes:
if ( dato1.equals (caracter) == true )
if ( dato1.equals (caracter) )
Resulta evidente que no es necesario realizar comparaciones booleanas dentro de las condiciones
lógicas utilizadas en la sentencia if (esto se hace extensivo a las sentencias do, while y for).
Problema 223
Desarrollar un programa en Java que permita ingresar un número mayor de tres dígitos. Convertir
el número en cadena, luego intercambiar posiciones; el primer dígito pasarlo al último y viceversa;
finalmente, mostrar el nuevo número.

Clase PrgIntercambioCadena
public class PrgIntercambioCadena {

int num, cant;
String dato1, dato2, dato3, cadena = "";
do {
System.out.print(" Ingresar un numero mayor de 3 dígitos: ");
num = Lectura.leerInt();
if (num < 100) {

System.out.println(" Número ingresado no válido… Reintente!");
}
} while (num < 100);
cadena = String.valueOf(num);
cant = cadena.length();
dato1 = cadena.substring(0, 1);
dato2 = cadena.substring(1, cant - 1);
dato3 = cadena.substring(cant-1);
cadena = dato3 + dato2 + dato1;
System.out.println(" El resultado es: " + cadena);}
}
}
Observe el uso del método valueOf ( ) de la clase String:
String.valueOf (num) ;
El método valueOf ( ) se utiliza directamente con la clase String (y no con una variable de tipo
String). Este método permite convertir una variable de cualquier tipo a una variable de tipoString
o cadena. En nuestra solución, convertimos la variable num a String con la finalidad de poder
manipular el contenido de la variable con métodos de la clase String. Una vez convertida la variable
num, se utiliza el método substring( ) para intercambiar las posiciones deseadas.
Problema 224
ingresado, de tal forma que se lea de izquierda a derecha (nombre mostrado al revés).
Clase PrgInvertirCadena
public class PrgInvertirCadena {
int cant, x ;
String nom, caracter, cadena = “” ;
do {
nom = nom.trim( ) ;
System.out.println ( “ Nombre ingresado no válido… Reintente! ” );
}
} while ( nom.length( ) == 0 ) ;
cant = nom.length( );
for (x=cant-1; x>=0; x-- ) {

cadena = cadena.concat(caracter) ;
}
System.out.println ( “ El nombre al revés es: ” + cadena ) ;

}
}
Observe el uso del método concat ( ) de la clase String:
En este programa, declaramos la variable carácter como una cadena (String). Cada vez que se
ejecuta la sentencia for, se obtiene de la variable nom, un carácter empezando desde el último y
terminando en el primero. Cada vez que se obtiene un carácter, este se agrega a la variable cadena,
de tal forma que al finalizar la ejecución de la sentencia for se tiene almacenado en la variable
cadena, el nombre ingresado con los caracteres finales al inicio y los caracteres iniciales al final.
Otra manera de solucionar este problema es la siguiente:
for ( x = cant - 1; x >= 0; x - - ) {

caracter = nom.charAt (x) ;
cadena += caracter ;
}
*Importante: Para esta solución, la variable caracter debe declararse como char. Observe cómo
se utiliza el método charAt ( ) de la clase String, con la finalidad de obtener carácter por carácter
de la variable nom (empezando desde el último y terminando en el primero), para agregarlos a la
variable cadena utilizando el signo “+” (concatenación).
Problema 225
Desarrollar un programa en Java que permita ingresar los nombres de 10 alumnos, este permitirá
visualizar la cantidad de nombres que empiezan con la letra “P” y la cantidad de nombres que
terminan con la letra “a”.

Clase PrgCuentaLetras1
public class PrgCuentaLetras1 {
String nombre, letraIni = “”, letraFin = “” ;

int i, contP= 0, contA = 0 ;
for (i = 0; i <11; i++) {

do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
nombre = Lectura.leerString( ) ;
nombre = nombre.trim( ) ;
if ( nombre.length( ) == 0 ) {
System.out.println (“Nombre ingresado no válido... Reintente!”);
}
} while (nombre.length( ) == 0 ) ;
letraIni = nombre.substring(0,1) ;
letraFin = nombre.substring ( nombre.length( )-1,nombre.length( ) ) ;
if ( letraIni.equals( “P” ) ) {
contP++;
}
if ( letraFin.equals( “a” ) ) {
contA++;
}
}
System.out.println ( “ Nombres que comienzas con la letra P: ” + contP);
System.out.println ( “ Nombres que terminan con la letra a: ” + contA);
}
}
Mejore la solución desarrollando un programa que permita ingresar los nombres de todos los
alumnos. Utilice la estructura do… while. Asegúrese que los nombres ingresados empiecen con
una letra mayúscula y que el resto esté en minúscula.
Problema 226
Desarrollar un programa en Java que permita ingresar los nombres de todos los empleados de una
empresa y mostrar el número de vocales que existen en cada uno de los nombres ingresados.
Clase PrgTotalVocales2
public class PrgTotalVocales2 {

int cant, cont=0, opc, d=0, x ;
String nom ;
char c = ‘ ’ ;
do {
do {
nom = nom.trim( ) ;
System.out.println ( “ Nombre no válido… Reintente! ” ) ;
}
} while ( nom.length( ) == 0 ) ;
for ( x=0; x<cant; x++ ) {
c = nom.charAt(x) ;
d = (int) (c) ;
switch(c) {
case 97 : // a
case 101 : // e
case 105 : // i
case 111 : // o
case 117 : cont ++ ; // u
}
}
System.out.println ( “ El Total de Vocales del nombre ingresado es:”+
cont);
System.out.println ( “ Desea ingresar otro nombre (Sí = 1, No = 2):”);
opc =Lectura.leerInt( ) ;
} while ( opc != 1 );
}
}
Mejorar la solución desarrollando un programa que considere el conteo de las vocales acentuadas
y las vocales en letra mayúscula. Como sugerencia, investigue los códigos ASCII de los dos tipos de
vocales mencionadas y agréguelas en la sentencia switch ( ).
Problema 227
Desarrollar un programa en Java que permita ingresar los nombres de todos los productos de una
determinada tienda y mostrar como resultado las posiciones pares.

Clase PrgProductosTienda
class PrgProductosTienda {

int x, cantidad, cont = 0 ;
String producto, acum = “” ;
do {
System.out.println ( “ Ingresar la cantidad de productos: ” ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ” ) ;
}
} while ( cantidad < 1 ) ;
do {
System.out.println ( “ Ingresar el nombre del producto: ” ) ;

producto = Lectura.leerString( ) ;
for ( x = 1; x <= producto.length(); x++ ) {
if ( x % 2 == 0 ) {
acum = acum + producto.substring(x - 1, x) ;
}
}
System.out.println ( “ Las posiciones pares del producto son:” + acum );
acum = “” ;
cont ++ ;
} while ( cantidad != cont ) ;
}
}
Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad, se valida el número
de alumnos ingresado, de tal forma que sea mayor a cero.
Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los productos y determinar
sus posiciones pares. Esto último se logra utilizando una sentencia for dentro de la sentencia do.
Observe el uso de los métodos length ( ) y substring ( ) de la clase String y la forma cómo se utilizan
las estructuras lógicas para la solución del problema.
Problema 228
Desarrollar un programa en Java que permita ingresar los nombres de todos los alumnos de un salón
de clase. Mostrar la longitud de cada nombre ingresado, el nombre que tiene la mayor longitud y
el que tiene la menor longitud.
Clase PrgLongitudNombre
class PrgLongitudNombre {

int cantidad, cont = 0, longMayor = 0, longMenor = 100 ;
String alumno, nomMayor = “”, nomMenor = “” ;
do {
System.out.println ( “ Ingresar la cantidad de alumnos: ” ) ;
if ( cantidad < 1 ) {
System.out.println ( “ Cantidad no válida… Reintente! ”);
}
} while ( cantidad < 1 ) ;
do {
System.out.println ( “ Ingresar el nombre del alumno: ” ) ;
alumno = Lectura.leerString( ) ;
System.out.println ( “ La Longitud es: ” + alumno.length() );
if ( longMayor < alumno.length( ) ) {
longMayor = alumno.length( ) ;
nomMayor = alumno ;
}
if ( longMenor > alumno.length( ) ) {
longMenor = alumno.length( ) ;
nomMenor = alumno ;
}
cont ++ ;
} while ( cantidad != cont ) ;
System.out.println ( nomMenor + “ tiene de longitud ” + longMenor ) ;

System.out.println ( nomMayor + “ tiene de longitud ” + longMayor ) ;
}
}
Ingresamos la cantidad de alumnos y la almacenamos en la variable cantidad; se valida el número
de alumnos ingresado, de tal forma que sea mayor a cero.
Luego, se utiliza una sentencia do para ingresar el nombre de cada uno de los alumnos, y se
determina la longitud de cada nombre ingresado, el nombre con la mayor longitud y el nombre con
la menor longitud.
Observe el uso de los métodos length ( ) de la clase String y la forma como se utilizan las estructuras
lógicas para la solución del problema.
Problema 229
Desarrollar un programa en Java que permita ingresar una fecha con el siguiente formato “dd-mm-
aaaa” y validarla.
Clase PrgFechaFormato
class PrgFechaFormato {

String fecha, dia, mes, anio ;
int num1 = 0, num2 = 0 ;
System.out.println ( “ Formato de la fecha es : dd-mm-aaaa ” ) ;
System.out.println ( “ Ingresar la fecha actual: ” ) ;

fecha = Lectura.leerString( ) ;
if ( fecha.length( ) <= 10 ) {
dia = fecha.substring(0, 2) ;
num1 = Integer.parseInt(dia) ;
mes = fecha.substring(3, 5) ;
num2 = Integer.parseInt(mes) ;
anio = fecha.substring(6, 10) ;
if ( ( dia.length() != 2 ) || ( num1 < 31 ) ) {
System.out.println ( “ El dia ingresado es incorrecto ” ) ;
} else {
if ( (mes.length() != 2 ) || ( num2 < 12 ) ) {
System.out.println ( “ El mes ingresado es incorrecto ” ) ;
} else {
if ( anio.length( ) != 4 ) {
System.out.println (“El año ingresado esta incorrecto”);
} else {
System.out.println (“ La fecha ingresada es correcta ”);
}
}
}
}
}
}
Intente mejorar la solución validando la fecha, de tal forma que el mes ingresado solo sea válido si
es que la variable dia contiene el número de días válidos para dicho mes. Incluya la posibilidad de
que el mes de febrero sea bisiesto.
Problema 230
Desarrollar un programa en Java que permita completar por la izquierda (utilizando asteriscos), una
determinada cadena en base a una longitud especificada.
Ejemplo:
Se ingresa:
Longitud = 10
Cadena = “Danae”
Resultado:
Cadena = “Danae*****”
Clase PrgCompletarCadenaIzq
classPrgCompletarCadenaIzq{
String cadena ;
int longitud, tamaño, x ;
System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;
System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;
if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;
for ( x = 1; x <= tamaño; x++) {
cadena = cadena + “*” ;
}
}
System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}
Problema 231
Desarrollar un programa en Java que permita completar por la derecha (utilizando asteriscos), una
determinada cadena en base a una longitud especificada.
Ejemplo:
Se ingresa:
Longitud = 10
Cadena = “Danae”
Resultado:
Cadena = “Danae*****”
Clase PrgCompletarCadenaDer
classPrgCompletarCadenaDer {
String cadena ;
int longitud, tamaño, x ;
System.out.println ( “ La longitud especificada es: ” ) ;

longitud = Lectura.leerInt( ) ;
System.out.println ( “ Ingresar cadena: ” ) ;

cadena = Lectura.leerString( ) ;
if ( longitud > cadena.length( ) ) {

tamaño = longitud - cadena.length( ) ;
for ( x = 1; x <= tamaño; x++ ) {

cadena = “*” + cadena ;
}
}
System.out.println ( “ La nueva cadena es: ” + cadena ) ;

}
}
Problema 232
Desarrollar un programa en Java que permita transformar un arreglo de caracteres en una cadena,
especificando la posición del arreglo donde comenzará la cadena y su longitud. Finalmente, analizar
la solución.
Clase PrgArregloCadena
classPrgArregloCadena {
char arregloA = { ‘D’, ‘a’, ‘n’, ‘a’, ‘e’ } ;

String cadena = String.valueOf (arregloA, 1, 3) ;
System.out.println ( “ La cadena es: ” + cadena ) ;
}
}
Observe el uso del método valueOf ( ) de la clase String:
String.valueOf ( char [ ], int, int ) ;
El método valueOf( ) se utiliza directamente con la clase String (y no con una variable de tipo
String), el cual permite convertir un arreglo de caracteres o parte de él, en una variable de tipo
String o cadena. En nuestra solución convertimos parte del arreglo arregloA a un String, con la
finalidad de mostrar el contenido de dicha variable.
Observe que en este método, en primer lugar, se especifica el arreglo de tipo char, del cual se
obtendrá la cadena. En segundo lugar, se indica la posición del arreglo desde el cual se van a tomar
los datos. Finalmente, se indica la longitud o el número de caracteres que se obtendrán del arreglo.
En el ejemplo, se muestra como resultado la cadena “ana”.

Ejemplos de uso del método matches de la clase String de Java:
Problema 233
Ingreso de una sola letra. Puede ingresar la letra en mayúscula o minúscula.
String letras;
do {
letras=LE.leerString( “Ingrese 1 sola letra:”);
if(!letras.matches(“[a-z-A-Z]”)){
LE.mostrarError( “Error; la letra ingresada es incorrecta; reintente”);
}
}while(!letras.matches(“[a-z-A-Z]”));
Problema 234
Ingreso de varias letras.
String letras;
do{
letras=LE.leerString(“Ingrese varias letras:”);
if(!letras.matches(“[a-z-A-Z]+” )){
LE.mostrarError( “Error; las letras ingresadas son incorrectas; reintente” );
}
}while(!letras.matches(“[a-z-A-Z]+”));
Problema 235
Ingreso de solo tres letras. Las llaves agregadas al argumento, más el número al interior, indican el
número de caracteres que deben ser ingresados.
String letras;
do{
letras=LE.leerString(“Ingrese 3 letras: ” );
if(!letras.matches(“[a-z-A-Z]{3}” )){
LE.mostrarError( “Error; las letras ingresadasson incorrectas; reintente” );
}
}while(!letras.matches(“[a-z-A-Z]{3}” ));
Problema 236
Ingreso de varias letras, un espacio en blanco y después varias letras.
String letras;
do{
letras=LE.leerString(“Ingrese sus dos nombres: ” );
if(!letras.matches(“[a-z]+[ ][a-z]+” )){

LE.mostrarError( “Error; no ha ingresado dos nombres; reintente ” );
}
}while(!letras.matches(“[a-z]+[ ][a-z]+” ));
Problema 237
Ingreso de un número con un dígito.
String numeros;
do{
numeros=LE.leerString(“Ingrese un número de un dígito: ” );
if(!numeros.matches(“[0-9]” )){
LE.mostrarError( “Error; el número ingresado es incorrecto; reintente” );
}
}while(!numeros.matches(“[0-9]”));
Problema 238
Ingreso de un número de varias cifras.
String numeros;
do{
numeros=LE.leerString(“Ingrese un número: ” );
if(!numeros.matches(“[0-9]+” )){
LE.mostrarError(“Error; el número ingresado es incorrecto; reintente");
}
}while(!numeros.matches(“[0-9]+”));
Problema 239
Ingreso de un número de tres cifras.
String numeros;
do{
numeros=LE.leerString(“Ingrese un número: ” );
if(!numeros.matches(“[0-9]{3}” )){
LE.mostrarError( “Error; el número ingresado es incorrecto; reintente ” );
}
}while(!numeros.matches(“[0-9]{3}” ));
Problema 240
Ingreso de dos letras y un número de cinco cifras.
String cadena;
do{
cadena=LE.leerString(“Ingrese 2 letras y un número: ” );
if(!cadena.matches(“[a-z-A-Z]{2}[0-9]{5}” )){
LE.mostrarError( “Error; el dato ingresado es incorrecto; reintente” );
}
}while(!cadena.matches(“[a-z-A-Z]{2}[0-9]{5}” ));
Analizando la codificación, podemos deducir lo siguiente:
}|Primer argumento [a-z-A-Z]{2}

Permite el ingreso de dos letras. Puede ser en mayúscula o en minúscula.
}|Segundo argumento [0-9]{5}

Permite que posteriormente ingresen cifras de un dígito.
Problema 241
Validación de sexo (1).
String sexo;
do{
sexo = LE.leerString(“Ingrese el sexo: F: Femenino | M: Masculino” );
if(!sexo.matches(“[FMfm]” )){
LE.mostrarError( “Error; el dato ingresado es incorrecto; reintente” );
}
}while(!sexo.matches(“[FMfm]” ));
Problema 242
String sexo;
do{
if(!sexo.matches(“[FMfm] {1}” )){

LE.mostrarError(“Error; el dato ingresado es incorrecto; reintente” );
}
}while(!sexo.matches(“[FMfm]{1}” ));
Problema 243
String sexo;
do{
sexo=sexo.toUpperCase();
if(!sexo.matches(“[FM] {1}” )){

LE.mostrarError(“Error; el dato ingresado es incorrecto; reintente” );
}
}while(!sexo.matches(“[FM]{1}” ));
Problema 244
Validación de número telefónico.
String numTelefono;
do{
numTelefono=LE.leerString(“Ingrese el número de teléfono” );
if(!numTelefono.matches(“[0-9]{7}” )){
LE.mostrarError(“Error; el Nro. ingresado es incorrecto; reintente” );
}
}while(!numTelefono.matches(“[0-9]{7}” ));
De la misma forma se pueden realizar las validaciones de:
}|DNI
}|Número de teléfono celular

Problema 245
Se debe recordar que el argumento proporcionado para el funcionamiento del método matches es
para un tipo de correo que pueda poseer:
Ingreso del nombre del mail – Puede ser letras o números o ambos caracteres.
El mail puede poseer un “_” de carácter.
Ingreso de dominio del mail- Este solo puede contener caracteres de tipo texto.
String Email;
do{
Email=LE.leerString(“Ingrese su e-mail: ” );
Email = Email.toLowerCase();
if(!Email.matches(“[a-z-0-9-_]+[@][a-z]+[.][a-z]{3}” )){
LE.mostrarError(“Error; el tipo de correo valido es usuario@dominio.com;
reintente” );
}
}while(!Email.matches(“[a-z-0-9-_]+[@][a-z]+[.][a-z]{3}” ));
manEjO dE FORmaTOs: ClasE dECimalFORmaT
java.lang.Object
--> java.text.Format
--> java.text.NumberFormat
--> java.text.DecimalFormat
DecimalFormat es una clase concreta de NumberFormat que da formato a números decimales. Tiene
una gran variedad de opciones para dar formatos a números en cualquier sistema; incluye soporte
para dígitos occidentales, arábigos e índicos. También soporta gran variedad de formatos numéricos,
como enteros, decimales, notación científica, formato de moneda, etc.
Con la clase DecimalFormat se especifica un formato de número con patrón. La clase

DecimalFormatSymbols permite modificar los símbolos de formato, como separadores decimales o el
signo negativo, entre otros.
Se puede utilizar la clase DecimalFormat para formatear números decimales en cadenas específicas
de la localidad. Los programas almacenan y operan con números de una forma independiente de
la localidad. Antes de mostrar o imprimir un número, el programa debe convertirlo a un String que
esté en un formato sensible a la localidad. Por ejemplo, en Francia, el número 123456.78 debería
ser formateado como 123 456,78, y en Alemania debería aparecer como 123.456,78. Para poner en
práctica esto podemos recurrir a dos métodos:
NumberFormat formato ;
DecimalFormat df ;
Si queremos dar formato a números:
formato = NumberFormat.getNumberInstance(currentLocale);
Si queremos dar formato a monedas:
formato = NumberFormat.getCurrencyInstance(currentLocale);
Luego aplicamos las características locales almacenadas en formato a df:
DecimalFormat df = (DecimalFormat)nf;
Esta clase permite controlar los ceros iniciales y finales, los sufijos y prefijos, separadores (millares) y el
separador decimal. Si se quiere cambiar un símbolo del formateo como el separador decimal, se puede
utilizar DecimalFormatSymbols en conjunción con la clase DecimalFormat.
Símbolos usados para formato
Símbolo Significado
0 Dígito
# Dígito, el cero se muestra como ausente
. Separador decimal
- Signo menos
, Separador de agrupación
E Para notación científica "0.###E0" muestra 1234 como "1.234E3"
; Para separar formatos positivos y negativos
% Multiplica por 100 y lo muestra como porcentaje
\u2030 Multiplica por 1000 y muestra como millares
¤ (\u00A4) Utilizado para mostrar símbolos monetarios
' Usado para mostrar caracteres especiales
Problema 246
Desarrollar un programa en Java que permita ingresar un número por teclado, luego mostrar el
número ingresado con un formato determinado. Finalmente, analizar la solución.
Clase PrgFormatoNumero
import java.text.* ;
classPrgFormatoNumero {

double num ;
DecimalFormat numFormato ;
System.out.println ( “Ingrese numero entero: ” ) ;

num = Lectura.leerDouble();
numFormato = new DecimalFormat ( “###.000" ) ;
System.out.println (“El número con formato es : ” + df.format (num));

}
}
Observe que se declara un objeto de la clase DecimalFormat llamado numFormato; luego, este
objeto es creado utilizando el operador new, estableciendo el formato a utilizar en el método
constructor. Finalmente, con el método format ( ) se procede a establecer el formato creado para
el número ingresado.
Problema 247
Ingresar un número por teclado y visualizarlo en diferentes formatos. Para ello, utilice la clase
DecimalFormat de Java.
Clase PrgFormatoNumero2
classPrgFormatoNumero2 {

double n;
String s;
DecimalFormat f;
System.out.print("Ingresa número a dar formato : ");
n = Lectura.leerDouble();
f = new DecimalFormat("###,###");
s = f.format(n);
System.out.println(s);
f = new DecimalFormat("###,###.00");
s = f.format(n);
f = new DecimalFormat("###,###.0000");
s = f.format(n);
f = new DecimalFormat("'U$' ###,##0.00");
s = f.format(n);
f = new DecimalFormat("'S/.'###,##0.00 Soles");
s = f.format(n);
f = new DecimalFormat("#,##0.####E0");
s = f.format(n);
f = new DecimalFormat("###,##0.00%");
s = f.format(n);
}
}
Resultado:
Problema 248
En la siguiente codificación en Java utilizamos la clase DecimalFormatSymbols y reemplazamos
el símbolo de separación decimal por | y el separador de grupos por ^; asimismo, los grupos los
hacemos de cuatro dígitos (en vez de tres como es regularmente) y finalmente, reemplazamos el
símbolo que representa números negativos (-) por n.

Clase PrgFormatoNumero2
classPrgFormatoNumero2 {

double n;
String s;
DecimalFormat f;
System.out.print("Ingresa número a dar formato : ");
n = Lectura.leerDouble();
//Ahora modificamos los símbolos usados como separadores decimales
//y de millares, asi como el símbolo usado para especificar un negativo.
//esto lo hacemos utilizando la clase DecimalFormatSymbols
DecimalFormatSymbols simbolosraros = new DecimalFormatSymbols();
simbolosraros.setDecimalSeparator('|');
simbolosraros.setGroupingSeparator('^');
simbolosraros.setMinusSign('n');
f = new DecimalFormat("###,##0.00", simbolosraros);
f.setGroupingSize(4);
s = f.format(n);
System.out.println("Alterando los símbolos : " + s);
}
}
manEjO dE FEChas: ClasE CalEndaR
java.lang.Object
--> java.util.Calendar
Calendar es una clase base abstracta para conversiones entre un objeto Date y una gama de enteros
como YEAR(año), MONTH(mes), DAY(día), HOUR(hora), y así sucesivamente.
Subclases de la clase calendario interpretan una fecha de acuerdo con las reglas específicas de un
calendario determinado. Esta plataforma implementa una subclase concreta: GregorianCalendar.
Futuras subclases podrían representar los diferentes tipos de calendarios lunares en muchos sitios del
mundo.
Para inicializar un objeto Calendar con los valores de fecha y horas actuales, se utilizará el método
getInstance( ):
Calendar cal = Calendar.getInstance();
Los campos de un objeto calendario pueden ser manipulados usando tres métodos:
set()
// cambiamos los campos YEAR, MONTH y DATE del calendario cal
// a los valores dados en año, mes y día.
cal.set (año, mes, día) ;
// cambiamos el valor del campo YEAR del calendario cal

// al valor guardado en año
cal.set (cal.YEAR,año) ;
// cambiamos los campos YEAR, MONTH , DATE, HOUR y MINUTE

// del calendario cal a los valores dados en año, mes, etc….
cal.set (año, mes, día, hora, minuto) ;
add()
// agrega cambio al campo f. Esto es equivalente a hacer set (f, get(f) + cambio)
// agrega cambio al valor del campo campo del calendario cal
cal.add(cal.MONTH, 1) //aumenta el mes actual en 1
roll()
// roll (f, cambio) agrega cambio al campo f sin variar campos superiores, esto es,
// si aumentamos por ejemplo 40 minutos a la hora 3:30, la nueva hora sería 3:10 a
// diferencia del método add ( ) que nos daría 4:10..
cal.roll(cal.HOUR, 40)
// si la hora actual fuera 3:30, la nueva hora sería 3:10 a diferencia del
// método add ( ) que nos daría 4:10.
Sumario de campos
static int AM
Constante que representa el campo AM.
static int AM_PM

Constante que representa el campo AM_PM.
static int DATE

Constante que representa la fecha del calendario actual (día).
static int DAY_OF_MONTH

Constante que representa el campo Día del mes.
static int DAY_OF_WEEK

Constante que representa el campo Día de la semana.
static int DAY_OF_WEEK_IN_MONTH

Constante que representa el campo Día del mes.
static int DAY_OF_YEAR

Constante que representa el campo Día del año.
static int ERA

Constante que representa el campo AC/DC.
static int FIELD_COUNT

Indica el número de campos que pueden ser usados por la instrucción get o set.
static int HOUR

Constante que representa el campo hora.
static int HOUR_OF_DAY

Constante que representa el campo Hora del día.
static int JANUARY, FEBRUARY, MARCH, etc…

Constantes que representan a los meses que corresponden del año.
static int MILLISECOND

Constante que representa el campo, que indica los milisegundos de la hora actual.
static int MINUTE

Constante que representa el campo, que indica los minutos de la hora actual.
static int MONDAY, TUESDAY, WEDNESDAY, etc…

Constantes que representan a los días, que corresponden de la semana.
static int MONTH

Constante que representa el campo, que indica el mes actual.
static int PM.
static int SECOND

Constante que representa el campo, indica o establece los segundo de la hora actual.
Sumario de campos
static int UNDECEMBER
indica el 13o mes, del mes.
static int WEEK_OF_MONTH

Constante que representa el campo Semana del mes.
static int WEEK_OF_YEAR

Constante que representa el campo Semana del año.
static int YEAR

Constante que representa el campo Año.
Estas constantes nos sirven para especificar en los métodos que se detallan a continuación, cuáles son
los campos que queremos manipular. Por ejemplo; si queremos agregar un minuto al calendario actual
debemos utilizar el método add, cuyos parámetros son:
int Campo, int Cantidad ;
Entonces para agregar un minuto, debemos especificarle al método que queremos manipular el
campo minuto y la cantidad que queremos agregar al valor almacenado en este campo (supongamos
ya definido un Calendar cal):
cal.add (cal.MINUTE,1) ;
Sumario de métodos
abstract void add(int Campo, int Cantidad)
Date Arithmetic function.
boolean after(Object cuando)

Compara los tiempos, si la fecha actual de nuestro calendario es superior a cuando
retorna verdadero.
boolean before(Object cuando)

Compara los tiempos, si la fecha actual de nuestro calendario es inferior a cuando
retorna verdadero.
void clear()
Limpia los valores de todos los campos del calendario.
void clear(int campo)

Limpia el valor del campo indicado.
boolean equals(Object objeto)

Compara este calendario con el objeto dado y si son iguales retorna verdadero.
int get(int campo)

Obtiene el valor almacenado en el campo dado.
Sumario de métodos
getActualMaximum(int campo)
Retorna el valor máximo que puede obtener este campo con la fecha del
int
calendario actual. Por ejemplo; si campo=Calendar.DAY_OF_MONTH y el mes actual
es Abril, entonces el valor retornado será 30 (el máximo valor).
getActualMinimum(int campo)
int Retorna el valor mínimo que puede obtener este campo con la fecha del
calendario actual.
getFirstDayOfWeek()
int
Obtiene el primer día de la semana. Por ejemplo SUNDAY (0).
getInstance()
static Calendar
Obtiene un calendario utilizando la zona actual y las reglas dadas.
getInstance(TimeZone zona)
static Calendar
Obtiene un calendario utilizando zona y las reglas dadas.
getTime()
Date
Obtiene la hora actual del calendario.
getTimeInMillis()
long
Obtiene la hora actual del calendario en milisegundos.
getTimeZone()
TimeZone
Obtiene la zona horaria.
isSet(int campo)
boolean
Determina si el campo dado tiene un valor almacenado.
roll(int field, boolean up)

abstract void
Time Field Rolling function.
roll(int field, int amount)

void
set(int field, int value)
setFirstDayOfWeek(int value)
void
Establece cual es primer día de la semana para el calendario actual. Ej: MONDAY
setTime(Date fecha)
void
Establece la hora del calendario actual a la fecha.
setTimeInMillis(long milisegundos)
void
Establece la hora del calendario actual utilizando los milisegundos dados.
setTimeZone(TimeZone value)
void
Sets the time zone with the given time zone value.
toString()
String
Retorna una representación de cadena del calendario actual.
Problema 249
Resultado:
manEjO dE FEChas: ClasE gREgORianCalEndaR

java.lang.Object
--> java.util.Calendar
--> java.util.GregorianCalendar
GregorianCalendar es una subclase concreta de la Clase Calendar y provee el calendario Standard

usado por la mayoría del mundo.
¿Qué es el Calendario Gregoriano?

La reforma del calendario surgió durante el papado de Gregorio XIII (1502-1585), quien ordenó hacerlo
para compensar las desviaciones del calendario juliano (perdía un día cada 128 años, y por lo tanto
cada año se hacía más notorio que la fecha de la Pascua de Resurrección se atrasaba con respecto al
equinoccio) y hacer coincidir el año civil con el año trópico.
La tarea recayó en una comisión, en la cual destacaron Cristóbal Clavio y Luigi Lilio, entre otros; quienes
presentaron el nuevo calendario a Gregorio XIII; cuya reforma fue aprobada el 14 de septiembre de
1580 y llevada a la práctica en octubre de 1582.
Los cálculos supusieron un día medio de 24 horas y un año medio de 365 días, 5 horas, 49 minutos
y 20 segundos (26 segundos más que el año real). Para ello se alternarían años de 365 días y de 366
días. El calendario gregoriano intercala un año bisiesto cada cuatro años; sin embargo, no cuenta como
bisiestos los años seculares (los que terminan en doble cero: 1800, 1900, 2000), solo cuando las dos
primeras cifras son múltiplo de 4, como el 2000.
Dicha excepción se genera debido a un error en los cálculos de Luigi Lilio, el de un día cada 134 años.
Por tanto, se debía suprimir tres días cada 402 años.
Como esta cifra está relativamente cerca de 400 se acordó que no fuesen bisiestos los años terminados
en doble cero (100, 200 y 300), excepto el 400 y sus múltiplos. De esta manera se produce un error
de sólo un día cada 3323 años. No obstante, si se suprimiese un año bisiesto cada 128 años, el error
acumulado sería menor a un día cada 100 000 años.
Como en 1257 años de vigencia del calendario juliano, se habían acumulado 10 días de retraso, se
estableció que el día siguiente al 4 de octubre de 1582, fuese el 15 de octubre de 1582. El año comienza
el 1 de enero.
El calendario gregoriano consta de doce meses: enero (31 días), febrero (28 o 29), marzo (31), abril
(30), mayo (31), junio (30), julio (31), agosto (31), septiembre (30), octubre (31), noviembre (30) y
diciembre (31); y de una semana de siete días: lunes, martes, miércoles, jueves, viernes, sábado y
domingo; que es independiente del mes. Para el cómputo eclesiástico, el primer día de la semana es
el domingo. Los días del mes se numeran correlativamente.El Calendario Gregoriano Standard tiene 2
eras: A.C y D.C.
Para trabajar con fechas en Java que puedan encontrarse entre ambos calendarios, lo recomendable
es reescribir a mano todo el proceso y operaciones necesarias. En caso de que las fechas vayan a estar
dentro del calendario Gregoriano, lo recomendable es usar la clase GregorianCalendar que trae un
grupo extenso de métodos para operar con fechas en Java.
Problema 250
Resultado:
manEjO dE FEChas: ClasE simPlEdaTEFORmaT
java.lang.Object
--> java.text.Format
--> java.text.DateFormat
Esta clase se utiliza para presentar las fechas como cadenas de texto con formato de acuerdo a un
patrón establecido. Los patrones que se utilizan son:
Letra Significado Ejemplos

G Era AD
y Año 1996; 96
M Mes del año Julio; Jul; 07
w Semana del año 27
W Semana del mes 2
D Día del año 189
d Día del mes 10
F Día de la semana en el mes 2
E Día de la semana Jueves; Jue
a AM/PM PM
H Hora del día (0-23) 0
k Hora del día (1-24) 24
K Hora en AM/PM (0-11) 0

Letra Significado Ejemplos

h Hora en AM/PM (1-12) 12
m Minuto de la hora 30
s Segundo del minuto 55
S Milisegundo 978
z Zona horaria GMT -5:00
Z Zona horaria -0500
Los pasos a seguir son:
1. Creación del formateador
SimpleDateFormat s=new SimpleDateFormat("EEEEE,dd 'de' MMMM 'del' yyyy G zz");
2. Aplicar el formato a una fecha y asignarlo a una cadena
//asumimos que se tiene un objet. calendar previamente creado e inicializado
String Cad=s.format(calendar.getTime()) ;
System.out.println(Cad) ; // jueves,20 de mayo del 2004 AD GMT-05:00

Método de Las 6'D, Tomo I - Juan José Flores Cueto

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Método de Las 6'D, Tomo I - Juan José Flores Cueto

Cargado por

Copyright:

Formatos disponibles

Método de las 6`D Modelamiento - Algoritmo - Programación.

Tomo I. Enfoque orientado a las estructuras lógicas

© Derechos de autor registrados:

© Derechos de edición, arte gráﬁco y diagramación reservados:

Coordinación de arte y diseño:

Edición a cargo de:

 Teléfono: (511) 748 0560

Primera edición: seƟembre de 2014

ISBN N.° 978-612-304-218-9

Se ha desempeñado profesionalmente en diversas empresas nacionales, ocupando las funciones de desarrollador

A nuestros hijos, Danae y el pequeño Rodrigo

Bibliograİa .............................................................................................................................................. 631

Clases creadas e incorporadas en Java ................................................................................................... 633

* El presente apéndice solo se encuentra disponible en la página web de la editorial: www.editorialmacro.com

Se explican los conceptos fundamentales sobre el modelamiento y el UML, profundizando en el

}|Desarrollo de aplicaciones Java utilizando Java Development Kit ( JDK )

}|Software para decompilar aplicaciones Java

}|Desarrollo de miniaplicaciones Java (Applet) utilizando Java Development Kit ( JDK )

}|Software para generar ejecutables en MS-Windows basado en aplicaciones Java

1.1 MÉTODO DE LAS 6’D

1.1.1 Etapas y pasos

A. Descripción de la Etapa 01 – Descripción del problema

Una vez identiﬁcado el problema, es necesario

B. Descripción de la Etapa 02 – Deﬁnición de la solución

Una vez entendido el problema se está en

}|Deﬁnir el resultado deseado.

C. Descripción de la Etapa 03 – Deﬁnición de la solución

Para el modelado de la solución del problema

Para el desarrollo de algoritmos se utilizarán

Finalizado el desarrollo de los algoritmos es

}|Deﬁnir un nombre para el proyecto.

D. Descripción de la Etapa 04 – Desarrollo de la solución

La codiﬁcación involucra traducir los

CODIFICACIÓN }|Codiﬁcar el proyecto.

E. Descripción de la Etapa 05 – Depuración y pruebas

Hay que corregir el programa, anular, modiﬁcar

}|Realizar la depuración y veriﬁcar la correcta

F. Descripción de la Etapa 06 – Documentación

El tiempo dedicado a esta etapa será de

El manual técnico debe incluir, como mínimo:

}|Listado de programas con comentarios

}|Recopilar el material generado en cada

}|Generar el manual del usuario.

Ingeniería La ingeniería reversa permite crear o

Descripción Deﬁnición Diseño Desarrollo Depuración

}|Identificación }|Definir el }|Definir un }|Codificar el }|Realizar la }|Recopilar el

}|Enunciado claro deben ingresar relaciones y programas de programas. del programa.

Etapa 01 Etapa 02 Etapa 03 Etapa 04 Etapa 05 Etapa 06

Descripción Deﬁnición Diseño Desarrollo Depuración Documento

1.2 MARCO DE TRABAJO

El Lenguaje Uniﬁcado de Modelado (UML) es un lenguaje gráﬁco que permite:

NombrePaquete Nombre del paquete

NombreClase Nombre de la clase y del paquete al

Atributos Lista de atributos de la clase

Métodos Lista de métodos de la clase

Nombre de la clase a la cual

1.3.4 Diagrama de paquetes

Se desarrollan los siguientes pasos:

En el paquete “dominioDeLaAplicacion” se deﬁnirá la clase que va a permitir solucionar el problema

}|Una lista de pasos que deben ser ejecutados.

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

}|Un algoritmo puede o no tener datos de entrada.