Pontificia Universidad Católica de Chile

Escuela de Ingenierı́a
Departamento de Ciencia de la Computación

IIC1103 — Introducción a la Programación

Ayudantı́a: Arreglos y Matrices

Profesores: Daniel Langdon y Carla Vairetti

Resumen teórico
Arreglos
Hasta ahora poco a poco hemos podido almacenar y trabajar con información en java de manera cada vez
más eficiente.
Sin embargo cuando tenemos que trabajar con muchos objetos del mismo tipo, el código se vuelve un poco
ineficiente. Por eso es que existen estructuras llamadas arreglos, que hacen las veces de vectores, donde se
puede almacenar información del mismo tipo.
Es como una caja seccionada, donde podemos guardar un dato en cada casilla. Supongamos que cada casilla
guarda la palabra que representa a un número.

Algo importante es que al definir un arreglo, éste asigna posiciones a cada uno de los datos almacenados
comenzando desde CERO, entonces si el arreglo llega hasta la posición “n”, tendrá “n+1” elementos.
Por ejemplo: Arreglo de Strings
Podemos definirlo asignando el número de posiciones que tendrá al instante.

//declaracion del arreglo

String[] nombres=new String[3];
nombres[0]="Juan";
nombres[1]="Pablo";
nombres[2]="Ana";

Podemos definirlo también de un largo determinado en un ciclo o directamente con sus elementos.

//declaracion del arreglo directamente

char[] iniciales={’a’,’b’,’c’};

Es común asignar valores a los arreglos recorriendo cada una de sus casillas.

//declaracion en un ciclo con los múltiplos de 17

int[] multiplos=new int[10];
for (int i=0; i<10; i++)
{
multiplos[i]=(i+1)*17;
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 1

Para utilizar la información que guarda el arreglo en una determinada posición, lo llamamos de la siguiente
manera:

<identificador>[i]

Por ejemplo en el caso de los múltiplos, si yo quisiera averiguar el 5 deg múltiplo de 17, tengo que escribir:

int quinto=multiplos[4];

Entonces quinto = 5x17 (ojo con las posiciones que están definidas para el arreglo, comienzan desde cero).
Podemos tener arreglos de cualquier cosa, de String, int, char, objetos, arreglos, etc.
Importante: Para definir un arreglo se debe utilizar el sı́mbolo ’[ ]’. De la siguiente manera inicializamos el
arreglo:

<tipo>[ ] <identificador> = new <tipo>[n] ;

Aunque cada una de las posiciones por defecto está vacı́a o nula (null).
Al igual que los otros objetos podemos crearlo y no inicializarlo hasta que sea necesario, lo importante es que
ANTES de asignarle valores a cada espacio, debemos indicarle al arreglo su largo (a menos que lo creemos
directamente, lo que no es muy usual).
Existen algunos comandos que se utilizan con los arreglos, por ejemplo, para saber el largo del arreglo, te-
nemos:

<identificador>.length;

Que nos devolverá el ndeg de valores que almacena el arreglo, es decir, al número que ingresamos al decla-
rarlo. Por ejemplo, si nuestro arreglo tiene casillas 0, 1 y 2, lenght nos retornará 3.
Un arreglo NO se puede asignar a otro arreglo, por ejemplo, si se tiene que:

int[] Pares={2, 4, 6, 8, 10};

int[] num=new int[5];

No puedo hacer la asignación siguiente:

num=Pares;

Esta asignación no copiará los valores, si no que, al igual que en los objetos, cambiará la referencia “num”,
de manera que apunte a la misma dirección de memoria que “Pares”. Para todos los efectos, ambas variables
“Pares” y “num” estarán apuntando al mismo arreglo. Para copiar los valores la forma correcta es:

for (int i=0; i<num.length; i++)

{
num[i]=Pares[i];
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 2

Matrices
Las matrices no son más que arreglos de arreglos, simplemente como un dato guardado en un espacio que
ahora no se define por una posición, sino por un par de coordenadas.

Las matrices pueden ser regulares o irregulares, es decir, puede que en cada fila, el número de elementos sea
distinto, o pueden no ser cuadradas, etc.
La forma de definirlas es:

<tipo>[ ][ ] <identificador> = new <tipo>[ ][ ];

IIC1103 – Ayudantı́a: Arreglos y Matrices 3

Ejemplos
Problema 1: Patrones
Enunciado
Se le ha pedido ayuda para escribir un programa que detecte patrones anómalos en el funcionamiento de
maquinaria industrial en una fábrica.
Cada dı́a una máquina registra minuto a minuto su temperatura de funcionamiento, la cual es almacenada
en un arreglo como el que se muestra a continuación:

Se han establecido dos condiciones que revelan un posible funcionamiento anómalo en una máquina:

Oscilación: la cual se reconoce cuando aumenta (o disminuye) la temperatura en dos intervalos consecu-
tivos (t1 > t0 y t2 > t1) y luego disminuye (o aumenta) la temperatura en dos intervalos consecutivos
(t3 < t2 y t4 < t3). En el arreglo anterior, se pueden apreciar los dos tipos de oscilaciones: una
ascendente (a partir del instante 4) y otra descendente (a partir del instante 11).
Ciclicidad diaria: la cual se produce cuando en dos dı́as seguidos se repite una secuencia de tres tempe-
raturas en el mismo instante del dı́a. Si el siguiente arreglo corresponde al dı́a siguiente al del arreglo
anterior:

Entonces hay ciclicidad diaria a partir del instante 2, del instante 9 y del instante 16.

Escriba en lenguaje Java los siguientes métodos para ayudar a detectar comportamientos anómalos:
a) DetectarOscilaciones

// Muestra en consola mensajes indicando oscilaciones

// Recibe un arreglo que contiene las temperaturas registradas en un dı́a
// cualquiera
public static void DetectaOscilaciones(int[] regDia1) { ... }

En el caso anterior, deberı́a desplegar los siguientes mensajes:

Oscilación ascendente a partir del instante 4

Oscilación descendente a partir del instante 11

b) DetectarCiclicidad

// Muestra en consola mensajes indicando ciclicidades

// Recibe dos arreglos que contienen las temperaturas de dos dı́as
// consecutivos
public static void DetectaCiclicidad(int[] regDia1, int[] regDia2) { ... }

En el caso anterior, deberı́a desplegar los siguientes mensajes:

Ciclicidad diaria a partir del instante 2

Ciclicidad diaria a partir del instante 9
Ciclicidad diaria a partir del instante 16

IIC1103 – Ayudantı́a: Arreglos y Matrices 4

Criterios de solución
NOTA: el ı́ndice de la última posición de un arreglo es, ocupando como ejemplo regDia1, regDia1.length-1,
ya que los ı́ndices parten desde cero.
a) En este problema lo importante es darse cuenta de que solo hay que comparar enteros y la verdadera
dificultad se encuentra en sacar estos enteros de los arreglos. Por esto, para comparar el dı́a t con el dı́a t+1,
sacamos el entero t+1 del arreglo (regDia1[t+1]) y lo comparamos con el entero t del arreglo (regDia1[t]).
Esto luego se hace para t+2, t+3 y t+4 buscando la condición indicada por el enunciado. Es importante
notar que el for llega hasta la ante ante ante penúltima posición del arreglo (regDia1.length-4) ya que, o si
no, al pedir el entero regDia1[t+4] este estarı́a fuera del arreglo.
b) Esto es muy similar al ejercicio anterior, la diferencia está en que, en vez de comparar enteros dentro de
un mismo arreglo, se comparan entre dos arreglos distintos.

Posible solución
//Parte a)
//Muestra en consola mensajes indicando oscilaciones
//Recibe un arreglo que almacena la temperatura en un dı́a cualquiera
public static void DetectaOscilaciones(int[] regDia1){
int t;
for(t=0;t<regDia1.length-4;t++)//llegamos solo hasta la antepenultima posicion
{ if (regDia1[t+1] > regDia1[t] && //si se cumple la condicion para ascendente
regDia1[t+2] > regDia1[t+1] &&
regDia1[t+3] < regDia1[t+2] &&
regDia1[t+4] < regDia1[t+3]){
Usuario.mensajeConsola("Oscilación ascendente a partir del instante "+t);
} else if (regDia1[t+1] < regDia1[t] && //si se cumple la condicion para descendente
regDia1[t+2] < regDia1[t+1] &&
regDia1[t+3] > regDia1[t+2] &&
regDia1[t+4] > regDia1[t+3]){
Usuario.mensajeConsola("Oscilación descendente a partir del instante "+t);
}
}
}
//Parte b)
// Muestra en consola mensajes indicando ciclicidades
// Recibe dos arreglos que almacenan la temperatura en dos dı́as //consecutivos
public static void DetectaCiclicidad(int[] regDia1, int[] regDia2) {
int t;
for(t=0;t<regDia1.length-2;t++) {
if (regDia1[t] == regDia2[t] &&
regDia1[t+1] == regDia2[t+1] &&
regDia1[t+2] == regDia2[t+2]) {
Usuario.mensajeConsola("Ciclicidad diaria a partir del instante "+t);
}
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 5

Problema 2: El juego de la vida
Enunciado
El juego de la vida es un juego de cero jugadores inventado por el matemático John Conway en 1970. Este
se juega en una grilla de células cuadradas (como un tablero de ajedrez) donde cada posición del tablero
tiene dos opciones, o tiene una célula o no. El objetivo de este juego (visto de una manera muy superficial)
es simular la vida, por esta misma razón hay reglas para determinar la supervivencia y muerte de las células.
Estas reglas son:

Una célula rodeada de menos de 2 células muere de soledad.

Una célula rodeada de 2 o 3 células sobrevive.

Una célula rodeada de más de 3 celular muere por sobrepoblación.

En un espacio sin células solamente aparece (nace) una si es que está rodeada por exactamente 3
células.

Usted debe crear un programa que simule este juego. Debe mostrar el tablero en consola donde se deben
representar los espacios con células con unos y los vacı́os con ceros. Las posiciones de cada célula deben
ser generadas aleatoriamente al empezar cada juego y en cada iteración de este se debe mostrar el tablero.
Puede escoger cualquier tamaño de tablero mientras sea mayor que 3x3. Para terminar, en cada iteración
debe preguntar al usuario si desea continuar.
Ejemplo de tablero 8x8:

IIC1103 – Ayudantı́a: Arreglos y Matrices 6

 Primera Iteración Segunda Iteración
----------------- -----------------
|0|0|0|0|0|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|0|0|0|0|1|0|1| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|0|0|0|0|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|0|0|0|0|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|0|0|0|0|0|1|1| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|1|0|0|1|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|1|0|0|0|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------
|0|0|0|0|0|0|0|0| |0|0|0|0|0|0|0|0|
----------------- -----------------

Criterios de solución
Es claro que la grilla del juego puede ser representado por una matriz. Entonces lo primero que debemos
hacer es crear una matriz e inicializarla, esto lo hacemos con un doble for el cual tiene una probabilidad de
30 % de generar un célula en dicho espacio.
Luego, para revisar las condiciones, debemos contar la cantidad de unos que hay alrededor de cada una de
las células, una vez hecho esto podemos decidir si la célula muere o vive. El problema que queda es que esta
información no puede ser inmediatamente aplicada a nuestra matriz ya que debemos ocuparla, tal como esta,
para calcular la condición de las otras células, es por esto que el siguiente estado de la matriz lo guardamos
en una matriz auxiliar. Luego esta matriz es guardada en la matriz original y se repite el proceso.

Posible solución
import iic1103Package.*;
public class Principal {
public static void main(String[] args) {
int numeroI=8; //numero de columnas
int numeroJ=8; //numero de filas
int probabilidad=3; //probabilidad de obtener un 1 en una posicion
int[][] matriz= new int[numeroI][numeroJ];//aqui guaradamos las
//posiciones de las celulas
int[][] auxiliar=new int[numeroI][numeroJ];//aqui guardamos las
//posiciones nuevas
for(int i=0;i<numeroI;i++)//creamos el tablero{
System.out.println("-----------------");
for(int j=0;j<numeroJ;j++){
if(Aleatorio.entero(1, 10)>probabilidad)//si es mayor que la
matriz[i][j]=0; //probabilidad no creamos una celula
else
matriz[i][j]=1;
System.out.print("|"+matriz[i][j]);
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 7

 System.out.println("|");
}
System.out.println("-----------------");
System.out.println(" \n\n\n");

while(true)//itera hasta que hacemos un break{

for(int i=0;i<numeroI;i++)//vamos iterando por la matriz{
for(int j=0;j<numeroJ;j++){
int contador=0;//cuenta la cantidad de celulas que rodean a
//una posicion
if(i!=0&&j!=0)//revisamos que no estamos en la esquinas superior
{ //izquierda, ya que o si no no podriamos ver si es
//que tenemos una celula a en nuesta diagonal
//arriba hacia la izquierda
if(matriz[i-1][j-1]==1)//si es que hay una celula arriba a
contador++; //mi izquierda sumo 1 al contador
}
if(i!=0)//reviso que no este en el borde superior del tablero
{ //ya que si estoy ahi no puedo mirar hacia la posicion
//que esta arriba mio
if(matriz[i-1][j]==1)//si es que hay una celula arriba mio
contador++; //sumo 1 al contador
}
if(i!=0&&j!=(numeroJ-1))//igual, pero esquina superior derecha{
if(matriz[i-1][j+1]==1)
contador++;
}
if(j!=numeroJ-1){
//igual, pero borde derecho
if(matriz[i][j+1]==1)
contador++;
}
if(i!=(numeroI-1)&&j!=(numeroJ-1)){
//igual pero esquina inferior derecha
if(matriz[i+1][j+1]==1)
contador++;
}
if(i!=(numeroI-1))
{ //igual pero borde inferior
if(matriz[i+1][j]==1)
contador++;
}
if(i!=(numeroI-1)&&j!=0){
//igual pero esquina inferior izquierda
if(matriz[i+1][j-1]==1)
contador++;
}
if(j!=0){
//igual pero borde izquierdo
if(matriz[i][j-1]==1)
contador++;

IIC1103 – Ayudantı́a: Arreglos y Matrices 8

 }
if(matriz[i][j]==0&&contador==3)
{ //si es que en la posicion no habia una y el contador es tres
auxiliar[i][j]=1;//creamos una celula en la posicion
}
else if(matriz[i][j]==1&&(contador==2||contador==3)) {
//si es que habia una y hay 2 0 3 celulas
auxiliar[i][j]=1;//creamos la celular
}
else{
//en cualquier otro caso eliminamos la celula
auxiliar[i][j]=0;
}
}
}
for(int i=0;i<numeroI;i++)//imprimimos la matriz e igualamos auxiliar a matriz{
System.out.println("-----------------");
for(int j=0;j<numeroJ;j++){
matriz[i][j]=auxiliar[i][j];
auxiliar[i][j]=0;
System.out.print("|"+matriz[i][j]);
}
System.out.println("|");
}
System.out.println("-----------------");
System.out.println(" \n\n\n");
int continuar=Interfaz.PedirEntero("Desea Continuar?");
if(continuar==0)
break;
}
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 9

Problema 3: Ordenando Strings
Enunciado
Usted recibe una matriz con el siguiente contenido: ’c’ ’b’ ’a’ ’a’ ’z’ ’i’ ’z’ ’b’ ’a’ Donde cada carácter es
un char. Debe crear un programa que ordene alfabéticamente esta matriz, primero las filas y después, sin
cambiar las filas, las columnas, de tal manera que quede ası́: ’a’ ’b’ ’c’ ’a’ ’b’ ’z’ ’a’ ’i’ ’z’ Aunque este problema
se puede resolver de manera “sucia”, resuélvalo pensando que este programa debe ser aplicable a cualquier
matriz de 3x3.

Criterios de solución
Lo importante aquı́ es darse cuenta de que cada fila de una matriz se puede tratar como un arreglo unidi-
mensional. Para hacer esto ocupamos matriz[i][j] dejando el i estático. Con esto vamos a ir obteniendo los
valores de nuestras filas. Luego para ordenarlas, se revisa uno por uno los caracteres y se le compara con
todos los otros caracteres de la misma fila. En caso de que sea mayor, se pone a la derecha del carácter
revisado. Luego es cosa de hacer lo mismo pero ahora para las columnas.

Posible solución
import iic1103Package.*;
public class Ordenar {
public static boolean sonIguales(char[] palabra1,char[] palabra2,int tamano){
for(int i=0;i<tamano;i++){
if(palabra1[i]!=palabra2[i])//vemos letra por letra
return false; //revisando que sean iguales
}
return true;
}

public static void main(String[] args) {

int tamanoMatriz=3;
char[][] matriz=new char[tamanoMatriz][];
char[] fila1={’c’,’b’,’a’};
char[] fila2={’a’,’z’,’i’};
char[] fila3={’z’,’b’,’a’};
matriz[0]=fila1;//inicializamos la matriz con las filas
matriz[1]=fila2;
matriz[2]=fila3;
for(int i=0;i<tamanoMatriz;i++)//en este for comparamos cada letra de
{ //cada fila
for(int j=0;j<tamanoMatriz;j++){
for(int k=0;k<tamanoMatriz;k++){
char auxiliar;
if(matriz[i][j]<matriz[i][k])//si es que la letra es menor
{ //se va para la derecha
auxiliar=matriz[i][j];
matriz[i][j]=matriz[i][k];
matriz[i][k]=auxiliar;
}
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 10

 }
for(int j=0;j<tamanoMatriz;j++)//en este for comparamos cada fila con
{ //cada fila
for(int k=0;k<tamanoMatriz;k++){
int i=0;
if(!sonIguales(matriz[j],matriz[k],tamanoMatriz))//si son iguales
{ //no hacemos nada
while(matriz[j][i]==matriz[k][i])//esperamos a encontrar una letra
{ //distinta (por ejemplo cuando
//comparamos "abc" con "abz")
i++;
}
char[] auxiliar;
if(matriz[j][i]<matriz[k][i])//si la letra es menor cambiamos
{ //la palabra
auxiliar=matriz[j];
matriz[j]=matriz[k];
matriz[k]=auxiliar;
}
}
}
}
for(int i=0;i<tamanoMatriz;i++)//imprimimos {
for(int j=0;j<tamanoMatriz;j++){
System.out.print(matriz[i][j]);
}
System.out.println("");
}
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 11

Problema 4: Validando un Sudoku (Pregunta 3 I2 - 2007-1)
Enunciado
El objetivo del Sudoku es rellenar una cuadrı́cula de 9x9 celdas (81 casillas), dividida en 9 subcuadrı́culas de
3x3 casillas (estas subcuadrı́culas son conocidas como cajas o regiones) con las cifras del 1 al 9 manteniendo
las siguientes restricciones:

Dentro de una región no puede repetirse ninguna cifra (cada región tiene 9 celdas por lo que en cada
región deben estar las 9 cifras posibles).
Cada fila dentro de la cuadrı́cula debe tener las 9 cifras posibles (como son 9 celdas por fila, solamente
debe haber una aparición de cada cifra en esa fila).
Cada columna dentro de la cuadrı́cula debe tener las 9 cifras posibles (como son 9 celdas por columna,
solamente debe haber una aparición de cada cifra en esa columna).
En la siguiente figura se muestra el tablero final del Sudoku, siendo los valores alrededor del tablero,
ı́ndices que permiten identificar las filas y las columnas.

Usted debe escribir el método Validar que dado un tablero final de Sudoku chequea si este cumple con las
reglas arriba enunciadas.

boolean Validar(int[][] sudoku){...}

Recuerde chequear que la matriz sea válida, puede suponer que la matriz es regular y que ha sido inicializada,
pero debe chequear que tiene la cantidad correcta de filas y columnas.
Si lo considera conveniente, puede crear otros métodos y clases que le permitan resolver el problema y que
sean llamados desde el método Validar.

Criterios de solución
Debemos ir revisando las condiciones de manera secuencial. Primero debemos comprobar que el tamaño del
arreglo sea correcto. Luego pasaremos por todos los casilleros, revisando que el número esté entre los valores
permitidos (1 y 9), y no se encuentre repetido en la fila o columna. Por último revisaremos las submatrices
de 3x3, comprobando que no se repitan números. Si en cualquier caso una comprobación falla, retornaremos
false, si pasa todas las validaciones, retornaremos true.

IIC1103 – Ayudantı́a: Arreglos y Matrices 12

Posible solución
public static boolean Validar(int[][] tabla)
{ // Comprobamos que el tamano sea el correspondiente
if(tabla.length != 9 || tabla[0].length != 9)
return false;
for(int k=1;k<10;k++) // Elejimos un número del 1 al 9
{ // Viajamos por una de las dimensiones del array
for(int i=0;i<tabla.length;i++)
{ // Suponemos que el numero buscado no esta ni en las filas ni en las columnas
// para cada columna y fila respectivamente e inicialmente
boolean estafilas=false;
boolean estacolumnas=false;
for(int j=0;j<tabla[i].length;j++)
{ // Comprobamos que el numero de la tabla este entre 1 y 9
if(tabla[i][j]<1 || tabla[i][j]>9)
return false;
// Verificamos igualdad del numero en la tabla corresponde al buscado en las filas
if(tabla[i][j]==k)
{ // Si estaba anteriormente retorna false, sino graba que esta
if(estafilas)
return false;
estafilas=true;
}
// Verificamos igualdad del numero en la tabla corresponde al buscado en las columnas
if(tabla[j][i]==k)
{ // Si estaba anteriormente retorna false, sino graba que esta
if(estacolumnas)
return false;
estacolumnas=true;
}
}
}
// Dividimos la tabla en submatrices de 3x3
// Recorresmos las submatrices con los ı́ndices n y m
for(int n=0;n<3;n++) {
for(int m=0;m<3;m++)
{ // Suponemos que el numero buscado no esta en el cuadrado
boolean estacuadrado=false;
// Recorremos la submetriz con los indices i y j, dependientes de n y m
for(int i=3*n;i<3*n+3;i++){
for(int j=3*m;j<3*m+3;j++){
// Verificamos igualdad del numero en la tabla corresponde al buscado la submatriz
if(tabla[j][i]==k){
// Si estaba anteriormente retorna false, sino graba que esta
if(estacuadrado)
return false;
estacuadrado=true;
}
}
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 13

 }
}
return true;
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 14

Problema 5: Suavizar Imagen
Enunciado
Se le pide que diseñe un algoritmo de suavizado para trabajar con una clase Imagen ya existente. Ésta posee
un atributo Pixel[][] bitmap que contiene todos los pixeles que conforman la imagen. Además la clase
Pixel representa los pixeles según su color RGB. Ésta tiene los siguientes métodos:

Pixel(int r, int g, int b) // constructor con los valores RGB ingresados

Pixel(int[] rgb) // constructor con los valores R = rgb [0], G = rgb[1], B = rgb[2]
int getAzul() // retorna el valor entero asociado al color azul
int getRojo() // retorna el valor entero asociado al color rojo
int getVerde() // retorna el valor entero asociado al color verde

El suavizado se realiza asignando a cada pixel el color promedio entre él y los 8 pixeles adyacentes.

Criterios de solución
Primero observamos que debemos ver todos los pixeles que componen el bitmap, y para cada uno, revisar
todos los pixeles adyacentes, y obtener el promedio de sus colores. Además notamos que los pixeles de los
bordes tendrán menos pixeles adyacentes.
La forma de obtener el promedio de los colores es sumar determinada componente de todos los pixeles, y
dividirlo por el número de pixeles, repitiendo el proceso con cada componente.
También notamos que si realizamos las operaciones sobre la misma matriz, se modificará el resultado de los
pixeles adyacentes del siguiente pixel, por lo que es mejor opción realizar la tarea sobre un arreglo auxiliar.

Posible solución
private void Suavizar()
{ Pixel[][] nuevoBitmap = new Pixel[bitmap.length][bitmap[0].length];
for(int x = 0 ; x < nuevoBitmap.length ; x++){
for(int y = 0 ; y < nuevoBitmap[0].length ; y++){
int r, g, b, pixeles;
r = 0;
g = 0;
b = 0;
pixeles = 0;
for(int i = x - 1 ; i < x+1 ; i++){
for(int j = y - 1 ; j < y + 1 ; j++){
if(i >= 0 && i < nuevoBitmap.length && j >= 0 && j < nuevoBitmap[0].length){
pixeles++;
r = r + bitmap[i][j].getRojo();
g = g + bitmap[i][j].getVerde();
b = b + bitmap[i][j].getAzul();
}
}
}
r = r/pixeles;
g = g/pixeles;
b = b/pixeles;

IIC1103 – Ayudantı́a: Arreglos y Matrices 15

 nuevoBitmap[x][y] = new Pixel(r,g,b);
}
}
bitmap = nuevoBitmap;
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 16

Problema 6: RunningUC
Enunciado
No sólo el estudio hace al estudiante. También es importante la vida universitaria. Dentro de esta, la activi-
dad deportiva es algo que deberı́amos tener siempre en mente.
En este problema se le pide que realice un programa en Java que maneja la inscripción (de manera simplifi-
cada) del ya tradicional evento “RunningUC”1 . Para esto, se le entregan las clases P rincipal y Alumno, y
ud. debe completar los métodos correspondientes en la clase BBDD.
Considere que la información a desplegar debe ser lo más clara posible. En particular, el método inf oInscritoN ()
deberá mostrar un mensaje tipo

Corredor Numero: 1 | Nombre: Ricardo | Edad: 23 | Categoria: Elite|

avisando si el corredor no existe.

Es decir, complete:

public class BBDD {

public void agregar(Corredor al) {...}// agrega un nuevo corredor al arreglo
public String infoInscritoN(int i) {...} // muestra la informacion del i-esimo inscrito
public String mostrarInscritos() {...}// muestra todos los inscritos
}

sin modificar:

public class Corredor {

// [ATRIBUTOS]
private String nombre; // nombre del corredor
private int edad; // su edad
private int categoria; // 5 para 5k, 10 para 10k, 11 para elite
// [METODOS]
// Constructor
public Corredor(String nombre, int edad, int categoria) {
this.nombre = nombre;
this.edad = edad;
this.categoria = categoria;
}
// getters
public int getCategoria() {
return categoria;
}
public int getEdad() {
return edad;
}
public String getNombre() {
return nombre;
}
}

1 para esto y mas visite www.runninguc.cl, o dirı́jase a deportes

IIC1103 – Ayudantı́a: Arreglos y Matrices 17

import iic1103Package.*;
public class Principal {
/** Programa para manejar la inscripcion para una corrida*/
public static void main(String[] args) {
// String con los mensajes a mostrar
String bienvenida = "Bienvenido a la inscripcion de soporte para el RunningUC" +
"\nMas informacion en www.runninguc.cl";
String despedida = "Nos vemos \n (mas info en www.runninguc.cl)";
String pedirNombbre = "Ingrese el nombre", pedirEdad = "Ingrese la edad";
String pedirCategoria = "Ingrese la categoria:" +
"\n 1] 5K\n 2] 10K \n 3] Elite";
String menu = "Ingrese una opcion:" +
"\n0) Salir\n1) Inscribir\n2) Mostrar informacion de un corredor\n3) Mostrar inscritos";
BBDD bd = new BBDD(); // creamos la base de datos (inicialmente vacia)
int opcion;
Usuario.mensaje(bienvenida);
do{
opcion = Usuario.entero(menu); // pedimos una opcion
while(opcion < 0 || opcion > 3){ // la validamos
Usuario.mensaje("Opcion incorrecta!");
opcion = Usuario.entero(menu);
}
switch (opcion) { // hacemos lo que se pide
case 0: { Usuario.mensaje(despedida);break;}// Salir
case 1: {// Inscribir
// pedimos el nombre
String nombre=Usuario.texto(pedirNombbre);
// pedimos la edad
int edad = Usuario.entero(pedirEdad);
while (edad < 0) {edad = Usuario.entero(pedirEdad);}// validamos que sea >0
// pedimos la categoria
int categoria = Usuario.entero(pedirCategoria);
// verificamos que este entre 1 y 3
while (categoria < 1 || categoria > 3 ) {
categoria = Usuario.entero(pedirCategoria);
}
Corredor al = new Corredor(nombre, edad, categoria); // lo creamos
bd.agregar(al); // lo agregamos
break;
}case 2: {// Pedir informacion de un corredor
int numero = Usuario.entero("Ingrese el numero del corredor: ");
while(numero < 1 ) // validamos que sea >= 1
numero = Usuario.entero("Ingrese el numero del corredor: ");
// buscamos esa posicion. Partimos de 0, asi que restamos 1 al numero
Usuario.mensaje(bd.infoInscritoN(numero-1));
break;
}case 3: {Usuario.mensajeConsola(bd.mostrarInscritos());break;}// Mostrar todos
}
} while(opcion != 0);
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 18

Criterios de solución
Primero que todo, es importante reconocer los métodos que debemos implementar y su forma:

public void agregar(Corredor al) {...}

public String infoInscritoN(int i) {...}
public String mostrarInscritos() {...}

Además, hay que llevar un registro con los corredores, i.e. es un arreglo de tipo Corredor, que como todos
los atributos será privado: private Corredor[] inscritos.
Ahora bien, al momento de agregar un corredor se pueden tener 2 escenarios:

el arreglo estaba vacı́o, y se crea uno nuevo (contiene sólo al nuevo corredor)
el arreglo ya tenı́a corredores. Es necesario crear uno nuevo, de tamaño mayor en 1 al anterior, copiar
cada elemento del arreglo antiguo al nuevo, y finalmente, copiar el nuevo elemento al final de este nuevo
arreglo 2 .

Por otro lado, la información que debemos mostrar emplea palabras para las categorı́as de los corredores,
por lo que debemos utilizar, por ejemplo, un switch para hacer la relación.
Por último, mostraremos un mensaje ad-hoc para la bienvenida, despedida, y en el caso que se pida infor-
mación y la lista esté vacı́a.

Posible solución
public class BBDD {
private Corredor[] inscritos;
// agrega un nuevo corredor al arreglo
public void agregar(Corredor nuevo){
// si el arreglo estaba vacio
if(this.inscritos == null){
inscritos = new Corredor[1]; // creamos un arreglo de tama~
no 1
inscritos[0] = nuevo; // ponemos al Corredor en la posicion 0 (la primera posicion)
}else{
agrandarArreglo(); // agrandamos el arreglo
// agregamos al nuevo Corredor en la ultima casilla (que la creamos vacia)
this.inscritos[this.inscritos.length-1] = nuevo;
}
}
// hacemos el arreglo una casilla mas grande
// es privado porque solo se debe llamar desde metodos de esta clase
private void agrandarArreglo() {
// creamos un arreglo auxiliar de largo lenght+1
Corredor[] aux = new Corredor[this.inscritos.length+1];
// copiamos cada Corredor al arreglo auxiliar
for(int i = 0 ; i < this.inscritos.length ; i++){
aux[i] = this.inscritos[i];
}
// la ultima posicion es null (porque es 1 mas grande)
this.inscritos = aux;
}
2 la solución que se muestra acá crea un método para esto

IIC1103 – Ayudantı́a: Arreglos y Matrices 19

 // metodo para retornar la informacion del inscrito numero-esimo
public String infoInscritoN(int numero) {
String info="";
// si la lista esta vacia
if(this.inscritos == null){
info = "No hay inscritos."; // decimos que no hay inscritos
}else{ // si la lista tiene por lo menos un inscrito
// avisamos si el numero esta fuera del largo del arreglo
if(this.inscritos.length <= numero){
info += "No se encuentra el numero solicitado";
}else // es una posicion valida, asi que obtenemos su informacion
{
// llamamos a los gets() correspondientes (y agregamos un "\n")
info += "Corredor Numero: "+(numero+1) +"|";
info += "Nombre: "+this.inscritos[numero].getNombre() +"|";
info += "Edad: "+this.inscritos[numero].getEdad() +"|";
int categoria = this.inscritos[numero].getCategoria();
String cat = ""; // mostraremos la categoria como el string que corresponde
switch (categoria) {
case 1:
cat = "5 K";
break;
case 2:
cat = "10 K";
break;
case 3:
cat = "Elite";
break;
}
info += "Categoria: "+cat+"|";
}
}
return info; // retornamos la informacion del inscrito
}
// metodo para mostrar todos los inscritos que hay en ese momento
public String mostrarInscritos() {
String todos = ""; // variable que guardara la informacion
// si el arreglo es null
if(this.inscritos == null){
todos = "No hay inscritos."; // quiere decir que no hay inscritos
}
else{ // hay por lo menos un inscrito
// recorremos el arreglo
for(int i = 0 ; i < this.inscritos.length ; i++){
// le agregamos la informacion del i-esimo inscrito
todos += infoInscritoN(i)+"\n";
}
}
return todos; // retornamos la informacion total
}
}

IIC1103 – Ayudantı́a: Arreglos y Matrices 20