Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Arreglosc 1224190931391987 9
Arreglosc 1224190931391987 9
ESCUELA DE INGENIERÍA
DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN
IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN
Profesor: Rodrigo Sandoval U.
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
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.
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.
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.
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];
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.
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
class Arreglo {
int[] numeros;
class MainApp {
a.Imprimir();
a.Ordenar();
a.Imprimir();
a.Reordenar();
a.Imprimir();
Console.ReadLine();
}
}
Ejemplo:
using System;
class MainClass {
Console.ReadLine();
}
}
A continuación se incluyen ejemplos, tanto de declaración y uso de arreglos, como del uso de foreach.
2. 3 Instancias:
La única instancia requerida es notas1, de la clase Curso.
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());
minimo = MAX_NOTA;
maximo = MIN_NOTA;
class MainApp {
Ejemplo de ejecución:
using System;
class Conjunto {
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();
}
return (false);
}
// 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();
// Intersección de Conjuntos
public static Conjunto Interseccion(Conjunto c1, Conjunto c2) {
Conjunto c = new Conjunto();
class MainApp {
Console.WriteLine("Conjunto2 U Conjunto3");
c4 = Conjunto.Union(c2,c3);
c4.Imprimir();
Console.ReadLine();
}
}
Ejemplo de ejecución:
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.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
2. 3 Instancias:
La única instancia requerida es notas1, de la clase Curso.
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
minimo = MAX_NOTA;
maximo = MIN_NOTA;
class MainApp {
Ejemplo de ejecución:
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
}
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 C = Matriz.Multiplicar(A,B);
C.Mostrar();
Ejemplo de ejecución:
Multiplicación de A(NxN) X B(NxN)
Ingrese el valor de N (de 1 a 10): 3
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;