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

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

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

// 10 elementos

int i;
for (i=0; i<20; i++)
arreglo[i] = 0;

IIC 1102

// Error para i >= 10

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

2.

Declaracin de un arreglo de 100 caracteres:

char[] A = new char[100];

3.

Declaracin e inicializacin de un arreglo de 10 enteros:

int[] A = { 2, 5, 8, 100, 1, 2, 100, 5, 5, 5 }

4.

Inicializacin parcial: El resto se inicializa en cero:

int[] A = new int[100] { 25, 5, 100, 25, 5 }

5.

Declaracin e inicializacin de un arreglo de 10 caracteres:

char[] A = { 'a', 'z', 'E', 'e', 65, '\65', '@', 'U', '*', '\n' }

6.

Asignando un valor a la sexta posicin 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("{0} ", A[i]);

8.

Imprimiendo un arreglo de 100 enteros mediante un ciclo foreach:

foreach (int i in A)
Console.Write("{0} ", 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 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.

IIC 1102

Llamando una funcin que recibe un arreglo de enteros como

parmetro:
int prom; int[] A;
...
prom = promedio(A);

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;

// Las expresiones tipo float requieren una F al final

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());

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();

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

2.2

Rodrigo Sandoval U.

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;

// Las expresiones tipo float requieren una F al final

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)

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:

IIC 1102

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.

Pgina: 23