Ebook en PDF Guia de Ejercicios Resueltos Usando Arreglos en Java

GUÍA DE
EJERCICIOS
RESUELTOS Autor: José
USANDO
Roberto
Colón
Villalta
ARREGLOS EN
JAVA
Colección de ejercicios resueltos utilizando lenguaje
Java, los cuales involucran en su desarrollo el uso
de arreglos (arrays) de una o dos dimensiones
Contenido
Introducción ..............................................................................................................................................................2
Primera parte: Ejercicios resueltos con vectores de una dimensión ........................................................................3
Ejercicio #1: ..........................................................................................................................................................3
Solución al ejercicio #1: ........................................................................................................................................3
Observaciones importantes a la solución del ejercicio #1: ...................................................................................3
Ejercicio #2: ..........................................................................................................................................................4
Ejercicio #3: ..........................................................................................................................................................6
Ejercicio #4: ..........................................................................................................................................................8
Ejercicio #5: ..........................................................................................................................................................9
Observaciones importantes a la solución del ejercicio #5: ................................................................................ 10
Ejercicio #6: ....................................................................................................................................................... 11
Solución al ejercicio #5: ..................................................................................................................................... 11
Ejercicio #7: ....................................................................................................................................................... 15
Segunda parte: Ejercicios resueltos con matrices (vector de dos dimensiones) .................................................. 18
Ejercicio #8: ....................................................................................................................................................... 18
Ejercicio #9: ....................................................................................................................................................... 21
Ejercicio #10: ..................................................................................................................................................... 26
Solución al ejercicio #10: ................................................................................................................................... 26
Observaciones importantes a la solución del ejercicio #10: .............................................................................. 27
Ejercicio #11: ..................................................................................................................................................... 28
Solución al ejercicio #11: ................................................................................................................................... 28
Observaciones importantes a la solución del ejercicio #11: .............................................................................. 29
Referencias ............................................................................................................................................................ 32
1
Introducción
La presente guía de ejercicios resueltos, es una compilación de código Java de mi

autoría, desarrollado a lo largo de los años en la catedra de Programación I -la cual imparto en
la Facultad Multidisciplinaria de Occidente de la Universidad de El salvador- pero delimitada
exclusivamente a la temática: arreglos (arrays) de una y dos dimensiones.
Considero de extrema importancia la temática debido a que su aprendizaje y aplicación
requieren de lógica, orden y conocimientos básicos de programación en Java; todos esos
atributos son indispensables para un fututo programador, indistintamente del lenguaje que
prefiera más adelante en su vida profesional.
Cada ejercicio resuelto consta de tres partes: planteamiento del problema, código Java que da
solución al problema, y observaciones importante sobre la solución; esta última parte es de
gran importancia, ya que provee el análisis de las partes más importantes de las instrucciones.
Se tienen además muchos comentarios que guían o dan pistas de lo que se está resolviendo,
además delimitan los trozos de código y la parte que soluciona del problema.
Antes de proceder a revisar los ejercicios resueltos, recomiendo encarecidamente hacer una
lectura básica sobre la temática arreglos (arrays), para lo cual recomiendo el siguiente
documento en línea: “Vectores y matrices” (Berzal Galiano). También es indispensable
conocer cómo crear, guardar y recuperar proyectos en Java NetBeans, para ello, en lugar de
una lectura, sugiero visitar YouTube y buscar video tutoriales que demuestran cómo hacerlo.
Ahora sí, sin más preámbulos, comencemos a revisar código de programación.
2
Primera parte: Ejercicios resueltos con vectores de una dimensión
Ejercicio #1:
Desarrolle un vector de tamaño dinámico de entre 1 y 50 posiciones, determinado por el
usuario, que almacene calificaciones en un rango válido de 0.0 a 10.0. Finalmente, muestre
cada una de las calificaciones del vector separadas por comas (,).
Solución al ejercicio #1:

double[] notas;
double nota, burbuja;
String salida="";
int tamanio, posicion, recorrido;
//dimensionamiento del vector, tamaño entre 1 y 50 posiciones

do{
tamanio=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas calificaciones
guardará? (entre 1 y 50)"));
}while(tamanio<=0 || tamanio>50);
notas=new double[tamanio];
//ingreso de notas o calificaciones

for (posicion=0; posicion<notas.length;posicion++){
do{
nota=Double.parseDouble(JOptionPane.showInputDialog("La nota del alumno
#"+(posicion+1)+" es"));
}while(nota<0 || nota>10);
notas[posicion]=nota;
}
//mostrar datos originales

for (posicion=0; posicion<notas.length;posicion++){
salida=salida+notas[posicion]+",";
}
JOptionPane.showMessageDialog(null, salida);
Observaciones importantes a la solución del ejercicio #1:

Para las entradas y salidas de datos se está utilizando la librería javax.swing.JOptionPane, la
cual será necesario importarla y usarla como parte del código.
En el ingreso de notas o calificaciones (ver comentario en el código de la solución) se utiliza
una variable de nombre o identificador nota, que permite ser validada en un rango de 0.0 a
10.0 antes de que dicho valor sea almacenado en el vector en la posición correspondiente; es
importante aclarar que ya sea en un vector o en una base de datos, siempre es pertinente
guardar datos válidos y evitar guardar datos incorrectos y luego proceder a revisarlos.
3
Ejercicio #2:
Desarrolle un vector de tamaño dinámico de entre 1 y 100 posiciones, determinado por el
usuario, que almacene valores enteros; muestre el contenido del vector como originalmente
se llenó; posteriormente, aplique el método de la burbuja (Fundamentos de la programación,
2013-2014, pág. 649) para ordenarlos del menor valor al mayor; finalmente, muestre el vector
ordenado ascendentemente.

int vector[];
int tamanio, posicion, iteracion, burbuja;
String salida = "";
do {
tamanio = Integer.parseInt(JOptionPane.showInputDialog("¿De qué tamaño es el
vector? (entre 1 y 100)"));
} while (tamanio < 1 || tamanio > 100);
vector = new int[tamanio];
//ingreso de valores al vector, sin validarlos

for (posicion = 0; posicion < vector.length; posicion++) {
vector[posicion] = Integer.parseInt(JOptionPane.showInputDialog("vector[" + posicion +
"]"));
}
//mostrar los valores del vector tal como fueron ingresados

salida = salida + vector[posicion] + ",";
}
/*proceso de ordenamiento usando dos bucles anidados, el primero de ellos para las
repeticiones del proceso y el segundo bucle para comparar una posición del vector con
la siguiente*/
for (iteracion = 1; iteracion <= tamanio; iteracion++) {
for (posicion = 0; posicion < (tamanio - 1); posicion++) {
if (vector[posicion] > vector[posicion + 1]) {
burbuja = vector[posicion];
vector[posicion] = vector[posicion + 1];
vector[posicion + 1] = burbuja;}
}
}
//mostrar los valores del vector ya ordenados ascendentemente

salida="";
salida = salida + vector[posicion] + ",";}
4
El método de ordenamiento de vectores de una dimensión es un proceso bien documentado y
de revisión indispensable en los cursos de programación. Personalmente recomiendo hacer
una revisión del documento titulado: “Fundamentos de la programación”, página 649, del autor:
Luis Hernández Yáñez; que a fecha 6 de octubre de 2017 está en línea en la Web oficial de la
Universidad Complutense – Facultad de Informática, URL:
https://www.fdi.ucm.es/profesor/luis/fp/FP.pdf
5
Ejercicio #3:
Desarrolle el mismo ejercicio #2, pero para cada iteración o recorrido del vector que trata de
ordenarse ascendentemente, muestre como va quedando el vector.

int vector[];
int tamanio, posicion, iteracion, burbuja;
String salida = "";
do {
tamanio = Integer.parseInt(JOptionPane.showInputDialog("¿De que tamaño es el
vector? (entre 1 y 100)"));
} while (tamanio < 1 || tamanio > 100);
vector = new int[tamanio];
//ingreso de valores al vector, sin validarlos

vector[posicion] = Integer.parseInt(JOptionPane.showInputDialog("vector[" + posicion +
"]"));
}
//mostrar los valores del vector tal como fueron ingresados

salida = salida + vector[posicion] + ",";
}
//ordenamiento asecendente a través del método de la burbuja

salida="";
for (iteracion = 1; iteracion <= tamanio; iteracion++) {
//mostrar paso a paso el ordenamiento
for (posicion = 0; posicion < tamanio; posicion++) {
salida=salida+vector[posicion]+",";
}
salida=salida+"\n";
//proceso de ordenamiento usando dos bucles anidados

for (posicion = 0; posicion < (tamanio - 1); posicion++) {
if (vector[posicion] > vector[posicion + 1]) {
burbuja = vector[posicion];
vector[posicion] = vector[posicion + 1];
vector[posicion + 1] = burbuja;
}
}
}
6
Para mostrar cada iteración de ordenamiento, solo fue necesario agregar un nuevo bucle que
permite modificar la variable salida, y en ella se va acumulando cada uno de los miembros del
vector (ver código debajo del comentario //mostrar paso a paso el ordenamiento). Luego,
aparece el método de la burbuja, que hace su función de ordenamiento.
7
Ejercicio #4:
Hasta el momento le hemos llamado vector dinámico a los que para dimensionarse, primero
se le pregunta al usuario ¿de qué tamaño será el vector?, o con preguntas similares. Sin
embargo, en Java existen verdaderos vectores dinámicos que aumentan y disminuyen de
tamaño en virtud de los elementos que se le agregan o quitan.
A continuación se desarrolla un ejemplo sencillo en el cual el array (ArrayList) contendrá datos
de cualquier tipo y dejará de recibirlos al ingresar un valor vacío. Luego mostrará el contenido.

ArrayList datos = new ArrayList();
String entrada, salida;
JTextArea hoja = new JTextArea();
int posicion;
entrada = JOptionPane.showInputDialog("Ingrese un dato....déjelo vacío para finalizar");
//proceso de entrada de datos al ArrayList, finaliza cuando se ingresa un dato vacío

while (!entrada.equals("")){
datos.add(entrada);
entrada = JOptionPane.showInputDialog("Ingrese un dato....déjelo vacío para finalizar");
}
//mostrar el contenido del arreglo

salida="";
for (posicion=0;posicion<datos.size();posicion++){
salida=salida+datos.get(posicion)+"\n";
}
hoja.setText(salida);
JOptionPane.showMessageDialog(null, hoja);

Para las entradas y salidas de datos se está utilizando la librería JOptionPane, la cual será
necesario importarla y usarla como parte del código, además se importará la librería
java.util.ArrayList que nos proporcionará el acceso a las funcionalidades de la Clase ArrayList
y la librería import javax.swing.JTextArea que proporciona cuadros de texto para mejorar las
salidas cuando la cantidad de datos por mostrarse es grande o requiere formato.
En la primer línea se hace una instanciación de la clase ArrayList, el objeto creado se llama
datos. En la tercera línea se hace una instanciación de la clase JTextArea, el objeto creado
se llama hoja.
Para el ingreso de datos hacia el ArrayList se utiliza un bucle while, que repetirá el proceso
hasta que se ingrese un dato vacío.
Finalmente, la salida de datos se hará a través de un solo bucle que irá obteniendo uno por
uno los datos del arreglo a través de: datos.get(posicion), hasta llegar al final; el cálculo de
la tamaño de la lista se hace a través de datos.size(); cada dato extraído se añadirá a la
variable salida. Todo el texto que ha acumulado en la variable salida se asigna al objeto hoja
a través del método setText: hoja.setText(salida), como paso final el objeto hoja debe
mostrarse a través de un cuadro de dialogo JOptionPane.showMessageDialog(null, hoja);
8
Ejercicio #5:
A continuación se desarrolla un ejemplo sencillo en el cual el array (ArrayList) contendrá datos
de tipo String y tratará de guardarse nombres masculinos y femeninos, finalizará cuando se
ingrese un nombre vacío. Se mostraran los nombres guardados y se dará la oportunidad de
quitar algún nombre de la lista.

ArrayList<String> nombres = new ArrayList(); //lista de datos de tipo String
int posicion, cuantos;
String nombre, salida, cualQuitar;
//Ingreso de nombres al arreglo

nombre=JOptionPane.showInputDialog("Ingrese un nombre masculino o femenino");
while (!nombre.equals("")){
nombres.add(nombre);
nombre=JOptionPane.showInputDialog("Ingrese un nombre masculino o femenino");
}
//mostrar los nombres de la lista

salida="";
for (posicion=0; posicion<nombres.size();posicion++){
salida=salida+nombres.get(posicion)+"\n";}
//solicitar el nombre a remover de la lista

cuantos=nombres.size();
do{
cualQuitar=JOptionPane.showInputDialog("Ingrese el nombre a remover de la lista");
}while(cualQuitar.equals(""));
/*buscar en la lista el nombre, si existe se proceder a removerlo,

sino se informa que no se encontro*/
if (cualQuitar.equals(nombres.get(posicion))){
nombres.remove(posicion);
}
}
if (nombres.size()<cuantos){
JOptionPane.showMessageDialog(null, "Se removió "+cualQuitar+" de la lista");
}
else{
JOptionPane.showMessageDialog(null, "No se encontró el nombre");
}
//mostrar los nombres de la lista excepto si se removió alguno

9
salida="";
salida=salida+nombres.get(posicion)+"\n";
}

Para las entradas y salidas de datos se está utilizando la librería JOptionPane, la cual será
necesario importarla y usarla como parte del código, además se importará la librería
java.util.ArrayList que nos proporcionará el acceso a las funcionalidades de la Clase ArrayList
y la librería import javax.swing.JTextArea que proporciona cuadros de texto para mejorar las
En la primer línea se hace una instanciación de la clase ArrayList, el objeto creado se llama
nombres y es de tipo String. En la tercera línea se hace una instanciación de la clase
JTextArea, el objeto creado se llama hoja.
Para el ingreso de datos hacia el ArrayList se utiliza un bucle while, que repetirá el proceso
hasta que se ingrese un nombre vacío.
La salida de datos se hará a través de un solo bucle que irá obteniendo uno por uno los datos
del arreglo a través de: datos.get(posicion), hasta llegar al final; el cálculo de la tamaño de la
lista se hace a través de datos.size(); cada dato extraído se añadirá a la variable salida. Todo
el texto que ha acumulado en la variable salida se asigna al objeto hoja a través del método
setText: hoja.setText(salida), como paso final el objeto hoja debe mostrarse a través de un
cuadro de dialogo JOptionPane.showMessageDialog(null, hoja).
Para buscar un nombre se le solicita al usuario que ingrese el texto a través de un cuadro de
dialogo y este valor se almacena en la variable cualQuitar. El proceso de búsqueda consiste
en ir comparando el valor de cualQuitar con cada uno de los elementos del ArrayList; si lo
encuentra -es decir si hay coincidencia de valores- se procede a removerlo de la lista:
nombres.remove(posicion).
Al salir del bucle de búsqueda pueden suceder dos cosas: primero, que el nombre buscado
existe y por lo tanto se removió; o dos, el nombre no se encontró; para codificar esa situación,
antes de hacer la búsqueda se calculó y guardo el tamaño del ArrayList (nombres.size() ) en
la variable cuantos, luego al salir de la búsqueda, es posible averiguar si aún hay igual
cantidad de elementos en el ArrayList o si hay menos, y así concluir sobre si el elemento se
removió o no se encontró.
10
Ejercicio #6:
Imagine una administración de casilleros, dónde el usuario alquila un casillero por un tiempo,
dicho cobro es por $2 y a la hora que lo “devuelve” y queda vacío se le regresa $1 al cliente.
Tenga en cuenta que no se puede alquilar un casillero ya ocupado, y que también para
devolver un casillero este debió estar ocupado. En general las opciones a programar son las
siguientes: Mostrar el estado de los casilleros: “d” significará desocupado y “o” ocupado,
alquilar casillero, devolver llave de casillero, caja (cuánto dinero se ha recaudado), cerrar el
negocio y ver el historial de préstamos y devoluciones de casilleros.

char[] casilleros;
double caja = 0;
/*al cobrar se tienen $2, pero se devuelve
$1 al recibir la llave del casillero*/
int tamanio, posicion, opcion, cual;
String salida, salida2, historial = "";
do {
tamanio = Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos casilleros
administrará? (entre 1 y 10)"));
} while (tamanio <= 0 || tamanio > 10);
casilleros = new char[tamanio];
//a cada casillero se le asigna un d(esocupado)

casilleros[posicion] = 'd';
}
opcion = Integer.parseInt(JOptionPane.showInputDialog("Menú:\n1.Mostrar\n2.Alquilar
casillero\n3.Devolver llave\n4.Caja\n5.Cerrar\nCualquier otro número para salir"));
while (opcion >= 1 && opcion <= 5) {
if (opcion == 1) {
salida = "";
salida2 = "";
salida = salida + casilleros[posicion] + "\t";
salida2 = salida2 + posicion + "\t";
}
hoja.setText(salida + "\n" + salida2);
} else if (opcion == 2) {
do {
cual = Integer.parseInt(JOptionPane.showInputDialog("¿Cual casillero quiere?
(entre 0 y " + (tamanio - 1) + ")"));
} while ((cual < 0 || cual >= tamanio) || casilleros[cual] == 'o');
casilleros[cual] = 'o';
caja = caja + 2;
historial = historial + "Se prestó el casillero #" + cual + " (aumento $2 la caja)\n";
11
do {
cual = Integer.parseInt(JOptionPane.showInputDialog("¿De cual casillero
devolvera llave? (entre 0 y " + (tamanio - 1) + ")"));
} while ((cual < 0 || cual >= tamanio) || casilleros[cual] == 'd');
casilleros[cual] = 'd';
caja = caja - 1;
historial = historial + "Se recibió la llave del casillero #" + cual + " (disminuye
$1 la caja)\n";
JOptionPane.showMessageDialog(null, "Se ha recolectado $" + caja);
hoja.setText(historial);
}
opcion =Integer.parseInt(JOptionPane.showInputDialog("Menú:\n1.Mostrar\n2.Alquilar
}

Para las entradas y salidas de datos se está utilizando la librería JOptionPane, la cual deberá
importarse (Meza González, 2012-2017) y usarla como parte del código, además se importará
la librería javax.swing.JTextArea que nos proporcionará cuadros de texto para mejorar las
Luego, se le pregunta al usuario por la cantidad de casillero a administrar (entre 1 y 10).
El vector utilizado es de tipo char, se usa un bucle para llenar cada posición con valores ‘d’
que significará que cada casillero está desocupado (vacío).
En el presente ejercicio se utiliza un bucle while que simula el comportamiento de un menú, es
decir una serie de opciones a las cuales el usuario puede acceder una y otra vez, hasta que
decida salir de la ejecución del programa. La primera línea de este menú consiste en mostrar
las opciones al usuario:
El menú se mantiene en funcionamiento con dicho while que permitirá permanecer dentro
mientras se elijan opciones válidas:
//aquí irá el código de las opciones del menú
}
La codificación de cada una de las opciones es la siguiente:

La primera opción es: 1.Mostrar, ver el listado de casilleros y si están ocupados ‘o’ o
desocupados ‘d’:
12
if (opcion == 1) {
salida = "";
salida2 = "";
salida = salida + casilleros[posicion] + "\t";
salida2 = salida2 + posicion + "\t";
}
hoja.setText(salida + "\n" + salida2);
}
La segunda opción es: 2.Alquilar casillero, se debe buscar el casillero, determinar si existe y
si está desocupado, entoncesproceder a cambiar su estado de ‘d’ a ‘o’:
else if (opcion == 2) {
do {
cual = Integer.parseInt(JOptionPane.showInputDialog("¿Cual casillero quiere?
(entre 0 y " + (tamanio - 1) + ")"));
} while ((cual < 0 || cual >= tamanio) || casilleros[cual] == 'o');
casilleros[cual] = 'o';
caja = caja + 2;
historial = historial + "Se prestó el casillero #" + cual + " (aumento $2 la caja)\n";
}
Muy importante es hacer notar que cuando se han alquilado todos los casilleros y se accede
a dicha opción, se puede incurrir en un bucle infinito, debido a que no hay casilleros disponibles
y el proceso requiere de uno libre para poder salir.
La tercera opción es: 3.Devolver llave, se debe buscar el casillero, determinar si existe y si
está ocupado, entonces proceder a cambiar su estado de ‘o’ a ‘d’; también se debe reducir en
1 el valor de la variable caja debido a la devolución de $1 al cliente, tal como lo indica el
planteamiento del problema:
do {
cual = Integer.parseInt(JOptionPane.showInputDialog("¿De cual casillero
devolvera llave? (entre 0 y " + (tamanio - 1) + ")"));
} while ((cual < 0 || cual >= tamanio) || casilleros[cual] == 'd');
casilleros[cual] = 'd';
caja = caja - 1;
historial = historial + "Se recibió la llave del casillero #" + cual + " (disminuye
$1 la caja)\n";
}
La cuarta opción es: 4.Caja, se muestra el valor acumulado hasta ese momento en la variable
caja:
JOptionPane.showMessageDialog(null, "Se ha recolectado $" + caja);
}
13
La quinta opción es: 5.Cerrar, se muestra un historial de todas los alquileres y devoluciones
ocurridos; para ello, siempre que se hace un alquiler o una devolución -opción 2 y opción 4,
respectivamente- se agrega una texto indicando dicha acción, la variable que guarda dichas
anotaciones es historial:
hoja.setText(historial);
}
14
Ejercicio #7:
Imagine la administración de dinero de un usuario a través de dos rubros principales: entradas
de efectivo y salidas de efectivo.
Para ello se crearan dos vectores: el primero, entradas, este se utilizará para registrar cada
ingreso de dinero; por el contrario, el segundo, salidas, se utilizará para registrar cada egreso
de dinero.

double[] entradas;
double[] salidas;
int tamanio, opcion, posicionEntrada=0, posicionSalida=0, posicion=0;
double salida, entrada;
String cadena1="Salidas\n", cadena2="Entradas\n";
JTextArea pagina = new JTextArea();
do{
tamanio=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos registros desea
administrar?(máximo 100)"));
entradas = new double[tamanio];
salidas=new double[tamanio];
opcion=Integer.parseInt(JOptionPane.showInputDialog("Opciones:\n1.Salida de
efectivo\n2.Entrada de efectivo\n3.Ver estado de cuenta, Cualquier otro número para
salir"));
//acceso al menú
while(opcion>=1 && opcion<=3){
if (opcion==1){
//salida de efectivo
do{
salida=Double.parseDouble(JOptionPane.showInputDialog("¿Cuánto fue la
salida de efectivo? (mayor a cero)"));
}while(salida<=0);
salidas[posicionSalida]=salida;
posicionSalida=posicionSalida+1;
}
else if (opcion==2){
//entrada de efectivo
do{
entrada=Double.parseDouble(JOptionPane.showInputDialog("¿Cuánto fue la
entrada de efectivo? (mayor a cero)"));
}while(entrada<=0);
entradas[posicionEntrada]=entrada;
posicionEntrada=posicionEntrada+1;
}
//estado de cuenta
posicion=0;
15
cadena1="Salidas\n";
cadena2="Entradas\n";
while (salidas[posicion]!=0.0){
cadena1=cadena1+salidas[posicion]+",";
posicion=posicion+1;
}
posicion=0;
while (entradas[posicion]!=0.0){
cadena2=cadena2+entradas[posicion]+",";
posicion=posicion+1;
}
pagina.setText(cadena1+"\n"+cadena2);
JOptionPane.showMessageDialog(null, pagina);
}
efectivo\n2.Entrada de efectivo\n3.Ver estado de cuenta, Cualquier otro número para
salir"));
}

Se tienen dos vectores: entradas y salidas, ambos de dimensiones que el usuario determina
durante la ejecución del programa, validando que su tamaño no sea menor a 1 ni mayor a 100
posiciones:
do{
tamanio=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos registros desea
administrar?(máximo 100)"));
entradas = new double[tamanio];
salidas=new double[tamanio];
En el presente ejercicio se utiliza un bucle while que simula el comportamiento de un menú, es

decir una serie de opciones a las cuales el usuario puede acceder una y otra vez, hasta que
decida salir de la ejecución del programa. La primera línea de este menú consiste en mostrar
las opciones al usuario:
efectivo\n2.Entrada de efectivo\n3.Ver estado de cuenta, Cualquier otro número para salir"));
El menú se mantiene en funcionamiento con dicho while que permitirá permanecer adentro
mientras se elijan opciones válidas:
efectivo\n2.Entrada de efectivo\n3.Ver estado de cuenta, Cualquier otro número para salir"));
}
16
La codificación de cada una de las opciones es la siguiente:
La primera opción es: 1.Salida de efectivo, es decir, registrar en el vector salida el egreso de
una cantidad de dinero válida:
if (opcion==1){
//salida de efectivo
do{
salida=Double.parseDouble(JOptionPane.showInputDialog("¿Cuánto fue la
salida de efectivo? (mayor a cero)"));
}while(salida<=0);
salidas[posicionSalida]=salida;
posicionSalida=posicionSalida+1;
}
La segunda opción es: 2.Entrada de efectivo, es decir, registrar en el vector entrada el

ingreso de una cantidad de dinero válida:
//entrada de efectivo
do{
entrada=Double.parseDouble(JOptionPane.showInputDialog("¿Cuánto fue la
entrada de efectivo? (mayor a cero)"));
}while(entrada<=0);
entradas[posicionEntrada]=entrada;
posicionEntrada=posicionEntrada+1;
}
La tercera opción es: 3.Estado de cuenta, genera una salida a través de un cuadro de dialogo
que contiene un objeto JTextArea llamado pagina, en el cual se listan cada uno de los
elementos del vector salidas separadas por comas (,) y luego de un salto de línea, se listan
cada uno de los elementos del vector entradas separadas por comas (,):
//estado de cuenta
posicion=0;
cadena1="Salidas\n";
cadena2="Entradas\n";
while (salidas[posicion]!=0.0){
cadena1=cadena1+salidas[posicion]+",";
posicion=posicion+1;}
posicion=0;
while (entradas[posicion]!=0.0){
cadena2=cadena2+entradas[posicion]+",";
posicion=posicion+1;}
pagina.setText(cadena1+"\n"+cadena2);
JOptionPane.showMessageDialog(null, pagina);
}
17
Segunda parte: Ejercicios resueltos con matrices (vector de dos
dimensiones)
Ejercicio #8:
Se gestionaran calificaciones para un grupo de estudiantes. El grupo de clase puede ser de un
solo alumno hasta un máximo de treinta, las calificaciones que se administran para cada
estudiante son como mínimo 3 y máximo 10.

double notas[][];
double nota;
int alumnos, periodos; //variables que se usaran para las dimensiones de la matriz
int alumno, periodo, texto;
String salida="";
do{
alumnos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos alumnos?
(mínimo 1 y máximo 30)"));
}while(alumnos<1 || alumnos>30);
do{
periodos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos períodos?
}while(periodos<3 || periodos>10);
notas= new double[alumnos][periodos];
for (alumno=0;alumno<alumnos;alumno++){
JOptionPane.showMessageDialog(null, "Ingresará las notas del alumno
#"+(alumno+1));
for (periodo=0;periodo<periodos;periodo++){
do{
nota=Double.parseDouble(JOptionPane.showInputDialog("Ingrese la nota del
período #"+(periodo+1)+" del alumno #"+(alumno+1)));
notas[alumno][periodo]=nota;
}
}
//formación de un encabezado dinámico

salida="Alumno#\tP1\tP2\tP3";
for (texto=4;texto<=periodos;texto++){
salida=salida+"\tP"+texto;
}
salida=salida+"\n";
18
//generar la secuencia de calificaciones para cada estudiante
salida=salida+(alumno+1)+"\t";
salida=salida+notas[alumno][periodo]+"\t";
}
salida=salida+"\n";
}

Se tiene una matriz de nombre notas, que administrará datos de tipo double.
Para lograr que la matriz sea de tamaño variable en cada ejecución del programa, se procede
a utilizar dos bucles que validan sus dimensiones:
do{
alumnos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos alumnos?
do{
periodos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos períodos?
}while(periodos<3 || periodos>10);
notas= new double[alumnos][periodos];
El proceso de ingreso de calificaciones para cada estudiante, requiere del uso de tres bucles
anidados: el primero, para recorrer cada una de las filas de la matriz, cada fila representa a un
estudiante; el segundo bucle, para ingresar cada una de las calificaciones del estudiante, es
decir, cada una de las columnas de la matriz; finalmente, el tercer bucle, valida que calificación
ingresada este en el rango de 0.0 a 10.0:
JOptionPane.showMessageDialog(null, "Ingresará las notas del alumno
#"+(alumno+1));
do{
período #"+(periodo+1)+" del alumno #"+(alumno+1)));
notas[alumno][periodo]=nota;
}
}
19
Mostrar el conjunto de notas requiere de un encabezado que se ajuste a la cantidad de
calificaciones que se desean mostrar, por ejemplo, mostrar tres calificaciones por estudiante
requiere de tres columnas; mostrar 5 calificaciones por estudiante requiere de cinco columnas;
en términos generales se necesita de un encabezado ajustable, pero se debe recordar que
como mínimo son 3 calificaciones por estudiante y como máximo son 10:
//formación de un encabezado dinámico
salida="Alumno#\tP1\tP2\tP3";
for (texto=4;texto<=periodos;texto++){
salida=salida+"\tP"+texto;
}
salida=salida+"\n";
Añadir el registro de calificaciones de cada estudiante al encabezado generado anteriormente,

se consigue a través de dos bucles anidados: el primero para recorrer las filas de la matriz; y
el segundo, para recorrer las columnas de la matriz:
//generar la secuencia de calificaciones para cada estudiante
salida=salida+(alumno+1)+"\t";
salida=salida+notas[alumno][periodo]+"\t";
}
salida=salida+"\n";
}
Al final, todo el texto acumulado en la variable salida es asignada al objeto hoja (objeto de tipo
JTextArea); el objeto hoja se muestra a través de un cuadro de dialogo.
20
Ejercicio #9:
Se gestionaran calificaciones para un grupo de estudiantes utilizando una matriz de tipo double
y de nombre notas. El grupo de clase puede ser de un solo alumno hasta un máximo de treinta;
las calificaciones que se administran para cada estudiante son como mínimo 3 y máximo 10.
Adicionalmente, se administraran los nombres de los estudiantes en un vector de tipo String.

double notas[][];
String nombres[];
int alumnos, evaluaciones; //variables que se usaran para las dimensiones de la matriz
int alumno, opcion, periodo, evaluacion;
String nombre, salida;
double nota, promedio;
JTextArea hoja=new JTextArea();
do{
alumnos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos alumnos
administra en su clase? (entre 1 y 25)"));
nombres=new String[alumnos];
do{
evaluaciones=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas evaluaciones
}while(evaluaciones<3 || evaluaciones>5);
notas=new double[alumnos][evaluaciones];
do{
nombre=JOptionPane.showInputDialog("Ingrese el nombre del alumno #"+alumno);
}while(nombre.length()==0);
nombres[alumno]=nombre;
}
//se administrará un menú

opcion=Integer.parseInt(JOptionPane.showInputDialog("Opciones:\n1.Ver listado de
estudiantes\n2.Ingresar notas por período\n3.Ver notas por período\n4.Mostrar
promedios\nCualquier otro número para salir"));
while (opcion>=1 && opcion<=4){
if (opcion==1){//crear lista de alumnos
salida="";
salida="Nombre del alumno\n";
salida=salida+nombres[alumno]+"\n";
}
}
else if (opcion==2){//ingresar notas de un período
21
do{
periodo=Integer.parseInt(JOptionPane.showInputDialog("¿De cuál período
ingresará notas? entre (1 y "+evaluaciones+")" ));
}while(periodo<1 || periodo>evaluaciones);
do{
alumno "+nombres[alumno]));
notas[alumno][periodo-1]=nota;
}
}
do{
desea ver notas? entre (1 y "+evaluaciones+")" ));
salida="";
salida="Alumno\tPeríodo#"+periodo+"\n";
salida=salida+nombres[alumno]+"\t"+notas[alumno][periodo-1]+"\n";
}
}
else if(opcion==4){//calcular promedios, las calificaciones tienen igual ponderación

salida="";
salida="Alumno\t\tPromedio\n";
promedio=0.0;
for (evaluacion=0;evaluacion<evaluaciones;evaluacion++){
promedio=promedio+notas[alumno][evaluacion];
}
promedio=promedio/evaluaciones;
salida=salida+nombres[alumno]+"\t\t"+promedio+"\n";
}
}
}
22
Se tiene una matriz de nombre notas, que administrará datos de tipo double.
Para lograr que la matriz y el vector sean de tamaño variable en cada ejecución del programa,
se procede a utilizar dos bucles que validan sus dimensiones:
do{
alumnos=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos alumnos
administra en su clase? (entre 1 y 25)"));
nombres=new String[alumnos];
do{
evaluaciones=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas evaluaciones
}while(evaluaciones<3 || evaluaciones>5);
notas=new double[alumnos][evaluaciones];
El ingreso de los nombres de los estudiantes en el vector nombres, es el siguiente:

do{
nombre=JOptionPane.showInputDialog("Ingrese el nombre del alumno #"+alumno);
}while(nombre.length()==0);
nombres[alumno]=nombre;
}
Para facilitar el uso del programa al usuario, se administrará un menú que permitirá
permanecer dentro de él se seleccionen opciones válidas y salir al ingresar un valor de opción
de menú que no exista:
//se administrará un menú de opciones para el usuario
while (opcion>=1 && opcion<=4){
//Aquí irá todo el código relativo a las opciones del 1 al 4 del menú
}
La primera opción del menú es: 1.Ver listado de estudiantes, se requiere de un bucle que
recorra una a una las posiciones del vector nombres y los añada a la variable de tipo String
llamada salida, luego ese grupo de texto se asigna a un objeto llamado hoja (objeto de tipo
JTextArea) y finalmente se muestra a través de un cuadro de dialogo:
23
if (opcion==1){//crear lista de nombre de alumnos
salida="";
salida="Nombre del alumno\n";
salida=salida+nombres[alumno]+"\n";
}
}
La segunda opción del menú es: 2.Ingresar notas por período, debido a lo complicado de
ingresar notas para todos los estudiantes de todos los períodos, es factible hacerlo de un
período en particular a la vez.
else if (opcion==2){//ingresar notas de un período en partícular
do{
ingresará notas? entre (1 y "+evaluaciones+")" ));
do{
alumno "+nombres[alumno]));
notas[alumno][periodo-1]=nota;
}
}
Al momento de guardar una calificación de un período en particular, es importante recordar
que aunque el usuario indique período 1, 2, 3….10; en el vector notas se estaría haciendo
referencia a un número de columna anterior al indicado, debido a que la matriz comienza su
conteo de columnas en cero.
La tercera opción es: 3.ver calificaciones por período, se procede a utilizar un bucle que
recolecte el nombre del estudiante desde el vector nombres y también recolecte las
calificaciones de una misma columna de la matriz notas, ambas informaciones se van
acumulando en una variable de nombre salida:
do{
desea ver notas? entre (1 y "+evaluaciones+")" ));
salida="";
salida="Alumno\tPeríodo#"+periodo+"\n";
salida=salida+nombres[alumno]+"\t"+notas[alumno][periodo-1]+"\n";
}
JOptionPane.showMessageDialog(null, hoja);}
24
Todo el texto acumulado en la variable salida se asigna al objeto hoja (objeto de tipo
JTextArea) y este se muestra a través de un cuadro de dialogo.
La cuarta opción es: 4.Mostrar promedios, para facilitar este cálculo, se asume que cada
calificación tiene igual ponderación. El cálculo del promedio requiere que se acumule cada una
de las calificaciones de cada estudiante y luego este valor acumulado se divida entre la
cantidad de evaluaciones. Cada nombre de estudiante y promedio calculado se acumula en
una variable de tipo String llamada salida:
else if(opcion==4){//calcular promedios, las calificaciones tienen igual ponderación
salida="";
salida="Alumno\t\tPromedio\n";
promedio=0.0;
for (evaluacion=0;evaluacion<evaluaciones;evaluacion++){
promedio=promedio+notas[alumno][evaluacion];
}
promedio=promedio/evaluaciones;
salida=salida+nombres[alumno]+"\t\t"+promedio+"\n";
}
}
Todo el texto acumulado en la variable salida se asigna al objeto hoja (objeto de tipo
JTextArea) y este se muestra a través de un cuadro de dialogo.
25
Ejercicio #10:
Se tiene un matriz que almacena números de tipo entero, las dimensiones mínimas de la matriz
son de 1 fila y 1 columna, y sus máximas 100 filas y 100 columnas. Después de ingresar datos,
se desea buscar si existe un número en particular y la frecuencia con que éste aparece.

int matriz[][];
int filas, columnas, fila, columna, busqueda, frecuencia=0;
boolean encontrado=false;
do {
filas = Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas filas? (entre 1 y
100)"));
} while (filas < 1 || filas > 100);
do {
columnas = Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas columnas?
(entre 1 y 100)"));
} while (columnas < 1 || columnas > 100);
matriz = new int[filas][columnas];
//Ingreso de datos que no requieren validación

for (fila=0;fila<filas;fila++){
for (columna=0;columna<columnas;columna++){
matriz[fila][columna]=Integer.parseInt(JOptionPane.showInputDialog("matriz["+fila+"]["
+columna+"]"));
}
}
//busque un dato
busqueda = Integer.parseInt(JOptionPane.showInputDialog("¿Cual número busca?"));
if (busqueda==matriz[fila][columna]){
encontrado=true;
frecuencia=frecuencia+1;
}
}
}
if (encontrado==true){
JOptionPane.showMessageDialog(null, "El número "+busqueda+" se encontró
"+frecuencia+" veces");
}
else{
JOptionPane.showMessageDialog(null, "El número "+busqueda+" no se encontró");
}
26
importarse (Meza González, 2012-2017) y usarla como parte del código.
do {
filas = Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas filas? (entre 1 y
100)"));
} while (filas < 1 || filas > 100);
do {
columnas = Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas columnas?
(entre 1 y 100)"));
} while (columnas < 1 || columnas > 100);
matriz = new int[filas][columnas];
En este caso, no se requerirá validar las entradas, se puede ingresar cualquier número entero
y guardar en la matriz:
//Ingreso de datos que no requieren validación
matriz[fila][columna]=Integer.parseInt(JOptionPane.showInputDialog("matriz["+fila+"]["
+columna+"]"));
}
}
Para realizar la búsqueda de un número en particular, se usará la variable busqueda de tipo

entero y como apoyo se usará una variable booleana encontrado, esta última inicializada con
el valor false y que cambiará de estado a true, en caso de hallar coincidencias entre lo que se
busca y el contenido de la matriz; la variable frecuencia, es un contador de las ocurrencias de
estas coincidencias:
//busque un dato
busqueda = Integer.parseInt(JOptionPane.showInputDialog("¿Cual número busca?"));
if (busqueda==matriz[fila][columna]){
encontrado=true;
frecuencia=frecuencia+1;
}
}
}
Finalmente, puede darse que el número buscado se encontró o no:

if (encontrado==true){
JOptionPane.showMessageDialog(null, "El número "+busqueda+" se encontró
"+frecuencia+" veces");}
else{
JOptionPane.showMessageDialog(null, "El número "+busqueda+" no se encontró");}
27
Ejercicio #11:
Se simulara una sala de cine, en la cual las butacas estarán nombradas con un código que
combine letra y número; también se hará venta de boletos, uno a la vez.

String sala[][];
char letra;
String salida="", cualAsiento;
char letras[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
int fila, filas, columna, columnas, opcion, encontrado=0;
do{
filas=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas filas? (mínimo 10 y
máximo 26)"));
}while(filas<10|| filas>26);//al menos diez filas y como máximo 26
do{
columnas=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas columnas?
}while(columnas<10|| columnas>26);//al menos diez columnas y como máximo 26
sala=new String[filas][columnas];
//asignación de código a butacas y mostrar la sala

sala[fila][columna]=letras[fila]+String.valueOf(columna+1);
salida=salida+sala[fila][columna]+"\t";
}
salida=salida+"\n";
}
//menú de dos opciones: ver la sala y vender un boleto a la vez

do{
opcion=Integer.parseInt(JOptionPane.showInputDialog("Opciones:\n1.Ver
sala\n2.Vender boleto"));
if (opcion==1){
salida="";
}
salida=salida+"\n";
}
}
else if(opcion==2){
28
hoja.setText(salida+"\n"+"¿Cuál asiento desea?");
cualAsiento=JOptionPane.showInputDialog(hoja);
letra=cualAsiento.charAt(0); //extraer la primer letra de la búsqueda
for(columna=0;columna<letras.length;columna++){//hacer la búsqueda
if (letra==letras[columna]){
encontrado=columna;
}
}
if (encontrado>filas){
JOptionPane.showMessageDialog(null, "No existe esa fila en la sala");
}
else{
for(columna=0;columna<columnas;columna++){//hacer la búsqueda
if (cualAsiento.equals(sala[encontrado][columna])){
sala[encontrado][columna]="X";
JOptionPane.showMessageDialog(null, "Asiento vendido");
}
}
}
}
}while (opcion>=1 && opcion<=2);

Se tiene una matriz de nombre sala, que administrará datos String, se tiene además un vector
llamado letras de tipo char y tamaño ya definido: 26 posiciones; en él se guardan las letras del
abecedario, obviando la letra ñ:
char letras[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
do{
filas=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas filas? (mínimo 10 y
máximo 26)"));
}while(filas<10|| filas>26);//al menos diez filas y como máximo 26
do{
columnas=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantas columnas?
}while(columnas<10|| columnas>26);//al menos diez columnas y como máximo 26
sala=new String[filas][columnas];
La asignación de un código a cada butaca, consiste en considerar que la primera fila es la letra
‘a’ y que el primer asiento es el número 1, de ahí que su código sea: a1, el siguiente asiento a
la derecha (columna en la matriz) es el asiento a2 y así sucesivamente. Al avanzar a la fila de
29
abajo –la segunda fila- esa será la letra ‘b’ y su primer asiento es el número 1, de ahí que su
código sea: b1; el proceso se repetirá para el resto de filas y columnas:
//asignación de código a butacas y mostrar la sala
sala[fila][columna]=letras[fila]+String.valueOf(columna+1);
}
salida=salida+"\n";
}
Se utiliza una variable String de nombre salida para ir acumulando todo el texto de lo que será
la apariencia de la sala de cine; luego ese cumulo de texto se le asigna al objeto hoja (objeto
de tipo JTextArea). Finalmente se muestra la apariencia de la sala de cine a través de un
cuadro de dialogo.
En este caso, se usará un menú de solo dos opciones: 1. Ver la sala y 2. Vender boleto. Para
simular el comportamiento de un menú en el cual se permanece mientras se eligen opciones
válidas (1 o 2) y del cual se sale al ingresar una opción no válida (cualquier número diferente
de 1 o 2), se usará un bucle do-while:
//menú de dos opciones: ver la sala y vender un boleto a la vez

do{
opcion=Integer.parseInt(JOptionPane.showInputDialog("Opciones:\n1.Ver
sala\n2.Vender boleto"));
//Aquí se programa todo el código de las opciones 1 y 2 del menú
}while (opcion>=1 && opcion<=2);
La primera opción del menú es: 1.Ver sala, se recorre la matriz y se acumulan los códigos de
las butacas en una variable String de nombre salida, luego ese cumulo de texto se asigna al
objeto hoja y finalmente se muestra a través de un cuadro dialogo:
if (opcion==1){
salida="";
}
salida=salida+"\n";
}
}
30
La segunda opción es: 2.Vender boleto, antes de mostrar la sala de cine en su estado actual,
es neceaario volver a generar la apariencia de la sala, el código utilizado es similar al de la
opción #1 (1.ver sala); el proceso de vender boleto continua, cuando se le pregunta al usuario
por el código del asiento que desea; posteriormente el programa averiguará si el código es
válido, es decir si la fila existe, en caso de no existir notificar al usuario, en caso de que la fila
si existe, entonces buscar el número de asiento en la fila indicada y cambiar su código a “X”.
salida="";
}
salida=salida+"\n";
}
hoja.setText(salida+"\n"+"¿Cuál asiento desea?");
cualAsiento=JOptionPane.showInputDialog(hoja);
letra=cualAsiento.charAt(0); //extraer la primer letra de la búsqueda
for(columna=0;columna<letras.length;columna++){//hacer la búsqueda
if (letra==letras[columna]){
encontrado=columna;
}
}
if (encontrado>filas){
JOptionPane.showMessageDialog(null, "No existe esa fila en la sala");
}
else{
for(columna=0;columna<columnas;columna++){//hacer la búsqueda
if (cualAsiento.equals(sala[encontrado][columna])){
sala[encontrado][columna]="X";
JOptionPane.showMessageDialog(null, "Asiento vendido");
}
}
}
}
Mejora sugerida a la solución: cuando se trata de vender una butaca que ya ha sido vendida
(ya marcada con una “X”), el programa actual, simplemente regresa al menú; sería deseable
que se le muestre un mensaje al usuario indicándole que la butaca ya ha sido vendida.
31
Referencias
Berzal Galiano, F. (s.f.). http://elvex.ugr.es/. Obtenido de http://elvex.ugr.es/decsai/java/pdf/6A-Arrays.pdf
Blanco, Á. F. (s.f.). UNIDAD DIDACTICA Nº 4 . BUCLES. Obtenido de Innovación Educativa:

https://innovacioneducativa.files.wordpress.com
Hernández Yáñez, L. (2013-2014). Fundamentos de la programación. Obtenido de Facultad de Informática,

Universidad Complutense: https://www.fdi.ucm.es/profesor/luis/fp/FP.pdf
Meza González, J. D. (2012-2017). Obtenido de Uso de librerías en Java:

https://www.programarya.com/Cursos/Java/Librerias
32

Ebook en PDF Guia de Ejercicios Resueltos Usando Arreglos en Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ebook en PDF Guia de Ejercicios Resueltos Usando Arreglos en Java

Uploaded by

Copyright:

Available Formats

GUÍA DE

La presente guía de ejercicios resueltos, es una compilación de código Java de mi

Solución al ejercicio #1:

//dimensionamiento del vector, tamaño entre 1 y 50 posiciones

//ingreso de notas o calificaciones

//mostrar datos originales

Observaciones importantes a la solución del ejercicio #1:

Solución al ejercicio #2:

//ingreso de valores al vector, sin validarlos

//mostrar los valores del vector tal como fueron ingresados

//mostrar los valores del vector ya ordenados ascendentemente

Solución al ejercicio #3:

//ingreso de valores al vector, sin validarlos

//mostrar los valores del vector tal como fueron ingresados

//ordenamiento asecendente a través del método de la burbuja

//proceso de ordenamiento usando dos bucles anidados

Solución al ejercicio #4:

//proceso de entrada de datos al ArrayList, finaliza cuando se ingresa un dato vacío

//mostrar el contenido del arreglo

Observaciones importantes a la solución del ejercicio #4:

Solución al ejercicio #5:

//Ingreso de nombres al arreglo

//mostrar los nombres de la lista

//solicitar el nombre a remover de la lista

/*buscar en la lista el nombre, si existe se proceder a removerlo,

//mostrar los nombres de la lista excepto si se removió alguno

Observaciones importantes a la solución del ejercicio #5:

Solución al ejercicio #5:

//a cada casillero se le asigna un d(esocupado)

Observaciones importantes a la solución del ejercicio #6:

//aquí irá el código de las opciones del menú

La codificación de cada una de las opciones es la siguiente:

Solución al ejercicio #7:

Observaciones importantes a la solución del ejercicio #7:

En el presente ejercicio se utiliza un bucle while que simula el comportamiento de un menú, es

La segunda opción es: 2.Entrada de efectivo, es decir, registrar en el vector entrada el

Solución al ejercicio #8:

notas= new double[alumnos][periodos];

//formación de un encabezado dinámico

Observaciones importantes a la solución del ejercicio #8:

Añadir el registro de calificaciones de cada estudiante al encabezado generado anteriormente,

Solución al ejercicio #9:

//se administrará un menú

else if(opcion==4){//calcular promedios, las calificaciones tienen igual ponderación

El ingreso de los nombres de los estudiantes en el vector nombres, es el siguiente:

Solución al ejercicio #10:

//Ingreso de datos que no requieren validación

Para realizar la búsqueda de un número en particular, se usará la variable busqueda de tipo

Finalmente, puede darse que el número buscado se encontró o no:

Solución al ejercicio #11:

//asignación de código a butacas y mostrar la sala

//menú de dos opciones: ver la sala y vender un boleto a la vez

Observaciones importantes a la solución del ejercicio #11:

//menú de dos opciones: ver la sala y vender un boleto a la vez

//Aquí se programa todo el código de las opciones 1 y 2 del menú

}while (opcion>=1 && opcion<=2);

Berzal Galiano, F. (s.f.). http://elvex.ugr.es/. Obtenido de http://elvex.ugr.es/decsai/java/pdf/6A-Arrays.pdf

Blanco, Á. F. (s.f.). UNIDAD DIDACTICA Nº 4 . BUCLES. Obtenido de Innovación Educativa:

Hernández Yáñez, L. (2013-2014). Fundamentos de la programación. Obtenido de Facultad de Informática,

Meza González, J. D. (2012-2017). Obtenido de Uso de librerías en Java:

You might also like