- Vectores estáticos (Arreglos unidimensionales)

Hasta ahora hemos visto las tres estructuras de programación fundamentales: estructuras secuenciales, estructuras condicionales y estructuras repetitivas.

Al mismo tiempo hemos empleado variables de distinto tipo para el almacenamiento de datos (variables Integer, Double, String).

En esta sección veremos otros tipos de variables que permiten almacenar un conjunto de datos en una única variable.

Tipo de dato simple: 	Integer (Almacena un único entero)
			Double (Almacena un único valor flotante)
			String (Almacena un conjunto de caracteres)

Estructuras de datos: Array unidimensionales estáticos (Vector estáticos)

Un vector estático es una estructura de datos que permite almacenar un CONJUNTO de datos del mismo tipo.
Con un único nombre se define un vector y por medio de un subíndice hacemos referencia a cada elemento del mismo (componente).

Problema 1

Se desea guardar los sueldos de 5 operarios.
Según lo conocido deberíamos definir 5 variables si queremos tener en un cierto momento los 5 sueldos almacenados en memoria.

Empleando un vector solo se requiere definir un único nombre y accedemos a cada elemento por medio del subíndice.

Nombre del Vector: Sueldos

Accedemos a cada elemento con el subíndice: Sueldos[1] la primer componente, Sueldos[2] la segunda y así sucesivamente.

El contenido de la componente Sueldos [4] es 550.

Todas las componentes son del mismo TIPO de datos (por ejemplo Integer).

La carga de un vector se realiza componente a componente, indicando el subíndice del vector.

Diagrama de flujo:

La estructura de programación que más se adapta para cargar en forma completa las componentes de un vector es un for, ya que sabemos de antemano la cantidad de valores a cargar.

Es fundamental señalar qué elemento se está cargando en cada momento, esto se logra indicando el subíndice del vector: Sueldos[f], como sabemos la variable f es un contador del for que tomará valores entre 1 y 5.

Es un error si disponemos en la carga el nombre del vector únicamente sin indicar subíndice.

Se podría haber cargado con una estructura secuencial:

Por supuesto que emplear una estructura secuencial es mucho más largo y es prácticamente imposible si la cantidad de elementos del vector es muy grande.

Esto significa que no es obligatorio emplear estructuras repetitivas para la carga e impresión de un vector, pero es conveniente.

Es importante entender que cuando cargamos una componente de un vector estamos cargando un tipo de dato simple: un entero, un flotante o una cadena de caracteres. Lo que no se puede hacer es cargar todas las componentes de un vector con una única instrucción:

Tampoco se pueden imprimir todas las componentes de una sola vez, sino hay que indicar componente a componente.

Proyecto58

program Proyecto58;

{$APPTYPE CONSOLE}

type
  TSueldos = array[1..5] of Integer;
var
  Sueldos: TSueldos;
  f: Integer;

begin
  for f:=1 to 5 do
  begin
    Write('Ingrese sueldo ', f, ':');
    ReadLn(Sueldos[f]);
  end;
  WriteLn('Los sueldos que paga la empresa son:');
  for f:=1 to 5 do
  begin
    Write(Sueldos[f], '-');
  end;
  ReadLn;
end.

Con vectores aparece una nueva zona del programa que es la type, en dicha zona declaramos los nuevos tipos de datos.

type
  <Nombre de Tipo>=array[<Valor inicial>..<Valor final>] of <Tipo de dato>;

El <Nombre de Tipo> debe ser un identificador válido. Generalmente se aconseja antecederlo con la letra T que nos recuerda que es un tipo de dato (Ejemplo: TSueldos, TPersonas, TEdades, etc. )

Luego del nombre disponemos un "=" , la palabra clave de Pascal para definir arreglos es "array" y entre corchetes los subíndices inicial y final del vector, por último después de la palabra "of" disponemos el tipo de datos del vector.

En la zona de la var como sabemos se definen variables, en este caso definimos el vector Sueldos de tipo TSueldos.

Es necesario declarar el tipo de dato y luego la variable de ese tipo.

Dentro del algoritmo hacemos referencia a la variable (Sueldos) y no al tipo de dato (TSueldos). Si nos olvidamos de definir la variable Sueldos no se reserva espacio para almacenar los 5 sueldos.

Observemos que en la carga:

  for f:=1 to 5 do
  begin
    Write('Ingrese sueldo ', f, ':');
    ReadLn(Sueldos[f]);
  end;

Indicamos por medio de los corchetes una componente específica.

Inicialmente f vale 1 por lo que estaremos cargando Sueldos[1], luego f se incrementa en 1 y cargaremos Sueldos[2], así sucesivamente hasta cargar Sueldos[5].

Problema 2

Definir un vector de 5 componentes de tipo Double que representen las alturas de 5 personas. Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio y cuántas más bajas.

Diagrama de flujo:

El primer paso es realizar la carga del vector con las 5 alturas (buscar nombres de variables que nos indiquen cuál es su contenido, en este caso un buen nombre es llamar al vector Alturas).

Para obtener el promedio hay que sumar las 5 alturas, a este proceso lo podemos ir realizando a medida que cargamos las componentes del vector (ver diagrama de flujo). Al acumulador suma lo inicializamos previo al for.

Al salir de la estructura repetitiva podemos calcular el promedio de las alturas:

Promedio := suma / 5;

Como el problema pide contar la cantidad de personas más altas y la cantidad de personas más bajas que el promedio necesitamos dos contadores.

A los contadores cant1 y cant2 los inicializamos en cero antes de entrar a la estructura repetitiva.

Dentro del for procesamos (comparamos con el promedio) todas las alturas verificando cada altura con respecto al promedio. Si la altura de una persona supera al promedio incrementamos el contador cant1, en caso que sea inferior incrementamos el contador cant2. Si es igual no hacemos nada.

Importante:

En este problema podemos observar una ventaja de tener almacenadas todas las alturas de las personas. Si no conociéramos los vectores tenemos que cargar otra vez las alturas por teclado para compararlas con el promedio.

Mientras el programa está en ejecución tenemos el vector Alturas a nuestra disposición. Es importante tener en cuenta que cuando finaliza la ejecución del programa se pierde el contenido de todas las variables (simples y vectores).

Proyecto59

program Proyecto59;

{$APPTYPE CONSOLE}

{$R *.res}

type
  TAlturas=array[1..5] of Double;

var
  Alturas: TAlturas;
  f: Integer;
  suma: Double;
  promedio: Double;
  cant1, cant2: Integer;

begin
  suma := 0;
  for f:=1 to 5 do
  begin
    Write('Ingrese altura:');
    ReadLn(Alturas[f]);
    suma := suma + Alturas[f];
  end;
  cant1 := 0;
  cant2 := 0;
  promedio := suma / 5;
  for f:=1 to 5 do
  begin
    if Alturas[f] > promedio then
    begin
      cant1 := cant1 + 1;
    end
    else
    begin
      if Alturas[f] < Promedio then
      begin
        cant2 := cant2 + 1;
      end;
    end;
  end;
  WriteLn;
  WriteLn('Promedio:', promedio:0:2);
  WriteLn('La cantidad de personas mas altas que el promedio:', cant1);
  WriteLn('La cantidad de personas mas bajas que el promedio:', cant2);
  ReadLn;
end.

Cuando ejecutemos el programa recordar que al ingresar la altura se debe cargar un valor Double. Ejemplo: 1.75, utilizando el punto como separador.

El vector debe tener componentes de tipo Double:

  TAlturas=array[1..5] of Double;

La definición del vector:

  Alturas: TAlturas;

Es importante diferenciar la declaración de un tipo de dato (type) y la definición de una variable de ese tipo.

El tipo de dato Integer ya existe y uno sólo tiene que DEFINIR variables de tipo Integer.
El tipo de dato TAlturas en cambio no existe y por eso debemos DECLARARLO en la type. En general siempre que trabajemos con estructuras de datos debemos declararlos en la type.

Definición de varios vectores de un mismo tipo.

Podemos declarar:

  type
    TVector = array[1..10] of Integer;
	
  var
    Vector1: TVector;
    Vector2: TVector;
    VecSuma: TVector;

Hemos declarado un tipo de dato TVector con 10 componentes de tipo Integer. Luego definimos tres variables de tipo TVector. Cada variable tiene reservado espacio para almacenar 10 enteros.

Podemos observar que no es indispensable declarar tres tipos de datos para definir tres vectores. Esto es posible porque los tres vectores son del mismo tipo (vectores de 10 Integer).

Problema 3

Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la mañana y 4 por la tarde).
Confeccionar un programa que permita almacenar los sueldos de los empleados agrupados por turno.
Imprimir los gastos en sueldos de cada turno.

En este problema emplearemos dos vectores para almacenar cada turno.

type
  TSueldos = array[1..4] of Double;

var
  SueldoMa: TSueldos;
  SueldoTar: TSueldos;

Declaramos un tipo de dato vector con 4 componentes de tipo Double.
Definimos 2 vectores del tipo de dato previamente declarado.

Diagrama de flujo:

Proyecto60

program Proyecto60;

{$APPTYPE CONSOLE}

{$R *.res}

type
  TSueldos = array[1..4] of Double;

var
  SueldoMa :TSueldos;
  SueldoTar: TSueldos;
  f: Integer;
  gastoma: Double;
  gastotar: Double;

begin
  WriteLn('Sueldos del turno de la mañana');
  for f:=1 to 4 do
  begin
    Write('Ingrese sueldo:');
    ReadLn(SueldoMa[f]);
  end;
  WriteLn;
  WriteLn('Sueldos del turno de la tarde');
  for f:=1 to 4 do
  begin
    Write('Ingrese sueldo:');
    ReadLn(SueldoTar[f]);
  end;
  gastoma:=0;
  gastotar:=0;
  for f:=1 to 4 do
  begin
    gastoma := gastoma + SueldoMa[f];
    gastotar := gastotar + SueldoTar[f];
  end;
  WriteLn;
  WriteLn('Total sueldos de la mañana:', gastoma:0:2);
  WriteLn('Total sueldos de la tarde :',gastotar:0:2);
  ReadLn;
end.

Cuando codificamos el diagrama, los títulos deben mostrarse antes de entrar a los for:

WriteLn('Sueldos del turno de la mañana');

La acumulación de cada turno puede hacerse también dentro de los for de carga. Como la información está almacenada en los VECTORES podemos acumularlo en otro for:

  gastoma:=0;
  gastotar:=0;
  for f:=1 to 4 do
  begin
    gastoma := gastoma + SueldoMa[f];
    gastotar := gastotar + SueldoTar[f];
  end;

Problemas propuestos

• Desarrollar un programa que permita ingresar un vector de 8 elementos de tipo Integer, e informe:
  El valor acumulado de todos los elementos del vector.
  El valor acumulado de los elementos del vector que sean mayores a 36.
  Cantidad de valores mayores a 50.
  
• Realizar un programa que pida la carga de dos vectores numéricos enteros de 4 elementos. Obtener la suma de los dos vectores, dicho resultado guardarlo en un tercer vector del mismo tamaño. Sumar componente a componente.
• Se tienen las notas del primer parcial de los alumnos de dos cursos, el curso A y el curso B, cada curso cuenta con 5 alumnos.
  Realizar un programa que muestre el curso que obtuvo el mayor promedio general.
• Cargar un vector de 10 elementos y verificar posteriormente si el mismo está ordenado de menor a mayor.

Solución

program Proyecto61;

{$APPTYPE CONSOLE}

type
  TVector = array[1..8] of Integer;

var
  Vec: TVector;
  f: Integer;
  suma: Integer;
  sumamayor36: Integer;
  cant: Integer;

begin
  for f:=1 to 8 do
  begin
    Write('Ingrese elemento:');
    ReadLn(Vec[f]);
  end;
  suma := 0;
  for f:=1 to 8 do
  begin
    suma := suma + Vec[f];
  end;
  WriteLn('La suma de los 8 elementos es:', suma);
  sumamayor36 := 0;
  for f:=1 to 8 do
  begin
    if Vec[f] > 36 then
    begin
      sumamayor36 := sumamayor36 + Vec[f];
    end;
  end;
  WriteLn('La suma de valores mayores a 36 es:', sumamayor36);
  cant := 0;
  for f:=1 to 8 do
  begin
    if Vec[f] > 50 then
    begin
      cant := cant + 1;
    end;
  end;
  WriteLn('La cantidad de valores mayores a 50 es:', cant);
  ReadLn;
end.




program Proyecto62;

{$APPTYPE CONSOLE}

{$R *.res}

type
  TVector = array[1..4] of Integer;

var
  Vec1: TVector;
  Vec2: TVector;
  VecSuma: TVector;
  f: Integer;

begin
  WriteLn('Carga del primer vector.');
  for f:= 1 to 4 do
  begin
    Write('Ingrese elemento:');
    ReadLn(Vec1[f]);
  end;
  WriteLn('Carga del segundo vector.');
  for f:= 1 to 4 do
  begin
    Write('Ingrese elemento:');
    ReadLn(Vec2[f]);
  end;
  for f:= 1 to 4 do
  begin
    VecSuma[f] := Vec1[f] + Vec2[f];
  end;
  WriteLn('Vector resultante.');
for f:= 1 to 4 do
  begin
    Write(VecSuma[f],'-');
  end;
  ReadLn;
end.




program Proyecto63;

{$APPTYPE CONSOLE}

{$R *.res}

type
  TNotas = array[1..5] of Integer;

var
  CursoA: TNotas;
  CursoB: TNotas;
  f: Integer;
  suma1: Integer;
  suma2: Integer;
  promedio1: Double;
  promedio2: Double;

begin
  WriteLn('Carga de notas del curso A');
  for f:= 1 to 5 do
  begin
    Write('Ingrese nota:');
    ReadLn(CursoA[f]);
  end;
  WriteLn('Carga del notas del curso B');
  for f:= 1 to 5 do
  begin
    Write('Ingrese nota:');
    ReadLn(CursoB[f]);
  end;
  suma1 := 0;
  suma2 := 0;
  for f:=1 to 5 do
  begin
    suma1 := suma1 + CursoA[f];
    suma2 := suma2 + CursoB[f];
  end;
  promedio1 := suma1 / 5;
  promedio2 := suma2 / 5;
  WriteLn('Promedio curso A:', promedio1:0:2);
  WriteLn('Promedio curso B:', promedio2:0:2);
  if promedio1 > promedio2 then
  begin
    WriteLn('El curso A tiene un promedio mayor.');
  end
  else
  begin
    WriteLn('El curso B tiene un promedio mayor.');
  end;
  ReadLn;
end.




program Proyecto64;

{$APPTYPE CONSOLE}

{$R *.res}

type
  TVector = array[1..10] of Integer;

var
  Vector: TVector;
  f: Integer;
  orden: Integer;

begin
  for f:=1 to 10 do
  begin
    Write('Ingrese elemento:');
    ReadLn(Vector[f]);
  end;
  orden := 1;
  for f:=1 to 9 do
  begin
    if Vector[f+1] < Vector[f] then
    begin
      orden := 0;
    end;
  end;
  if orden = 1 then
  begin
    WriteLn('Esta ordenado de menor a mayor');
  end
  else
  begin
    WriteLn('No esta ordenado de menor a mayor');
  end;
  ReadLn;
end.