1.1.- Arreglos unidimensionales.

1.1.1.- Conceptos bsicos.

Un arreglo unidimensional tiene una sola dimensin. En C#, la dimensin
se maneja por medio de un par de corchetes.
A los arreglos de una dimensin tambin se les llama listas.

1.1.2.- Operaciones.
Para manejar un arreglo, las operaciones a efectuarse son:
Declaracin del arreglo,
Creacin del arreglo,
Inicializacin de de los elementos del arreglo, y
Acceso a los elementos del arreglo.
A continuacin describiremos cada una de estas operaciones, en C#.
Declaracin.
La declaracin de un arreglo unidimensional consiste en establecer las
caractersticas del arreglo y sus elementos, por medio de la siguiente
sintaxis:
<tipo> [ ] < identificador > ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes, [ ], representa la dimensin del arreglo y encierra un
nmero entero que corresponde al nmero de elementos del arreglo.
Ejemplos:
int [ ] a ;
float [ ] distancia ;
Artculo [ ] art = new Artculo[ 3];
Observe que, en la declaracin, el espacio entre los corchetes est
vaco. Esto se debe a que, durante dicha operacin, no se reserva
espacio en la memoria.
Creacin.
La creacin de un arreglo unidimensional consiste en reservar espacio de
memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new <tipo> [ tamao ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de
ejecucin,
tamao es un nmero entero que representa el nmero 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 precisin sencilla .Artculo [] art =
new Artculo[3];
Artculo [ ] art = new Artculo[ 3]; // Se crean 3 referencias a objetos de la
clase Artculo
art[0]= new Artculo(); // Se crea el primer objeto del arreglo art
art[1]= new Artculo(); // Se crea el segundo objeto del arreglo art
art[2]= new Artculo(); // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaracin y creacin anteriores se
pueden agrupar en una sola instruccin, como se muestra enseguida:
int [ ] a = new int [10] ;
float [ ] distancia = new float[5] ;

Inicializacin.
Un arreglo es un objeto que,cuando es creado por el compilador, se le
asignan automticamente valores iniciales predeterminados a cada uno
de sus elementos, de acuerdo a los siguientes criterios:
Si el tipo del arreglo es numrico, 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 declaracin,
creacin e inicializacin en una sola instruccin, 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", "Lus" };

Acceso.
Se puede acceder a los valores de los elementos de un arreglo a travs
del nombre del arreglo y un subndice. El subndice debe escribirse entre
corchetes y representa la posicin del elemento en el arreglo. As,
podemos referirnos a un elemento del arreglo escribiendo el nombre del
arreglo y el subndice del elemento entre corchetes. Los valores de los
subndices empiezan en cero para el primer elemento, hasta el tamao
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 precisin
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 calificacin para cada uno de los
alumnos.
Primero se debern leer los nombres de los alumnos y la calificacin que
corresponde a cada uno de ellos y despus 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:
Nmero de alumnos: 30
Nombre [0] :
Calificacin[0] :
Nombre [1] :
Calificacin[1] :
Nombre [2] :
Calificacin[2] :
...
...
Nombre [29] :
Calificacin[29] :
El despliegue en el monitor lucira as:
No. Nombre Calif.
1 Hugo 100
2 Paco 90
3 Lus 95
... ...
30 Donald 70
El siguiente cdigo 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("Nmero 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("Calificacin [" + 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
Fsica, los vectores sirven para representar velocidades, aceleraciones,
etc.
Podemos representar a un vector como un segmento de recta dirigida
que tiene magnitud, orientacin 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 funcin 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 funcin de sus
componentes como:
v1 = 20i + 15j + 35k
Si tenemos otro vector,
v2 = -5i + 40j + 25k
La suma de los dos vectores sera:
s = v1+v2 = (20-5)i +(15+40)j+(35+25)k
s = 15i + 55j + 60k
Un segmento del programa para este ejemplo sera:
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 coleccin
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 posicin 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 declaracin.

Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar 5 datos de tipo entero (integer)

x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto quiere decir en el arreglo X en la posicin 1 guarda 34, en el
arreglo X en la posicin 2 guarda 22, asi hasta la ltima posicin 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= array [1x] 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 informacin en ellos, para esto usamos estructuras repetitivas
la mas recomendable por su facilidad es el for, una vez cargada la informacin se puede hacer cualquier operacin
de calculo y por ltimo mostramos la informacin 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 posicin del arreglo:
for i:=1 to num do
begin
readln(notas[i]);
end;
Mostrar la informacin de un arreglo, la letra i es el indice o subindice del arreglo e indica la posicin del arreglo::
for i:=1 to num do
begin
writeln(notas[i]:3:1);
end;
Se han hechos programas que suman una cantidad de nmeros usando dos variables, una para leer cada nmero 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 nmeros con una cantidad mnima de cdigo 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 nmero: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('La suma es: ', s);
End.

Ntese el uso de una constante para marcar el tamao del arreglo; dicha constante, tambin sirve para controlar el
For. De este modo, slo se hace necesario cambiar un nmero para adecuar el programa a la escala 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 nmeros en un arreglo, calcule la suma,
promedio, cuadrado , cubo y desviacin estndar 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 desviacin
estandar de una serie de nmeros */
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 mismos
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 impresin de cuadrado, cubo y desviacin 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 enteros, por el tamao de los valores
que se generan en los clculos.

Ejemplo 2:
El siguiente programa lee 5 valores de teclado y los guarda en un arreglo 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 calcula 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;
}