Clase Teórica Nro 9

INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
ARREGLOS EN PASCAL.
Un arreglo en cualquier lenguaje de programación es una sucesión consecutiva de bytes en memoria. Los arreglos pueden representar:
Matrices (de 2 ó más dimensiones).
Vectores (de una sola dimensión).
La cantidad de bytes que ocupa un arreglo depende del tipo de dato que almacene
cada domicilio. Así un arreglo de 4 domicilios de tipo char ocupará 4 bytes, mientras
que un arreglo de 4 domicilios de tipo double ocupará 32 bytes. Este es un dato muy a
tener en cuenta cuando se dimensiona un arreglo a fin de no sobrecargar demasiado
la memoria.
La forma clásica de una matriz de m x n que nosotros representamos como:
m [filas]
n [columnas]
en una computadora no existe: allí los arreglos son siempre lineales (no olvidar que
la memoria es secuencial). La simulación a una matriz bidimensional se obtiene como
(por ejemplo para una matriz M de 3 x 10):
1
10 11
Fila 1
20
Fila 2
30
Fila 3
La posición correspondiente para el elemento [2,4] vendría dada por la expresión:
Offset para M[2,4] = PosInicio + [(Fila – 1) x DIM2] + (Col-1)
Offset para M[2,4] = PosInicio + (2 – 1) x 10 + 3
Offset para M[2,4] = 13
Offset significa el desplazamiento desde PosIni.
Por supuesto, hemos asumido que cada elemento del arreglo contiene un dato de tipo
char o byte que solo ocupa 1 byte de memoria.
En caso de que cada domicilio contuviera un dato de mayor longitud, por ejemplo de
tipo Word, haríamos la siguiente modificación:
Offset para M[2,4] = PosInicio + [(Fila – 1) x DIM2 + (Col - 1)] x Sizeof(Tipo)
Clase Teórica Nro 9
Pág 1/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
Es posible obtener una expresión para 3 dimensiones, pero normalmente trabajaremos
solo hasta 2.
Declaración formal de un arreglo en Pascal.
var Mat : array[DIM1,DIM2]of <Tipo>;
En el cual DIM se especifica como un subrango de tipo ordinal que tiene un límite
inferior y un límite superior:
var
Mat : array[1..4,1..5]of integer;
Vect : array[1..100]of boolean;
Letras: array[1..27]of char;
etc.
En realidad lo conveniente es crear un “alias” para los arreglos, mediante una declarativa type:
const DIM1 = 4;
DIM2 = 5;
type TMat = array[1..DIM1,1..DIM2]of integer;
TVect = array[1..100]of boolean;
etc,
Luego en el bloque var ponemos:
var
Mat : TMat;
V1 : TVect;
etc.
El bloque type en realidad permite construir nuevos tipos de datos pero basados en los
que ya se hallan predefinidos en el lenguaje.
El límite inferior y superior de cada dimensión no tiene por qué arrancar siempre en 1
ni siquiera ser de tipo numérico. Las siguientes declarativas son perfectamente posibles:
type TMat = array[‘A’..’Z’]of char;
TVect = array[-10..-5]of double;
En el primer caso la variable de control de lazo deberá ser de tipo char y moverse entre estos dos límites:
var c : char;
for c:=’A’ to ‘Z’ do .....
Cómo se accesa un domicilio de un arreglo.
Los elementos de un arreglo pueden accesarse para leer o para escribir su contenido.
La forma de hacerlo es:
M[Fila,Col]:=.......
Vect[i]
:=.....
Clase Teórica Nro 9
Pág 2/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
ó bien: if(Mat[i,j]=....) then .....
Para asignar por completo un arreglo:
for i:=1 to DIM1 do
for j:=1 to DIM2 do
M[i,j]:=20+random(81);
Para mostrarlo en pantalla:
for i:=1 to DIM1 do begin
for j:=1 to DIM2 do write(M[i,j]:4);
writeln;
end;
Nótese que hemos utilizado la sentencia write( ) con formato para imprimir cada fila
completa sobre el mismo renglón y encolumnando con 4 espacios. El writeln sólo, se
emplea para bajar un renglón.
Un caso particular de arreglos: las cadenas.
Hasta ahora hemos estudiado un tipo individual de datos: los char o caracteres, que
representan cualquier elemento de la tabla ASCII (American Standard Code Information Interchange) o Código Standard Americano para el Intercambio de Información.
En esta tabla se hallan todos los caracteres alfabéticos, numéricos, de puntuación, caracteres especiales y caracteres de control. A nosotros sólo nos interesa los alfabéticos y numéricos. A cada caracter le es asignado un valor numérico único, por ejemplo:
A
B
C
....
a
b
c
...
65
66
67
0
1
2
48
49
50
97
98
99
{
}
[
123
125
91
Así, al pulsar un caracter cualquiera del teclado, el mismo genera automáticamente
alguno de estos códigos. Cuando muchos caracteres conforman palabras y texto,
Pascal provee un tipo especial de dato que permite manejarlos de forma muy cómoda
y sencilla: los datos de tipo string. Este tipo especial de dato se trata de un arreglo de
char, aunque en su sintaxis no aparezca la declarativa array[...]of char.
Su declarativa es la siguiente:
var
Texto : string;
Frase : string[80];
Clase Teórica Nro 9
Pág 3/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
La primera (string), es la declarativa por defecto. Pascal asigna 255 espacios para almacenar caracteres. Si lo que vamos a manejar son cadenas pequeñas, podemos
acotar la cantidad de domicilios colocando entre corchetes el espacio requerido.
El domicilio 0 (cero) tiene un uso muy particular: Pascal almacena allí (en forma de
equivalente char) la cantidad de caracteres que han ingresado a la cadena. De esta
forma:
Frase:=’Programación en Turbo Pascal’;
que contiene 28 caracteres, se almacena como:
0
Pr og r a m a c i ó n
en Turbo Pascal
Equivalente char de la longitud de la cadena
Cómo determinar la longitud de una cadena.
Pascal provee una función específica:
length( var string);
Que retorna un entero equivalente a la cantidad de caracteres de la cadena.
De esta manera:
Longitud:=length(Frase)
quedaría cargado con la magnitud 28.
Cuándo emplear arreglos en un problema.
Imaginemos que disponemos de una frase en la cual deseamos detectar la cantidad
de vocales a, e, i, etc., presentes en la misma.
type
var
TVoc = array[1..5]of integer;
Voc : TVoc;
Frase : string;
i
: integer;
begin
clrscr; highvideo;
Frase:=’Esta es una frase breve de prueba’;
for i:=1 to 5 do Voc[i]:=0;
for i:=1 to lenght(Frase) do
case Frase[i] of
‘a’,’A’ : Voc[1]:=Voc[1]+1;
‘e’,’E’ : Voc[2]:=Voc[2]+1;
‘i’,’I’ : Voc[3]:=Voc[3]+1;
Clase Teórica Nro 9
Pág 4/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
‘o’,’O’ : Voc[4]:=Voc[4]+1;
‘u’,’U’ : Voc[5]:=Voc[5]+1;
end;
for i:=1 to 5 do writeln(‘Vocal ‘,chr(64+i),’=’,Voc[i]);
readkey;
end.
Aquí aparecen un par de cositas nuevas: una extensión de la instrucción case y una
instrucción nueva: chr( ).
La estructura case permite varias posibilidades. En una clase anterior la mostrábamos
con un listado de constantes aisladas:
case VarOrdinal of
caso 1 : begin instrucciones 1; end;
case 2 : begin instrucciones 2 ; end;
case 3 : begin instrucciones 3; end;
..........
case n : begin instrucciones n; end;
end;
También admite la siguiente sintaxis:
case VarOrdinal of
Valor1 .. Valor2 : begin instrucciones 1; end;
Valor3 .. Valor4 : begin instrucciones 2; end;
etc.
end;
en la cual cada opción se trata de un subrango, como las categorías en los deportes:
case Edad of
5 .. 7 : writeln(‘categoría infantil’);
7 .. 10 : writeln(‘ categoría superjuvenil’);
10..13 : writeln(‘ ...................................’);
etc.
end;
Otra sintaxis admitida es una especie de enumeración:
case VarOrdinal of
valor1,valor2,... : begin instrucciones 1; end;
valor5,valor6,... : begin instrucciones 2; end;
etc.
end;
Obviamente utilizaremos esta notación cuando los valores de cada opción NO SEAN
CONSECUTIVOS, como en el caso de las vocales.
Volviendo a nuestro problema con los arreglos de char, no hubo ninguna dificultad para referirnos a cada caracter almacenado en el arreglo, con la consabida notación:
Clase Teórica Nro 9
Pág 5/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
Frase[ i ]
IMPORTANTE:
En un arreglo (matriz o vector) perteneciente a un determinado tipo, el contenido de
cada domicilio goza de las mismas propiedades que un dato aislado perteneciente al
mismo tipo. Por ejemplo:
var
n : integer;
V : array[1..10]of integer;
V[1], V[2], etc., gozan de las mismas propiedades que n, pues se trata de enteros:
DIV
división entera.
MOD resto de una división entera.
pred predecesor.
succ sucesor.
Otro ejemplo en el cual conviene utilizar arreglos es el siguiente: Convertir un número
binario en su equivalente decimal.
uses crt;
type TBin = array[1..8]of byte;
var
NBin
: TBin;
NDec
: integer;
PesoDig : integer;
i
: byte;
begin
clrscr; highvideo; PesoDig:=128; NDec:=0;
for i:=8 downto 1 do begin
write('NBin ',i,'=');
readln(NBin[i]);
NDec:=NDec+NBin[i]*PesoDig;
PesoDig:=PesoDig DIV 2;
end;
write('El binario ingresado fue ');
for i:=8 downto 1 do write(NBin[i]);
writeln;
writeln('Su equivalente decimal es ',NDec);
readkey;
end.
Clase Teórica Nro 9
Pág 6/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
Como en toda base de numeración los dígitos de mayor peso son los que están más a
la izquierda, hemos trabajado con un lazo for decreciente (downto) de 8 hasta 1. Recuerde que los pesos binarios son:
Pesos
128 64
32
16
8
4
2
1
--------------------------------------------------------------------------8
7
6
5
4
3
2
1
Posiciones
En realidad a la primera posición es cero, pero a fin de no trabajar con potencias de 2,
le llamaremos 1. Además recuerde que los dígitos binarios sólo pueden ser 1’s o 0’s.
Imaginemos que ingresamos:
11001011
Para obtener su equivalente decimal tendríamos que hacer:
1x 128 + 1 x 64 + 0 x 32 + 0 x 16 + 1 x 8 + 0 x 4 + 1 x 2 + 1 x 1
o sea cada dígito por su correspondiente peso (como se vio en la primera clase).
Esta sumatoria de productos se halla implementada dentro del lazo for. Analícela.
Procedimientos y Arreglos.
Este es el momento de ver otras de las aplicaciones de los parámetros por referencia:
cuando un subprograma recibe un arreglo sobre el cual debe trabajar.
(* --- INFORMATICA 2014 - Procedimientos y arreglos 01.pas ---Un procedimiento denominado CargarMatriz( ) recibirá como único parámetro una
matriz de enteros de 10 x 15 y le asignará valores aleatorios en el rango 10, 50 mostrándola por pantalla en forma matricial. Este procedimiento también efectuará la suma
de cada fila, y dicho resultado será mostrado a la derecha de la matriz (a continuación
de cada fila).
Como forma de verificación, vuelva a imprimir la matriz, pero esta vez desde el main( ),
posterior a la invocación.
NOTA: Al pasar la matriz como parámetro variable, TODO lo que se
haga sobre ella subsistirá al finalizar la invocación.
-------------------------------------------------------------------------------------------------------- *)
uses crt;
const DIM1
DIM2
type TMat
var
Mat
i,j
=
=
=
:
:
10;
15;
array[1..DIM1,1..DIM2]of integer;
TMat;
integer;
Clase Teórica Nro 9
Pág 7/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
{ ---------------------------------------------------------------}
procedure CargarMatriz( var M : TMat);
var SumaFila : integer;
i,j
: integer;
begin
for i:=1 to DIM1 do begin
SumaFila:=0;
textcolor(WHITE);
for j:=1 to DIM2 do begin
M[i,j]:=10+random(41);
SumaFila:=SumaFila+M[i,j];
write(M[i,j]:3);
end;
textcolor(LIGHTRED);
writeln(SumaFila:6);
end;
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat);
readkey;
textcolor(LIGHTGREEN);
writeln('---------------------------------------------------');
textcolor(WHITE);
for i:=1 to DIM1 do begin
for j:=1 to DIM2 do write(Mat[i,j]:3);
writeln;
end;
end.
MUY IMPORTANTE: En la declarativa de parámetros formales de un subprograma, ya
sea función o procedimiento, NO SE PERMITEN DECLARACIONES ESTRUCTURADAS, pero en cambio sí un tipo simple creado en la línea type. Por eso es que hemos
declarado un tipo TMat que en realidad representa un dato estructurado: una matriz.
(* --- INFORMATICA 2014 - Procedimientos y arreglos 02.pas ---La misma matriz anterior, pero ahora no sumaremos cada fila sino que simplemente la
cargaremos, la mostraremos y desde el procedimiento se invocara una función de
nombre SumarDiagonal( ) que la recibirá como parámetro por referencia y determinara la suma su diagonal principal (valor que retornara). Este valor será mostrado en
pantalla desde el procedimiento CargarMatriz( ).
--------------------------------------------------------------------------------------------------------- *)
uses crt;
const DIM = 10;
type TMat = array[1..DIM,1..DIM]of integer;
var
Mat : TMat;
Clase Teórica Nro 9
Pág 8/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
{ ------------------------------------------------------------- }
function SumarDiagonal(var M : TMat):integer;
var SumaDiag : integer;
i
: integer;
begin
SumaDiag:=0;
for i:=1 to DIM do
SumaDiag:=SumaDiag+M[i,i];
SumarDiagonal:=SumaDiag;
end;
{ ---------------------------------------------------------------}
procedure CargarMatriz( var M : TMat);
var i,j
: integer;
begin
for i:=1 to DIM do begin
for j:=1 to DIM do begin
M[i,j]:=10+random(41);
write(M[i,j]:3);
end;
writeln;
end;
writeln;
writeln('SUMA DE LA DIAG PRINCIPAL : ',SumarDiagonal(M));
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat);
readkey;
end.
Este es un caso en el cual desde un subprograma se invoca los servicios de otro suprograma: desde el procedimiento CargarMatriz( ) se ha llamado a la función SumarDiagonal( ) la cual retorna a dicho procedimiento el valor solicitado: la suma de la diagonal principal.
(* --- INFORMATICA 2014 - Procedimientos y arreglos 03.pas ---Un procedimiento denominado CargarMatriz( ) recibirá como parámetros una matriz
de enteros de 10 x 15 y un valor dado. La matriz deberá ser cargada con valores aleatorios en el rango 100, 999 y mostrada por pantalla. Este procedimiento también encontrará el máximo valor almacenado (no lo mostrará por pantalla), pero si en cambio
se mostrará desde el punto de invocación (en el main( )).
--------------------------------------------------------------------------------------------------------- *)
uses crt;
const DIM1 = 10;
DIM2 = 15;
Clase Teórica Nro 9
Pág 9/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
type
var
TMat = array[1..DIM1,1..DIM2]of integer;
Mat : TMat;
Max : integer;
{ ------------------------------------------------------------- }
procedure CargarMatriz( var M
: TMat;
var Max : integer);
var i,j
: integer;
begin
Max:=0;
for i:=1 to DIM1 do begin
for j:=1 to DIM2 do begin
M[i,j]:=100+random(900);
write(M[i,j]:4);
if(M[i,j]>Max)then Max:=M[i,j];
end;
writeln;
end;
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat,Max);
writeln(' ------------------------------------------------ ');
writeln('MAXIMO : ',Max);
readkey;
end.
Nótese que los dos parámetros del procedimiento han sido recibidos por referencia, lo
cual indica que en el punto de invocación (main), se mantendrán todas las modificaciones que el procedure haga sobre la matriz y la variable pasadas.
(* --- INFORMATICA 2014 - Procedimientos y arreglos 04.pas ---Un procedimiento denominado CargarMatriz( ) recibirá como parámetros una matriz
de enteros de 10 x 15 y un vector dado, también de enteros. La matriz deberá ser cargada con valores aleatorios en el rango 100, 999 y mostrada por pantalla. Este procedimiento buscará todos los pares que hayan salido y lo almacenará en el vector recibido. Este vector será mostrado desde el main.
---------------------------------------------------------------------------------------------------------- *)
uses crt;
const DIM1
DIM2
type TMat
TVect
=
=
=
=
var
: TMat;
: TVect;
: integer;
Mat
Vect
i
10;
15;
array[1..DIM1,1..DIM2]of integer;
array[1..DIM1*DIM2]of integer;
Clase Teórica Nro 9
Pág 10/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
{ ------------------------------------------------------------- }
procedure CargarMatriz( var M
: TMat;
var V
: TVect );
var i,j,k : integer;
begin
for i:=1 to DIM1*DIM2 do V[i]:=0;
k:=1;
for i:=1 to DIM1 do begin
for j:=1 to DIM2 do begin
M[i,j]:=100+random(900);
write(M[i,j]:4);
if(M[i,j] MOD 2 =0)then begin
V[k]:=M[i,j];
k:=k+1;
end;
end;
writeln;
end;
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat,Vect);
writeln(' ------------------------------------------------ ');
i:=1;
while(Vect[i]<>0)do begin
write(Vect[i]:4);
i:=i+1;
end;
readkey;
end.
Ahora a nuestro famoso procedimiento CargarMatriz( ) le agregaremos más generalidad estableciendo que los limites de los aleatorios ingresen como parámetros. También estableceremos que solamente formarán parte de la matriz aquellas magnitudes
cuyo dígito central sea 5. Para ello nos valdremos de los operadores DIV y MOD. Finalmente este procedimiento rescatará en un vector todos aquellos valores de la matriz cuya suma de dígitos sea igual a 12. He aquí los códigos:
(* --- INFORMATICA 2014 - Procedimientos y arreglos 05.pas ---Un procedimiento denominado CargarMatriz( ) recibirá como parámetros una matriz
de enteros de 10 x 15, un vector de enteros y dos enteros simples. La matriz deberá
ser cargada con valores aleatorios en el rango establecido por los enteros simples, pero con la condición de que todos los valores posean el digito central igual a 5. También
deberá mostrarla por pantalla.
Este procedimiento detectara también todos aquellos valores cuya suma de dígitos
sea igual a 12 y los cargara en el vector.
Este vector será mostrado desde el main.
-------------------------------------------------------- *)
Clase Teórica Nro 9
Pág 11/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
uses crt;
const DIM1
DIM2
type TMat
TVect
=
=
=
=
var
: TMat;
: TVect;
: integer;
Mat
Vect
i
10;
15;
array[1..DIM1,1..DIM2]of integer;
array[1..DIM2]of integer;
{ ------------------------------------------------------------- }
procedure CargarMatriz( var M
: TMat;
var V
: TVect;
Linf : integer;
Lsup : integer
);
var i,j,k : integer;
Dig1 : integer;
Dig2 : integer;
Dig3 : integer;
begin
for i:=1 to DIM1*DIM2 do V[i]:=0;
k:=1;
for i:=1 to DIM1 do begin
for j:=1 to DIM2 do begin
repeat
M[i,j]:=100+random(900);
Dig1:= M[i,j] MOD 10;
Dig2:=(M[i,j] DIV 10) MOD 10;
Dig3:= M[i,j] DIV 100;
until(Dig2=5);
write(M[i,j]:4);
if(Dig1+Dig2+Dig3 = 12)then begin
V[k]:=M[i,j];
k:=k+1;
end;
end;
writeln;
end;
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat,Vect,100,900);
writeln(' ------------------------------------------------ ');
i:=1;
while(Vect[i]<>0)do begin
write(Vect[i]:4);
i:=i+1;
end;
readkey;
end.
Clase Teórica Nro 9
Pág 12/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
(* --- INFORMATICA 2014 - Procedimientos y arreglos 06.pas ---Un procedimiento denominado CargarMatriz( ) recibirá como parámetros una matriz
de enteros de 10 x 15, dos enteros simples (Linf y Lsup) y otros dos parámetros adicionales. La matriz deberá ser cargada con valores aleatorios en el rango establecido
por Linf y Lsup. También deberá mostrarla por pantalla.
Este procedimiento detectara también cual de todas las filas posee suma máxima y
cual fue esa suma, valores que retornara a través de los dos parámetros adicionales.
----------------------------------------------------------------------------------------------------------- *)
uses crt;
const DIM1
DIM2
type TMat
var
= 10;
= 15;
= array[1..DIM1,1..DIM2]of integer;
Mat
FilaSumaMax
SumaMaxima
i
:
:
:
:
TMat;
integer;
integer;
integer;
{ ------------------------------------------------------------- }
procedure CargarMatriz( var M
: TMat;
var FilaSumaMaxima : integer;
var SumaMaxima
: integer;
Linf
: integer;
Lsup
: integer
);
var i,j
: integer;
SumaParcial : integer;
{ suma parcial para cada fila }
begin
SumaMaxima:=0;
for i:=1 to DIM1 do begin
SumaParcial:=0;
for j:=1 to DIM2 do begin
M[i,j]:=Linf+random(Lsup-Linf);
SumaParcial:=SumaParcial+M[i,j];
write(M[i,j]:4);
end;
writeln;
if(SumaParcial>SumaMaxima)then begin
SumaMaxima:=SumaParcial;
FilaSumaMaxima:=i;
end;
end;
end;
{ -------------------------------------------------------------- }
begin (* main *)
clrscr; randomize;
CargarMatriz(Mat,FilaSumaMax,SumaMaxima,100,900);
writeln('-------------------------------------------------');
writeln('SUMA MAXIMA
: ',SumaMaxima);
Clase Teórica Nro 9
Pág 13/14
INFORMATICA CBI – 2015
Dictado : Ing. Juan Manuel Conti
writeln('FILA P/SUMA MAXIMA : ',FilaSumaMax);
readkey;
end.
Clase Teórica Nro 9
Pág 14/14