6. Arreglos

Objetivos

● Crear arreglos ;

● usar ciclos for para procesar arreglos;

● usar ciclo for avanzado para procesar un arreglo;

● usar arreglos como entradas y salidas de métodos;

● usar arreglos para mandar una cantidad variable de argumentos a un método;

● desarrollar rutinas para acceder y manipular arreglos;

● distinguir entre arreglos unidimensionales y multidimensionales ;

● crear y procesar arreglos bidimensionales ;

● crear arreglos irregulares .

6.1 Introducción

Se considera la situación en la cual se tiene que crear y manejar una cantidad grande de elementos de datos. Una aproximación sería declarar tantas variables como se requieran, lo que puede ser molesto. Por ejemplo, considerar una aplicación que registra siete temperaturas, una por cada día de la semana, para la cual se declaran siete variables cada una de tipo double :

public class LeerTemperaturas { public static void main(String[] args) { // declarar siete variables para las temperaturas double temperatura1, temperatura2, temperatura3, temperatura4, temperatura5, temperatura6, temperatura7; // más código irá aquí } }

Luego se escribe código que permite al usuario ingresar valores para esas temperaturas (se supone que se ha creado un objeto Scanner , teclado ) como se muestra enseguida:

System.out.print("¿Temperatura máxima para el día 1? "); temperatura1 = teclado.nextDouble();

67

El código para leer las otras temperaturas se tendrá que hacer de manera similar, repetir el par de líneas anteriores. Se quiere otra forma hacerlo, sabiendo que se tiene el ciclo for que es útil cuando se tienen que repetir líneas de código una cantidad fija de veces. Se quiere intentar algo como lo siguiente:

for (int i=1; i<=7; ++i) { // ¿qué código se pone? }

Lo anterior parece una solución simple, pero no hay una instrucción que se pueda escribir en el ciclo for que permita ingresar un valor en una variable diferente cada vez que el ciclo se repite, lo anterior porque cada variable tiene nombre único.

Idealmente se quiere dar a cada variable el mismo nombre, digamos temperatura , para que se pueda usar en el ciclo, pero también se quiere una forma de distinguir entre cada variable sucesiva. Lo anterior es lo que un arreglo permite hacer.

6.2 Crear un Arreglo

Un arreglo es un tipo especial de dato en Java que puede ser pensado como un contenedor para guardar una colección de artículos . Estos artículos son también referidos como los elementos del arreglo. Todos los elementos guardados en un arreglo particular deberán ser del mismo tipo pero no hay restricción en cuanto al tipo que es. Por ejemplo, un arreglo puede ser usado para guardar una colección de valores int o una colección de valores char , pero no puede ser usado para guardar una mezcla de valores int y char .

La creación de un arreglo es un proceso de dos etapas:

1. declarar una variable arreglo; 2. reservar memoria para guardar los elementos del arreglo

La variable para un arreglo es declarada casi de la misma forma que una variable simple excepto que un par de corchetes vacíos ( [] ) es agregado después del tipo. Por ejemplo, si se quiere declarar el arreglo temperatura conteniendo valores double , se escribirá de la siguiente forma:

double[] temperatura;

Lo anterior define temperatura para ser una variable que puede ser enlazada a una colección de valores double . Se dice que la variable temperatura guarda una referencia al arreglo de elementos. Una referencia es una variable que guarda una posición en la memoria de la computadora, conocida como dirección de memoria, donde los datos están guardados, en vez de los datos.

68

En ese momento la dirección de memoria guardada en la referencia temperatura no tiene sentido, ya que la memoria que guardará el arreglo de elementos todavía no ha sido reservada. Esa es la segunda etapa.

La información que se requiere para reservar el espacio en la computadora de la memoria para todos los elementos del arreglo es el tamaño del arreglo, esto es la cantidad máxima de elementos requeridos por el arreglo. Como cada tipo de dato requiere una cantidad diferente de espacio de memoria, también es necesario indicar el tipo de los elementos del arreglo, que es el mismo usado en la etapa de la declaración.

Con el operador new se crea el espacio en memoria para un arreglo de un tamaño dado y tipo de elemento. Una vez que el tamaño del arreglo es puesto este no puede ser cambiado, así que se debe crear un arreglo para que sea lo suficientemente grande. Para el ejemplo anterior, del registro de temperaturas, se quiere un arreglo para guardar siete temperaturas por lo que se reserva memoria como sigue:

temperatura = new double[7];

Como se puede ver en la figura anterior la creación del arreglo ha reservado siete posiciones contiguas en la memoria. Cada posición es lo suficientemente grande como para guardar un valor de tipo double . La variable temperatura está

69

enlazada a esos siete elementos conteniendo la dirección del primer elemento, de esta forma temperatura queda enlazada a siete variables nuevas. Cada una de las variables automáticamente tendrá un valor inicial. Si las variables son de algún tipo numérico, como int o double , el valor de cada una será inicialmente puesto a cero; si las variables son de tipo char sus valores serán inicialmente puestos al valor Unicode especial que representa un carácter vacío; si las variables son tipo boolean cada una será inicializada a false .

Las dos etapas de creación de un arreglo, declaración y reserva de espacio de memoria para los elementos, pueden ser combinadas en un solo paso como sigue:

double[] temperatura = new double[7];

Cada elemento en el arreglo comparte el mismo nombre que el arreglo, en este caso cada elemento es llamado temperatura . Los elementos individuales son identificados de forma única por un valor de índice adicional. Así un elemento del arreglo es identificado por el nombre del arreglo y el valor de índice.

En Java los índices de arreglo inician desde cero . El valor de índice es siempre encerrado entre corchetes, por lo que el primer elemento de la lista es identificado como temperatura[0] , el segundo como t emperatura[1] y así sucesivamente.

Por lo anterior el tamaño del arreglo y el valor de índice del último elemento no tienen el mismo valor, para el caso del arreglo temperatura este tiene tamaño siete y el último índice es seis. Lo anterior es una causa común de errores en los programas. Si se intenta acceder un elemento no válido, como temperatura[7] , el siguiente error será generado por el sistema: java.lang.ArrayIndexOutOfBoundsException

Este tipo de error es llamado una excepción .

Cuando un arreglo es creado los valores serán puestos cuando se ejecute el programa. Sin embargo, si todos los valores de los elementos del arreglo son conocidos previamente, entonces un arreglo puede ser creado sin el uso del operador new para inicializar el arreglo como se muestra enseguida:

double[] temperatura = {23, 24.5, 27.2, 26.1, 25, 22, 18};

Los valores iniciales son colocados entre llaves y separados por comas. El compilador determina el tamaño del arreglo por la cantidad de valores iniciales. Cada valor es puesto en el arreglo en orden, asi temperatura[0] es puesto a 23 , temperatura[1] a 24.5 , y así sucesivamente. Esta es la única instancia en la cual

70

todos los elementos de un arreglo pueden ser asignados explícitamente listando los elementos en una sola sentencia de asignación.

6.3 Acceder Elementos del Arreglo

Una vez que un arreglo ha sido creado, sus elementos pueden ser usados como cualquier otra variable del tipo dado. En el ejemplo de lectura de temperaturas, la inicialización de los valores de cada temperatura cuando el arreglo es creado no es muy realista, es más probable que las temperaturas sean ingresadas cuando se ejecuta el programa. Enseguida se muestra como lograr lo anterior.

Si un arreglo es inicializado o no, los valores pueden ser puestos en los elementos individuales del arreglo. Se sabe que cada elemento en este arreglo es una variable de tipo double . Como cualquier variable de un tipo primitivo, el operador de asignación puede ser usado para poner un valor.

Se tiene que recordar que cuando se usa el operador de asignación con un elemento del arreglo se tiene que especificar a cuál elemento se le colocará el valor. Por ejemplo, para permitir al usuario ingresar el valor de la primera temperatura, la siguiente sentencia de asignación podría ser usada, suponiendo la existencia de un objeto Scanner , teclado :

temperatura[0] = teclado.nextDouble();

Observar que la primera temperatura tiene índice cero porque los índices de los arreglos inician en cero.

También los elementos del arreglo podrían ser mostrados en la salida. Por ejemplo, el siguiente comando muestra el valor del sexto elemento del arreglo:

System.out.println(temperatura[5]); //índice del 6º elemento es 5

De los ejemplos anteriores, se puede ver que los elementos del arreglo se pueden usar como cualquier otra variable de un tipo dado. Enseguida otros ejemplos:

temperatura[4] = temperatura[4] * 2;

La asignación duplica el valor del quinto elemento. La siguiente sentencia if revisa si la temperatura del tercer día no fue una temperatura alta:

if (temperatura[2] >= 32) { System.out.println("Fue un día caluroso"); }

71

El sistema de indexado de arreglos es una herramienta de programación útil. El valor del índice no requiere ser un número literal como en los ejemplos previos; puede ser cualquier expresión que evalúe a entero .

Es más frecuente usar una variable entera en vez de un valor fijo de índice para acceder a un elemento del arreglo. Por ejemplo, si se supone que i es alguna variable entera, entonces la siguiente sentencia es una forma legal de acceder un elemento del arreglo:

System.out.println(temperatura[i]);

Una aplicación útil de esto es poner las instrucciones para un arreglo en un ciclo, generalmente un ciclo for , usando el contador de ciclo como índice del arreglo. Por ejemplo, regresando al problema original de ingresar las lecturas de siete temperaturas, el siguiente ciclo puede ser usado:

for (int i=0; i<7; ++i) { System.out.print("ingrese la temperatura máxima del día "+ (i+1)+": "); temperatura[i] =teclado.nextDouble(); //usar contador del ciclo }

Observar los siguientes puntos en este ciclo:

● A diferencia de los ejemplos previos de ciclo for donde se inicia en uno, este contador inicia en cero. Como el contador se usa para manejar los índices del arreglo, el cero es el valor apropiado para iniciar.

● El contador se incrementa, pero no incluye, la cantidad de datos en el arreglo, es decir, el contador llega hasta seis y no siete, ya que el índice del arreglo se detiene en seis para un arreglo de tamaño siete.

● En la sentencia println() se usa el contador del ciclo para mostrar el número del día que está siendo ingresado. Para que el mensaje tenga sentido al usuario, se muestra ( i+1 ) en vez de i , para no pedir la temperatura del día cero.

En los arreglos existe una propiedad incorporada que proporciona el tamaño de un arreglo. Esta es usada usando la palabra length después del nombre del arreglo. Enseguida se muestra:

System.out.print("Cantidad de temperaturas: "); System.out.println(temperatura. length ); // muestra tamaño del arr.

La propiedad length devuelve el tamaño del arreglo, no necesariamente la cantidad de datos guardados actualmente en el arreglo, que podría ser menor. Este atributo puede ser usado en lugar de una literal para el ciclo for como sigue:

72

for (int i=0; i< temperatura.length ; ++i) { // código para el ciclo aquí }

Para ver el uso de esta técnica se muestra enseguida el programa completo LeerTemperaturas , el cual guarda y muestra las temperaturas máximas diarias en una semana.

import java.util.Scanner; public class LeerTemperaturas { public static void main(String[] args) { Scanner teclado = new Scanner(System.in); // crear arreglo double[] temperatura; temperatura = new double[7]; // ingresar temperaturas for (int i=0; i<temperatura.length; ++i) { System.out.print( "ingresar la temperatura máxima del día "+(i+1)+": "); temperatura[i]=teclado.nextDouble(); //usa contador } // mostrar temperaturas System.out.println(); // línea en blanco System.out.println("*** Temperaturas Ingresadas ***"); System.out.println(); // línea en blanco for (int i=0; i<temperatura.length; ++i) { System.out.println("Día "+(i+1)+" "+temperatura[i]); } } }

6.4 Pasar Arreglos como Parámetros

En el capítulo anterior se revisa cómo los métodos pueden ser usados para dividir una tarea de programación en unidades manejables. Los métodos pueden recibir datos en la forma de parámetros y pueden devolver datos en la forma de un valor regresado. En la siguiente sección se revisa un ejemplo de un arreglo que es regresado desde un método. En esta sección se revisa cómo pasar arreglos como parámetros a un método. Como ejemplo de pasar un arreglo a un método, se considera nuevamente el programa LeerTemperaturas de la sección previa. Se puede observar que este programa contiene todo el procesamiento dentro del método main() , por lo tanto el código es un poco difícil de leer. Para simplificar al método main() este se auxiliará de dos métodos, ingresarTemperaturas() y mostrarTemperaturas() , para realizar lo que sus nombres indican. Para dar a

73

estos métodos acceso al arreglo estos deben recibirlo como un parámetro. La cabecera para el método ingresarTemperaturas() se muestra enseguida; observar que cuando un parámetro es declarado como un tipo arreglo, el tamaño del arreglo no es requerido por lo tanto los corchetes están vacíos:

static void ingresarTemperaturas( double[] temperatura ) { // el resto del método aquí }

Se había comentado en el capítulo previo que un parámetro recibe una copia de la variable original, pero con un arreglo es un poco diferente. Se explica más adelante. El código para el método es el mismo que estaba en el método main() .

Scanner teclado = new Scanner(System.in); for (int i=0; i<temperatura.length; ++i) { System.out.print("ingrese la temperatura máxima del día " + (i+1)+": "); temperatura[i]=teclado.nextDouble(); }

De igual forma el método mostrarTemperaturas() requerirá que el arreglo sea mandado como un parámetro. El programa siguiente reescribe el programa previo agregando los dos métodos anteriores.

 import java.util.Scanner; public class LeerTemperaturas2 { public static void main(String[] args) { double[] temperatura; temperatura = new double[7]; ingresarTemperaturas(temperatura); // llamar método mostrarTemperaturas(temperatura); // llamar método } // método para ingresar temperaturas static void ingresarTemperaturas(double[] temperatura) { Scanner teclado = new Scanner(System.in); for (int i=0; i<temperatura.length; ++i) { System.out.print( "ingrese la temperatura máxima del día "+(i+1)+": "); temperatura[i]=teclado.nextDouble(); } } // método para mostrar temperaturas static void mostrarTemperaturas( double[] temperatura ) { System.out.println(); System.out.println("*** Temperaturas Ingresadas ***"); System.out.println(); for (int i=0; i<temperatura.length; ++i) {

74

System.out.println("Día "+(i+1)+" "+temperatura[i]); } } }

El método ingresarTemperaturas() llena el arreglo original , y esto sucede porque en el caso de los arreglos, el valor enviado como parámetro no es una copia de cada elemento del arrreglo, sino una copia de la referencia del arreglo. Es decir, la ubicación del arreglo es enviada al método y no el valor de los contenidos del arrreglo. El parámetro que recibe ( temperatura ) también está apuntando al mismo lugar en la memoria, por lo tanto ambos están modificando el mismo arreglo. Esto se ilustra en la siguiente figura. Mandar la referencia del arreglo a un método en vez de una copia completa del arreglo es un uso eficiente de los recursos de cómputo, en particular cuando los arreglos son grandes.

6.5 Varargs

En el método mostrarTemperaturas() , de la sección previa, se declara el parámetro para que sea un arreglo de valores double , por lo que el método es capaz de trabajar con cualquier tipo de valores double contenidos en el parámetro del arreglo dado:

// puede aceptar un arreglo de cualquier tamaño

75

static void mostrarTemperaturas(double[] temperatura) { // código que muestra temperaturas aquí }

El método mostrarTemperaturas() puede trabajar con arreglos de cualquier tamaño, en el programa LeerTemperaturas2 se usa un arreglo de tamaño siete, pero se le podría pasar un arreglo de tamaño 365 para cada día del año y podría recibir estos datos y mostrar todas las temperaturas, independientemente del tamaño del arreglo.

Cercanamente relacionado a la idea de mandar un arreglo a un método se encuentra una característica de Java llamada varargs , abreviatura para variable arguments (argumentos variables). Igual que mandando un arreglo, la característica varargs permite mandar una cantidad variable de elementos de datos a un método, siempre y cuando cada elemento sea del mismo tipo, sin tener la necesidad de fijar la cantidad de elementos de datos de alguna forma. La reescritura de la cabecera mostrarTemperaturas() usando la sintaxis varargs es como sigue:

// puede aceptar un arreglo de cualquier tamaño static void mostrarTemperaturas(double... temperatura) { // código que muestra temperaturas aquí }

En vez de usar una sintaxis de arreglo de corchetes ( double [] ) se emplea la sintaxis varargs (double ... ), que consiste de un tipo, tres puntos consecutivos y un parámetro. Esto indica que una cantidad variable, cero o más, de valores double serán mandados al método. El código dentro del método se mantiene igual para el parámetro varargs , temperatura en este caso, es convertido implícitamente en un arreglo dentro del método.

// temperatura convertida a un arreglo static void mostrarTemperaturas(double... temperatura) { // código dentro del método permanece igual System.out.println(); System.out.println("*** Temperaturas Ingresadas ***"); System.out.println(); for (int i=0; i<temperatura.length; ++i) { System.out.println("Día "+(i+1)+" "+temperatura[i]); } }

Mientras el código para el método permanece igual con varargs , permite ofrecer vías flexibles para llamar al método. Se puede mandar un arreglo como antes, pero también se pueden enviar valores individuales si se quiere. El programa MostrarTemperaturasConVarargs ilustra lo anterior.

76

public class MostrarTemperaturasConVarargs { public static void main(String[] args) { // declarar y crear arreglo con 5 lecturas double[] temperatura={7.5, 8.4, 9.3, 10.2, 11.1}; System.out.println("Enviando arreglo"); mostrarTemperaturas(temperatura); // llamada con arreglo System.out.println(); System.out.println("Enviando elementos individuales"); mostrarTemperaturas(7.5,8.4,9.3,10.2,11.1); // con 5 valores mostrarTemperaturas(12.0); // llamada con 1 solo valor mostrarTemperaturas(); // llamada sin valores } // método para mostrar temperaturas usando varargs static void mostrarTemperaturas(double... temperatura) { System.out.println(); System.out.println("*** Temperaturas ***"); System.out.println("Cantidad de temperaturas: "+ temperatura.length); // contar elementos // mostrar temperaturas for (int i=0; i<temperatura.length; ++i) { System.out.print(temperatura[i] + " "); } } }

Si se quieren mandar parámetros adicionales a un método al igual que el parámetro varargs , entonces el parámetro varargs deberá estar al final de la lista de parámetros. En el siguiente ejemplo se tienen dos parámetros, una colección de enteros vararg llamada paramVarargs , y un solo parámetro entero llamado param1 . La cabecera correcta del método es la siguiente:

static void algunMetodo(int param1, int ... paramVarargs) { // código para el método aquí }

6.6 Regresar un Arreglo

Un método también puede regresar un arreglo al igual que recibir arreglos como parámetros. Como ejemplo, se reconsidera el método ingresarTemperaturas() del programa LeerTemperaturas2 de la sección 6.4 otra vez. Este método acepta un arreglo como un parámetro y lo llena con valores de temperatura. Como este método llena el arreglo original mandado como un parámetro, este no necesita regresar un valor, el tipo de retorno es por lo tanto void .

static void ingresarTemperaturas( double[] temperatura ) { // código para llenar el parámetro, temperatura, aquí

77

}

Una alternativa podría ser no mandar un arreglo a este método pero, en vez de esto, crear un arreglo dentro del método y llenar este arreglo con valores. Este arreglo luego puede ser devuelto desde el método:

// el método no recibe parámetros pero regresa arreglo double static double[] ingresarTemperaturas() { Scanner teclado = new Scanner(System.in); // crear un arreglo dentro del método double[] temperatura = new double[7]; // llenar el arreglo creado en el método for (int i=0; i<temperatura.length; ++i) { System.out.print( "ingresar la temperatura máxima del día "+(i+1)+": "); temperatura[i]=teclado.nextDouble(); } // regresar el arreglo creado en el método return temperatura; }

En el tipo del método se usan corchetes vacíos para indicar que un arreglo será regresado desde el método:

static double[] ingresarTemperaturas() {

Una vez que el arreglo ha sido llenado este es devuelto con la sentencia return . Observar que solo se requiere el nombre para regresar un arreglo:

return temperatura;

El método main() también necesita ser ajustado porque el método ingresarTemperaturas() ha cambiado, no requiere un parámetro y además devuelve un arreglo. Se tiene que usar el valor del arreglo para poner el valor del arreglo original temperatura en el método main() :

// declarar el arreglo temperatura pero no se reserva memoria double[] temperatura; // el arreglo temperatura se asigna valor devuelto de la llamada temperatura = ingresarTemperaturas();

El programa completo, LeerTemperaturas3 , se muestra enseguida:  import java.util.Scanner; public class LeerTemperaturas3 { public static void main(String[] args) { double[] temperatura; temperatura = ingresarTemperaturas(); // versión nueva

78

mostrarTemperaturas(temperatura); } // método para ingresar temperaturas regresando un arreglo static double[] ingresarTemperaturas() { Scanner teclado = new Scanner(System.in); double[] temperatura = new double[7]; for (int i=0; i<temperatura.length; ++i) { System.out.print( "ingresar la temperatura máxima del día "+(i+1)+": "); temperatura[i]=teclado.nextDouble(); } return temperatura; } // método sin cambios static void mostrarTemperaturas( double[] temperatura ) { System.out.println(); System.out.println("*** Temperaturas Ingresadas ***"); System.out.println(); for (int i=0; i<temperatura.length; ++i) { System.out.println("Día "+(i+1)+" "+temperatura[i]); } } }

6.7 Ciclo for avanzado

En los ejemplos anteriores cuando se ha requerido procesar el arreglo entero un ciclo es requerido. Frecuentemente, este será un ciclo for . Con un ciclo for , el contador de ciclo es usado como índice del arreglo en el cuerpo del ciclo. En los ejemplos previos, el contador de ciclo no solo fue usado como un índice del arreglo pero también para mostrar información útil al usuario. Por ejemplo:

for (int i=0; i<temperatura.length; ++i) { System.out.println("Día "+(i+1)+" "+temperatura[i]); }

El contador del ciclo fue usado para determinar el número del día que será mostrado en la pantalla, al igual que el índice de un elemento del arreglo. Frecuentemente, cuando un ciclo for es requerido, el único uso del contador de ciclo es como un índice del arreglo para acceder todos los elementos del arreglo consecutivamente. Java tiene una versión avanzada del ciclo for para este propósito.

En vez de usar un contador, el ciclo for avanzado consiste de una variable que, en cada iteración, guarda los elementos consecutivos del arreglo. Por ejemplo,

79

para mostrar cada valor del arreglo temperatura , el ciclo for avanzado podría ser usado como sigue:

// ciclo for avanzado itera a través de los miembros del // arreglo sin necesidad de un índice for (double elemento : temperatura) { System.out.println(elemento); }

Se ha nombrado a cada miembro del arreglo sucesivo como un elemento . La cabecera es leída como "para cada elemento en el arreglo temperatura". También se le conoce como ciclo for each . Observar que el tipo del elemento tiene que ser indicado, este es del mismo tipo elemento individual dentro del arreglo.

La variable elemento sólo puede ser usada dentro del ciclo, no puede ser referida fuera del ciclo.

La solución con un ciclo for avanzado es más simple que con un ciclo for tradicional.

El ciclo for avanzado puede ser usado con parámetros varargs.

Se debe tener presente que el ciclo for avanzado no debe ser usado para modificar los elementos del arreglo. Modificar los elementos no causa un error de compilación, pero no es seguro, ya que puede causar que el programa se comporte de forma poco confiable. El ciclo for avanzado deberá usarse cuando:

● se desea acceder al arreglo entero; ● se desea leer los elementos en el arreglo, no modificarlos; ● no se requiere el índice del arreglo para procesamiento adicional.

6.8 Métodos Útiles para Arreglos

Solo la propiedad length se encuentra incorporada para un arreglo. Se desarrollarán algunos métodos para procesar un arreglo. Se usará un arreglo simple de enteros. Enseguida está el esbozo del programa que se escribirá para hacer diversas tareas:

 import java.util.Scanner; public class MetodosUtilesParaArreglos { public static void main(String[] args) { Scanner teclado = new Scanner(System.in); int[] arreglo; // declarar un arreglo de enteros // pedir al usuario el tamaño del arreglo System.out.print("¿Cuántos elementos se guardan? "); int tam = teclado.nextInt();

80

arreglo = new int[tam]; // crear arreglo de tamaño tam // métodos para procesar arreglo aquí } }

La segunda etapa de la creación del arreglo ha sido retrasada hasta que el usuario indique cuantos elementos serán guardados en el arreglo.

6.8.1 Máximo del Arreglo

Se desarrollará un método que permitirá encontrar el valor máximo en un arreglo. Por ejemplo, se podría tener una lista de puntuaciones y se quiere saber la puntuación más alta en la lista. Encontrar el valor máximo en un arreglo es una mejor aproximación que la que se hizo en el capítulo 5 , donde se revisó un método para encontrar el máximo de dos valores y otro para el máximo de tres valores. El método de arreglo podrá usarse con arreglos de cualquier tamaño. La aproximación que se usará es similar al método max() hecho en el capítulo 5 para encontrar el máximo de tres valores. Cuando se tiene un arreglo, resultado es inicializado al primer valor y luego el resto de los valores son comparados con resultado para determinar el más grande, para lo cual se usa un ciclo, en vez de muchas sentencias if . Enseguida el algoritmo:

ASIGNAR primer número A resultado REPETIR DESDE segundo elemento HASTA último elemento INICIO SI elemento actual > resultado INICIO ASIGNAR elemento actual A resultado FIN FIN REGRESAR resultado

El método necesitará que se le mande el arreglo donde se hará la búsqueda como un parámetro. Además el método regresará el máximo valor así que deberá tener un tipo de regreso entero.

static int max(int[] arreglo) { int resultado = arreglo[0]; // poner 1er valor en resultado // el ciclo va del 2º elemento al último for (int i=1; i<arreglo.length; ++i) { if (arreglo[i]>resultado) { resultado = arreglo[i]; // poner nuevo máximo en resultado } } return resultado; }

81

Observar que no se puede usar el ciclo for avanzado, porque se necesita iterar desde el segundo elemento del arreglo en vez de todos los elementos, y el ciclo for estándar proporciona el control requerido.

6.8.2 Suma del Arreglo

El siguiente método calcula el total de todos los valores en el arreglo. Este método podría ser útil, por ejemplo, si se tiene una lista de depósitos hechos en una cuenta bancaria y se desea conocer el total de los depósitos. Una forma simple de calcular la suma es manteniendo un total y sumando el valor de cada elemento del arreglo. Siempre que se tenga que obtener un total se debe inicializar el total a cero. El algoritmo es:

ASIGNAR cero A total REPETIR DESDE primer elemento HASTA último elemento INICIO ASIGNAR total+valor del elemento actual A total FIN REGRESAR total

El método necesitará que el arreglo sea enviado como un parámetro, y regresará un entero, el valor de la suma, siendo el siguiente:

static int suma(int[] arreglo) { int total = 0; for (int elementoActual : arreglo) { total = total + elementoActual; } return total; }

Se usa el ciclo for avanzado porque se necesita iterar a través de todos los elementos en el arreglo.

6.8.3 Pertenencia a un Arreglo

Es frecuentemente útil determinar si un arreglo contiene un valor particular o no. Por ejemplo, si una lista es usada para guardar una colección de matrículas de estudiantes, este método podría ser usado para revisar si una matrícula nueva ya existe antes de ser agregada a la lista. Una técnica simple es revisar cada dato en la lista uno por uno, usando un ciclo, para ver si el valor dado está presente. Si el valor es encontrado el ciclo es abandonado. Si el ciclo alcanza el final se sabe entonces que el dato no está presente. Enseguida el pseudocódigo:

REPETIR DESDE primer elemento HASTA último elemento en arreglo

82

INICIO SI elemento actual = dato a encontrar INICIO ABANDONAR ciclo y REGRESAR verdadero FIN FIN REGRESAR falso

En el algoritmo anterior el valor de false será regresado solo si el dato dado no es encontrado. Si el valor es encontrado, el ciclo termina sin alcanzar el final y el valor de true será regresado.

Enseguida el código para el método. El método debe recibir el arreglo donde se buscará y el dato buscado; además deberá regresar un valor boolean .

static boolean contiene( int[] arreglo, int valor ) { // se usa ciclo for avanzado for (int elementoActual : arreglo) { if (elementoActual == valor) { return true; // salir antes si valor es encontrado } } return false; // valor no presente }

6.8.4 Búsqueda en el Arreglo

Una de las tareas más comunes relacionada con una lista de valores es determinar la posición de un dato en la lista. Por ejemplo, se podría querer saber la posición de un trabajo en una cola de impresión.

Se puede realizar de manera similar al método contiene() , se necesitará usar un ciclo para examinar cada dato en el arreglo. Dentro del ciclo se revisa cada dato uno a la vez y se compara con el dato que se está buscando.

Se debe decidir qué hacer si se llega al final del ciclo, habiendo revisado todos los elementos en el arreglo, sin encontrar el dato que se estaba buscando. Este método necesita regresar un entero independientemente de que el dato haya sido encontrado o no. Cuando el dato no se encuentra se debe regresar un valor que nunca sea interpretado como un índice de arreglo. Como los índices de arreglo siempre serán números positivos se puede regresar un número negativo, como -1 , para indicar que una posición válida no ha sido encontrada.

El pseudocódigo es:

REPETIR DESDE primer elemento HASTA último elemento en arreglo

83

INICIO SI elemento actual = dato a encontrar INICIO ABANDONAR ciclo y REGRESAR índice actual FIN FIN REGRESAR -1

Esta aproximación es referida frecuentemente como una búsqueda lineal . Enseguida el código para este método. El método debe recibir el arreglo donde se buscará y el dato buscado; además deberá regresar un valor entero.

static int buscar( int[] arreglo, int valor ) { // NO se puede usar ciclo for avanzado for (int i=0; i<arreglo.length; ++i) { if (arreglo[i] == valor) { return i; // salir antes con el índice de arreglo } } return -1; // indica que el valor no está en la lista }

El ciclo for avanzado no puede ser usado porque se requiere que el método regrese el índice arreglo del dato que se está buscando. El índice es dado por el contador de ciclo en el ciclo for estándar.

6.8.5 Programa Integrador

El programa completo para manipular un arreglo es presentado enseguida. Los métodos del arreglo son usados a través de un menú. Se incluyeron métodos adicionales para ingresar y mostrar el arreglo:

import java.util.Scanner; // programa manejado por menú para probar métodos útiles para arreglos public class MetodosUtilesParaArreglos { public static void main (String[] args) { char opcion; Scanner teclado = new Scanner(System.in); int[] arreglo; // declarar un arreglo de enteros System.out.print("¿Cuántos elementos se guardarán? "); int tam = teclado.nextInt(); // tamaño del arreglo arreglo = new int [tam]; // menú

84

do { System.out.println(); System.out.println("[1] Ingresar valores"); System.out.println("[2] Encontrar máximo"); System.out.println("[3] Calcular suma"); System.out.println("[4] Revisar pertenencia"); System.out.println("[5] Búsqueda en el arreglo"); System.out.println("[6] Mostrar valores"); System.out.println("[7] Salir"); System.out.print("Ingresar opción [1-7]: "); opcion = teclado.next().charAt(0); System.out.println(); // Se procesa opcion llamando métodos adicionales switch(opcion) { case '1': llenarArreglo(arreglo); break; case '2': int max = max(arreglo); System.out.println("Valor máximo del arreglo = " + max); break; case '3': int total = suma(arreglo); System.out.println("Suma de los valores del arreglo = " + total); break; case '4': System.out.print("Ingresar valor a encontrar: "); int valor = teclado.nextInt(); boolean encontrado = contiene(arreglo, valor); if (encontrado) { System.out.println(valor + " está en el arreglo"); } else { System.out.println(valor + " no está en el arreglo"); } break; case '5': System.out.print("Ingresar valor a encontrar: "); int dato = teclado.nextInt(); int indice = buscar(arreglo, dato); if (indice == -1) { // indica valor no encontrado

85

System.out.println ("Este valor no está en el arreglo"); } else { System.out.println ("Está en el arreglo con índice " + indice); } break; case '6': System.out.println("Valores del arreglo"); mostrarArreglo(arreglo); break; } } while (opcion != '7'); System.out.println("Adiós"); } // métodos adicionales // llenar un arreglo con valores static void llenarArreglo(int[] arreglo) { Scanner teclado = new Scanner (System.in); for (int i = 0; i < arreglo.length; i++) { System.out.print("Ingresar valor "); arreglo[i] = teclado.nextInt(); } } // regresa el valor máximo del arreglo static int max (int[] arreglo) { int resultado = arreglo[0]; // poner 1er valor en resultado // el ciclo va del 2º elemento al último for (int i=1; i<arreglo.length; ++i) { if (arreglo[i]>resultado) { resultado = arreglo[i]; // poner nuevo máximo en resultado } } return resultado; } // regresa el total de todos los valores guardados en el arreglo static int suma(int[] arreglo)

86

{ int total = 0; for (int elementoActual : arreglo) { total = total + elementoActual; } return total; } // revisar si un dato dado está contenido en el arreglo static boolean contiene(int[] arreglo, int valor) { // se usa ciclo for avanzado for (int elementoActual : arreglo) { if (elementoActual == valor) { return true; // salir antes si valor es encontrado } } return false; // valor no presente } // regresar la posición de un dato dentro del arreglo // o -1 si el valor no está presente en el arreglo static int buscar(int[] arreglo, int valor) { // NO se puede usar ciclo for avanzado for (int i=0; i<arreglo.length; ++i) { if (arreglo[i] == valor) { return i; // salir antes con el índice de arreglo } } return -1; // indica que el valor no está en la lista } // mostrar los valores del arreglo en pantalla static void mostrarArreglo(int[] arreglo) { System.out.println(); // se usa ciclo for estándar for (int i = 0; i < arreglo.length; i++) { System.out.println("arreglo[" + i + "] = " + arreglo[i]); } } }

87

6.9 Arreglos Multidimensionales

Al inicio del capítulo se usó un arreglo para guardar siete lecturas de temperatura, una para cada día de la semana. Con el arreglo se usan ciclos cuando se procesan los valores, en vez de tener que repetir el código siete veces.

Ahora considerar la situación donde las temperaturas fueran requeridas para las cuatro semanas de un mes. Se podrían crear cuatro arreglos como sigue:

double[] temperatura1 = new double[7]; // semana 1 de temperaturas double[] temperatura2 = new double[7]; // semana 2 de temperaturas double[] temperatura3 = new double[7]; // semana 3 de temperaturas double[] temperatura4 = new double[7]; // semana 4 de temperaturas

Para ingresar las temperaturas para estos cuatro arreglos la solución sería escribir cuatro ciclos, uno para procesar cada arreglo. Java tiene una aproximación más simple para todo lo anterior, crear un arreglo multidimensional .

Un arreglo multidimensional es un arreglo que tiene más de un índice. Los arreglos vistos anteriormente tienen un solo índice, por lo tanto son frecuentemente referidos como arreglos unidimensionales . Un arreglo podría tener tantos índices como sea necesario, hasta el límite de la memoria de la máquina. Para este ejemplo particular se necesitan dos índices para acceder a una lectura de temperatura, uno para el número de la semana y el otro para el número del día. Si se requieren temperaturas para cada mes del año se podrían requerir tres índices, uno para el número del mes, uno para el número de la semana y uno para el número del día y así sucesivamente. La cantidad de dimensiones de un arreglo tiene que corresponder a la cantidad de índices requeridos. Un arreglo con dos índices es llamado un arreglo bidimensional .

6.9.1 Creación de un arreglo bidimensional

Para crear un arreglo bidimensional (2D) se debe dar el tamaño de ambos índices. En el siguiente ejemplo se tienen cuatro grupos de siete temperaturas:

double[][] temperatura; // declara un arreglo 2D temperatura = new double[4][7]; // memoria para arreglo 4 x 7

Se observa que la creación es muy similar a la creación de un arreglo unidimensional excepto que se tienen dos pares de corchetes para un arreglo bidimensional. Para dimensiones mayores se pueden tener más pares de corchetes, tres pares para tres dimensiones, etc. En el ejemplo, se ha escogido usar el primer índice como representante de la cantidad de semanas (4) y el segundo representa

88

la cantidad de días (7), también se podría escoger de forma invertida, primer índice para cantidad de días y el segundo para la cantidad de semanas.

Mientras un arreglo unidimensional se podría pensar como una lista, se podría visualizar un arreglo bidimensional como una tabla con renglones y columnas, sin embargo en Java es implementado como un arreglo de arreglos. El nombre de cada dato en un arreglo bidimensional es el nombre del arreglo y el índice del renglón y la columna, ver la siguiente figura:

Observar que ambos índices inician en cero, así que la temperatura para la tercera semana del mes y el sexto día de esa semana está dado por temperatura[2][5] .

6.9.2 Inicialización de arreglos bidimensionales

Al igual que con los arreglos unidimensionales, es posible declarar e inicializar arreglos multidimensionales con una colección de todos los valores en una sola instrucción. En un arreglo unidimensional se separan los valores con comas y se encierran entre llaves. Una construcción similar se usa en arreglos multidimensionales. Con un arreglo bidimensional los conjuntos de valores en cada renglón son encerrados entre llaves, luego los renglones son a su vez encerrados por llaves y separados por comas. Por ejemplo, un arreglo de dos dimensiones de enteros se inicializa como sigue:

// crea arreglo 2D con dos renglones y cuatro columnas int[][] arreglo2D = { {11, 13, 15, 17}, {-19,-21,-23,-25} };

El mismo arreglo también puede ser creado con el siguiente grupo de instrucciones:

int[][] arreglo2D = new int[2][4];

89

// inicializar primer renglón del arreglo arreglo2D[0][0] = 11; arreglo2D[0][1] = 13; arreglo2D[0][2] = 15; arreglo2D[0][3] = 17; // inicializar segundo renglón del arreglo arreglo2D[1][0] = -19; arreglo2D[1][1] = -21; arreglo2D[1][2] = -23; arreglo2D[1][3] = -25;

Generalmente un arreglo bidimensional primeramente se crea y luego los valores son agregados individualmente al arreglo cuando el programa se está ejecutando.

6.9.3 Procesamiento de arreglos bidimensionales

Con un arreglo bidimensional, un par de ciclos anidados es usado generalmente para procesar cada elemento, un ciclo por cada índice del arreglo. Considerando nuevamente el arreglo bidimensional de valores de temperatura se usará un par de ciclos anidados, uno para controlar el número de la semana y el otro para el número de día. En el siguiente fragmento de código se han iniciado los contadores en uno para el día y la semana, y luego se ha quitado uno a los contadores para obtener los índices apropiados para el arreglo:

// crear objeto Scanner para entrada del usuario Scanner teclado = new Scanner(System.in); // ciclo externo controla el renglón semana for (int semana=1; semana<=temperatura.length; ++semana) { // ciclo interno controla la columna día for (int dia=1; dia<=temperatura[semana-1].length; ++dia) { System.out.print("ingresar temperatura para semana " + semana + " y día " + dia + ": "); // como índices de arreglo inician en cero, // se quita uno a los contadores de los ciclos temperatura[semana-1][dia-1] = teclado.nextDouble(); } }

En un arreglo bidimensional, el atributo length regresa el tamaño del primer índice, esto es lo que se ha visualizado como la cantidad de renglones:

// el atributo length regresa 4, cantidad de renglones for (int semana=1; semana<=temperatura. length ; ++semana) {

90

La cantidad de columnas se determina obteniendo el tamaño de un renglón particular o de cada renglón. Se escogió el tamaño de cada renglón:

// el tamaño de un renglón regresa 7, cantidad de columnas for (int dia=1; dia<=temperatura [semana-1] . length ; ++dia) {

Se ha usado un par de ciclos anidados porque se desea procesar el arreglo bidimensional completo. Sin embargo, si solo se quiere procesar una parte del arreglo, como un renglón o una columna, entonces un solo ciclo sería suficiente.

6.9.4 Programa TemperaturasMensuales

El siguiente programa proporciona al usuario un menú de opciones. La primera opción permite al usuario ingresar las lecturas para cuatro semanas de un mes. La segunda opción permite mostrar todas las lecturas. La tercera opción permite mostrar las lecturas de una semana particular ingresada. La cuarta opción muestra las lecturas de un día ingresado de la semana para cada semana. La quinta opción sale de la aplicación.

import java.util.Scanner; public class TemperaturasMensuales { public static void main(String[] args) { Scanner teclado = new Scanner (System.in); char opcion; double[][] temperatura = new double[4][7]; // crear arreglo 2D // ofrecer menú do { System.out.println(); System.out.println("[1] Ingresar temperaturas"); System.out.println("[2] Mostrar todo"); System.out.println("[3] Mostrar una semana"); System.out.println("[4] Mostrar un día de cada semana"); System.out.println("[5] Salir"); System.out.print("Ingresar opción [1-5]: "); opcion = teclado.next().charAt(0); System.out.println(); // procesar opcion llamando métodos adicionales switch(opcion) { case '1': ingresarTemps(temperatura); break; case '2': mostrarTodasTemps(temperatura); break; case '3': mostrarSemana(temperatura); break; case '4': mostrarDias(temperatura); break;

91

case '5': System.out.println ("Adiós"); break; default: System.out.println("ERROR: ¡opciones 1 a 5 solamente!"); } } while (opcion != '5'); } // método para ingresar temperaturas en arreglo 2D, ocupa ciclo anidado static void ingresarTemps(double[][] temperatura) { Scanner teclado = new Scanner (System.in); / / ciclo externo controla el renglón semana for (int semana = 1; semana <= temperatura.length; ++semana) { // ciclo interno controla la columna día for (int dia = 1; dia <= temperatura[semana-1].length; ++dia) { System.out.print("ingresar temperatura para semana " + semana + " y día " + dia + ": "); temperatura[semana-1][dia-1] = teclado.nextDouble(); } } } // método para mostrar todas las temperaturas en el arreglo 2D, // requiere ciclo anidado static void mostrarTodasTemps(double[][] temperatura) { System.out.println(); System.out.println("***TEMPERATURAS INGRESADAS***"); // ciclo externo controla el renglón semana for (int semana = 1; semana <= temperatura.length; ++semana) { // ciclo interno controla la columna día for (int dia = 1; dia <= temperatura[semana-1].length; ++dia) { System.out.println("semana " +semana+" dia "+dia+": "+ temperatura[semana-1][dia-1]); } } } // método para mostrar temperaturas para una sola semana // requiere un solo ciclo static void mostrarSemana(double[][] temperatura) { Scanner teclado = new Scanner (System.in); int semana; // ingresar número de semana System.out.print("Ingresar número de semana (1-4): "); semana = teclado.nextInt(); // validación de entrada: número de semana deberá estar entre 1 y 4 while (semana<1 || semana > 4) { System.out.println("¡Número de semana no válido!"); System.out.print("Ingresar nuevamente (1-4 solamente): "); semana = teclado.nextInt(); } // mostrar temperaturas para semana dada System.out.println(); System.out.println("***TEMPERATURAS INGRESADAS PARA SEMANA "+ semana+"***");

92

System.out.println(); // número de semana está fijo entonces solo se requiere un ciclo para // procesar los días for (int dia = 1; dia <= temperatura[semana-1].length; ++dia) { System.out.println("semana " +semana+" día "+dia+": "+ temperatura[semana-1][dia-1]); } } // método para mostrar temperaturas para un sólo día de cada semana // requiere un solo ciclo static void mostrarDias(double[][] temperatura) { Scanner teclado = new Scanner (System.in); int dia; // ingresar día de la semana System.out.print("Ingresar día de la semana (1-7): "); dia = teclado.nextInt(); // validación de entrada: número del día deberá estar entre 1 y 7 while (dia<1 || dia > 7) { System.out.println("¡Número de día no válido!"); System.out.print("Ingresar nuevamente (1-7 solamente): "); dia = teclado.nextInt(); } // mostrar temperaturas para un día de cada semana System.out.println(); System.out.println("***TEMPERATURAS INGRESADAS PARA DÍA "+dia+"***"); System.out.println(); // número de dia está fijo entonces sólo se requiere un ciclo para // procesar los número de semana for (int semana = 1; semana <= temperatura.length; ++semana) { System.out.println("semana "+semana+" día "+dia+": " + temperatura[semana-1][dia-1]); } } }

Observar que cuando solo se ocupa mostrar una de las dimensiones del arreglo no se ocupa un par de ciclos anidados. Por ejemplo, el método mostrarSemana() le permite al usuario escoger un número de semana particular para que solo las temperaturas para esa semana sean mostradas, por lo que solo se requiere un solo ciclo para iterar a través de los días de la semana, ya que el número de la semana está fijo por el valor dado por el usuario.

6.10 Arreglos Irregulares

En los ejemplos de los arreglos bidimensionales discutidos en la sección previa, cada renglón del arreglo tenía la misma cantidad de columnas. Por ejemplo, cada renglón del arreglo bidimensional temperatura tenía 7 columnas. Frecuentemente este será el caso. Sin embargo, ocasionalmente, será necesario que los renglones tengan una cantidad variable de columnas. Un arreglo bidimensional con una cantidad variable de columnas es llamado un arreglo irregular . Por ejemplo,

93

enseguida se muestra como se podría declarar e inicializar un arreglo bidimensional de caracteres con una cantidad variable de columnas para cada renglón:

// crear arreglo de bidimensional con número variable de columnas char[][] animales = { {'C','O','N','E','J','O'}, // 6 columnas {'O','S','O'}, // 3 columnas {'F','O','C','A'}, // 4 columnas };

La figura siguiente ilustra el arreglo creado después de esta inicialización.

Para declarar tal arreglo sin inicialización, se necesita indicar primero la cantidad de renglones primero y dejar la cantidad de columnas sin indicar. En el siguiente ejemplo se tienen tres renglones:

// cantidad de columnas sin indicar char[][] animales = new char[3][];

Luego, para cada renglón se fija el tamaño apropiado de la columna. En el siguiente ejemplo el primer renglón tiene seis columnas, el segundo renglón tiene tres columnas y el último renglón, cuatro columnas:

animales[0] = new char[6]; // cantidad de columnas, 1er renglón animales[1] = new char[3]; // cantidad de columnas, 2º renglón animales[2] = new char[4]; // cantidad de columnas, 3er renglón

Con estas instrucciones se observa que Java implementa un arreglo bidimensional como un arreglo de arreglos. Cuando se procesan arreglos irregulares se debe tener cuidado de no usar una cantidad fija para controlar la cantidad de columnas. La cantidad actual de columnas de un renglón se obtiene con el atributo length del renglón. Por ejemplo las siguientes instrucciones mostrarían la cantidad de columnas para cada renglón:

System.out.println(animales[0].length); // muestra 6 System.out.println(animales[1].length); // muestra 3 System.out.println(animales[2].length); // muestra 4

94

El programa siguiente usa un par de ciclos anidados para mostrar el arreglo animales :

public class ArregloIrregular { public static void main(String[] args) { // crear e inicializar arreglo irregular char[][] animales = { {'C','O','N','E','J','O'}, // 6 cols. {'O','S','O'}, // 3 cols. {'F','O','C','A'}, // 4 cols. }; // cantidad de renglones fijo for (int ren=0; ren<animales.length; ++ren) { // cantidad de columnas variable for (int col=0; col<animales[ren].length; ++col) { System.out.print(animales[ren][col]); } System.out.println(); } } }

6.11 Preguntas

1) Considerar la siguiente creación explícita de un arreglo:

int[] unArreglo={2,5,1,9,11};

a) ¿Cuál es el valor de unArreglo.length ? b) ¿Cuál es el valor de unArreglo[2] ? c) ¿Qué sucede si se intenta acceder unArreglo[6] ? d) Crear el arreglo equivalente usando el operador new y luego asigna el

valor de cada elemento individualmente. e) Escribir un ciclo for estándar que doble el valor de cada elemento en

unArreglo . f) Indicar porque para el inciso anterior no es apropiado usar un ciclo for

avanzado. g) Usar un ciclo for avanzado para mostrar los valores dentro del

arreglo. h) Modificar el ciclo for avanzado anterior para mostrar solo los números

mayores que dos. 2) Suponer que un arreglo ha sido declarado en el método main() como sigue:

int[] estudiantes;

95

Este arreglo será usado para guardar una lista de calificaciones de estudiantes. Para cada uno de los siguientes métodos, escribir el código para el método dado y la instrucción en el método main() para llamar a este método:

a) entrarCalificaciones() pide al usuario ingresar las calificaciones como enteros, las guarda en un arreglo y devuelve este arreglo.

b) incrementarCalificaciones() acepta un arreglo de calificaciones e incrementa cada calificación en cinco.

c) todosHanPasado() acepta un arreglo de calificaciones y regresa true si todas las marcas son mayores que o igual a 40, y false de otra forma.

3) En relación con la capacidad varargs de Java a) Describir esta capacidad. b) Reescribir el método contiene() para hacer uso de esta capacidad.

static boolean contiene( int[] arreglo, int valor ) { // se usa ciclo for avanzado for (int elementoActual : arreglo) { if (elementoActual == valor) { return true; // salir antes si valor es encontrado } } return false; // valor no presente }

c) Dar ejemplos de formas diferentes en las cuales se podría llamar el método contiene() reescrito con esta capacidad.

4) Considerar la siguiente declaración de arreglo, para guardar una colección de calificaciones.

char[][] calificaciones = new char[4][20];

Las calificaciones corresponden a cuatro grupos de tutorías, y cada grupo de tutoría consiste de 20 estudiantes.

a) ¿Cuántas dimensiones tiene el arreglo? b) ¿Qué valor tiene calificaciones.length ? c) ¿Qué valor tiene calificaciones[3].length ? d) Escribir la instrucción para registrar la calificación 'B ' para el segundo

estudiante en el tercer grupo de tutoría.

96

5) Escribir instrucciones para crear un arreglo irregular 2D de enteros, llamado triangulo , con la forma dada enseguida. También, escribir un fragmento de

código para encontrar el número más grande en el arreglo triangulo .

Página del curso: http://computo.fismat.umich.mx/computacion/computacion1

Profesor: Héctor Tejeda Villela

Correo electrónico: htejeda@umich.mx

97