Tutorial de Como Utilizar Pascal

https://www.youtube.com/watch?v=6aC5_vi6AjQ

Estructura de un Vector en pascal

Partes de un Vector en Pascal

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.

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.

Arreglo en pascal

ARRAYS (ARREGLO): Es un conjunto finito y ordenado de elementos homogéneos.

· Ordenado : cada elemento del arreglo puede ser identificado

· Homogéneo : son del mismo tipo de dato

El tipo más simple de arreglo es el unidimensional o vector (matriz de una dimensión).

Una estructura de datos es "una colección de datos organizados de un modo particular." Las estructuras de datos pueden ser de dos tipos: estáticas y dinámicas.

Las estructuras de datos estáticas son aquellas a las que se le asigna una cantidad fija de memoria cuando se declara la variable. Las estructuras de datos dinámicas son aquellas cuya ocupación de memoria puede aumentar o disminuir durante el tiempo de ejecución. Entre las estructuras de datos estáticas podemos encontrar los vectores y los arreglos, tema que estudiaremos a continuación.

En programación, una matriz o vector (llamados en inglés arrays) es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones). En principio, se puede considerar que todas las matrices son de una dimensión, la dimensión principal, pero los elementos de dicha fila pueden ser a su vez matrices (un proceso que puede ser recursivo), lo que nos permite hablar de la existencia de matrices multidimensionales, aunque las más fáciles de imaginar son los de una, dos y tres dimensiones.

Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los datos se realice de forma aleatoria e impredecible. Por el contrario, si los elementos pueden estar ordenados y se va a utilizar acceso secuencial sería más adecuado utilizar una lista, ya que esta estructura puede cambiar de tamaño fácilmente durante la ejecución de un programa.