1
Arreglos Unidimensionales
Un arreglo es una estructura de datos en la que se almacena una colección de datos del mismo tipo.
Ejemplo, el arreglo A contiene números enteros:
(Gp:) 34
(Gp:) 56
(Gp:) 12
(Gp:) 5
(Gp:) 28
(Gp:) 44
(Gp:) 9
(Gp:) 67
(Gp:) 19
(Gp:) 21
(Gp:) 54
(Gp:) 85
(Gp:) A
(Gp:) 1 2 3 4 5 6 7 8 9 10 11 12
(Gp:) posición
(Gp:) A[1] := 34
A[2] := 56
A[3] := 12
…….
…….
A[12]: = 85
(Gp:) Primer elemento del arreglo A.
(Gp:) Segundo elemento del arreglo A.
(Gp:) Doceavo elemento del arreglo A.
(Gp:) Tercer elemento del arreglo A.
2
Declaración
TYPE nombre = ARRAY[1..n] OF TIPO_DATO
Ejemplo:
TYPE vector = ARRAY[1..100] OF INTEGER;
semaforo = (rojo, amarillo, verde);
trafico = ARRAY[1..30] OF semaforo;
VAR
X: vector;
Asignación
X[i] := dato;
Arreglos Unidimensionales
3
Ejemplo
Arreglos Unidimensionales
PROGRAM arreglos;
CONST
N = 10;
TYPE
vector = ARRAY[1..N] OF CHAR;
VAR
A: vector;
i: INTEGER;
BEGIN
FOR i := 1 TO N DO
BEGIN
WRITELN(‘Ingrese caracter ’,i, ‘ : ’);
READLN(A[i])
END
END.
4
Ejercicio
Arreglos Unidimensionales
Escriba un programa que permita encontrar la primera posición de un carácter en una frase contenida en un arreglo.
c
o
m
p
u
t
a
d
o
r
A
1 2 3 4 5 6 7 8 9 10 11 12
Si queremos obtener la posición de la letra ‘t’, el programa debe entregar el número 6.
5
Solución
Arreglos Unidimensionales
PROGRAM buscar_caracter;
CONST
Largo = 20;
TYPE
vector = ARRAY[1..Largo] OF CHAR;
VAR
X: vector; ch: CHAR; i, pos: INTEGER;
FUNCTION buscar(A: vector; dato: CHAR): INTEGER;
VAR
i: INTEGER; {variable local}
BEGIN
i := 1;
WHILE (i < = Largo) AND (A[i] < > dato) DO
i := i + 1;
buscar := i
END;
BEGIN
WRITELN(‘Ingrese frase: ’);
FOR i := 1 TO Largo DO
READ(X[i]);
WRITELN(‘Ingrese caracter a buscar: ’);
READ(ch);
pos := buscar(X, ch);
IF pos > Largo THEN WRITELN(‘No se encuentra el caracter’)
ELSE WRITELN(‘El caracter ’,ch,’ está en la posición ’, pos)
END.
6
Ejercicio: Buscar el mínimo valor y su posición en un arreglo de enteros de largo 10.
Arreglos Unidimensionales
PROGRAM minimo;
CONST
Largo = 10;
TYPE
arreglo = ARRAY[1..Largo] OF INTEGER;
VAR
A: arreglo; i,pos,min: INTEGER;
BEGIN
WRITELN(‘Ingrese ’, Largo, ’ números: ’);
FOR i := 1 TO Largo DO
READLN(A[i]);
min := A[1]; {el primer valor ingresado}
pos := 1; {se guarda la posición del menor valor}
FOR i := 2 TO Largo DO
IF A[i] < min THEN
BEGIN
min := A[i];
pos := i
END;
WRITELN(‘El mínimo es ’, min, ‘ y está en la posición ’, pos)
END.
7
STRING
Es una sucesión de 1 ó más caracteres.
Declaración
VAR nombre: STRING[tamaño];
El tamaño máximo es de 255 caracteres.
Uso
READLN(nombre);
o también
nombre := ‘Programación de Computadores’;
Arreglos Unidimensionales
(Gp:) Si se ubiera definido como ARRAY habría que leer caracter a caracter. Pero al ser del tipo STRING esto es posible.
8
Largo de un STRING
largo := LENGTH(nombre_del_string);
Asignación
str1 := str2 , si tienen el mismo tamaño no hay problema.
si str1 > str2 , se almacena str2 en str1 y toma el largo de str2.
si str1 < str2 , str2 es truncado hasta el tamaño de str1.
Arreglos Unidimensionales
9
Ejercicio: Escriba un programa que guarde una frase en un STRING de largo máximo y convierta las minúsculas en mayúsculas.
Arreglos Unidimensionales
PROGRAM minusculas_en_mayusculas;
CONST
Largo = 255;
VAR
S: STRING[Largo];
L,i: INTEGER;
BEGIN
WRITE('Ingrese frase: ');
READLN(S);
L:=LENGTH(S);
FOR i:=1 TO L DO
IF (S[i] >= 'a') AND (S[i] < = 'z') THEN
S[i] := CHR(ORD(S[i])-32);
WRITELN(S)
END.
10
Ejercicio: Calcular el promedio en un arreglo de largo 100, el cual puede no estar lleno completamente.
Arreglos Unidimensionales
PROGRAM Calcular_Promedio;
CONST L = 255;
TYPE vector = ARRAY[1..L] OF INTEGER;
VAR A: vector; n: INTEGER; respuesta: CHAR;
BEGIN
n := 0;
REPEAT
n := n + 1;
WRITE(‘Ingrese número: ’);
READLN(A[n]);
WRITE(‘Desea ingresar otro número (s/n): ’);
READLN(respuesta);
UNTIL (respuesta = ‘n’) OR (n = L);
WRITELN(‘El promedio es ’, Promedio(A,n))
END.
FUNCTION Promedio(X: vector, k: INTEGER): REAL;
VAR
suma,i: INTEGER; prom: REAL;
BEGIN
suma := 0;
FOR i := 1 TO k DO
suma := suma + X[i];
prom := suma / k;
Promedio := prom
END;
11
Ordenamiento Burbuja
Consiste en ir comparando los casilleros con el de abajo, de manera de ir dejando los menores o más livianos arriba y los mayores o más pesados abajo.
Arreglos Unidimensionales
(Gp:) 15
(Gp:) 8
(Gp:) 4
(Gp:) 50
(Gp:) 3
(Gp:) 8
(Gp:) 15
(Gp:) 4
(Gp:) 50
(Gp:) 3
(Gp:) 8
(Gp:) 4
(Gp:) 15
(Gp:) 50
(Gp:) 3
(Gp:) 8
(Gp:) 4
(Gp:) 15
(Gp:) 50
(Gp:) 3
(Gp:) 8
(Gp:) 4
(Gp:) 15
(Gp:) 3
(Gp:) 50
(Gp:) 8
(Gp:) 4
(Gp:) 15
(Gp:) 3
(Gp:) 50
(Gp:) 4
(Gp:) 8
(Gp:) 15
(Gp:) 3
(Gp:) 50
(Gp:) 4
(Gp:) 8
(Gp:) 15
(Gp:) 3
(Gp:) 50
(Gp:) 4
(Gp:) 8
(Gp:) 3
(Gp:) 15
(Gp:) 50
(Gp:) Aquí se encontró el número mayor.
(Gp:) Aquí se encontró el segundo número mayor.
12
Ordenamiento Burbuja
(continuación)
Arreglos Unidimensionales
(Gp:) 4
(Gp:) 8
(Gp:) 3
(Gp:) 15
(Gp:) 50
(Gp:) 4
(Gp:) 8
(Gp:) 3
(Gp:) 15
(Gp:) 50
(Gp:) 4
(Gp:) 3
(Gp:) 8
(Gp:) 15
(Gp:) 50
(Gp:) Aquí se encontró el tercer número mayor.
(Gp:) 4
(Gp:) 3
(Gp:) 8
(Gp:) 15
(Gp:) 50
(Gp:) 3
(Gp:) 4
(Gp:) 8
(Gp:) 15
(Gp:) 50
(Gp:) Aquí se tiene el arreglo ordenado.
Página siguiente  |