PONTIFICIA UNIVERSIDAD CATLICA DE CHILE ESCUELA DE INGENIERA DEPARTAMENTO DE CIENCIA DE LA COMPUTACIN IIC 1102 INTRODUCCIN A LA PROGRAMACIN Profesor: Rodrigo

Sandoval U.

Captulo VII Arreglos y Enumeraciones en C#

1 ARREGLOS ......................................................................................................................................................... 1 1.1 DECLARACIN DE ARREGLOS UNIDIMENSIONALES ........................................................................................ 2 1.2 USO DE ARREGLOS UNIDIMENSIONALES ......................................................................................................... 3 1.2.1 Funciones ms comunes con arreglos.................................................................................................... 4 1.2.2 Foreach para el manejo de arreglos...................................................................................................... 5 1.2.3 Ejemplos de declaracin y uso de arreglos............................................................................................ 6 1.2.4 Ejemplo: Clculo de mnimo, mximo y promedio de una lista de notas de estudiantes....................... 7 1.2.5 Ejemplo: Programa de simulacin de conjuntos con arreglos .............................................................. 9 2 ARREGLOS MULTIDIMENSIONALES ....................................................................................................... 13 2.1 DECLARACIN DE MATRICES........................................................................................................................ 13 2.2 USO DE MATRICES ........................................................................................................................................ 14 2.2.1 Obteniendo Dimensiones de una Matriz .............................................................................................. 14 2.2.2 Ejemplos de uso de Matrices................................................................................................................ 14 2.2.3 Foreach en matrices............................................................................................................................. 14 2.2.4 Ejemplo: Clculo de las notas finales de un curso (mnimo, mximo, promedio) ............................... 15 2.2.5 Ejemplo: Multiplicacin de Matrices Cuadradas ................................................................................ 18 3 ENUMERACIONES .......................................................................................................................................... 23

Material preparado por Rodrigo Sandoval U en Marzo 2004, basado en los apuntes de clase del curso IIC1102, ao 2003, de M. Nussbaum, Marcos Seplveda, et.al

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

1 Arreglos
Los arreglos son estructuras de datos complejas (en el sentido de que no son atmicas) que agrupan datos de un mismo tipo en particular, llamado el tipo base del arreglo. El tipo base de un arreglo puede ser cualquiera de los tipos bsicos de C#, o incluso algunos tipos complejos como las clases. Un arreglo es tambin ejemplo de un modelo. Un arreglo puede considerarse como ejemplo de una variable compuesta capaz de almacenar uno o ms datos al mismo tiempo.

La sintaxis del lenguaje permite referirse a cada uno de los elementos que constituyen el arreglo empleando ndices. Esto es posible pues los elementos del arreglo estn numerados en forma jerrquica y consecutiva, empezando en 0 en cada dimensin. El siguiente grfico ilustra un ejemplo de un arreglo llamado numeros, cuya posicin 0 almacena el valor 10, la posicin 1 el valor de 21, etc. Este arreglo en total almacena n+1 elementos. El valor de n, depende de la memoria que pueda tener el computador y el tipo de elementos que se almacenen en el arreglo.

IIC 1102

Pgina: 1

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Los arreglos, al igual que el resto de las variables se identifican con un nombre. Al emplear ese nombre, se hace referencia a la estructura de datos como un todo, es decir, con todos sus elementos. El lenguaje interpreta dicho nombre como un puntero. Cuando se utiliza el nombre del arreglo en forma indexada, es decir, combinado con ndices, se hace referencia a un elemento particular, del tipo base, dentro de la estructura compleja. Importante: El lenguaje C# no controla la validez de los ndices que se emplean para referenciar un arreglo. Esto quiere decir que es posible cometer errores graves y difciles de detectar en este sentido. Ms adelante se presenta un ejemplo en este sentido.

1.1

Declaracin de Arreglos Unidimensionales

Los arreglos, al igual que las dems variables deben declararse antes de poder utilizarlas, y cumplen con las mismas reglas de alcance y vida. Los arreglos de una sola dimensin reciben tambin el nombre de vectores. La sintaxis de la declaracin de un arreglo unidimensional es la siguiente: <tipo-base>[] <identificador>; Observaciones: El <tipo-base> puede ser cualquiera de los tipos bsicos del lenguaje, o incluso algunos complejos como estructuras. El <identificador> es el nombre que distinguir el arreglo. Los corchetes [] son obligatorios y denotan que el identificador descrito, del tipo-base indicado, es un arreglo (lista de elementos del tipo base). En esta declaracin NO se define el tamao que tendr el arreglo (aunque se puede determinar las dimensiones, lo que se ver ms adelante).

El tamao del arreglo se determina en una segunda declaracin, que puede ir en la siguiente lnea, como se muestra a continuacin.

<identificador> = new <tipo-base> [<NumElementos>]

En esta declaracin, se dimensiona el arreglo con una cantidad determinada de elementos, todos correspondientes a tipo-base.

Es posible hacer la declaracin del arreglo y su dimensionamiento en una misma sentencia: <tipo-base>[] <identificador> = new <tipo-base>[<NumElementos>]

Adicionalmente es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en una sola declaracin: <tipo-base>[] <identificador> = {valor1, valor2, ..., valorN}; Esta ltima declaracin implcitamente dimensiona el arreglo para almacenar los N elementos descritos, por lo que no se requiere dimensionarlo aparte. Es decir: Con los valores indicados entre llaves {} se inicializarn los elementos del arreglo. Los valores deben ser del <tipo-base> del arreglo.

IIC 1102

Pgina: 2

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Tambin es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en una sola declaracin, pero slo indicando un subconjunto de los valores que el arreglo puede guardar: <tipo-base>[] <identificador> = new <tipo-base>[N] {valor1, ..., valorM}; ... donde M<N, y N debe ser una expresin constante, como por ejemplo 10. Es factible hacer una declaracin donde M>N, en cuyo caso, el real dimensionamiento del arreglo se regir por M. Algunos ejemplos:

// Arreglo para 10 enteros int [] numeros; numeros = new int[10]; // Arreglo para 10 enteros int [] numeros = new int[10]; // Arreglo para 10 enteros int [] numeros = { 1, 1, 1, 2, 3, 5, 2, 5, 3, 4 };

1.2

Uso de Arreglos Unidimensionales

Los elementos de un arreglo son variables del tipo base del vector, por lo que se utilizan de la misma manera en expresiones y dems instrucciones, como la asignacin. Por ejemplo, para asignar un valor a un elemento de un arreglo basta con escribir:

<arreglo>[indice] = <expresion>;
donde <arreglo> es el nombre de la variable e indice hace referencia a la posicin del elemento al que se le quiere asignar el <expresion>. La referencia de valores en un arreglo, se indexa desde el 0 al N-1. Importante: Puesto que los arreglos son estructuras complejas (es decir, no bsicas), no es posible asignar un arreglo a otro mediante una simple asignacin (=). Para hacer esto es necesario escribir un ciclo y asignar elemento a elemento. Como se mencion anteriormente, el lenguaje C# no controla la validez de los ndices que se emplean para referenciar un arreglo. Esto quiere decir que es posible cometer errores muy difciles de detectar en este sentido. Es necesario prestar especial inters a los valores que toman los ndices para evitar estos problemas. Por ejemplo, la siguiente porcin de cdigo compila sin problemas (es decir, sin errores sintcticos), pero probablemente produzca un error en tiempo de ejecucin al referenciarse posiciones inexistentes del arreglo.

// Las posiciones con ndices del 10 al 19 son invlidas. int[] arreglo = { 1,1,1,1,1,1,1,1,1,1 }; int i; for (i=0; i<20; i++) arreglo[i] = 0; // Error para i >= 10 // 10 elementos

IIC 1102

Pgina: 3

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Tambin es comn cometer estos errores olvidando que las posiciones de los arreglos estn numeradas a partir del ndice cero. Es decir, en un arreglo de tamao N las posiciones estn numeradas de 0 a N-1.

1.2.1 Funciones ms comunes con arreglos

En C#, los arreglos se representan con un tipo especfico, y por ello cuentan con sus propios atributos y mtodos especficos. Por ejemplo, para obtener el largo (la cantidad de elementos dimensionados) de un arreglo, o para ordenarlo. El Largo de un Arreglo En el caso de los arreglos unidimensionales, el tamao o cantidad de elementos se obtiene con la propiedad Length. int [] numeros = { 1,2,3,4,5,6 } Console.WriteLine(Largo: {0}, numeros.Length);

Ordenamiento de un Arreglo En el caso de los arreglos que sean de uno de los tipos predefinidos (int, float, char, etc.), es factible ordenarlos en forma creciente, aprovechando el mtodo bsico Sort() de la clase Array: int [] numeros = { 4,5,2,3,1,6 } Array.Sort(numeros); // 1,2,3,4,5,6

Revertir el Orden de un Arreglo En el mismo caso en que se pueda ordenar un arreglo, se puede reordenar exactamente al revs de cmo est, aprovechando el mtodo bsico Reverse() de la clase Array: int [] numeros = { 1,2,3,4,5,6 } Array.Reverse(numeros); // 6,5,4,3,2,1

Ejemplo de Manipulacin de Arreglos

using System; class Arreglo { int[] numeros; public Arreglo(int [] arreglo) { numeros = new int[arreglo.Length]; for (int i=0; i<numeros.Length; i++) numeros[i] = arreglo[i]; } public void Ordenar() { Array.Sort(numeros); } public void Reordenar() { Array.Reverse(numeros); } public void Imprimir() { foreach(int i in numeros) Console.Write("{0} ",i); Console.WriteLine(); }

IIC 1102

Pgina: 4

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

} class MainApp { static void Main() { int[] numeros = { 2,5,6,1,3,4 }; Arreglo a = new Arreglo(numeros); a.Imprimir(); a.Ordenar(); a.Imprimir(); a.Reordenar(); a.Imprimir(); Console.ReadLine(); } }

1.2.2 Foreach para el manejo de arreglos

Existe esta sentencia de control de flujo, especialmente diseada para este tipo de estructuras, donde se manejan listas de elementos, todos del mismo tipo. Foreach depende de la definicin previa de un arreglo de elementos del mismo tipo, los cuales puede recorrer individualmente sin conocer el tamao explcitamente (como se requiere en otras instrucciones, por ejemplo en el for). La sintaxis de uso es:

foreach ( <tipo> <variable> in <arreglo> ) { <instrucciones> }

Donde: <tipo> es el tipo bsico de los elementos contenidos en el arreglo. <arreglo> es el arreglo de elementos a revisar. <variable> es un identificador de una variable local del foreach() que se usar para ver un elemento del arreglo en cada iteracin.

Ejemplo: using System; class MainClass { public static void Main() { int impares = 0, pares = 0; int[] arr = new int [] {0,1,2,5,7,8,11}; foreach (int i in arr) { if (i%2 == 0) pares++; else impares++; } Console.WriteLine("Hay {0} impares y {1} pares.", impares, pares);

IIC 1102

Pgina: 5

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Console.ReadLine(); } } A continuacin se incluyen ejemplos, tanto de declaracin y uso de arreglos, como del uso de foreach.

1.2.3 Ejemplos de declaracin y uso de arreglos

En todos los casos, A es el nombre de la variable declarada: 1. Declaracin de un arreglo de 50 enteros: int[] A = new int[50]; Declaracin de un arreglo de 100 caracteres: char[] A = new char[100]; Declaracin e inicializacin de un arreglo de 10 enteros: int[] A = { 2, 5, 8, 100, 1, 2, 100, 5, 5, 5 } Inicializacin parcial: El resto se inicializa en cero: int[] A = new int[100] { 25, 5, 100, 25, 5 } Declaracin e inicializacin de un arreglo de 10 caracteres: char[] A = { 'a', 'z', 'E', 'e', 65, '\65', '@', 'U', '*', '\n' } Asignando un valor a la sexta posicin de un arreglo de enteros: A[5] = 200; Imprimiendo un arreglo de 100 enteros mediante un ciclo for: int i; for (i=0; i<100; i++) Console.Write("{0} ", A[i]); Imprimiendo un arreglo de 100 enteros mediante un ciclo foreach: foreach (int i in A) Console.Write("{0} ", i);

2.

3.

4.

5.

6.

7.

8.

9. Leyendo del usuario el contenido de un arreglo de 20 enteros, mediante un ciclo for: int i; for (i=0; i<20; i++) A[i] = int.Parse(Console.ReadLine()); 10. Una funcin que recibe un arreglo de enteros como argumento y calcula el promedio: int promedio(int[] A) { int prom = 0; foreach( int i in A ) prom = prom + i; return(prom/A.Length); } 11. Llamando una funcin que recibe un arreglo de enteros como parmetro: int prom; int[] A; ... prom = promedio(A);

IIC 1102

Pgina: 6

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

1.2.4 Ejemplo: Clculo de mnimo, mximo y promedio de una lista de notas de estudiantes
Se desea calcular el promedio, mnimo y mximo de una lista de notas correspondientes a un curso. Se recibir el nmero de alumnos y la nota correspondiente a c/u, y se entregan los resultados en la pantalla. 1. Definicin del problema 1.1 Conceptualizacin: El problema consiste en calcular el promedio, mnimo y mximo de una lista de notas de un curso. Cada alumno tiene una nota en el curso. Se supone que el usuario conoce a priori la cantidad de alumnos del curso y que entregar los datos en forma correcta. 1.2 Objetivo: El objetivo es obtener el promedio, el mximo, y el mnimo de las notas del curso. 1.3 Elementos involucrados: Los nicos elementos involucrados son las notas, la cantidad de alumnos, el promedio, el mnimo y el mximo. Como elemento activo, el usuario que conoce las notas en detalle. 2. Conceptualizacin de la solucin 2.1 Entidades: El Curso es la nica entidad relevante, la cual se conceptualiza como la agrupacin de notas correspondientes a los alumnos. 2.2 Clases: La clase Curso, ser la representacin de las notas de un curso cuyo promedio se quiere calcular. Esta clase se compone de los siguientes: Atributos de la Clase Curso notas: un arreglo que almacenar todas las notas (en forma de nmero real, con decimales) promedio (PROM): el valor resultante del promedio de notas del curso minimo (MIN): el valor de la mnima de todas las notas del curso maximo (MAX): el valor de la mnima de todas las notas del curso Mtodos de la Clase Curso Curso: (constructor) obtiene los valores de todas las notas ingresadas por el usuario. El algoritmo de este mtodo es: 1. Obtener la cantidad de alumnos: N 2. Iterar para cada uno de los N alumnos 2.1 Obtener la nota del alumno Calcular: recorre la lista de notas, calculando el mnimo, el mximo y el promedio de estos valores. El algoritmo de este mtodo es: 0. Se declara una variable local: SUMA 1. Inicialmente la suma de notas, SUMA, es 0, el mximo, MAX, es 1, y el mnimo, MIN, es 7 2. Iterar para cada para cada uno de los N alumnos 2.1 Agregar a SUMA la nota del alumno 2.2 Si la nota del alumno es mayor que MAX 2.2.1 MAX es ahora la nota del alumno 2.3 Si la nota del alumno es menor que MIN 2.3.1 MIN es ahora la nota del alumno 3. El promedio, PROM es SUMA dividido por N Mostrar: muestra en pantalla los valores de promedio, mnimo y mximo

IIC 1102

Pgina: 7

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

2. 3 Instancias: La nica instancia requerida es notas1, de la clase Curso.

3. Especificacin del Algoritmo Algoritmo:

1. 2. 3. 4. Declarar instancia de curso Obtener las notas para el curso Calcular el promedio, mnimo y mximo Mostrar los resultados

4. Validacin Es importante analizar casos extremos en los que el usuario pueda ingresar valores poco usuales. Por ejemplo, si la cantidad de alumnos es cero o si es muy grande. Esto es particularmente importante para validar el programa en C#. Por lo tanto, deben definirse dominios de validacin que representan estas situaciones. Adems, deben considerarse dominios que incluyan distintos valores para las notas. Por ejemplo, varias notas distintas y repetidas, todas las notas iguales, etc. Tambin debe definirse un dominio en el que el nmero de estudiantes es uno, pues podra presentar algn problema. 5. Limitaciones Las limitaciones de este algoritmo se presentan principalmente en su implementacin en el lenguaje de programacin C#. Dado que se va a utilizar un arreglo para almacenar las distintas notas, el mximo nmero de notas que podrn ingresarse estar limitado por la dimensin mxima factible de almacenar en un arreglo, aunque dado el caso de C# y el contexto, se asumo que la cantidad de notas difcilmente ser tan grande. Por otra parte, no se planean controles de validez sobre los nmeros que ingresa el usuario, de modo que se supone que se ingresarn valores correctos, en el rango de 1 a 7. De no ser as, el comportamiento del programa no est definido (es decir, puede pasar cualquier cosa). Tambin se supone que el nmero de alumnos es mayor que cero, o el comportamiento del programa no est definido. Por ejemplo, si se ingresa como nmero de alumnos un cero, esto producir una divisin por cero al calcular el promedio.

//////////////////////////////////////////////////////////////// // Programa que lee del usuario una lista de notas correspondientes a los // alumnos de un curso, y calcula el promedio, mnimo y mximo. Se ilustra // el uso de arreglos para el almacenamiento de la informacin de entrada. // Este programa podra reescribirse sin el uso de arreglos: Como? //////////////////////////////////////////////////////////////// using System; class Curso { const float MAX_NOTA = 7.0F; const float MIN_NOTA = 1.0F; float[] notas; float promedio; float minimo; float maximo; public Curso() { int n; Console.Write("Ingrese el nmero de alumnos en la seccin: "); n = int.Parse(Console.ReadLine()); // Las expresiones tipo float requieren una F al final

IIC 1102

Pgina: 8

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

notas = new float[n]; for(int i=1; i<=n; i++) { Console.Write("Ingrese la nota {0}: ", i); notas[i-1] = float.Parse(Console.ReadLine()); } } public void Calcular() { float suma = 0; minimo = MAX_NOTA; maximo = MIN_NOTA; foreach( float nota in notas ) { if (minimo>nota) minimo = nota; if (maximo<nota) maximo = nota; suma += nota; } promedio = suma / notas.Length; } public void Mostrar() { Console.WriteLine("Promedio de las {0} notas = {1}", notas.Length, promedio); Console.WriteLine("Mnimo de las {0} notas = {1}", notas.Length, minimo); Console.WriteLine("Mximo de las {0} notas = {1}", notas.Length, maximo); } } class MainApp { static void Main() { Curso c = new Curso(); c.Calcular(); c.Mostrar(); Console.ReadLine(); } }

Ejemplo de ejecucin:

Ingrese el nmero de alumnos en la seccin: 5 Ingrese la nota 1: 5,6 Ingrese la nota 2: 5,8 Ingrese la nota 3: 6,2 Ingrese la nota 4: 4,6 Ingrese la nota 5: 5,1 Promedio de las 5 notas = 5,46 Mnimo de las 5 notas = 4,6 Mximo de las 5 notas = 6,2

1.2.5 Ejemplo: Programa de simulacin de conjuntos con arreglos

//////////////////////////////////////////////////////////////// // Programa de simulacin de operaciones sobre conjuntos de // elementos del tipo entero, se pueden considerar todos los // nmeros enteros positivos y negativos, excepto el 0 //////////////////////////////////////////////////////////////// using System; class Conjunto {

IIC 1102

Pgina: 9

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

const int MAX_NUMS = 20; int[] numeros; // Constructor. // Se considera que toda posicin del arreglo que tiene un // 0, no es un elemento del conjunto entonces un arreglo de // n posiciones con valores 0, es un conjunto vaco public Conjunto () { numeros = new int[MAX_NUMS]; Limpiar(); } public int Elemento(int n) { return(numeros[n-1]); } public void Limpiar() { for (int i=0; i<MAX_NUMS; i++) numeros[i] = 0; } public void Cargar() { int i = 0; Console.WriteLine("CARGA DE DATOS (0 para terminar)"); do { Console.WriteLine("Ingrese el elemento {0} del conjunto ",i+1); Agregar(int.Parse(Console.ReadLine())); i++; } while(numeros[i-1]!=0 && i < numeros.Length); }

// Se requiere la cantidad de elementos que son !=0 public int Largo() { int largo = 0; foreach (int n in numeros) { if(n==0) break; largo++; } return(largo); } // Verifica si el elemento a est en el conjunto public bool Esta(int a) { foreach(int n in numeros) if(n == a) return (true); return (false); }

// Agrega el elemento si hay espacio y slo si no est public void Agregar(int a) { int posicion; posicion = Largo(); if(!Esta(a) && posicion<numeros.Length) numeros[posicion] = a; } // Imprime en pantalla en formato ( ... ) public void Imprimir() { Console.Write("{0} elementos: ( ", Largo()); foreach(int n in numeros) if(n!=0) Console.Write("{0} ",n); else break; Console.WriteLine(")"); } // Unin de conjuntos // Se usan dos instancias de la clase como parmetros de este mtodo // Este mtodo es de nivel superior a cada instancia, por lo que se // declara "static" -> comn para todas las instancias de la clase Conjunto public static Conjunto Union(Conjunto c1, Conjunto c2) { Conjunto c = new Conjunto();

IIC 1102

Pgina: 10

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

// Primero se copian todos los elementos del conjunto 1 for(int i=0; i<c1.Largo(); i++) c.Agregar(c1.Elemento(i+1)); // Segundo, se copian los del segundo conjunto que an no estn for(int i=0; i<c2.Largo(); i++) if (!c.Esta(c2.Elemento(i+1))) c.Agregar(c2.Elemento(i+1)); return(c); // Se retorna el conjunto resultante } // Interseccin de Conjuntos public static Conjunto Interseccion(Conjunto c1, Conjunto c2) { Conjunto c = new Conjunto(); // Se copian todos los elementos del conjunto 1 que estn en c2 for(int i=0; i<c1.Largo(); i++) if (c2.Esta(c1.Elemento(i+1))) c.Agregar(c1.Elemento(i+1)); return(c); // Se retorna el conjunto resultante } }

class MainApp { static void Main() Conjunto c1 Conjunto c2 Conjunto c3 Conjunto c4 { = = = =

new new new new

Conjunto(); Conjunto(); Conjunto(); Conjunto();

// Se le agregan elementos al primer conjunto y se muestra c1.Agregar(2); c1.Agregar(3); c1.Agregar(4); c1.Imprimir(); Console.WriteLine("5 es elemento del conjunto 0? --> {0}", c1.Esta(5)); Console.WriteLine("Se ingresa 5 al conjunto c1"); c1.Agregar(5); Console.WriteLine("5 es elemento del conjunto 0? --> {0}", c1.Esta(5)); c1.Imprimir(); Console.WriteLine("---------------------------"); Console.WriteLine("Ingrese elementos del conjunto 2"); c2.Cargar(); Console.WriteLine("---------------------------"); Console.WriteLine("Ingrese elementos del conjunto 3"); c3.Cargar(); Console.WriteLine("---------------------------"); Console.WriteLine("Conjunto 2: "); c2.Imprimir(); Console.WriteLine("Conjunto 3: "); c3.Imprimir(); Console.WriteLine("Conjunto2 c4 = Conjunto.Union(c2,c3); c4.Imprimir(); U Conjunto3");

Console.WriteLine("Conjunto2 Intersec. Conjunto3"); c4 = Conjunto.Interseccion(c2,c3); c4.Imprimir(); Console.ReadLine(); } }

IIC 1102

Pgina: 11

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Ejemplo de ejecucin:

3 elementos: ( 2 3 4 ) 5 es elemento del conjunto 0? --> False Se ingresa 5 al conjunto c1 5 es elemento del conjunto 0? --> True 4 elementos: ( 2 3 4 5 ) --------------------------Ingrese elementos del conjunto 2 CARGA DE DATOS (0 para terminar) Ingrese el elemento 1 del conjunto 1 Ingrese el elemento 2 del conjunto 2 Ingrese el elemento 3 del conjunto 3 Ingrese el elemento 4 del conjunto 4 Ingrese el elemento 5 del conjunto 0 --------------------------Ingrese elementos del conjunto 3 CARGA DE DATOS (0 para terminar) Ingrese el elemento 1 del conjunto 2 Ingrese el elemento 2 del conjunto 4 Ingrese el elemento 3 del conjunto 6 Ingrese el elemento 4 del conjunto 8 Ingrese el elemento 5 del conjunto 0 --------------------------Conjunto 2: 4 elementos: ( 1 2 3 4 ) Conjunto 3: 4 elementos: ( 2 4 6 8 ) Conjunto2 U Conjunto3 6 elementos: ( 1 2 3 4 6 8 ) Conjunto2 Intersec. Conjunto3 2 elementos: ( 2 4 )

IIC 1102

Pgina: 12

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

2 Arreglos Multidimensionales
Los arreglos que se estudiaron anteriormente son estructuras de datos vectoriales de una sola dimensin. En C# tambin es posible manejar arreglos de ms de una dimensin. Particularmente en este lenguaje, existen dos maneras de declarar arreglos multidimensionales, por un lado aquellos en que todas las dimensiones son fijas, tambin conocidos como matrices, y en segundo lugar, los que tienen filas (o columnas) de largo distinto. En forma rigurosa, estos ltimos arreglos no son ms que arreglos en los que cada elemento es a la vez otro arreglo, que puede ser de diferente dimensin que su vecino. Los arreglos de dos dimensiones reciben el nombre de matrices. Gran parte del desarrollo de esta seccin se limita a las matrices, es decir, a arreglos de dos dimensiones, de filas del mismo tamao. Sin embargo, tanto la sintaxis para la declaracin como la forma de utilizar estos arreglos puede generalizarse sin problema a dimensiones mayores (3D, 4D, etc). Para referirse a cada uno de los elementos que constituyen el arreglo es necesario emplear una serie de ndices. En el caso de las matrices, dos. Esto es posible pues los elementos de la matriz, al igual que en el caso de los vectores unidimensionales, estn numerados en forma jerrquica consecutiva, empezando en 0,0. Cada par de ndices referencia tanto una fila, como una columna de la matriz, identificando de manera nica cada elemento de la estructura.

2.1

Declaracin de Matrices

Como se mencion anteriormente, las matrices no son ms que arreglos en los que cada elemento es a su vez otro arreglo. La sintaxis de la declaracin de una matriz es la siguiente: <tipo-base>[,] <identificador>; Observaciones: El <tipo-base> puede ser cualquiera de los tipos bsicos del lenguaje, o incluso algunos complejos como estructuras. Cada elemento de la matriz ser del tipo definido aqu. El <identificador> es el nombre que distinguir la matriz. Los corchetes [] son obligatorios. El separador de dimensiones es la coma ,.

El dimensionamiento de estas matrices se puede hacer en una declaracin separada, de la siguiente manera:

<identificador> = <tipo-base>[NumElem1, NumElem2];

El trmino <NumElem1> determina el tamao de la primera dimensin de la matriz, es decir, la cantidad de filas que tendr. Los elementos de la segunda dimensin (columnas) estn numerados en forma consecutiva, empezando en 0. El trmino <NumElem2> determina el tamao de la segunda dimensin de la matriz, es decir, la cantidad de elementos del tipo base que contendr. Dichos elementos estarn numerados en forma consecutiva, empezando en 0.

Al igual que en el caso de arreglos unidimensionales, es posible declarar una matriz y al mismo tiempo inicializar sus elementos con valores del tipo base. La sintaxis para hacer esto es la siguiente: <tipo-base>[M,N] identif = { { valor1-1, valor1-2, ..., valor1-N },

{ valor2-1, valor2-2, ..., valor2-N }, ..., { valorM-1, valorM-2, ..., valorM-N }

}; Con los valores indicados entre llaves {} se inicializarn los MxN elementos de la matriz. Los valores deben ser del <tipo-base> de la matriz.

IIC 1102

Pgina: 13

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

2.2

Uso de Matrices

Los elementos de una matriz se pueden entender como un casillero o una celda, determinada por fila y columna. Para asignar un valor a un elemento de una matriz basta con escribir: matriz[indice1,indice2] = valor; en donde matriz es el nombre de la variable y las expresiones indice1 e indice2 hacen referencia a la posicin del elemento al que se le quiere asignar el valor. El nombre de una matriz tambin puede emplearse sin ndice, bajo ciertas circunstancias, por ejemplo, para pasar la matriz completa como argumento a una funcin.

2.2.1 Obteniendo Dimensiones de una Matriz

Al igual que en las matrices unidimensionales, el largo de la fila o columna de una matriz se puede obtener, en este caso con el mtodo GetLength(dimension), donde dimension se refiere a filas, columnas, etc. En el caso de una matriz bidimensional, el largo de las filas se ve con GetLength(0), y de las columnas, con GetLength(1).

2.2.2 Ejemplos de uso de Matrices

En todos los casos, matriz es el nombre de la variable declarada: 1. Declaracin de una matriz de 50 filas de 20 enteros: int[,] matriz = new int[50,20]; 2. Declaracin e inicializacin de una matriz: int[,] matriz = { { 2, 5, 8 }, { 9, 1, 2 } };

// 2 filas, 3 col.

3. Asignando un valor a la primera posicin de la segunda fila de una matriz de enteros: matriz[1,0] = 50; 4. Imprimiendo una matriz de 100x50 enteros mediante un ciclo for: int i, j; for (i=0; i<100; i++) { for (j=0; j<50; j++) Console.Write("{0} ", matriz[i,j]); Console.WriteLine(); } 5. Imprimiendo una matriz de NxN enteros mediante un ciclo for: int i, j; for (i=0; i<matriz.GetLength(0); i++) { for (j=0; j< matriz.GetLength(1); j++) Console.Write("{0} ", matriz[i,j]); Console.WriteLine(); }

2.2.3 Foreach en matrices

En forma similar al caso de los arreglos unidimensionales, es posible utilizar foreach() para recorrer los elementos de las celdas de una matriz. Sin embargo, foreach() hace un recorrido exhaustivo sin explicitar cuando se cambia de fila o de columna. Es decir, en este caso sirve para recorrer todo el contenido de una matriz, sin tener conocimiento explcito de las respectivas posiciones de las celdas.

IIC 1102

Pgina: 14

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

2.2.4 Ejemplo: Clculo de las notas finales de un curso (mnimo, mximo, promedio)
Se desea calcular las notas finales de los alumnos de un curso, as como tambin el promedio, mnimo y mximo de stas. Se recibir el nmero de alumnos y las notas parciales de cada uno de stos. Las notas parciales corresponden a la I1, I2, T1, T2 y Exmen. La nota final se calcula empleando la frmula: NF = 0.7*NP + 0.3*Ex en donde NP es la nota de presentacin calculada como: NP = (I1+I2+T1+T2)/4

1. Definicin del problema

Conceptualizacin: El problema consiste en calcular la nota final obtenida por cada uno de los alumnos de un curso, y el promedio, mnimo y mximo de estas notas finales. El clculo de la nota final es una funcin de las notas parciales que obtuvo durante el semestre. Se supone que cada alumno tiene todas y cada una de las notas parciales definidas, que el usuario conoce a priori la cantidad de alumnos del curso y que entregar los datos en forma correcta. Objetivo: El objetivo es obtener la nota final de cada alumno, junto con el promedio, el mximo, y el mnimo de stas. Elementos involucrados: Los elementos involucrados son la cantidad de alumnos, las notas parciales y la nota final de cada alumno, y por ltimo el promedio, el mnimo y el mximo de las notas finales.

2. Conceptualizacin de la solucin
2.1 Entidades: El Curso es la nica entidad relevante, la cual se conceptualiza como la agrupacin de notas correspondientes a los alumnos. 2.2 Clases: La clase Curso, ser la representacin de las notas de un curso cuyo promedio se quiere calcular. Esta clase se compone de los siguientes: Atributos de la Clase Curso notas: una matriz que almacenar todas las notas parciales (en forma de nmero real, con decimales). promedio (PROM): el valor resultante del promedio de notas del curso minimo (MIN): el valor de la mnima de todas las notas del curso maximo (MAX): el valor de la mnima de todas las notas del curso Mtodos de la Clase Curso Curso: (constructor) obtiene los valores de todas las notas parciales ingresadas por el usuario. El algoritmo de este mtodo es: 1. Obtener la cantidad de alumnos: N 2. Iterar para cada uno de los N alumnos 2.1 Iterar para cada nota parcial del alumno 2.1.1 Obtener la nota parcial del alumno 2.2 Calcular la Nota P del Alumno 2.3 Calcular la Nota Final del Alumno y agregarlo a la matriz Calcular: recorre la lista de notas, calculando el mnimo, el mximo y el promedio de estos valores. El algoritmo de este mtodo es:

IIC 1102

Pgina: 15

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

0. Se declara una variable local: SUMA 1. Inicialmente la suma de notas, SUMA, es 0, el mximo, MAX, es 1, y el mnimo, MIN, es 7 2. Iterar para cada para cada uno de los N alumnos 2.1 Agregar a SUMA la nota FINAL del alumno 2.2 Si la nota FINAL del alumno es mayor que MAX 2.2.1 MAX es ahora la nota FINAL del alumno 2.3 Si la nota FINAL del alumno es menor que MIN 2.3.1 MIN es ahora la nota FINAL del alumno 3. El promedio, PROM es SUMA dividido por N Mostrar: muestra en pantalla las notas finales y los valores de promedio, mnimo y mximo

2. 3 Instancias: La nica instancia requerida es notas1, de la clase Curso.

3. Especificacin del Algoritmo

Algoritmo:
1. 2. 3. 4. Declarar instancia de curso Obtener las notas para el curso Calcular el promedio, mnimo y mximo Mostrar los resultados

Cdigo de la Solucin
//////////////////////////////////////////////////////////////// // Programa que lee del usuario una lista de notas parciales correspondientes a los alumnos // de un curso, y calcula la nota final de cada alumno, y el promedio, mnimo y mximo. // Se ilustra el uso de arreglos 2D (matrices) para el almacenamiento de la info. de entrada. ////////////////////////////////////////////////////////////////using System; class Curso { const float MAX_NOTA = 7.0F; const float MIN_NOTA = 1.0F; float[,] notas; float promedio; float minimo; float maximo; public Curso() { int n; float notap; Console.Write("Ingrese el nmero de alumnos en la seccin: "); n = int.Parse(Console.ReadLine()); notas = new float[n,6]; // 6 notas (5 parciales y 1 final) de n alumnos for(int i=1; i<=n; i++) { Console.WriteLine("Alumno N {0}", i); for(int j=1; j<=5; j++) { // Slo se asignan 5 notas parciales Console.Write("Ingrese la nota {0}: ", j); notas[i-1,j-1] = float.Parse(Console.ReadLine()); } // Nota P, con las primeras 4 notas notap = (notas[i-1,0]+notas[i-1,1]+notas[i-1,2]+notas[i-1,3]) / 4.0F; // Nota final: 0.7*NotaP + 0.3*Examen (la 5a)

// Las expresiones tipo float requieren una F al final

IIC 1102

Pgina: 16

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

notas[i-1,5] = 0.7F*notap + 0.3F*notas[i-1,4]; } } public void Calcular() { float suma = 0; minimo = MAX_NOTA; maximo = MIN_NOTA; for(int i=0; i<notas.GetLength(0); i++) { if (minimo>notas[i,5]) minimo = notas[i,5]; if (maximo<notas[i,5]) maximo = notas[i,5]; suma += notas[i,5]; } promedio = suma / notas.GetLength(0); } public void Mostrar() { Console.WriteLine("Notas Finales:"); for(int i=0; i<notas.GetLength(0); i++) Console.Write("{0:F1} ",notas[i,5]); Console.WriteLine("Promedio de las {0} notas = {1}", notas.GetLength(0), promedio); Console.WriteLine("Mnimo de las {0} notas = {1}", notas.GetLength(0), minimo); Console.WriteLine("Mximo de las {0} notas = {1}", notas.GetLength(0), maximo); } } class MainApp { static void Main() { Curso c = new Curso(); c.Calcular(); c.Mostrar(); Console.ReadLine(); } }

Ejemplo de ejecucin: Ingrese el nmero de alumnos en la seccin: 3 Alumno N 1 Ingrese la nota 1: 4,3 Ingrese la nota 2: 4,4 Ingrese la nota 3: 4,5 Ingrese la nota 4: 5,2 Ingrese la nota 5: 5,6 Alumno N 2 Ingrese la nota 1: 5,4 Ingrese la nota 2: 6,2 Ingrese la nota 3: 5,8 Ingrese la nota 4: 5,5 Ingrese la nota 5: 5,7 Alumno N 3 Ingrese la nota 1: 3,4 Ingrese la nota 2: 6,2 Ingrese la nota 3: 5,6 Ingrese la nota 4: 4,5 Ingrese la nota 5: 6,0 Notas Finales: 4,9 5,7 5,2 Promedio de las 3 notas = 5,288333 Mnimo de las 3 notas = 4,9 Mximo de las 3 notas = 5,7175

IIC 1102

Pgina: 17

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

2.2.5 Ejemplo: Multiplicacin de Matrices Cuadradas

Se desea realizar la multiplicacin AxB de dos matrices cuadradas A y B, utilizando el algoritmo que se presenta en el siguiente diagrama. Dadas dos matrices A, de dimensin MxP, y B, de dimensin PxN, la matriz multiplicacin C, de dimensin MxN, se calcula de la siguiente forma:

IIC 1102

Pgina: 18

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

1. Definicin del problema

Conceptualizacin: El problema consiste en calcular la multiplicacin de 2 matrices cuadradas de igual dimensin. El usuario debe entregar la dimensin y los valores de cada uno de los elementos de las matrices a multiplicar (nmeros enteros). Objetivo: El objetivo es obtener una matriz resultante de multiplicar las dos matrices entregadas. Elementos involucrados: Los elementos involucrados son la dimensin de las matrices, las matrices a multiplicar y la matriz con el resultado.

2. Conceptualizacin de la solucin
Entidades: la nica entidad relevante es Matriz, que representa precisamente una matriz de NxN Clases: para representar esta nica entidad, la clase Matriz ser la encargada de exponer la informacin y funcionalidad para distinguir una matriz de otra, as como los mtodos para operar con ellas, en particular el mtodo de multiplicacin entre matrices. Atributos: la estructura para manejar los datos de la matriz: datos. Mtodos: Matriz(n): Constructor. Inicializa la dimensin de la matriz (n). Cargar():se le preguntan los datos al usuario Obtener la dimensin de la matriz Inicializacin de la estructura datos. Obtener los valores de los elementos de las matrices 1. Iterar la fila i de la matriz por todos sus posibles valores 1.1. Iterar la columna j de la matriz por todos sus posibles valores 1.1.1. Obtener el elemento ( i , j ) de la matriz Multiplicar(Matriz A, Matriz B): se calcula la multiplicacin de dos matrices A y B 1. Iterar sobre cada fila i de la matriz resultado C 1.1. Iterar sobre cada columna j de la fila i 1.1.1. Obtener el valor del elemento C ( i , j ) del resultado 1.1.1.1. Inicialmente C ( i , j ) es 0 (acumulador) 1.1.1.2. Iterar k desde 1 hasta la dimensin de las matrices Agregar a C ( i , j ) el valor A ( i , k ) * B ( k , j ) Mostrar(): muestra la matriz en pantalla

Instancias: A: Primera de las matrices a multiplicar B: Segunda de las matrices a multiplicar C: Matriz resultado (AxB)

3. Especificacin del Algoritmo

Declarar instancia Matriz A y B Cargar A y Cargar B Declarar instancia Matriz C C = A x B Mostrar C en pantalla

IIC 1102

Pgina: 19

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

4. Validacin
En primera instancia se debe considerar las situaciones extremas para la dimensin de las matrices, tal es el caso en que se defina como cero como para comprometer la implementacin en C# (segn la definicin de la matriz). Por otra parte, otros dominios deben incluir distintos valores para la dimensin de las matrices y para los elementos dentro de las matrices. Algunos casos interesante de estudiar son aquellos en que alguna de las matrices (o ambas) son cero (todos sus elementos) o uno (la diagonal). Tambin debe estudiarse el caso en que la dimensin de las matrices es uno, lo cual es correcto pero podra presentar problemas.

5. Limitaciones
No se incluyen controles de validez de los nmeros que ingresa el usuario como elementos de las matrices, de modo que se supone que se ingresarn valores correctos. De no ser as, el comportamiento del programa no est definido (es decir, puede pasar cualquier cosa). Tambin se supone que la dimensin de las matrices es mayor que cero, o el comportamiento del programa no est definido.

Cdigo de la Solucin
///////////////////////////////////////////////////////////////////////// // Programa que hace la multiplicacin AxB de dos matrices cuadradas A y B. // El programa pide al usuario que ingrese la dimensin de las matrices, es // decir, la longitud de los lados, as como los valores para las entradas de // ambas matrices (A y B), calcula la multiplicacin empleando un ciclo for // con anidamiento de tres niveles, y finalmente despliega el resultado de // la multiplicacin A*B, el cual se almaceno en una tercera matriz: C. ///////////////////////////////////////////////////////////////////////// using System; class Matriz { int[,] datos; public Matriz(int n) { datos = new int[n,n]; // Se crea la matriz del tamao indicado } public void Cargar() { int i,j; Console.WriteLine("\nIngrese los Valores para la matriz:"); for (i=0; i<datos.GetLength(0); i++) { Console.WriteLine("Fila {0}:", i); for (j=0; j<datos.GetLength(1); j++) { Console.Write("\tCelda {0}: ", j); datos[i,j] = int.Parse(Console.ReadLine()); } } } int Tamano() { return(datos.GetLength(0)); } public static Matriz Multiplicar(Matriz A, Matriz B) { Matriz m = new Matriz(A.Tamano()); // El siguiente ciclo con anidamiento de 3 nivel realiza la multiplicacin for (int i=0; i<m.Tamano(); i++) { for (int j=0; j<m.Tamano(); j++) { m.datos[i,j] = 0; for (int k=0; k<m.Tamano(); k++) m.datos[i,j] += (A.datos[i,k] * B.datos[k,j]); } } return(m); }

IIC 1102

Pgina: 20

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

// Mostrar(): muestra en pantalla (consola) la matriz. public void Mostrar() { Console.WriteLine("\n"); // Se imprime por filas completas hacia el lado for (int i=0; i<datos.GetLength(0); i++) { Console.Write("| "); // Se imprime un separador for (int j=0; j<datos.GetLength(1); j++) Console.Write("{0} ",datos[i,j]); Console.WriteLine("|"); // Se imprime un separador } // Al final de recorrer la fila, se cambia de lnea Console.WriteLine(); } } class MainApp { static void Main() { int N; // Dimension real de las matrices, dada por el usuario Console.WriteLine("Multiplicacin de A(NxN) X B(NxN)"); Console.Write("Ingrese el valor de N (de 1 a 10): "); N = int.Parse(Console.ReadLine()); Matriz A = new Matriz(N); Matriz B = new Matriz(N); A.Cargar(); B.Cargar(); // Se declaran e inicializan las dos matrices A y B

Matriz C = Matriz.Multiplicar(A,B); C.Mostrar(); Console.Write("Presione ENTER para terminar..."); Console.ReadLine(); } }

Ejemplo de ejecucin: Multiplicacin de A(NxN) X B(NxN) Ingrese el valor de N (de 1 a 10): 3 Ingrese los Valores para la matriz: Fila 0: Celda 0: 1 Celda 1: 2 Celda 2: 3 Fila 1: Celda 0: 4 Celda 1: 5 Celda 2: 6 Fila 2: Celda 0: 7 Celda 1: 8 Celda 2: 9 Ingrese los Valores para la matriz: Fila 0: Celda 0: 9 Celda 1: 8 Celda 2: 7 Fila 1: Celda 0: 6 Celda 1: 5 Celda 2: 4

IIC 1102

Pgina: 21

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

Fila 2: Celda 0: 3 Celda 1: 2 Celda 2: 1 | 30 24 18 | | 84 69 54 | | 138 114 90 |

IIC 1102

Pgina: 22

Intro. Prog. Orientada a Objeto Arreglos y Enumeraciones

Rodrigo Sandoval U.

3 Enumeraciones
Existe una versin simplificada de arreglos, que se declaran con datos incluidos. Estos se utilizan esencialmente para listar opciones fijas para un programa. Por definicin, todos los elementos de las enumeraciones son de tipo entero. En otras palabras, al declarar una enumeracin, se est definiendo un conjunto de valores aceptados, dndole nombres ms entendibles, y como consecuencia, el compilador dar aviso cuando se intente usar un valor no definido. La sintaxis para la declaracin de una enumeracin es la siguiente:

enum <identificador> { <nombre1> = <valorEntero1>, <nombre2> = <valorEntero2>, ... <nombreN> = <valorEnteroN> }

Por ejemplo, una til enumeracin se puede definir al utilizar una clase con un atributo que slo puede tomar los valores Femenino o Masculino. Ejemplo: public enum Sexo { Femenino = 1, Masculino = 2 } class Persona { string nombre; int edad; Sexo sexo; Public void Mostrar() { Console.WriteLine(Nombre: {0}, nombre); Console.WriteLine(Edad: {0}, edad); if ( sexo == Sexo.Masculino ) Console.WriteLine(Sexo: Masculino); else Console.WriteLine(Sexo: Femenino); } }

Entre los beneficios de utilizar enumeraciones se cuentan: Se hace ms fcil de mantener el cdigo, al permitir asegurar que las variables slo reciben valores dentro de un rango definido, sin posibilidad de valores invlidos. Las enumeraciones hacen al cdigo ms legible y entendible, permitiendo referenciar valores enteros con nombres ms descriptivos, en lugar de nmeros oscuros y mgicos.

IIC 1102

Pgina: 23