1.1.- Arreglos unidimensionales.
1.1.1.- Conceptos básicos. Un arreglo unidimensional tiene una sola dimensión. En C#, la dimensión se maneja por medio de un par de corchetes. A los arreglos de de una dimensión dimensión también se les les llama listas listas..
1.1.2.- Operaciones. Para manejar un arreglo, las operaciones a efectuarse son:
Declaración del arreglo, Declaración del Creación del Creación del arreglo, Inicialización de Inicialización de de los elementos del arreglo, y Acceso a Acceso a los elementos del arreglo.
A continuación continuación describiremos cada una de de estas operaciones, operaciones, en C#.
Declaración. La declaración de un arreglo unidimensional consiste en establecer las características características del arreglo y sus elementos, por medio de la siguiente sintaxis: > [ ] < ] < identificador > ; Donde: tipo indica tipo indica el tipo correspondiente correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que corresponde al número de elementos del arreglo. Ejemplos: int [ ] a ; float [ ] distancia ; Artículo [ ] art = new Artículo[ 3]; Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación. La creación de un arreglo unidimensional consiste en reservar espacio de memoria para todos sus elementos, utilizando la siguiente sintaxis: < identificador > = new [ tamaño ] ; Donde: new es el operador para gestionar espacio de memoria, en tiempo de ejecución, tamaño es un número entero que representa el número de elementos del arreglo. Ejemplos: a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero. distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante y precisión sencilla .Artículo [] art = new Artículo[3]; Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo
art[0]= new Artículo(); // Se crea el primer objeto del arreglo art art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art
Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida: int [ ] a = new int [10] ; float [ ] distancia = new float[5] ;
Inicialización. Un arreglo es un objeto que,cuando es creado por el compilador, se l e asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero. Si el tipo del arreglo es char , a sus elementos se les asigna el valor '\u0000'. Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false. Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo: int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 }; float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F }; string [ ] pato = { "Hugo", "Paco", "Luís" };
Acceso. Se puede acceder a los valores de los elementos de un arreglo a través del nombre del arreglo y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno. Ejemplo: float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos. float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla. distancia[0] = x + y ; // El valor asignado al primer elemento es 35. distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento. distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento. distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento // y disminuye en 1 el valor del tercero.
distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento. y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.
1.1.3.- Aplicaciones. Listas.
Resolvamos el problema de manejar dos listas: una con los nombres de un grupo de alumnos y otra con una calificación para cada uno de los alumnos. Primero se deberán leer los nombres de los alumnos y la calificación que corresponde a cada uno de ellos y después habrá que desplegar dos columnas: una con los nombres de los alumnos y la otra con sus respectivas calificaciones. La lectura debe lucir de manera similar a la siguiente: Número de alumnos: 30 Nombre [0] : Calificación[0] : Nombre [1] : Calificación[1] : Nombre [2] : Calificación[2] : ... ... Nombre [29] : Calificación[29] : El despliegue en el monitor luciría así: No. Nombre
Calif.
1 Hugo
100
2 Paco
90
3 Luís
95
...
...
30 Donald
70
El siguiente código corresponde a un programa que resuelve el problema. // Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de
// alumnos de una materia. using System; using C = System.Console; public class Lista { public static void Main() { int nAlumnos; C.Write("Número de alumnos: "); nAlumnos = Convert.ToInt32(C.ReadLine()); string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de //alumnos. int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones. // Lee los elementos de los dos arreglos. for(int i = 0; i < nAlumnos ; i++) { C.Write("Nombre del alumno [" + i + "] : "); alumnos[i] = C.ReadLine( ); C.Write("Calificación [" + i + "] : "); calif[i] = Convert.ToInt32(C.ReadLine( )); } // Despliega los valores de los dos arreglos. C.WriteLine("No. Nombre Calif."); for(int i = 0 ; i < nAlumnos ; i++) {
C.Write(" " + (i+1) + ".- " + alumnos[ i] ); C.WriteLine(" " + calif[i] ); } } }
Vectores. Otra de las aplicaciones de los arreglos es el manejo de vectores. En Física, los vectores sirven para representar velocidades, aceleraciones, etc. Podemos representar a un vector como un segmento de recta dirigida que tiene magnitud, orientación y sentido. En un espacio tridimensional, un vector puede expresarse por medio de tres componentes sobre los ejes cartesianos. Cada componente puede, a su vez, expresarse en función de los vectores unitarios i, j, k ,que se ubican en los ejes x, y, z, respectivamente. Por ejemplo , un vector v1 puede representarse en función de sus componentes como: v1 = 20i + 15j + 35k Si tenemos otro vector, v2 = -5i + 40j + 25k La suma de los dos vectores sería: s = v1+v2 = (20-5)i +(15+40)j+(35+25)k s = 15i + 55j + 60k Un segmento del programa para este ejemplo sería:
double v1[ ] = new double[3]; double v2[ ] = new double[3]; double s[ ] = new double[3]; v1[0] = 20; v1[1] = 15; v1[2] = 35; v2[0] = -5; v2[1] = 40; v2[2] = 25; for(int i=0; i < 3 ; i++) { s[ i ] = v1[ i ] + v2[ i ] ; }
ARREGLOS UNIDIMENSIONALES Un arreglo unidimensional es un tipo de datos estructurado que está formado por una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. Los datos que se guarden en los arreglos todos deben ser del mismo tipo.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa. Para implementar arreglos unidimensionales se debe reservar espacio en memoria. Los arreglos nos permiten hacer un conjunto de operaciones para manipular los datos guardados en ellos, estas operaciones son: ordenar, buscar, insertar, eliminar, modificar entre otras.
REPRESENTACION EN MEMORIA: Los arreglos guardan en memoria la cantidad de espacios que se le indican en la declaración.
Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar 5 datos de t ipo entero (integer)
x : array[1..5] of integer En memoria el computador guarda 5 espacios: esto quiere decir en el arreglo X en la posición 1 guarda 34, en el arreglo X en la posición 2 guarda 2 2, asi hasta la última posición del arreglo X posicion 5 guarda 72. X [1] 34 X [2] 22 X [3] 39 X [4] 63 X [5] 72 Declaracion de los arreglos unidimensionales: Se declara el tipo del arreglo, con la palabra reservada TYPE, luego se declara la variable de tipo arreglo, esto se hace en el bloque de declaracion de variables palabra reservada VAR.
Type nombre_arreglo= array[x..y]of tipo_dato; Ejemplos: salarios= arr ay [1…x] of real; nombre_trabajador=array[1..x] of string; Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string etc. Variables tipo array Var sueldo:salarios; nombre:nombre_trabajador; Una vez declarados los arreglos procedemos a cargar información en ellos, para esto usamos estructuras repetitivas la mas recomendable por su f acilidad es el for, una vez cargada la información se puede hacer cualquier operación de calculo y por último mostramos la información de los arreglos usando de igual manera la estructura repetitiva for. carga de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo: for i:=1 to num do begin readln(notas[i]); end; Mostrar la información de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo:: for i:=1 to num do begin writeln(notas[i]:3:1); end; Se han hechos programas que suman una cantidad de números usando dos variables, una para leer cada número y otra para acumular la suma. Este enfoque tiene la desventaja de que se pierden los valores de los sumandos. El uso de arreglos permite calcular la suma de los números con una cantidad mínima de código y a la vez conservar cada valor, como muestra el siguiente programa completo:
Program SumaN; Uses Crt;
Const n = 5; Var nums: Array[1..n] Of Integer; s, i: Integer; Begin For i:=1 To n Do Begin Write('Escriba el número: '); ReadLn(nums[i]); s := s + nums[i]; End; WriteLn('La suma es: ', s); End. Nótese el uso de una constante para marcar el tamaño del arreglo; dicha constante, también sirve para controlar el For. De este modo, sólo se hace necesario cambiar un número para adecuar el programa a la esc ala apropiada Ejercicios de arreglos unidimensionales:
* Dadas n cantidad de notas, calcular e imprimir el promedio de las notas y todas las notas que fueron mayor a la media calculada. PROGRAM calificaciones; USES CRT; type listacalificaciones=array[1..n]of real; VAR notas:listacalificaciones; media,suma:real; num,i:integer; BEGIN WRITELN('INTRODUZCA la cantidad de notas a procesar'); READLN(NUM); suma:=0; for i:=1 to num do
begin readln(notas[i]); suma:=suma+notas[i]; end; media:=suma/num; writeln('la media es:' , media:2:2); writeln('la lista de calificaciones mayores a la media es:'); for i:=1 to num do begin if notas[i]>media then writeln(notas[i]:3:1); readln; end; END. (*Escribir un programa en pascal que rellene un array con 11 numeros, luego dividirlos entre 3 y mostralos por pantalla *) PROGRAM numeros; USES CRT; type arreglonumeros=array[1..11]of real; VAR num:arreglonumeros; i:integer; numero:real; BEGIN for i:=1 to 11 do begin WRITELN('Introduzca el numero ' , i, ' a dividir'); readln(num[i]); numero:=num[i]/3; write('los numero resultantes de la division son:' ,numero:2:2); readln; end; end.
Ejemplo 1: Elabore un programa que permita leer una lista de números en un arreglo, calcule la suma, promedio, cuadrado , cubo y desviación estándar de los mismos: #include stdio.h> #include stdlib.h> #include conio.h> #include math.h> #define tam 4 /* programa para calcular la suma, promedio, cuadrado, cubo y desviación estandar de una serie de números */ main ( ) {
double vector[tam],cuadrado, cubo; float prom, desv,suma=0; int i, j; system("cls" ); printf ("PROGRAMA PARA CALCULAR \n"); printf(" PROMEDIO, SUMA, CUADRADO, CUBO Y DESV. EST.\n\n") ; //Captura de valores y suma de los m ismos for(i = 0 ; i < tam ; ++i) { printf ("num [%d] = " , i) ; scanf ("%lf" , &vector[i]) ; suma+= vector[i] ; } prom = suma / tam ; printf (" \n El promedio de los numeros es: %4 .2f\n ", prom) ; //Calculo e impresión de cuadrado, cubo y desviación estandar printf(" \n \n NUMERO CUADRADO CUBO DESV. EST.\n"); for( i = 0 ; i < tam ; ++i ) { cuadrado = vector[i] * vector[i] ; cubo = pow (vector[i], 3) ; desv = vector [i] - prom ; printf ("%.2lf", vector[i] ) ; printf (" \t%.2lf", cuadrado) ; printf (" \t%.2lf", cubo) ; printf (" \t%.2f\n", desv) ; } system("pause"); return(0); } Nota que los valores fueron declarados de tipo double no ente ros, por el tamaño de los valores que se generan en los cálculos. Ejemplo 2: El siguiente programa lee 5 valores de teclado y los guarda en un arre glo a. Luego los escribe. #include stdio.h> #include stdlib.h> main() {
int a[5],i,num; for(i=0; i<5;i++){ printf("Digite el numero:\n"); scanf("%d",&num); a[i]=num; } printf("\nEscribiendo el arreglo con los datos leidos:\n\n"); for(i=0; i<5;i++){ printf("a[%d]= %d\n\n",i,a[i]); } system("pause"); return 0; } Ejemplo 3: El siguiente programa, pide 5 numeros y c alcula los cubos de ellos, los cuales son guardados en un arreglo y son desplegados. #include stdio.h> #include stdlib.h> #include math.h> main() { int i; double a[5], num; for (i=0; i<5; i++) { printf("\n Digite numero:"); scanf("%lf", &num); a[i]=num; } printf("_________________________________________\n"); printf("Los cubos de los numeros leidos son:\n"); for (i=0; i<5; i++){ a[i]=pow(a[i],3); printf("%.0lf\n",a[i]); } printf("\n"); system("pause"); return 0; }
