13-Vectores Estáticos (Arreglos Unidimensionales) PDF

Vectores estáticos (Arreglos unidimensionales) https://www.tutorialesprogramacionya.com/delphiya/detalleconcepto.php?punto=13&codigo=95&ini...
13 - 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:
1 de 12 12/05/2019 07:48 a. m.
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
2 de 12 12/05/2019 07:48 a. m.
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:
3 de 12 12/05/2019 07:48 a. m.
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
4 de 12 12/05/2019 07:48 a. m.
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.
5 de 12 12/05/2019 07:48 a. m.
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:
6 de 12 12/05/2019 07:48 a. m.
Proyecto60
7 de 12 12/05/2019 07:48 a. m.
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:
8 de 12 12/05/2019 07:48 a. m.
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.
9 de 12 12/05/2019 07:48 a. m.
program Proyecto61;
{$APPTYPE CONSOLE}
type
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
var
Vec1: TVector;
Vec2: TVector;
VecSuma: TVector;
f: Integer;
begin
WriteLn('Carga del primer vector.');
for f:= 1 to 4 do
begin
ReadLn(Vec1[f]);
end;
WriteLn('Carga del segundo vector.');
for f:= 1 to 4 do
begin
ReadLn(Vec2[f]);
end;
for f:= 1 to 4 do
10 de 12 12/05/2019 07:48 a. m.
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
var
11 de 12 12/05/2019 07:48 a. m.
Vector: TVector;
f: Integer;
orden: Integer;
begin
for f:=1 to 10 do
begin
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.
Retornar (index.php?inicio=0)
12 de 12 12/05/2019 07:48 a. m.

13-Vectores Estáticos (Arreglos Unidimensionales) PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

13-Vectores Estáticos (Arreglos Unidimensionales) PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Vectores estáticos (Arreglos unidimensionales) https://www.tutorialesprogramacionya.com/delphiya/detalleconcepto.php?punto=13&codigo=95&ini...

13 - Vectores estáticos (Arreglos unidimensionales)

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

Nombre del Vector: Sueldos

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

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

Se podría haber cargado con una estructura secuencial:

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

Observemos que en la carga:

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

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

El vector debe tener componentes de tipo Double:

La definición del vector:

Definición de varios vectores de un mismo tipo.

En este problema emplearemos dos vectores para almacenar cada turno.

Declaramos un tipo de dato vector con 4 componentes de tipo Double.

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

S-ar putea să vă placă și