Explicación detallada sobre los algoritmos: 6.1 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.

REPRESENTACIóN 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 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 posición 1 guarda 34, en el arreglo X en la posición 2 guarda 22, asi hasta la última posición del arreglo X posicion 5 guarda 72.

X [1]

X [2]

X [3]

X [4]

X [5]
72

Declaracin 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 [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 facilidad 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 escala apropiada

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

Observaciones:

El tipo-base puede ser cualquiera de los tipos básicos del lenguaje, o incluso algunos complejos como estructuras. Cada elemento del arreglo será del tipo definido aquí.

El identificador es el nombre que distinguirá el arreglo.

Los corchetes [] son obligatorios.

El término NumElementos determina el tamaño del arreglo, es decir, la cantidad de elementos del tipo base que contendrá. Dichos elementos estarán numerados consecutivamente, empezando en 0.

Es posible declarar un arreglo unidimensional y al mismo tiempo inicializar sus elementos con valores del tipo base. La sintaxis para hacer esto es la siguiente:

   <tipo-base> <identificador>[<NumElementos>] = { valor1, valor2, ... };

Observaciones:

Con los valores indicados entre llaves {} se inicializarán los elementos del arreglo.

Los valores deben ser del <tipo-base> del arreglo.

Si se incluyen menos valores que elementos en el arreglo, los últimos serán inicializados en cero.

Si se hace inicialización, es posible omitir el tamaño del arreglo y dejar que el compilador lo deduzca a partir de los valores asignados. Ver ejemplo más abajo.

La declaración de estructuras complejas, como los arreglos, se hace a partir de tipos existentes, por lo que es posible declarar variables de un tipo simple y arreglos con ese tipo como base, en una misma línea. Por ejemplo, en la siguiente declaración se está definiendo una variable entera, llamada numero, y al mismo tiempo un arreglo con 100 enteros, numerados de 0 a 99, y llamado vec:

   int numero, vec[100];

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

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

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.

/* Ejemplo de error por acceso fuera de rango a un arreglo. */ /* Las posiciones con índices del 20 al 29 son inválidas. */ int i, arreglo[20]; for (i=0; i<30; i++) arreglo[i] = 0;

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.

El nombre de un arreglo también puede emplearse sin índice, bajo ciertas circunstancias, por ejemplo, para pasar el arreglo completo como parámetro a una función. Cuando se emplea el nombre solo, lo que se está manejando es en realidad un puntero al primer elemento del arreglo. Más adelante, en la sección de strings se hará una descripción más detallada sobre esto.

Ejemplos

En todos los casos, A es el nombre de la variable declarada:

1.   Declaración de un arreglo de 50 enteros:
        int A[50];

2.   Declaración de un arreglo de 100 caracteres:
        char A[100];

3.   Declaración e inicialización de un arreglo de 10 enteros:
        int A[10] = { 2, 5, 8, 100, 1, 2, 100, 5, 5, 5 }

4.   Inicialización parcial: El resto se inicializa en cero:
        int A[100] = { 25, 5, 100, 25, 5 }

5.   Declaración e inicialización de un arreglo de 10 caracteres:
        char A[10] = { 'a', 'z', 'E', 'e', 65, '\65', '@', 'U', '*', '\n' }

6.   Determinación en forma implícita del tamaño de un arreglo:
        int A[] = { 5, 10, 2, 15, 20 }

7.   Asignando un valor a la sexta posición de un arreglo de enteros:
        A[5] = 200;

8.   Imprimiendo un arreglo de 100 enteros mediante un ciclo for:
        int i;
        for (i=0; i<100; i++)
           printf("%d\n", A[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++)
           scanf("%d", &A[i]);  /* scanf() requiere puntero: & */

10.  Una función que recibe un arreglo de enteros como argumento
     y calcula el promedio:
        int promedio(int A[], int num_elementos) {
           int prom = 0;
           int i;
           for (i=0; i<num_elementos; i++)
              prom = prom + A[i];
           return(prom/num_elementos);
        }

11.  Llamando una función que recibe un arreglo de enteros como
     parámetro:
        int prom, A[100];
        ...
        prom = promedio(A);

12. Contando el número de caracteres de una cadena

    int numero_caracteres (char *s){
        int i=0;
        while (s[i] != `\0`)
           i++;
        return (i);
    }

Para establecer el rango del arreglo (número total de elementos) que componen el arreglo se utiliza la siguiente formula:
RANGO = Ls - (Li+1)
Donde:
ls = Límite superior del arreglo
li = Límite inferior del arreglo
Para calcular la dirección de memoria de un elemento

dentro de un arreglo se usa la siguiente formula:
                A[i] = base(A) + [(i-li) * w]
Donde:
A = Identificador único del arreglo
i = Indice del elemento
li = Límite inferior
w = Número de bytes tipo componente
Si el arreglo en el cual estamos trabajando tiene un índice numerativo utilizaremos las siguientes fórmulas:

                RANGO = ord (ls) - (ord (li)+1)
                A[i] = base (A) + [ord (i) - ord (li) * w]