arreglos c#

PONTIFICIA UNIVERSIDAD CATÓLICA DE CHILE ESCUELA DE INGENIERÍA DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN Profesor: Rodrigo Sandoval U.

Capítulo VII – Arreglos y Enumeraciones en C#

1 ARREGLOS ......................................................................................................................................................... 1 1.1 DECLARACIÓN DE ARREGLOS UNIDIMENSIONALES ........................................................................................ 2 1.2 USO DE ARREGLOS UNIDIMENSIONALES......................................................................................................... 3

1.2.1 Funciones más comunes con arreglos.................................................................................................... 4 1.2.2 Foreach para el manejo de arreglos...................................................................................................... 5 1.2.3 Ejemplos de declaración y uso de arreglos............................................................................................ 6 1.2.4 Ejemplo: Cálculo de mínimo, máximo y promedio de una lista de notas de estudiantes....................... 7 1.2.5 Ejemplo: Programa de simulación de conjuntos con arreglos .............................................................. 9

2 ARREGLOS MULTIDIMENSIONALES....................................................................................................... 13 2.1 DECLARACIÓN 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: Cálculo de las notas finales de un curso (mínimo, máximo, promedio) ............................... 15 2.2.5 Ejemplo: Multiplicación de Matrices Cuadradas ................................................................................ 18

3 .......................................................................................................................................... 23 ENUMERACIONES

Material preparado por Rodrigo Sandoval U en Marzo 2004, basado en los apuntes de clase del curso IIC1102, año 2003, de M. Nussbaum, Marcos Sepúlveda, 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 atómicas) 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 básicos de C#, o incluso algunos tipos complejos como las clases.

Un arreglo es también ejemplo de un modelo. Un arreglo puede considerarse como ejemplo de una variable compuesta capaz de almacenar uno o más 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 están numerados en forma jerárquica y consecutiva, empezando en 0 en cada dimensión.

El siguiente gráfico ilustra un ejemplo de un arreglo llamado numeros, cuya posición 0 almacena el valor 10, la posición 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 Página: 1


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 difíciles de detectar en este sentido. Más adelante se presenta un ejemplo en este sentido.

1.1 Declaración de Arreglos Unidimensionales Los arreglos, al igual que las demás variables deben declararse antes de poder utilizarlas, y cumplen con las mismas reglas de alcance y vida.

Los arreglos de una sola dimensión reciben también el nombre de vectores. La sintaxis de la declaración de un arreglo unidimensional es la siguiente:

<tipo-base>[] <identificador>; Observaciones:

• El <tipo-base> puede ser cualquiera de los tipos básicos 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 declaración NO se define el tamaño que tendrá el arreglo (aunque se puede determinar las dimensiones, lo que se verá más adelante).

El tamaño del arreglo se determina en una segunda declaración, que puede ir en la siguiente línea, como se muestra a continuación.

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

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

Es posible hacer la declaración 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 declaración:

<tipo-base>[] <identificador> = {valor1, valor2, ..., valorN}; Esta última declaración implícitamente 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 inicializarán los elementos del arreglo.

• Los valores deben ser del <tipo-base> del arreglo.

IIC 1102 Página: 2


También es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en una sola declaración, pero sólo 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 expresión constante, como por ejemplo 10. Es factible hacer una declaración 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 demás instrucciones, como la asignación. 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 posición 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 básicas), no es posible asignar un arreglo a otro mediante una simple asignación (=). 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 difíciles de detectar en este sentido. Es necesario prestar especial interés a los valores que toman los índices para evitar estos problemas.

Por ejemplo, la siguiente porción de código compila sin problemas (es decir, sin errores sintácticos), pero probablemente produzca un error en tiempo de ejecución al referenciarse posiciones inexistentes del arreglo.

// Las posiciones con índices del 10 al 19 son inválidas.

int[] arreglo = { 1,1,1,1,1,1,1,1,1,1 }; // 10 elementos

int i;

for (i=0; i<20; i++)

arreglo[i] = 0; // Error para i >= 10

IIC 1102 Página: 3


También es común cometer estos errores olvidando que las posiciones de los arreglos están numeradas a partir del índice cero. Es decir, en un arreglo de tamaño N las posiciones están numeradas de 0 a N-1.

1.2.1 Funciones más comunes con arreglos En C#, los arreglos se representan con un tipo específico, y por ello cuentan con sus propios atributos y métodos específicos. 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 tamaño 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 método básico 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 revés de cómo está, aprovechando el método básico Reverse() de la clase Array:

int [] numeros = { 1,2,3,4,5,6 } Array.Reverse(numeros); // 6,5,4,3,2,1

Ejemplo de Manipulación 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 Página: 4


} 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 diseñada para este tipo de estructuras, donde se manejan listas de elementos, todos del mismo tipo. Foreach depende de la definición previa de un arreglo de elementos del mismo tipo, los cuales puede recorrer individualmente sin conocer el tamaño explícitamente (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 básico 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 iteración.

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 Página: 5


Console.ReadLine(); } }

A continuación se incluyen ejemplos, tanto de declaración y uso de arreglos, como del uso de foreach.

1.2.3 Ejemplos de declaración y uso de arreglos En todos los casos, A es el nombre de la variable declarada:

1. Declaración de un arreglo de 50 enteros: int[] A = new int[50]; 2. Declaración de un arreglo de 100 caracteres: char[] A = new char[100]; 3. Declaración e inicialización de un arreglo de 10 enteros: int[] A = { 2, 5, 8, 100, 1, 2, 100, 5, 5, 5 } 4. Inicialización parcial: El resto se inicializa e int[] A = new int[100] { 25, 5, 100, 25, 5 }

n cero:

5. Declaración e inicialización de un arreglo de 10 caracteres: char[] A = { 'a', 'z', 'E', 'e', 65, '\65', '@', 'U', '*', '\n' } 6. Asignando un va A[5] = 200;

lor a la sexta posición de un arreglo de enteros:

7. Imprimiend int i;

o un arreglo de 100 enteros mediante un ciclo for:

for (i=0; i<100; i++) Console.Write("{0} ", A[i]); 8. Imprimiendo un arreglo de 100 enteros mediante un ciclo foreach: Console.Write("{0} ", i);

foreach (int i in A) 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 función 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 función que recibe un arreglo de enteros como parámetro: int prom; int[] A; ... prom = promedio(A);

IIC 1102 Página: 6


1.2.4 Ejemplo: Cálculo de mínimo, máximo y promedio de una lista de notas de estudiantes

Se desea calcular el promedio, mínimo y máximo de una lista de notas correspondientes a un curso. Se recibirá el número de alumnos y la nota correspondiente a c/u, y se entregan los resultados en la pantalla.

1. Definición del problema

1.1 Conceptualización: El problema consiste en calcular el promedio, mínimo y máximo 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 máximo, y el mínimo de las notas del curso.

1.3 Elementos involucrados: Los únicos elementos involucrados son las notas, la cantidad de alumnos, el promedio, el mínimo y el máximo. Como elemento activo, el usuario que conoce las notas en detalle.

2. Conceptualización de la solución

2.1 Entidades: El Curso es la única entidad relevante, la cual se conceptualiza como la agrupación de notas correspondientes a los alumnos.

2.2 Clases: La clase Curso, será la representación 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 número real, con decimales)

promedio (PROM): el valor resultante del promedio de notas del curso

minimo (MIN): el valor de la mínima de todas las notas del curso

maximo (MAX): el valor de la mínima de todas las notas del curso

Métodos de la Clase Curso

Curso: (constructor) obtiene los valores de todas las notas ingresadas por el usuario. El algoritmo de este método 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 mínimo, el máximo y el promedio de estos valores. El algoritmo de este método es:

0. Se declara una variable local: SUMA

1. Inicialmente la suma de notas, SUMA, es 0, el máximo, MAX, es 1, y el mínimo, 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, mínimo y máximo

IIC 1102 Página: 7


2. 3 Instancias:

La única instancia requerida es notas1, de la clase Curso.

3. Especificación del Algoritmo

Algoritmo: 1. Declarar instancia de curso 2. Obtener las notas para el curso 3. Calcular el promedio, mínimo y máximo 4. Mostrar los resultados

4. Validación

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 validación que representan estas situaciones.

Además, deben considerarse dominios que incluyan distintos valores para las notas. Por ejemplo, varias notas distintas y repetidas, todas las notas iguales, etc. También debe definirse un dominio en el que el número de estudiantes es uno, pues podría presentar algún problema.

5. Limitaciones

Las limitaciones de este algoritmo se presentan principalmente en su implementación en el lenguaje de programación C#. Dado que se va a utilizar un arreglo para almacenar las distintas notas, el máximo número de notas que podrán ingresarse estará limitado por la dimensión máxima factible de almacenar en un arreglo, aunque dado el caso de C# y el contexto, se asumo que la cantidad de notas difícilmente será tan grande.

Por otra parte, no se planean controles de validez sobre los números que ingresa el usuario, de modo que se supone que se ingresarán 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).

También se supone que el número de alumnos es mayor que cero, o el comportamiento del programa no está definido. Por ejemplo, si se ingresa como número de alumnos un cero, esto producirá una división 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, mínimo y máximo. Se ilustra // el uso de arreglos para el almacenamiento de la información de entrada. // Este programa podría reescribirse sin el uso de arreglos: Como? //////////////////////////////////////////////////////////////// using System; class Curso { const float MAX_NOTA = 7.0F; // Las expresiones tipo float requieren una F al final const float MIN_NOTA = 1.0F; float[] notas; float promedio; float minimo; float maximo; public Curso() { int n; Console.Write("Ingrese el número de alumnos en la sección: "); n = int.Parse(Console.ReadLine());

IIC 1102 Página: 8


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("Mínimo de las {0} notas = {1}", notas.Length, minimo); Console.WriteLine("Máximo 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 ejecución:

Ingrese el número de alumnos en la sección: 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 Mínimo de las 5 notas = 4,6 Máximo de las 5 notas = 6,2

1.2.5 Ejemplo: Programa de simulación de conjuntos con arreglos //////////////////////////////////////////////////////////////// // Programa de simulación de operaciones sobre conjuntos de // elementos del tipo entero, se pueden considerar todos los // números enteros positivos y negativos, excepto el 0 //////////////////////////////////////////////////////////////// using System; class Conjunto {

IIC 1102 Página: 9


const int MAX_NUMS = 20; int[] numeros; // Constructor. // Se considera que toda posición del arreglo que tiene un // 0, no es un elemento del conjunto entonces un arreglo de // n posiciones con valores 0, es un conjunto vacío 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 sólo 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(")"); } // Unión de conjuntos // Se usan dos instancias de la clase como parámetros de este método // Este método es de nivel superior a cada instancia, por lo que se // declara "static" -> común para todas las instancias de la clase Conjunto public static Conjunto Union(Conjunto c1, Conjunto c2) { Conjunto c = new Conjunto();

IIC 1102 Página: 10


// 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 aún no estén 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 } // Intersección de Conjuntos public static Conjunto Interseccion(Conjunto c1, Conjunto c2) { Conjunto c = new Conjunto(); // Se copian todos los elementos del conjunto 1 que estén 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 = new Conjunto(); Conjunto c2 = new Conjunto(); Conjunto c3 = new Conjunto(); Conjunto c4 = new 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 U Conjunto3"); c4 = Conjunto.Union(c2,c3); c4.Imprimir(); Console.WriteLine("Conjunto2 Intersec. Conjunto3"); c4 = Conjunto.Interseccion(c2,c3); c4.Imprimir(); Console.ReadLine(); } }




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 )



2 Arreglos Multidimensionales Los arreglos que se estudiaron anteriormente son estructuras de datos vectoriales de una sola dimensión. En C# también es posible manejar arreglos de más de una dimensión. Particularmente en este lenguaje, existen dos maneras de declarar arreglos multidimensionales, por un lado aquellos en que todas las dimensiones son fijas, también conocidos como matrices, y en segundo lugar, los que tienen filas (o columnas) de largo distinto. En forma rigurosa, estos últimos arreglos no son más que arreglos en los que cada elemento es a la vez otro arreglo, que puede ser de diferente dimensión que su vecino.

Los arreglos de dos dimensiones reciben el nombre de matrices. Gran parte del desarrollo de esta sección se limita a las matrices, es decir, a arreglos de dos dimensiones, de filas del mismo tamaño. Sin embargo, tanto la sintaxis para la declaración 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, están numerados en forma jerárquica 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 Declaración de Matrices Como se mencionó anteriormente, las matrices no son más que arreglos en los que cada elemento es a su vez otro arreglo. La sintaxis de la declaración de una matriz es la siguiente:

<tipo-base>[,] <identificador>; Observaciones:

• El <tipo-base> puede ser cualquiera de los tipos básicos 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 declaración separada, de la siguiente manera:

<identificador> = <tipo-base>[NumElem1, NumElem2]; • El término <NumElem1> determina el tamaño de la primera dimensión de la matriz, es decir, la

cantidad de “filas” que tendrá. Los elementos de la segunda dimensión (columnas) están numerados en forma consecutiva, empezando en 0. El término <NumElem2> determina el tamaño de la segunda dimensión de la matriz, es decir, la cantidad de elementos del tipo base que contendrá. Dichos elementos estarán 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 inicializarán los MxN elementos de la matriz.

• Los valores deben ser del <tipo-base> de la matriz.



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 posición del elemento al que se le quiere asignar el valor.

El nombre de una matriz también puede emplearse sin índice, bajo ciertas circunstancias, por ejemplo, para pasar la matriz completa como argumento a una función.

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 método 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. Declaración de una matriz de 50 filas de 20 enteros: int[,] matriz = new int[50,20]; 2. Declaración e inicialización de una matriz: int[,] matriz = { { 2, 5, 8 }, { 9, 1, 2 } }; // 2 filas, 3 col. 3. Asignando un valor a la primera posición 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 explícito de las respectivas posiciones de las celdas.



2.2.4 Ejemplo: Cálculo de las notas finales de un curso (mínimo, máximo, promedio) Se desea calcular las notas finales de los alumnos de un curso, así como también el promedio, mínimo y máximo de éstas. Se recibirá el número de alumnos y las notas parciales de cada uno de éstos. Las notas parciales corresponden a la I1, I2, T1, T2 y Exámen. La nota final se calcula empleando la fórmula:

NF = 0.7*NP + 0.3*Ex

en donde NP es la nota de presentación calculada como:

NP = (I1+I2+T1+T2)/4

1. Definición del problema Conceptualización: El problema consiste en calcular la nota final obtenida por cada uno de los alumnos de un curso, y el promedio, mínimo y máximo de estas notas finales. El cálculo de la nota final es una función 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 máximo, y el mínimo 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 mínimo y el máximo de las notas finales.

2. Conceptualización de la solución 2.1 Entidades: El Curso es la única entidad relevante, la cual se conceptualiza como la agrupación de notas correspondientes a los alumnos.

2.2 Clases: La clase Curso, será la representación 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 número real, con decimales).

promedio (PROM): el valor resultante del promedio de notas del curso

minimo (MIN): el valor de la mínima de todas las notas del curso

maximo (MAX): el valor de la mínima de todas las notas del curso

Métodos de la Clase Curso

Curso: (constructor) obtiene los valores de todas las notas parciales ingresadas por el usuario. El algoritmo de este método 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 mínimo, el máximo y el promedio de estos valores. El algoritmo de este método es:



0. Se declara una variable local: SUMA

1. Inicialmente la suma de notas, SUMA, es 0, el máximo, MAX, es 1, y el mínimo, 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, mínimo y máximo

2. 3 Instancias:

La única instancia requerida es notas1, de la clase Curso.

3. Especificación del Algoritmo Algoritmo: 1. Declarar instancia de curso 2. Obtener las notas para el curso 3. Calcular el promedio, mínimo y máximo 4. Mostrar los resultados

Código de la Solución

//////////////////////////////////////////////////////////////// // 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, mínimo y máximo. // 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; // Las expresiones tipo float requieren una F al final const float MIN_NOTA = 1.0F; float[,] notas; float promedio; float minimo; float maximo; public Curso() { int n; float notap; Console.Write("Ingrese el número de alumnos en la sección: "); 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++) { // Sólo 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)



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("Mínimo de las {0} notas = {1}", notas.GetLength(0), minimo); Console.WriteLine("Máximo 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 ejecución:

Ingrese el número de alumnos en la sección: 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 Mínimo de las 3 notas = 4,9

Máximo de las 3 notas = 5,7175



2.2 ces Cuadradas Se desea realizar la multiplicación AxB de dos matrices cuadradas A y B, utilizando el algoritmo que se

uiente forma:

.5 Ejemplo: Multiplicación de Matri

presenta en el siguiente diagrama.

Dadas dos matrices A, de dimensión MxP, y B, de dimensión PxN, la matriz multiplicación C, de dimensión MxN, se calcula de la sig



1. Definición del problema Conceptualización: El problema consiste en calcular la multiplicación de 2 matrices cuadradaigual dimensión. El usuario debe entregar la dimensión y los valores de cada uno de los elemlas matrices a multiplicar (números enteros).

Objetivo: El objetivo es obtener una matriz resultante de multiplicar las dos matrices entregadas.

Elementos involucrados: Los elementos involucrados son la dimensión de las matricematrices a multiplicar y la matriz con el resultado.

2. Conceptualización de la solución 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 exponeinformación y funcionalidad para distinguir una matriz de otra, así como los métodos para operaellas, en particular el método de multiplicación entre matrices.

Atributos: la estructura para manejar los datos de la matriz: datos.

Métodos:

- Matriz(n): Constructor. Inicializa la dimensión de la matriz (n).

- Cargar():se le preguntan los datos al usuario

• Obtener la dimensión de la matriz

• Inicialización 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 multiplicación 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 dimensión 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)

s de entos de

s, las

r la r con

3. E

specificación 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



4. Ves extremas para la dimensión de las matrices, tal

o para comprometer la implementación en C# (según la defi

Porelemlas cas ría presentar problemas.

5. Limitaciones No se incluy uario como elementos de las matrices e es correctos. De no ser así, el comportamiento del program n pasar cualquier cosa). También se supone que la dimensión d mportamiento del programa no está definido.

Código de a/////////////////////////////////////////////////////////////////////////

alidación cionEn primera instancia se debe considerar las situa

es el caso en que se defina como cero comnición de la matriz).

otra parte, otros dominios deben incluir distintos valores para la dimensión de las matrices y para los entos dentro de las matrices. Algunos casos interesante de estudiar son aquellos en que alguna de

matrices (o ambas) son cero (todos sus elementos) o uno (la diagonal). También debe estudiarse el o en que la dimensión de las matrices es uno, lo cual es correcto pero pod

en controles de validez de los números que ingresa el us, d modo que se supone que se ingresarán valor

a o está definido (es decir, puedee las matrices es mayor que cero, o el co

l Solución

// Programa que hace la multiplicación AxB de dos matrices cuadradas A y B. // El programa pide al usuario que ingrese la dimensión de las matrices, es // decir, la longitud de los lados, así como los valores para las entradas de // ambas at m rices (A y B), calcula la multiplicación empleando un ciclo for // con a dani miento de tres niveles, y finalmente despliega el resultado de // la multiplicación 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 tamaño indicado } lpub ic void Cargar() { int i,j; Console.WriteLine("\nIngrese los Valores para la matriz:"); for (i=0; i<datos.GetLength(0); i++) { Console.WriteLine("Fila :", i); {0} 1); j++) { for (j=0; j<datos.GetLength( Console.Write("\tCelda {0}: ", j); datos[i,j] = int.Parse(Console.ReadLine()); } } } int Tamano() { return(datos.GetLength(0)); } car(Matriz A, Matriz B) { public static Matriz Multipli A.Tamano()); Matriz m = new Matriz( ciclo con anidamiento de 3 nivel realiza la multiplicación // El siguiente 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); }



// 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 línea Console.WriteLine(); } } class MainApp { static void Main() { int N; // Dimension real de las matrices, dada por el usuario Console.WriteLine("Multiplicación 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); // Se declaran e inicializan las dos matrices A y B Matriz B = new Matriz(N); A.Cargar(); B.Cargar(); Matriz C = Matriz.Multiplicar(A,B); C.Mostrar(); Console.Write("Presione ENTER para terminar..."); Console.ReadLine(); } }


Multiplicación 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 a Celd 1: 2 Celda 2: 3 Fila 1: Celda 0: 4 Celda 1: 5 Celda 2: 6 F :ila 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



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



3 Enumeraciones simplificada de arreglos, que se declaran con datos incluidos. Estos se utilizan

encialmente para listar opciones fijas para un programa. Por definición, todos los elementos de las raciones son de tipo entero.

En otras palabras, al declarar una enumeración, se está definiendo un conjunto de valores aceptados, dándole nombres más entendibles, y como consecuencia, el compilador dará aviso cuando se intente usar un valor no definido.

La sintaxis para la declaración de una enumeración es la siguiente:

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

Por ejemplo, una útil enumeración se puede definir al utilizar una clase con un atributo que sólo puede tomar los valores Femenino o Masculino.

Ejemplo:

public enum Sexo {

Existe una versión esenume

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 más fácil de mantener el código, al permitir asegurar que las variables sólo reciben valores dentro de un rango definido, sin posibilidad de valores inválidos.

- Las enumeraciones hacen al código más legible y entendible, permitiendo referenciar valores enteros con nombres más descriptivos, en lugar de números “oscuros y mágicos”.


arreglos c#

Education

arreglos y enumeraciones

arreglos multidimensionales

empezando en

arreglo en forma indexada

elementos que se almacenen

arreglo es tambin ejemplo

ejemplo en este sentido

foreach en matrices