Cuaderno de Ejercicios - AyP - v11

Agosto de 2019
Algoritmos y Programas
Cuaderno de ejercicios
Departamento Académico de Computación

División Académica de Ingeniería
Contenido
1- Introducción ................................................................................................................................ 2
2- Expresiones aritméticas, relacionales y lógicas........................................................................... 3
3- Algorítmica .................................................................................................................................. 4
4- Retos Algorítmica ........................................................................................................................ 9
5- Mapas de Memoria ................................................................................................................... 14
6- Conceptos de Programación Orientada a Objetos (POO) y diagramas UML ............................ 20
7- Programación en Java ............................................................................................................... 25
8- Retos Programación en Java ..................................................................................................... 35
9- Cadenas de caracteres y archivos de texto ............................................................................... 39
10- Arreglos ................................................................................................................................. 43
11- Arreglos bidimensionales ...................................................................................................... 50
12- Retos Arreglos ....................................................................................................................... 53
13- Interfaces gráficas de usuario (GUI) ...................................................................................... 58
Apéndice A: Uso del Debugger en Eclipse ......................................................................................... 61
Apéndice B: Uso de clases definidas en otros proyectos .................................................................. 67
1
1- Introducción
En este cuaderno de ejercicios se presentan varios problemas donde se aplican los

conceptos vistos en clase. Es muy importante resolver la mayor cantidad de problemas para
asegurar que los conceptos se entendieron y, por lo tanto, pudieron aplicarse en la solución
de un problema. Tu profesor te indicará los ejercicios que sean obligatorios, sin embargo,
en este cuaderno encontrarás muchos ejercicios más que podrás hacer por tu cuenta.
Además, en algunas secciones, encontrarás ejercicios titulados “retos” los cuales tienen un
nivel de complejidad más alto y que te podrán ayudar cuando estudies los temas vistos en
clase.
2
2- Expresiones aritméticas, relacionales y lógicas
En esta sección se presentan ejercicios para practicar el uso de los operadores aritméticos,
relacionales y lógicos. Recuerda que los mismos están expresados en pseudocódigo y, por
lo tanto, no se corresponden necesariamente con los de algún lenguaje de programación.
Ejercicio 1: Evalúa las siguientes expresiones aritméticas.
a) 6 – 3 * 4 / 4 + 5 * 2
b) (2 * 3 + 6 div (3 – 1)) ** 2
c) 6 mod 3 - 9 / 4 * 2 + 1
Ejercicio 2: Indica, usando [], el orden en el cual se aplican los operadores.
a) a div b * c mod e – f * g
b) a – b * c / d + e *f
c) a * (b + c) + abs(d * e / f) – g * (h + i / j)
Ejercicio 3: Elimina los paréntesis innecesarios de las siguientes expresiones.
a) ((a mod b) / c) * (d + e)
b) ((a / b) * c) – d
c) (a + (b * (c + d))) – ((e + f) / g * h)
Ejercicio 4: Evalúa las siguientes expresiones.
a) (5 / 2 * 3 – 1) = 4 div 2 mod 2
b) (7 div 3) > (3 / 4) ** 2 * (2 + 10 mod 5)
c) 10 ≤ 3 + 4 – 2 * (2 + 6)
Ejercicio 5: Evalúa las siguientes expresiones.
a) no (15 ≥ 7 ** 2) o (43 – 8 * 2 div 4  3 * 2 div 2)

b) (15 ≥ 7 * 3 ** 2 y 8 > 3 y 15 > 6) o no (7 * 3 < 5 + 12 * 2 div 3 ** 2)
c) no ((7 * 3 div 2 * 4 < 20) o (15 / 2 * 6 ≤ 15 * 2 / 17))
3
3- Algorítmica
Resuelve los siguientes problemas, para cada uno haz el diagrama de flujo y mapa de
memoria. Es importante que leas y analices con cuidado el enunciado, identificando los
datos de entrada, el resultado esperado y los pasos necesarios (algoritmo) para llegar a
alcanzar el resultado.
Para desarrollar tu capacidad de análisis y abstracción, luego de leer el problema, debes
buscar similitudes con problemas resueltos previamente. De esta manera, irás
encontrando ciertos patrones que se repiten y que puedes emplear en la solución de los
problemas nuevos.
Ejercicio 1: Sean los datos: x, a1, a2, a3, a4. Elabore un diagrama de flujo para calcular:
a1x3 + a2x2 + a3x + a4
Restricción: no puedes usar la operación de potencia.
a) ¿Cuántas operaciones de multiplicación y cuántas de suma utilizó?

b) ¿Puede reducir ambas cantidades? En caso afirmativo, hazlo.
c) Prueba tu solución.
Ejercicio 2: El precio de un boleto de viaje redondo en tren se calcula tomando en cuenta el

número de kilómetros que se van a recorrer, siendo el precio $60.00 por km. Este precio
puede tener un descuento del 30% si el viaje de regreso se hace después de 7 días del viaje
de ida, o si el recorrido supera los 800 km.
Elabora un diagrama de flujo para calcular cuánto se debe pagar por un boleto de tren
dando como datos el total de km recorridos y el número de días entre el viaje de ida y el
viaje de vuelta. Prueba tu diagrama con los siguientes grupos de datos:
a) 850 km y 10 días.
b) 356 km y 8 días
Ejercicio 3: Elabora un diagrama de flujo para resolver ax2 + bx + c = 0 en el caso de raíces

reales. Identifica los datos y resultados. Puedes usar las operaciones que necesites.
Asegúrate que el resultado sea válido.
Análisis del problema:

Si a ≠ 0 se presentan tres casos:
● Primero, con dos soluciones dadas con la fórmula correspondiente a la ecuación de
segundo grado cuando el discriminante es positivo.
● Segundo, con una solución dada por la fórmula cuando el discriminante es cero.
● Tercero, con dos soluciones complejas, dadas por la fórmula cuando el discriminante
es negativo.
Si a = 0 se presentan a su vez tres casos:
4
 Primero, es cuando b ≠ 0 cuya solución es.
● Segundo, es cuando b = 0 y c = 0, que es evidente una identidad.

● Tercero, cuando b = 0 y c ≠ 0 que no tiene solución.
Ejercicio 4: Realiza un diagrama de flujo para calcular y de acuerdo a lo que se especifica a

continuación. Prueba tu solución.


5
Ejercicio 7: Elabora un diagrama de flujo para leer una lista de enteros positivos, calcular e
imprimir su suma y su promedio. El fin de los datos está indicado por un valor negativo.
Identifica los datos y el resultado esperado. Prueba tu solución.
Ejercicio 8: Elabora un diagrama de flujo para leer n enteros, calcular e imprimir su suma y
su promedio. Identifica los datos y el resultado esperado. Prueba tu solución.
Ejercicio 9: Una tienda desea obtener una serie de reportes diarios a partir de las ventas
realizadas en un día. Elabora un diagrama de flujo que:
a) Solicite el monto de cada venta sin IVA,

b) Para cada venta, calcule e imprima el IVA y el total con IVA,
c) Al terminar el día, imprima un reporte con los totales de:
● Ventas sin IVA
● IVA
● Ventas con IVA
● Promedio de las ventas con IVA
Se desconoce el número de ventas que se realizan en un día, por lo que el final de los datos
se indica con un –1. Considera que el IVA es del 16%.
Identifica los datos y los resultados esperados. Prueba tu solución.
Ejercicio 10: Una tabla de estadísticas muestra la producción de barriles de petróleo de 5

países petroleros (México, Venezuela, Arabia Saudita, Libia y Argelia), durante el primer
semestre de 2015. La tabla tiene el siguiente formato:
bm, bv, bas, bl, ba: No. de barriles/país en enero

bm, bv, bas, bl, ba: No. de barriles/país en febrero
...
bm, bv, bas, bl, ba: No. de barriles/país en junio
Elabora un diagrama de flujo que calcule la producción total de barriles en el semestre y la

de cada uno de los países involucrados.
6
Ejercicio 11: Dados los datos: n, a1, a2,..., an con n > 0. Elabore un diagrama de flujo para
encontrar el máximo de los ai.
Ejercicio 12: Retoma el problema anterior y modifícalo de tal manera que ahora, además
de encontrar el mayor, también identifique cuantos de los n datos son positivos, negativos
o cero.
Ejercicio 13: Una empresa que cuenta con k empleados desea realizar algunos cálculos para
la nueva nómina. Los datos con que cuenta son los sueldos de los k empleados:
k, s1, s2, s3, ..., sk.
Elabora un diagrama de flujo para leer los datos y contestar a las siguientes preguntas:
a) ¿Cuál es el aumento correspondiente a cada empleado según el siguiente criterio?
● 17% si el sueldo es inferior a $5,000
● 10% si el sueldo está entre $5,000 y $15,000
● 5% si el sueldo es superior a $15,000
b) ¿Cuál es el nuevo sueldo para cada empleado?
c) ¿Cuál es el total de la nueva nómina?
d) ¿Cuál es el incremento en la nómina?
e) ¿Cuál es el máximo sueldo nuevo?
f) ¿Cuál es el mínimo sueldo nuevo?
Resuelve los incisos progresivamente.
Ejercicio 14: Una carrera profesional consta de 40 materias, repartidas en 8 semestres a

razón de 5 materias por semestre. Como datos se dan las 40 calificaciones correspondientes
a un alumno. Elabora un diagrama de flujo para leer los datos y contestar a las siguientes
preguntas:
a) ¿Cuál es el promedio del alumno por semestre? Indica tanto el promedio como el
semestre.
b) ¿Cuál es el promedio que obtuvo en la carrera?
c) ¿Cuál fue la calificación más alta por semestre?
d) ¿Cuál fue la calificación más baja de la carrera?
Ejercicio 15: Se dispone del ingreso y del número de habitantes de cada uno de los estados
de la República Mexicana. Identifica cuántos y de qué tipo serán los datos que se ingresarán,
si se necesita un diagrama de flujo para:
a) Calcular e imprimir el ingreso per cápita de cada estado que resulta de la división
entre el ingreso y el número de habitantes.
b) Calcular el ingreso per cápita total de la República Mexicana que resulta de dividir la
suma de los ingresos entre la suma de los habitantes.
7
Identifica cuáles y cuántos son los resultados esperados. Además, decide de qué manera se
deberán proporcionar los datos para poder, aplicando el algoritmo diseñado, llegar a esos
resultados.
Ejercicio 16: Dados los valores: n, p1, p2,..., pn con n ≥ 2, donde los pt (t = 1,...,n) representan
los índices de precios al consumidor de varios años. Elabora un diagrama de flujo para
calcular e imprimir:
a) La tasa de inflación entre años consecutivos:
b) La tasa media inflacionaria:
Ejercicio 17: Sean los datos:

n, a1, a2,..., an
Donde:
n es un entero positivo, no necesariamente múltiplo de tres, que indica el total de
datos que el usuario va a ingresar.
ai son los números que el usuario ingresa.
Haz un diagrama de flujo para calcular la siguiente suma:
Ejercicio 18: Dados los datos:
n, x, a0, a1, a2, ..., an

con: n: entero,  0
x: real
ai: reales
Elabora un diagrama de flujo que, sin utilizar la operación de potencia y minimizando el

número de multiplicaciones, (y observando los signos), calcule:
a0 – a1*x + a2* x2 – a3 * x3 + . . . ± an * xn
¿Existe una única manera de alternar los signos?
8
4- Retos Algorítmica
Ejercicio 1: Un agricultor sembró en sus parcelas 4 tipos diferentes de jitomates. Cada tipo
de jitomate puede ser sembrado en más de una parcela. Los datos referentes a la cosecha
se dan a continuación:
precioJit1, precioJit2, precioJit3, precioJit4
tipoJit1, numcajas1
tipoJit2, numcajas2
tipoJit3, numcajas3
...
-1, -1
Donde:
precioJitj precio de la caja de jitomate tipo j
tipoJiti tipo de jitomate (1, 2, 3 o 4) sembrado en la parcela i
numcajasi número de cajas cosechadas en la parcela i
-1, -1 bandera de fin de datos
No se sabe cuántas parcelas sembró el agricultor. Cada pareja de datos representa una
parcela.
Realiza un diagrama de flujo para contestar lo siguiente:
a) ¿Cuál es el número total de cajas cosechadas de cada uno de los 4 tipos de jitomate?
b) ¿En cuántas parcelas se sembró el jitomate tipo 2?
c) ¿Qué tipo de jitomate dejó más dinero por su venta, suponiendo que todas las cajas
cosechadas se vendieron?
d) ¿Cuántas parcelas produjeron más de 20 cajas?
Ejercicio 2: El próximo mes de julio se llevarán a cabo las elecciones presidenciales en

México. Solamente hay cuatro partidos (1, 2, 3 y 4) que tienen oportunidad de ganarlas.
Uno de los partidos desea realizar una encuesta a n personas sobre sus preferencias para
decidir la estrategia a seguir. A cada persona entrevistada se le pregunta: si va a votar, y en
caso de que vote, por cuál partido votará.
Los datos son:
n
resp1 (partido1)
resp2 (partido2)
...
respn (partidon)
Donde:
n es el número de personas a entrevistar
resp indica si la persona votará o no (N o n = no votará, S o s = sí votará)
partido indica la clave del partido por el que votará: 1=PAN, 2=PRD, 3=PRI,
4=MORENA
9
Nota: el dato partido solamente se lee si la persona entrevistada ha contestado que sí
votará.
Se desea que hagas un diagrama de flujo para contestar las siguientes preguntas:
a) ¿Cuál es el porcentaje de abstenciones?

b) ¿Cuál es el porcentaje de votos a favor de cada partido en base al total de personas
que van a votar?
c) ¿Cuál es el partido favorito?
d) Nombre del partido, si existe, al que ninguno de los entrevistados (que sí votarán)
va a votar
Ejercicio 3: Se cuenta con la siguiente información de ventas de un camión repartidor de

gas estacionario durante el mes de enero:
precio
surtido1,1, surtido1,2, …, -1
…
Donde:
precio es el precio de un litro de gas
surtidoi,j es el número de litros de gas surtidos por el camión en su parada j del día i
Realiza un diagrama de flujo que permita calcular:
a) ¿Cuál fue el monto total (en pesos) de las ventas realizadas por el camión durante
el mes de enero?
b) ¿Cuál fue el día en el que surtió más litros de gas el camión?
c) ¿Cuántos días no trabajó el camión? (líneas que sólo contienen –1)
d) ¿Cuál fue el promedio de litros surtidos en cada día de trabajo?
Ejercicio 4: Realiza un diagrama de flujo para resolver el siguiente problema: Inicialmente

recibes un dato de entrada llamado suerte, que es considerado el número de la suerte, el
objetivo de tu solución es pedir números enteros (positivos o negativos) hasta que el
usuario adivine o llegue a 10 intentos. Por cada número que dé el usuario tu algoritmo debe
indicarle si el número de la suerte es mayor o menor al número dado. Al finalizar, tu
algoritmo debe imprimir un mensaje adecuado indicando al usuario si adivinó o no y, si lo
hizo, cuantos intentos lo logró.
Ejercicio 5: En la pasada Feria del Libro de Guadalajara se realizó una encuesta a los
asistentes con el fin de obtener algunas estadísticas acerca del público en general. Cada
asistente fue identificado con una clave en el momento de su registro y se le preguntó
cuántos libros había leído en el transcurso del año y cuántas páginas tenía cada uno de ellos,
el formato de los datos era el siguiente:
10
claveAsistente1
n1 pag1, pag2 …pagn1
claveAsistente2
claveAsistente3
-1
Como no se sabe cuántos asistentes habrá en total a lo largo de la Feria, el fin de datos está
señalado con un -1 en la claveAsistente de tipo numérica.
Se desea que hagas un diagrama de flujo que permita contestar las siguientes preguntas:
a) ¿Cuántos asistentes hubo en la Feria?

b) Para cada asistente: ¿Cuál es el promedio de páginas por libro que leyó?
c) ¿Cuántos asistentes NO leyeron ningún libro?
d) ¿Cuál fue el asistente que leyó más páginas?
e) ¿Cuál es el promedio de páginas leídas por todos los asistentes a la Feria?
f) ¿Cuál es la clave del asistente que leyó el libro con el menor número de páginas?
Ejercicio 6: Escribe un diagrama de flujo que pida primero un número (límite) y después
pida números hasta que la suma de los números introducidos supere el número límite. El
programa termina escribiendo el promedio de los números proporcionados (excepto el
número límite).
Ejercicio 7: En el Sistema Meteorológico Nacional se tiene la información de precipitaciones

pluviales en los días que ha llovido durante el último mes de agosto. La información se
proporciona de la siguiente manera:
diaMes1
hora1, precipitación1, duración1
...
-1, -1, -1
diaMes2
...
-1, -1, -1
...
-1
11
Donde:
diaMesi representa el número del día del mes de agosto (cualquier número entre 1-
31) en el que hubo precipitación pluvial registrada. Cada precipitación pluvial del día
se indica con tres valores:
▪ horaj representa la hora del día (0 a 24) en la que inició la precipitación
pluvial.
▪ precipitaciónj representa la caída de lluvia en un valor numérico por m2.
▪ duraciónj representa los minutos durante los cuales llovió sin
interrupción.
No se sabe a priori cuántas precipitaciones se presentan al día por lo que cuando ya
no haya más lluvias registradas en el día, el usuario ingresará -1, -1, -1.
Se te pide hacer un diagrama de flujo que conteste las siguientes preguntas:

a) ¿Cuál es el total en m2 de precipitación pluvial registrada durante el mes?
b) ¿Cuántos días hubo menos precipitaciones pluviales por la tarde (de las 12 a las 24
horas) que por la mañana (de las 0 a las 1159)? Considera la hora de inicio de la lluvia
para contestar esta pregunta.
c) El número de día en el que se presentó la precipitación más larga (en duración) de
todas las del mes.
d) ¿Cuántos días hubo 10 o más precipitaciones pluviales?
Ejercicio 8: Una importante empresa de software organizó un concurso entre alumnos de

carreras en el área de computación de todo el mundo. Durante el concurso presentó una
lista de clases a los participantes para que las desarrollaran en un cierto tiempo. Cada
participante programó las clases que pudo en ese tiempo y las envió para su evaluación.
Sólo se podían enviar las clases que no tenían errores y que hacían lo especificado. La
empresa buscaba detectar “mentes brillantes” a través de la manera en la que resolvieron
los problemas.
Los datos se proporcionan de la siguiente manera:
n
nombreParticipante1,
k1,
líneas1,1, líneas1,2, …, líneas1, k1
nombreParticipante2,
k2,
líneas2,1, líneas2,2, …, líneas2, k2
…
12
nombreParticipanten,
kn,
líneasn,1, líneasn,2, …, líneasn, kn
Donde:
● n: número de participantes (n > 0)
● nombreParticipantei: nombre del participante i
● ki: total de clases programadas por el participante i
● líneasi,j: total de líneas de código programadas por el participante i, en la clase j
Antes de analizar la solución diseñada, se quiere analizar la productividad de cada

participante por lo que se te pide hacer un diagrama de flujo que:
a) Obtenga e imprima el total de líneas de código que programó cada participante.
b) Encuentre e imprima, si es posible, el total de participantes que programaron por lo
menos 3 clases con más de 100 líneas de código.
c) Obtenga e imprima el nombre del participante que programó las clases con el
promedio más bajo de líneas de código.
d) Obtenga e imprima el promedio de clases programadas por los participantes.
Ejercicio 9: Realiza un diagrama de flujo que lea un número entero positivo y obtenga e
imprima el dígito más significativo. Por ejemplo, si el número dado es 8704, se deberá
imprimir 8 acompañado de un mensaje adecuado.
13
5- Mapas de Memoria
Ejercicio 1: El siguiente diagrama de flujo tiene un fin específico:
a) Realiza el mapa de memoria, primero con n = 10 y posteriormente con n = 456.

Analiza los resultados y di qué hace en forma breve y concisa.
b) Marca en el diagrama las estructuras algorítmicas usadas, indicando cuáles son.
Nota: n, x y k son enteros
14
Ejercicio 2: Considera los siguientes diagramas de flujo y para cada uno: indica sobre él las
estructuras algorítmicas utilizadas, cuántas instrucciones contiene cada una de ellas y
dibuja el mapa de memoria.
a) Datos: 1 3 1 1 0
15
b) Datos: 2 5 3 0
16
c) Datos: 1 3 1 2 0
17
d) Dato: 5
18
Ejercicio 3:
Para el siguiente diagrama de flujo:

a) Haz el mapa de memoria para los valores -4, 2, 782, 15, indicando que imprime.
b) Marca y nombra claramente las estructuras algorítmicas que contiene el diagrama.
c) Para cada estructura algorítmica di cuántas instrucciones tiene.
19
6- Conceptos de Programación Orientada a Objetos (POO) y
diagramas UML
Esta sección incluye ejercicios para practicar los conceptos vistos de POO y la elaboración
de diagramas UML. En algunos de los problemas sólo se te pide identificar a los miembros
de una clase, mientras que, en otros, además deberás representar la clase con un
diagrama UML. En este último caso, también tendrás que incluir constructor(es), métodos
get’s/set’s necesarios y la funcionalidad mínima requerida de toda clase.
Ejercicio 1: La clase Dulce se quiere utilizar para representar los dulces en un sistema para
una tienda. Cada dulce tiene un sabor y color diferente de acuerdo a los ingredientes que
lo componen. Cada uno viene envuelto de manera individual y tiene un peso específico.
Como los dulces se venden a granel, el cliente compra los dulces que desea en bolsas de 1
Kg, 1.5 Kg o 2 Kg. Los dulces han sido, tradicionalmente, de tres tipos diferentes: caramelo,
chicloso o líquido; sin embargo, últimamente el dueño ha comenzado a fabricar dulces con
relleno, lo cual implica tener un nuevo tipo de dulce llamado relleno y hacer algunos
cambios en dulces ya existentes (por ejemplo, las paletas de caramelo ahora tienen relleno).
Se ha decidido por políticas de la tienda, que cada dulce determine su papel de envoltura,
en función de su sabor y color.
A continuación, se presenta una lista de palabras que se pueden utilizar en el diseño de esta
clase, señala en cada caso si es un atributo (propiedad), un método o una función de la
clase, si es método o función indica si necesita parámetros o no, en caso de necesitarlos
indica cuales serían, si se trata de una función indica también de qué tipo es y por qué. Es
muy importante que justifiques tu respuesta ya que la evaluación depende en gran medida
de tu justificación.
1. sabor
2. determinaEnvoltura
3. color
4. envoltura
5. cambiaTipo
6. tipo
7. peso
8. calculaDulcesPorBolsa
9. dameTipo
Ejercicio 2: Una factura es un comprobante en el cual se reflejan las transacciones

realizadas, bien de las mercancías vendidas o de los servicios prestados. Es el justificante
que acredita la venta realizada. Actualmente, la Compañía X está diseñando un sistema para
trabajar con la factura electrónica, pasar de sus facturas en papel a medios electrónicos y
20
desea le ayudes a diseñar una clase Factura. Después de investigar, encuentras que los
requisitos para la factura electrónica son: folio consecutivo, fecha expedición, razón social
de quien emite la factura así como del comprador, domicilio del vendedor y domicilio del
comprador, número de identificación fiscal (otorgado por la Administración de los
Impuestos de cada país), descripción del producto con indicación del precio, cantidad,
importe total, así como los impuestos que gravan la operación separando e indicando tanto
el porcentaje como el monto, firma electrónica avanzada, sello digital y cadena original (los
cuales se conforman con la información completa de la factura). El dueño de la Compañía X
quiere manejar una factura por cada tipo de producto, añadirle además el logo de la
empresa, indicar la forma de pago y el correo electrónico del cliente, quiere también poder
reflejar los descuentos otorgados a sus clientes. El dueño de la Compañía X desea que las
operaciones de la factura como: totales por producto (cantidad * precio unitario), aplicación
del descuento (sobre total de la factura), aplicación del IVA (sobre total de la factura –
descuentos) y cálculo del monto a pagar, que ampara la factura (total factura – descuentos
+ impuestos) se calculen automáticamente. Una vez que se introduce la información
completa de la factura se deben generar la “cadena original” y el “sello digital” para poder
enviar la factura como archivo .pdf y .xml al correo electrónico del cliente.
A continuación, se presenta una lista de palabras que se pueden utilizar en el diseño de esta
clase. Determina para cada una de ellas, si es un atributo (propiedad), un método o una
función de la clase. Si es método o función indica si necesita parámetros o no, en caso de
necesitarlos indica cuales serían, si se trata de una función indica también de qué tipo es y
porqué. Es muy importante que justifiques tu respuesta ya que la evaluación depende en
gran medida de eso.
1. folio
2. calculaMontoAPagar
3. asignaCliente
4. totalFactura
5. calculaIVA
6. selloDigital
7. fecha
8. calculaDescuento
9. dameFolio
10. enviaFactura
Ejercicio 3: El ITAM desea almacenar la información de sus alumnos. De cada uno necesita
tener su nombre, edad, promedio, carrera en la que está inscrito (considere solo una), total
de créditos de las materias que actualmente está cursando y número de materias
aprobadas. Cada alumno debe ser capaz de calcular el costo del semestre actual dado el
precio de un crédito. Recuerda poner los métodos y funciones necesarias para que tu clase
21
tenga la funcionalidad mínima requerida. Diseña una clase que se ajuste a lo anterior y
represéntala por medio de un diagrama UML.
Ejercicio 4: El dueño del club deportivo “MiClub S.A. de C.V.” quiere que le ayudes a
organizar las Membresías de sus clientes, cada Membresía tiene un número, el nombre del
cliente, dirección del cliente, tipo de membresía (A, B o C), año de inscripción del cliente y
si toma clases particulares de algún deporte. Cada Membresía debe de ser capaz de indicar
el costo mensual de la misma (para lo cual debe recibir el costo base y considerando el tipo
de membresía, la antigüedad y si toma clases particulares de algún deporte, calcular el
monto a pagar mensual) así como, indicar la antigüedad en años del cliente. Si un cliente
cambia de dirección, la Membresía debe actualizarse, de igual manera debe actualizarse,
cuando decide ya no tomar clases particulares de algún deporte. De acuerdo a lo descrito
más arriba, identifica atributos, métodos o funciones específicos de la clase y funcionalidad
mínima. Representa la clase por medio de un diagrama UML.
Ejercicio 5: Considera que estás encargado de desarrollar un sistema de inventario para una
armadora de autos, la cual “arma” varios tipos de autos a partir de un grupo de partes que
compra a los respectivos fabricantes. En el sistema de inventario se requieren varias clases,
una de ellas se describe a continuación. De cada parte se debe guardar su clave, su nombre,
una breve descripción, país de origen, precio, color, número de unidades disponibles, entre
otras características. Es importante que a cada parte se le pueda cambiar su color, precio,
país de origen y descripción. También se requiere consultar la cantidad de unidades que hay
en inventario. Por último, se quiere determinar si es “momento de comprar” una parte, lo
cual depende de si la cantidad de unidades es menor a un valor que se ingresa de acuerdo
a la demanda de autos.
a) ¿Cómo debe llamarse la clase? _________________________
b) Identifica 3 atributos, indica un nombre y un tipo de dato para cada uno de ellos.
1. _________________________________________________________
2. _________________________________________________________
3. _________________________________________________________
c) Identifica 2 métodos, indica su nombre y los parámetros si fueran necesarios. Si
requiere parámetros, debes indicar también de qué tipo de dato son.
1. _________________________________________________________
2. _________________________________________________________
d) Identifica 2 funciones, indica su nombre, el tipo de la función y los parámetros si

fueran necesarios. Si requiere parámetros, debes indicar también de qué tipo de
dato son.
1. _________________________________________________________
2. _________________________________________________________
22
Ejercicio 6: Una fábrica de productos lácteos está interesada en actualizar sus sistemas de
información. El equipo encargado está en la etapa de analizar los procesos y los
requerimientos para posteriormente hacer el diseño de los sistemas. Uno de los ingenieros
hizo las siguientes anotaciones con respecto a los productos que se fabrican. Todos ellos se
caracterizan en que son fabricados usando leche vacuna o leche de cabra (algunos quesos).
Sin embargo, se distinguen por el nombre comercial, sabor, tipo (queso, yogur, leche, etc.),
ingrediente adicional (levadura, bacilos, frutas, etc.), color, empaque y consistencia
(líquidos o cremosos). Se necesita determinar el empaque según el tipo y la consistencia.
Se deben poder cambiar los ingredientes adicionales y el nombre comercial. También debe
permitir consultar el sabor. Otra necesidad es que se debe poder calcular “la prioridad” de
la fabricación de un producto de acuerdo a su tipo, consistencia y la estación del año en la
que se está (primavera, verano, otoño o invierno).
Una vez leído y analizado el texto anterior, señala:
a) Nombre de la clase: _________________________
b) Atributos (nombre y un tipo de dato) para cada uno de ellos
c) Métodos (nombre y los parámetros si fueran necesarios)
d) Funciones (nombre, el tipo de la función y los parámetros si fueran necesarios)
Posteriormente representa la clase por medio de un diagrama UML.
Ejercicio 7: Representa por medio de un diagrama UML la figura geométrica “pentágono”

(tiene 5 lados iguales y una apotema). A los pentágonos se les puede calcular su perímetro
y su área con unas fórmulas sencillas. Los lados y la apotema del pentágono son números
que pueden tener decimales. Analiza el problema y decide qué atributos y métodos se
requieren.
Ejercicio 8: Se están actualizando los sistemas de una galería de arte que vende obras de
pintores contemporáneos mexicanos. De cada obra se registra el nombre del autor, el
nombre de la obra, la técnica (‘O’ óleo, ‘A’ acuarela, ‘G’ gouache, ‘X’ otras), el precio base y
el tamaño (ancho y alto). Para poder llevar el registro de las obras, a medida que ingresen
a la galería se les asignará una clave de manera automática, a partir del 1001. Decide cuáles
atributos podrán ser consultados y cuáles podrán ser modificados y considera los métodos
necesarios para llevar a cabo estas operaciones. También debes tener en cuenta que las
obras deben poder compararse entre sí usando sus claves y se debe poder tener toda la
información de ellas. Por último, se necesita poder calcular el precio de venta de una obra
de la siguiente manera: precio base más 25% si es óleo, 20% si es acuarela, 18% si es
gouache y 10% para cualquier otra técnica. Además, si la obra mide más de 14,000cm2,
independientemente de la técnica usada, se deberá incrementar su precio en 10%. Todos
los meses la galería promociona la obra de un pintor dando un descuento especial a sus
obras. La galería indica el nombre del pintor y el porcentaje (%) de descuento otorgado. Por
23
lo tanto, para calcular el precio de venta se debe también considerar el posible descuento.
Realiza el diagrama UML de la clase, indicando el nombre de la clase, los atributos, su(s)
constructor(es) y los métodos que requiere. Agrega los métodos necesarios para darle la
funcionalidad mínima a la clase, de acuerdo al enunciado anterior.
Ejercicio 9: La tienda “Anda en Bici” solicita a los alumnos de Algoritmos y Programas una
aplicación en java para realizar una clase que modele las bicicletas que fabrican y venden,
ya que están personalizadas. Cada bicicleta tiene un número de identificación único
(generado automáticamente a partir del número 200), un tipo, número de accesorios extras
y material de fabricación (aluminio o fibra de carbono). Cada bicicleta se puede construir
con todos los datos o sólo con el tipo y material de fabricación. Los tipos válidos de bicicleta
son: ‘U’: urbana, ‘P’: de pista o ‘M’: de montaña. Es necesario que cada bicicleta pueda
calcular su costo.
● El costo base para la bicicleta urbana es de $ 7000 pesos.
● El costo base para la bicicleta de pista es de $ 15,000 pesos.
● El costo base para la bicicleta de montaña es de $ 27,000 pesos.
El costo final se calcula dependiendo del tipo de bicicleta, material de fabricación y número
de accesorios, de la siguiente manera: al costo base se le aumenta $2,000 pesos por ser de
aluminio o $5,000 por ser de fibra de carbono; si el número de accesorios es menor a 3, no
hay costo adicional, pero si son 3 o 4 accesorios se cobra $600.00 pesos adicionales y si son
más de 4 accesorios se cobran $1,000 pesos adicionales. Decide cuáles atributos podrán ser
consultados y cuáles podrán ser modificados y considera los métodos necesarios para llevar
a cabo estas operaciones. Las bicicletas deben poder compararse entre ellas, el criterio de
comparación será el número de identificación único.
Una vez leída y analizada la información proporcionada, realiza el diagrama UML de la clase
identificada.
24
7- Programación en Java
Antes de resolver cada problema, ten en cuenta que:
● Para encontrar la solución a un problema, primero debes entenderlo. Dada la

descripción del problema planea (lee la información, identifica los elementos más
importantes: entradas, resultados, operaciones, etc.) cómo vas a realizar tu
trabajo. Luego diseña la solución y representa a la misma (diagramas UML y
algoritmos en pseudo código). Define los casos de prueba que usarás para evaluar
tu solución. Una vez que tengas una idea clara de todo el problema y de la solución
del mismo (expresada por medio de clases y algoritmos) impleméntala utilizando
el lenguaje Java. Por último, prueba tu solución usando los casos de prueba
previamente elegidos. Asegúrate que los resultados son los esperados según la
descripción del problema. Si encuentras errores debes corregirlos hasta que tu
programa quede libre de ellos.
● Es necesario leer cuidadosamente el enunciado de cada problema. Identifica qué
parte de la descripción está haciendo referencia a un dato que puedes generalizar
y qué parte está relacionada con la solución del problema concreto que se te
presenta. Cuando tengas esto claro, representa lo primero como una clase que
podrá ser usada posteriormente. Es decir, trata que sea general. En cambio, la
segunda parte debe ser representada por una clase que se ajusta al problema
actual
● A medida que los problemas que analices se tornen más complejos, puede resultar
necesario crear más de una clase general, mientras que siempre tendrás una clase
con un método main.
● En tus clases vas a incluir dos tipos de miembros: atributos (son las características
de lo que está siendo representado por medio de la clase) y métodos (son las
operaciones válidas a aplicarse sobre los atributos de la clase).
● Los atributos siempre se declaran privados. Cuando se use herencia se podrán
declarar protegidos, si el problema lo justifica.
● En cada clase incluye los métodos equals(), hashCode(), compareTo() y toString(),
y los métodos get() y set() necesarios.
● Para la codificación de tu solución debes seguir los lineamientos que se encuentran
en Comunidad.
Existen algunos atributos de calidad que son necesarios o deseables en los productos de
software que generamos. Es importante que vayas desarrollando la disciplina necesaria
para que todos los programas que escribas puedan considerarse productos de calidad. A
continuación, se mencionan algunos de los atributos más importantes:
25
 Correctitud (Correctness)
 Robustez (Robustness)
 Desempeño (Eficciency)
 Usabilidad (Usability)
 Verificabilidad (Verifiability)
 Mantenibilidad (Maintainability)
o Reparabilidad (Reparability)
o Evolucionabilidad (Evolvability)
 Reusabilidad (Reusability)
 Comprensibilidad (Understandability)
 Interoperabilidad (Interoperability)
 Entrega a tiempo (Timeliness)
Ejercicio 1: Un rectángulo se caracteriza por tener cuatro lados, de los cuales hay dos pares
de lados iguales. Asimismo, se sabe que las operaciones que permiten calcular el área y el
perímetro del rectángulo son muy útiles. De acuerdo a esta información y, teniendo en
cuenta lo mencionado en la introducción:
a) Realiza el diagrama de la clase Rectangulo en UML.

b) Escribe la clase Rectangulo usando el lenguaje Java.
c) Prueba la clase Rectangulo en la clase PruebaGeometrico.
Ejercicio 2: Un círculo se caracteriza por el valor de su radio. Asimismo, se sabe que las
operaciones que permiten calcular el área y la circunferencia del círculo son muy útiles. De
acuerdo a esta información y, teniendo en cuenta lo mencionado en la introducción:
a) Realiza el diagrama de la clase Circulo en UML.
b) Escribe la clase Circulo usando el lenguaje Java.
c) Prueba la clase Circulo en la clase PruebaGeometrico.
Ejercicio 3: Considera que se necesita calcular el espacio ocupado por 3 mesas rectangulares
que se colocarán en una sala. Se sabe que la primera mesa mide 2 x 1.8 metros, la segunda
1 x 1.5 metros y la tercera 3 x 2 metros. Crea la clase CalculaEspacio con un método main
que, usando la clase del ejercicio 1, calcule e imprima el espacio ocupado por las tres mesas.
Ejercicio 4: Considera que se tiene una oficina rectangular (el usuario deberá darte las
medidas) que está cubierta por 3 tapetes circulares. En la clase del problema anterior,
modifica el main para que pueda, además, usando las clases de los ejercicios 1 y 2, calcular
e imprimir el área de la oficina que NO está cubierta por los tapetes.
26
Ejercicio 5: Modifica el ejercicio 4 de manera que ahora tengas n oficinas rectangulares (que
pueden ser de diferente tamaño) y en cada una de ellas k tapetes circulares. ¿Cuál es el
área total descubierta considerando todas las oficinas?
Ejercicio 6: Programa la clase CientificoMatematico según el siguiente diagrama UML:
CientificoMatematico
-nombre: String
-areaEspecialidad: String
…
+CientificoMatematico()
+CientificoMatematico(String,String….)
+getNombre(): String
+setAreaEspecialidad (String): void
+getAreaEspecialidad (): String
+toString():String
….
….
Puedes agregar los métodos que creas conveniente. Considera lo enunciado en la

introducción.
Ejercicio 7: En la clase CientificoMatematico agrega el método estaOrdenCreciente(int

número1, int número2): boolean que regresa true si los números dados están en orden
creciente.
Ejercicio 8: En la clase CientificoMatematico agrega el método ordenaCreciente(int

número1, int número2): String que regresa una cadena formada con los dos números
dados, ubicados de tal manera que estén ordenados de forma creciente y separados por un
guión. Es decir, si la entrada es 26 y 23, el método deberá regresar 23–26.
Ejercicio 9: En la clase CientificoMatematico agrega el método esImpar(int número):

boolean que regresa true si el número recibido como parámetro es impar y false en caso
contrario.
Ejercicio 10: En la clase PruebaCientificoMatematico escribe un método main en el cual se

construya un objeto del tipo CientificoMatematico y se prueben todos los métodos
desarrollados en los ejercicios anteriores.
27
Ejercicio 11: En la clase CientificoMatematico agrega el método calculaFuncion1 (double
x): double que calcula y regresa el resultado de la función que se muestra a continuación.
Al terminar, prueba tu método en la clase PruebaCientificoMatematico.
Ejercicio 12: En la clase CientificoMatematico agrega el método calculaFuncion2(int x):

double que calcula y regresa el resultado de la función que se muestra más abajo.
Al terminar, prueba el método en la clase PruebaCientificoMatematico.
Ejercicio 13: en la clase CientificoMatematico agrega el método calculaFuncion3(int num,

int v): double que calcula y regresa el resultado de la función que se muestra más abajo.
28
Ejercicio 14: Un número complejo consta de una parte real y una parte imaginaria teniendo
la forma a + bi, donde a y b son números reales. Así, en el número complejo 1.5 + 3.4i, 1.5
es la parte real, y 3.4 es la parte imaginaria; en el número complejo 2.3 - 4.8i, 2.3 es la parte
real, y -4.8 es la parte imaginaria. Considerando, además, la funcionalidad básica de una
clase en Java, escribe la clase Complejo (en UML y en Java).
Ejercicio 15: Una calculadora científica puede realizar operaciones con números complejos.
Define la clase CalculadoraCompleja de tal manera que pueda sumar, restar, multiplicar y
dividir números complejos.
Recuerda que para los números complejos a + bi y c + di, las operaciones se definen de la
siguiente manera:
● Suma: (a + bi) + (c + di) = (a + c) + (b + d)i
● Resta: (a + bi) - (c + di) = (a - c) + (b - d)i
● Multiplicación: (a + bi) * (c + di) = (ac - bd) + (ad + bc)i
● División: (a + bi) / (c +di) = ( (ac + bd) + (bc – ad)i ) / (c2 + d2) con c2+d2 diferente de
cero
Ejercicio 16: Prueba los resultados del ejercicio anterior con una clase
PruebaCalculadoraComplejos. Debes presentar al usuario un menú de operaciones a
realizar con números complejos, leer la opción del usuario, la cual será expresada a través
del símbolo correspondiente a la operación (‘+’, ‘-‘, ‘*’, ‘/’), posteriormente debes leer dos
números complejos, mandar llamar a la operación indicada y mostrar el resultado, sin
olvidar la validación pertinente en el caso de la división.
El programa debe permitir al usuario ejecutar tantas operaciones como desee, hasta que
indique la opción de salida (‘s’).
Realiza los algoritmos necesarios, diagramas de flujo y diagramas de clase UML antes de
realizar el código.
Ejercicio 17: Una venta se caracteriza (de manera muy simplificada) por el monto y el
nombre del vendedor que la realizó. En la clase, además de los atributos, se debe incluir el
método calculaComisión(): double, el cual calcula y regresa la comisión que le corresponde
al vendedor por realizar dicha venta. Si la venta es menor a $1,000, se le otorga el 3% de
comisión. Si la venta es de $1,000 o más, el vendedor recibe el 5% de comisión. De acuerdo
a esta información se te pide:
a) Realizar el diagrama de la clase Venta, usando el lenguaje UML.
b) Escribir la clase Venta usando el lenguaje Java.
c) Escribe la clase PruebaVenta en la cual se crean dos objetos del tipo ventas
considerando una venta de $850 y otra de $2350.
29
Ejercicio 18: En la clase CientificoMatematico agrega el método generaSerieAscendente(int
n): String que genera y regresa los primeros n números naturales en forma de cadena,
siendo n >1. Es decir, deberá generar una cadena de la forma 1 2 3 4 5... n. Al terminar,
prueba el método en la clase PruebaCientificoMatematico.
Ejercicio 19: En la clase CientificoMatematico agrega el método

generaSerieDescendente(int n): String que genera y regresa los primeros n números
naturales en forma de cadena, siendo n >1. Los elementos de la serie deben estar en orden
descendente. Es decir, deberá generar una cadena de la forma n n-1... 3 2 1.
Ejercicio 20: En la clase CientificoMatematico agrega el método encuentraPares(int n):

String que encuentra y regresa los primeros n números pares en forma de cadena, siendo n
>1. Es decir, deberá generar una cadena de la forma 2 4 6 8... Al terminar, prueba el
método en la clase PruebaCientificoMatematico.
Ejercicio 21: Se requiere representar de manera simplificada el concepto Persona por

medio de una clase de Java. Para resolver el problema tienes que pensar cuales son las
características del concepto que estás representando con la clase (toda persona tiene un
nombre, el CURP, un domicilio, etc.). De esta forma puedes determinar los atributos de la
clase. Luego piensa cuales son las operaciones que pueden aplicarse sobre los atributos y
que pueden requerirse de manera frecuente. Una persona puede cambiar de domicilio, de
teléfono, de estado civil, se puede necesitar su CURP, su nombre, etc.
Persona
- nombre: String
- curp: String
- domicilio: String
- teléfono: int
- estadoCivil: String
….
+Persona()
…..
+getCurp(): String
….
30
Ejercicio 22: Realiza una clase PruebaPersona para probar la funcionalidad de la clase
Persona del ejercicio anterior.
Ejercicio 23: Se necesita una aplicación en Java para dar de alta cuentas bancarias. Cada
cuenta bancaria tiene un número de cuenta, el nombre del cliente y el saldo. Las cuentas
deben activarse con el nombre del cliente y se les asigna automáticamente el número de
cuenta, el depósito inicial es opcional. A cada cuenta se le deben poder realizar depósitos
y retiros, verificando que estos procedan y regresando un resultado que indique si se pudo
o no. A cada cuenta se le puede preguntar su saldo en cada momento, así como toda la
información propia de la cuenta.
Las cuentas deben poder compararse entre ellas, el criterio de comparación será el número
de cuenta.
Después de analizar cuidadosamente el problema:
● Realiza un diagrama UML de la clase CuentaBancaria, identifica los atributos y los
métodos necesarios para que tenga la funcionalidad mínima requerida.
● Escribe la clase CuentaBancaria en Java.
● Crea una clase PruebaCuentaBancaria para probar tu clase CuentaBancaria, dando
de alta 2 cuentas: una para José Pérez con $3’000.00 y otra para Juana García.
● Para la cuenta de Juana García registra un depósito de $4’000.00.
● Para la cuenta de José Pérez registra un retiro de $10’000.00.
● Para la cuenta de José Pérez registra un depósito de $1’000.00.
● Compara ambas cuentas imprimiendo un mensaje adecuado.
Ejercicio 24: Una agencia de renta de automóviles desea llevar el control de los autos que
renta, para cada auto se tiene una clave única (asignada por el sistema), la marca del auto,
el año, número de kilómetros, nombre y el número de la licencia del cliente al que se le
renta el automóvil.
Crea la clase Auto en Java con los atributos mencionados anteriormente. Además de la
funcionalidad mínima requerida la clase debe incluir diferentes métodos para poder
registrar una renta y/o una devolución:
● La renta del auto incluye tomar los datos del cliente que lo renta: nombre y número
de licencia, pedir el número de días para el cálculo de la renta. Se cobra por
adelantado. Si el año del auto es anterior a 2005 la renta diaria es de $200.00 y para
automóviles de años posteriores la renta es de $300.00. Si el automóvil tiene menos
de 20,000 km se le cobra un sobreprecio de $ 20.00 por día.
● La devolución del auto incluye borrar los datos del cliente del auto y aumentar el
número de kilómetros recorridos del mismo.
● Realiza el diagrama de clase UML antes de realizar el código.
● Escribe la clase Auto en Java
31
Posteriormente define la clase PruebaAuto donde se haga la instancia de 5 autos que son
con los que está empezando a operar. Después realiza la renta de 2 autos, calcula e imprime
el cobro respectivo a los clientes y realiza la devolución de uno de ellos.
Ejercicio 25: Realiza una clase llamada Calculadora. Programa los métodos estáticos que
corresponda para que se calcule la multiplicación y la potencia sin usar operadores ni
funciones matemáticas predefinidas (biblioteca Math) en Java.
Ejercicio 26: En la clase Calculadora agrega el método estático calculaUllman(int número):

String que genera y regresa los elementos correspondientes a la conjetura de Ullman (en
honor al matemático S. Ullman). Con el dato recibido (número > 1) como parámetro genera
los elementos según se indica a continuación:
1. Empieza con el número dado.
2. Si es par, divídelo entre 2; si es impar multiplícalo por 3 y agrégale 1.
3. Obtén enteros sucesivamente repitiendo el proceso, hasta llegar al 1.
Siempre se llega al número 1, independientemente del entero inicial. Por ejemplo, si el
entero inicial fuera 26, la secuencia será:
26 13 40 20 10 5 16 8 4 2 1
Ejercicio 27: En la clase Calculadora agrega el método estático generaCubosNicomano(int

n): String que genera y regresa –en forma de cadena- los primeros n cubos de Nicómaco.
Para ello, considera la siguiente propiedad descubierta por Nicómaco de Gerasa: “Con el
primer número impar, se obtiene el primer cubo. Sumando los dos siguientes impares se
obtiene el segundo cubo. Sumando los tres siguientes, se obtiene el tercer cubo, etc.”
Es decir: 1 = 1 3,
3 + 5 = 23 = 8,
7 + 9 + 11 = 33 = 27,
13 + 15 + 17 + 19 = 43 = 64.
Ejercicio 28: Retoma la clase Calculadora. Agrégale el método estático calculaFactorial(int

n): int que calcula y regresa el factorial de n (con n ≥ 0).
Ejercicio 29: Retoma la clase Calculadora. Agrégale el método estático

calculaMaximoComunDivisor(int m, int n): int que calcula y regresa el Máximo Común
Divisor de dos números enteros, aplicando el algoritmo de Euclides que establece: si m>=n,
MCD(m,n) = MCD(n, m % n). Si n=0, MCD(m,n) = m.
Ejercicio 30: retoma la clase Calculadora. Agrégale el método estático

generaSerieFibonacci(int n): String que calcula y regresa –en forma de cadena- los primeros
32
n números de la serie de Fibonacci. Recuerda que los dos primeros números de la serie son
0 y 1. A partir del tercero se calcula como la suma de los dos números que le preceden.
Ejemplo: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …
Ejercicio 31: Retoma la clase Calculadora. Agrégale el método estático calculaSerie1(int n):
int que calcula y regresa el resultado de la siguiente sumatoria (con n ≥ 0).
Ejercicio 32: Retoma la clase Calculadora. Agrégale el método estático calculaSerie2(int n,

int número): int que calcula y regresa el resultado de la serie que aparece más abajo. El
método recibe el número de términos, n (con n ≥ 0) y el dato número y regresa el resultado
generado.
Ejercicio 33: Retoma la clase Calculadora. Agrégale el método estático calculaSerie3(int n):
int que calcula y regresa el resultado de la siguiente sumatoria (con n  0).
Que ya desarrollada para n=5, quedaría:
Usa el método factorial definido anteriormente. Revisa si puedes realizar tu cálculo de una
manera distinta.
Ejercicio 34: Retoma la clase Calculadora. Agrégale el método estático esDivisiblePor11(int

n): boolean que determina si el número n es divisible por 11, de acuerdo a lo que se explica
más abajo. El método regresa true si el número dado es divisible por 11 y false en caso
contrario.
Un número es divisible por 11 si la diferencia entre la suma de sus dígitos en posición impar
y la suma de sus dígitos en posición par, es divisible entre 11 o viceversa. Por ejemplo: 47
679 291 es divisible entre 11, puesto que,
33
(4+6+9+9) - (7+7+2+1) = 28 -17=11 resulta divisible entre 11.
(7+7+2+1) - (4+6+9+9) = 17 -28=-11 resulta divisible entre 11.
número 4 7 6 7 9 2 9 1
posición 0 1 2 3 4 5 6 7
posiciones pares: 4, 6, 9, 9
posiciones impares: 7, 7, 2, 1
Ejercicio 35: Crea una clase llamada CalculadoraTrigonometrica para poder trabajar con las
funciones trigonométricas. Si es necesario utiliza las funciones potencia y factorial
programadas anteriormente en la clase Calculadora. La variable x está en radianes. Realiza
los diagramas de flujo y diagramas de clase UML antes de realizar el código. Se deben de
crear las funciones utilizando las siguientes fórmulas:
Considera que la condición de terminación de las series sen(x) y cos(x) es cuando el

elemento que se agregue sea poco significativo (elemento<0.0001). Elabora una clase
PruebaTrigonometria que tenga un método main en el cual se pida al usuario un número y
que, por medio de un menú de operaciones, se le pregunte qué operación desea realizar.
Una vez realizada la operación solicitada, se deberá desplegar en pantalla el resultado
obtenido. Se debe permitir al usuario ejecutar tantas operaciones como desee, indicando
el término de la operación con: ‘s’.
34
8- Retos Programación en Java
Ejercicio 1: La planta de México de la compañía de juguetes LEGO, en la que se crean piezas

de los famosos juguetes, está lista para cambiar maquinaria.
Cada máquina puede programarse para producir 2 tipos de pieza en 5 colores diferentes:
negro 1, azul 2, rojo 3, amarillo 4 y verde 5, estas máquinas pueden trabajar 24 horas al día.
Cada máquina se identifica por una clave que indica su modelo, año y posición en la planta,
por ejemplo 37-2018-AC.
Una vez que se enciende la máquina se debe indicar el tipo de pieza a producir: ‘B’ básica o
‘C’ compleja, se debe indicar también el número de piezas a producir y el número del color
de las mismas. Al terminar de producir las piezas indicadas la máquina es capaz de reportar
el tiempo transcurrido, así como el costo total de las piezas.
Estas máquinas nuevas son capaces de producir 720 piezas por minuto para el tipo básico y
240 piezas del tipo complejo.
El costo de las piezas depende del precio del plástico, el tipo de pieza y el color de las
mismas. Cada 12 piezas del tipo básico consumen 120 ml de plástico y cada 4 piezas del tipo
complejo consumen 28.5 ml de plástico. Para los colores rojo y amarillo la tinta cuesta
$10.00 por cada 5 litros de plástico, para los colores negro, azul y verde la tinta cuesta
$12.50 por cada 5 litros de plástico.
El precio del plástico ha estado variando mucho últimamente por lo que al momento de
pedir el costo se debe indicar el precio del plástico por litro.
1. Realiza un diagrama UML de la clase Máquina:
a) Identifica los atributos.
b) Identifica los métodos y funciones necesarios para que tenga la
funcionalidad mínima requerida
c) Identifica los métodos y funciones necesarios para que tenga además la
funcionalidad propia del problema.
2. Realiza los algoritmos y diagramas de flujo necesarios.
3. Crea una clase PlantaLegoMex para probar tu clase Maquina, ya que te llegó un
pedido:
a) Instancia dos máquinas: la 37-2018-AC y la 37-2018-AB
b) Enciende la máquina 37-2018-AC para producir 75524 piezas básicas (B)
amarillas (4).
c) Enciende la máquina 37-2018-AB para producir 3256 piezas complejas (C)
verdes (5).
d) Indica el tiempo en horas que se van a tardar entre las dos máquinas en
producir las piezas y cuál sería el costo total del pedido, si el litro de plástico
cuesta $1.50.
35
Ejercicio 2: Se necesita una aplicación en Java para manejar tarjetas de crédito titular o
tarjetas de crédito adicional en un banco. Cada tarjeta tiene un número de tarjeta, un tipo
(titular o adicional), una categoría (azul = 0, oro = 1 o platinum = 2), un número de cuenta
asignada al cliente, el año de adquisición (año actual), el año de vencimiento (las tarjetas
sólo tienen 5 años de vigencia), el número secreto, el límite de crédito (azul = $20,000, oro
= $30,000 o platinum = $50,000) y el saldo.
Las tarjetas se crean mínimo con el número de tarjeta, el número de cuenta asignada al
cliente, el tipo, la categoría, y año de adquisición (año actual). El año de vencimiento y el
límite de crédito se le deben asignar automáticamente.
Cuando un cliente solicita una tarjeta, el banco crea la tarjeta y el cliente debe activarla
proporcionando el número secreto.
Las tarjetas deben poder compararse entre ellas, el criterio de comparación será el número
de tarjeta.
1. Realiza el diagrama UML de la clase Tarjeta como se indica a continuación:
a) Define los atributos necesarios.
b) Define constructores.
c) Define los get’s y los set’s, que consideres convenientes, justifica
brevemente tu respuesta.
d) Define las funciones compareTo y toString.
e) Define el método activaTarjeta: para activar la tarjeta. Indica parámetros si
los necesita.
f) Define el método calculaCreditoDisponible: debe calcular y regresar el
crédito disponible de la tarjeta (en base al saldo y al límite de crédito de la
tarjeta). Indica parámetros si los necesita.
g) Define el método calculaComision: debe calcular y regresar la comisión de
la tarjeta. Indica parámetros si los necesita. La comisión se calcula de la
siguiente manera:
● Si la tarjeta es titular: la comisión es el 1% del límite de crédito si su
categoría es platinum, de otro modo la comisión es del .05% del límite
de crédito.
● Si la tarjeta es adicional: la comisión es el .05% del límite de crédito
cuando su categoría es platinum, del .02% del límite de crédito si su
categoría es oro y el .01% del límite de crédito si su categoría es azul.
Revisa el diagrama UML asegurando que tengas todo lo necesario: atributos,

constructores, todas las funciones que permitan la funcionalidad mínima requerida
de la clase, así como los métodos y funciones para implementar las actividades
indicadas. Para todos los métodos y funciones recuerda indicar también los
36
parámetros que necesitan y el tipo de resultado que regresa para el caso de las
funciones.
2. Escribe en Java la clase Tarjeta.
3. Define una clase PruebaTarjeta para probar tu clase Tarjeta
a) Crea 2 tarjetas
b) Activa una tarjeta a un cliente pidiéndole al usuario los datos pertinentes.
c) Calcula e imprime la comisión de la tarjeta activada
d) Imprime la información completa de cada tarjeta
Ejercicio 3: Se necesita una aplicación en Java para manejar las frutas en una frutería. Cada
fruta tiene un número consecutivo como clave de identificación, el nombre de la fruta, su
color, ciudad de origen y su costo por kilo. Las frutas se pueden dar de alta de dos maneras:
la primera sólo con su clave de identificación y la segunda con todas sus características antes
mencionadas. Se les asigna automáticamente una clave de identificación consecutiva que
comienza a partir del número 2000.
Las frutas deben poder compararse entre ellas, el criterio de comparación será la clave de
identificación.
1. Realiza el diagrama UML de la clase Fruta, indicando los atributos de la clase, su(s)
constructor(es), métodos get/set necesarios y los métodos (o funciones) para
implementar las actividades siguientes, así como los métodos y funciones que
permitan la funcionalidad mínima de la clase. Para todos los métodos indica también
los parámetros que necesita y el tipo de resultado que regresa.
2. Escribe la clase Fruta en Java, de acuerdo a lo modelado en el inciso anterior.
3. Programa la función calculaPorcentajeDescuento: esta función debe calcular y
regresar el porcentaje de descuento (use parámetros si los necesita). El porcentaje
de descuento se calcula de la siguiente manera:
● 0% de descuento si la compra es menor de $1,500.00.
● Un descuento del 0% al 10% si el monto de la compra está entre $1,500.00 y
$10,000.00. La expresión es: ((monto de compra - 1,500) / 8,500) * 10%
● 10% de descuento si la compra es mayor a $10,000.00.
4. Programa la función calculaCosto: esta función debe calcular y regresar el costo de
los kilos solicitados (use parámetros si los necesita).
5. Escribe la clase MundoFruteria para probar tu clase Fruta,
a) Construye 2 Frutas con la siguiente información:
● Fruta 1: Manzana, roja, Campeche, 14.50.
● Fruta 2: Plátano, amarillo, Veracruz, 6.85.
b) Calcula e imprima el porcentaje de descuento para $8,500.00 de inversión
en cada fruta.
c) Calcula e imprima el costo total por fruta de 122 kilos.
37
d) Imprime la información completa de cada fruta.
e) Da un mensaje adecuada para decir cuál de las dos frutas es mayor o menor
según su clave de identificación.
38
9- Cadenas de caracteres y archivos de texto
En esta sección se presentan problemas cuya solución requiere de los métodos de la clase
String. Se sugiere revisar la documentación de java para conocer los métodos de los cuales
se dispone.
(https://docs.oracle.com/javase/7/docs/api/java/lang/String.html).
Ejercicio 1: Define la clase ManejadorCadenas que contenga métodos estáticos capaces de:
a) Dada una cadena, generar y regresar otra cadena con los caracteres que ocupan
posiciones pares seguidos de todos los caracteres que ocupan las posiciones
impares. Por ejemplo, si la cadena recibida es: “flor de un día”, la cadena generada
deberá ser: “fo e u ílrdnda”.
b) Dada una cadena y un carácter, contar y regresar el número de veces que el carácter
se encuentra en la cadena.
Ejercicio 2: El teclado de una computadora está descompuesto y, cada vez que se oprime la
letra ‘s’, esta se repite tres veces. Se desea que escribas un método estático que reciba
como parámetro una cadena de caracteres y que regrese dicha cadena modificada, de tal
manera que no tenga ‘s’ de más. Considera todos los casos que puedan presentarse. Prueba
tu solución, desplegando en pantalla el texto modificado.
Ejercicio 3: En un archivo de texto se han guardado frases de escritores célebres. En esas

frases hay sustantivos propios que deben resaltarse antes de desplegarlas en pantalla. La
manera elegida para destacar esas palabras es escribiéndolas completamente con
mayúsculas. Puedes suponer que no hay sustantivos propios al inicio de la oración, que en
las frases no hay signos de puntuación y que las palabras están separadas por un único
espacio en blanco. Para ello, debes hacer un programa completo en Java que lea cada
oración del archivo, haga el cambio solicitado y la imprima en pantalla.
Ejercicio 4: Diseña e implementa un programa completo en Java para decodificar una

sucesión de a’s y b’s que aparece codificada por medio de un conjunto de parejas de dígitos
y letras donde el dígito indica el número de veces que se repite la letra que lo sucede. El
programa debe leer de un archivo de texto las líneas codificadas y, a medida que las
decodifica, las desplegará en pantalla. Para que la solución resulte más fácil de mantener,
divídela en módulos (métodos o subprogramas).
Por ejemplo, si la sucesión codificada leída es:
3a4b2a
Tu programa debe generar la siguiente secuencia: aaabbbbaa
39
Notas:
 Los números son de un sólo dígito (no hay 10,11, ...).
 Puede haber tantas sucesiones de a’s y b’s como se desee.
 Las letras no necesariamente vienen alternadas.
 En la línea de lectura, no hay ningún espacio.
Ejercicio 5: Define la clase Persona que tenga, entre sus atributos, el CURP. Incluye los
métodos necesarios para:
a) Obtener el género de la persona. Debe regresar una cadena indicando si la persona
es del género femenino o masculino.
b) Obtener la edad de la persona. Se consideran años cumplidos, es decir: año actual
– año de nacimiento.
c) Obtener si la persona es nacida en el país o no (en el CURP aparece como NE:
Nacido en el Extranjero).
Prueba tu solución. Acompaña los resultados con mensajes adecuados.
Ejercicio 6: Retoma la clase del ejercicio 1. Agrégale un método que, dada una cadena,
regrese true si dicha cadena es un palíndromo y false en caso contrario. Una cadena se
considera un palíndromo si puede leerse el mismo contenido de izquierda a derecha, que
de derecha a izquierda. Observa los siguientes ejemplos. Tu solución debe ser general, es
decir debe servir para palabras y frases. Prueba tu solución.
1234  no es un palíndromo
1221  sí es un palíndromo
gato  no es un palíndromo
reconocer  sí es un palíndromo
Neuquén  sí es un palíndromo
Amad a la dama  sí es un palíndromo
Ella te da detalle  sí es un palíndromo
Ella va a votar  no es un palíndromo
Anita lava la tina  sí es un palíndromo
A mamá, Roma le aviva el amor a papá y a papá, Roma le aviva el amor a Mamá  sí es un
palíndromo
En los ejemplos anteriores se puede observar que se ignoraron los acentos, las mayúsculas,
los espacios en blanco y los signos de puntuación. Puedes suponer que en la cadena que se
analizará no hay palabras acentuadas ni signos de puntuación.
40
Ejercicio 7: Escribe la clase AnalizaCadena que tenga un método estático que reciba una
cadena y un ArrayList<String> que almacena palabras que deben quitarse de la cadena. El
método regresa la cadena modificada (si tenía las palabras recibidas en el ArrayList).
 En la cadena, las palabras están separadas entre sí por un único espacio en blanco.
 Si la palabra está en la cadena más de una vez, sólo se elimina la primera ocurrencia.
En la misma clase escribe un método main que: a) Declare e inicialice una cadena y construya
un ArrayList y b) Llame al método anterior e imprima el resultado acompañado de un mensaje
adecuado. Puedes probar tu solución con el ejemplo que aparece más abajo y con los casos
que creas conveniente. Considera todos los casos que puedan presentarse.
Ejemplo:
Cadena: valor es lo que se necesita para levantarse y hablar, pero también es lo que se requiere
para sentarse y escuchar
ArrayList: [hablar, sentarse, valor, flores]
Cadena modificada: es lo que se necesita para levantarse y, pero también es lo que se

requiere para y escuchar
Ejercicio 8: Una “Agencia de Inteligencia” se caracteriza, de manera simplificada, por el

nombre de la agencia y el nombre de la persona responsable de la misma. Además, se
espera que pueda, entre otras actividades, comprimir mensajes. Escribe la clase
correspondiente con los atributos indicados, el o los constructores y
a) Un método que, dado un mensaje (dato de tipo String) que se recibe como parámetro,
genere y regrese otra cadena que es el mensaje comprimido. La secuencia de caracteres
“se comprime” considerando los caracteres iguales entre sí que ocupan posiciones
consecutivas. Puedes suponer que el mensaje recibido no contiene dígitos, sólo letras
y símbolos.
Restricción: no se debe pasar la cadena a un arreglo o a un ArrayList para resolver el

problema. Debes emplear métodos de la clase String para resolver de la mejor manera el
problema.
Analiza los siguientes ejemplos:
Cadena de entrada: abcd ----> Cadena resultado: a1b1c1d1
Cadena de entrada: "" ----> Cadena resultado:
41
Cadena de entrada: ajjjjjjkkumtbb ----> Cadena resultado: a1j6k2u1m1t1b2
Cadena de entrada: a????kku*****b ----> Cadena resultado: a1?4k2u1*5b1
b) Un método main para probar tu solución. Construye un objeto de la clase previamente

definida y prueba el método que comprime mensajes. Asegúrate que funciona
correctamente considerando todos los casos que puedan presentarse. Puedes tomar
los ejemplos dados y, si lo consideras conveniente, agregar otros casos de prueba.
Variante: modifica tu solución o escribe otro método en la misma clase, tal que se puedan
comprimir cadenas como:
Cadena de entrada: aabccccaaa ----> Cadena resultado: a2b1c4a3

Cadena de entrada: ***mtt?????*t ----> Cadena resultado: *3m1t2?5*1t1
42
10- Arreglos
Ejercicio 1: Define la clase ManejadorArreglos que contenga métodos estáticos capaces

de:
a) Sumar los elementos de un arreglo de double.
b) Obtener el promedio de los elementos de un arreglo de double.
c) Obtener el índice donde se encuentra el elemento mayor de un arreglo de double.
d) Obtener el índice donde se encuentra el elemento menor de un arreglo de double.
e) Determinar cuántos elementos de un arreglo de double son mayores a un cierto
parámetro.
f) Determinar cuántos elementos de un arreglo de double son menores a un cierto
parámetro.
g) Correr los elementos de un arreglo de double k lugares a la derecha.
h) Correr los elementos de un arreglo de double k lugares a la izquierda.
Prueba tus soluciones leyendo de un archivo de texto los datos necesarios para generar los
arreglos. Considera todos los casos que puedan presentarse.
Ejercicio 2: En una oficina gubernamental se cuenta con la información del número de

habitantes de cada uno de los estados de un país. Dicha oficina quiere procesar esa
información para poder tomar algunas decisiones. Usa un arreglo de double para almacenar
la población de cada estado y un arreglo (paralelo) de Strings para almacenar los nombres
de los estados. Dicha oficina está a cargo del Lic. Martín Cuenta. A partir de la información
que se tiene se quiere obtener:
a) El nombre del estado con mayor población.

b) El promedio de habitantes por estado a nivel nacional.
c) Total de estados que tienen una población menor al promedio.
Define la clase OficinaGobierno, represéntala en un diagrama UML y prográmala en Java.
Decide qué atributos y métodos incluir en ella. Puedes emplear métodos que hayas
programado en la clase ManejadorArreglos. Crea una clase ClaseGobierno y prueba los
incisos anteriores.
Ejercicio 3: Escribe un programa completo que cuente e imprima el total de vocales

(minúsculas o mayúsculas) que están contenidas en un grupo de frases, almacenadas en un
archivo de texto. El programa debe tener y usar un método estático que reciba el nombre
del archivo y que regrese el total de cada una de las 5 vocales. ¿Qué tipo de resultado
deberá regresar ese método?
Ejercicio 4: Escribe un programa completo que decodifique frases de una agencia de
inteligencia, la cual codifica ciertos mensajes reemplazando las vocales por números. El
43
programa debe leer una frase, decodificarla e imprimirla. La codificación utilizada es la
siguiente:
a 1
e 2
i 3
o 4
u 5
Por ejemplo:
Texto codificado: T4m1 1ñ4s c4nstr53r l1 c4nf31nz1 y s4l4 m3n5t4s p1r1 d2str53rl1.
Texto decodificado: Toma años construir la confianza y solo minutos para destruirla.
Ejercicio 5: La compañía “Empaques S.A. de C.V.” que se encuentra localizada en Av.

Constitución 34 en la Cd. de Querétaro quiere saber cuál es el promedio de ventas por mes
del año pasado, cuál fue el mes en el que se hicieron más ventas, cuál fue el mes en el que
se vendió menos, cuántos meses están por arriba del promedio de ventas y el total de
ventas en el año. Para lo cual el Sr. Pérez, que es el director de la empresa, te proporciona
el monto de ventas de cada mes del año pasado.
a) Elabora una clase Compania que tenga como atributos nombre, dirección, ciudad,
director y ventas. Esta clase debe tener la funcionalidad mínima requerida de toda
clase.
Compania
-nombre:String
-direccion:String
-ciudad:String
-director:String
-ventas: [] double
-totalVentas: int
+ Compañía()
+ Compañía(String, String, String, String)
….
+getUnaVenta(int):double
+promedio():double
+mesMayor():int
+mesMenor():int
+arribaPromedio():int
+…
44
b) Crea una clase llamada PruebaCompania para pedirle al Sr. Pérez las ventas de los
12 meses del año anterior y que utilice la funcionalidad de la clase Compañía para
obtener e imprimir los datos requeridos.
Ejercicio 6: Define la clase CampamentoVerano que tiene como atributos el lugar donde se
llevó a cabo, la fecha, el responsable, el total de asistentes y los datos de todas las personas
que asistieron. Para representar a los asistentes utiliza la clase del ejercicio 5, de la sección
9 (Cadenas). Considera que el campamento tiene una capacidad máxima de 100 asistentes.
La clase solicitada debe tener la siguiente funcionalidad:
a) Dar de alta/baja un asistente.
b) Modificar la fecha.
c) Obtener y regresar el total de hombres/mujeres que asistieron.
d) Generar y regresar un reporte con los datos de los asistentes, clasificados de
acuerdo a la edad de los mismos: menores a 13 años, entre 13 y 16, mayores de 16
pero menores de 21 y de 21 o más. Se consideran años cumplidos, es decir: año
actual – año de nacimiento.
e) Obtener y regresar el total de asistentes nacidos (o no) en el país.
Puedes agregar otros atributos y métodos si lo requieres. Prueba tu solución considerando

todos los casos que puedan presentarse.
Ejercicio 7: En la guardería “La Casita Feliz”, especializada en niños menores de 4 años y

preocupada por cuestiones ambientales, quieren conocer algunos datos sobre el consumo
diario de pañales. Luego de muchos años de experiencia, las nanas de la guardería saben
que a los niños de meses les cambian 6 veces los pañales durante el tiempo que
permanecen a su cuidado. Por su parte, a los niños que ya cumplieron el año, pero que aún
no tienen 2 le cambian los pañales 4 veces al día. Los que tienen 2 años o más, sin llegar a
los 3, ocupan 3 pañales y a los de 3 años o más sólo los cambian 2 veces al día. Para este
problema sólo se necesita conocer la edad, en años cumplidos de los niños y crear con estos
datos un arreglo de enteros. Actualmente “La Casita Feliz” recibe a 20 niños. Identifica
atributos y métodos requeridos para:
a) Calcular total diario de pañales.
b) Calcular promedio diario de pañales.
c) Determinar en qué categoría de niños (de acuerdo a la edad) se consumen más
pañales.
Define la clase Guarderia. Decide qué atributos y métodos incluir en ella. También debes
escribir una clase con un método main para probar toda la funcionalidad de la clase
Guarderia. Las edades de los niños fueron almacenadas en un archivo de texto.
45
Ejercicio 8: En un casino se desea generar ciertas estadísticas sobre el juego de ruleta. Para
diseñar e implementar el programa necesario, debes recordar que la ruleta está formada
por 70 elementos: los números del 1 al 34 (rojos), los números del 1 al 34 (negros), el 0 y el
00. El total de juegos varía, no todos los días se realiza el mismo número de jugadas. Al final
de cada día se necesita conocer la siguiente información:
 Cuantas veces resultó ganador cada uno de los números de la ruleta.
 Todos los números que no resultaron ganadores a lo largo del día.
 El número de cada color que ganó más veces. Puedes suponer que sólo hay uno.
 El número que ganó en más ocasiones.
 Dado un color, decir si los números pares de dicho color salieron más veces que los
números impares.
Luego de leer cuidadosamente el problema, decide:

a) Cuáles y cuántos datos se necesitan y en qué formato deberán ser proporcionados
(considera los números, los colores, el orden en el que se ingresarán, etc.). Puedes
suponer que los datos se proporcionan en un archivo de texto.
b) Los resultados que se esperan (qué representan, en qué formato, etc.)
c) La o las clases necesarias para resolver el problema. Además, decide qué atributos
y métodos se requieren para poder obtener todos los resultados esperados.
Ejercicio 9: Cerca del ITAM hay una institución que se especializa en dar clases de natación
y que requiere que le ayuden a estimar algunos costos para mejorar sus instalaciones. La
institución se caracteriza por su nombre, domicilio, total de albercas, y tamaño de las
albercas (todas son de forma rectangular). Luego de las Olimpiadas el club ha recibido
muchas solicitudes de inscripción de potenciales ganadores de medallas de oro. Para
ofrecer un mejor servicio el club decidió techar todas sus albercas, pero de manera
individual para independizar el sistema de calefacción de cada una de ellas. Se te pide que
con la ayuda de la clase Rectangulo calcules e imprimas la cantidad de dinero requerido si
el costo por m2 de techo es de $1000. Crea una clase que contenga un arreglo de clase
Rectangulo, el número de albercas y decide qué atributos y métodos son necesarios incluir
para representar a esta institución y resolver su problema.
Ejercicio 10: En una galería de arte se tienen para la venta varias pinturas de autores
modernos. De cada pintura se guarda el nombre, el nombre del pintor, la técnica usada, el
año en el cual fue terminada y el precio de venta. Analiza todo el problema y decide qué
métodos incluir en esta clase. De la galería se guarda su nombre, su teléfono y los datos de
las pinturas que tiene para la venta (máximo 100). En esta clase, además de los atributos
mencionados, constructores y funcionalidad mínima que creas conveniente, debes
programar los métodos necesarios para que tenga la siguiente funcionalidad:
46
a) Dar de alta una pintura. Se reciben como parámetros los datos de la pintura y debes
realizar las validaciones pertinentes.
b) Consulta por pintor y técnica. Dados el nombre de un pintor y el de una técnica, el
método debe generar y regresar un ArrayList<String> con todos los datos de las
obras pintadas por dicho pintor, en las que haya usado la técnica dada. Si la galería
no tiene ninguna obra que cumpla con las características solicitadas, el método
deberá regresar null.
c) Consultar por precio. Dado un precio, el método debe regresar true si existe alguna
pintura que cueste menos que ese precio. En caso contrario, deberá regresar false.
Prueba tu solución asegurándote que obtiene los resultados correctos en cada caso.
Ejercicio 11: Retoma la clase ManejadorArreglos y agrega métodos que permitan:
a) Ordenar los elementos de un arreglo de enteros/double.

b) Buscar un elemento en el arreglo de enteros/double y obtener el índice donde se
encuentre o el negativo del índice donde debería estar.
Ejercicio 12: Transforma tu clase ManejadorArreglos en otra clase llamada

ManejadorArreglosGenerico con los mismos métodos de la clase original pero genéricos
<T> o <T extends Comparable <T>> para que puedas trabajar con ellos independientemente
del tipo de datos que almacenan. ¿Qué métodos vale la pena convertir? ¿De qué depende?
Ejercicio 13: Durante un Seminario de Ética Profesional llevado a cabo en el ITAM, el pasado
mes de febrero, se registraron los nombres de todos los asistentes. Escribe una clase que
permita almacenar la información del seminario, incluyendo la información de los
participantes. En la clase Seminario se debe contar con métodos que permitan:
a) Generar un reporte de todos los asistentes, ordenado alfabéticamente de menor a
mayor.
b) Dado el nombre de una persona decir si dicha persona asistió o no al seminario.
c) Agregar un nombre (suponiendo que hubo alguna omisión al momento de capturar
inicialmente los datos).
d) Eliminar un nombre (suponiendo que se capturó dicho nombre por error).
Ejercicio 14: Define la clase Alumno. Un alumno se caracteriza por su nombre, domicilio,
CURP, nombre de carrera, total de materias aprobadas hasta el momento y las calificaciones
obtenidas en cada una de ellas. Si consideras conveniente agregar otros atributos puedes
hacerlo. Además, debe contar con métodos para cambiar de domicilio, de carrera, obtener
el promedio, calcular la edad, etc.
47
También debes escribir la clase Universidad que tiene, entre sus atributos, una lista de
alumnos ordenados por nombre. Esta clase debe tener, además de la funcionalidad mínima,
el siguiente comportamiento:
a) Dar de alta un nuevo alumno.
b) Dar de alta una calificación para alguno de los alumnos ya registrados.
c) Cambiar el domicilio de alguno de los alumnos ya registrados.
d) Dar de baja un alumno.
e) Generar un reporte (cadena) con los datos de todos los alumnos que se mencionan
a continuación: CURP, nombre, total materias aprobadas y promedio.
f) Generar un reporte (cadena) con los datos de todos los alumnos mayores de una
cierta edad (se recibe como parámetro).
Ejercicio 15: Define la clase Fiesta, según las especificaciones que se dan más abajo.
Observa que el atributo nombresInvitados es una lista de cadenas que almacenará los
nombres de todos los invitados.
Fiesta
-fecha: String
-lugar: String
-nombresInvitados: String[]
+Fiesta()
+Fiesta(String, String)
:::
+alta(String):boolean
+toString(): String
…
Incluye los métodos necesarios para que puedas:

a) Agregar un invitado a la lista de invitados, de tal manera que los nombres queden
ordenados alfabéticamente, de la “A” a la “Z”. Todos los nombres deben guardarse
en mayúsculas, independientemente de cómo los dé el usuario. El método debe
regresar un valor booleano indicando si se agregó o no (no se aceptan dos invitados
con el mismo nombre).
b) Quitar a uno de los invitados de la lista. El usuario da como dato el nombre de un
invitado. El método debe regresar un valor booleano indicando si se eliminó o no.
c) Obtener el primero de la lista.
d) Obtener el último de la lista.
e) Obtener, en forma de cadena, la lista completa de invitados. Además, encabezando
la información, se deberá incluir la fecha y el lugar donde se llevará a cabo la fiesta.
48
Por último, define la clase FiestaCumpleanios que utilice la clase Fiesta y pruebe que la
misma se comporta como se espera.
Ejercicio 16: Define la clase AgenciaAutomotriz considerando que se caracteriza por un

nombre, una dirección, la cantidad de marcas que vende (en el caso de que varias marcas
pertenezcan al mismo corporativo), los nombres de todas las marcas (ordenados
alfabéticamente de la “A” a la “Z”), la cantidad de autos que tiene para vender y los datos
de cada uno de los autos.
Para almacenar los nombres de las marcas y los datos de los autos utiliza arreglos que
deberán estar ordenados crecientemente. Si no tienes la clase Auto, defínela incluyendo los
atributos y métodos que creas conveniente.
Se quiere que la clase AgenciaAutomotriz pueda agregar una nueva marca a las que ya
vende, dejar de vender alguna de las que vende, recibir nuevos autos para su venta, vender
alguno de los autos que tiene, dar a conocer todas sus características al usuario o sólo
alguna de ellas, dar los datos del auto más caro, dada una marca (si la agencia la vende)
obtener cuántos autos tiene de dicha marca. Debes definir los métodos que mejor
representen el comportamiento deseado de la clase.
Por último, define la clase VendeAutos que utilice la clase AgenciaAutomotriz y pruebe que
la misma se comporta como se espera.
Ejercicio 17: Define la clase TiendaMascotas de tal manera que quede caracterizada por su
nombre, dirección, y los datos de todos los animales. Para representar a los animales debes
usar la clase Animal (si no la tienes definida debes hacerlo, incluyendo los atributos y
métodos que consideres importantes). La clase TiendaMascotas debe tener el siguiente
comportamiento: agregar nuevos animales para la venta, vender un animal, cambiar la
dirección de la tienda, dar a conocer todos sus datos, obtener e imprimir cuántos animales
de cierto tipo (por ejemplo, perros, gatos, patos, etc.) hay para vender en la tienda y, por
último, que determine si la tienda tiene, al menos, un animal exótico para la venta.
Por último, define la clase VendeMascotas que utilice la clase TiendaMascotas y pruebe
que la misma se comporta como se espera. Crea los diagramas UML para todos los
componentes del ejercicio.
Ejercicio 18: Realiza una clase VendeMascotasArchivos que utilice la clase TiendaMascotas
del ejercicio anterior, pero que haga una carga de datos inicial, leyendo de un archivo la
información de los animales con los que cuenta la tienda.
49
11- Arreglos bidimensionales
Ejercicio 1: Define la clase ManejadorArreglosBidimensionales que contenga métodos

estáticos para cada uno de los incisos. Considera todos los casos posibles. Prueba tu
solución.
a) Sumar los elementos de una columna de un arreglo bidimensional de double.
b) Sumar los elementos de un renglón de un arreglo bidimensional de double.
c) Sumar todos los elementos de un arreglo bidimensional de double.
d) Sumar los elementos de la diagonal principal de un arreglo bidimensional de double.
e) Sumar los elementos de la diagonal secundaria de un arreglo bidimensional de
double.
f) Generar una cadena con todos los elementos de un arreglo bidimensional de
double, de tal manera que sea vea de forma rectangular.
g) Encontrar el elemento más grande/pequeño de una columna de un arreglo
bidimensional de double y regresar la posición del mismo.
h) Encontrar el elemento más grande/pequeño de un renglón de un arreglo
bidimensional de double y regresar la posición del mismo.
Ejercicio 2: En la clase ManejadorArreglosBidimensionales agrega métodos estáticos para

cada uno de los incisos. Considera todos los casos posibles. Prueba tu solución.
a) Sumar dos matrices. El método recibe dos matrices y sus respectivos números de
renglones y de columnas y, si es posible, calcula otra matriz que representa la suma
de las dadas.
b) Multiplicar dos matrices. El método recibe dos matrices y sus respectivos números
de renglones y de columnas y, si es posible, calcula otra matriz que representa la
multiplicación de las dadas.
c) Genera la traspuesta. El método recibe una matriz y su total de renglones y de
columnas y, si es posible, genera otra matriz que representa la traspuesta de la
primera.
d) Determinar si una matriz es simétrica.
e) Determinar si una matriz es identidad (o unidad).
Ejercicio 3: En la clase Compañía se tiene, entre sus atributos, una matriz de double de 12x4
que representa sus ventas, a lo largo del año anterior, en sus 4 departamentos. Programa
la clase Compañía, incluyendo los métodos necesarios para tener la funcionalidad que se
pide más abajo. Considera todos los casos que pueden presentarse. Prueba tu solución.
a) Obtener, para un departamento, el mes con el mayor monto de ventas del año.
50
b) Obtener, para un mes, el promedio de ventas, considerando todos los
departamentos.
c) Obtener, para un departamento, el promedio de ventas del año.
d) Obtener, si es posible, el mes en el cual no hubo ventas en ninguno de los
departamentos.
Ejercicio 4: En la clase Serpentario se tiene, entre sus atributos, una matriz que representa
el espacio en el cual viven (y se exhiben) las serpientes. Ese espacio puede verse como una
matriz, en la cual en cada casilla vive una serpiente diferente. De acuerdo a sus principales
características, les van asignando distinto renglón. Por ejemplo, en el primer renglón se
almacenan las constrictoras, en el siguiente las venenosas, etc. Considera que puede haber
diferente número de serpientes por renglón. Para guardar los datos de cada serpiente
define una clase, llamada Serpiente, y decide qué datos son necesarios o deseables y la
funcionalidad requerida. La clase Serpentario debe tener la funcionalidad que se pide más
abajo.
a) Dar de alta una serpiente. Se reciben los datos de la serpiente y el número de

renglón que le corresponde.
b) Consultar los datos de una serpiente. Dada su clave, si está, dar toda la información
que se tenga.
c) Dado un tipo de alimentación, contar y regresar el total de serpientes que tienen
esa alimentación.
d) Dar de baja una serpiente. Decide qué datos deberán ser proporcionados.
e) Encontrar y regresar el tipo de serpiente del cual haya más ejemplares.
NOTAS:
i) Debes decidir cómo manejar el hecho de que en cada renglón puede haber un
número diferente de datos almacenados.
ii) La implementación de tus soluciones debe ser consistente con lo establecido en el
inciso i.
Ejercicio 5: Define la clase ManejadorArregloBidimensionalGenerico que contenga

métodos estáticos para:
a) Buscar un elemento en un renglón del arreglo. Regresa la columna donde se

encuentra o un -1. Decide qué parámetros necesita.
b) Buscar un elemento en una columna del arreglo. Regresa el renglón donde se
encuentra o un -1. Decide qué parámetros necesita.
51
c) Generar y regresar una cadena con el contenido del arreglo. Agrega espacios y saltos
de línea de tal manera que se facilita la visualización de la información.
d) Encontrar y regresar la posición del elemento más grande/pequeño de un cierto
renglón/columna.
e) Determinar si dos matrices son iguales. Para ser iguales deben almacenar el mismo
número de elementos en renglones y columnas y, además, los datos que almacenen
en cada una de sus casillas deben ser iguales. El método regresa un booleano.
Ejercicio 6: En la clase Restaurante se tiene, entre sus atributos, el nombre, dirección,

teléfono, total de mesas y una matriz que representa las mesas (renglones) y los alimentos
pedidos en cada mesa (columna). Considera que no se pide el mismo número de alimentos
en todas las mesas. De cada alimento se guarda la clave, el nombre, una breve descripción
y el precio. Escribe los métodos necesarios de tal manera que se pueda:
a) Conocer el total a pagar en cada mesa.
b) Determinar si en alguna mesa se pidió un cierto alimento. Se proporciona la clave
del alimento.
c) Encontrar la mesa que más alimentos consumió, no necesariamente que más dinero
gastó.
d) Encontrar la mesa que menos dinero gastó.
e) Encontrar el alimento, si existe, que fue ordenado en todas las mesas.
f) Dado un alimento, contar y regresar en cuántas mesas fue ordenado.
g) Los datos del platillo más caro que ofrece el restaurante.
h) El gerente decide ofrecer un nuevo alimento a partir del próximo mes. Hay que
incorporarlo a la oferta del restaurante.
i) El gerente decide dejar de ofrecer un nuevo alimento a partir del próximo mes (por
cuestiones de materia prima dependiente de la temporada). Hay que quitarlo de la
oferta del restaurante.
j) Dada una cadena de caracteres (que puede almacenar algún ingrediente), encontrar
y regresar la lista de alimentos en los cuales en su descripción aparece dicho
ingrediente. Esta es una funcionalidad muy útil para prevenir accidentes por
alergias.
NOTAS:
i) Analiza el problema e identifica los requisitos funcionales.
ii) Diseña la solución: ¿clases necesarias? ¿relación entre las clases? Realiza el
diagrama UML de tu diseño.
iii) Reusa los métodos de los manejadores de arreglos genéricos (unidimensional o
bidimensional, según corresponda).
52
12- Retos Arreglos
Ejercicio 1: Realiza una función estática llamada datosPosiciones que reciba como
parámetros: un arreglo de double y un número entero x (0 a 9), y que regrese un ArrayList
con los elementos que se encuentran en todas las posiciones múltiplo de x (incluyendo la
posición x).
En el main lee los datos de un archivo de texto (Datos.txt) y prueba tu función, imprimiendo
el ArrayList resultante.
Ejercicio 2: Realiza una clase en Java PracticaArreglos y programa en ella una función
estática llamada encuentraParesImpares que reciba como argumento dos arreglos de tipo
int llamados arrePares y arreImpares y regrese un ArrayList con los números pares del
arreglo arrePares y los números impares del arreglo arreImpares.
Ejemplo:
arrePares
0 1 2 3 4 5 6 7
10 7 3 12 9 8 1 22
0 1 2 3 4 5 6 7 8
arreImpares
11 13 10 15 8 4 2 1 44
0 1 2 3 4 5 6 7
ArrayList
10 12 8 22 11 13 15 1
La clase debe tener un método main para probar la función encuentraParesImpares e

imprimir el ArrayList resultante.
Ejercicio 3: Realiza un método estático que reciba un número entero n y regrese un

ArrayList con todos los números primos comprendidos entre 2 y n. Para ello, debe utilizar
el algoritmo que se conoce con el nombre “Criba de Eratóstenes”. Este algoritmo se
describe a continuación: se inicializa con 1 todos los elementos de un arreglo (de n+1
casillas). Las casillas 0 y 1 se ignoran. Se debe empezar a analizar el arreglo desde la casilla
2 (i = 2). Luego, hay que recorrer todos los elementos, desde i+1, y, si hay un 1, se cambia a
53
0 si su índice es múltiplo de i. El proceso debe repetirse con i= 3, 4, etc. siempre que la
correspondiente casilla almacene 1. Por último, los números primos, comprendidos entre 2
y n, serán los índices de aquellas casillas en las que haya quedado un 1. La clase debe tener
un método main para probar el método solicitado e imprimir el ArrayList resultante.
Considera todos los casos que puedan presentarse.
Ejercicio 4: Define la clase Zoologico según las especificaciones que se dan más abajo.
Observa que el atributo “animales” es un arreglo desordenado de objetos del tipo Animal
que almacenará los datos de todos los animales (por ejemplo: nombre, edad, raza). Incluye
los métodos necesarios para que puedas:
a) Dado una raza indicar cuántos animales hay de esa raza en el Zoológico.
b) Calcular el promedio de las edades de los animales del Zoológico.
Por último, define una clase en Java llamada PruebaZoologico con un main que utilice un
archivo (datos.txt) para llenar el arreglo e imprimir lo solicitado probando cada uno de los
incisos anteriores.
Zoologico
-nombre: String
-direccion: String
-animales: Animal [20]
+Zoologico()
+Zoologico(String, String)
+promedioEdad (): double
+cuantosRaza(String): int
…
Ejercicio 5: Realiza la clase Inversion, la clase PortafolioInversion y la clase

PruebaPortafolioInversion.
La clase Inversion se utiliza para representar la inversión realizada en un fondo
determinado, la cual se distingue por nombre del fondo, monto invertido, plazo (en meses)
y el rendimiento que otorga.
Un PortafolioInversion se caracteriza por su nombre, el número de inversiones que maneja
y por tener un arreglo de inversiones, ordenado alfabéticamente.
1. Escribe las clases Inversion y PortafolioInversion para poder trabajar con un arreglo
de Inversiones en el PortafolioInversion y para poder llamar a las funciones del
ManejadorArreglosGenerico.
2. La clase PortafolioInversion debe tener la funcionalidad necesaria para que:
54
a) Dados los datos de una inversión realice el alta ingresándola en el arreglo.
b) Dado el nombre de un fondo indique si en el PortafolioInversion existe o no
una inversión en dicho fondo.
c) Indicar cuantas inversiones son mayores a un monto de inversión
determinado.
3. Realiza el main de la clase PruebaPortafolioInversion para que:
a) Construyas un objeto tipo PortafolioInversion.
b) Des de alta 2 inversiones.
c) Muestres si se invirtió en el fondo “C”.
d) Indiques en cuántos fondos se invirtió más de $650,000 pesos.
Ejercicio 6: Un hospital desea hacer una serie de reportes de los médicos que prestan sus
servicios. Los médicos pueden ser especialistas en más de una enfermedad. El hospital tiene
como máximo 50 médicos registrados.
Debes realizar la clase Hospital considerando que el hospital cuenta, entre sus atributos,
con los datos de todos sus médicos, ordenados de manera creciente de acuerdo a una clave.
Debes hacer la clase Medico para poder utilizarla en la clase Hospital.
La clase Hospital debe tener la siguiente funcionalidad:
a) Dar de alta un médico en el hospital.
b) Dar de alta una especialidad a un médico ya registrado en el hospital.
c) Generar una cadena con las especialidades que tenga un médico. Se recibe la clave
como parámetro.
d) Determina cuántos médicos tienen cierta especialidad (dada por el usuario).
e) Dar de baja a un médico en el hospital. Se recibe la clave como parámetro.
Realiza el PruebaHospital donde:
a) Des de alta 2 médicos indicando si hubo algún error en el alta.

b) Para cada uno de los médicos que diste de alta agrégale dos especialidades.
c) Pidas la clave de un médico al usuario e imprimas sus especialidades.
d) Dada una especialidad, imprimas cuantos médicos tienen esa especialidad.
e) Des de baja a un médico (pidiendo al usuario la clave) y muestres toda la información
de dicho médico o un mensaje adecuado si no se pudo realizar la baja.
Ejercicio 7: Define la clase ObservatorioAstronomico la cual debe tener, entre sus atributos,
la información de la luz observada en diferentes puntos del espacio, de acuerdo a una
fotografía tomada por la noche. La información se almacena en forma de tabla como se
muestra más abajo. De acuerdo a esta información, se puede determinar si hay o no una
estrella en la posición i,j. Se sabe que hay una estrella si:
55
 el punto no se encuentra en las orillas de la fotografía (primero o último
renglón o columna), y
 (a[i, j] + a[i - 1, j] + a[i + 1, j] + a[i, j - 1] + a[i, j + 1]) > 30
La siguiente tabla es un ejemplo de como se almacena la información (los valores

almacenados están comprendidos entre el 0 y el 20).
0 3 4 0 0 0 6 8
5 13 6 0 0 0 2 3
2 6 2 7 3 0 10 0
0 0 4 15 4 1 8 0
0 0 7 12 6 9 10 4
5 0 6 10 6 4 8 0
El observatorio será capaz de generar una tabla en la cual aparecerá un ‘*’ en todos los i, j
en los cuales se determinó que hay una estrella. Las demás posiciones quedarán vacías.
Siguiendo con el ejemplo anterior, se debería obtener una tabla como la que se muestra a
continuación:
1 2 3 4 5 6 7 8
2 *
3
4 *
5 * * *
6
a) Prueba la clase considerando todos los casos que puedan presentarse.

b) ¿Qué cambios deberías hacer si quisiéramos que el observatorio fuera capaz de
analizar la información de varias fotografías?
56
Ejercicio 8: Define la clase Estacionamiento que permita representar un estacionamiento
de n pisos con m lugares (cajones de estacionamiento) por piso. Decide el tipo y la cantidad
de atributos y los métodos que se necesitan para que la clase represente el concepto
mencionado y tenga la funcionalidad requerida según lo que se describe más abajo.
Cuando un auto se estaciona debe validar su boleto indicando el piso y el cajón que está
ocupando, así como la hora a la que llegó (del 0 al 24). La máquina de validación de boletos
le indica al usuario si el piso y cajón indicados son correctos o no, luego de verificar si el
lugar estaba o no como disponible. Además, se le solicita al usuario que proporcione toda
la información referente a su automóvil (marca, año, modelo, placas, tipo, fechas de
servicios realizados durante el año (mes), y cada uno de los tipos de servicios realizados:
afinación, frenos, cambio aceite, balatas, etc…).
El administrador del estacionamiento desea que, en cualquier momento, se puedan

contestar las siguientes preguntas:
a) ¿Cuántos automóviles tipo USV (camionetas) hay estacionadas en un cierto piso del
estacionamiento?
b) ¿Cuántos cajones de estacionamiento hay libres?
c) Considerando un automóvil con ciertas placas, ¿cuántos servicios tiene registrados
en el año?
d) La lista de autos (sólo sus placas) que cumplan la condición de tener registrado algún
servicio específico (p.e. cambio de aceite).
e) Cajón de estacionamiento (piso y número de cajón) en el cual se encuentra el auto
más viejo (puedes suponer que las placas son asignadas de menor a mayor de
acuerdo a la antigüedad del auto).
f) ¿Cuántos autos de una cierta marca hay estacionados en todo el estacionamiento?
g) Si existe, indique el piso que se encuentre con todos los lugares disponibles.
h) Partiendo del primer piso y primer cajón, hasta el piso n y último cajón, indique el
primer lugar disponible que haya en el estacionamiento.
i) Indique si el estacionamiento NO tiene ningún lugar disponible.
OPCIONAL: Suponiendo que cada auto tiene registrada la información de la Persona

(puedes usar la clase Persona ya programada) que lo compró (en el momento de que el auto
“entre” al estacionamiento el usuario la proporcionará también), se deberá poder contestar
las siguientes preguntas:
a) ¿Cuál es el auto estacionado (placas) cuyo dueño sea el más longevo?

b) ¿Cuántos autos estacionados son propiedad de personas de algún género específico
(p.e. mujeres)?
c) Plantea alguna pregunta “interesante” que tenga que ver con esta nueva
información explotable desde el Estacionamiento…
57
13- Interfaces gráficas de usuario (GUI)
Ejercicio 1: El ITAM está recabando fondos para las becas de manutención con una
presentación de cine. Para ayudar a la venta de los boletos, se te pide realizar un programa
con una ventana como la que se muestra a continuación y su controlador.
Dado el número de boletos de adulto, el número de boletos de niño y su clasificación, se
debe calcular y regresar el costo a pagar por la función. El pago se realiza multiplicando el
número de boletos de adulto por 120 pesos si es clasificación A, 130 pesos si es clasificación
B y 150 pesos si es clasificación C. A esto se le debe sumar el número de boletos de niño por
30 pesos, no importa la clasificación excepto que el niño no puede ver películas de
clasificación C. Para mostrar el costo, modifica la ventana muestra o abre otra ventana.
Ejercicio 2: Se desea desarrollar un sistema que apoye al diagnóstico temprano de la

diabetes. Para ello debes construir una ventana que permita capturar la respuesta a las
siguientes preguntas:
¿Sed extrema?
¿Hambre extrema?
¿Ganas de orinar frecuentemente?
¿Llagas o moretones que se curan lentamente?
Si el paciente presenta cualquiera de estos síntomas se considera propenso a la diabetes
tipo uno y si, además:
¿Tiene más de 45 años de edad?
¿Está pasado de peso?
¿Su padre, madre, hermano o hermana tiene diabetes?
Entonces es propenso a la diabetes tipo dos.
1. Escribe la clase DiabetesVista en donde dibujes la ventana requerida para capturar
los datos arriba mencionados.
58
2. Escribe la clase DiabetesControlador donde le des la funcionalidad al sistema de tal
manera que, al recibir las respuestas de un paciente, imprima si es propenso o no a
desarrollar diabetes y, en caso afirmativo, de qué tipo.
Ejercicio 3: Escribe la clase MasaVista para crear una ventana como la que se muestra a
continuación:
El índice de masa corporal (IMC) es una medida de asociación entre el peso y la estatura de
un individuo ideada por el estadístico belga Adolphe Quetelet, por lo que también se conoce
como índice de Quetelet. Se calcula según la expresión matemática:
IMC = peso/estatura2
La clasificación de la OMS del estado nutricional de acuerdo con el IMC es:
Bajo peso <18.50

Normal 18.5 – 24.99
Sobrepeso ≥25.00
Obesidad ≥30.00
Escribe la clase MasaControlador de tal manera que pueda informar a cada usuario en qué
categoría se encuentra, según su peso y estatura.
Ejercicio 4: Escribe una clase “vista” que permita construir una ventana como la que se
muestra más abajo. Como se puede observar, en la ventana hay algunas etiquetas, campos de
texto y un botón. Esa ventana permite ingresar el nombre de un archivo y una letra. Escribe
también una clase “controlador” que, una vez oprimido el botón Aceptar, se despliegue en el
último campo de texto todas las palabras que contiene el archivo que empiecen o terminen
con la letra dada. Considera todos los casos que puedan presentarse.
En el ejemplo se captura el nombre del archivo: frutas (el mismo se proporciona en la unidad
U) y, al ingresar la letra n, el programa despliega todas las frutas que se encuentran en el
archivo cuyos nombres empiezan o terminan con la n. En este caso: naranja, melon
NOTAS:
59
i) Se suprimieron los acentos intencionalmente.
ii) Puedes suponer que en el campo de texto usado para mostrar el resultado siempre
hay lugar. También puedes investigar e incorporar lo necesario para desplegar gran
cantidad de información.
iii) Considera que tanto el nombre del archivo como las letras pueden darse en
mayúsculas o minúsculas.
Ejercicio 5: La Secretaría de Gobernación está solicitando un programa para hacer diversas

consultas sobre los ciudadanos. Para cumplir con esa necesidad, retoma la clase Persona de
la sección de cadenas de caracteres y escribe una clase “vista” tal que permita al usuario
ingresar los datos de una persona, con especial atención en el CURP. Esa clase también
puede usarse para mostrar los resultados de las consultas. Además, escribe una clase
“controlador” que, una vez ingresados los datos de la persona, ofrezca la funcionalidad
requerida para extraer y desplegar información complementaria de la persona como: edad,
género y lugar de nacimiento. Analiza el problema, identifica los requisitos funcionales y
diseña la solución. Decide qué componentes gráficos incluir en la vista y la distribución de
los mismos, así como las clases requeridas y la relación entre ellas.
60
Apéndice A: Uso del Debugger en Eclipse
El debugging permite correr un programa interactivamente mientras se analiza el código y

las variables durante la ejecución. A través de los breakpoints en el código, se especifica
dónde debe parar la ejecución del programa. Una vez que el programa es detenido se
pueden analizar las variables, cambiar su contenido, etc.
Eclipse te permite correr un programa de Java en modo Debug, para lo cual proporciona un
conjunto preconfigurado de opciones.
● Se puede controlar el proceso de ejecución del programa y analizar el estado de las
variables
Colocar los breakpoints

Para colocar los breakpoints en el renglón de código deseado, da clic derecho en el pequeño
margen izquierdo y selecciona Toggle Breakpoint en el menú desplegable. Otra manera es
dar doble clic en esa misma posición.
Iniciar el Debugger
Para iniciar el Debugger, selecciona el archivo de Java que será ejecutado, da clic derecho
en él y selecciona Debug As → Java Application.
61
Una vez que has iniciado la aplicación a través del menú anterior, puedes usar de nuevo la
configuración de lanzamiento creada a través del botón Debug en la barra de herramientas
de Eclipse.
Si no has definido ningún breakpoint, tu programa correrá normal. Para utilizar el Debug
necesitas definir primero los breakpoints.
Si iniciaste el Debugger, Eclipse te pregunta si quieres cambiar a la vista Debug una vez que
se alcanza un punto para detenerse. Responde que sí en el cuadro correspondiente.
Después Eclipse abre una vista similar a la siguiente imagen:
62
El programa se ejecuta de inmediato y el debugger está listo para usarse. Automáticamente
se detiene en el primer breakpoint indicado para que el usuario pueda empezar su análisis.
Controlar la ejecución del programa
Eclipse proporciona botones en la barra de herramientas para controlar la ejecución del

programa, aunque es más fácil usar las teclas correspondientes para controlar la ejecución.
Observa la siguiente tabla.
Tecla ● Descripción
Ejecuta la línea actualmente seleccionada y avanza a la siguiente línea

F5 en tu programa. Si la línea seleccionada es una llamada a un método,
el debugger avanza al código asociado.
F6 Ejecuta un método sin que el debugger se pare adentro.
Finaliza la ejecución del método actual y regresa a donde fue

F7
llamado.
63
Continúa la ejecución del programa hasta que se tope con el
F8
siguiente breakpoint o watchpoint.
La pila de llamadas muestra las partes del programa que están siendo actualmente
ejecutadas y como están relacionadas entre ellas. La pila de llamadas es mostrada en la vista
Debug.
La pestaña Breakpoints permite eliminar o desactivar breakpoints.
La pestaña Variables muestra campos y variables locales de la pila que está siendo ejecutada
actualmente. Se necesita correr el debugger para ver las variables en esta pestana. Usa el
drop-down menú para mostrar las variables estáticas. Con el drop-down menú de la
pestaña también puedes personalizar las columnas visualizadas.
Además la pestaña Variables también permite cambiar el valor asignado a tu variable en
tiempo de ejecución.
Controlar la visualización de las variables

Por default la pestaña Variables usa el método toString() para determinar cómo visualizar
una variable. Pero puedes definir un Detail Formatter en el cual puedes usar código de Java
para definir cómo será visualizada la variable. Da clic derecho en la variable correspondiente
y selecciona New Detail Formatter en el menú desplegado. Después puedes usar un método
de esa clase para determinar la salida.
64
65
Ejemplo
1. Captura el código anterior.

2. Coloca un breakpoint dentro del método sumaN() de la clase Contador. Utiliza el
debug para correr el programa y sigue la ejecución del método.
3. Define un Detailed Formatter para Contador que use el método getResultado().
Utiliza el debug para correr el programa y verifica que el cambio fue efectuado.
4. Podrás analizar cómo va aumentando la variable i y cómo va cambiando la variable
aux. Cuando acabe de ejecutarse el método, el Debugger regresará al main donde
podrás ver el valor de la variable prueba antes de imprimir en la consola.
66
Apéndice B: Uso de clases definidas en otros proyectos
Cuando se está trabajando en un proyecto y se quieren usar clases definidas en otro

proyecto se puede proceder de diversas maneras, algunas más formales que otras. A
continuación, se presenta una de ellas, la cual resulta fácil de llevar a cabo.
Sobre el proyecto en el que se quieren usar las clases de otro proyecto:
1) Dar click en el botón derecho del mouse

2) Elegir Properties
3) Dar click en Java Build Path
4) Dar click en Projects
5) Dar click en Add
6) Elegir el proyecto en el cual están las clases que se quieren usar
7) Dar click en OK
Después de aplicado el último paso se podrán usar cualquiera de las clases del proyecto
agregado.
67

Cuaderno de Ejercicios - AyP - v11

Cargado por

Copyright:

Formatos disponibles

Cuaderno de Ejercicios - AyP - v11

Cargado por

Información del documento

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

Cuaderno de Ejercicios - AyP - v11

Cargado por

Copyright:

Formatos disponibles

Agosto de 2019

Departamento Académico de Computación

En este cuaderno de ejercicios se presentan varios problemas donde se aplican los

Ejercicio 1: Evalúa las siguientes expresiones aritméticas.

Ejercicio 2: Indica, usando [], el orden en el cual se aplican los operadores.

Ejercicio 3: Elimina los paréntesis innecesarios de las siguientes expresiones.

Ejercicio 4: Evalúa las siguientes expresiones.

Ejercicio 5: Evalúa las siguientes expresiones.

a) no (15 ≥ 7 ** 2) o (43 – 8 * 2 div 4  3 * 2 div 2)

a) ¿Cuántas operaciones de multiplicación y cuántas de suma utilizó?

Ejercicio 2: El precio de un boleto de viaje redondo en tren se calcula tomando en cuenta el

Ejercicio 3: Elabora un diagrama de flujo para resolver ax2 + bx + c = 0 en el caso de raíces

Análisis del problema:

● Segundo, es cuando b = 0 y c = 0, que es evidente una identidad.

Ejercicio 4: Realiza un diagrama de flujo para calcular y de acuerdo a lo que se especifica a

Ejercicio 5: Realiza un diagrama de flujo para calcular y de acuerdo a lo que se especifica a

Ejercicio 6: Realiza un diagrama de flujo para calcular y de acuerdo a lo que se especifica a

a) Solicite el monto de cada venta sin IVA,

Ejercicio 10: Una tabla de estadísticas muestra la producción de barriles de petróleo de 5

bm, bv, bas, bl, ba: No. de barriles/país en enero

Elabora un diagrama de flujo que calcule la producción total de barriles en el semestre y la

Ejercicio 14: Una carrera profesional consta de 40 materias, repartidas en 8 semestres a

b) La tasa media inflacionaria:

Ejercicio 17: Sean los datos:

Haz un diagrama de flujo para calcular la siguiente suma:

Ejercicio 18: Dados los datos:

n, x, a0, a1, a2, ..., an

Elabora un diagrama de flujo que, sin utilizar la operación de potencia y minimizando el

¿Existe una única manera de alternar los signos?

Ejercicio 2: El próximo mes de julio se llevarán a cabo las elecciones presidenciales en

a) ¿Cuál es el porcentaje de abstenciones?

Ejercicio 3: Se cuenta con la siguiente información de ventas de un camión repartidor de

Ejercicio 4: Realiza un diagrama de flujo para resolver el siguiente problema: Inicialmente

a) ¿Cuántos asistentes hubo en la Feria?

Ejercicio 7: En el Sistema Meteorológico Nacional se tiene la información de precipitaciones

Se te pide hacer un diagrama de flujo que conteste las siguientes preguntas:

Ejercicio 8: Una importante empresa de software organizó un concurso entre alumnos de

Antes de analizar la solución diseñada, se quiere analizar la productividad de cada

Ejercicio 1: El siguiente diagrama de flujo tiene un fin específico:

a) Realiza el mapa de memoria, primero con n = 10 y posteriormente con n = 456.

Nota: n, x y k son enteros

Para el siguiente diagrama de flujo:

Ejercicio 2: Una factura es un comprobante en el cual se reflejan las transacciones

d) Identifica 2 funciones, indica su nombre, el tipo de la función y los parámetros si

Posteriormente representa la clase por medio de un diagrama UML.

Ejercicio 7: Representa por medio de un diagrama UML la figura geométrica “pentágono”

Antes de resolver cada problema, ten en cuenta que:

● Para encontrar la solución a un problema, primero debes entenderlo. Dada la

a) Realiza el diagrama de la clase Rectangulo en UML.

Ejercicio 6: Programa la clase CientificoMatematico según el siguiente diagrama UML:

Puedes agregar los métodos que creas conveniente. Considera lo enunciado en la

Ejercicio 7: En la clase CientificoMatematico agrega el método estaOrdenCreciente(int

Ejercicio 8: En la clase CientificoMatematico agrega el método ordenaCreciente(int

Ejercicio 9: En la clase CientificoMatematico agrega el método esImpar(int número):

Ejercicio 10: En la clase PruebaCientificoMatematico escribe un método main en el cual se

Al terminar, prueba tu método en la clase PruebaCientificoMatematico.

Ejercicio 12: En la clase CientificoMatematico agrega el método calculaFuncion2(int x):

Al terminar, prueba el método en la clase PruebaCientificoMatematico.

Ejercicio 13: en la clase CientificoMatematico agrega el método calculaFuncion3(int num,