UNIDAD V:

ARREGLOS UNIDIMENSIONALES
 Unidad V: Arreglos Unidimensionales

UNIDAD V: ARREGLOS UNIDIMENSIONALES

1.1 GENERALIDADES:

En los temas anteriores se ha manejado el concepto de variable como todo campo que permite
que el contenido que se encuentra almacenado en el espacio de memoria asignado a dicho
campo, pueda ser alterado en el transcurso de la ejecució n del pseudocó digo. Debemos
comprender que a una variable se le asigna un espacio en memoria donde se puede guardar
de forma temporal un ú nico valor, bien sea numérico, carácter o ló gico.

Frecuentemente tenemos la necesidad de almacenar una colecció n de datos del mismo tipo.
Por ejemplo, cuando se leen las notas de los estudiantes de un curso en particular. Los datos
siempre que estén relacionados se pueden organizar en estructuras, de tal manera que
podemos tener un conjunto de datos numéricos, ló gicos, o caracteres manejados a través de
un mismo nombre. Una estructura de datos es la organizació n que reciben los datos para que
sean tratados como una unidad, esta unidad recibe el nombre de arreglo (array).

Un arreglo es un conjunto finito de componentes del mismo tipo, los cuales se diferencian
o relacionan a través de un subíndice.

1.2 CONCEPTO DE ARREGLO:

Los arreglos son estructuras de datos homogéneas (todos sus datos son del mismo tipo) que
permiten almacenar un determinado nú mero de datos bajo un mismo identificador, para
luego referirse a los mismos utilizando uno o má s subíndices. Los arreglos pueden pensarse
como vectores, matrices, etc. Para poder utilizar un arreglo, primero es obligatorio su
dimensionamiento; es decir, declarar los rangos de sus subíndices, lo cual determina cuantos
elementos se almacenará n y como se accederá a los mismos.

Cada ítem del arreglo se denomina elemento. Los elementos de un arreglo se numeran
consecutivamente 0, 1, 2, 3... Estos nú meros se denominan valores índice o subíndice del
array. El término “subíndice” se utiliza ya que se especifica igual que en matemá ticas, como
una secuencia a0, a1, a2, a3… Estos nú meros localizan la posició n del elemento dentro del
arreglo, proporcionando acceso directo al array.

Si el nombre del array es "a", entonces a[0] es el nombre (valor) del elemento que está en la
posició n 0, a[1] es el nombre (valor) del elemento que está en la posició n 1, etc. En general, el
elemento i-ésimo está en la posició n i-1. De modo que si el array tiene n elementos, sus
nombres son a[0], a[1], a[2], …., a[n-1].

Se pueden declarar má s de un arreglo en una misma instrucció n, separá ndolos con una
coma (,).
Dimension <ident1> (<max11>,...,<max1N>),..., <identM> (<maxM1>,...,<maxMN>)
Grá ficamente se representa así el array “a” de 6 elementos:

Dimension a[6]; //Declara un array de 6 elementos

2
 Unidad V: Arreglos Unidimensionales

El array tiene 6 elementos: a[0] contiene 5, a[1] contiene 8, a[2] contiene 6, a[3] contiene 10,
a[4] contiene 9, a[5] contiene 4. En un array sus elementos se almacenan siempre en una
secuencia de posiciones de memoria contiguas.

1.3 DIMENSIONAMIENTO DE UN ARREGLO:

La instrucció n Dimension permite declarar un arreglo, indicando sus dimensiones.

Dimension nombre_arreglo [tamaño(, tamaño, ...)];

Donde:
• Dimension: Es la palabra reservada del lenguaje que indica que se está declarando un
arreglo.
• nombre_arreglo: Corresponde al identificador por medio del cual podemos
referenciar al arreglo.
• tamaño: Un nú mero entero mayor que cero que indica el tamañ o del array o bien el
nú mero de elementos que será capaz de almacenar el arreglo.

Esta instrucció n define un arreglo con el nombre indicado en <indentificador> y N

dimensiones. Los N pará metros indican la cantidad de dimensiones y el valor má ximo de cada
una de ellas. La cantidad de dimensiones puede ser una o má s, y la má xima cantidad de
elementos debe ser una expresió n numérica positiva.

Si se utilizan arreglos en base 0, al declarar un arreglo de, por ejemplo 15 elementos, los
índices de elementos vá lidos van de 0 a 14; mientras que si se utilizan arreglos en base 1 los
índices vá lidos van de 1 a 15. Esto se configura en la opción Opciones del Lenguaje
(perfiles) del menú Configurar.

Ejemplos de declaración de arreglos:

Definir arreglo_datos, edad como Entero;

Dimension arreglo_datos[25]; // Arreglo con capacidad para almacenar 25 elementos enteros.

Dimension edad[50]; //Arreglo con capacidad para almacenar 50 elementos enteros.

1.4 ARREGLOS EN BASE CERO:

Para empezar a diseñ ar nuestros algoritmos con arreglos en base cero, vamos al menú
Configurar y escogemos Opciones del lenguaje (perfiles), se mostrar un cuadro como este:

3
 Unidad V: Arreglos Unidimensionales

Seleccionamos el perfil <personalizado> y hacemos clic en el botó n Personalizar…

Aparecerá el siguiente cuadro de diá logo:

Marcamos la casilla: Utilizar arreglos en base cero y presionamos aceptar. De esta manera
ya queda configurado el programa para utilizar arreglos en base cero.

Si esta opció n esta activada, el primer elemento de un arreglo de N elementos será el 0 y el

ú ltimo el N-1, en caso de no estar activada esta opció n el primer elemento será el 1 y el ú ltimo
el N.

4
 Unidad V: Arreglos Unidimensionales

Consideraciones: No importa con que base trabajemos en los arreglos: uno o cero, siempre
obtendremos los mismos resultados de forma eficiente, se recomienda al estudiante trabajar
en PSeInt con arreglos en base cero ya que a la hora de aprender un lenguaje de programació n
como por ejemplo C, los arreglos siempre van a comenzar desde cero. También podemos
definir uno o má s arreglos en una misma instrucció n separá ndolos con una coma.

1.5 INICIALIZACIÓN DE UN ARRAY:

Se deben asignar valores a los elementos del arreglo antes de utilizarlos, tal como se asignan
valores a variables. Para asignar valores a cada elemento del arreglo de enteros “edades”, se
puede escribir:

edades [0] <- 15;

edades [1] <- 25;

edades [3] <- 30;

edades [4] <- 35;

La primera sentencia fija edades[0] al valor 15, edades[1] al valor 25, etc. Sin embargo, este
método no es práctico cuando el array contiene muchos elementos. El método utilizado,
normalmente, es inicializar el array completo en una sola sentencia.

Ejemplo #1: Pseudocódigo para inicializar un arreglo de 10 elementos a 0.

Solución #1:

Proceso inicializar
Definir datos,i como entero;
Dimension datos[10];
Para i<-0 Hasta 9 Con Paso 1 Hacer
datos[i] <- 0;
Escribir Sin Saltar datos[i]," ";
FinPara
FinProceso

1.6 OPERACIONES QUE SE PUEDEN REALIZAR EN UN ARREGLO:

Dos operaciones bá sicas pueden ser llevadas a cabo sobre los elementos de un arreglo, estas
son:

• Almacenamiento: establecer un valor al elemento del arreglo.

• Extracción: se obtiene el valor de un elemento del arreglo.

Por ejemplo, si definimos un arreglo llamado array con un tamañ o de tres elementos como se
muestra a continuació n: Dimension array[3];

5
 Unidad V: Arreglos Unidimensionales

Son vá lidos los índices que está n en el rango de 0 a 2.

1.6.1 OPERACIÓN DE ALMACENAMIENTO EN UN ARREGLO:

Esta operació n nos permite almacenar un valor en la posició n que se indique por medio del
índice, por ejemplo: si tenemos un arreglo llamado mis_datos con un tamañ o de tres
elementos y queremos almacenar en la posició n 1 el valor 10, la sentencia sería:

mis_datos[1] <- 10;

La sentencia anterior almacena en posició n correspondiente al índice 1 el valor 10.

1.6.2 OPERACIÓN DE EXTRACCIÓN EN UN ARREGLO:

Esta operació n permite acceder al valor que se encuentre en la posició n indicada por medio
del índice y devuelve ese valor a una variable, por ejemplo: si lo que deseamos es recuperar
valores desde una posició n del arreglo podemos proceder como se indica en el siguiente
ejemplo:

var <- mis_datos [1];

Ejemplo #2: Pseudocódigo que declara e inicializa un arreglo de N datos, de modo que
los elementos de índice par valgan 0 y los de índice impar valgan 1.

Solución #2:

Proceso posiciones_array
Definir#3:
datos_array,v Como Entero;
Solución
Dimension datos_array[100];
Proceso sumpares_prodimpares
Escribir "Cuantos datos desea enprodimp,
el arreglo?";
Definir npar, nimpar, sump, datos, ndatos como entero;
Leernpar<-0;
ndatos; nimpar<-0; prodimp<-1;
ParaDimension
v<-0 Hastadatos[50];
ndatos-1 Hacer
Si v % 2 = 0 Entonces
Escribir 'Cuantos elementos tiene el arreglo?';
datos_array[v]<-0;
Leer ndatos;
Sino
Para d<-1 Hasta ndatos Hacer
datos_array[v]<-1;
Escribir 'Dato[',d,']:';
FinSi Leer datos[d];
Escribir "Dato[",v+1,"]=",datos_array[v];
Si datos[d] % 2 = 0 Entonces
FinPara npar <- npar+1;
FinProceso sump <- sump + datos[d];
FinSi
Si datos[d]
Ejemplo #3: Realice % 2 <> 0 Entonces
un pseudocódigo que declare y lea un arreglo de N elementos,
nimpar
imprimir la suma de los números <- nimpar+1;
pares y el producto de los números impares del
arreglo. prodimp <- prodimp * datos[d];
FinSi
FinPara
Escribir 'ELEMENTOS DEL ARREGLO';
Para d<-1 Hasta ndatos Hacer
Escribir datos[d],' ';
FinPara
Escribir 'La suma de los ',npar,' numeros
6 pares del arreglo es:',sump;
Escribir 'El producto de los ',nimpar,' numeros impares del arreglo
es:',prodimp;
FinProceso
 Unidad V: Arreglos Unidimensionales

Ejemplo #4: Pseudocódigo que declare en un arreglo unidimensional de 50 posiciones,

números pares comenzando por el 2.

Solución #4:
Proceso contenido_numpares
Definir datos_array,v,num Como Entero;
Dimension datos_array[50];
num<-2;
v<-0;
Mientras v<50 Hacer
datos_array[v]<-num;
Escribir "Dato[",v+1,"]=",datos_array[v];
num<-num+2;
v<-v+1;
FinMientras
FinProceso

Ejemplo #5: Se tiene almacenado en memoria en un arreglo de una dimensión las notas
de 50 alumnos del primer parcial correspondiente a la asignatura “Programación I”. Se
pide realizar un pseudocódigo que calcule e imprima:

• La mayor nota.
• La menor nota.

7
 Unidad V: Arreglos Unidimensionales

• El porcentaje de alumnos que aprobaron el parcial con nota superior 60 pts.

• El promedio de las notas.

Solución #5:
Proceso maynota
Definir notas,nalumnos,a,sum_notas,maynota,posmen como entero;
Dimension notas[100];
a<-0;
sum_notas<-0;
maynota<-0;
mennota<-101;
Solución #6:
apro<-0;
Proceso numeros_pos_neg_nul
Escribir Sin Saltar "Numero de alumnos es:";
LeerDefinir number,d,sumpos,sumneg,pos,neg,nul Como Entero;
nalumnos;
Dimension
Repetir number[100];
sumpos<-0;
Escribir Sin Saltar "Calificacion[",a+1,"]:";
sumneg<-0;
Leer notas[a];
pos<-0;
sum_notas<-sum_notas+notas[a];
neg<-0;
Si notas[a] > maynota entonces
nul<-0; maynota<-notas[a];
Escribir
FinSi sin saltar "¿Cuantos datos desea en el arreglo?";
Leer ndatos;
si notas[a]<mennota Entonces
d<-0; mennota<-notas[a];
Mientras d<ndatos Hacer
FinSi Escribir Sin Saltar "Dato[",d+1,"]=";
Leer number[d];
Si notas[a]>=60 entonces
Siapro<-apro+1;
number[d]>0 entonces
FinSi pos<-pos+1;
a<-a+1; sumpos<-sumpos+number[d];
sino
Hasta Que a>=nalumnos
si number[d]<0 Entonces
porapro<-apro*100/nalumnos;
neg<-neg+1;
prom_notas<-sum_notas/nalumnos;
sumneg<-sumneg+number[d];
Escribir "La calificacion mayor del grupo fue de: ",maynota," puntos.";
Sino menor del grupo fue de: ",mennota," puntos.";
Escribir "La calificacion
nul<-nul+1;
Escribir "El porcentaje de aprobados fue del: ",porapro,"%.";
Escribir "El promedioFinSi
de notas es: ",prom_notas;
FinProceso FinSi
d<-d+1;
FinMientras
Escribir "Hay ",pos," numeros POSITIVOS en el arreglo.";
Escribir "Hay ",neg," numeros NEGATIVOS en el arreglo.";
Escribir "Hay ",nul," CEROS en el arreglo.";
Escribir "La suma de los numeros positivos es:",sumpos;
Escribir "La suma de los numeros negativos es:",sumneg;
FinProceso
Ejemplo #6: Pseudocódigo que permita almacenar N números en un arreglo, imprimir
cuántos son ceros, cuántos negativos y cuántos positivos. Imprimir además la suma de
los negativos y los positivos.

8
 Unidad V: Arreglos Unidimensionales

Ejemplo #7: Realice un pseudocódigo que permita introducir en un array de 20

posiciones números aleatorios entre 1 y 100. Utilice la función AZAR().

Solución #7:
Proceso numeros_azar
Definir n, Numeros_azar, numg como entero;
Dimension Numeros_azar[20];

Para n<-0 hasta 19 Con Paso 1 Hacer

numg <- Azar(100)+1;
Numeros_azar[n] <- numg;
Escribir Sin Saltar Numeros_azar[n]," ";
FinPara
FinProceso

Ejemplo #8: Realice un pseudocódigo que permita sumar los elementos de dos arreglos
y guarde el resultado en otro array. Deberá imprimir el array resultante.

Solución #8:
Proceso suma_arreglos
Definir suma,datos1,datos2 como entero;
Dimension suma[5],datos1[5],datos2[5];
Escribir "Datos del Arreglo #1";
Para a1<-0 Hasta 4 con paso 1 Hacer
Escribir Sin Saltar "Datos[",a1+1,"]:";
leer datos1[a1];
FinPara
Escribir "Datos del Arreglo #2";
a1<-0;
Mientras a1 < 5 Hacer
Escribir Sin Saltar "Datos[",a1+1,"]:";
Leer datos2[a1];
suma[a1]<-datos1[a1]+datos2[a1];
a1<-a1+1;
FinMientras
Escribir "***Arreglo Suma***";
a2<-0;
Repetir
Escribir Sin Saltar suma[a2]," ";
a2<-a2+1;
Hasta Que a2>4
Escribir "";
FinProceso 9
 Unidad V: Arreglos Unidimensionales

Ejemplo #9: Pseudocódigo que permita al Director del Consejo Supremo Electoral
encontrar el número y porcentaje de votos obtenidos por cada uno de los 4 candidatos
de la contienda electoral en relación a los votantes que asistieron a las urnas a
depositar su voto. Lea en un arreglo la intención de voto de cada una de las personas.

Solución #9:

Proceso elecciones
Definir nvotos,v,c1,c2,c3,c4,nulos,nv Como Entero;
Definir pc1,pc2,pc3,pc4,pcnul Como Real;
Dimension nvotos[100];
nv<-0;
Repetir
Escribir sin saltar "Su voto es por el candidato (1-2-3-4):";
Leer nvotos[nv];
Segun nvotos[nv]
1:
c1<-c1+1;
2:
c2<-c2+1;
3:
c3<-c3+1;
4:
c4<-c4+1;
De Otro Modo:
Escribir "Voto Nulo";
nulos<-nulos+1;
FinSegun
nv<-nv+1;
Escribir "Hay otro votante: ";
leer resp;
Hasta Que Mayusculas(resp) = 'N'
pc1<- (c1*100)/nv;
pc2<-(c2*100)/nv;
pc3<-(c3*100)/nv;
pc4<-(c4*100)/nv;
pcnul<-(nulos*100)/nv;
Escribir "******RESULTADOS FINALES******";
Escribir "En las elecciones votaron: ",nv," personas";
Escribir "El candidato 1 obtuvo: ",c1," votos -- Porcentaje: ",pc1;
Escribir "El candidato 2 obtuvo: ",c1," votos -- Porcentaje: ",pc2;
Escribir "El candidato 3 obtuvo: ",c1," votos -- Porcentaje: ",pc3;
Escribir "El candidato 4 obtuvo: ",c1," votos -- Porcentaje: ",pc4;
Escribir "Hubieron ",nulos," votos nulos -- Porcentaje: ",pcnul;
FinProceso

10
 Unidad V: Arreglos Unidimensionales

Ejemplo #10: Realice un pseudocódigo que lea un arreglo de N datos y asigne a sus
elementos los valores 1, 4, 9, 16........etc ( 12, 22, 32...).

Solución #10:
Proceso serie
Definir nelem,val,serie, v como entero;
Escribir 'Introduzca el nú mero de elementos del arreglo:';
Leer nelem;
val<-1;
Dimension serie[100];
Mientras val <= nelem Hacer
serie[val] = val^2;
val<-val+1;
FinMientras
v<-1;
Mientras v <= nelem Hacer
Escribir serie[v];
v<-v+1;
FinMientras
FinProceso

11
 Unidad V: Arreglos Unidimensionales

EJERCICIOS PROPUESTOS:

1. Realice un pseudocódigo que lea N elementos y que imprima el número de veces

que se repite un número X en dicho array.

2. Realice un pseudocódigo que almacene en un arreglo unidimensional de tipo

entero los primeros 100 números primos.

3. Realice un pseudocódigo que lea en un arreglo las marcas obtenidas por 10

corredores en una carrera e imprimir cuántos tienen una marca mayor y
cuántos tienen una marca menor que el promedio.

4. Realice un pseudocódigo que almacene en un arreglo unidimensional los

primeros 100 números de la serie Fibonacci e imprima el arreglo
correspondiente.

5. Realice un pseudocódigo que al recibir como dato un arreglo unidimensional de

tipo entero de N elementos, determine si el arreglo es palíndrome. Por ejemplo,
el arreglo que se muestra a continuación es palíndrome:

2 4 5 4 2

6. Pseudocódigo que almacene en un arreglo unidimensional los 30 primeros

números perfectos. Un número se considera perfecto si la suma de los divisores,
excepto el mismo, es igual al propio número. El 6, por ejemplo es un número
perfecto.

7. Pseudocódigo que al recibir un arreglo unidimensional de tipo entero que

contiene calificaciones de exámenes de alumnos, calcule lo siguiente:
a. La media aritmética: Se calcula como la suma de los elementos entre el
número total de elementos.
b. La varianza: Se calcula como la suma de los cuadrados de las
desviaciones de la media, entre el número de elementos.
c. La desviación estándar: Se calcula como la raíz cuadrada de la varianza.
d. La moda: Se calcula obteniendo el mayor con mayor frecuencia.

8. Diseñe un Pseudocódigo que al recibir como dato un arreglo unidimensional de

N números reales, obtenga como resultado la suma del cuadrado de dichos
números.

12