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 ENUMERACIONES .......................................................................................................................................... 23

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];

int [] numeros = new int[10];

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(quot;{0} quot;,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(quot;Hay {0} impares y {1} pares.quot;, 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 en cero:
int[] A = new int[100] { 25, 5, 100, 25, 5 }

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 valor a la sexta posición de un arreglo de enteros:
A[5] = 200;

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

8. Imprimiendo un arreglo de 100 enteros mediante un ciclo foreach:
foreach (int i in A)
Console.Write(quot;{0} quot;, i);

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(quot;Ingrese el número de alumnos en la sección: quot;);
n = int.Parse(Console.ReadLine());

IIC 1102 Página: 8


notas = new float[n];

for(int i=1; i<=n; i++) {
Console.Write(quot;Ingrese la nota {0}: quot;, 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(quot;Promedio de las {0} notas = {1}quot;, notas.Length, promedio);
Console.WriteLine(quot;Mínimo de las {0} notas = {1}quot;, notas.Length, minimo);
Console.WriteLine(quot;Máximo de las {0} notas = {1}quot;, notas.Length, maximo);
}
}

class MainApp {

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
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(quot;CARGA DE DATOS (0 para terminar)quot;);
do {
Console.WriteLine(quot;Ingrese el elemento {0} del conjunto quot;,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(quot;{0} elementos: ( quot;, Largo());
foreach(int n in numeros)
if(n!=0) Console.Write(quot;{0} quot;,n);
else break;
Console.WriteLine(quot;)quot;);
}

// 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 quot;staticquot; -> 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
if (!c.Esta(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
if (c2.Esta(c1.Elemento(i+1)))

return(c); // Se retorna el conjunto resultante
}
}

class MainApp {

Conjunto c1 = 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(quot;¿5 es elemento del conjunto 0? --> {0}quot;, c1.Esta(5));
Console.WriteLine(quot;Se ingresa 5 al conjunto c1quot;);
c1.Agregar(5);
Console.WriteLine(quot;¿5 es elemento del conjunto 0? --> {0}quot;, c1.Esta(5));
c1.Imprimir();
Console.WriteLine(quot;---------------------------quot;);

Console.WriteLine(quot;Ingrese elementos del conjunto 2quot;);
c2.Cargar();

Console.WriteLine(quot;Ingrese elementos del conjunto 3quot;);
c3.Cargar();

Console.WriteLine(quot;Conjunto 2: quot;); c2.Imprimir();
Console.WriteLine(quot;Conjunto 3: quot;); c3.Imprimir();

Console.WriteLine(quot;Conjunto2 U Conjunto3quot;);
c4 = Conjunto.Union(c2,c3);
c4.Imprimir();

Console.WriteLine(quot;Conjunto2 Intersec. Conjunto3quot;);
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
2
3
4
0
---------------------------
Ingrese elementos del conjunto 3
CARGA DE DATOS (0 para terminar)
2
4
6
8
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(quot;{0} quot;, 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(quot;{0} quot;, 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

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.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.

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(quot;Ingrese el número de alumnos en la sección: quot;);
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(quot;Alumno Nº {0}quot;, i);
for(int j=1; j<=5; j++) { // Sólo se asignan 5 notas parciales
Console.Write(quot;Ingrese la nota {0}: quot;, 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);
}

Console.WriteLine(quot;Notas Finales:quot;);
for(int i=0; i<notas.GetLength(0); i++)
Console.Write(quot;{0:F1} quot;,notas[i,5]);
Console.WriteLine(quot;Promedio de las {0} notas = {1}quot;, notas.GetLength(0), promedio);

Console.WriteLine(quot;Mínimo de las {0} notas = {1}quot;, notas.GetLength(0), minimo);

Console.WriteLine(quot;Máximo de las {0} notas = {1}quot;, notas.GetLength(0), maximo);
}
}

class MainApp {

Curso c = new Curso();
c.Calcular();
c.Mostrar();
Console.ReadLine();
}
}


Ingrese el número de alumnos en la sección: 3
Alumno Nº 1
Alumno Nº 2
Alumno Nº 3
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.5 Ejemplo: Multiplicación de Matrices Cuadradas
Se desea realizar la multiplicación AxB de dos matrices cuadradas A y B, utilizando el algoritmo que se
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 siguiente forma:



Conceptualización: El problema consiste en calcular la multiplicación de 2 matrices cuadradas de
igual dimensión. El usuario debe entregar la dimensión y los valores de cada uno de los elementos de
las 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 matrices, las
matrices a multiplicar y la matriz con el resultado.
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
información y funcionalidad para distinguir una matriz de otra, así como los métodos para operar con
ellas, 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)

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



4. Validación
En primera instancia se debe considerar las situaciones extremas para la dimensión de las matrices, tal
es el caso en que se defina como cero como para comprometer la implementación en C# (según la
definición de la matriz).
Por otra parte, otros dominios deben incluir distintos valores para la dimensión 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). También debe estudiarse el
caso en que la dimensión de las matrices es uno, lo cual es correcto pero podría presentar problemas.

5. Limitaciones
No se incluyen controles de validez de los números que ingresa el usuario como elementos de las
matrices, de modo que se supone que se ingresarán valores correctos. De no ser así, el comportamiento
del programa no está definido (es decir, puede pasar cualquier cosa). También se supone que la
dimensión de las matrices es mayor que cero, o el comportamiento del programa no está definido.

Código de la 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 matrices (A y B), calcula la multiplicación empleando un ciclo for
// con anidamiento 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
}

public void Cargar() {
int i,j;
Console.WriteLine(quot;nIngrese los Valores para la matriz:quot;);
for (i=0; i<datos.GetLength(0); i++) {
Console.WriteLine(quot;Fila {0}:quot;, i);
for (j=0; j<datos.GetLength(1); j++) {
Console.Write(quot;tCelda {0}: quot;, 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 multiplicación
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.

Console.WriteLine(quot;nquot;);
// Se imprime por filas completas hacia el lado
for (int i=0; i<datos.GetLength(0); i++) {
Console.Write(quot;| quot;); // Se imprime un separador
for (int j=0; j<datos.GetLength(1); j++)
Console.Write(quot;{0} quot;,datos[i,j]);
Console.WriteLine(quot;|quot;); // Se imprime un separador
}
// Al final de recorrer la fila, se cambia de línea
Console.WriteLine();
}
}

class MainApp {
int N; // Dimension real de las matrices, dada por el usuario
Console.WriteLine(quot;Multiplicación de A(NxN) X B(NxN)quot;);
Console.Write(quot;Ingrese el valor de N (de 1 a 10): quot;);
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(quot;Presione ENTER para terminar...quot;); 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
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



Fila 2:
Celda 0: 3
Celda 1: 2
Celda 2: 1

| 30 24 18 |
| 84 69 54 |
| 138 114 90 |



3 Enumeraciones
Existe una versión simplificada de arreglos, que se declaran con datos incluidos. Estos se utilizan
esencialmente para listar opciones fijas para un programa. Por definición, todos los elementos de las
enumeraciones 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 {
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#

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Arreglos C#

Similaire à Arreglos C# (20)

Dernier

Dernier (20)

Arreglos C#