Arreglos PDF

Técnico Profesional en Programación Desarrollo del Pensamiento Analítico y Sistémico I
________________________________________________________________________________________
Autor
Luis Norberto Zapata Puerta
Docente Facultad de Ingenierías
Politécnico Colombiano Jaime Isaza Cadavid
Medellín – Colombia. 2009
4 ARREGLOS
Introducción
Generalmente algunos problemas son difíciles de resolver utilizando datos de tipo simple
y es por ello que se requiere la implementación de arreglos que permitan el
almacenamiento de un conjunto de datos.
Partamos del siguiente ejemplo: La empresa XX cuenta con un total de 760 empleados y
desea determinar el total de personas que devengan sueldos por debajo al promedio de
salarios de dicha empresa.
Si se decide resolver éste problema haciendo uso de datos de tipo simple, muy
seguramente nos daremos cuenta del gran consumo de tiempo y variables de memoria
que se requieren, lo que hace que el programa sea muy ineficiente, además, se presenta
un problema adicional y es que el usuario debe ingresar los datos dos veces, la primera
vez al momento de calcular el promedio y la segunda al momento de calcular los salarios
por debajo al promedio, esto puede ocasionar que los datos ingresados en la segunda
ronda sean diferentes y por ende los resultados arrojados no serán confiables, por lo tanto
la mejor solución para éste tipo de problemas es utilizar datos de tipo estructurados como
son los arreglos de memoria.
Justificación
Como ya se menciono, el hecho de tener que ingresar datos doblemente no solo causa
problemas de eficiencia sino también de fiabilidad, ya que se corre el riesgo de ingresar
datos diferentes en la segunda vuelta.
Cuando se utilizan variables de tipo simple, cada vez que se ingresa un nuevo dato hace
que el anterior se pierda, y en el caso de necesitar realizar nuevas operaciones o cálculos
no previstos se tendría entonces que volver a introducir dichos datos, lo cual no es una
buena práctica desde cualquier punto de vista.
Los arreglos son necesarios cuando se requiere manejar cierta cantidad de datos que
posteriormente se deben volver a utilizar, y cuando al realizar cálculos u operaciones
resulte más eficiente almacenarlos provisionalmente que volverlos a calcular.
Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 1

________________________________________________________________________________________
Objetivo General
Proveer las herramientas necesarias que le permitan al estudiante resolver exitosamente

problemas algorítmicos que requieran el uso de estructuras de datos estáticas y la
implementación de arreglos como parámetros a subprogramas.
Competencias Específicas
Cognitivas (Saber):
1. Diferenciar el uso de estructuras cíclicas MIENTRAS vs PARA.

2. Clasificar las estructuras de almacenamiento estático.
3. Representar arreglos unidimensionales (vectores) y bidimensionales (matrices).
4. Recorrer arreglos unidimensionales y bidimensionales.
5. Identificar las operaciones con vectores y matrices.
6. Reconocer los métodos de búsqueda y ordenación.
7. Relacionar el paso de arreglos como parámetros a subprogramas.
8. Identificar las operaciones con manejo de cadenas en arreglos.
Actitudinales (Ser):
1. Lógico y analítico al diseñar soluciones de problemas.

2. Ordenado y sistémico para identificar y abstraer los datos del problema.
3. Capacidad de análisis y síntesis.
4. Demuestra interés y motivación, curiosidad e inquietud investigadora.
5. Demuestra ser creativo y capacidad de aprendizaje autónomo.
6. Participa activamente y asiste a clase.
7. Trabaja en equipo.
8. Responsable, organizado y puntual para entregar los trabajos asignados.
9. Se preocupa por mejorar.
10. Tener iniciativa, capacidad para adaptarse a nuevas situaciones y espíritu
emprendedor.

________________________________________________________________________________________
Resultados de Aprendizaje
1. Dividir en subprogramas o módulos la solución de problemas simples o complejos, con

el fin de identificar código reutilizable en el algoritmo.
2. Aplicar estructuras estáticas tales como vectores y matrices para la solución de
problemas que requieran almacenamiento de datos.
3. Emplear correctamente las estructuras de control a emplear en la solución de
problemas algorítmicos.
4. Implementar los métodos de búsqueda y ordenación más pertinentes para dar
solución a los problemas esbozados.
5. Aplicar las estructuras de datos estáticas más adecuadas a los requerimientos de los
algoritmos planteados.
6. Comprobar la funcionalidad de los algoritmos por medio de pruebas de escritorio.
Estrategias Metodológicas
1. Trabajo Presencial
a. Clase magistral
- El profesor explica los conceptos fundamentales y orienta el desarrollo
de la temática.
- El docente estimula al estudiante en la elaboración de algoritmos y el
desarrollo de su capacidad de análisis e ingenio.
b. Actividades dinámicas en clase.
El profesor plantea y dirige las actividades a desarrollar.
- Lectura de documentos
- Consultas
- Taller
- Autoevaluación
- Desarrollo de pequeños retos (prácticas) con relación a cada temática.
(Actividades propuestas en cada unidad)
c. Clase práctica (Laboratorio).
- El desarrollo de algoritmos y el lenguaje de programación se manejan de
forma simultánea.
- Para afianzar el aprendizaje se plantea desarrollar como mínimo tres
prácticas las cuales son independientes de los problemas resueltos en
clase, donde se apliquen los conocimientos adquiridos.
El profesor desarrolla los algoritmos más representativos y busca aterrizar el

manejo de las estructuras algorítmicas en el lenguaje seleccionado.
2. Trabajo Asistido
a. Tutorías
Los estudiantes asisten a las tutorías que imparte el docente en el
horario acordado.

________________________________________________________________________________________
b. Trabajo Individual asesorado

El profesor orienta consultas, lecturas y prácticas en el espacio individual de
asesorías.
c. Trabajo en grupo
El profesor propone, orienta, asesora y evalúa el avance en cada proyecto
sobre el cual deben trabajar los equipos conformados desde la primera
semana de clase.
Sugerencias para el Docente
1. Propiciar actividades dinámicas en clase:

- Lecturas de documentos
- Socializar consultas
- Talleres
- Autoevaluación
- Desarrollo de pequeños retos (prácticas) (incentivar con nota).
2. Proponer resolver ejercicios en clase por parte de los estudiantes
(incentivar con nota).
3. Revisar y socializar la realización de consultas y talleres (incentivar con nota.)
4. Desarrollar los algoritmos más representativos en el laboratorio
Medios de Apoyo y Recursos a Utilizar
1. Salón de clase: (Tablero, Marcadores)

2. Sala de cómputo : (Computadores, Video beam, Dvd, Internet)
3. Documentación complementaria del tema: (Folletos, documentos digitales)
4. Material multimedia: (Contenido apoyado en ITS)
5. Talleres
6. Guía de laboratorios
7. Bibliografia

________________________________________________________________________________________
Contenidos
1. Arreglos (Arrays)
2. Clasificación de los arreglos
2.1 Arreglos unidimensionales o vectores

2.1.1 Sintaxis: creación e impresión de un vector de N elementos
2.1.2 Ejemplos con vectores
2.1.3 Operaciones con vectores
2.2 Arreglos bidimensionales o matrices

2.2.1 Sintaxis: creación e impresión de una matriz de NxM elementos
2.2.2 Operación básicas con matrices
2.2.3 Ejemplos

________________________________________________________________________________________
1. Arreglos (Arrays)
Un Arreglo es una agrupación, disposición o lista de elementos.
Un arreglo es un conjunto de datos del mismo tipo, agrupados bajo un nombre que los
identifica, y deben ser finitos, es decir, estan compuestos por un tamaño limitado de
elementos.
Los datos individuales de los arreglos se deminan elementos, estos se almacenan en

posiciones adyacentes en memoria, es decir, en forma consecutiva.
Antes de utilizar un arreglo en un programa, es necesario definir el tamaño y el tipo de

dato que almacenará.
Ejemplo: Dimensión del arreglo
Entero: Edades[100] : Vector de Edades (enteras), con tamaño de 100 elementos

Real: Notas[20][5] : Matriz de Notas (reales), con tamaño de 20 filas x 5 columnas
Los arreglos se clasifican en:
2.1 Arreglos unidimensionales o vectores
Un arreglo unidimensional es un vector o lista de elementos del mismo tipo, agrupados

bajo un nombre y en el cual el orden es significativo. El orden se maneja mediante un
subindice que hace referencia a cada elemento dentro del arreglo.
Ejemplo:
Dada una lista de edades de un grupo de estudiantes, así:
Edades: 15,21,16,17,20,19,18 (lista de edades)
Este vector puede representarse gráficamente de la siguiente forma:
1 2 3 4 5 6 7
Edades 15 21 16 17 20 19 18
Elemento del arreglo
Para hacer referencia a un determinado elemento del arreglo se hace de la forma:
NombArreglo[#]
Indice

________________________________________________________________________________________
Edades[1]=15
Edades[4]=17
2.1.2 Sintaxis: para crear / imprimir un vector N elementos
Sintaxis: para crear un vector de N elementos enteros
Imprima: “Ingrese el tamaño del vector:”

Lea n
Para (i=1, n, 1) Haga
Imprima: “Ingrese un valor en la posición:”, i
Lea vec[ i ]
FinPara
Sintaxis: para imprimir un vector de N elementos enteros

Imprima: vec[ i ]
FinPara
2.1.3 Ejemplos con vectores
Creación de un vector de N elementos utilizando – CICLO MIENTRAS
Inicio
Entero: vec[50],n,i=1
Imprima: “Ingrese el tamaño del vector <1-50>:”
Lea n
Mientras (i <= n) Haga
Lea vec[i]
i=i+1
FinMQ
Fin
Creación de un vector de N elementos utilizando – CICLO PARA
Inicio
Entero: vec[50],n,i
Lea n
Lea vec[i]
FinPara

________________________________________________________________________________________
Fin
Creación de un vector de N elementos utilizando – CICLO REPITA HASTA_QUE
Inicio
Entero: vec[50],n,i=0
Lea n
Repita
i = i +1
Lea vec[i]
Hasta_Que(i = n) Haga
Fin
Diferencias entre el ciclo MIENTRAS y el CICLO PARA:
1.- Diferencia:
- En el ciclo MIENTRAS la variable contador (i) debe inicializarse por fuera del ciclo.
- En el ciclo PARA, NO se requiere inicializar la variable contador (i) por fuera del ciclo,
ya que cuando llega al ciclo: Para (i=1, n, 1) , éste la inicializa automáticamente en
uno.
2.- Diferencia:
- Al interior del ciclo MIENTRAS la variable contador (i) se debe incrementar: i = i +1, el
no hacerlo conlleva a que el programa se quede en un ciclo infinito.
- En el ciclo PARA, NO requiere incrementar la variable (i) al interior del ciclo, éste
automáticamente la incrementa según se specifique en: Para (i=1, n, Incr) Haga.
- El término Incr significa que la variable (i) debe incrementarse en el valor que sea
especificado en éste lugar.
Diferencias entre el ciclo MIENTRAS y el REPETIR_HASTA:
1ra. Diferencia:
- En el MIENTRAS para poder ingresar al ciclo se debe cumplir la condición, es decir,

debe ser verdadera: Mientras (j <=n), de no cumplir la condición el programa no ingresa
al ciclo ni siquiera una sola vez.
- En el REPETIR_HASTA el programa siempre ingresa por lo menos una vez al ciclo

cumpla o no se cumpla la condición.

________________________________________________________________________________________
2da. Diferencia:
- El MIENTRAS repite el ciclo siempre y cuando la condición sea verdadera, es decir, que
Cuando la condición se haga falsa se sale de dicho ciclo.
- En el REPETIR_HASTA el programa repite el ciclo siempre y cuando la condición sea

falsa, es decir, cuando la condición se haga verdadera se sale de dicho ciclo.
Resultados en memoria
n i vec[ i ] Iteración Posiciones
5 1 2 3 4 5
1 vec[1]=4 1 vec 4 7 11 9 3
2 vec[2]=7 2
3 vec[3]=11 3
4 vec[4]=9 4
5 vec[5]=3 5
6 Fin ciclo
Sintaxis: para imprimir un vector de N elementos enteros (forma ascendente)

Imprima: vec[ i ]
FinPara
n i Imprime Iteración Posiciones
5 1 2 3 4 5
1 4 1 vec 4 7 11 9 3
2 7 2
3 11 3
4 9 4
5 3 5
6 Fin ciclo
Sintaxis: para imprimir un vector de N elementos enteros (forma descendente)
Para (i=n, 1, -1) Haga

Imprima: vec[ i ]
FinPara

________________________________________________________________________________________
5 1 2 3 4 5
5 3 1 vec 4 7 11 9 3
4 9 2
3 11 3
2 7 4
1 4 5
0 Fin ciclo
2.1.4 Operaciones con vectores
Las operaciones básicas que se pueden realizar con los elementos de un vector son:
a. Métodos de búsqueda
b. Métodos de ordenación
c. Actualización (inserción, elimininación y modificación)
a. Búsqueda
Un método de búsqueda consiste en localizar un determinado valor dentro los elementos

del arreglo para recuperar alguna información asociada con dicho valor.
Existen diferentes métodos de búsqueda, dentro de los cuales están:
a.1 Búsqueda lineal o secuencial (el más común y fácil de implementar)

a.2 Búsqueda binaria
a.3 Búsqueda HASH
a.4 Árboles de búsqueda
Veamos algunas de ellos:
a.1. Búsqueda lineal o secuencial:
Consiste en recorrer todo el vector elemento por elemento, accediendo a todas las
posiciones del vector. Si el valor a buscar es localizado, se informa la posición del vector
donde fue encontrado dicho valor, de lo contrario, se presenta un mensaje diciendo que el
valor buscado no se encontró.
Ventajas:

________________________________________________________________________________________
- No requiere ordenar los elementos del arreglo

- Es un método fácil de implementar
Desventajas:
- Es un método muy lento de búsqueda

- Es un método ineficiente
Con éste método de búsqueda sucede lo mismo que sucede con los bancos o sitios de
atención al público y es que puede ocurrir que cuando llegas al sitio te dicen que ya no
hay servicio, con relación a la búsqueda secuencial puede ocurrir algo similar, es decir,
perder tiempo recorriendo el arreglo y no localizar el dato.
Ejemplo:
Desarrollar un algoritmo que determine si un valor que es ingresado por pantalla se

encuentra o no dentro de un vector de N valores enteros.
Nota: implementar por medio de un subprograma.
Documentación:
Nombre del subprograma : Busq_Secuencial( )

Tipo de subprograma : Función (Devuelve un solo valor, la posición)
Tarea que realiza : Buscar en forma secuencial un valor en un vector.
Parámetros de recibo : El vector “vec[ ]”
: El tamaño del vector “N”
: El valor a buscar “val”
Valor de retorno : La posición “i” donde sea localizado el valor en el vector,
o 0 si no es localizado dicho valor.
Subprograma: Busq_Secuencial( ):
Entero Busq_Secuencial(entero: vec[ ], entero: n, entero: val) {

Entero: i=1
Mientras (i <= n) AND (val <> vec[ i ]) Haga
i = i +1
FinMQ
Si (i <= n) entonces
Retorne(i)
Sino
Retorne(0)
FinSi
}

________________________________________________________________________________________
a.2. Búsqueda binaria
Este método consiste en hacer particiones sucesivas de dos en dos sobre cada arreglo
resultante y requiere que dicho arreglo se encuentre ordenado ya sea ascendente o
descendentemente. El procedimiento consiste en dividir el vector en dos mitades y
comparar el valor buscado con el elemento de la mitad del arreglo, si no coinciden, se
determina en cuál de las dos mitades puede estar, eliminando con ello una de las dos
mitades; se divide en dos la mitad en donde posiblemente está y se compara el valor
buscado con la mitad de ese segmento, si no coincide, se procede de igual forma hasta
que se encuentre o se determine que no está en el vector. De existir el valor en el vector
siempre será localizado en la posición del medio.
Ejemplo:

Nota: implementar por medio de un subprograma.
Documentación:
Nombre del subprograma : Busq_Binaria( )

Tipo de subprograma : Función
Tarea que realiza : Buscar un valor en un vector utilizando el método de
búsqueda binaria.
Parámetros de recibo : El tamaño del vector “n”
: El vector ordenado previamente “vec[ ]”
: El valor a buscar “val”
Valor de retorno : La posición de la mitad “Med” donde sea localizado el valor
en el vector o 0 si no es localizado dicho valor.
Otras variables:
Li : Limite Inferio (posición del primer elemento del segmento del vector en donde se
Busca).
Ls : Limite Superior (posición del último elemento del segmento del vector en donde
se busca).
Med : Posición de la mitad del vector.
Subprograma: Busq_Binaria( ):
Entero Busq_Binaria(entero:vec[ ], entero: n, entero: val){

Entero: Li=1, Ls=n, Med Primero se valida que el valor se
Si (val >= vec[1] AND val <= vec[n]) entonces encuentre dentro del posible rango de
valores antes de comenzar a buscar
Mientras (Li <= Ls) Haga

________________________________________________________________________________________
Med = (Li + Ls) DIV 2 //toma la parte entera de la división

Si (vec[Med] = val) entonces
Retorne (Med)
Sino
Si (val <= vec[Med]) entonces
Ls = Med – 1
Sino
Li = Med + 1
FinSi
FinSi
FinMQ
FinSi
Retorne(0)
}
b. Ordenación
La ordenación es el proceso por el cual, se organizan los elementos de un vector ya sea

en forma ascendente o descendente.
Si el vector queda ordenado ascendentemente, sus elementos quedan de forma tal que:
vec[1] < vec[2] < vec[3] <...< vec[N]
Si el vector queda ordenado descendentemente, sus elementos quedan de forma tal que:
vec[1] > vec[2] > vec[3] >...> vec[N]
Existen diferentes métodos de ordenamiento, dentro de los cuales, los más conocidos
son:
b.1 Método burbuja

b.2 Método burbuja mejorado
b.3 Método de inserción o método de la baraja
b.5 Método de la piedrita
A continuación se ilustra cada uno de ellos:
b.1 Método burbuja:
El método consiste en comparar elementos adyacentes del vector e intercambiarlos si

están desordenados. Al hacerlo, los valores mayores van “burbujeando” hacia el final del
vector (ordenamiento ascendente), o los menores “burbujean” hacia el final del vector
(ordenamiento descendente). Al método burbuja también se le conoce como método por
intercambio.

________________________________________________________________________________________
Por ejemplo, supongamos que tenemos el siguiente vector y que lo deseamos

ordenaremos en forma ascendente.
1
1 2
2 3
3 4
4 5
5
14
14 5
5 8
8 3
3 1
1 Vector original
Se compara el primer elemento con el segundo, como no están ordenados, se

intercambian, así:
Aux = vec[1]
vec[1] = vec[2]
vec[2] = Aux
El vector queda:
1 2 3 4 5
5 14 8 3 1
Luego se compara el segundo con el tercero, como están desordenados, se intercambian,

así:
Aux = vec[2]
vec[2] = vec[3]
vec[3] = Aux
El vector queda:
1 2 3 4 5
5 8 14 3 1
Luego se compara el tercero con el cuarto, como están desordenados, se intercambian,

así:
Aux = vec[3]
vec[3] = vec[4]
vec[4] = Aux
El vector queda:
1 2 3 4 5
5 8 3 14 1
Luego se compara el cuarto con el quinto, como están desordenados, se intercambian,

así:
Aux = vec[4]
vec[4] = vec[5]
vec[5] = Aux

________________________________________________________________________________________
El vector queda:
1 2 3 4 5
5 8 3 1 14
Al finalizar esta primera pasada, el mayor de los elementos quedó en la última posición.
Luego se hace la segunda pasada, pero esta vez se compara el primero con el segundo,
el segundo con el tercero y el tercero con el cuarto. El quinto no se compara con ninguno
porque ya está en su posición. Al finalizar esta segunda pasada, el segundo mayor
elemento queda en la penúltima posición.
Se continúa así, hasta completar N-1 pasadas, al final de la cual, el vector queda
ordenado. Miremos la segunda pasada:
1 2 3 4 5
5 8 3 1 14
1 2 3 4 5
5 8 3 1 14 El método permite que la burbuja
1 2 3 4 5 (valor) más pesado emerja a la
5 3 8 1 14 superficie o viceversa.
1 2 3 4 5
5 3 1 8 14
En la tercera pasada sucedería lo siguiente:
1 2 3 4 5
5 3 1 8 14
1 2 3 4 5
3 5 1 8 14
1 2 3 4 5
3 1 5 8 14
En la cuarta pasada, se compara el primer elemento con el segundo, como están

desordenados, se intercambian, así:
1 2 3 4 5
3 1 5 8 14
1 2 3 4 5
1 3 5 8 14

________________________________________________________________________________________
Para hacer el intercambio de posición entre un valor y otro, es necesario utilizar una
variable auxiliar que guarde uno de los valores a intercambiar para evitar que alguno de
ellos se pierda.
Ejemplo:
Hacer un subprograma que ordene ascendentemente por medio del método burbuja, un
vector de N elementos.
Documentación:
Nombre del subprograma : Burbuja

Tipo de subprograma : Procedimiento
Tarea que realiza : Ordena en forma ascendente un vector utilizando el
método burbuja.
El tamaño del vector “N”
Parámetros de envío : El vector ordenado (es parámetro de recibo y de envío).
Otras variables:
i, j : Índices para el vector
aux : Variable auxiliar para guardar uno de los elementos a
intercambiar.
Subprograma: Burbuja( ):
Void Burbuja(entero:vec[ ], entero: n){

Entero: i, j, aux
Para (i = 1, n-1, 1) Haga
Para (j = 1, n-i, 1) Haga
Si (vec[ j ] > vec[j+1]) entonces
aux = vec[ j ]
vec[ j ] = vec[j+1]
vec[j+1] = aux
FinSi
FinPara
FinPara
}
b.2 Método burbuja mejorado:
Este método se basa en el de la burbuja pero es eficiente si los elementos están casi
ordenados, por ejemplo, cuando el vector está ordenado inicialmente y se le ingresan al
final nuevos elementos sin tener en cuenta el ordenamiento. La variación con respecto al

________________________________________________________________________________________
de la burbuja consiste en que si en alguna pasada no hay intercambios, es porque el

vector ya está ordenado y se debe detener el proceso de comparación (ruptura del ciclo).
Ejemplo:
Hacer un subprograma que ordene en forma ascendente un vector utilizando el método

de la burbuja mejorado.
Documentación:
Nombre del subprograma : BurbujaMejor( )

método de la burbuja mejorado.
Otras variables:
j, k : Índices para el vector
intercambiar.
sw : Variable tipo suiche o bandera que cambiará de valor si
hay intercambio.
Subprograma: BurbujaMejor( ):
Void BurbujaMejor(entero: vec[ ], entero: n){

Entero: j=1,k,aux
Repita
sw = 1
Para (k = 1, n - j, n, 1) Haga
Si (vec[ j ] > vec[j+1]) entonces
aux = vec[k]
vec[k] = vec[k+1]
vec[k+1] = aux
sw = 0
FinSi
FinPara
j=j+1
HASTA_QUE( sw = 0) Haga
}
b.3 Método de inserción o método de la baraja
El método de inserción es similar al método utilizado por los jugadores de cartas para
ordenar la baraja. El procedimiento se realiza recorriendo la baraja con la carta nueva a
insertar, ésta se va comparando con cada una a medida que se va desplazando, cuando

________________________________________________________________________________________
se localiza el espacio adecuado, todas las cartas son desplazan un lugar hacia delante
para alojarla.
Ejemplo:

de ordenación por inserción.
Documentación:
Nombre del subprograma : Insercion( )

método de inserción.
Otras variables:
i, k : Índices para el vector
intercambiar.
sw : Variable tipo suiche o bandera que cambiará de valor si
hay intercambio.
Subprograma: Insercion( ):
Void Insercion(entero:vec[ ], entero:n){

Entero: i,k,aux,sw
Para (k = 2, n, 1) Haga //Se toma el 2do elemento para comenzar a comparar
aux = vec[k]
i = k -1
sw=0
Mientras ( i >= 1 AND sw=0) Haga
Si (aux < vec[ i ]) entonces
vec[i+1]=vec[ i ]
i = i -1
Sino
sw =1
FinSi
FinMQ
vec[i+1]=aux
FinPara

________________________________________________________________________________________
Fin
Resultados en Memoria
n i k aux sw i >= 1 AND sw = 0 aux < vec[i] Posiciones
5 1 2 14 0 Verdadero Falso 1 2 3 4 5
1 Falso vec 5 14 2 8 1
2 3 2 0 Verdadero Verdadero vec 5 14 2 8 1
1 Verdadero Verdadero vec 5 14 8 1
0 Falso vec 2 5 14 8 1
3 4 8 0 Verdadero Verdadero vec 2 5 14 8 1
2 Verdadero Falso vec 2 5 8 14 1
1 Falso vec 2 5 8 14 1
4 5 1 0 Verdadero Verdadero vec 2 5 8 14
3 Verdadero Verdadero vec 2 5 8 14
2 Verdadero Verdadero vec 1 2 5 8 14
1 Verdadero Verdadero
0 Falso
b.4 Método de selección
El método de ordenación por selección consiste en encontrar el valor más pequeño del
vector e intercambiarlo con el que se encuentra en la primera posición, luego se localiza el
siguiente menor y se intercambia con el de la segunda posición, y así sucesivamente
hasta completar el proceso con todo el vector.
Ejemplo:

de ordenación por selección.
Documentación:
Nombre del subprograma : Seleccion( )

método de selección.

________________________________________________________________________________________
Otras variables:
i, j : Índices para el vector
intercambiar.
Subprograma: Seleccion( ):
Void Seleccion(entero:vec[ ], entero:n){

Entero: i,j,aux
Para (i = i, n -1, 1) Haga
Para (j = i+1, n, 1) Haga
Si (vec[ i ] > vec[ j ]) entonces
aux = vec[ i ]
vec[ i ] = vec[ j ]
vec[ j ] = aux
FinSi
FinMQ
FinPara
}
n I j aux vec[ i ] > vec[ j ] Posiciones
5 1 2 Verdadero 1 2 3 4 5
3 Verdadero vec 14 8 2 5 1
4 Falso
6
2 3 Falso vec 2 14 8 5 1
4 Verdadero
6
3 4 Verdadero vec 2 14 8 5 1
5 Verdadero
6 vec 1 14 8 5 2
4 5 Verdadero
6 vec 1 8 14 5 2
vec 1 8 14 5 2
vec 1 5 14 8 2
vec 1 2 14 8 5
vec 1 2 8 14 5
vec 1 2 5 14 8
vec 1 2 5 8 14

________________________________________________________________________________________
b.5 Método de la piedrita
Como su nombre lo indica, en vez de “subir o burbujear” hacia el final los elementos más
grandes (ordenación ascendente) o los más pequeños (ordenación descendente), en este
método, van a “bajar” hacia el principio del vector los más pequeños (ordenación
ascendente) o los más grandes (ordenación descendente). Es un método similar al de la
burbuja, solo que en este nuevo método, se compara el primer elemento con todos los
demás a su derecha en la primera pasada, al cabo de la cual, el menor elemento quedará
en la primera posición. Luego se compara el segundo elemento con los demás a su
derecha en la segunda pasada, al cabo de la cual, el segundo menor elemento, quedará
en la segunda posición y así sucesivamente.
Ejemplo:
Diseñar un subprograma que ordene ascendentemente por el método de la piedrita, un

vector de N elementos.
Documentación:
Nombre del subprograma : Piedrita

método de la piedrita.
Otras variables:
j, k : Índices para el vector
intercambiar.
Subprograma: Piedrita( ):
Void Piedrita(entero:vec[ ], entero:n){

Entero: j, k, aux
Para (j = 1, n -1, 1) Haga
Para (k = j+1, n, 1 Haga
Si (vec[ j ] > vec[k]) entonces
aux = vec[ j ]
vec[ j ] = vec[k]
vec[k] = aux
FinSi
FinPara
FinPara
}

________________________________________________________________________________________
c. inserción
La inserción consiste en adicionar un nuevo elemento al vector, teniendo en cuenta de

que no se debe sobrepasar el tamaño definido para el mismo, pues si se sobrepasa, se
incurre en el error denominado “desbordamiento”, o en inglés “overflow”.
La inserción se puede hacer tanto si el arreglo está ordenado como si está desordenado,
si está desordenado, el proceso es sencillo, pero si está ordenado, el proceso es un poco
más complejo.
Si el vector está desordenado:
Si el vector está desordenado, simplemente se incrementa en uno el tamaño del vector y

en la última posición se inserta el nuevo elemento.
Ejemplo:
Elaborar un subprograma que inserte un nuevo elemento en un vector desordenado.
Documentación:
Nombre del subprograma : InsDesorden( )

Tarea que realiza : Inserta un nuevo elemento en un vector desordenado.
El valor a insertar (val)
Parámetros de envío : El tamaño del vector aumentado en uno para evitar
el desbordamiento
El vector con un elemento más.
Subprograma: InsDesorden( ):
Void InsDesorden(entero:vec[ ], entero:n, entero:val){

n=n+1
vec[n] = val
}

________________________________________________________________________________________
Si el vector está ordenado y se quiere seguir con el ordenamiento:
Si el vector está ordenado y se desea continuar con el ordenamiento se debe hacer lo

siguiente:
(1) Buscar la posición del arreglo en la cual se insertará el nuevo elemento

(2) Aumentar el tamaño del vector en uno
(3) Correr los elementos del vector una posición a la derecha, a partir de la posición
en la cual se insertará el nuevo elemento.
(4) Insertar el nuevo elemento en su posición.
Ejemplo:
Desarrollar un subprograma que inserte un nuevo elemento en un vector ordenado en

forma ascendente, conservando su ordenamiento.
Documentación:
Nombre del subprograma : InsOrdenado( )

Tarea que realiza : Inserta un nuevo elemento en un vector ordenado en forma
ascendente.
El elemento a insertar (val)
Parámetros de envío : El tamaño del vector aumentado en uno
El vector con un elemento más.
Variables locales:
I : variable para encontrar la posición en donde se insertará el

nuevo elemento
j : variable para correr los elementos un lugar hacia la
derecha
Subprograma: InsOrdenado( ):
Void InsOrdenado(entero:vec[ ], entero:n, entero:val){

Entero: i=1, j
Mientras (i <= n) AND (val > vec[ i ]) Haga
i = i +1
FinMQ //finalizado este mientras, i tiene la posición de inserción
n=n+1
Para (j = n, i+1, -1) Haga
vec[ j ] = vec[j-1]
FinPara
vec[ i ] = val
}

________________________________________________________________________________________
b. Borrado
Consiste en eliminar un elemento del vector y se puede hacer tanto si éste está ordenado
como si está desordenado mediante el mismo procedimiento. Para hacerlo hay que hacer
lo siguiente:
(1) Verificar que el arreglo no está vació

(2) Buscar la posición donde está el valor a borrar
(3) Correr todos los elementos del vector una posición hacia la izquierda, a partir de la
siguiente de donde está el valor a borrar.
(4) Disminuir el tamaño del vector en uno.
(5) Enviar un mensaje si no se encontró el valor a borrar.
Ejemplo:
Crear un subprograma que elimine un elemento de un vector el cual se puede encontrar

ordenado o desordenado.
Documentación:
Nombre del subprograma : Eliminar( )

Tarea que realiza : Borra un elemento de un vector ordenado o desordenado.
El elemento a borra (val)
Parámetros de envío : El tamaño del vector disminuido en uno
El vector con un elemento menos.
Variables locales:
i : variable para encontrar la posición en donde se borrará el

elemento
j : variable para correr los elementos un lugar hacia la
izquierda

________________________________________________________________________________________
Subprograma: Eliminar( ):
Void Eliminar(entero:vec[ ], entero:n, entero:val){
Entero: i=1
i=i+1
FinMQ //finalizado este mientras, I tiene la posición de borrado
Para (j = i, n - 1, 1) Haga
vec[ j ] = vec[j+1]
FinPara
n=n-1
Sino
Imprima: “El valor “, val, “no está en el vector”
FinSi
}

________________________________________________________________________________________
2.1.2 Ejemplos
Ejemplo 1
a. Definición
Elaborar un algoritmo que permita crear un vector de N elementos numéricos y calcule

el promedio de los valores de dicho arreglo.
b. Análisis
Datos de entrada
o n : Tamaño del vector
Dato de Proceso
o sum = sum + vec[ i ] : Sumatoria de los valores del vector

o prom = sum / n : Promedio de los valores del vector
Datos de salida
o prom : Promedio de los valores del vector
Otras variables:
o i : Índice del vector

o vec[ ] : Vector
c. Pseudocódigo
Inicio
Entero: n,i,vec[100],sum=0
Real: prom
Imprima: “Ingrese el tamaño del vector: “ Realmente son las posiciones a llenar
Lea n
Imprima: “Ingrese un valor en la posición: “,i
Lea vec[ i ]
sum = sum + vec[ i ]
FinPara
prom = sum / n
Imprima: “El promedio de los valores del arreglo es:“,prom
Fin

________________________________________________________________________________________
d. Prueba de escritorio
5 1 2 3 4 5
5 3 1 vec 4 7 11 9 3
4 9 2
3 11 3
2 7 4
1 4 5
0 Fin ciclo
e. Implementado como subprograma (Procedimiento / Función):
Programa Principal
Inicio
Entero: n,vec[100]
Real: prom
Imprima: “Ingrese el tamaño del vector: “
Lea n
Crear_Vector(vec, n)
prom = Promediar(vec, n)
Imprima: “El promedio de los valores del arreglo es:“,prom
Fin
Subprograma: Crear_Vector( )
Void Crear_Vector(entero: vec[ ], entero: n ) {

Entero: i
Imprima: “Ingrese un valor en la posición:“, i
Lea vec[ i ]
FinPara
}

________________________________________________________________________________________
Subprograma: Promediar( )
Real Promediar(entero: vec[ ], entero: n ) {

Entero: i, sum=0
FinPara
Retorne (sum / n)
}
Ejemplo 2
a. Definición

Solución por medio de la búsqueda secuencial:
b. Análisis
Datos de entrada
o n : Tamaño del vector
o val : Valor a buscar
Dato de Proceso (no hay cálculos matemáticos)
o i=i+1 : Incremento del índice para recorrer el vector

o val <> vec[ i ] : Se compara el valor con los elementos del vector
Datos de salida
o i : Posición en la cual es localizado el valor
Otras variables:
o vec[ ] : Vector

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: n,i,vec[100],val
Imprima: “Ingrese el tamaño del vector: “ Realmente son las posiciones a llenar
Lea n
Imprima: “Ingrese un valor en la posición: “,i
Lea vec[ i ]
FinPara
Imprima: “Ingrese el valor a buscar:”
Lea val
i=1
i = i +1
FinMQ
Imprima: “El valor fue localizado en la posición:”, i
Sino
Imprima: “El valor no existe en el vector”
FinSi
Fin
n i vec[ i ] val (i <= n) AND Iteración Posiciones
(val <> vec[ i ])
7 1 2 3 4 5 6 7
1 vec[1]=4 1 vec 4 7 11 9 3 8 1
2 vec[2]=7 2
3 vec[3]=11 3
4 vec[4]=9 4
5 vec[5]=3 5
6 vec[6]=8 6
7 vec[7]=1 7
8 11
1 vec[1]=4 11 Verdadero
2 vec[2]=7 11 Verdadero 1
3 vec[3]=11 11 Falso 2 “El valor fue localizado en la posición:", 3

________________________________________________________________________________________
Programa Principal
Inicio
Entero: n,vec[100],val,pos
Lea n
Lea val
pos = Busq_Secuencial(vec, n, val)
Si (pos <> 0) entonces
Imprima: “El valor fue localizado en la Posición:”, pos
Sino
FinSi
Fin

Entero: i
Lea vec[ i ]
FinPara
}
Subprograma: Busq_Secuencial( ):
Entero Busq_Secuencial(entero: vec[ ], entero: n, entero: val) {

Entero: i=1
i = i +1
FinMQ
Retorne(i)
Sino
Retorne(0)
FinSi
}

________________________________________________________________________________________
Solución por medio de la búsqueda binaria:
Programa Principal
Inicio
Entero: n,vec[100],val,pos
Lea n
Lea val
Ordenar_Vector(vec, n)
pos = Busq_Binaria(vec, n, val)
Si (pos <> 0) entonces
Imprima: “El valor fue localizado en la Posición:”, pos
Sino
FinSi
Fin

Entero: i
Lea vec[ i ]
FinPara
}
Subprograma: Ordenar_Vector( ):
Void Ordenar_Vector(entero:vec[ ], entero: n){

Entero: i, j, aux
Para (j = i, n, 1) Haga
aux = vec[ i ]
vec[ i ] = vec[ j ]
vec[ j ] = aux
FinSi
FinPara
FinPara
}

________________________________________________________________________________________
Subprograma: Busq_Binaria( ):
Entero Busq_Binaria(entero:vec[ ], entero: n, entero: val){

Entero: Li=1, Ls=n, Med Primero se valida que el valor se
Si (val >= vec[1] AND val <= vec[n]) entonces encuentre dentro del posible rango de
valores antes de comenzar a buscar
Mientras (Li <= Ls) Haga
Med = (Li + Ls) DIV 2 //toma la parte entera de la división
Si (vec[Med] = val) entonces
Retorne (Med)
Sino
Si (val <= vec[Med]) entonces
Ls = Med – 1
Sino
Li = Med + 1
FinSi
FinSi
FinMQ
FinSi
Retorne(0)
}
Ejemplo 3
a. Definición
Realizar un algoritmo que calcule la desviación estándar representada por la siguiente

expresión:
n _
σ = 1 /(n − 1)∑ ( xi − x) 2
i =1
Donde:
_
Media aritmética o promedio: prom = x = ( x[1] + x[2] + x[3] + ... + x[n]) / n
Sumatoria de cada valor xi menos el promedio al cuadrado:
n
∑ (x i − prom) 2 = ( x[1] − prom) 2 + ( x[2] − prom) 2 + ... + ( x[n] − prom) 2

i =1

________________________________________________________________________________________
b. Análisis
Datos de entrada
o n : Limite superior de la sumatoria

o vec[ i ] : Significa que cada valor se almacena en una posición diferente
Datos de Proceso
o prom = ( x[1] + x[2] + ... + x[n]) /:Promedio

n de los valores xi ingresados
o sum = (sum + x[i]); prom =(sum / n) : Acumulador de cada valor xi

o sumat = sumat + ( x[i] - prom)^2 :sumatoria de cada valor menos el prom.
o desv = sqrt (1 /( n − 1) * sumat ) : Desviación estándar
Datos de salida
o desv : Desviación estándar
c. Pseudocódigo
Inicio
Entero n,i
Real: vec[100], prom,sum=0,sumat=0,desv
Imprima: "Ingrese el limite superior de la sumatoria:"
Lea n
Para (i =1, n, 1) Haga
Imprima: “Ingrese un valor en la Posición:”, i
Lea vec[ i ]
FinPara
prom = sum / n Importante: Observe que no es
Para (i =1, n, 1) Haga necesario ingresar nuevamente
los datos, ya que se encuentran
sumat = sumat + (vec[ i ] – prom)^2
almacenados en el vector.
FinPara
desv = sqrt(1/(n-1)*sumat)
Imprima: “La desviación estándar es =”, desv
Fin

________________________________________________________________________________________
n I vec[ i ] sum prom sumat desv Posiciones
7 0 0 1 2 3 4 5 6 7
1 4 4 vec 4 7 11 9 3 8 1
2 7 11
3 11 22
4 9 31
5 3 34
6 8 42
7 1 43
8 6.1
1 4 4.4
2 7 5.2
3 11 29.2
4 9 37.6
5 3 47.3
6 8 50.9
7 1 76.9
8 3.6
e. Implementado como subprograma (Función):
Programa Principal
Inicio
Entero n
Real: vec[100],prom,sumat,desv
Imprima: "Ingrese el limite superior de la sumatoria:"
Lea n
prom = Promedio(vec, n)
sumat = Sumatoria(vec,n,prom)
desv = sqrt(1/(n-1)*sumat)
Imprima: “La desviación estándar es =”, desv
Fin

________________________________________________________________________________________
Void Crear_Vector(Real: vec[ ], entero: n ) {

Entero: i
Lea vec[ i ]
FinPara
}
Subprograma: Promedio( )
Real Promedio(entero: vec[ ], entero:n) {

Entero: i=1
Real: sum=0
FinPara
Retorne(sum / n)
}
Subprograma: Sumatoria( )
Real Sumatoria(Real:vec[ ],entero:n, Real:prom) {

Entero: i=1
Real: sum=0
sum = sum + (vec[ i ] – prom)^2
FinPara
Retorne(sum)
}
Ejemplo 4
a. Definición
Desarrollar un algoritmo que permita crear 2 vectores A y B de dimensiones N y P

respectivamente, se desea construir un tercer vector C el cual sea el resultado de
intercalar los valores de A y B sin que queden valores repetidos en C.
Nota: el vector resultante C debe quedar ordenado ascendentemente a medida que se va

construyendo, es decir, una vez almacenado un valor en dicho vector no se podrá realizar
ningún tipo de ordenación, además suponga que en cada vector no hay valores repetidos.

________________________________________________________________________________________
Ejemplo ilustrativo:
1 2 3 4 5
A 1 3 5 6 7
1 2 3 4 5 6
B 1 2 3 4 6 8
1 2 3 4 5 6
C 1 2 3 4 5 6 7 8
b. Análisis
Datos de entrada
o n : Tamaño del vector A

o p : Tamaño del vector B
o k : Tamaño del vector C
Procedimiento:
1°. Crear el vector A y Luego el vector B

2°. Ordenar el vector A y Luego el vector B
3°. Intercalar los elementos de A y B:
Si (A[ i ] = B[ i ]) se lleva uno de los dos valores de A o B a C[ r ]
Si los valores son diferentes se pregunta:
si (A[ i ] < B[ i ]) llevar el valor de A[ i ] a C[ r ]
si (A[ i ] > B[ i ]) llevar el valor de B[ i ] a C[ r ]
Datos de salida
o C[ ] : El vector resultante

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: A[100],n,B[100],p,i,j,k,aux
Imprima: "Ingrese el tamaño del vector A:”
Lea n
Imprima: "Ingrese el tamaño del vector B:”
Lea p
Entero: C[n+p]
Lea A[ i ]
FinPara
Para (i =1, p, 1) Haga
Lea B[ i ]
FinPara
Si (A[ i ] > A[ j ]) entonces
aux = A[ i ]
A[ i ] = A[ j ]
A[ j ] = aux
FinSi
FinPara
FinPara
Si (B[ i ] > B[ j ]) entonces
aux = B[ i ]
B[ i ] = B[ j ]
B[ j ] = aux
FinSi
FinPara
FinPara
i = 1, j = 1
k=0
Mientras (i <= n AND j <= p) Haga
k=k+1
Si (A[ i ] = B[ j ]) entonces
C[k] = A[ i ]
i=i+1
j = j +1
Sino
Si (A[ i ] < B[ j ]) entonces
C[k] = A[ i ]
i=i+1
Sino
C[k] = B[ j ]

________________________________________________________________________________________
j=j+1
FinSi
FinSi
FinMQ
Si (i <= n) Haga
Mientras ( i <= n ) Haga
C[k] = A[ i ]
k=k+1
i=i+1
FinMQ
Sino
Mientras ( j <= p ) Haga
C[k] = B[ j ]
k=k+1
j=j+1
FinMQ
FinSi
Para (i =1, k, 1) Haga
Imprima: C[ i ]
FinPara
Fin
n I A[ i ] p J B[ j ] Posiciones
5 1 5 1 2 3 4 5
2 3 A 5 3 6 7 1
3 6
4 7 1 2 3 4 5 6
5 1 B 8 4 2 6 1 3
6
6 1 8 1 2 3 4 5
2 4 A 1 3 5 6 7
3 2
4 6 1 2 3 4 5 6
5 1 B 1 2 3 4 6 8
6 3
7 1 2 3 4 5 6 7 8
Ordenación del vector A C 1 2 3 4 5 6 7 8
Ordenación del vector B
Intercalación del Vector A y B en C
Imprime: 1 ,2, 3, 4, 5, 6, 7, 8

________________________________________________________________________________________
e. Implementado como subprograma (Procedimiento):
Programa Principal
Inicio
Entero: A[100],n,B[100],p,k=0
Lea n
Lea p
Entero: C[n+p]
Crear_Vector(A, n)
Crear_Vector(B, p)
Ordenar_Vector(A, n)
Ordenar_Vector(B, p)
Intercalar_Vector(A,n,B,p,C,k)
Imprimir_Vector(C,k)
Fin

Entero: i
Lea vec[ i ]
FinPara
}

Entero: i, j, aux
aux = vec[ i ]
vec[ i ] = vec[ j ]
vec[ j ] = aux
FinSi
FinPara
FinPara
}

________________________________________________________________________________________
Subprograma: Intercalar_Vector( ):
Void Intercalar_Vector(entero:A[ ], entero:n, entero: B[ ], entero:p, entero:C[ ], entero:k){

Entero: i=1,j=1
k=k+1
C[k] = A[ i ]
i=i+1
j = j +1
Sino
C[k] = A[ i ]
i=i+1
Sino
C[k] = B[ j ]
j=j+1
FinSi
FinSi
FinMQ
Si (i <= n) Haga
C[k] = A[ i ]
k=k+1
i=i+1
FinMQ
Sino
C[k] = B[ j ]
k=k+1
j=j+1
FinMQ
FinSi
}
Subprograma: Imprimir_Vector( )
Void Imprimir_Vector(Real: vec[ ], entero:n ) {

Entero: i
Imprima: vec[ i ]
FinPara
}

________________________________________________________________________________________
Ejemplo 5
a. Definición
Desarrollar un algoritmo que permita crear 2 vectores A y B de dimensiones N y P

respectivamente, se desea construir un tercer vector C, el cual contenga los valores NO
COMUNES de A y B, sin que queden valores repetidos en C.
Nota: el vector resultante C debe quedar ordenado ascendentemente a medida que se va

construyendo, es decir, una vez almacenado un valor en dicho vector no se podrá realizar
ningún tipo de ordenación, además suponga que en cada vector no hay valores repetidos.
Ejemplo ilustrativo:
1 2 3 4 5
A 1 4 5 8 9
1 2 3 4 5 6
B 1 5 6 7 8 11
1 2 3 4 5
C 4 6 7 9 11
b. Análisis
Datos de entrada
o n : Tamaño del vector A

o p : Tamaño del vector B
o k : Tamaño del vector C
Procedimiento:
1°. Crear el vector A y Luego el vector B

2°. Ordenar el vector A y Luego el vector B
3°. Extraer los elementos de A y B:
si (A[ i ] = B[ i ]) se omiten los valores y se pasa a la siguiente posición
en ambos vectores.
Si los valores son diferentes se pregunta:
si (A[ i ] < B[ i ]) se lleva el valor de A[ i ] a C[ r ]
si (A[ i ] > B[ i ]) se lleva el valor de B[ i ] a C[ r ]
Datos de salida
o C[ ] : El vector resultante

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: A[100],n,B[100],p,i,j,k,aux
Lea n
Lea p
Entero: C[n+p]
Lea A[ i ]
FinPara
Para (i =1, p, 1) Haga
Lea B[ i ]
FinPara
Si (A[ i ] > A[ j ]) entonces
aux = A[ i ]
A[ i ] = A[ j ]
A[ j ] = aux
FinSi
FinPara
FinPara
Si (B[ i ] > B[ j ]) entonces
aux = B[ i ]
B[ i ] = B[ j ]
B[ j ] = aux
FinSi
FinPara
FinPara
i = 1, j = 1
k=0
k=k+1
i=i+1
j = j +1
Sino
C[k] = A[ i ]
i=i+1
Sino
C[k] = B[ j ]
j=j+1

________________________________________________________________________________________
FinSi
FinSi
FinMQ
Si (i <= n) Haga
C[k] = A[ i ]
k=k+1
i=i+1
FinMQ
Sino
C[k] = B[ j ]
k=k+1
j=j+1
FinMQ
FinSi
Imprima: C[ i ]
FinPara
Fin
n i A[ i ] p J B[ j ] Posiciones
5 1 9 1 2 3 4 5
2 5 A 9 5 8 1 4
3 8
4 1 1 2 3 4 5 6
5 4 B 8 6 1 11 5 7
6
6 1 8 1 2 3 4 5
2 6 A 1 4 5 8 9
3 1
4 11 1 2 3 4 5 6
5 5 B 1 5 6 7 8 11
6 7
7 1 2 3 4 5
Ordenación del vector A C 4 6 7 9 11
Ordenación del vector B
Valores NO comunes del Vector A y
B en C
Imprime: 4, 6, 7, 9, 11

________________________________________________________________________________________
e. Implementado como subprograma (Procedimiento):
Programa Principal
Inicio
Entero: A[100],n,B[100],p,k=0
Lea n
Lea p
Entero: C[n+p]
Crear_Vector(A, n)
Crear_Vector(B, p)
Ordenar_Vector(A, n)
Ordenar_Vector(B, p)
Intercalar_Vector(A,n,B,p,C,k)
Imprimir_Vector(C,k)
Fin

Entero: i
Lea vec[ i ]
FinPara
}

Entero: i, j, aux
aux = vec[ i ]
vec[ i ] = vec[ j ]
vec[ j ] = aux
FinSi
FinPara
FinPara
}

________________________________________________________________________________________
Subprograma: Intercalar_Vector( ):
Void Intercalar_Vector(entero:A[ ], entero:n, entero: B[ ], entero:p, entero:C[ ], entero:k){

Entero: i=1,j=1
k=k+1
i=i+1
j = j +1
Sino
C[k] = A[ i ]
i=i+1
Sino
C[k] = B[ j ]
j=j+1
FinSi
FinSi
FinMQ
Si (i <= n) Haga
C[k] = A[ i ]
k=k+1
i=i+1
FinMQ
Sino
C[k] = B[ j ]
k=k+1
j=j+1
FinMQ
FinSi
}

Entero: i
Imprima: vec[ i ]
FinPara
}

________________________________________________________________________________________
Ejemplo 6
a. Definición
Elabore un algoritmo que elimine el valor que más se repita en un vector de N elementos.
Ejemplo:
1 2 3 4 5 6 7 8 9
1 3 2 3 5 2 3 6 3
1 2 3 4 5 6 7 8 9 Número de veces que se repite

1 4 2 3 1 1 2 1 1 el valor, al buscarlo hacia
delante en el vector.
Para hallar la solución a éste problema se puede realizar de varias maneras, a

continuación se ilustraran dos (2) posibles formas de hacerlo:
Pasos solución: 1
1°. Contar el número de veces que se repite cada va lor.

2°. Crear un nuevo vector:
- Un vector Y que almacene el número de veces que se repite dicho valor
3°. Finalmente, se recorre el vector Y para determi nar cuál es el mayor valor
4°. Una vez determinado el mayor valor Y[ i ], en l a misma posición equivalente se
encuentra el valor que más se repite vec[ i ].
b. Análisis
Datos de entrada
o n : Tamaño del vector “vec[ ]”

o vec[ i ] : Valor a introducir en la posición i.
Procedimiento:
o Y[ ] : Vector que almacenará el número de veces que se repite

cada valor del vector “X[ ]”
o i, j : Índices para recorrer los vectores
o cont : Contador de valores repetidos.
o may : Mayor valor del vector Y[ ]
Datos de salida
o vec[ i ] : El valor más repetido

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: vec[100],n,Y[100],i,j,may,val
Imprima: "Ingrese el tamaño del vector vec:”
Lea n
Lea vec[ i ]
FinPara
Para (i =1, n -1, 1) Haga
cont = 1
Para (j =i+1, n, 1) Haga
Si (vec[ i ] = vec[ j ]) entonces
cont = cont + 1
FinSi
FinPara
Y[ i ] = cont
FinPara
may = Y[1]
val = vec[1] \\ se asume el primero como el mayor valor
Si (may < Y[ i ]) entonces
may = Y[ i ]
val = vec[ i ]
FinSi
FinPara
\\ en este punto, ya se sabe cual es el valor que más se repite (val)
\\ lo que se hace para eliminar el valor más repetido, es traer los demás valores hacia
\\ adelante y al final se disminuye el tamaño del vector.
Veamos:

Si (vec[ i ] = val) entonces
Para (j = i, n -1, 1) Haga
vec[ j ] = vec[j+1]
FinPara
n=n-1
FinSi
FinPara
Si (val = vec[ i ]) entonces
n=n-1
FinSi
Para (i =1, n , 1) Haga
Imprima: vec[ i ]
FinPara

________________________________________________________________________________________
n i vec[ i ] Posiciones
9 1 1 1 2 3 4 5 6 7 8 9
2 3 vec 1 3 2 3 5 2 3 6 3
3 2
4 3
5 5 Y 1 4 2 3 1 1 2 1 1
6 2
7 3 Procedimiento para eliminar el valor más repetido
8 6
9 3 1 2 3 4 5 6 7 8 9
10 vec 1 3 2 3 5 2 3 6 3
Número de veces que se repiten
El valor que más se repite n
1 2 3 4 5 6 7 8 n = n-1
vec 1 2 3 5 2 3 6 3 3
1 2 3 4 5 6 7 n = n-1
vec 1 2 5 2 3 6 3 3 3
1 2 3 4 5 6 n = n-1
vec 1 2 5 2 6 3 3 3 3
Si (val = vec[ i ]) entonces: n = n - 1
n = n-1
e. Implementado como subprograma (Procedimiento / Función ):
Programa Principal
Inicio
Entero: vec[100],n,Y[100],i,j,val
Lea n
Valores_Repetidos(vec, n, Y)
val = Valor_Masrepetido(Y, n, vec)
Eliminar_Masrepetido(vec, n, val)
Imprimir_Vector(vec, n)
Fin

________________________________________________________________________________________

Entero: i
Lea vec[ i ]
FinPara
}
Subprograma: Valores_Repetidos( ):
Void Valores_Repetidos(entero:vec[ ], entero: n, entero:Y[ ]){

Entero: i, j, cont
cont = 1
Para (j =i+1, n, 1) Haga
Si (vec[ i ] = vec[ j ]) entonces
cont = cont + 1
FinSi
FinPara
Y[ i ] = cont
FinPara
}
Subprograma: Valor_Masrepetido( ):
Entero Valor_Masrepetido(entero:Y[ ], entero: n, entero:vec[ ]){

Entero: may = Y[1], valor
Si (Y[ i ] > may) entonces
may = Y[ i ]
valor = vec[ i ]
FinSi
FinPara
Retorne(valor)
}
Subprograma: Eliminar_Masrepetido( ):
Void Valor_Masrepetido(entero:vec[ ], entero: n, entero:val){

Entero: i, j,

________________________________________________________________________________________
vec[ j ] = vec[j+1]
FinPara
n=n-1
FinSi
FinPara
n=n–1
FinSi
}

Entero: i
Imprima: vec[ i ]
FinPara
}
Pasos solución: 2
1°. Ordenar el vector en forma ascendente o descend ente: de ésta forma los
valores que se repiten quedan en forma consecutiva.
2°. Contar el número de veces que se repite cada va lor.
3°. Cada vez que se localice un valor que se repita más que el anterior más
repetido, se reemplaza para actualizar dicho valor.
b. Análisis
Datos de entrada
o n : Tamaño del vector “vec[ ]”

o vec[ i ] : Valor a introducir en la posición i
Procedimiento:
o i, j : Índices para recorrer los vectores

o cont : Contador de valores repetidos
o may : El mayor número de veces que se repite
o val : Valor que más se repite
Datos de salida
o vec[ i ] : El valor más repetido

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: vec[100],n,i,j,aux,cont=1,may=0
Lea n
Lea vec[ i ]
FinPara
aux = vec[ i ]
vec[ i ] = vec[ j ]
vec[ j ] = aux
FinSi
FinPara
FinPara
val = vec[1]
Si (vec[ i ] = vec[i+1]) entonces
cont = cont + 1
else
Si (cont > may) entonces
may = cont
val = vec[ i ]
cont = 1
FinSi
FinSi
FinPara
vec[ j ] = vec[j+1]
FinPara
n=n-1
FinSi
FinPara
n=n-1
FinSi
Para (i =1, n , 1) Haga
Imprima: vec[ i ]
FinPara

________________________________________________________________________________________
Ejemplo 7
a. Definición
Crear un vector con una frase, la cual debe ser ingresada caracter por caracter hasta que
se introduzca un punto; se desea, crear un programa que elimine todos los espacios en
blanco que contenga dicha frase.
b. Análisis
Datos de entrada
o car : Caracter ingresado por teclado.
Procedimiento:
o Si (frase[ i ] = ‘ ‘) entonces
: Cada vez sea localizado un espacio en blanco, se deben traer todos
los caracteres siguientes en el vector un lugar hacia a atrás, es decir,
el carácter siguiente se mueve a la posición en blanco, y así
sucesivamente con todos los demás caracteres hasta terminar de
recorrer el vector:
Para (j = i, n-1, 1) haga Se comienza desde la posición en la cual

frase[ j ] = frase[j+1] fue localizado el espacio en blanco.
FinPara
n = n -1
Al final, se debe decrementar el tamaño del vector en 1 (n = n -1).
Y se repite de nuevo el ciclo hasta localizar otro espacio en blanco.
Datos de salida
o frase[ i ] : Vector frase.
Otras variables:
o frase[ ] : Vector que contiene la frase

o n : Tamaño que alcanza la frase
o j : Segundo índice para traer los caracteres hacia adelante
una vez sea localizado un espacio en blanco.

________________________________________________________________________________________
A continuación pude visualizar dos programas equivalentes para crear el vector frase:
- Por medio de un ciclo MIENTRAS.
Imprima: "Ingrese un caracter o <punto (.) para finalizar>:”

Lea car
Mientras (car <> ‘.’) haga
i=i+1
frase[ i ]=car
Lea car
FinMQ
n=i
- Por medio de un ciclo REPETIR _ HASTA.
Repetir
Lea car
i=i+1
frase[ i ] = car
Hasta_Que (car <>’.’) Haga
n=i
Diferencias entre crear el vector frase con ciclo MIENTRAS vs REPETIR_HASTA:
1°. Diferencia:
• Con el ciclo MIENTRAS, si se ingresa un punto, éste no queda almacenado en el

vector.
• Con el ciclo REPETIR_HASTA, el punto, si queda almacenado en el vector.
2°. Diferencia:
• Con el ciclo MIENTRAS, si el primer carácter ingresado es un punto, no ingresará al

ciclo.
• Con el ciclo REPETIR_HASTA, siempre se ingresa por lo menos una vez al ciclo , de
tal forma, que si el primer carácter ingresado es un punto, éste quedará almacenado
en el vector.

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: n,i=0,j
Caracter: frase[100], car
Repetir
Lea car
i=i+1
frase[ i ] = car
n=i
Si (frase[ i ] = ‘ ‘) entonces
Para (j = i, n-1, 1) Haga
frase[ j ] = frase[j+1]
FinPara
n = n -1
FinSi
FinPara
Imprima: frase[ i ]
FinPara
Fin

________________________________________________________________________________________
n i frase[ i ] Car frase[ i ] = ‘ ‘ Vector Frase
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 frase[1]=’H’ ‘H’ H O L A F E L I Z D I A .
2 frase[2]=’O’ ‘O’
3 frase[3]=’L’ ‘L’
4 frase[4]=’A’ ‘A’
5 frase[5]=’ ‘ ‘‘
6 frase[6]=’F’ ‘F’
7 frase[7]=’E’ ‘E’
8 frase[8]=’L’ ‘L’
9 frase[9]=’I’ ‘I’
10 frase[10]=’Z’ ‘Z’
11 frase[11]=’ ’ ‘‘
12 frase[12]=’D’ ‘D’
13 frase[13]=’I’ ‘I’
14 frase[14]=’A’ ‘A’
15 frase[15]=’.’ ’.’ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
15 H O L A F E L I Z D I A .
1 Falso
2 Falso
3 Falso
4 Falso
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
5 Verdadero H O L A F E L I Z D I A . .
14 6 Falso
7 Falso
9 Falso
10 Verdadero
13 11 Falso
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
12 Falso H O L A F E L I Z D I A . . .
13 Falso
14
Programa Principal
Inicio
Entero: n
Caracter: frase[100]
n = Crear_Vector(frase)
n = Eliminar_Blancos(frase,n)
Imprimir_Frase(frase, n)
Fin

________________________________________________________________________________________
Entero Crear_Vector(Caracter: frase[ ]) {

Entero: i
Caracter: car
Repetir
Lea car
i=i+1
frase[ i ] = car
retorne( i )
}
Subprograma: Eliminar_Blancos( )
Entero Eliminar_Blancos(Caracter: frase[ ], entero:n) {

Entero: i, j
Si (frase[ i ] = ‘ ‘) entonces
Para (j = i, n-1, 1) Haga
frase[ j ] = frase[j+1]
FinPara
n = n -1
FinSi
FinPara
Retorne (n)
}
Void Imprimir_Vector(Caracter:frase[ ], entero:n) {

Entero: i
Imprima: frase[ i ]
FinPara
}

________________________________________________________________________________________
2.2 Arreglos bidimensionales o matrices
Una matriz es un arreglo cuyos elementos están dispuestos en dos direcciones, filas y
columnas y para poder referenciar uno de sus elementos, son necesarios dos índices, uno
para la fila y otro para la columna.
Una matriz se puede ver como un vector de vectores, por ejemplo, si se tiene la matriz:
0 −5 6 9
4 −2 1 7
X=
8 −9 2 0
3 − 1 10 11
Se puede ver como el vector fila
0 -5 6 9
X= 4 -2 1 7
8 -9 2 0
3 -1 10 11
O como el vector columna
0 -5 6 9
4 -2 1 7
X=
8 -9 2 0
3 -1 10 11
A los arreglos bidimensionales (matrices) se les debe dar un nombre (Nomb_arreglo) para
identificar el conjunto de datos que éste agrupa, los nombres de arreglos son
identificadores y como tal deben ser nombres nemotécnicos que sean representativos.
Nomb_arreglo[# , #]
hace referencia a la columna
hace referencia a la fila

________________________________________________________________________________________
Un elemento de una matriz puede ser referenciado individualmente si se acompaña el

nombre de la matriz por los dos índices que indican, el primero la fila y el segundo la
columna en las cuales está el elemento, así, si nos vamos a referir al elemento ubicado en
la fila 3 columna 2 de la matriz X, escribimos X[3,2] y de ésta forma nos referimos al valor
-9.
Referencia de elementos
Ejemplo: 0 -5 6 9
• X[2,3] = 1 4 -2 1 7
• X[4,2] =-1 X=
8 -9 2 0
3 -1 10 11
ne
Para formar o crear una matriz, se puede hacer formando primero la primera fila, luego la
segunda fila, luego la tercera, y así sucesivamente, es decir se crea “por filas”, pero
también se puede hacer “por columnas”, es decir, se forma primero la primera columna,
luego la segunda columna, luego la tercera y así en adelante.
Dimensionamiento y Carga de una matriz
Así como un vector tiene que ser nombrado y dimensionado antes de ser utilizado, una
matriz también. La instrucción para dimensionar un matriz es:
dimensionar M[5,6] , es decir:
• Entero M[5,6], se creará una matriz de cinco filas x seis columnas, de valores enteros.
• Real M[4,3], se creará una matriz de cuatro filas x tres columnas, de valores reales.
La carga de datos se realiza de la misma forma que un vector, por medio de un ciclo
PARA; solo que en este caso, vamos a necesitar 2 ciclos; uno que recorra las filas y otro
las columnas:
Ejemplo:
Para (F = 1, 5, 1) Haga
Para (C = 1, 6, 1) Haga
Imprima: “Ingrese un valor en la Posición:”, F, C
Lea M[F, C]
FinPara
FinPara

________________________________________________________________________________________
En éste ejemplo, la variable fila (F) comienza en el valor 1, luego se da inicio al ciclo más
interno que controla las columnas (C) que va desde 1 hasta 6. El ciclo de las columnas
debe terminar todo su recorrido para que pueda saltar a la siguiente fila. Los índices van
tomando estos valores:
1er Ciclo 2do Ciclo 3er Ciclo 4to Ciclo 5to Ciclo 6to Ciclo
F,C F,C F,C F,C F,C F,C
MAT [1, 1] MAT [2, 1] MAT [3, 1] MAT [4, 1] MAT [5, 1] MAT [6, 1]
C=6 C=6 C=6 C=6 C=6 C=6
F =7
Fin del ciclo interno
Fin del ciclo externo
El recorrido de una matriz se hace, por tanto de esta manera:
Col 1 Col 2 Col 3 Col 4 Col 5 Col

6
Fila 1 5 99 -34 56 45 2
Fila 2 7 125 25 57 32 3
Fila 3 6 12 -78 -89 154 -2
Fila 4 9 18 0 -79 451 78
Fila 5 -8 -14 43 87 325 52
2.2.1 Sintaxis: para crear e imprimir una matriz de dimensiones nxm elementos
Sintaxis: para crear una matriz de dimensiones nxm elementos fila por fila
Entero: i, j, n, m, mat[20,20]
Imprima: “Ingrese el número de filas:”
Lea n
Imprima: “Ingrese el número de columnas:”
Lea m
Para (i=1 , n, 1) Haga
Para (j=1 , m, 1) Haga
Imprima:”Ingrese un valor en la posición:”, i, j
Lea mat[i, j]
Fin Para
Fin Para
Fin

________________________________________________________________________________________
n m i j Mat[i, j] Mat
4 3 1 1 Mat[1, 1] = 5
1 2 3
2 Mat[1, 2] = 2 5 2 9
1
3 Mat[1, 3] = 9 11 8 3
2
4 Fin ciclo interno 4 1 6
3
2 1 Mat[2, 1] = 11 10 13 25
4
2 Mat[2, 2] = 8
3 Mat[2, 3] = 3
4 Fin ciclo interno
3 1 Mat[3, 1] = 4
2 Mat[3, 2] = 1
3 Mat[3, 3] = 6
4 Fin ciclo interno
4 1 Mat[4, 1] = 10
2 Mat[4, 2] = 13
3 Mat[4, 3] = 25
4 Fin ciclo
5 Fin ciclo externo
Sintaxis: para crear una matriz de dimensiones nxm elementos columna por columna
Entero: i, j, n, m, mat[20,20]
Imprima: “Ingrese el número de filas:”
Lea n
Imprima: “Ingrese el número de columnas:”
Lea m
Para (j=1 , m, 1) Haga se intercambian los ciclos, el interno pasa a ser externo y vs.
Imprima:”Ingrese un valor en la posición:”, i, j
Lea mat[i, j]
Fin Para
Fin Para
Fin

________________________________________________________________________________________
n m j i Mat[i, j] Mat
4 3 1 1 Mat[1, 1] = 5
1 2 3
2 Mat[2, 1] = 11 5 2 9
1
3 Mat[3, 1] = 4 11 8 3
2
4 Mat[4, 1] = 10 4 1 6
3
5 Fin ciclo interno 10 13 25
4
2 1 Mat[1, 2] = 2
2 Mat[2, 2] = 8
3 Mat[3, 2] = 1
4 Mat[4, 2] = 13
5 Fin ciclo interno
3 1 Mat[1, 3] = 9
2 Mat[2, 3] = 3
3 Mat[3, 3] = 6
4 Mat[4, 3] = 25
5 Fin ciclo interno
4 Fin ciclo externo
Sintaxis: para imprimir una matriz de dimensiones nxm elementos fila por fila

Imprima: mat[i, j]
Fin Para
Fin Para
Fin
Sintaxis: para imprimir una matriz de dimensiones nxm elementos columna por columna

Imprima: mat[i, j]
Fin Para
Fin Para
Fin

________________________________________________________________________________________
2.2.2 Matrices especiales
a. Matriz cuadrada
Una matriz es cuadrada si el número de filas es igual al número de columnas. En este

caso, su tamaño (número de elementos) se puede definir únicamente con el orden, es
decir, se puede definir simplemente diciendo “matriz cuadrada de orden N” y no es
necesario decir “N filas y N columnas”.
Ejemplo: la siguiente es una matriz cuadrada de orden 3
12 10 32
MAT -6 -9 56
45 81 97
En una matriz cuadrada existen dos diagonales que son: la diagonal principal y la
diagonal secundaria. La principal está conformada por los elementos que están en la línea
imaginaria que va desde la parte superior izquierda hasta la parte inferior derecha de la
matriz.
La diagonal secundaria está conformada por los elementos que están situados en la línea
imaginaria que va desde la parte superior derecha hasta la parte inferior izquierda de la
matriz. Así
Diagonal secundaria
Diagonal principal

________________________________________________________________________________________
Visualizada de otra forma:
Las matrices cuadradas tienen ciertas características; por ejemplo, los elementos en
donde el número de filas es igual al número de columnas se llama diagonal principal
(señalados en amarillo): fila = columna
La diagonal principal define así dos áreas bien notorias, una que está por encima y otra
por debajo. La región determinada por los elementos situados sobre la diagonal principal
se llama matriz triangular superior que tiene la propiedad en la cual: fila < columna.
La matriz triangular inferior es la zona situada debajo de la diagonal principal, cuyos

índices cumplen con la propiedad: fila > columna.
Elementos de la Matriz Elementos de la Matriz

triangular superior. triangular inferior.
b. Matriz identidad
Una matriz es identidad si es cuadrada y además, los elementos de la diagonal principal

son todos iguales a 1 y los demás son ceros.

________________________________________________________________________________________
Ejemplo: La siguiente matriz es identidad
1 0 0 0
0 1 0 0
I=
0 0 1 0
0 0 0 1
c. Matriz transpuesta
La transpuesta de la matriz A, denotada AT, es una matriz tal que las filas de A son las
columnas de AT y las columnas de A son las filas de AT. Por consiguiente, si la matriz A es
de orden N*M, la matriz AT es de orden M*N.
Ejemplo:
9 -1 0
9 5 7 8
5 40 2
Sea la matriz A = -1 40 11 -5 la transpuesta AT =
7 11 6
0 2 6 7
8 -5 7
d. Matriz simétrica
Una matriz S es simétrica si se cumple que S[I,J] = S[J,I], para todos los elementos de la
matriz.
Ejemplo, la siguiente matriz es simétrica, porque en todas las posiciones de ella se

cumple la condición anterior.
8 4 -1 0
4 7 -2 9
S=
-1 -2 0 3
0 9 3 5

________________________________________________________________________________________
e. Matriz inversa
La inversa de la matriz A, denotada A-1, es una matriz tal que A * A-1 = I, siendo I la matriz
identidad.
Propiedades de los elementos de la matriz cuadrada
Sea la matriz cuadrada de orden 5, en la cual los elementos se representarán con el

nombre de la matriz y su posición dentro de ella, es decir, el primer dígito es la fila y el
segundo es la columna en donde están ubicados:
Diagonal secundaria
A11 A12 A13 A14
A21 A22 A23 A24
A31 A32 A33 A34
A41 A42 A43 A44

Diagonal principal
Si I es el índice de la fila y J es el índice de la columna y N es el orden de la matriz,

entonces:
(1) Los elementos de la diagonal principal cumplen la condición: I = J

(2) Los elementos de la diagonal secundaria cumplen la condición i + j = N + 1
(3) Los elementos por encima de la diagonal principal cumplen la condición: I < J
(4) Los elementos por debajo de la diagonal principal cumplen la condición: I > J

________________________________________________________________________________________
2.2.3 Operaciones con Matrices
a. Suma de matrices: Si A y B son dos matrices de igual dimensión (M x N), entonces

la suma de A y B existe y es igual a una matriz C también de dimensión M x N en
donde cada elemento de C[i, j] = A[i, j] + B[i, j]
10 8 3 0 1 6 9 69
A= 7 -3 33 45 B= 14 22 56 7
9 15 71 29 3 5 80 1
A y B son de igual dimensión, por lo tanto existe una matriz C que es la suma de A y B
11 14 13 69
C= 21 19 89 52
12 20 151 30
b. Multiplicación de matrices: Si A es una matriz de dimensión N x M y B es otra

matriz de dimensión P x Q, el producto de A * B es posible, siempre y cuando el
número de columnas de la matriz A sea igual al número de filas de la a otra matriz B,
es decir M=P, por lo tanto la matriz resultantes será de dimensión N X Q: R[N,Q].
Ejemplo:
1 3 11 19
2 1
2 5
A * B = R 19 32
3 6
4 0 8 4

________________________________________________________________________________________
2.2.4 Ejemplos
Ejemplo 1
a. Definición
Las notas definitivas de un grupo de 20 estudiantes se tienen almacenadas en una

matriz llamada NOTAS, cada estudiante tiene un total de 5 materias, se desea elaborar
un programa que calcule e imprima:
- El promedio de notas de cada estudiante es sus cinco materias.

- Número total de estudiantes que pierden cada materia.
- Número total de estudiantes con nota igual a 1.0 en cada asignatura.
- Número total de estudiantes con nota igual a 5.0 en cada asignatura.
- Promedio de notas de todo el grupo en cada asignatura.
- Número total de estudiantes que pierden tres (3) o mas materias.
- Promedio de notas de todo el grupo en sus cinco (5) materias.
b. Análisis
Datos de entrada
o notas[ ][ ] : Matriz de notas
Dato de Proceso
o sum = sum + notas[ ][ ] : Sumatoria de notas

o prom : Promedio de notas
o si (notas[ ][ ]< 3.0) entonces
estp = estp + 1 : Total de estudiantes que pierden
o si (notas[i][j] = 1.0) entonces
est1 = est1 + 1 : Total de estudiantes con nota=1.0
o si (notas[i][j] = 5.0) entonces
est1 = est1 + 1 : Total de estudiantes con nota=5.0

________________________________________________________________________________________
Datos de salida
o prom : Promedio de notas de cada estudiante

o estp : Estudiantes que pierden materias
o estn1 : Estudiantes con nota = 1.0
o estn5 : Estudiantes con nota = 5.0
o estp3 : Estudiantes que pierden 3 o más materias
Otras variables:
o i : Índice para recorrer las filas

o j : Índice para recorrer las columnas
o notas[ ][ ] : Matriz de notas
c. Pseudocódigo
Inicio
Entero: i, j,estp,estn1,estn5,testp=0
Real: notas[20][5], sum, prom, sumpro=0
Para (i =1, 20, i) Haga
Para (j=1, 5, 1) Haga
Imprima: “Ingrese la nota del estudiante:”, i “en su materia:”, j
Lea notas[i][j]
FinPara
FinPara
//a. Promedio de cada estudiante en sus cinco materias
sum = 0, estp = 0
sum = sum + notas[i][j]
Si (notas[i][j] < 3.0) entonces
estp = estp + 1
FinSi
FinPara
Si (estp >= 3) entonce
testp = testp + 1
FinSi
prom = (sum / 5)
Imprima: “El promedio del estudiante:”, i, “En sus 5 materias es:”, prom
FinPara
Imprima: “El total de estudiantes que perdieron tres (3) o más materias es:”, testp
Para (j =1, 5, i) Haga
estp=0, estn1=0,estn5=0, sum=0
Para (i=1, 20, 1) Haga
estp = estp + 1

________________________________________________________________________________________
Si (notas[i][j] = 1.0) entonces

estn1 = estn1 + 1
FinSi
Sino
estn5 = estn5 + 1
FinSi
FinSi
FinPara
prom = sum / 20
sumpro = sumpro + prom
Imprima: “Total de estudiantes que perdieron la Materia: ”, j , “es=”, estp
Imprima: “Total de estudiantes que sacaron nota=1.0 en la Materia: ”, j , “es=”, estn1
Imprima: “Total de estudiantes que sacaron nota=5.0 en la Materia: ”, j , “es=”, estn5
Imprima: “El promedio del grupo en la Materia: ”, j , “es=”, prom
FinPara
prom=(sumpro/5)
Imprima: “El promedio de notas de todo el grupo en sus cinco materias es:”, prom
Fin
Nota: para efectos de la prueba de escritorio se creará una matriz para un grupo de 4
estudiantes.
Materias
i j sum prom estp testp
j =1 2 3 4 5
1 1a5 19.5 3.9 1 1 i=1 2.5 3.5 5.0 4.5 4.0
2 1a5 12.2 2.4 4 2.9 2.3 1.5 1.8 3.7
2
3 1a5 16.5 3.3 2 4.5 4.0 3.3 2.0 2.7
3
4 1a5 15.5 3.1 2 2.6 3.8 2.0 4.0 3.1
4
Estudiantes que pierden 3 o más materias: 1
i j sum prom estp estn1 estn5 Estudiantes
1a4 1 12.5 3.1 3 0 0
1a4 2 13.6 3.4 1 0 0
1a4 3 11.8 3.0 2 0 1
1a4 4 12.3 3.1 2 0 0
1a4 5 13.5 3.4 1 0 0
Total: 16
El promedio de todo el grupo en sus 5 materias es: (16 / 5) = 3.2

________________________________________________________________________________________
Programa Principal
Inicio
Real: notas[20][5]
Crear_Matriz(notas)
Calcular_Datos1(notas)
Calcular_Datos2(notas)
Fin
Subprograma: Crear_Matriz( )
Entero Crear_Matriz(Real: notas[ ][ ] ) {

Entero: i, j
Imprima: “Ingrese la nota del estudiante:”, i “en su materia:”, j
Lea notas[i][j]
FinPara
FinPara
}
Subprograma: Calcular_Datos1( )
Void Calcular_Datos1(Real: notas[ ][ ] ) {

Entero: i, j, estp, testp=0
Real: sum, prom
sum = 0, estp = 0
estp = estp + 1
FinSi
FinPara
Si (estp >= 3) entonce
testp = testp + 1
FinSi
prom = (sum / 5)
Imprima: “El promedio del estudiante:”, i, “En sus 5 materias es:”, prom
FinPara
Imprima: “El total de estudiantes que perdieron tres (3) o más materias es:”, testp
}

________________________________________________________________________________________
Subprograma: Calcular_Datos2( )
Void Calcular_Datos2(Real: notas[ ][ ] ) {

Entero: i, j, estp, estn1, estn5
Real: sum, prom, sumpro=0
Para (j =1, 5, i) Haga
estp=0, estn1=0,estn5=0,sum=0
Para (i=1, 20, 1) Haga
estp = estp + 1
estn1 = estn1 + 1
FinSi
Sino
estn5 = estn5 + 1
FinSi
FinSi
FinPara
prom = sum / 20
sumpro = sumpro + prom
Imprima: “El total de estudiantes que perdieron la Materia: ”, j , “es=”, estp
Imprima: “El promedio del grupo en la Materia: ”, j , “es=”, prom
FinPara
prom=(sumpro/5)
Imprima: “El promedio de notas de todo el grupo en sus cinco materias es:”, prom
}
Ejemplo 2
a. Definición
Crear una Matriz de dimensiones n x m; construya un algoritmo que permita conformar

dos nuevos vectores así:
- El primer vector debe contener todos los valores pares de la matriz, sin que queden
valores repetidos en éste.
- El segundo vector debe contener todos los valores impares de la matriz, sin que
queden valores repetidos en éste.

________________________________________________________________________________________
b. Análisis
Datos de entrada
o X[ ][ ] : Matriz de valores creada por el usuario
Dato de Proceso
o X[i][j] MOD 2 = 0 : Para determinar los valores pares de la matriz

o k=k+1 : Contador de valores pares
o par[ ] : Vector de valores pares
o X[i][j] MOD 2 = 1 : Para determinar los valores impares de la matriz
o r=r+1 : Contador de valores impares
o imp[ ] : Vector de valores impares
Datos de salida
o par[ ] : Vector de valores pares

o imp[ ] : Vector de valores impares
Otras variables:

c. Pseudocódigo
Inicio
Entero: X[10][10], par[50],imp[50],n,m, i, j,k=0, r=0, s
Imprima: “Ingrese el número de filas de la matriz X:”
Lea n
Imprima: “Ingrese el número de columnas de la matriz X:”
Lea m
Para (j=1, m, 1) Haga
Imprima: “Ingrese un valore en la posición:”, i, j
Lea X[i][j]
FinPara
FinPara
Si (X[i][j] mod 2=0) entonces
s=1
Mientras (X[i][j] <> par[s] AND s <= k) Haga
s=s+1
FinMQ

________________________________________________________________________________________
Si (s > k) entonces
k = k +1
par[k] = X[i][j]
FinSi
Sino
s=1
Mientras (X[i][j] <> imp[s] AND s <= r) Haga
s=s+1
FinMQ
Si (s > r) entonces
r = r +1
imp[r] = X[i][j]
FinSi
FinSi
FinPara
FinPara
Imprima: par[i]
FinPara
Para (i =1, r, 1) Haga
Imprima: imp[i]
FinPara
Fin

________________________________________________________________________________________
X
i j X[i][j] K Par[k] r imp[r]
j =1 2 3 4
1 1 4 1 4 i=1 4 1 8 3
2 1 1 1 10 5 3 7
2
3 8 2 8 4 6 7 8
3
4 3 2 3 15 4 1 6
4
2 1 10 3 10
2 5 3 5
3 3
K=1 2 3 4 5 6
4 7 4 7 par 4 8 10 6
3 1 4
r =1 2 3 4 5 6
2 6 4 6 imp 1 3 5 7 15
3 7
4 8
4 1 15 5 15
2 4
3 1
4 6
Programa Principal
Inicio
Entero: X[10][10], n,m
Imprima: “Ingrese el número de filas de la matriz X:”
Lea n
Imprima: “Ingrese el número de columnas de la matriz X:”
Lea m
Crear_Matriz(X,n,m)
Par_Impar(X,n,m)
Fin

________________________________________________________________________________________
Void Crear_Matriz(Entero: X[ ][ ], Entero: n, Entero: m ) {

Entero: i, j
Lea X[i][j]
FinPara
FinPara
}
Subprograma: Par_Impar( )
Entero Par_Impar(Entero: X[ ][ ], Entero: n, Entero: m ) {

Entero: i, j,s,k,r, par[n*m], imp[n*m]
Si (X[i][j] mod 2=0) entonces
s=1
Mientras (X[i][j] <> par[s] AND s <= k) Haga
s=s+1
FinMQ
Si (s > k) entonces
k = k +1
par[k] = X[i][j]
FinSi
Sino
s=1
Mientras (X[i][j] <> imp[s] AND s <= r) Haga
s=s+1
FinMQ
Si (s > r) entonces
r = r +1
imp[r] = X[i][j]
FinSi
FinSi
FinPara
FinPara
Imprima: par[i]
FinPara
Para (i =1, r, 1) Haga
Imprima: imp[i]
FinPara
}

________________________________________________________________________________________
Ejemplo 3
a. Definición
Crear una Matriz de dimensiones n x m; elabore un algoritmo que permita obtener lo

siguiente:
- El valor mayor de cada columna.

- El valor menor de cada columna.
- El numero de veces que se repite el mayor valor de cada columna.
- El numero de veces que se repite el menor valor de cada columna.
- El menor valor de la matriz y el número de veces que se repite.
- El mayor valor de la matriz y el número de veces que se repite.
b. Análisis
Datos de entrada
o M[i][j] : Matriz de valores creada por el usuario
Datos de salida
o M[1][j] : Menor valor de cada columna

o M[n][j] : Mayor valor de cada columna
o cont : Número de veces que se repite el menor valor y
y número de veces que se repite el mayor valor
Otras variables:

c. Pseudocódigo
Inicio
Entero: M[10][10],n,m,i,j,k,aux,men,nmen=0,may,nmay=0
Imprima: “Ingrese el número de filas de la matriz M:”
Lea n
Imprima: “Ingrese el número de columnas de la matriz M:”
Lea m
Lea M[i][j]
FinPara
FinPara
Para (j =1, m, 1) Haga
Para (k=1, n-1, 1) Haga

________________________________________________________________________________________
Para (i=k+1, n, 1) Haga

Si (M[k][j] > M[i][j]) entonces
aux = M[k][j]
M[k][j] = M[i][j]
M[i][j] = aux
FinSi
FinPara
FinPara
FinPara
Para (j = 1, m, 1) Haga
Imprima: “El menor valor de la columna:”, j “es :”, M[1][j]
Imprima: “El mayor valor de la columna:”, j “es :”, M[n][j]
FinPara
cont=0
i=2
Mientras (M[1][j] <> M[i][j] AND i <=n) Haga
cont = cont +1
i=i+1
FinMQ
Imprima: “El número de veces que repite el menor valor de la columna:”, j “es:”,cont
FinPara
cont=0
i=n-1
Mientras (M[n][j] <> M[i][j] AND i >=1) Haga
cont = cont +1
i = i -1
FinMQ
Imprima: “El número de veces que repite el mayor valor de la columna:”, j “es:”,cont
FinPara
men=M[1][1]
may=M[1][1]
Si (M[i][j] < men) entonces
men = M[i][j]
FinSi
Si (M[i][j] > may) entonces
may = M[i][j]
FinSi
FinPara
FinPara
Si (M[i][j] = men) entonces
nmen = nmen + 1
FinSi
Si (M[i][j] = may) entonces

________________________________________________________________________________________
nmay = nmay + 1
FinSi
FinPara
FinPara
Imprima: “El menor valor de la matriz es:”, men “y se repite:”, contmen “veces”
Imprima: “El mayor valor de la matriz es:”, may “y se repite:”, contmay “veces”
Fin

________________________________________________________________________________________
i J M[1][j] M[n][j]
j =1 2 3 4
1 1 10 i=1 4 8 2 6
2 2 8 2. 2 8 9 1
2
3 2 9 10 2 6 9
3
4 1 9 3 8 3 1
4
1 2 5 9
Menor de cada col Mayor de cada columna n=5
i j M[i][j] cont 3.
1 1 1 1 Número
j =1 2 3 4
de veces i=1
1 2 2 1 1 2 2 1
que se
2 2 2 2 2 3 1
repite 2
1 3 2 1 el menor 1. 3 8 5 6
3
valor
1 4 1 1 de cada 4 8 6 9
4
2 1 2 columna 10 8 9 9
5
i j M[i][j] cont 4. 5. i J M[i][j] men nmen may nmay

5 1 10 1 Número 1 9
5 2 8 1 de veces 1 1-4 2
4 8 2 que se 2 1-4 3
3 8 3 repite 3 1-4
el mayor
5 3 9 1 4 1-4 1
valor
5 4 9 1 5 1-4 3
de cada
4 9 2 columna

________________________________________________________________________________________
Programa Principal
Inicio
Entero: M[10][10], n,m, j
Lea n
Lea m
Crear_Matriz(M,n,m)
Ordenar_Matriz(M,n,m)
Imprima: “El menor valor de la columna:”, j “es :”, M[1][j]
Imprima: “El mayor valor de la columna:”, j “es :”, M[n][j]
FinPara
Tvalmen_Col(M,n,m)
Tvalmay_Col(M,n,m)
Menmay_Matriz(M,n,m)
Fin

Entero: i, j
Lea M[i][j]
FinPara
FinPara
}

Entero: i, j, k, aux
Para (j =1, m, 1) Haga
Para (k=1, n-1, 1) Haga
Para (i=k+1, n, 1) Haga
Si (M[k][j] > M[i][j]) entonces
aux = M[k][j]
M[k][j] = M[i][j]
M[i][j] = aux
FinSi
FinPara
FinPara
FinPara
}

________________________________________________________________________________________
Subprograma: Tvalmen_Col( )
Void Tvalmen_Col(Entero: M[ ][ ], Entero: n, Entero: m ) {

Entero: i, j,cont
cont=0
Para (i = 2, n, 1) Haga
Si (M[1][j] = M[i][j]) entonces
cont = cont +1
FInSi
FinPara
Imprima: “El número de veces que repite el menor valor de la columna:”, j “es:”,cont
FinPara
}
Subprograma: Tvalmay_Col( )
Void Tvalmen_Col(Entero: M[ ][ ], Entero: n, Entero: m ) {

Entero: i, j,cont
cont=0
Para (i = n-1, 1, -1) Haga
Si (M[n][j] = M[i][j]) entonces
cont = cont +1
FInSi
FinPara
Imprima: “El número de veces que repite el mayor valor de la columna:”, j “es:”,cont
FinPara
}
Subprograma: Menmay_Matriz( )
Void Menmay_Matriz(Entero: M[ ][ ], Entero: n, Entero: m ) {

Entero: i,j,men, may,contmen=0,contmay=0
men=M[1][1]
may=M[1][1]
Si (M[i][j] < men) entonces
men = M[i][j]
FinSi
Si (M[i][j] > may) entonces
may = M[i][j]
FinSi
FinPara
FinPara

________________________________________________________________________________________

Si (M[i][j] = men) entonces
contmen = contmen + 1
FinSi
Si (M[i][j] = may) entonces
contmay = contmay + 1
FinSi
FinPara
FinPara
Imprima: “El menor valor de la matriz es:”, men “y se repite:”, contmen “veces”
Imprima: “El mayor valor de la matriz es:”, may “y se repite:”, contmay “veces”
}
Ejemplo 4
a. Definición
Construya una matriz de dimensiones n x m; diseñe un algoritmo que calcule e
imprima:
- El número total de veces que se repite CADA VALOR en la matriz.

- El valor que más se repite en la matriz.
- La cantidad de números que son menores al promedio de los valores de dicha matriz.
b. Análisis
Datos de entrada
o M[i][j] : Matriz de valores creada por el usuario
Datos de proceso
o cont : Número de veces que se repite un valor en la matriz
o sum = sum + M[i][j] : Sumatoria de los valores de la matriz
o prom=(sum/(n*m)) : Promedio de los valores de la matriz
o nmen : Contador de valores menores al promedio
o vec[ ] : Vector que contiene los valores de la matriz
o cont : Número de veces que se repite un valor
Datos de salida
o tot : Número veces que se repite el valor más repetido

o val : Valor que más se repite
o nmen : Total de valores menores al promedio

________________________________________________________________________________________
Otras variables:

o k : Índice para recorrer el vector vec[ ]
c. Pseudocódigo
Inicio
Entero: M[10][10],n,m,i,j,k=0,sum=0,nmen=0,cont=0,aux,tot,val
Real: prom
Lea n
Lea m
Entero: vec[n*m]
Lea M[i][j]
FinPara
FinPara
k = k +1
vec[k] = M[i][j]
sum = sum + M[i][j]
FinPara
FinPara
prom = sum /(n*m)
Si (M[i][j] < prom) entonces
nmen = nmen + 1
FinSi
FinPara
FinPara
Imprima: “Total de números menores al promedio de los valores de la matriz:”, nmen
Para (i =1, n-1, 1) Haga
Para (j=i+1, n, 1) Haga
Si (vec[i] > vec [j]) entonces
aux = vec[i]
vec[i] = vec[j]
vec[j] = aux
FinSi
FinPara
FinPara

________________________________________________________________________________________
cont = 1,tot=1,val=vec[1]
Si (vec[i] = vec[i+1]) entonces
cont = cont + 1
Sino
Imprima : “El valor : “, vec[i], “se repite:”, cont ,”veces”
Si (cont > tot) entonces
tot = cont
val = vec[i]
FinSi
cont = 1
FinSi
FinPara
Imprima : “El valor que más se repite es: “, val, “con un total de:”, may ,”repeticiones”
Fin

________________________________________________________________________________________
1. 2. Mat
i j sum nmen
1 2 3
1 1-4 17 2 5 3 9
1
2 1-4 39 1 Valores 11 8 3
2
3 1-4 55 2 menores al
promedio 3
9 1 6
4 1-4 87 0 10 13 9
4
prom 7.25 5 Valores menores al promedio
vec 5 3 9 11 8 3 9 1 6 10 13 9
3. Vector Ordenado
vec 1 3 3 5 6 8 9 9 9 10 11 13
4. El valor que más se repite

i vec[i] = vec[i+1] cont tot cont > tot val
1 1 1
1 1 = 3 :Falso 1 Falso
2 3 = 3 :Verdadero 2
3 3 = 5 :Falso 1 2 Verdadero 3
9 9 = 10 :Falso 1 3 Verdadero 9
El valor: 9 se repite un total de: 3 veces

________________________________________________________________________________________
Programa Principal
Inicio
Entero: M[10][10], n,m,men
Real: prom
Lea n
Lea m
Entero: vec[n*m]
Crear_Matriz(M,n,m)
prom = Promedio(M,n,m,vec)
men = Menor_Promedio(M,n,m,prom)
Imprima: “Total de números menores al promedio de los valores de la matriz:”, men
Ordenar_Vector(vec,n*m)
Val_Masrepet(vec,n*m)
Fin

Entero: i, j
Lea M[i][j]
FinPara
FinPara
}
Subprograma: Promedio( )
Real Promedio(Entero: M[ ][ ], Entero: n, Entero: m,Entero: vec[ ]) {

Entero: i, j, k=0, sum=0
sum = sum + M[i][j]
k = k +1
vec[k] = M[i][j]
FinPara
FinPara
Return (sum /(n*m))
}

________________________________________________________________________________________
Subprograma: Menor_Promedio( )
Real Menor_Promedio(Entero: M[ ][ ], Entero: n, Entero: m,Real: prom) {

Entero: i, j, nmen=0
Si (M[i][j] < prom) entonces
nmen = nmen + 1
FinSi
FinPara
FinPara
Retorne(nmen)
}
Subprograma: Ordenar_Vector( )
Void Ordenar_Vector(Entero: vec[ ], Entero: n) {

Entero: i, j, aux
Para (j=i+1, n, 1) Haga
Si (vec[i] > vec [j]) entonces
aux = vec[i]
vec[i] = vec[j]
vec[j] = aux
FinSi
FinPara
FinPara
}
Subprograma: Val_Masrepet( )
Void Val_Masrepet(Entero: vec[ ], Entero: n) {

Entero: i, cont = 1,may=1,val=vec[1]
cont = cont + 1
Sino
Imprima : “El valor : “, vec[i], “se repite:”, cont ,”veces”
Si (cont > may) entonces
may = cont
val = vec[i]
FinSi
cont = 1
FinSi
FinPara
Imprima : “El valor que más se repite es: “, val, “con un total de:”, may ,”repeticiones”
}

________________________________________________________________________________________
Ejemplo 5
a. Definición
Dada una matriz cuadrada de orden N; desarrollar un algoritmo que calcule e imprima:
- Promedio de los valores de la diagonal principal

- Promedio de los valores de la diagonal secundaria
- Promedio de los valores que se encuentran por encima de la diagonal principal
(triangular superior)
- Promedio de los valores que se encuentra por debajo a la diagonal principal
(triangular inferior)
- Determinar si el promedio de valores de la triangular superior es mayor al promedio
de los valores de la triangular inferior
b. Análisis
Datos de entrada
o M[i][j] : Matriz de valores ingresados por el usuario
Datos de proceso
o sdp : Sumatoria de valores de la diagonal principal
o stsup : Sumatoria de valores de la triangular superior
o sds : Sumatoria de valores de la diagonal secundaria
o stinf : Sumatoria de valores de la triangular inferior
o pdp : Promedio de valores de la diagonal principal
o ptsup : Promedio de valores de la triangular superior
o pds : Promedio de valores de la diagonal secundaria
o ptinf : Promedio de valores de la triangular inferior
Datos de salida
o pdp : Promedio de valores de la diagonal principal

o pds : Promedio de valores de la diagonal secundaria
o ptsup : Promedio de valores de la triangular superior
o ptinf : Promedio de valores de la triangular inferior
Otras variables:


________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: M[10][10],n,i,j,sdp=0,stsup=0,sds=0,stinf=0,cont=0
Real: pdp,ptsup,pds,ptinf
Lea n
Para (j=1, n, 1) Haga
Imprima: “Ingrese un valor en la posición:”, i, j
Lea M[i][j]
FinPara
FinPara
j=n
sdp = sdp + M[i][i]
sds = sds + M[i][j]
j = j -1
FinPara
pdp = sdp/n
pds = sds/n
Imprima: “El promedio de valores de la diagonal principal es:”, pdp
Imprima: “El promedio de valores de la diagonal secundaria es:”, pds
stsup=0, stinf=0
Si (i < j) entonces
stsup = stsup + M[i][j]
cont = cont + 1
Sino
Si (i > j) entonces
stinf = stinf + M[i][j]
FinSi
FinSI
FinPara
FinPara
ptsup = stsup/cont
ptinf = stinf/cont
Imprima: “El promedio de la triangular superior es:”, ptsup
Imprima: “El promedio de la triangular inferior es:”, ptinf
Si (ptsup > ptinf) entonces
Imprima:”El promedio de valores de la triangular superior es mayor al promedio de
valores de la triangular inferior”
Sino
Imprima:”El promedio de valores de la triangular inferior es mayor al promedio de
valores de la triangular superior”
FinSi
Fin

________________________________________________________________________________________
i J sdp sds pdp pds

j =1 2 3 4
0 0 i=1
4.75 5.0 4 8 2 6
1 4 4 6
2
2 8 9 1
2 3 12 15
3
10 2 6 9
3 2 18 17
4
3 8 3 1
4 1 19 20
i j stsup stinf ptsup ptinf cont

j =1 2 3 4
0 0 i=1
5.83 4.66 4 8 2 6
1 2-4 16 3
2
2 8 9 1
2 1 2 5
3
10 2 6 9
3-4 26
6 4
3 8 3 1
3 1-2 14
4 35
4 1-3 28
Programa Principal
Inicio
Entero: M[10][10], n
Lea n
Crear_Matriz(M,n)
Prom_Diagonales(M,n)
Prom_Triangulares(M,n)
Fin

________________________________________________________________________________________
Void Crear_Matriz(Entero: M[ ][ ], Entero: n) {

Entero: i, j
Imprima: “Ingrese un valor en la posición:”, i, j
Lea M[i][j]
FinPara
FinPara
}
Subprograma: Prom_Diagonales( )
Void Prom_Diagonales(Entero: M[ ][ ], Entero: n) {

Entero: i, j, sdp=0, sds=0
Real: pdp,pds
j=n
sdp = sdp + M[i][i]
sds = sds+ M[i][j]
j = j -1
FinPara
pdp = sdp/n
pds = sds/n
Imprima: “El promedio de valores de la diagonal principal es:”, pdp
Imprima: “El promedio de valores de la diagonal secundaria es:”, pds
}
Subprograma: Prom_Triangulares( )
Void Prom_Triangulares(Entero: M[ ][ ], Entero: n) {

Entero: i, j,stsup=0,stinf=0
Real: ptsup, ptinf
Si (i < j) entonces
stsup = stsup + M[i][j]
Sino
Si (i > j) entonces
stinf = stinf + M[i][j]
FinSi
FinSI
FinPara
FinPara
ptsup = stsup/n

________________________________________________________________________________________
ptinf = stinf/n
Imprima: “El promedio de la triangular superior es:”, ptsup
Imprima: “El promedio de la triangular inferior es:”, ptinf
Si (ptsup > ptinf) entonces
Imprima:”El promedio de valores de la triangular superior es mayor al promedio
de valores de la triangular inferior”
Sino
Imprima:”El promedio de valores de la triangular inferior es mayor al promedio
de valores de la triangular superior”
FinSi
}
Ejemplo 6
a. Definición
Elaborar un algoritmo que forme e imprima una matriz con las siguientes características:
• La primera fila y la primera columna tienen como elementos los números del 0 a N.
• Los demás elementos se obtienen de multiplicar cada elemento de la fila uno por
cada elemento de la columna uno. Así:
Ilustración:
0 1 2 3 4 5 6 7 8 9 10 …… N
1 1 2 3 4 5 6 7 8 9 10 ……
2 2 4 6 8 10 12 14 16 18 20 ……
3 3 6 9 12 15 18 21 24 27 30 ……
.
.
N
Al final, se debe imprimir la matriz creada (columna por columna).

________________________________________________________________________________________
b. Análisis
Datos de entrada
o M[i][j] : Matriz con las tablas de multiplicar
o N : Número hasta el cual se generarán las
multiplicaciones
Datos de proceso
o M[i][j]= (i - 1) * (j – 1) : Multiplicación de posiciones de la matriz
Datos de salida
o M[i][j] : Matriz con las tablas multiplicar generadas
Otras variables:
o i : Índice de las filas

o j : Índice de las columnas
c. Pseudocódigo
Inicio
Entero: M[10][10],n,i,j
Imprima: “¿Hasta qué número quiere generar las tablas de multiplicar?”
Lea: n
Para (j = 1, n, 1) Haga
M[1][j] = j -1
M[j][1] = j -1
FinPara
M[i][j] = (i - 1) * (j – 1)
FinPara
FinPara
Para (i= 1, n, 1) Haga
Imprima: M[i][j]
FinPara
FinPara
Fin

________________________________________________________________________________________
j =1 2 3 4 5 6 7 8
i=1 0 1 2 3 4 5 6 7
2 1 1 2 3 4 5 6 7
3 2 2 4 6 8 10 12 14
4 3 3 6 9 12 15 18 21
5 4 4 8 12 16 20 24 28
i j M[i][j] = (i - 1) * (j – 1)
2 2 M[2][2] 1 = (2 - 1) * (2 – 1)
3 M[2][3] 2 = (2 - 1) * (3 – 1)
4 M[2][3] 3 = (2 - 1) * (4 – 1)
3 2 M[3][2] 2 = (3 - 1) * (2 – 1)
3 M[3][3] 4 = (3 - 1) * (3 – 1)
4 M[3][3] 6 = (3 - 1) * (4 – 1)
4 2 M[4][2] 3 = (4 - 1) * (2 – 1)
3 M[4][3] 6 = (4 - 1) * (3 – 1)
4 M[4][4] 9 = (4 - 1) * (4 – 1)
Programa Principal
Inicio
Entero: M[10][10],n
Imprima: “¿Hasta qué número quiere generar las tablas de multiplicar?”
Lea: n
Crear_Matriz(M,n)
Tabla_Multiplicar(M,n)
Imprimir(M,n)
Fin

________________________________________________________________________________________
Void Crear_Matriz(Entero: M[ ][ ], Entero: n) {

Entero: j
M[1][j] = j -1
M[j][1] = j -1
FinPara
}
Subprograma: Tabla_Multiplicar( )
Void Imprimir(Entero: M[ ][ ], Entero: n) {

Entero: i, j
Para (i= 1, n, 1) Haga
Imprima: M[i][j]
FinPara
FinPara
}
Subprograma: Imprimir( )
Void Imprimir(Entero: M[ ][ ], Entero: n) {

Entero: i, j
Imprima: M[i][j]
FinPara
FinPara
}

________________________________________________________________________________________
Ejemplo 7
a. Definición
Multiplicación de matrices: Si A es una matriz de dimensión N x M y B es otra matriz de

dimensión P x Q, el producto de A * B es posible, siempre y cuando el número de
columnas de la matriz A sea igual al número de filas de la matriz B, es decir M=P, por lo
tanto la matriz resultantes será de dimensiones N X Q.
m
Recuerde que para obtener: R=AxB se calcula para cada R[i][j] = ∑ A[i][k]* B[k][j]
k =1
b. Análisis
Datos de entrada
o A[ ] : Matriz A
o N,M : Dimensiones de la matriz A
o B[ ] : Matriz B
o P, Q : Dimensiones de la matriz B
Datos de proceso
o sum=sum+A[i][j] * B[i][j]: Multiplicación de los elementos de la matriz
o R[i][j] = sum : Conformación de la matriz resultante
Datos de salida
o R[ ] : Matriz resultante de la multiplicación de A[ ] * B[ ]
Otras variables:
o i : Índice de las filas

o j : Índice de las columnas

________________________________________________________________________________________
c. Pseudocódigo
Inicio
Entero: A[10][10],B[10][10],R[10][10],n,m,p,q,i,j,k,sum
Imprima: “Ingrese el número de filas de la matriz A:?”
Lea: n
Imprima: “Ingrese el número de columnas de la matriz A:?”
Lea: m
Imprima: “Ingrese el número de filas de la matriz B:?”
Lea: p
Imprima: “Ingrese el número de columnas de la matriz B:?”
Lea: q
Si (m <> p) entonces
Imprima: “Las matrices no se pueden multiplicar, <m <> p>”
Sino
Imprima: “Ingrese un valor en la posición A[”, i “,” j ”]:”
Lea: A[i][j]
FinPara
FinPara
Para (i = 1, p, 1) Haga
Para (j = 1, q, 1) Haga
Imprima: “Ingrese un valor en la posición B[”, i “,” j ”]:”
Lea: B[i][j]
FinPara
FinPara
sum =0
Para (k = 1, m, 1) Haga
sum= sum + A[i][k]*B[k][j]
FinaPara
FinaPara
R[i][j]=sum
FinPara
Para (j= 1, q, 1) Haga
Imprima: R[i][j]
FinPara
FinPara
FinSi
Fin

________________________________________________________________________________________
A B R
1 2 3 1 2 1 2
1
3 2 1 1
4 2 1
16 19
2
1 4 3 * 2
1 6 = 2
14 29
2X3 2 1 2X2
3
Nxm nxq
3X2
pxq
i <= 2 j <= 2 k <= 3 sum = A[i][k]*B[k][j]
0
1 1 1 12 12= A[1][1]*B[1][1]
2 14 2= A[1][2]*B[2][1]
3 16 2= A[1][3]*B[3][1]
0
2 1 6 6= A[1][1]*B[1][2]
2 18 12= A[1][2]*B[2][2]
3 19 1= A[1][3]*B[3][2]
0
2 1 1 4 4= A[2][1]*B[1][1]
2 8 4= A[2][2]*B[2][1]
3 14 6= A[2][3]*B[3][1]
0
2 1 2 2= A[2][1]*B[1][2]
2 26 24= A[2][2]*B[2][2]
3 29 3= A[2][3]*B[3][2]
Programa Principal
Inicio
Entero: A[10][10],B[10][10],R[10][10],n,m,p,q
Imprima: “Ingrese el número de filas de la matriz A:?”
Lea: n
Imprima: “Ingrese el número de columnas de la matriz A:?”
Lea: m
Imprima: “Ingrese el número de filas de la matriz B:?”
Lea: p
Imprima: “Ingrese el número de columnas de la matriz B:?”
Lea: q

________________________________________________________________________________________
Si (m <> p) entonces
Imprima: “Las matrices no se pueden multiplicar, <m <> p>”
Sino
Crear_Matriz(A,n,m)
Crear_Matriz(B,p,q)
Mult_Matrices(A,n,m,B,p,q,R)
Imprimir(R,n,q)
FinSi
Fin
Void Crear_Matriz(Entero: M[ ][ ], Entero: n, Entero: m) {

Entero: i, j
Imprima: “Ingrese un valor en la posición M[”, i “,” j ”]:”
Lea: M[i][j]
FinPara
FinPara
}
Subprograma: Mult_Matrices( )
Void Mult_Matrices(Entero:A[ ][ ],Entero:n,Entero:m,Entero:B[ ][ ],Entero:p,Entero:q,Entero:R[ ][ ]) {

Entero: i, j, k, sum
sum =0
Para (k = 1, m, 1) Haga
sum= sum + A[i][k]*B[k][j]
FinaPara
FinaPara
R[i][j]=sum
FinPara
}
Subprograma: Imprimir( )
Void Imprimir(Entero: M[ ][ ], Entero: n, Entero: m) {

Entero: i, j
Imprima: R[i][j]
FinPara
FinPara
}

________________________________________________________________________________________
Actividades de Enseñanza Y Aprendizaje
Actividad 1:
Competencias a desarrollar:
a. Aplicar prueba de escritorio.

b. Identificar y utilizar las estructuras de datos más adecuadas dependiento del problema
a resolver.
c. Desarrollar habilidad en el análisis y solución de problemas algorítmicos.
Descripción Actividad: Desarrollar un programa que imprima el valor de un cheque en

letras.
Ejemplo 6´756.420*******
Imprimir: Seis Millones Setecientos Cicuenta y Seis Mil Cuatro Cientos Veinte Pesos M/L.
Lugar : Casa o Ambiente de Aprendizaje.
Duración : Tres horas
Número de Participantes : Máximo 2.
Medios de apoyo y recursos a utilizar: Papel, lápiz, borrador, módulo, documentos de

apoyo y computador.
Cierre de la actividad : en la próxima clase el docente podrá elegir según lo

considere pertinente, varios estudiantes que expliquen la solución realizada.

________________________________________________________________________________________
Actividad 2:
Competencias a desarrollar:
a. Aplicar prueba de escritorio.

b. Identificar y utilizar las estructuras de datos más adecuadas dependiento del problema
a resolver.
c. Desarrollar habilidad en el análisis y solución de problemas algorítmicos.
Descripción Actividad: Una empresea desea que usted desarrolle un programa que
permita calcular la nómina quincenal de sus 20 empleados. Los datos de los empleados
son almacenados en la siguiente forma:
Cod: Es un vector de 20 posiciones, el cual contiene el código de cada empleado.

HorT: Es una matriz de 20x15, la cual contiene las horas trabajadas de cada empleado en
la quincena. (las filas corresponden a los empleados, y las columnas son las horas
trabajadas cada día de la quincena).
ValHT: Es un vector de 20 posiciones, el cual contiene el Valor Hora que se paga a cada
empleado (hay una correspondencia posicional entre los vectores ValHT[ ] y Cod[ ], es
decir, el valor de la hora del empleado Cod[1], es el mismo que aparece en ValHT[1], y
asi sucesivamente para los demás).
NHij: Es un vector de 20 posiciones, el cual contiene el número de hijos del empleado.
La nómina se calcula con base a lo siguiente:
• Las horas menores o iguales a 96 se pagan al Valor Hora asignado a cada empleado.
• Las horas superiores a 96 se consideran como Horas Extras y se pagan al doble del
Valor Hora asignado a cada empleado.
• A cada empleado se le hace un descuento del 12% sobre su salario básico:
SalBas = HorT*ValHT (es decir, horas trabajadas * valor de la hora, NO incluye el valor
de las horas extras)
• A cada empleado se le da un subsidio de transporte de 15.000 pesos.
• Adicionalmente, cada empleado recibe una bonificación adicional de 20.000 pesos por
cada hijo que tenga.
La empresa desea saber lo siguiente:
a. Valor pagado por salario neto, salario básico, descuento, bonificación por cada
empleado.
b. Valor total pagado por salarios netos, valor horas extras, y bonificaciones de todos los
empleados.
c. Código del empleado que más gana y código del que menos gana.
d. Además, desea que ordene e imprima ascendentemente los salarios netos de cada
empleado.

________________________________________________________________________________________
Lugar : Casa o Ambiente de Aprendizaje.
Duración : Dos horas
Número de Participantes : Máximo 2.
Medios de apoyo y recursos a utilizar: Papel, lápiz, borrador, módulo, documentos de

apoyo y computador.
Cierre de la actividad : en la próxima clase el docente podrá elegir según lo

considere pertinente, varios estudiantes que expliquen la solución realizada.

________________________________________________________________________________________
Taller
Diseñe un algoritmo para cada uno de los problemas planteados, con su respectiva
prueba de escritorio.
1. Desarrollar un algoritmo que permita determinar los tres valores que más se repiten en
un vector de n elementos, además imprima el número de veces que se presenta cada
valor.
2. Diseñar un algoritmo que compruebe si una frase ingresada en un vector es un

palíndromo (frase que se puede leer igual de izquierda a derecha y de derecha a
izquierda, no se tienen en cuenta los espacios y signos de puntuación).
Ejemplo de frases palíndromos:
- Amor a Roma
- Anita lava la tina
- Oso
- Reconocer
- Ala
3. Elaborar un agoritmo que imprima los valores primos de un vector de n elementos,

además se requiere saber cuál es el primo que más se repite en dicho vector.
4. Se desea crear un vector con un párrafo que es ingresado por teclado, dicho párrafo
termina con el caracter de punto. Desarrolle un algoritmo que determine lo siguiente:
- Número total de preposiciones: a, con, de.
- Númeto total de determinantes artículos: el, la, los, las , un, una.
- Número total de espacios en blanco.
- Número total de palabras que no sean preposiciones ni artículos.
- Número de palabras que comiencen con: e (elefante), c (casa), u (uña), que
no sean preposiciones ni artículos.
- Número total de vocales.
5. Desarrollar un algoritmo que calcule el resultado de la siguiente sumatoria:
n
X [i]2i+1
∑
i =1 (2i + 1)!
Para n > 0
6. Dado un vector “V1” de n enteros positivos en base (10 , elaborar un algoritmo que
permita crear un nuevo vector “V2” el cual deberá contener el correspondiente Octal
de cada uno de los valores de “V1”.
7. Dado un vector “V1” de n enteros positivos, elaborar un algoritmo que permita crear
un nuevo vector “V2” el cual debe contener el correspondiente valor inverso de cada
posición de “V1”.

________________________________________________________________________________________
521 123 3654 12 …
125 321 4563 21 …
8. Dado un vector “V1” compuesto por N valores enteros positivos entre 1 y 100,
elaborar un algoritmo que permita crear un nuevo vector “V2” el cual deberá contener
el correspondiente Binario de cada valor decimal de “V1”.
9. La liga de Antioquia tiene almacenado los datos de una serie de deportista en tres
vectores, así:
Nomb: contiene el nombre de cada deportista.

Estat: contiene las estaturas de cada deportista, en la misma posición
correspondiente al vector de nombres.
Edad: contiene la edad de cada deportista, en la misma posición correspondiente al
vector de nombres.
La liga desea contratar sus servicios para desarrollar un programa, que permita
seleccionar los deportitas que jugarán los próximos torneos, según los siguientes
criterios:
Clasifican:
- Todos los deportistas cuya estatura sea mayor al promedio de todas las estaturas,
siempre y cuando su edad no sea mayor a 25 años.
- Todos los deportistas cuya estatura sea igual al promedio de todas las estaturas,
siempre y cuando su edad no sea menor o igual a 20 años.
Desarrolle un programa que imprima:

a. Nombre de los deportistas que clasifican.
b. Nombre de los deportistas que no clasican.
c. Nombre del deportista que clasificó con la mayor estatura.
d. Nombre del deportista que clasificó con la menor estatura.
10. Dado dos (2) vectores cualesquiera:
Por ejemplo:
A 236 3130 5235 2683 4532
B 126 3889 8996 1565
a. Diseñar un algoritmo que calcule la suma de A + B.
Por ejemplo:
sum 236 3256 9125 1679 6097

________________________________________________________________________________________
b. Diseñar un algoritmo que calcule la resta de A – B.
Por ejemplo:
res 236 3004 1345 3687 2967
Nota: recuerde que los enteros (int) sólo se pueden almacenar valores
comprendidos en el rango: (-32767 a +32768), por lo tanto, en cada posición
únicamente se pueden almacenar máximo 4 dígitos.
11. Crear una matriz A de N x N, elaborar un algoritmo que calcule el determinante de A.
Se sabe que:
a11 a12 a13
Det (A) = a21 a22 a23 = a11a22a33 + a12a23a31+ a21a32a13 - a13a22a31 - a12a21a33 – a32a23a11
a31 a32 a33
12. Dada una matriz X de dimensiones NxN, desarrollar un algoritmo que intercambie los
valores de la triangular inferior con los de la triangular superior.
13. Dada una matriz A de dimensiones NxN, elaborar un algoritmo que permita calcular la
inversa de dicha matriz.
14. Dadas tres matrices A, B y C de diemensiones 3x3, diseñar un algoritmo para que
calcule:
a. A + B – C
b. 3*A + C/2
c. (A * B) / C
15. Dada una matriz de dimensiones NxM, se desea contruir tres nuevos vectores, así:
a. Neg: almacenará todos los valores negativos de la matriz.

b. Par: contendrá todos los valores pares de la matriz.
c. Imp: conformado por todos los valores impares de la matriz.
Importante: los vectores no podrán contener valores duplicados.
Nota: Los vectores deben quedar ordenados en la medida en que se van

construyendo, es decir, una vez almacenado un valor en el vector no se podrá realizar
ningún tipo de ordenamiento.

________________________________________________________________________________________
16. Desarrollar un algoritmo que ordene todos los valores de una matriz ascendente, no
esta permitido llevar los elementos de la matriz a otro medio de almacenamiento para
ordenarlos y luego traerlos de vuelta.
17. Crear una matriz con valores reales, diseñe un programa que cree un menú con las
siguientes opciones:
MENÚ
1. Moda Debe calcular e imprimir la moda de los valores de la matriz
2. Varianza Debe calcular e imprimir la varianza de los valores de la matriz
3. Media Debe calcular e imprimir la media de los valores de la matriz
18. El instituto del medio lleva un registro sobre las temperaturas que se producen a diario
en la ciudad durante los doce meses del año, dichas temperaturas son almacenadas
en una matriz de 12x31 (doce meses por 31 días), se desea crear un programa que:
a. Calcule el promedio de temperatura de cada mes (complete con cero (0) para los
meses que tienen 29 o 30 días). Nota: para calcular el promedio se debe tener en
cuenta el número de días reales del mes.
b. Imprima el mes (en letras) más caliente y el de temperatura más baja.
c. Imprima los dias con su mes (en letras), en el cual la temperatura estuvo por
encima al promedio.
19. Un restaurante almacena las ventas diarias totales de sus meseros en una matriz de
10X7 (diez meseros por siete días de la semana). El restaurante paga a sus meseros
una comisión que depende del valor total de las ventas realizadas en el día, según la
siguiente tabla:
Venta Total Diaria Comisión

(sobre la venta)
<= 50.000 5%
>50.000 AND <=100.000 10%
>100.000 AND <=200.000 15%
>200.000 20%
El restaurante desea saber:
a. Total pagado por comisiones a sus 10 vendedores.

b. Nombre del mesero que obtuvo mayor pago de comisiones por día
c. Nombre del mesero que obtuvo menor pago de comisiones por día
d. Día de la semana (en letras: Ej. Lun, Mar) que presentó mayor valor de ventas
e. Día de la semana (en letras: Ej. Lun, Mar) que presentó menor valor de ventas
Los nombres de los vendedores se encuentran almacenados en un vector de 10

posiciones.
20. Crear una matriz A de dimensiones NxM con valores enteros que son ingresados por
el usuario, se desea construir un algoritmo que copie todos los valores de la matriz a
un vector, luego los ordene de la siguiente manera:

________________________________________________________________________________________
a. Los valores pares deben quedar en la primera mitad del vector (ordenados
ascendente mente).
b. Los valores impares deben quedar en la segunda mitad del vector (ordenados
ascendentemente).
Valores pares Valores impares

________________________________________________________________________________________
Autoevaluación
TEST: Cada respuesta correcta vale 0.25.

1. Según el siguiente segmento de programa: 6. Complete la línea que hace falta del siguiente
segmento de programa:
char animal[3]={‘o’,’s’,’o’};
for (int i=0; i<=2; i++){ while (inicio <= fin) {
for (int j=0; j<=1; j++) _____________________
cout<<animal[ j ]; if (vector[pos] == dato)
} return pos;
else {
if (vector[pos] < dato)
Imprime:
inicio = pos + 1;
else
A. ososos fin = pos - 1;
B. osooso }
C. osoosooso }
D. oosooso return -1;
2. Según el siguiente segmento de programa: 7. Según el siguiente segmento de programa:
int a[10]; int vec[10]={1,2,3,4,5};

for (int i=0; i<5; i++){ for (int i=0; i<5; i++){
a[ i ] = (i+1)*2; vec[ i ] = (vec[i++]+1)*2;
} }
for (i=5; i<10; i++)
a[ i ] = a[i - 5] – a[9 - i]; Al final, los datos almacenados en el vector son:
} A. 1,2,3,4,5
B. 2,6,8,10,12
Qué dato se almacenará en la posición a[9]: C. 4,6,8,10,12
D. 4,2,8,4,12
A. -4
B. -8 8. Tras la ejecución del siguiente segmento de
C. 8 programa:
D. 4 i=0;
while (i<10 && x[i] != dato){
3. Cuál de las siguientes estructuras es valida: i++;
}
A. for (i=0; i>10; i--) cout<<i; \\ imprime 10
B. for (i=0; 10; i++)
C. for (i=0; i<10; i++) Significa que:
D. for (i==0; i<10; i++) A. El dato fue localizado en la posición 10.
B. El dato no fue localizado.
4. Cuál es la forma correcta de invocar la función: C. El dato fue localizado en una posición intermedia.
D. Ninguna de las anteriores.
A. void promedio(int vec[n]);
B. void promedio(int vec[ ],int n); 9. Según el siguiente segmento de programa:
C. float promedio(vec[ ],n);
D. float promedio(int vec,n); A. int crear_vector(int vec,int n){
E. float promedio(int vec,int n); B. for (i=0, i<=n, i++)
C. cin<<vec[ i ];
5. Qué es un arreglo?: D. retorne(vec);
}
A. Conjunto de datos de diferentes tipos
B. Lista o agrupación de datos Escriba las correcciones que se requieran:
C. Lista o agrupación de datos del mismo tipo A. __________________________
D. Conjunto de datos homogéneos B. __________________________
E. Conjunto de datos No homogéneos C. __________________________
D. __________________________

________________________________________________________________________________________
10. Escriba el resultado de multiplicar A * B:
1 5
A= 2 3
4 6
3x2
2 4
B=
3 1
2x2
C=
Autoevaluación Algoritmo: Valor (2.5)
Desarrollar un algoritmo que elimine el valor que más se repite en un vector de n valores
enteros positivos.

________________________________________________________________________________________
Respuestas Autoevaluación
R/=1. A. ososos
R/=2. C. 8
R/=3. C. for (i=0; i<10; i++)
R/=4. E. float promedio(int vec,int n);
R/=5. C. Lista o agrupación de datos del mismo tipo

D. Conjunto de datos homogéneos
R/=6. pos = (inicio + fin) / 2;
R/=7. D. 4,2,8,4,12
R/=8. B. El dato no fue localizado.
R/=9. A. void crear_vector(int vec[ ],int n){

B. for (int i=0; i<n; i++)
C. cin>>vec[ i ];
D. (no se retorna, los arreglos pasan por referencia)
}
R/=10.
17 9
C= 13 11
26 22
Solución Algoritmo:
Análisis:
Datos de Entrada (D.E):
num : Valor entero positivo

n : Tamaño del vector
Datos de Proceso (D.P):
cont = cont + 1 : Cuenta el valor más repetido

val : Valor más repetido
Datos de Salida (D.S):
vec[ ] : Vector sin el valor que más se repite

________________________________________________________________________________________
Otros datos:
j : Indice para recorrer el vector al momento de eliminar
aux : Variable auxiliar para intercambiar los valores
max : Máximo de veces que se repite el valor
sw : Suiche utilizado con la finalidad de que el programa
termine una vez se elimina el valor más repetido.
Algoritmo:
Inicio
Entero: vec[200],n,cont=1,val,i=1,num,j,aux,max=1,sw=1
Imprima: “Ingrese el tamaño del vector <2 a 200>:”
Lea n
\\Valida el tamaño que se va a llenar, no sobrepase la dimensión del vector (vec[200])
Mientras (n < 2 OR n > 200) haga
Imprima: “Ingrese el tamaño del vector <2 a 200>:”
Lea n
FinMQ
\\Valida que el número sea positivo
Mientras (i <= n) haga
Imprima: “Ingrese un número entero positivo en la posición:”, i
Lea num
Si (num >=0) entonces
vec[i] =num
i=i+1
FinSi
FinPara
Para (i=1, n-1, 1) haga
Para (j=i+1, n, 1) haga
Si (vec[i] > vec[j]) entonces
aux = vec[i]
vec[i] = vec[j]
vec[j] = aux
FinSi
FinPara
FinPara
\\Determina el valor que más se repite
Para (i=1, n-1 ,1) haga
cont = cont + 1
Sino
Si (cont > max) entonces
max = cont
val = vec[i]
FinSi
cont = 1
FinSi
FinPara
\\Elimina el valor que más se repite del vector
i=1, cont=0
Mientras (i < n AND sw=1) haga
Si (val = vec[i]) entonces
Para (j = i, n-1, 1) haga

________________________________________________________________________________________
vec[j] = vec[j+1]
FinPara
n = n -1
cont = cont + 1
Si (cont=max) entonces
sw=0
FinSi
Sino
i = i +1
FinSi
FinMQ
Para (i=1, n ,1) haga
Imprima: vec[i]
FinPara
Fin

________________________________________________________________________________________
Criterios De Evaluación
CUMPLIÓ
CRITERIOS OBSERVACIONES
SI NO
Criterios Generales:
1. ¿Comprende cuál es el objetivo que se debe

alcanzar según el problema planteado?
2. ¿Identifica y abstrae los datos del enunciado

del problema?
3. ¿Es organizado, metódico y sistémico para

organizar la información?
4. ¿Selecciona y decide las operaciones o

cálculos a efectuar?
5. ¿Descompone el problema en otros más

pequeños?
6. ¿Demuestra capacidad de análisis y síntesis

en la solución de problemas?
7. ¿Ejecuta en detalle cada operación o cálculo?
8. ¿Busca e identifica la mejor solución?
9 ¿Es capaz de elaborar el algoritmo?
10. ¿Comprueba los resultados esperados,

mediante pruebas de escritorio?
11. ¿Es capaz de depurar el algoritmo para que

sea funcional?
12. ¿Trabaja en equipo aportando ideas?
13.¿Participa activamente en clase?
14. ¿Demuestra capacidad de aprendizaje

autónomo?
15.¿Realiza las actividades propuestas por el

profesor a conciencia y con interés?
16.¿Asiste a las asesorías impartidas por el

profesor?

________________________________________________________________________________________
Criterios Específicos:
1. ¿Identifica y utiliza las estructuras de datos

más adecuadas dependiendo el problema a
resolver?
2. ¿Plantea soluciones por medio de la estructura

cilco PARA?
3. ¿Diseña algoritmos funcionales que requieran

el almacenamiento de datos en arreglos?
4. ¿Plantea soluciones por medio de

subprogramas a problemas algorítmicos que
requieran el almacenamiento de datos en
arreglos?
5. ¿Explica el concepto de paso de parámetros

por valor y por referencia?
6. ¿Emplea los métodos de búsqueda en la

solución de problemas algorítmicos?
7. ¿Resuelve problemas de algoritmos que

requieren la implementación de los métodos de
ordenación?
8. ¿Comprueba los resultados esperados

mediante pruebas de escritorio?
9. ¿Codifica los problemas algorítmicos en el

lenguaje seleccionado?
10. ¿Aplica el manejo de suiches o banderas

para resolver problemas de algoritmos?

________________________________________________________________________________________
Evidencia De Desempeño
La evaluación a realizar estará compuesta de:
1. Evaluación teórica tipo ECAES

El objetivo de éste tipo de evaluación, es analizar el nivel de comprensión que ha
alcanzado el estudiante dentro de una temática en particular.
2. Solución de problemas por medio de algoritmos y elaboración de prácticas de

laboratorio.
El objetivo principal es determinar la adquisición de competencias, en la solución de
problemas donde se desarrolle el análisis de un caso determinado, se diseñe el
algoritmo y se implemente mediante la codificación en el lenguaje seleccionado,
utilizando las técnicas y metodologías vistas en el curso.
3. El estudiante deberá entregar un trabajo, con la solución a cada problema que se

plantea en las actividades propuestas en el transcurso del capítulo.

________________________________________________________________________________________
Bibliografía
1. Fundamentos de programación. Joyanes, Luis.

2. Problemas de la metodología en la programación. Joyanes, Luis.
3. Algoritmos, conceptos básicos. Becerra, Cesar.
4. Metodología de la programación Algoritmos, diagramas de flujo y programas
Cairó, Osvaldo
5. Algoritmos. Peralta, Luis A.
6. Desarrollo de algoritmos y sus aplicaciones. Correa Guillermo.
7. Introducción a la ciencia de los computadores. Tremblay. J. P.
8. Lógica para programación de computadores. Vasquez, Gabriel.
9. Lógica de programación. Oviedo R, Efraín.
10. Diagramación y programación. Lozano. Letvin.
11. Soluciones secuenciales. Ríos C, Fabián.
12. Algoritmos 2. Gonzalez, Luis F., Monsalve, John J.

Arreglos PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arreglos PDF

Cargado por

Copyright:

Formatos disponibles

Técnico Profesional en Programación Desarrollo del Pensamiento Analítico y Sistémico I

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 1

Proveer las herramientas necesarias que le permitan al estudiante resolver exitosamente

1. Diferenciar el uso de estructuras cíclicas MIENTRAS vs PARA.

1. Lógico y analítico al diseñar soluciones de problemas.

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 2

1. Dividir en subprogramas o módulos la solución de problemas simples o complejos, con

El profesor desarrolla los algoritmos más representativos y busca aterrizar el

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 3

b. Trabajo Individual asesorado

Sugerencias para el Docente

1. Propiciar actividades dinámicas en clase:

Medios de Apoyo y Recursos a Utilizar

1. Salón de clase: (Tablero, Marcadores)

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 4

2. Clasificación de los arreglos

2.1 Arreglos unidimensionales o vectores

2.2 Arreglos bidimensionales o matrices

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 5

Un Arreglo es una agrupación, disposición o lista de elementos.

Los datos individuales de los arreglos se deminan elementos, estos se almacenan en

Antes de utilizar un arreglo en un programa, es necesario definir el tamaño y el tipo de

Ejemplo: Dimensión del arreglo

Entero: Edades[100] : Vector de Edades (enteras), con tamaño de 100 elementos

Los arreglos se clasifican en:

2.1 Arreglos unidimensionales o vectores

Un arreglo unidimensional es un vector o lista de elementos del mismo tipo, agrupados

Edades: 15,21,16,17,20,19,18 (lista de edades)

Este vector puede representarse gráficamente de la siguiente forma:

Elemento del arreglo

Para hacer referencia a un determinado elemento del arreglo se hace de la forma:

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 6

2.1.2 Sintaxis: para crear / imprimir un vector N elementos

Sintaxis: para crear un vector de N elementos enteros

Imprima: “Ingrese el tamaño del vector:”

Sintaxis: para imprimir un vector de N elementos enteros

Para (i=1, n, 1) Haga

2.1.3 Ejemplos con vectores

Creación de un vector de N elementos utilizando – CICLO MIENTRAS

Creación de un vector de N elementos utilizando – CICLO PARA

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 7

Creación de un vector de N elementos utilizando – CICLO REPITA HASTA_QUE

Diferencias entre el ciclo MIENTRAS y el CICLO PARA:

Diferencias entre el ciclo MIENTRAS y el REPETIR_HASTA:

- En el MIENTRAS para poder ingresar al ciclo se debe cumplir la condición, es decir,

- En el REPETIR_HASTA el programa siempre ingresa por lo menos una vez al ciclo

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 8

- En el REPETIR_HASTA el programa repite el ciclo siempre y cuando la condición sea

Sintaxis: para imprimir un vector de N elementos enteros (forma ascendente)

Para (i=1, n, 1) Haga

Sintaxis: para imprimir un vector de N elementos enteros (forma descendente)

Para (i=n, 1, -1) Haga

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 9

2.1.4 Operaciones con vectores

Un método de búsqueda consiste en localizar un determinado valor dentro los elementos

Existen diferentes métodos de búsqueda, dentro de los cuales están:

a.1 Búsqueda lineal o secuencial (el más común y fácil de implementar)

Veamos algunas de ellos:

a.1. Búsqueda lineal o secuencial:

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 10

- No requiere ordenar los elementos del arreglo

- Es un método muy lento de búsqueda