domingo, 19 de marzo de 2017
Definición de vector en Pascal
Un vector, array o arreglo es una porción de determinado
tamaño en la que se pueden ingresar muchos valores de un mismo tipo. Para
identificar cada porción de memoria se emplea un índice. De este modo, por
ejemplo, podemos evitar estar declarando 20 variables de tipo integer y
declarar un vector de tamaño 20.
La forma en como se declara un vector es como sigue:
1) Empleando tipos
type
TVector = array[1..10] of tipo_dato;
var
Vector: TVector;
2) empleando una variable directamente:
var
Vector = array[1..10] of tipo_dato;
Después para hacer uso del vector debemos identificar la
posición de memoria, valiéndonos de un índice.
variable := vector[6];
vector[3] := 89;
Un ejemplo del uso de un vector puede ser por ejemplo para
llevar un registro de las temperaturas mínima y máxima de los días de la
semana. Al finalizar, le podemos aplicar algunas operaciones... por ejemplo:
calcular la temperatura promedio de la semana, la máxima o la mínima, la
moda... etc. Entonces:
type
TDatosTemperatura = record
Minima, Maxima: real;
end;
TVectorTemperatura = array[1..7] of TDatosTemperatura;
var
Vector: TVectorTemperatura;
...
for dia := 1 to 7 do
begin
suma_min := suma_sim + vector[dia].Minima;
suma_max := suma_max + vector[dia].Maxima;
end;
media_min := suma_min/7;
media_max := suma_max/7;
Las operaciones que se le apliquen dependerá del propósito.
Creo que con esto se puede entender medianamente el tema. En
otras ocasiones he hablado y profundizado más en el concepto. Si te interesa,
puedes bucear entre mis respuestas y leer las relacionadas con el tema.
sábado, 18 de marzo de 2017
Partes de los Arreglos de Pascal
- Arrays de una dimensión
Un arrays (que algunos autores traducen como
"arreglo") es una estructura que se utiliza para guardar una serie de
elementos, todos los cuales son del mismo tipo (por ejemplo, 20 números
reales).
A la hora de definir un arrays, deberemos indicar el índice
inferior y superior (desde dónde y hasta dónde queremos contar), separados por
dos puntos (..), así como el tipo de datos de esos elementos individuales. Por
ejemplo, para guardar hasta 200 números enteros, usaríamos:
lista: arrays [1..200] of integer
Se suele emplear para definir vectores o matrices. Para
mostrar en pantalla el segundo elemento de esa lista de números (o de ese
vector) se usaría
write( lista[2] );
Un ejemplo completo, que guarde varios datos en un array y
luego muestre uno de ellos podría ser:
(* ARRAY00.PAS, Contacto con arrays *)
(* Datos en posiciones prefijadas *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
Arrays00;
var
datos: arrays[1..4] of integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
writeLn('El
segundo dato es ',dato[2]);
end.
Es habitual recorrer todo un arrays usando un bucle
"for", de modo que podamos pedir y mostrar los datos de forma
repetitiva. Por ejemplo, podríamos pedir al usuario 5 números y luego
mostrarlos en orden inverso, así:
(* ARRAY01.PAS, Ejemplo de uso de arrays (01): *)
(* Pedir datos y mostrarlos al revés *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
Array01;
var
datos: arrays[1..5] of integer;
i: integer;
begin
for i := 1 to 5 do
begin
write('Deme el dato ',i,': ');
readLn(datos[i]);
end;
write('Los datos
al reves son: ');
for i := 5 downto 1 do
write(datos[i], ' ');
writeLn;
end.
- Buscar en un arrays
Buscar en un arrays "tiene truco": si el elemento
que estamos mirando contiene el dato que buscábamos, sabremos con seguridad que
el dato existía, pero, por el contrario, no podremos afirmar que un dato no
existe hasta que no hayamos comprobado todos los elementos. Por eso, lo
habitual es usar un "boolean" para memorizar si lo hemos encontrado o
no:
(* ARRAYB.PAS, Buscar en un arrays *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArrayB;
var
datos: arrays[1..5] of integer;
i: integer;
encontrado: boolean;
begin
for i := 1 to 5 do
begin
write('Deme el dato ',i,': ');
readLn(datos[i]);
end;
encontrado :=
false;
write('Buscando un
10... ');
for i := 1 to 5 do
if datos[i] = 10 then encontrado :=
true;
if encontrado then
writeLn('Encontrado!');
else
writeLn('No encontrado.');
end.
- Máximo y mínimo de un arrays
No es difícil encontrar el valor máximo o el mínimo de un
arrays. Debemos empezar con un máximo (o mínimo) provisional, que puede ser el
primer valor del arrays. A partir de ese punto, vamos comparando uno a uno con
todos los demás datos. Si el dato actual es mayor que el máximo (o menor que el
mínimo), pasará a ser nuestro nuevo máximo (o mínimo), que deberemos memorizar.
(* ARRAYSMAX.PAS, Maximo valor en un arrays *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArraysMax;
var
datos: arrays[1..6] of integer;
i: integer;
maximo: integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 48;
datos[6] := 14;
maximo := datos[1];
for i := 2 to 6 do
if datos[i] > maximo then
maximo :=
datos[i];
writeLn('El maximo
es: ', maximo);
end.
(* Resultado:
El maximo es: 48*)
- Arrays de dos o más dimensiones
Cuando se trata de una matriz de 2, 3 o más dimensiones,
podemos indicar los rangos de valores aceptables, separados por comas. Por
ejemplo, una matriz de bidimensional de tamaño 3x2 que debiera contener números
reales sería:
matriz1: arrays [1..3, 1..2] of real
y para ver el elemento (3,1) de la matriz haríamos:
writeLn( matriz1[3,1] );
Un ejemplo más completo, que pidiera 2x3 datos y mostrar uno
de ellos sería:
(* ARRAYBI.PAS, Array bidimensional *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program
ArrayBi;
var
datos: arrays[1..2, 1..3] of integer;
fila,columna: integer;
begin
for fila := 1 to 2 do
for columna := 1 to 3 do
begin
write('Deme el dato de la fila ',fila,
' y
columna ', columna, ': ');
readLn(datos[fila, columna]);
end;
writeLn('El dato
de la fila 1 y columna 2 es ', datos[1,2]);
end.
(* Ejemplo de ejecucion:
Deme el dato de la fila 1 y columna 1: 1
Deme el dato de la fila 1 y columna 2: 20
Deme el dato de la fila 1 y columna 3: 3
Deme el dato de la fila 2 y columna 1: 54
Deme el dato de la fila 2 y columna 2: 15
Deme el dato de la fila 2 y columna 3: 9
El dato de la fila 1 y columna 2 es 20*)
- Sobredimensionar un arrays
Cuando no sabemos cuántos datos vamos a tener que guardar,
una primera solución es sobredimensionar: crear un arrays más grande de lo que
esperemos necesitar y llevar un contador de cuántos datos ya hemos almacenado:
(* ARRAYSD.PAS, Array sobredimensionado *)
(* Parte de CUPAS5, por Nacho Cabanes *)
program ArraySD;
var
datos:
arrays[1..20] of integer; { Los datos en si }
cantidad:
integer; { Cantidad de datos guardados }
i:
integer; { Para bucles }
begin
{ Pedimos 200
datos o hasta introducir el valor 999 }
cantidad := 0;
repeat
if cantidad
>= 200 then
writeLn('No caben mas datos!')
else
begin
cantidad
:= cantidad+1;
write('Deme el dato ',cantidad,' (999 para salir): ');
readLn(datos[cantidad]);
end;
until
datos[cantidad]=999;
{ El ultimo dato
no hay que guardarlo }
cantidad :=
cantidad-1;
{ Al final,
muestro todos }
writeLn('Cantidad
de datos: ', cantidad);
writeLn('Los datos
al reves son: ');
for i := cantidad downto 1 do
write(datos[i], ' ');
writeLn;
end.
(* Ejemplo de ejecucion:
Deme el dato 1 (999 para salir): 23
Deme el dato 2 (999 para salir): 45
Deme el dato 3 (999 para salir): 7
Deme el dato 4 (999 para salir): 16
Deme el dato 5 (999 para salir): 999
Cantidad de datos: 4
Los datos al reves son: 16 7 45 23*)
- Borrar e insertar en un arrays
En un arrays sobredimensionado, nos puede interesar borrar o
insertar datos. Para borrar, deberemos desplazar hacia "la izquierda"
(hacia el principio del arrays) los datos que hay desde esa posición, y luego
disminuir el contador de datos:
(* ARRAYSBor.PAS, Borrar en un arrays sobredimensionado *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
ArraysBor;
var
datos: arrays[1..10] of integer;
cantidad: integer;
i: integer;
posicionBorrar:
integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 8;
datos[6] := 49;
cantidad := 6;
{ Primero
mostramos los datos }
writeLn('Los datos
iniciales son: ');
for i := 1 to cantidad do
write(datos[i], ' ');
writeLn;
{ Ahora borramos
el tercero }
posicionBorrar :=
3;
for i :=
posicionBorrar to cantidad-1 do
datos[i] :=
datos[i+1];
cantidad :=
cantidad-1;
{ Y mostramos el
resultado }
writeLn('Los datos
tras borrar el tercero son: ');
for i := 1 to cantidad do
write(datos[i], ' ');
writeLn;
end.
(* Resultado:
Los datos iniciales son:
20 12 7 35 8 49
Los datos tras borrar el tercero son:
20 12 35 8 49*)
- Ordenar los datos de un arrays
¿Y si necesitamos ordenar los datos de menor a mayor, o de
mayor a menor, o (pronto) alfabéticamente? Hay muchas formas de hacerlo.
Algunas son eficientes pero difíciles de entender, otras son sencillas pero
lentas, otras son intermedias entre ambas.
Uno de los algoritmos de ordenación más simples y conocidos
es el de "burbuja", en el que se va comparando cada dato con todos
los anteriores, de modo que el más pequeño (el más "ligero", como si
se tratara de una burbuja) vaya desplazándose hacia el final del arrays (como si
"subiera hacia la superficie"). Tras cada pasada, el número más
pequeño quedará colocado en su sitio:
(* ARRAYSORD.PAS, Ordenar un arrays (burbuja) *)
(* Parte de CUPAS5, por Nacho Cabanes *)
Program
ArrayOrd;
var
datos: arrays[1..6] of integer;
i,j: integer;
temporal: integer;
begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;
datos[5] := 49;
datos[6] := 8;
{ Primero
mostramos los datos }
writeLn('Los datos
iniciales son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
{ Ahora ordenamos
mediante burbuja }
for i := 6 downto 2 do
for j := 0 to i - 1 do
if datos[j] > datos[j +
1] then
begin
temporal := datos[j];
datos[j] := datos[j + 1];
datos[j + 1] := temporal;
end;
{ Y mostramos el
resultado }
writeLn('Los datos
tras ordenar son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
end.
(* Resultado:
Los datos iniciales son:
20 12 7 35 49 8
Los datos tras ordenar son:
7 8 12 20 35 49*)
Clasificación de arreglos de pascal
Los arrays se clasifican en:
• Unidimensionales (vectores o listas)
• Multidimensionales (tablas o matrices)
- Arreglos Unidimensionales (Vectores o listas)
Un arrays de una dimensión (vector o lista) es un tipo de
datos estructurado compuesto de un número de elementos finitos, tamaño fijo y
elementos homogéneos.
Supongamos que se desea conservar las edades de 10 personas.
Para almacenar estas edades se necesita reservar 10 posiciones de memoria,
darle un nombre al arrays, y a cada persona asignarle su edad correspondiente.
Nombre del
vector: Edad
Subíndice: [ 1 ], [ 2 ],…
Contenido: Edad [ 2 ] = 15
- Multidimensionales (tablas o matrices)
Hasta ahora nuestros arreglos son solo de una dimensión, es
decir, tenemos nuestros datos
encadenados en línea recta:
[ ] - [ ] - [ ] -
.... - [ ]
pero además, es posible definir arreglos de dos dimensiones,
o también conocidos como matrices:
[ ] - [ ] - [ ] -
.... - [ ]
| | | |
[ ] - [ ] - [ ] -
.... - [ ]
| | | |
. . . .
. . . .
. . . .
[ ] - [ ] - [ ] -
.... - [ ]
A simple vista la estructura parece muy compleja pero no lo
es tanto. En realidad un arreglo
bidimensional es tratado en forma muy similar a un arreglo
unidimensional. Veamos como se
definen:
var nombre: ARRAYS[
rango1, rango2 ] OF tipo;
Por ejemplo:
var Matriz: ARRAYS[ 1..3, 1..5 ] OF integer;
es un arreglo bidimensional de 3x5. Originalmente este
arreglo esta vacio:
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
y si queremos guardar algo en alguna posición solo hacemos:
nombre[ columna, fila
] := valor;
Por ejemplo: Matriz[
2, 2 ]:=3;
y el arreglo quedaría
as¡:
[ ] - [ ] - [ ]
[ ] - [3] - [ ]
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
[ ] - [ ] - [ ]
El resto de las operaciones son las mismas que con los
arreglos.
También podemos utilizar contadores para movernos por las
filas y las columnas de manera de
leer, imprimir o copiar un arreglo bidimensional. Veamos un
ejemplo:
------------------------------------------------------------------------------
uses crt;
var M:
arrays[1..3, 1..4] of integer;
c, f: integer;
begin
randomize;
clrscr;
{ Rellena la matriz
con numeros al azar }
for f:=1 to 4 do
for c:=1 to 3 do
M[c,f] := random(10);
{ Imprime la matriz }
for f:=1 to 4 do
begin
for c:=1 to 3 do write( '[', M[c,f], ']' );
writeln;
end;
readln;
end.
------------------------------------------------------------------------------
Así como arreglos bidimensionales también podemos crear
arreglos de 3, 4, 5 ... y todas las
dimensiones que queramos:
Ej.: var R1:
array[1..3, 0..5, -1..7, -2..6 ] of integer;
Pero solo podemos representar gráficamente hasta de 3
dimensiones, las demás solo se consideran como estructuras para almacenar datos
- Arreglos paralelos
Dos o más arrays que utilizan el mismo subíndice para
referirse a términos homólogos se llaman arrays paralelos.
Basados en el programa anterior, se tienen las edades de 'x'
personas, para saber a qué persona se refiere dicha edad se puede usar otro
arreglo en forma paralela y asociarle los nombres de manera simultánea con las
edades.
Operaciones básicas
- Lectura
Se dice que se efectúa una lectura, o acceso a la
estructura, cuando una variable de tipo arreglo figura como factor en una
expresión. La evaluación del factor se logra, previamente calculando el valor
del índice, para luego acceder en la estructura el valor de la componente
correspondiente.
- Escritura
Se dice que se efectúa una escritura, o asignación
selectiva, si una variable de tipo arreglo aparece a la izquierda en una
instrucción de asignación. En este caso la expresión de la derecha, debe tener
igual tipo que la base del arreglo. También deben calcularse la expresiones que
figuran como índices de la variable, para asignarle posteriormente el valor ya
calculado de la expresión a la derecha del símbolo de asignación.
Características de arreglos en pascal
Un arreglo está formado por un número fijo de elementos
contiguos de un mismo tipo. Al tipo se le llama “tipo base” del arreglo. Los
datos individuales se llaman “elementos” del arreglo. Para definir un tipo
estructurado arreglo, se debe especificar el tipo base y el número de
elementos.
Un arrays se caracteriza por:
1. Almacenar los elementos del array en posiciones de
memoria continua,
2. Tener un único nombre de variable que representa a todos
los elementos, y éstos a su vez se diferencian por un índice o subíndice.
3. Acceso directo o aleatorio a los elementos individuales
del arrays.
Suscribirse a:
Entradas (Atom)