IIC1103 Introducción a la Programación

Transcripción

1 Pontificia Universidad Católica de Chile Escuela de Ingeniería Departamento de Ciencia de la Computación IIC1103 Introducción a la Programación Capítulo 6: Arreglos 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 Capítulo 6: Arreglos 1

2 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, tenemos: <identificador>.length; Que nos devolverá el ndeg de valores que almacena el arreglo, es decir, al número que ingresamos al declararlo. 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 Capítulo 6: Arreglos 2

3 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 Capítulo 6: Arreglos 3

4 Ejemplos Problema 1: Preguntas Varias Enunciado Responda las siguientes preguntas: 1. Responda las siguientes preguntas en base al arreglo: int[] array = {0,1,2,3: a) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2] = array[2] + 1;, cuáles son los valores del arreglo array? por qué? b) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2] = 4;, cuáles son los valores del arreglo array? por qué? 2. Responda las siguientes preguntas en base al arreglo: String[] array = {" las "," los ", "el ","un "; a) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2] = array[2] + "la";, cuáles son los valores del arreglo array? por qué? b) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2] = "la";, cuáles son los valores del arreglo array? por qué? 3. Existe la clase Auto declarada de la siguiente forma: class Auto { private String color ; private int agno ; public Auto( String _color, int _agno) {... public String getcolor () { return color; public int getagno () { return agno ; public void setcolor ( String nuevo ) { color = nuevo; public void setagno ( int nuevo ) { agno = nuevo ; Responda las siguientes preguntas en base al arreglo: Auto[] array = { new Auto(" gris ", 2000), new Auto(" azul ", 1999), new Auto(" blanco ", 2005), new Auto(" rojo ", 2000): a) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2].setagno(array[2].getagno()+1);, cuáles son los valores de los atributos de los objetos del arreglo array? por qué? b) Si se realiza la instrucción array[1] = array[2]; seguida por la instrucción array[2] = new Auto("negro", 2009);, cuáles son los valores de los atributos de los objetos del arreglo array? por qué? c) Si se realiza la instrucción array[3].setcolor("gris") cuál es el resultado de la comparación array[0] == array[3]? por qué? Criterios de solución En este ejercicio lo importante es tener claro cuando las variables se copian por valor y cuando por referencia. En las dos primeras preguntas, al tratarse de arreglos de enteros y Strings las variables se copian por valor, por lo que luego de copiadas quedan completamente independientes. Cuando se trata de objetos las variables se copian por referencia, lo que implica que ambas (la original y la nueva copiada) referencian al mismo objeto y los cambios que se hagan a una se reflejan también en la otra. IIC1103 Capítulo 6: Arreglos 4

5 Posible solución 1. Solución a) 0,2,3,3 La primera instrucción hace una copia desde la posición 1 a la 2, y la segunda instrucción solamente modifica el valor en el casillero 2, ya que por ser int los casilleros 1 y 2 se mantienen independientes. b) 0,2,4,3 La misma justificación anterior, como la primera instrucción realiza una copia del valor de la casilla 2 a la 1, ambas se mantienen independientes. 2. Solución a) {" las ","el "," ella ","un "; La primera instrucción hace una copia de la referencia de la casilla 2 a la casilla 1, mostrando ambos el mismo valor. La segunda instrucción modifica el String en la casilla 2, creando un nuevo String (son inmutables) independiente del String en la casilla 1. b) {" las ","el ","la "," un "; Al igual que la pregunta anterior, la primera instrucción hace una copia de la referencia de la casilla 2 a la casilla 1, mostrando ambos el mismo valor. La segunda instrucción crea un nuevo String en la casilla 2, independiente del String en la casilla Solución a) { Auto (" gris ", 2000), Auto (" blanco ", 2006), Auto (" blanco ", 2006), Auto (" rojo ", 2000): Con la primera instrucción, tanto la casilla 1 como la 2 del arreglo referencian al mismo objeto. Al modificar este objeto con la segunda instrucción, cambian los atributos del objeto referenciado tanto por la casilla 1 como por la 2, dado que son el mismo. b) { Auto (" gris ", 2000), Auto (" blanco ", 2005), Auto (" negro", 2009), Auto (" rojo ", 2000): Con la primera instrucción, tanto la casilla 1 como la 2 del arreglo referencian al mismo objeto. Pero la segunda instrucción crea un nuevo objeto en la casilla 2, lo que hace que esta quede independiente del objeto referenciado por la casilla 1. Por ende, la segunda instrucción no afecta a la casilla 1. c) La comparación es a nivel de objetos, no de los valores de los atributos. Por ende, la comparación es false, ya que los objetos referenciados por la casilla 0 y por la casilla 3 son distintos (aunque el valor de los atributos sea el mismo). IIC1103 Capítulo 6: Arreglos 5

6 Problema 2: Más Repetidos Enunciado En esta pregunta usted debe implementar un método con encabezado: public int repetidos ( int arreglo []) que recibe como entrada un arreglo de números enteros mayores o iguales que cero, y retorna el valor en el arreglo que aparece repetido un mayor número de veces. Por ejemplo, si arreglo almacena la lista de números [1, 33, 4, 2, 4, 97, 0, 5, 4, 3, 48, 6, 4, 4, 3], entonces repetidos retorna el valor 4, ya que éste es el número que aparece repetido una mayor cantidad de veces en arreglo. Nota: Si hay dos o más números que satisfagan la condición mencionada arriba, entonces el método repetidos tiene que retornar alguno de ellos. Criterios de solución Una manera de resolver este ejercicio es utilizar un arreglo auxiliar que en la posición i almacene el número de veces que el número i aparece en el arreglo original. Para hacer esto lo primero que debemos obtener es el valor máximo que contiene el arreglo original pues este valor representará el largo de nuestro arreglo auxiliar. Luego llenamos el arreglo auxiliar aumentando en uno la cuenta en la posición adecuada según el número que aparezca en el arreglo original. Finalmente, revisamos el arreglo auxiliar y obtenemos el mayor valor guardado, donde la posición nos dará el número al que corresponde el mayor número de repeticiones. Posible solución public int repetidos( int arreglo []) { int i, max, indice ; int aux []; max = 0; for ( i = 1; i < arreglo. length ; i++) { if ( arreglo [i] > max) { max = arreglo [i]; aux = new int[ max + 1]; for ( i = 0; i < max + 1; i++) { aux[i] = 0; for ( i = 0; i < arreglo. length ; i++) { aux[ arreglo [i ]]++; max = aux [0]; indice = 0; for ( i = 1; i < aux. length ; i++) { if (aux[i] > max) { max = aux[i]; indice = i; return ( indice ); IIC1103 Capítulo 6: Arreglos 6

7 Problema 3: 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 consecutivos (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 temperaturas 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 Capítulo 6: Arreglos 7

8 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 sólo 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 dia 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(" Oscilacion 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(" Oscilacion descendente a partir del instante "+t); // Parte b) // Muestra en consola mensajes indicando ciclicidades // Recibe dos arreglos que almacenan la temperatura en dos dias // 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 Capítulo 6: Arreglos 8

9 Problema 4: Lista Números Enunciado Escriba la clase ListaNumeros que reciba un arreglo de enteros. Esta clase debe proveer los métodos ElementoMayor() que retorna el mayor elemento dentro del arreglo, ElementoMenor(), que retorna el menor elemento dentro de la lista y ElementoMasRepetido() que retorna el valor del elemento que más veces aparece en el arreglo. Criterios de solución Para el método ElementoMayor lo que tenemos que hacer es tener una variable donde almacenar el mayor valor. Luego recorremos todo el arreglo y comparamos cada elemento con el mayor valor, si el elemento es mayor entonces actualizamos el mayor valor. Al terminar el ciclo que recorre todo el arreglo, en la variable estará el mayor valor del arreglo. Para el método ElementoMenor hacemos lo mismo que para el método anterior pero comparamos si el elemento del arreglo es menor que el valor guardado en nuestra variable que almacena el menor valor en este caso. Para el método ElementoMasRepetido ocupamos dos variables, una que guarde el número que se ha repetido más veces y otra para guardar cuantas veces se ha repetido. Con un ciclo recorremos todo el arreglo, para cada elemento contamos (utilizando otro ciclo que recorra todo el arreglo) cuantas veces aparece. Luego comparamos este número de veces con el número que hasta el momento tenga mayor número de repeticiones y actualizamos su valor si es necesario. Posible solución public class ListaNumeros { private int [] arregloenteros; public ListaNumeros( int[] lista ) { // Copiamos el arreglo arregloenteros = new int[ lista. length ]; for ( int i = 0; i < arregloenteros. length ; i++) { arregloenteros[i] = lista [i]; public int ElementoMayor() { int mayor = arregloenteros[0]; for ( int i = 1; i < arregloenteros. length ; i++) { if ( arregloenteros[i] > mayor ) { mayor = arregloenteros[i]; return mayor ; public int ElementoMenor() { int menor = arregloenteros[0]; for ( int i = 1; i < arregloenteros. length ; i++) { if ( arregloenteros[i] < menor ) { menor = arregloenteros[i]; return menor ; public int ElementoMasRepetido() { // Buscamos cuantas veces aparece cada elemento, y guardamos el que mas // aparezca int masrepetido = 0; int masveces = 0; for ( int i = 0; i < arregloenteros. length ; i++) { // Reviso cuantas apariciones tiene el elemento i int contador = 0; for ( int j = 0; j < arregloenteros. length ; j++) { IIC1103 Capítulo 6: Arreglos 9

10 if ( arregloenteros[i] == arregloenteros[j ]) { contador ++; // Veo si el elemento i tiene mas apariciones que el con mas // apariciones hasta el momento if ( contador > masveces ) { return masveces = contador ; masrepetido = arregloenteros[i]; masrepetido; IIC1103 Capítulo 6: Arreglos 10

11 Problema 5: Calcular Primos Enunciado Escriba un programa en JAVA que calcule los números primos del 1 al 100 utilizando la criba de Eratostenes. Este algoritmo consiste en crear una lista con los números del 1 al 100 y luego ir descartando primero los múltiplos de 2, luego los de 3, los de 4 y así sucesivamente hasta los múltiplos de 10. Criterios de solución Siguiendo la descripción del algoritmo implementamos un ciclo que parta de 2 hasta 10 (para ir descartando los múltiplos de estos números). Dentro de este ciclo implementamos otro que recorra todo el arreglo original y revise para cada elemento si es múltiplo. Si lo es debemos sacarlo del arreglo, para lo que corremos todos los elementos hacia la izquierda a partir del elemento que queremos borrar. Finalmente imprimimos el arreglo con los números que nos quedan, siempre cuidando que al haber menos elementos no podemos recorrer todo el arreglo sino sólo hasta donde tenemos almacenados números. Posible solución import iic1103package.*; public class Principal { public static void main( String[] args) { int[] numeros = new int [100]; for ( int i = 0; i < numeros. length ; i++) numeros [i] = i + 1; // Al comienzo decimos que todos son primos int numprimos = 100; for ( int i = 2; i <= 10; i++) { for ( int j = 0; j < numprimos; j ++) { // Revisamos si el elemento j es multiplo del valor i // En caso de que sea debemos sacarlo del arreglo if ( numeros [j] % i == 0) { // Debemos sacar el elemento j, para eso corremos todos los // elementos hacia la izquierda a partir del elemento j for ( int k = j; k < numprimos - 1; k ++) { numeros [k] = numeros [k + 1]; // Tenemos un numero primo menos numprimos --; // Como corri todo hacia la izquierda debo volver a reviser // en la posicion j j--; // Mostramos los numeros encontrados for ( int i = 0; i < numprimos; i++) { Usuario. mensajeconsola( numeros [i] + " es primo." ); IIC1103 Capítulo 6: Arreglos 11

12 Problema 6: Código Desconocido Enunciado Indique lo que el siguiente código muestra en la consola import iic1103package.*; public class Principal { public static void main( String[] args) { int[] arreglo = { 171, 472, 96, 443, 112, 78, 352, 320, 70 ; Metodo ( arreglo ); public static void Metodo ( int[] arreglo ) { int x = arreglo [0]; for ( int i = 1; i < arreglo. length ; i++) { if ( arreglo [i] > x) { x = arreglo [i]; for ( int n = 10; 10 * x / n > 0; n = n * 10) { int[] temp = new int [10]; for ( int i = 0; i < temp. length ; i++) { temp [i] = 0; for ( int i = 0; i < arreglo. length ; i++) { temp [( arreglo [i] % n) / (( int) (n / 10))]++; for ( int i = 1; i < temp. length ; i++) { temp [i] += temp[i - 1]; Imprimir ( temp ); int[] aux = new int[ arreglo. length ]; for ( int i = arreglo. length - 1; i >= 0; i --) { aux[ temp [( arreglo [i] % n) / (( int) (n / 10))] - 1] = arreglo [i ]; temp [( arreglo [i] % n) / (( int) (n / 10))] - -; for ( int i = 0; i < arreglo. length ; i++) { arreglo [i] = aux[i]; Imprimir ( arreglo ); public static void Imprimir ( int[] arreglo ) { String texto = ""; for ( int i = 0; i < arreglo. length ; i++) { texto += arreglo [i] + " "; Usuario. mensajeconsola( texto ); Criterios de solución En éste tipo de problemas es buena opción escribir a un lado una tabla con las variables, arreglos y objetos, e ir anotando los cambios línea a línea, realizando una especie de debug manual. Se debe ser bastante sistemático para no equivocarse, y cuidar interpretar correctamente los cambios en las variables, arreglos y en los objetos. Posible solución IIC1103 Capítulo 6: Arreglos 12

13 Problema 7: Histograma Enunciado Un histograma es una representación gráfica (o como tabla) de las frecuencias de ciertos datos, distribuidos en alguna cantidad de categorías. Por ejemplo en los siguientes datos: 0, 2, 4, 5, 3, 12, 1, 4, 5, 121, 78, 12, 56, 1, 7, 9, 12, 13, 25, 24, 28, 6, 65, 91, 14, 75, podríamos definir las categorías x 20, 20 <x 50 y 50 <x, con lo que se produce el siguiente histograma: X Frecuencia x <x <x 6 Se le pide implementar la clase Histograma que permita crear un histograma de una serie de números enteros comprendidos en un rango establecido al momento de inicializar el objeto, y usando como categorías los mismos números, es decir, contar cuantas veces se repite cada número en el rango. Use un método Agregar que permita agregar un nuevo valor al Histograma. Criterios de solución Para definir nuestra clase Histograma utilizamos como atributos un arreglo que lleve el conteo de las apariciones de los números y variables que nos permitan identificar el rango en el que se encuentran los números. Así nuestro arreglo debe ser del tamaño suficiente para almacenar el conteo de todos los valores posibles dentro del rango definido. Luego creamos un método Agregar como nos dice el enunciado que lo que hace es revisar en que posición del arreglo se está acumulando el valor recibido como parámetro (la cual será el valor ingresado menos el límite inferior del rango) y aumentamos la cantidad almacenada en esa posición en uno. Para completar nuestra clase agregamos un método Mostrar que recorre el arreglo donde almacenamos el conteo y muestra cada valor (correspondiente a la posición en el arreglo más el límite inferior) y la cantidad almacenada en él. IIC1103 Capítulo 6: Arreglos 13

14 Posible solución import iic1103package.*; public class Histograma { private int [] conteo ; private int liminf ; private int limsup ; private int cantidad ; // Constructor, recibe los limites de los valores public Histograma( int liminf, int limsup ) { this. liminf = liminf ; this. limsup = limsup ; this. cantidad = limsup - liminf + 1; conteo = new int[ cantidad ]; for ( int i = 0; i < conteo. length ; i++) { conteo [i] = 0; // Agrega un valor al Histograma, para ello busca en que posicion del arreglo // se esta acumulando ese valor public void Agregar ( int valor ) { conteo [ valor - liminf ] = conteo [ valor - liminf ] + 1; public void Mostrar () { int limite = limsup - liminf ; int suma = 0; for ( int i = 0; i < conteo. length ; i++) { Usuario. mensajeconsola(( i + liminf ) + ": " + conteo [i ]); suma = suma + conteo [i ]; Usuario. mensajeconsola(" Suma : " + suma ); IIC1103 Capítulo 6: Arreglos 14

15 Problema 8: Mejor Ubicación Enunciado Implemente el método public int[] buscarmejorubicacion(int[][] plano, int tam). El primer parámetro es un arreglo bidimensional que representa un plano, donde cada casilla del arreglo indica la calidad asignada a esa posición en el plano. El método debe buscar la submatriz cuadrada de lado tam, cuya calidad sea la máxima. Debe retornar la ubicación de la casilla superior izquierda (fila y columna). En otras palabras, si tam es 2, debe buscar la matriz de 2x2 dentro del plano, cuya suma de las casillas es mayor. Si hay más de una empatada, debe retornar cualquiera. Asuma que el arreglo bidimensional siempre es regular (todas las filas tienen el mismo número de columnas). Ejemplo: Si tam fuera 2, el método debe retornar el arreglo {0, 3, ya que es la posición donde comienza la matriz de 2x2, cuya suma es mayor (13). En cambio si tam fuera 3, el método debe retornar el arreglo {0, 2, dado que es la mayor suma (35). Criterios de solución Lo primero que tenemos que hacer es recorrer la matriz por completo. Para eso utilizamos un doble ciclo pero considerando que para no pasarnos de los límites de la matriz tenemos que llegar a length-tam. Dentro de este ciclo tenemos que recorrer la submatriz de tamaño tam, utilizando también un doble ciclo y calculando la suma de sus posiciones. Luego, si esa suma es mayor que la encontrada hasta el momento actualizamos el valor de la suma mayor y el valor de los índices donde comienza la submatriz. Posible solución public int [] buscarmejorubicacion( int[][] plano, int tam) { int[] indices = { -1, -1 ; int max = 0; for ( int i = 0; i <= plano. length - tam; i++) { for ( int j = 0; j <= plano [i]. length - tam; j++) { int suma = 0; for ( int k = i; k < i + tam; k ++) { for ( int m = j; m < j + tam; m ++) { suma += plano [k][ m]; if ( indices [0] == -1 suma > max) { max = suma; indices [0] = i; indices [1] = j; return indices ; IIC1103 Capítulo 6: Arreglos 15

16 Problema 9: Output Desconocido Enunciado Indique el output que aparece en consola al ejecutar el siguientes código: public class ClassA { private int id; private String texto ; public ClassA( int n, String t) { id = n; texto = t; public int getid (){ return id; public String gettexto (){ return texto ; public void agregartexto( String t) { texto = texto + t; public ClassA copia () { return new ClassA(id, texto ); public class ClassB { private ClassA[] listaa ; public ClassB( int n, int id ) { listaa = new ClassA[n]; for( int i = 0; i < listaa. length - 1; i++) { listaa [i] = new ClassA(id, "T" + i); id = id + 1; public void agregar ( ClassA a) { listaa [ listaa. length -1] = a; public ClassA geta( int i) { return listaa [i]; public String ver () { String texto = " texto : "; for( int i = 0; i < listaa. length ; i++) { if( listaa [i]!= null) texto = texto + listaa [i]. gettexto () + " "; return texto ; import iic1103package.*; public class Principal { public static void main( String[] args) { int x = 1; ClassB b1 = new ClassB(4, x); ClassB b2 = new ClassB(4, x + 1); Usuario. mensajeconsola("l1:" + b1. ver ()); Usuario. mensajeconsola("l2:" + b2. ver ()); b1. agregar (b2. geta (2)); ClassA a1 = b1. geta (3); if ( a1. gettexto (). equals ( b2. geta (2). gettexto ())) { a1. agregartexto("s"); else { a1. agregartexto("n"); Usuario. mensajeconsola("l3:" + b1. ver ()); Usuario. mensajeconsola("l4:" + b2. ver ()); ClassA a2 = b1. geta (3). copia (); a2. agregartexto("p" + b2. geta (1). getid ()); if ( a2 == b2. geta (2)) { a2. agregartexto("s"); else if ( a2. getid () == b2. geta (2). getid ()) { a2. agregartexto("n"); b2. agregar (a2 ); Usuario. mensajeconsola("l5:" + b1. ver ()); Usuario. mensajeconsola("l6:" + b2. ver ()); IIC1103 Capítulo 6: Arreglos 16

17 Criterios de solución En éste tipo de problemas es buena opción escribir a un lado una tabla con las variables, arreglos y objetos, e ir anotando los cambios línea a línea, realizando una especie de debug manual. Se debe ser bastante sistemático para no equivocarse, y cuidar interpretar correctamente los cambios en las variables, arreglos y en los objetos. Posible solución L1:texto: T0 T1 T2 L2:texto: T0 T1 T2 L3:texto: T0 T1 T2 T2S L4:texto: T0 T1 T2S L5:texto: T0 T1 T2 T2S L6:texto: T0 T1 T2S T2SP3N IIC1103 Capítulo 6: Arreglos 17

18 Problema 10: Admin Palabras Enunciado Existe la clase AdminPalabras la cual posee una lista de palabras. Esta clase posee un método ContarPalabrasPosibles el cual recibe un String y retorna la cantidad de palabras de la lista que son posibles de formar con las letras del String recibido, cuidando que cada letra se puede usar una sola vez. Usted debe implementar el método ContarPalabrasPosibles de la clase AdminPalabras. A continuación se presenta un esquema de esta clase, usted no puede modificar los atributos de la clase, ni cambiar la firma del método. Si lo desea, puede agregar nuevos métodos a la clase. public class AdminPalabras { private String[] listapalabras; public AdminPalabras( String[] lista ) { listapalabras = lista ; public int ContarPalabrasPosibles( String letras ) {.... A continuación se muestra un ejemplo de un main que utiliza esta clase y el output que produce. public static void main( String[] args) { String[] lista = {" auto", " pato", " palo", " poto ", " amar", " amor", " loca ", " loco", " polo", " poco", " poca", " rota ", " roto"; AdminPalabras admin = new AdminPalabras( lista ); String[] letras = {" escalopa ", " automotor", " percatado"; for( int i = 0; i < letras. length ; i++) { int cont = admin. ContarPalabrasPosibles( letras [i]); Usuario. mensajeconsola( letras [i] + ": " + cont );. Output: escalopa: 3 automotor: 4 percatado: 3 Criterios de solución Para implementar el método que nos piden necesitamos primero declarar una variable para ir contando. Luego recorremos todas las palabras en la lista (con un for por ejemplo) y para cada una revisamos si es posible formarla con las letras recibidas. Para esto, dentro del ciclo que recorre la lista, creamos un arreglo para saber que letras ya hemos utilizado, donde el largo del arreglo es el número de letras disponibles y en cada posición del arreglo guardamos un true si esa letra ya se usó o false si todavía no se ha utilizado. Luego recorremos todas las letras de la palabras y vemos si están en la letras disponibles sin haber sido usadas. Cuando encontramos una letra la marcamos como no disponible. Así, si pudimos conseguir todas las letras aumentamos el contador en uno. Finalmente retornamos el contador. IIC1103 Capítulo 6: Arreglos 18

19 Posible solución public class AdminPalabras { private String[] listapalabras; public AdminPalabras( String[] lista ) { listapalabras = lista ; public int ContarPalabrasPosibles( String letras ) { // Creamos una variable para ir contando int contador = 0; // Recorremos todas las palabras en la lista y para cada una revisamos // si es posible formarla con las letras recibidas for ( int i = 0; i < listapalabras. length ; i++) { // Creamos un arreglo para saber que letras ya hemos utilizado, // lo iniciamos en false boolean[] usadas = new boolean [ letras. length ()]; for ( int j = 0; j < usadas. length ; j++) { usadas [j] = false; // Recorremos todas las letras de la palabra y vemos si estan en las // letras disponibles sin haber sido usadas boolean esposible = true; for ( int j = 0; j < listapalabras[i]. length (); j++) { boolean encontrada = false; // Buscamos la letra entre las disponibles for ( int k = 0; k < letras. length () &&! encontrada; k ++) { if (! usadas [k] && listapalabras[i]. charat (j) == letras. charat (k)) { // Encontramos la letra, la marcamos como utilizada encontrada = true; usadas [k] = true; if (! encontrada) { // Indica que la letra no fue encontrada entre las disponibles esposible = false; // Revisamos si fue posible conseguir todas las letras if ( esposible) { contador ++; return contador ; IIC1103 Capítulo 6: Arreglos 19

20 Problema 11: 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 éste 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 éste 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 Capítulo 6: Arreglos 20

21 Primera Iteración Segunda Iteración 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 está, 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 Usuario. mensajeconsola(" " ); for ( int j = 0; j < numeroj ; j++) { if ( Aleatorio. entero (1, 10) > probabilidad) { // si es mayor que la probabilidad no creamos una celula matriz [i][ j] = 0; else { matriz [i][ j] = 1; System. out. print (" " + matriz [i][j ]); Usuario. mensajeconsola(" "); Usuario. mensajeconsola(" " ); Usuario. mensajeconsola(" \n\n\n"); while ( true) {// itera hasta que hacemos un break IIC1103 Capítulo 6: Arreglos 21

22 for ( int i = 0; i < numeroi ; i++) { // vamos iterando por la matriz for ( int j = 0; j < numeroj ; j++) { // cuenta la cantidad de celulas que rodean a una posicion int contador = 0; if (i!= 0 && j!= 0) { // revisamos que no estamos en la esquina 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 // mi izquierda sumo 1 al contador 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 ++; 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 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 Usuario. mensajeconsola(" " ); for ( int j = 0; j < numeroj ; j++) { matriz [i][ j] = auxiliar [i][ j]; auxiliar [i][ j] = 0; IIC1103 Capítulo 6: Arreglos 22

23 System. out. print (" " + matriz [i][j ]); Usuario. mensajeconsola(" "); Usuario. mensajeconsola(" " ); Usuario. mensajeconsola(" \n\n\n"); int continuar = Usuario. entero (" Desea Continuar?"); if ( continuar == 0) { break; IIC1103 Capítulo 6: Arreglos 23

24 Problema 12: Validando un Sudoku 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 éste 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 Capítulo 6: Arreglos 24

25 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 numero 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 indices 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; return true ; IIC1103 Capítulo 6: Arreglos 25

26 Problema 13: 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 ; nuevobitmap[x][ y] = new Pixel (r, g, b); bitmap = nuevobitmap; IIC1103 Capítulo 6: Arreglos 26

27 Problema 14: Combinar Imágenes Enunciado Se requiere crear el método FusionEspecial de la clase Imagen, la cual está conformada por una matriz de elementos de la clase Pixel. El método FusionEspecial permite fusionar la imagen con otra imagen recibida como parámetro, retornando una matriz de Pixel, que representa el resultado de la fusión. El siguiente es el encabezado del método: public Pixel[][] FusionEspecial(Imagen imagen, float ponderador) El algoritmo para fusionar ambas imágenes indica que cada pixel en la imagen resultante se calcula como la ponderación entre los pixeles de ambas imágenes, multiplicando el pixel más fuerte por el ponderador y el pixel más débil por la diferencia entre el ponderador y 1. El pixel más fuerte será aquel cuya suma de las 3 intensidades que lo forman es mayor. Podríamos expresar esto en la siguiente fórmula: R(i, j) =α P M (i, j) + (1 α) P m (i, j), donde P M (i, j) corresponde al pixel más fuerte y P m (i, j) al más débil. La única restricción para que se pueda realizar la fusión es que ambas imágenes deben tener las mismas dimensiones, de lo contrario el método retorna null. A continuación se describen la clase Pixel y la clase Imagen. Usted debe solamente implementar el método FusionEspecial de la clase Imagen sin cambiar nada más de esta clase ni de la clase Pixel. public class Pixel { public Pixel ( int rojo, int verde, int azul) {... public Pixel ( int[] colores ){... public int getrojo (){... public int getverde (){... public int getazul (){... public class Imagen { private Pixel [][] pixeles ; public Imagen ( Pixel [][] pixeles ) { this. pixeles = pixeles ; public Pixel [][] FusionEspecial( Imagen imagen, float ponderador) {... public Pixel [][] getpixeles() { return pixeles ; Criterios de solución Lo primero que tenemos que hacer es revisar si las dimensiones son las mismas, ya que esto es una restricción de la fusión. Si no son iguales simplemente retornamos null. Si son iguales seguimos con el método. Creamos la matriz de Pixeles donde guardaremos los resultados. Implementamos un doble ciclo que nos permita recorrer toda la matriz de resultados para ir llenando cada posición. Luego calculamos dos sumas: la suma de todos los colores del pixel de la primera imagen y la suma de todos los colores del pixel de la segunda imagen. Revisamos cuál suma es mayor y según esto aplicamos la fórmula descrita en el enunciado para calcular el resultado y almacenarlo en la posición de la matriz resultante. Finalmente retornamos la matriz resultante. IIC1103 Capítulo 6: Arreglos 27

28 Posible solución public Pixel [][] FusionEspecial( Imagen imagen, float ponderador) { Pixel [][] otros = imagen. getpixeles(); // Revisamos si las dimensiones son las mismas, ya que esto es una // restriccion de la fusion if ( pixeles. length!= otros. length pixeles [0]. length!= otros [0]. length ) { return null ; // Creamos la matriz de pixeles donde guardaremos los resultados Pixel [][] resultado = new Pixel [ pixeles. length ][ pixeles [0]. length ]; // Recorremos la imagen resultante creando el color para cada pixel de esta for ( int i = 0; i < resultado. length ; i++) { for ( int j = 0; j < resultado[i]. length ; j++) { // Sumamos cada color para ver cual es mas fuerte int suma1 = pixeles [i ][ j]. getrojo () + pixeles [i][ j]. getverde () + pixeles [i][j]. getazul (); int suma2 = otros [i][ j]. getrojo () + otros [i][ j]. getverde () + otros [i][j]. getazul (); int rojo, verde, azul ; if ( suma1 > suma2 ) { rojo = ( int) ( pixeles [i][ j]. getrojo () * ponderador + (1 - ponderador) * otros [i][j]. getrojo ()); verde = ( int) ( pixeles [i][ j]. getverde () * ponderador + (1 - ponderador) * otros [i][j]. getverde ()); azul = ( int) ( pixeles [i][ j]. getazul () * ponderador + (1 - ponderador) * otros [i][j]. getazul ()); else { rojo = ( int) ( otros [i][ j]. getrojo () * ponderador + (1 - ponderador) * pixeles [i][j ]. getrojo ()); verde = ( int) ( otros [i][ j]. getverde () * ponderador + (1 - ponderador) * pixeles [i][j ]. getverde ()); azul = ( int) ( otros [i][ j]. getazul () * ponderador + (1 - ponderador) * pixeles [i][j ]. getazul ()); // Agregamos el pixel al resultado resultado[i][ j] = new Pixel ( rojo, verde, azul ); return resultado; IIC1103 Capítulo 6: Arreglos 28

29 Problema 15: Máquina de Bebidas Enunciado Una máquina expendedora de bebidas calientes vende 5 tipos de ésta, café, chocolate, cortado, capuccino y moka. La máquina recibe las monedas del cliente, procesa la opción elegida, y si es posible le entrega el producto, en conjunto con el vuelto correspondiente. La máquina acepta monedas de 10, 50, 100, 500, y billetes de 1000 y La máquina solamente es capaz de dar vuelto si es posible hacerlo con la mínima cantidad de monedas posibles (nunca se utilizan billetes para dar vuelto, sólo monedas). Por ejemplo, si el vuelto a dar son 1270, entonces la venta se realizará si y solo sí la máquina posee al menos 2 monedas de 500, 2 monedas de 100, 1 moneda de 50 y 2 monedas de 10. Implemente la clase Maquina la cual debe representar a esta máquina expendedora. Su clase debe tener al menos un constructor que reciba un arreglo con los precios de las 5 bebidas, e inicialice las cantidades iniciales para cada moneda, las cuales son 50 monedas de 10, 50, 100 y 500. Además su clase debe tener el método Vender el cual debe tener la siguiente firma: public int[] Vender(int[] ingresados, int producto) Donde ingresados representa a las monedas ingresadas por el cliente, en la posición 0 están las monedas de 10, en la 1 las de 50 y así sucesivamente en forma creciente (si no se ingresan monedas de algún tipo, entonces en la posición que le corresponde en el arreglo hay un 0). El parámetro producto indica el índice de la bebida seleccionada, en el mismo orden indicado anteriormente. Este método debe retornar un arreglo con las monedas (y billetes) que se deben dar de vuelto al usuario. En caso de no poder realizar la venta se retorna null. La compra no se puede realizar en caso que no sea posible dar el vuelto o en caso que el dinero ingresado no sea suficiente para la bebida seleccionada. Puede agregar todos los métodos y atributos que quiera a su clase. Criterios de solución Para cumplir con lo que nos piden en el enunciado la clase Maquina debería tener como atributos un arreglo que contenga la cantidad de cada una de las monedas que hay actualmente en la máquina y otro arreglo que contenga los precios de las 5 bebidas calientes. Además de esto la clase debe tener un constructor que reciba como parámetro los precios de las bebidas y los asigne al arreglo de precios que tiene como atributo. Además debe inicializar la cantidad de monedas en 50 (datos obtenidos del enunciado). Finalmente la clase debe tener un método Vender. En este método lo primero que hacemos es recorrer el arreglo con las monedas ingresadas por el usuario y calcular el precio total ingresado, para esto utilizamos un ciclo y multiplicamos el valor en cada posición del arreglo por el valor de la moneda que representa la posición. Luego de esto actualizamos la cantidad de monedas que tiene la máquina recorriendo el arreglo de ingresados y sumando las cantidades al atributo que contiene las cantidades de cada moneda. A continuación tenemos que verificar si es factible hacer la venta, para eso revisamos que el dinero total ingresado sea mayor que el precio del producto y que contemos con dinero suficiente para entregar el vuelto. Si se cumple esto entonces calculamos el vuelto y formamos el arreglo con las cantidades de cada moneda a devolver. IIC1103 Capítulo 6: Arreglos 29

30 Posible solución public class Maquina { private int [] monedas ; private int [] valormonedas = { 10, 50, 100, 500, 1000, 2000 ; private int [] precios ; public Maquina ( int[] precios ) { this. precios = new int [5]; for ( int i = 0; i < this. precios. length ; i++) { this. precios [i] = precios [i]; monedas = new int [6]; for ( int i = 0; i < monedas. length - 2; i++) { monedas [i] = 50; public int [] Vender ( int[] ingresados, int producto ) { int dineroingresado = 0; for ( int i = 0; i < ingresados. length ; i++) { dineroingresado += ingresados[i]* valormonedas[i]; int maxvuelto = dineroingresado - mascaro (); for ( int i = 0; i < monedas. length ; i++) { monedas [i] += ingresados[i]; if ( verificarfactibilidad( maxvuelto) && dineroingresado >= precios [ producto ]) { return devolverdinero( dineroingresado - precios [ producto ]); else { for ( int i = 0; i < monedas. length ; i++) { monedas [i] -= ingresados[i]; return null ; public int mascaro () { int mascaro = precios [0]; for ( int i = 1; i < precios. length ; i++) { if ( precios [i] > mascaro ) { mascaro = precios [i]; return mascaro ; public boolean verificarfactibilidad( int monto ) { for ( int i = monedas. length - 1; i > 0; i --) { if ( monto / valormonedas[i] > monedas [i]) { return false ; monto = monto % valormonedas[i]; return true ; public int [] devolverdinero( int dinero ) { int[] vuelto = new int[ monedas. length ]; for ( int i = monedas. length - 1; i > 0; i --) { vuelto [i] = dinero / valormonedas[i]; monedas [i] -= vuelto [i ]; dinero = dinero % valormonedas[i]; return vuelto ; IIC1103 Capítulo 6: Arreglos 30

31 Problema 16: Código Misterioso Enunciado Para el siguiente código, indique el output que aparecería en la Consola. public class ClassA { private String id; private ClassA hijo; private int total ; public ClassA( String n) { id = n; total = 0; public void sethijo ( ClassA h) { hijo = h; public ClassA gethijo () { return hijo ; public String getid () { return id; public void aumentar ( int delta ) { aumentardesdepadre( delta ); if ( hijo!= null) hijo. aumentardesdepadre( delta ); public void aumentardesdepadre( int delta ) { total += delta ; public int gettotal () { return total ; public static void main( String[] args) { ClassA[] listaobjetos = new ClassA[5]; for ( int i = 0; i < listaobjetos. length ; i++) { listaobjetos[i] = new ClassA(" Objeto " + i); if (i % 2 == 1) { listaobjetos[i]. sethijo ( listaobjetos[i - 1]); listaobjetos[i]. aumentar (i); for ( int i = 0; i < listaobjetos. length ; i++) { if ( listaobjetos[i]. gettotal () == 1) { Usuario. mensajeconsola(" L1: " + listaobjetos[i]. getid ()); for ( int i = 0; i < listaobjetos. length ; i++) { if ( listaobjetos[i]. gethijo () == null) { listaobjetos[i]. sethijo ( listaobjetos[( i + 2) % listaobjetos. length ]); for ( int i = 0; i < listaobjetos. length ; i++) { listaobjetos[i]. aumentar ( listaobjetos[i]. gethijo (). gethijo (). gettotal ()); for ( int i = 0; i < listaobjetos. length ; i++) { Usuario. mensajeconsola(" L2 : " + listaobjetos[i]. getid () + " - Total : " + listaobjetos[i]. gettotal ()); IIC1103 Capítulo 6: Arreglos 31

32 Criterios de solución En éste tipo de problemas es buena opción escribir a un lado una tabla con las variables, arreglos y objetos, e ir anotando los cambios línea a línea, realizando una especie de debug manual. Se debe ser bastante sistemático para no equivocarse, y cuidar interpretar correctamente los cambios en las variables, arreglos y en los objetos. Posible solución L1: Objeto0 L1: Objeto1 L2: Objeto0 - Total: 14 L2: Objeto1 - Total: 24 L2: Objeto2 - Total: 33 L2: Objeto3 - Total: 17 L2: Objeto4 - Total: 28 IIC1103 Capítulo 6: Arreglos 32

33 Problema 17: RunningUC Enunciado No sólo el estudio hace al estudiante. También es importante la vida universitaria. Dentro de ésta, la actividad 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 simplificada) 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 más visite o diríjase a deportes IIC1103 Capítulo 6: Arreglos 33

34 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); 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 IIC1103 Capítulo 6: Arreglos 34

35 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 informació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 tamanio 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; // 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 + " "; 2 la solución que se muestra acá crea un método para esto IIC1103 Capítulo 6: Arreglos 35

36 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 Capítulo 6: Arreglos 36

37 Problema 18: Naipes Enunciado Uno de los nuevos casinos que entró en funcionamiento en las últimas semanas le ha encargado que haga una clase que le permita manejar cartas de un naipe inglés. Este naipe contiene 52 cartas, donde cada una de ellas representa uno de los 13 valores posibles (i.e. 1 10, J, Q, K) combinado con alguna de las 4 pintas (i.e. corazón, pica, trébol y diamante). Una funcionalidad básica es poder barajar las cartas, para ello se puede escoger dos posiciones en el naipe al azar e intercambiarlos el número de veces que defina el usuario. También es necesario poder repartir un número variable de cartas al usuario y actualizar el naipe (eliminando las cartas entregadas de él). Usted deberá implementar la clase Naipe definiendo sus atributos y los siguientes métodos: public Naipe() constructor de la clase, inicializa el naipe con las 52 cartas posibles (no tendrá Jocker). public void barajar(int numero de intercambios) baraja escogiendo dos posiciones en el naipe al azar e intercambia las cartas, repite esta acción el número de veces definido por el parámetro numero de intercambios. public String[] repartir(int n) toma las primeras n cartas del naipe y las retorna como un arreglo de String donde cada elemento representa una carta en el formato valor-pinta (e.g. 2-diamante, J-trébol). Actualiza el naipe eliminando estas cartas. Debe retornar null si no hay suficientes cartas para repartir. Criterios de solución Lo primero que tenemos que hacer es declarar la clase y sus atributos, los cuales serán un arreglo que represente las cartas y un entero para saber cuantas cartas quedan del mazo. Para el constructor lo que tenemos que hacer es crear cada una de las cartas del naipe. Como son muchas cartas lo mejor es utilizar un ciclo que vaya construyendo las cartas por pinta y por número. Para el método barajar tenemos que implementar un ciclo que se repita tantas veces como el número de intercambios ingresado por el usuario. Luego, dentro del ciclo, generamos dos números aleatorios que serán las posiciones de los naipes que intercambiaremos. Así, cambiamos los naipes de las posiciones aleatorias, cuidando guardar el valor del primer naipe en una variable auxiliar para no perderlo al hacer el intercambio. Para el método repartir primero revisamos que haya suficientes cartas en el mazo. Si las hay formamos el arreglo con las cartas a repartir y con un ciclo movemos las cartas restantes hacia el inicio del arreglo, para así eliminar las primeras y no volver a repartirlas. Actualizamos también el número de cartas del mazo y retornamos el arreglo de las repartidas. IIC1103 Capítulo 6: Arreglos 37

38 Posible solución import iic1103package.*; public class Naipe { String[] mazo ; int numero_cartas; public Naipe () { numero_cartas = 52; mazo = new String[ numero_cartas]; String[] pinta = { " corazon ", " pica", " trebol ", " diamante " ; String[] numero_simbolo = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" ; for ( int i = 0; i < numero_simbolo. length ; i++) { for ( int j = 0; j < pinta. length ; j++) { mazo [i * 4 + j] = numero_simbolo[i] + " " + pinta [j]; public void barajar ( int numero_de_intercambios) { if ( numero_cartas < 2) { return; String aux; for ( int i = 0; i < numero_de_intercambios; i ++) { int primero = Aleatorio. entero (0, numero_cartas - 1); int segundo = Aleatorio. entero (0, numero_cartas - 1); if ( primero!= segundo ) { aux = mazo[ primero ]; mazo [ primero ] = mazo[ segundo ]; mazo [ segundo ] = aux; public String[] repartir ( int n) { // n negativo o mayor que el numero de cartas en el mazo if (n < 1 numero_cartas < n) { return null ; // Arreglo con cartas repartidas String[] mano = new String[n]; // Copio las cartas en el arreglo mano for ( int j = 0; j < n; j ++) { mano [j] = mazo[j]; // Elimino cartas del mazo desplazando las restantes hacia delante for ( int i = 0; i < numero_cartas - n; i ++) { mazo [i] = mazo[i + n]; // copio // Opcionalmente podra eliminar las repetidas del final // Actualizo la cantidad de cartas del mazo numero_cartas = numero_cartas - n; return mano ; IIC1103 Capítulo 6: Arreglos 38

39 Problema 19: Oficinas Enunciado Una empresa tiene oficinas distribuidas en varios edificios y quiere desarrollar un software que permita monitorear la forma en la que distribuye el espacio en cada planta de éstos. Para ello divide el espacio de cada planta en varias oficinas, a cada una de las cuales debe asignarse un nombre y un tamaño en metros cuadrados. Sin embargo, las salas asignadas a una planta del edificio no pueden exceder el tamaño total de ésta, ni se puede colocar más de 20 oficinas por planta, por pequeñas que sean, por un tema logístico. Genere un programa que permita representar este problema. En particular, incluya código en Java que al ejecutar el siguiente main(): public static void main( String[] args) { // Defino el tamanio de cada uno de los pisos del edificio. int[] tamanos = { 120, 120, 80 ; Edificio sanagustin = new Edificio (" San Agustin ", tamanos ); // Agrego oficinas a un determinado piso, con un nombre y tamanio // asignado. sanagustin. agregaroficina(0, " Sala H1", 30); sanagustin. agregaroficina(0, " Sala H2", 30); sanagustin. agregaroficina(0, " Sala H3", 30); sanagustin. agregaroficina(0, " Banio ", 15); sanagustin. agregaroficina(1, " Finanzas ", 50); sanagustin. agregaroficina(1, " Cubiculos", 50); sanagustin. agregaroficina(1, " Sala que no cabe", 50); // No hay espacio. sanagustin. agregaroficina(2, " Gerencia ", 80); sanagustin. mostrarestructura(); Muestre el siguiente mensaje en consola: Directorio del edificio San Agustin : El piso 1 contiene : - Sala H1 (30 mt2) - Sala H2 (30 mt2) - Sala H3 (30 mt2) - Banio (15 mt2) El piso 2 contiene : - Finanzas (50 mt2) - Cubiculos (50 mt2) El piso 3 contiene : - Gerencia (80 mt2) Utilice todo su conocimiento para dar un buen diseño a su solución. Criterios de solución Una posible solución a este problema es implementar tres clases: Oficina, Piso y Edificio. La clase Oficina como atributos debería tener el nombre y los metros cuadrados que ocupa, además de un constructor que reciba estos valores y los asigne a los atributos. Además debería tener los getters necesarios para obtenerlos. La clase Piso como atributos debería tener un arreglo de Oficinas (de largo 20 pues es el máximo número de oficinas por piso), un entero para determinar el número de oficinas que realmente hay en el piso y también un entero para almacenar el número de metros cuadrados disponibles. Además debería tener los siguientes métodos: Constructor: Reciba como parámetro el máximo número de metros cuadrados que puede tener el piso y cree el arreglo de oficinas. Método agregaroficina: Revise que no se hayan completado las 20 oficinas y que todavía queden metros cuadrados. Si hay espacio crear una nueva oficina, agregarla al arreglo y actualizar el número IIC1103 Capítulo 6: Arreglos 39

40 de metros cuadrados disponibles. Método mostrarestructura: Recorra todas las oficinas con un ciclo y muestre para cada una su nombre y el número de metros cuadrados que ocupa. La clase Edificio debería tener como atributos el nombre del Edificio y un arreglo de Pisos. Además debe tener los siguientes métodos: Constructor: Reciba como parámetro el nombre del Edificio y un arreglo con el tamaño de cada uno de los pisos. En el método debe crear el arreglo de pisos (según el número de elementos que contenga el arreglo de tamaños) y luego crear cada uno de los Pisos (con un ciclo) asignando el tamaño correcto. Método agregaroficina: Reciba como parámetros el índice del piso, el nombre y los metros cuadrados. Revise que el índice del piso es correcto y si es así llame al método agregaroficina del Piso correspondiente. Método mostrarestructura: Mostrar en pantalla el nombre del edificio y con un ciclo mostrar lo que contiene cada piso, llamando al método mostrarestructura de cada piso. Posible solución public class Oficina { private String nombre ; private int mt2; public Oficina ( String nombre, int mt2) { this. nombre = nombre ; this. mt2 = mt2; public int getmt2 () { return mt2; public String getnombre() { return nombre ; public class Piso { private Oficina [] piezas = new Oficina [20]; private int numpiezas = 0; private int mt2libres; public Piso ( int maxmt2 ) { piezas = new Oficina [20]; numpiezas = 0; mt2libres = maxmt2 ; boolean agregaroficina( String nombre, int mt2) { if ( numpiezas == 20 mt2libres < mt2) { return false ; piezas [ numpiezas++] = new Oficina ( nombre, mt2 ); mt2libres -= mt2; return true ; void mostrarestructura() { for ( int i = 0; i < numpiezas; i++) { System. out. println ("\t\t - " + piezas [i]. getnombre() + " (" + piezas [i]. getmt2 () + " mt2)"); IIC1103 Capítulo 6: Arreglos 40

41 public class Edificio { private Piso [] pisos ; private String nombre ; public Edificio ( String nombre, int[] tamanos ) { this. nombre = nombre ; pisos = new Piso[ tamanos. length ]; for ( int i = 0; i < pisos. length ; i++) { this. pisos [i] = new Piso ( tamanos [i ]); boolean agregaroficina( int piso, String nombre, int mt2) { if ( piso < 0 piso >= pisos. length ) { return false ; return pisos [ piso ]. agregaroficina( nombre, mt2 ); void mostrarestructura() { System. out. println (" Directorio del edificio " + nombre + ":"); for ( int i = 0; i < pisos. length ; i++) { System. out. println ("\ tel piso " + (i + 1) + " contiene :" ); pisos [i]. mostrarestructura(); IIC1103 Capítulo 6: Arreglos 41

42 Problema 20: Venta Pasajes EBE Enunciado La empresa de buses del estado (EBE) está realizando una promoción en la venta de pasajes. Para almacenar el costo de los recorridos entre ciudades, utiliza una matriz cuadrada donde cada ciudad tiene asociado un número que la identifica (entre 1 y N, siendo N el número total de ciudades a las que puede llegar la empresa). El elemento (x, y) de la matriz representa el costo que tiene realizar un viaje desde la ciudad x a la ciudad y. Cuando no existe un recorrido entre estas ciudades se deja el costo en 1. Además la empresa posee por cada recorrido entre dos ciudades un arreglo que indica los asientos libres y ocupados. Esto se debe a que la empresa ha destinado una fila completa del bus para esta promoción. Para que una persona pueda obtener un pasaje debe dirigirse a la boletería y comprarlo. Esto significa que el cajero a la hora de vender debe verificar si hay algún recorrido desde la ciudad x a la ciudad y y además si existe algún asiento disponible. En caso de disponibilidad simplemente marcará el asiento como ocupado. En caso contrario informará al pasajero la no disponibilidad El gráfico de la izquierda muestra el esquema de recorridos para 6 ciudades, y a la derecha se muestra una matriz que representa este esquema. En este ejemplo: - Existe un recorrido desde la ciudad 1 hasta la ciudad 2 y tiene costo 5000, pero no existe un recorrido desde la ciudad 2 hasta la ciudad 1 (costo es 1). Para esta pregunta se le pide implementar la clase Ruta para representar los recorrido, de acuerdo a las siguientes especificaciones: a) Los atributos de la clase son la matriz donde se debe almacenar el costo de los recorridos entre las ciudades y la matriz que indica la disponibilidad de asientos. b) Implemente el método constructor de la clase Ruta. Este método debe solicitar al usuario que ingrese la cantidad de ciudades. Luego debe solicitar el costo de viaje entre cada par de ciudades y almacenarlo en la matriz de costos definida en la clase. Recuerde tener vacía la matriz de disponibilidad. Usted debe pedirle al usuario que ingrese la cantidad de asientos disponibles en promoción, el cual es el mismo para cada par de ciudades. c) Implemente un método llamado costorecorridodirecto que retorne el costo de viaje entre dos ciudades. Si el camino no existe el método debe retornar 1 e imprimir el error. Nota: verifique antes que exista camino entre las dos ciudades. Por ejemplo: si observamos el esquema de recorridos no existe camino directo entre 4 y 1, pues para llegar a 4 antes debe recorrer las ciudades 2 y 3. Pero si existe camino directo entre 1 y 6 con costo IIC1103 Capítulo 6: Arreglos 42

43 d) Implemente un método ventapasaje que determine si se puede o no vender un pasaje, esto sólo si existe disponibilidad de asientos para realizar un viaje entre varias ciudades. El método recibe como parámetro un arreglo de enteros que representa las ciudades que forman la ruta. Por ejemplo: para la ruta [1, 6, 5], verifico que exista camino y disponibilidad de asientos. En ese caso vendo el pasaje. Caso contrario, para la ruta [1, 2, 3, 4, 5] no existe ruta debido a que para llegar a 5 antes debería pasar por 6. Criterios de solución El enunciado es bastante estructurado y nos indica que hacer. Primero declaramos la clase Ruta con dos atributos: una matriz de dos dimensiones para almacenar el costo de los recorridos y otra matriz de tres dimensiones para indicar la disponibilidad de un asiento desde una ruta hacia otra. Luego implementamos los métodos que nos piden: Constructor: En este método pedimos al usuario que ingrese el número de rutas y el número de asientos disponibles. Con estos datos creamos la matriz de costos y la de disponibilidad. Luego, con un doble ciclo inicializamos la matriz de costos, pidiendo para cada casilla el valor al usuario del costo de ir de una ciudad a otra. Dentro del mismo ciclo inicializamos también la matriz de disponibilidad. Método costorecorridodirecto: Este método debe recibir los índices de las ciudades. Lo primero que hacemos es revisar que dichos índices sean válidos (no nos salgamos de la matriz de costos). Luego obtenemos el valor en la posición de la matriz que corresponde al costo entre ambas ciudades y si este costo es -1 le avisamos al usuario. Si no, retornamos el costo que corresponde. Método ventapasaje: Recibe como parámetro un arreglo con las ciudades que forman la ruta. Lo primero que hacemos es un ciclo para recorrer el arreglo recibido como parámetro. Luego, dentro del ciclo, revisamos si hay costo para ir de una ciudad a la siguiente en el arreglo (llamando al método costorecorridodirecto). Luego revisamos si hay disponibilidad. Para esto revisamos la matriz de disponibilidad según las dos rutas, recorriendo en todos los posibles asientos de esas dos ciudades hasta encontrar alguno que sea true. Si esto se cumple para todas las ciudades del arreglo entonces actualizamos la disponibilidad de asientos. Posible solución import iic1103package.*; public class Ruta { private int [][] recorridos; private boolean [][][] disponibilidad; public Ruta () { int n = Usuario. entero (" Ingrese numero de rutas :" ); int t = Usuario. entero (" Ingrese numero de asientos disponibles:" ); recorridos = new int[n][ n]; disponibilidad = new boolean [n][ n][ t]; for ( int i = 0; i < n; i ++) for ( int j = 0; j < n; j ++) { recorridos[i][ j] = Usuario. entero (" Ingrese costo :" + i -1 + ","+ j -1); for ( int k = 0; k < t; k ++) { if (i == 5) { disponibilidad[i][ j ][ k] = false; else { disponibilidad[i][ j ][ k] = true; public int costorecorridodirecto( int x, int y) { x = x - 1; // por los indices y = y - 1; IIC1103 Capítulo 6: Arreglos 43

44 if (x >= 0 && y >= 0 && x < recorridos. length && y < recorridos[0]. length ) { if( recorridos[x][ y] == -1) Usuario. mensajeconsola(" No existe camino directo entre las ciudades." ); return recorridos[x][ y]; return -1; private boolean haydisponibilidad( int i, int j) { for ( int k = 0; k < disponibilidad [0][0]. length ; k++) { if ( disponibilidad[i][j][k]) { return true ; Usuario. mensaje (" no hay disponibilidad de " + i -1 + " a " + j -1); return false ; public void ventapasaje( int[] x) { int total = 0; boolean valida = true; for ( int i = 0; i < x. length - 1 && valida ; i++) { int costo = this. costorecorridodirecto(x[i], x[i + 1]); if ( costo > 0 && haydisponibilidad(x[i], x[i + 1])) total = total + costo ; else valida = false; if( valida ) { for ( int i = 0; i < x. length - 1; i++) this. restardisponibilidad(i, i +1); private void restardisponibilidad( int i, int j) { int k = 0; boolean noencontre = true; while ( noencontre && k < disponibilidad[0][0]. length ) { if ( disponibilidad[i][j][k]) { noencontre = false; disponibilidad[i][ j][ k]= k= k + 1; false; IIC1103 Capítulo 6: Arreglos 44

45 Problema 21: Facebook Enunciado Dados los problemas de privacidad que actualmente tiene Facebook, le han pedido a un grupo de programadores implementar un prototipo de red social para la universidad. La idea gruesa es poder almacenar una lista de contactos y luego almacenar cuáles de dichos contactos son amigos entre sí. Al repartir el trabajo se decidió que usted no va a escribir el main() del programa, sino proveer la funcionalidad requerida de forma que esté disponible para quien lo haga. Para ello, escriba las clases necesarias en java que permitan la serie de operaciones mencionadas a continuación: Representar una lista de personas de un tamaño máximo predefinido, a entregar por el main(). Poder agregar un nuevo nombre a la lista de personas. Su método debe ingresar una nueva persona con ese nombre y retornar a cambio un entero que sirva como identificador único para la persona en el sistema (para evitar problemas con nombres repetidos). Poder hacer que dos personas se vuelvan amigos. Para ello se proporcionan a la lista los dos identificadores correspondientes. Considere y valide lo siguiente: Que una persona no puede ser amigo de sí misma. Que la amistad es recíproca, no puedo ser amigo de alguien sin que éste sea amigo mío. Que una persona podría tener un máximo de 200 amigos. Poder obtener una persona teniendo su identificador. Poder pedirle a una persona que imprima en consola su red de amistades. La red de amistades está compuesta no sólo por sus amigos directos sino también por los amigos directos de sus amigos. La persona original no debe obviamente aparecer en la lista, pese a ser amiga de sus amigos. No importa si una misma persona aparece más de una vez en el listado (al ser amiga común de dos o más amigos). Criterios de solución Posible solución /** * Clase que almacena un contacto. */ public class Contacto { private String nombre ; private int id; private Contacto [] amigos ; private int numamigos; /** inicializa el contacto. Inicialmente se comienza con un numero base de amigos. nombre id */ public Contacto ( String nombrec, int idc) { nombre = nombrec ; id = idc; amigos = new Contacto [200]; numamigos = 0; /** * Agrega un nuevo amigo. El metodo intenta evitar tener que definir un * arreglo muy largo. Por ende, parte de una base fija y va duplicando la * capacidad cuando se queda sin espacio. amigo El amigo a agregar. */ IIC1103 Capítulo 6: Arreglos 45

46 public void agregaramigo( Contacto amigo ) { // Evito agregar un amigo ya existente. for ( int i = 0; i < numamigos; i++) { if ( amigos [i] == amigo ) { return; // Asigno un nuevo amigo amigos [ numamigos++] = amigo ; /** * Imprime la red de este contacto, es decir, todos los amigos directos y * los amigos de estos amigos. */ public void imprimirreddeamigos() { System. out. println (" Red de amigos de " + nombre + ":"); for ( int i = 0; i < numamigos; i++) { System. out. println ("\t- " + amigos [i]. nombre ); for ( int j = 0; j < amigos [i]. numamigos; j++) { if ( amigos [i]. amigos [j]!= this) { System. out. println ("\ t\t- " + amigos [i]. amigos [j]. nombre ); /** the nombre */ public String getnombre() { return nombre ; /** the id */ public int getid () { return id; /** the numamigos */ public int getnumamigos() { return numamigos; public class Facebook { private Contacto [] contactos; private int numcontactos; /** Constructor, facebook parte sin gente */ public Facebook ( int maximo ) { contactos = new Contacto [ maximo ]; numcontactos = 0; /** * Agrega un contacto con el nombre indicado y le asigna un id del sistema, * que es retornado */ public int agregarcontacto( String nombre ) { contactos[ numcontactos] = new Contacto ( nombre, numcontactos); return numcontactos++; /** * Relaciona a un contacto con otro, indicando que son amigos. La amistad * es bidireccional */ public void agregaramigo( int contacto, int amigo ) { if ( contacto < numcontactos && amigo < numcontactos && contacto!= amigo ) { contactos[ contacto ]. agregaramigo( contactos[ amigo ]); contactos[ amigo ]. agregaramigo( contactos[ contacto ]); IIC1103 Capítulo 6: Arreglos 46

47 /** Retorna el contacto pedido. */ public Contacto getcontacto( int id) { return contactos[ id ]; IIC1103 Capítulo 6: Arreglos 47

48 Problema 22: Patrones Sala Enunciado Muchas veces es necesario organizar las salas para controles e interrogaciones, de forma que se minimice la copia. Una de ellas es eliminar o habilitar algunos puestos de la sala, de forma que los alumnos se encuentren a mayor distancia de lo normal. Ud. deberá implementar un programa que permita aplicar algunos patrones de ubicaciones de personas a una sala en particular. Para la realización del ejercicio cuenta con las siguientes clases ya implementadas. No debe modificar la clase Principal. public class Sala { private int ancho ; private int largo ; private int [] representacionsala; public Sala ( int _ancho, int _largo ) { ancho = _ancho ; largo = _largo ; representacionsala = new int[ _ancho * _largo ]; for ( int i = 0; i < representacionsala. length ; i++) { representacionsala[i] = 0; public int [] getrepresentacionsala() { return representacionsala; public int getlargo () { return largo ; public int getancho () { return ancho ; public void imprimirrepresentacionsala() { System. out. println (" PIZARRON " ); for ( int i = 0; i < representacionsala. length ; i++) { if (i % ancho == 0) { System. out. println (); if ( representacionsala[ i] == 1) { System. out. print ("X"); else { System. out. print ( representacionsala[i ]); System. out. print (" "); System. out. println ("\n"); public int getindexfilavertical( int indexrep ) { return indexrep % ancho ; public int getindexfilahorizontal( int indexrep ) { return indexrep / ancho ; IIC1103 Capítulo 6: Arreglos 48

49 import iic1103package.*; public class Principal { public static void main( String[] args) { Patron [] _patrones = new Patron [4]; _patrones[0] = new Patron (1); _patrones[1] = new Patron (2); _patrones[2] = new Patron (3); _patrones[3] = new Patron (4); Distribucion _dist = new Distribucion( null, _patrones); int opcion = 0; while ( opcion!= 5) { opcion = Usuario. entero (" Ingrese opcion :\ n1: Crear sala\ n2: Aplicar patron \n" + " 3: Desaplicar patrones \ n4: Ver info sala\ n5: Salir " ); while ( opcion < 1 opcion > 5) { opcion = Usuario. entero (" OPCION INVALIDA \ ningrese opcion :\ n1: Crear sala\n" + " 2: Aplicar patron \ n3: Desaplicar patrones \ n4: Ver info sala \ n5: Salir " ); switch ( opcion ) { case 1: _dist. setsala ( crearsala()); _dist. getsala (). imprimirrepresentacionsala(); _dist. getsala (). imprimirinfosala(); break; case 2: if ( _dist. getsala ()!= null) { _dist. aplicarpatron( escogerpatron()); _dist. getsala (). imprimirrepresentacionsala(); _dist. getsala (). imprimirinfosala(); else { Usuario. mensaje (" Debe crear una sala para usar esta opcion " ); break; case 3: if ( _dist. getsala ()!= null) { _dist. desaplicarpatrones(); _dist. getsala (). imprimirrepresentacionsala(); _dist. getsala (). imprimirinfosala(); else { Usuario. mensaje (" Debe crear una sala para usar esta opcion " ); break; case 4: if ( _dist. getsala ()!= null) { _dist. getsala (). imprimirrepresentacionsala(); _dist. getsala (). imprimirinfosala(); else { Usuario. mensaje (" Debe crear una sala para usar esta opcion " ); break; public static int escogerpatron() { int opcion = 0; opcion = Usuario. entero (" Ingrese patron :\ n1: Borrar filas horizontales impares \n" + " 2: Borrar filas verticales impares \ n3: Eliminar en cruz \n" + " 4: Habilitar puestos par/ par o impar / impar " ); while ( opcion < 1 opcion > 4) { opcion = Usuario. entero (" OPCION INVALIDA \ ningrese patron :\ n" + " 1: Borrar filas horizontales impares \ n2 : Borrar filas verticales impares \n" + " 3: Eliminar en cruz\ n4: Habilitar puestos par/ par o impar / impar " ); return opcion - 1; public static Sala crearsala() { int ancho = Usuario. entero (" Ingrese el ancho de la sala"); int largo = Usuario. entero (" Ingrese el largo de la sala ( desde el pizarron al fondo )" ); return new Sala( ancho, largo ); IIC1103 Capítulo 6: Arreglos 49

50 El programa lo dividiremos en 3 subconjuntos incrementales. Le recomendamos no comenzar con el siguiente subconjunto hasta terminar y probar el funcionamiento correcto del subconjunto actual. Incremento 1 Para completar el primer incremento, deberá completar la implementación de la clase Sala. A continuación se detallan los métodos que deberá tener esta clase para este incremento (algunos ya están implementados): 1. Sala(int ancho, int largo) Constructor de la clase. Recibe el ancho y el largo (desde el pizarrón hasta atrás) que tiene la sala (en puestos). Este método también inicializa un arreglo unidimensional que representa a la sala, donde un 0 indica puesto disponible, y un 1 un puesto que no se puede usar. Tenga en cuenta que el tamaño de este arreglo es ancho*largo. 2. int[] getrepresentacionsala() Retorna el arreglo unidimensional que representa a la sala. 3. int getlargo() Retorna el largo (en puestos) de la sala. 4. int getancho() Retorna el ancho (en puestos) de la sala. 5. void imprimirrepresentacionsala() Imprime en consola el estado de la sala. Indica donde está el pizarrón, y los puestos deshabilitados están marcados con una X. 6. int getindexfilavertical(int indexrep) Retorna el índice de fila vertical de la celda representacionsala[indexrep]. 7. int getindexfilahorizontal(int indexrep) Retorna el índice de fila horizontal de la celda representacionsala[indexrep]. Además en este incremento deberá implementar la clase Patron con los siguientes métodos (ud. deberá crear completamente esta clase): 1. Patron(int tipo) Constructor de la clase. Recibe el número que representa el tipo del patrón a aplicar. 2. void settipo(int tipo) Setea el tipo de patrón. 3. void gettipo(int tipo) Retorna el tipo de patrón. 4. void aplicarpatron(sala sala) Aplica a sala el patrón que tiene seteado. Los índices parten desde cero (fila horizontal 0, fila vertical 0). Los patrones que debe tener implementados son 3 : tipo 1: deshabilitar filas horizontales impares. Un ejemplo de aplicación de este patrón sería (para una sala de ancho 10 y largo 6, a la que no se le han aplicado patrones): PIZARRON X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X 3 Los ejemplos aquí mostrados son outputs volcados en consola del resultado de la aplicación de los distintos patrones sobre una sala. En este método Ud. no debe implementar la impresión en pantalla, sino la asignación correcta de los valores del arreglo unidimensional que la representa. IIC1103 Capítulo 6: Arreglos 50

51 tipo 2: deshabilitar filas verticales impares. Un ejemplo de aplicación de este patrón sería (para una sala de ancho 10 y largo 6, a la que no se le han aplicado otros patrones): PIZARRON 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X 0 X tipo 3: deshabilitar asientos en cruz (diagonales). Ejemplos de aplicación de este patrón serían: Para una sala de ancho 10 y largo 6, a la que no se le han aplicado otros patrones: PIZARRON X X 0 X X X X X 0 0 X X X X X Para una sala de ancho 3 y largo 6, a la que no se le han aplicado otros patrones: PIZARRON X 0 X 0 X 0 X 0 X X 0 X 0 X 0 X 0 X tipo 4: habilitar asientos donde los índices de su posición sean ambos pares, o ambos impares. Ejemplo de aplicación de este patrón sería: Para una sala de ancho 10 y largo 6, a la que previamente se le aplicaron los patrones 1 y 2: PIZARRON 0 X 0 X 0 X 0 X 0 X X 0 X 0 X 0 X 0 X 0 0 X 0 X 0 X 0 X 0 X X 0 X 0 X 0 X 0 X 0 0 X 0 X 0 X 0 X 0 X X 0 X 0 X 0 X 0 X 0 En esta iteración se le pide que implemente los patrones 1 y 2. También deberá implementar por completo la clase Distribucion, la que deberá poseer los siguientes métodos: 1. Distribucion(Sala sala, Patron[] patrones) Constructor de la clase. Recibe un objeto de tipo Sala y un arreglo de tipo Patron, con los patrones asociados a esta distribución de asientos. 2. void setsala(sala sala) Setea la sala. 3. Sala getsala() Retorna la sala asociada a la distribución. 4. void aplicarpatron(int index) Aplica el patrón almacenado en patrones[index] a la sala previamente seteada. IIC1103 Capítulo 6: Arreglos 51

52 Incremento 2 Para completar el segundo incremento, Ud. debe agregar los siguientes métodos a la clase Sala: 1. int getcapacidadresultante() Retorna el número de asientos disponibles (luego de haber aplicado algún patrón, el número de asientos disponibles varía). 2. void imprimirinfosala() Muestra en pantalla con un mensaje, cierta información de la sala: ancho, largo, capacidad total, capacidad resultante luego de aplicar patrones. Además deberá implementar el patrón # 4, dentro del método aplicarpatron(...) de la clase Patron. Incremento 3 Para completar el tercer incremento, Ud. debe agregar los siguientes método a la clase Distribucion: 1. void aplicarpatrones() Aplica TODOS los patrones asociados a distribución a la sala previamente seteada. 2. void desaplicarpatrones() Desaplica TODOS los patrones que se han aplicado a la sala de la distribución. Además deberá implementar el patrón # 3, dentro del método aplicarpatron(...) de la clase Patron. Criterios de solución Posible solución public class Distribucion { private Sala sala; private Patron [] patrones ; public Distribucion( Sala sala, Patron [] patrones ) { this. sala = sala; this. patrones = patrones ; public void setsala ( Sala _sala ) { sala = _sala ; public Sala getsala () { return sala ; public void aplicarpatrones() { for ( int i = 0; i < patrones. length ; i++) { patrones [i]. aplicarpatron( sala ); public void desaplicarpatrones() { for ( int i = 0; i < sala. getrepresentacionsala(). length ; i++) { sala. getrepresentacionsala()[ i] = 0; public void aplicarpatron( int index ) { patrones [ index ]. aplicarpatron( sala ); public class Patron { private int tipo; public Patron ( int _tipo ) { IIC1103 Capítulo 6: Arreglos 52

53 tipo = _tipo ; public void settipo ( int _tipo ) { tipo = _tipo ; public int gettipo () { return tipo ; public void aplicarpatron( Sala _sala ) { if ( tipo == 1) { // eliminar filas horizontales impares for ( int i = 0; i < _sala. getrepresentacionsala(). length ; i++) { if ( _sala. getindexfilahorizontal(i) % 2!= 0) { _sala. getrepresentacionsala()[ i] = 1; else if ( tipo == 2) { // eliminar filas verticales impares for ( int i = 0; i < _sala. getrepresentacionsala(). length ; i++) { if ( _sala. getindexfilavertical(i) % 2!= 0) { _sala. getrepresentacionsala()[ i] = 1; else if ( tipo == 3){ // eliminacion cruz for ( int i = 0; i < _sala. getrepresentacionsala(). length ; i++) { int filavertical = _sala. getindexfilavertical(i); int filahorizontal = _sala. getindexfilahorizontal(i); if ( filavertical == filahorizontal % _sala. getancho () _sala. getancho () filavertical == filahorizontal % _sala. getancho ()) { _sala. getrepresentacionsala()[ i] = 1; else if ( tipo == 4) { // habilitacion puestos par/ par o impar / impar for ( int i = 0; i < _sala. getrepresentacionsala(). length ; i++) { int filavertical = _sala. getindexfilavertical(i); int filahorizontal = _sala. getindexfilahorizontal(i); if ( filavertical % 2 == filahorizontal % 2) { _sala. getrepresentacionsala()[ i] = 0; import iic1103package.*; public class Sala { private int ancho ; private int largo ; private int [] representacionsala; public Sala ( int _ancho, int _largo ) { ancho = _ancho ; largo = _largo ; representacionsala = new int[ _ancho * _largo ]; for ( int i = 0; i < representacionsala. length ; i++) representacionsala[i] = 0; public int [] getrepresentacionsala() { return representacionsala; public int getlargo () { return largo ; IIC1103 Capítulo 6: Arreglos 53

54 public int getancho () { return ancho ; public int getcapacidadresultante() { int capacidad = 0; for ( int i = 0; i < getrepresentacionsala(). length ; i++) { if ( getrepresentacionsala()[ i] == 0) { capacidad++; return capacidad; public void imprimirrepresentacionsala() { System. out. println (" PIZARRON " ); for ( int i = 0; i < representacionsala. length ; i++) { if (i % ancho == 0) { System. out. println (); if ( representacionsala[ i] == 1) { System. out. print ("X"); else { System. out. print ( representacionsala[i ]); System. out. print (" "); System. out. println ("\n"); public void imprimirinfosala() { Usuario. mensaje (" ancho :" + ancho + "\ nlargo : " + largo + "\ ncapacidad original :" + ( ancho * largo ) + "\ ncapacidad luego de aplicar patrones : " + getcapacidadresultante ()); public int getindexfilavertical( int indexrep ) { return indexrep % ancho ; public int getindexfilahorizontal( int indexrep ) { return indexrep / ancho ; IIC1103 Capítulo 6: Arreglos 54

55 Problema 23: Ventas Centro Comercial Enunciado Usted deberá implementar un programa que permita contabilizar las ventas realizadas por las tiendas en un centro comercial. Más específicamente deberá implementar las clases Mall y Tienda que permitan al método main ya implementado, poder extraer información sobre las ventas del centro comercial y las tiendas. Para la realización del ejercicio cuenta con la siguiente clase, la cual no debe modificar. import iic1103package.*; public class Principal { public static void main( String[] args) { int maxtiendas = Usuario. entero (" Ingrese el numero maximo de tiendas que puede " + " tener el mall." ); Mall shopping = new Mall( maxtiendas); int opcion = -1; while ( opcion!= 0) { opcion = Usuario. entero (" Ingrese la opcion de lo que desea hacer :" + "\n (1) Crear una nueva tienda " + "\n (2) Realizar una compra " + "\n (3) Ver el total de ventas del mall " + "\n (4) Ver las tiendas cuyo promedio de ventas se encuentra en un cierto rango " + "\n (5) Ver cuantas ventas realizo la tienda con mas ventas " + "\n (0) Salir " ); if ( opcion == 1) { int maxventas = Usuario. entero (" Ingrese el numero maximo de " + " ventas para la tienda." ); if ( shopping. creartienda( maxventas)) { Usuario. mensaje (" La tienda se creo con exito." ); else { Usuario. mensaje (" No fue posible crear la tienda." ); else if ( opcion == 2) { int numtienda = Usuario. entero (" Ingrese el numero de la tienda."); int monto = Usuario. entero (" Ingrese el monto de la compra." ); if ( shopping. realizarcompra( numtienda, monto )) { Usuario. mensaje (" Compra realizada con exito."); else { Usuario. mensaje (" No fue posible realizar la compra." ); else if ( opcion == 3) { Usuario. mensaje (" Las ventas totales del mall son: " + shopping. totalvendidomall()); else if ( opcion == 4) { double cantidad = Usuario. real(" Ingrese la cantidad con la cual comparar." ); double diferencia = Usuario. real(" Ingrese la diferencia maxima permitida."); shopping. mostrarcercanos( cantidad, diferencia); else if ( opcion == 5) { Tienda masventas = shopping. masventas(); if ( masventas == null) { Usuario. mensaje (" Necesita agregar tiendas al mall." ); else { Usuario. mensaje (" La tienda con mas ventas ha realizado " + masventas. getnumventas() + " ventas." ); El programa lo dividiremos en 3 subconjuntos incrementales. Le recomendamos no comenzar con el siguiente subconjunto hasta terminar y probar el funcionamiento correcto del subconjunto actual. Incremento 1 Para completar el primer incremento, deberá implementar la clase Tienda por completo. A continuación se detallan los métodos que deberá tener esta clase. IIC1103 Capítulo 6: Arreglos 55

56 1. Tienda(int maxventas) Constructor de la clase. Recibe la cantidad máxima de ventas que puede realizar la tienda. 2. int getnumventas() Retorna la cantidad de ventas realizadas por la tienda. 3. boolean agregarventa(int monto Agrega una nueva venta a la tienda, según el monto recibido. Retorna false si no es posible agregar la venta (ya se cumplió la cantidad máxima). 4. int totalvendido() Retorna el monto total de las ventas realizadas. 5. double promedioventas() Retorna el promedio de las ventas realizadas. 6. int maxventa() Retorna la venta realizada por la tienda con el mayor monto. Además en este incremento deberá implementar la clase Mall con los siguientes métodos: 1. Mall(int max) Constructor de la clase. Recibe la cantidad máxima de tiendas que puede haber en el centro comercial. 2. boolean creartienda(int maxventas) Permite agregar una nueva tienda al centro comercial. Recibe como parámetro la cantidad máxima de ventas que puede realizar la nueva tienda. Retorna false en caso de que no sea posible agregar la nueva tienda (ya se tiene la cantidad máxima de tiendas posibles). 3. boolean realizarcompra(int numtienda, int monto) Permite realizar una compra en una tienda determinada. Recibe el índice de la tienda (la tienda 0 es la primera que se agregó, la tienda 1 es la segunda y así sucesivamente), además recibe el monto de la compra que se quiere realizar. Retorna false en caso de no poder realizar la compra en la tienda. Incremento 2 Para completar el segundo incremento, su programa debe agregar los siguientes métodos a la clase Mall: 1. Tienda masventas() Permite obtener la tienda que ha realizado mas ventas. Si no hay tiendas en el centro comercial retorna null. 2. int totalvendidomall() Retorna el monto total de las ventas en el centro comercial, el cual se obtiene de la suma de las ventas totales de todas las tiendas. Incremento 3 Para completar el tercer incremento, su programa debe cumplir con los siguientes requisitos: 1. void mostrarcercanos(double cantidad, double diferencia) Muestra en la consola aquellas tiendas cuyo promedio de ventas se diferencia de cantidad en a lo más diferencia. Al mostrar en la consola se debe mostrar el índice de la tienda y el promedio real de la tienda. Después el método debe mostrar en un mensaje la cantidad de tiendas que cumplieron con el requisito buscado. Criterios de solución Posible solución public class Tienda { private int [] ventas ; private int ventaactual; public Tienda ( int maxventas) { // Al comienzo no hay ventas ventaactual = 0; IIC1103 Capítulo 6: Arreglos 56

57 // Inicializamos el arreglo donde guardaremos las ventas ventas = new int[ maxventas]; public int getnumventas() { return ventaactual; public boolean agregarventa( int monto ) { if ( ventaactual == ventas. length ) { return false ; ventas [ ventaactual] = monto ; ventaactual++; return true ; public int totalvendido() { // Definimos una variable de acumulador int total = 0; // Sumamos todas las ventas que ya se han realizado for ( int i = 0; i < ventaactual; i ++) { total += ventas [i]; return total ; public double promedioventas() { // Si no hay ventas se retorna 0 if ( ventaactual == 0) { return 0; // El promedio estara dado por el total de ventas dividido en la // cantidad // de ventas realizadas double prom = totalvendido(); prom = prom / ventaactual; return prom ; public int maxventa () { // Definimos una variable donde guardaremos el maximo int max = 0; for ( int i = 0; i < ventaactual; i ++) { if ( ventas [i] > max) { max = ventas [i]; return max; import iic1103package.*; public class Mall { private Tienda [] tiendas ; private int tiendaactual; public Mall ( int max) { tiendaactual = 0; // Inicializamos el arreglo con el tamanio maximo tiendas = new Tienda [ max ]; public boolean creartienda( int maxventas) { // Revisamos si aun se pueden agregar nuevas tiendas if ( tiendaactual == tiendas. length ) { return false ; // Agregamos la nueva tienda en la posicion Actual tiendas [ tiendaactual] = new Tienda ( maxventas); tiendaactual++; return true ; IIC1103 Capítulo 6: Arreglos 57

58 public boolean realizarcompra( int numtienda, int monto ) { // Revisamos que la tienda sea valida if ( numtienda >= tiendaactual) { return false ; // Retornamos el valor devuelto por el metodo agregar venta de la // clase tienda, ya que de no poder agregarse mas ventas este debe // retornar // false. return tiendas [ numtienda]. agregarventa( monto ); public Tienda masventas() { // Buscamos la Tienda que tienes mas ventas realizadas // Si no hay tiendas retornamos null if ( tiendaactual == 0) { return null ; Tienda max = tiendas [0]; // Recorremos todas las tiendas para ver cual es la con mas ventas for ( int i = 1; i < tiendaactual; i ++) { if ( tiendas [i]. getnumventas() > max. getnumventas()) { max = tiendas [i]; return max; public int totalvendidomall() { // Si no hay tiendas entonces no hay ventas if ( tiendaactual == 0) { return 0; // Definimos una variable quesirva de acumulador int total = 0; for ( int i = 0; i < tiendaactual; i ++) { total += tiendas [i]. totalvendido(); return total ; public void mostrarcercanos( double cantidad, double diferencia) { // Definimos una variable para contar las tiendas que poseen la // diferencia indicada. int contador = 0; // Recorremos todas las tiendas y mostramos aquellas cuyo promedio // se diferencia en a lo mas la diferencia indicada con la cantidad // recibida. for ( int i = 0; i < tiendaactual; i ++) { // Calculamos la diferencia entre el promedio de la tienda y la // cantidad // recibida. Le aplicamos valor absoluto para que no importe si es // positivo o negativo if ( Math. abs( cantidad - tiendas [i]. promedioventas()) <= diferencia) { contador ++; Usuario. mensajeconsola(" La tienda " + i + " tiene un promedio de " + " ventas de " + tiendas [i]. promedioventas()); // Mostramos el mensaje resumen Usuario. mensaje (" Se encontraron " + contador + " tiendas cuyo promedio de " + " ventas se diferenciaba por a lo mas " + diferencia + " con respecto a " + cantidad ); IIC1103 Capítulo 6: Arreglos 58

59 Problema 24: MasterMind Enunciado En este ejercicio usted deberá construir el juego mundialmente conocido MasterMind (Toque y Fama). Para esto cuenta con una clase que se encargará del manejo de la interfaz con el usuario, por lo que usted solamente deberá preocuparse de la lógica del juego. La clase InterfazMasterMind mostrada a continuación debe utilizarla pero no modificarla import iic1103package.*; /** Clase que sirve como interfaz grafica simple del juego MasterMind */ public class InterfazMasterMind { /** * Muestra el estado de un jugador y un menu de opciones tablerojuego : el tablero del jugador tableroayudas : el tablero con las ayudas intentosfaltantes : la cantidad de intentos que le quedan por hacer : opcion del usuario */ public int MostrarEstadoJugador( int[][] tablerojuego, int[][] tableroayudas, int intentosfaltantes) {... /** * Funcion que muestra en pantalla el codigo codigo : el codigo */ public void MostrarCodigo( int[] codigo ) {... /** * Pide al usuario los numeros del codigo, y retorna un arreglo con ellos rangomax : el entero maximo que puede ingresar cantnumeros : la cantidad de numeros a pedir */ public int [] ObtenerIntento( int rangomax, int cantnumeros) {... /** * Revisa si un numero ya esta en un arreglo num : el numero a revisar intento : el arreglo true si estaba, false si no */ public boolean YaEsta ( int num, int[] intento ) {... /** * Arma un string con el tablero y lo retorna tablerojuego : el tablero a mostrar ( el juego ) tableroayudas: el tablero con las ayudas un string con el tablero representado */ private String getstringtablero( int[][] tablerojuego, int[][] tableroayudas) {.... El juego consiste en que se genera un código de un largo predeterminado de números, y luego el usuario intenta adivinar el código generado. Para ello ingresa secuencias de números del mismo largo que el código. Para cada secuencia el juego le indica la cantidad de toques y la cantidad de famas que obtuvo, ambos valores obtenidos de la comparación del código ingresado por el usuario con el código secreto generado por el juego. Una fama se produce cuando uno de los valores indicados por el usuario está justo en la misma posición que el mismo valor en el código secreto. Por su parte, un toque se produce cuando el código del usuario contiene un valor que se encuentra en el código secreto, pero no están en la misma posición. Por ejemplo, si el código fuera de largo 4, el código secreto fuese {1, 2, 3, 4 y el usuario ingresa el código {2, 6, 3, 1, se le debiera indicar al usuario que obtuvo una fama (producto de que el 3 se encuentra en ambos códigos en la misma posición), y 2 toques, provocados por los números 1 y 2. IIC1103 Capítulo 6: Arreglos 59

60 Para esta versión, el código siempre contendrá valores diferentes. El jugador tendrá un máximo de intentos para lograr adivinar, perdiendo el juego si no logra dar con el número. El programa lo dividiremos en 3 subconjuntos incrementales. Le recomendamos no comenzar con el siguiente subconjunto hasta terminar y probar el funcionamiento correcto del subconjunto actual. Incremento 1 En este incremento deberá crear los siguientes métodos de la clase MasterMind. Esta clase representa a la lógica del juego. Debe contener atributos que permitan guardar el código secreto, otros que permitan guardar los valores indicados por el usuario en los diferentes intentos, así como el número de toques y famas en cada intento. Por último, deberá tener un objeto de la clase InterfazMasterMind, la cual se encargará de interactuar con el usuario. Fíjese en los parámetros que reciben los métodos de la clase InterfazMasterMind para que se haga una idea de como puede guardar la información en su clase. MasterMind() Constructor de la clase. void InicializarTablero(int maxintentos, int largocodigo) Método que inicializa los atributos encargados de guardar los códigos ingresados por el usuario, así como los resultados generados por estos códigos. Recibe como parámetros el número máximo de intentos y el largo del código. void GenerarCodigo(int largocodigo, int rangomax) Genera el código que deberá adivinar el usuario. Obtiene los números de forma aleatoria y verificando que todos sean distintos. Recibe el largo del código y el valor máximo para cada número del código (el mínimo siempre es 1). void IniciarJuego(int maxintentos, int largocodigo, int rangomax) Permite comenzar a jugar, manteniendo el ciclo del juego. Debe inicializar el tablero así como calcular el código. Luego debe mostrar el tablero utilizando el método MostrarEstadoJugador de la clase InterfazMasterMind. Este método retorna la opción seleccionada por el usuario, de la cual solamente debe considerar la opción 2 y 3. La opción 2 permite al usuario ver el código, para lo cual se debe invocar el método MostrarCodigo de la Interfaz del juego. La opción 3 indica que se debe salir del programa. Además debe crear el main del programa, el cual debe crear un MasterMind, pedir los valores al usuario para el máximo de intentos, el largo del código y el valor máximo de los números (debe verificar que este último sea mayor o igual al largo del código). Incremento 2 Debe agregar a la clase MasterMind el siguiente método: boolean Adivinar(int[] intento) Indica que el usuario desea adivinar el código secreto. Recibe como parámetro un arreglo con los valores indicados por el usuario, y retorna true en caso de adivinar completamente el código, o false en otro caso. Debe comparar el código del usuario con el código secreto, calcular el número de toques y famas, guardándolos donde corresponda, y luego retorna el valor correspondiente. Recuerde que si el largo del código es N, entonces en caso de tener N famas indica que el usuario acertó el código. Incremento 3 Debe agregar al método IniciarJuego la posibilidad de manejar la opción 1 indicada por el usuario, la cual indica que desea adivinar el código. Luego debe llamar al método ObtenerIntento de la interfaz, para luego revisar el intento con el método Adivinar. Luego si el usuario adivina se le debe mostrar un mensaje IIC1103 Capítulo 6: Arreglos 60

61 indicándole esto y terminar el programa. En caso de que no adivine debe revisarse si aún le quedan intentos, si no le quedan se debe mostrar un mensaje indicándole que perdió. Criterios de solución Posible solución import iic1103package.*; public class MasterMind { private int [] codigo ; private int [][] tablerojuego; private int [][] tableroayudas; private InterfazMasterMind GUI; private int numintentos; /** Constructor */ public MasterMind() { GUI = new InterfazMasterMind(); numintentos = 0; /** Metodo que inicializa los valores en el tablero del juego maxintentos : numero maximo de intentos largocodigo : numero de valores que forman el codigo */ public void InicializarTablero( int maxintentos, int largocodigo) { // Creamos tablero, inicializado en -1 tablerojuego = new int[ maxintentos][ largocodigo]; for ( int i = 0; i < tablerojuego. length ; i++) { for ( int j = 0; j < tablerojuego[i]. length ; j++) { tablerojuego[i][ j] = -1; // Creamos tablero de ayudas, inicializado en -1 tableroayudas = new int[ maxintentos][2]; for ( int i = 0; i < tablerojuego. length ; i++) { for ( int j = 0; j < 2; j++) { tableroayudas[i][ j] = -1; /** * Metodo que genera un codigo de forma aleatoria con todos los valores * distintos largocodigo : numero de valores que forman el codigo rangomax : valor maximo para cada uno de los numeros que forman el codigo */ public void GenerarCodigo( int largocodigo, int rangomax ) { // Creamos el arreglo codigo = new int[ largocodigo]; // Generamos los valores al azar, buscando que no se repitan for ( int i = 0; i < codigo. length ; i++) { boolean aceptado = false; // Lo comparamos con los valores anteriores while (! aceptado ) { codigo [i] = Aleatorio. entero (1, rangomax ); aceptado = true; for ( int j = i - 1; j >= 0; j --) { if ( codigo [j] == codigo [i]) { aceptado = false; /** * Intenta adivinar el codigo intento : un arreglo con el intento de adivinar el codigo si gano o todavia no */ public boolean Adivinar ( int[] intento ) { // Obtenemos intento del jugador y lo ponemos en el tablero IIC1103 Capítulo 6: Arreglos 61

62 for ( int i = 0; i < tablerojuego[ numintentos]. length ; i++) { tablerojuego[ numintentos][ i] = intento [i]; // Revisamos el intento y armamos las ayudas tableroayudas[ numintentos][0] = 0; tableroayudas[ numintentos][1] = 0; for ( int i = 0; i < codigo. length ; i++) { // Revisamos si esta el numero correcto en el lugar correcto if ( codigo [i] == tablerojuego[ numintentos][ i]) { tableroayudas[ numintentos][1]++; // Le achunto al numero, y en // el lugar adecuado else { // Si no esta en el lugar correcto, buscamos si al menos esta en // otro lugar for ( int j = 0; j < tablerojuego[ numintentos]. length ; j++) { if (( i!= j) && ( tablerojuego[ numintentos][ i] == codigo [j ])) { tableroayudas[ numintentos][0]++; // Le achunto al numero, pero no en el lugar adecuado // Revisamos si gano boolean gano = false; if ( tableroayudas[ numintentos][1] == codigo. length ) { gano = true; // Avanzamos y retornamos numintentos++; return gano ; /** Metodo principal del juego maxintentos : numero maximo de intentos largocodigo : numero de valores que forman el codigo rangomax : valor maximo para cada uno de los numeros que forman el codigo */ public void IniciarJuego( int maxintentos, int largocodigo, int rangomax ) { InicializarTablero( maxintentos, largocodigo); GenerarCodigo( largocodigo, rangomax ); // Ciclo principal boolean salir = false; while (! salir ) { // Mostramos tablero, obtenemos opcion y revisamos int opcion = GUI. MostrarEstadoJugador( tablerojuego, tableroayudas, maxintentos - numintentos); if ( opcion == 1) { // Obtenemos coordenadas y marcamos int[] intento = GUI. ObtenerIntento( rangomax, largocodigo); boolean gano = Adivinar ( intento ); import // Revisa si gano o perdio, si ya marco todas if ( gano) { Usuario. mensaje (" Adivinaste! Ganaste el juego." ); GUI. MostrarCodigo( codigo ); return; else if ( numintentos == tablerojuego. length ) { Usuario. mensaje (" Se te acabaron los intentos! Perdiste el juego." ); GUI. MostrarCodigo( codigo ); return; else if ( opcion == 2) { GUI. MostrarCodigo( codigo ); else if ( opcion == 3) { salir = true; iic1103package.*; public class Principal { public static void main( String[] args) { // Crea el objeto del juego IIC1103 Capítulo 6: Arreglos 62

63 MasterMind juego = new MasterMind(); // Pedimos al usuario los datos correspondientes int maxintentos = Usuario. entero (" Ingrese el numero maximo de intentos :" ); int largocodigo = Usuario. entero (" Ingrese el largo del codigo :" ); int maxrango = Usuario. entero (" Ingrese el maximo para los valores del codigo :" ); // Revisamos que sea mayor o igual al largo while ( maxrango < largocodigo) { maxrango = Usuario. entero (" Ingrese el maximo para los valores del codigo :" ); // Comienza el juego juego. IniciarJuego( maxintentos, largocodigo, maxrango ); IIC1103 Capítulo 6: Arreglos 63