Você está na página 1de 52

Seamos realistas y hagamos lo

imposible. .

Ernesto Che Guevara

Arreglos
Objetivo
Familiarizar al alumno con el manejo de estructuras de datos
aplicando todas las sentencias antes aprendidas mediante el uso
de los arreglos de datos ya sea unidimensionales o
bidimensionales, además de observar diversos tipos de
operaciones que se pueden desarrollar sobre estos.

En esta unidad
Estructura de Datos.
Arreglos de Datos
Arreglos Unidimensionales.
Arreglos Bidimensionales.
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

1. Estructura de Datos
En las unidades anteriores se ha visto como se trata a los datos de manera simple es
decir aquellos datos cuyo valor son de tipo numérico, cadena o lógico. Todos estos
aplicados a variables simples que solamente podían almacenar un valor a la vez como
por ejemplo:
X : Entero CAD : Cadena
X = 10 CAD = “Hola José”
X = 40 CAD = “Nos vemos en la tarde”
X = - 21 CAD = “Verónica es aplicada”
En ninguno de los casos mostrados podíamos asignar a cualquier variable dos o mas
valores al mismo tiempo, es que nace entonces la necesidad de estudiar otro tipo de
datos que si permite ese tipo de manejo para los datos: “Los Datos Estructurados”.
Los datos estructurados se agrupan en dos bloques: Simples o Estáticos y Compuestos o
Dinámicos; estos permiten al almacenamiento de gran cantidad de datos dependiendo la
necesidad del usuario se hará uso de uno u otro.

Datos Estructurados

Simples o Estáticos Compuestos o


Dinámicos

Arreglos Listas
Unidimensionales Pilas
Bidimensionales Colas
Registros Listas Enlazadas
Conjuntos Árboles

Algunas de las características de ambos tipos de datos radica en que a los datos
simples o estáticos se les tiene que asignar el número de elementos que deberán admitir o
en todo caso esta predefinido, para acceder a los valores se hace a través de un índice
definido; mientras que los datos compuestos o estáticos no tiene límites, están limitados
únicamente por los recursos del computador en donde trabajen, para acceder a los valores
se hace a través de los denominados punteros.

Pag. 147
Fundamentos de programación

2. Arreglos de Datos
Son aquellas estructuras que permiten almacenar grandes cantidades de información
en una sola estructura, a la que se debe referenciar mediante un nombre e indicar el
índice para poder ya sea obtener, guardar, actualizar o eliminar un valor.
Estas estructuras poseen un conjunto finito de datos, son de tamaño fijo y ordenado de
elementos (valores) homogéneos.
Se dice:

a) Finito.- Por que posee un último elemento, es decir no puede expresarse como de
valores ilimitados.

b) Tamaño fijo.- Por que en tiempo de diseño se expresa el número de elementos


por el que estará compuesto, en algunos casos se puede volver a redimensionar en
arreglo.

c) Homogéneo.- Porque todos los elementos deben ser de un mismo tipo de dato.

Concepto general de arreglo


Un arreglo lineal es un conjunto finito de datos similares, que tienen el mismo nombre
de variable, para hacer referencia a ello se utiliza el nombre de variable seguido por su
índice.
El índice es un conjunto de n números consecutivos, normalmente 1,2,3, …,n.
Si al array se le nombra con la letra X, los elementos de X se puede denotar de tres
formas diferentes:
Por medio de la notación subindizada: X1, X2, X3, … , Xn
Utilizada generalmente en las ciencias matemáticas
A través de la notación patentizada: X(1), X(2), X(3), … , X(n)
O utilizando corchetes X[1], X[2], X[3], … , X[n]
Estas dos últimas se utilizan en ciencias de la computación.
Los arreglos en general se dividen en: Unidimensionales, Bidimensionales,
Tridimensionales

Arreglo estático unidimensional


Es un conjunto finito de elementos del mismo tipo, que tienen un mismo nombre de
variable. El nombre va acompañado de un índice que indica el número de orden del
elemento dentro del arreglo.

Pag. 148
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Si tenemos un arreglo con el nombre de variable X, de n elementos, que almacena


números, este arreglo se denota como sigue:
X(1), X(2), X(3), X(4) … X(n) que son las referencias a los elementos del arreglo.
Gráficamente se representa, como se muestra en la gráfica
Ejemplo Gráfico

X
1 12 Inicio del Vector
2 4
3 5
4 77 Vector X para
n valores
5 -8

n 15 Final del Vector

Índices del
vector X Valores
almacenados
en el vector X

Arreglo estático bidimensional


Es un conjunto finito de elementos del mismo tipo, que tienen un mismo nombre de
variable. El nombre va acompañado de dos índices que indica el número de orden del
elemento dentro del arreglo. Este arreglo se expande tanto en filas como en columnas.
Si tenemos un arreglo con el nombre de variable Y de 2 filas por 3 columnas de
elementos, que almacena nombres de personas, este arreglo se denota como sigue:
Y(1,1), Y(1,2), Y(1,3)
Y(2,1), Y(2,2), Y(2,3)
Que son las referencias a los elementos del arreglo
Gráficamente se representa, como se muestra en la gráfica

Referencia a los elementos del arreglo.


Los elementos de un arreglo bidimensional se referencian con un subíndice para la fila y
otra para la columna.

Pag. 149
Fundamentos de programación

Arreglo estático tridimensional


Es un conjunto finito de elementos del mismo tipo, que tienen un mismo nombre de
variable. El nombre va acompañado de tres índices que indica el número de orden del
elemento dentro del arreglo. Este arreglo se expande filas, columnas y fondo.
Si tenemos un arreglo con el nombre de variable Z de 2 filas , 3 columnas y 2 fondos de
elementos, que almacena nombres de personas, este arreglo se denota como sigue:
Z(1,1,1), Z(1,2,1), Z(1,3,1)
Z(2,1,2), Z(2,2,2), Z(2,3,2)
Que son las referencias a los elementos del arreglo
Gráficamente se representa, como se muestra en la gráfica

Los elementos de un arreglo tridimensional se referencian con un subíndice para la fila,


otra para la columna y una última para el fondo.

Representación de un arreglo unidimensional


Supongamos que tenemos un arreglo unidimensional al que se le ha denominado
“Deporte”, el cual tiene 5 elementos, y guarda datos de tipo texto. Este arreglo puede
dibujarse como se muestra en la gráfica.

Pag. 150
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Representación de los arreglos lineales en memoria


Siguiendo con el ejemplo anterior como se muestra un arreglo lineal almacenado en la
memoria del computador. La memoria de un computador consiste en una secuencia de
celdas direccionables. Si el siguiente cuadro fuera la memoria podemos observar que un
arreglo se almacena en direcciones consecutivas.

Arreglos Valor de la variable


Nombre de la variable
Del gráfico se observan:
Los arreglos: Deporte, Fruta y Pais.
Las variables: A, B, C, D, E.

Declaración de un arreglo unidimensional


La declaración de un arreglo permite definir la estructura que tendrá el arreglo, tipo de
arreglo, tipo de dato del arreglo y número de elementos del arreglo. Para indicar la
cantidad de elementos del arreglo usted puede especificar el límite inferior y superior.
Sintaxis:
Dim Nombre ( Dimensión) As TipoDeDato

Pag. 151
Fundamentos de programación

Donde
Nombre: Es el nombre del arreglo
Dimensión: Define el número de elementos del arreglo
TipodeDato: Define el tipo de dato: Integer, string, date, etc.

También puede declarar


Dim Nombre( Li to Ls) As TipoDeDato
Dónde:
Li. Es el límite inferior del arreglo
Ls. Es el límite superior del arreglo
Si no define el límite inferior del arreglo por defecto es cero.
Los nombres de arreglos deben ser diferentes de los nombres de variables.
Ejemplos.
Dim X (10) As Integer
Declara un arreglo de 11 elementos, denotados como:
X(0), X(1), X(2), … , X(10)
El tipo de dato para todos los elementos del arreglo es entero. Gráficamente se muestra
como sigue:

Dim Y(1 to 10) As Integer


Declara un arreglo de 10 elementos, denotados como:
Y(1), Y(2), Y(3), … , Y(10)
El tipo de dato para todos los elementos del arreglo es entero. Gráficamente se muestra
como sigue:

Dim Z(1 to 5) as string


Declara un arreglo de 5 elementos, denotados como:
Z(1), Z(2), Z(3),Z(4),Z(5)
El tipo de dato para todos los elementos del arreglo es cadena. Gráficamente se muestra
como sigue:

Dim A(4 to 8) as string

Pag. 152
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Declara un arreglo de 5 elementos, denotados como:


A(4), A(5), A(6),A(7),A(8)
El tipo de dato para todos los elementos del arreglo es cadena. Gráficamente se muestra
como sigue:

Operaciones sobre vectores


Sea el Vector:
X
1 2 3 4 5 6 7
14 4 1

a) Asignación. Consiste en guardar un dato a través de una operación.


Ejemplo:
X [4] = 66

X
1 2 3 4 5 6 7
14 4 1 66

b) Escritura. Consiste en guardar un dato a través de una operación de captura


de datos.
Ejemplo:
...
Capturar (X [5])
...
Se asumirá que el valor ingresado es 12
X
1 2 3 4 5 6 7
14 4 1 66 12

c) Lectura. Consiste en obtener los datos almacenados anteriormente en un


vector.
Ejemplo:
X
1 2 3 4 5 6 7
14 4 1 66 12

Pag. 153
Fundamentos de programación

...
W = X [2]
...
mostrar (W)
En la pantalla se observará el valor de W: 4
Que era el valor de X [2] en el vector respectivo.

Ejercicio de aplicación No. 1


Crear un algoritmo que permita el ingreso de 20 números a un arreglo X.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar 20 números a un arreglo.
ii. ¿Qué datos necesito conocer?
Los números que se almacenarán.

2. Planteamiento Lógico.
Este es un problema básico que solo mostrará como se desarrolla el ingreso de
datos a un vector.

3. Definición de variables de entrada.


No se requieren variables de ingreso, este es directo al vector.
4. Definición de variables de salida.
No existe variable de salida ya que se trata de un simple ingreso de datos a un
vector.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
i: entero
X: arreglo[1 ..20] – entero
Para i = 1 hasta 20
Escribir(„Ingrese el número a guardar en el vector:‟)
Capturar( X[i])
Fin_Para
FIN

Pag. 154
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2 Diagrama de Flujo

INICIO

Declaración de variables i: entero


X: arreglo[1 ..20] – entero

Para i=1
Hasta 20

X[i]

FIN

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form1
Dim X(0 To 19) As Integer
Dim i As Byte
Private Sub Button2_Click
Dim i As Integer
DataGridView1.RowCount = 1
DataGridView1.Item(0, 0).Value = "Indice"
DataGridView1.RowCount = DataGridView1.RowCount + 1
DataGridView1.Item(0, 1).Value = "Número"
For i = 1 To 19
X(i) = ListBox1.Items(i - 1)
DataGridView1.ColumnCount = DataGridView1.ColumnCount + 1
DataGridView1.Item(i, 0).Value = i

Pag. 155
Fundamentos de programación

DataGridView1.Item(i, 1).Value = X(i)


DataGridView1.Columns(i).Width = 30
Next i
End Sub
Private Sub Button1_Click
Dim i As Integer
ListBox1.Items.Clear()
For i = 1 To 20
ListBox1.Items.Add(Str(Math.Round(Rnd() * 100, 0)))
Next i
End Sub
Private Sub SAlir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub Nuevo_Click
ListBox1.Items.Clear()
DataGridView1.RowCount = 1
End Sub
End Class

Ejercicio de aplicación No. 2


Se van a ingresar dos notas de 100 alumnos, deberá hallar el promedio y almacenarlo en
un arreglo; una vez realizado ello, tendrá que recorrer el arreglo y determinar cuantos
alumnos aprobaron y cuantos desaprobaron. Diseñe el algoritmo.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Calcular el promedio de motas de 100 alumnos y almacenarlo en un vector, luego
contabilizar cuantos aprobaron y cuantos desaprobaron.
ii. ¿Qué datos necesito conocer?
Las notas de los alumnos.

2. Planteamiento Lógico.
El ingreso de las notas permitirá hallar el promedio el cual se almacenará en el
vector y finalmente se hará un recorrido al vector de modo que se pueda saber
cuantos alumnos aprobaron y cuantos desaprobaron.

Pag. 156
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

3. Definición de variables de entrada.


Se requerirá 2 variables para capturar las notas.
4. Definición de variables de salida.
Se usarán las variables de tipo contador AP y DS para los aprobados y desaprobados
respectivamente.
5. Diseño de la Solución.

5.1 Pseudocódigo
INICIO
Declaración de variables
N1, N2: entero
PR: real
X: arreglo[1 ..100] – real
Para i = 1 hasta 100
Escribir(„Ingrese la primera nota:‟)
Capturar( N1)
Escribir(„Ingrese la segunda nota:‟)
Capturar( N2)
PR = (N1 + N2)/2
X[i] = PR
Fin_Para
AP = 0
DS = 0
Para i = 1 hasta 100
Si (X[i] >= 10.5) entonces
AP = AP + 1
Sino
DS = DS + 1
Fin_Si
Fin_Para
Mostrar(„El número de aprobados fue:‟, AP)
Mostrar(„El número de desaprobados fue:‟, DS)
FIN

Pag. 157
Fundamentos de programación

5.2 Diagrama de Flujo

INICIO

Declaración de variables
i: entero
X: arreglo[1 ..20] – entero

Para i=1
Hasta 20

N1, N2

PR = (N1 + N2)/2
X[i] = PR

AP = 0
DS = 0

Para i=1
Hasta 20

X[i] >= 10.5

DS = DS + 1 AP = AP + 1

AP, DS

FIN

Pag. 158
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form2
Dim X(0 To 19) As Integer
Dim N1 As Byte
Dim N2 As Byte
Dim PR As Single
Dim AP As Integer
Dim DS As Integer
Private Sub cmdgenerar_Click
DataGridView1.RowCount = 2
For i = 0 To 19
N1 = Rnd() * 20
N2 = Rnd() * 20
PR = Format((N1 + N2) / 2, 0.0#)
DataGridView1.Item(0, i).Value = N1
DataGridView1.Item(1, i).Value = N2
DataGridView1.Item(2, i).Value = PR
X(i) = PR
DataGridView1.RowCount = DataGridView1.RowCount + 1
Next i
End Sub
Private Sub cmdprocesar_Click
AP = 0
DS = 0
For i = 0 To 19
If (X(i) > 10) Then
AP = AP + 1
Else
DS = DS + 1
End If
Next i
TextBox1.Text = AP
TextBox2.Text = DS
End Sub
Private Sub cmdsalir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If

Pag. 159
Fundamentos de programación

End Sub
Private Sub cmdNuevo_Click
DataGridView1.RowCount = 1
TextBox1.Text = 0
TextBox2.Text = 0
End Sub
End Class

Ejercicio de aplicación No. 3


Realizar un algoritmo que permita el ingreso de N números a un arreglo unidimensional,
calcular e imprimir el promedio de todos los números que se ingresarán al vector, tenga en
cuenta que solo se guardarán aquellos números que estén entre 10 y 80.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar números a un arreglo, los cuales deben estar en el rango de 10 a 80.
ii. ¿Qué datos necesito conocer?
La cantidad de números a ingresar y después los números que se ingresarán al
vector.

2. Planteamiento Lógico.
Inicialmente se debe recordar que los vectores deben estar definidos en un número
exacto de elementos que se almacenarán en este caso dice el problema que el número de
elementos a ingresar no se sabe así que habrá que definir un rango máximo para poder
empezar a trabajar después se deberá validar ese caso.
Ejemplo:
X: arreglo[1 ..1000] – entero
Se ha definido un arreglo de 1000 espacios, por lo tanto al momento de especificar el
número de elementos a ingresar no podrá sobrepasar los 1000 números (validar).
Luego se deberán ingresar los números que se almacenarán en el vector, tenga en cuenta
que solo se graban en el vector aquellos números que estén en el rango de 10 a 80 al
mismo tiempo se deberán ir acumulando para finalmente hallar el promedio de estos
números almacenados en el vector.

3. Definición de variables de entrada.


Se deberá saber el número de elementos a leer (N), y los números (NUM) que se
pretenden almacenar en el vector.

Pag. 160
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

4. Definición de variables de salida.


La variable en donde se observará el promedio de los números que cumplieron con la
condición será: PR.
5. Diseño de la Solución. INICIO
5.1 Pseudocódigo
Declaración de variables
AC, C, i, N, NUM: entero
INICIO PR: real
Declaración de variables X: arreglo[1 ..500] – entero
AC, C, i, N, NUM: entero
PR: real
X: arreglo[1 ..500] – entero
Hacer N
Escribir(„Ingrese el número de
elementos a evaluar:‟)
Capturar(N) N<=500
Hasta que (N <= 500)
AC = 0
C=0 AC = 0
Para i = 1 hasta N C=0
Escribir(„Ingrese número a
evaluar:‟)
Capturar( NUM) Para i=1
Hasta N
Si (NUM>=10 and NUM<=80)
entonces
C=C+1
X[C] = NUM NUM
AC = AC + X[C]
Fin_Si
Fin_Para NUM>=10 and
NUM<=80
PR = AC / C
Mostrar(„El promedio de los números
almacenados en el vector es:‟, PR) C=C +1
FIN X[C] = NUM
AC = AC + X[C]

5.2 Diagrama de Flujo

PR=AC/C

PR

FIN

Pag. 161
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form1
Dim X(0 To 500) As Integer
Dim C As Byte
Dim i As Byte
Dim AC As Integer
Dim PR As Single
Private Sub cmdgenerar_Click
Dim i As Integer
ListBox1.Items.Clear()
For i = 1 To Val(TextBox1.Text)
ListBox1.Items.Add(Str(Format(Rnd() * 200, 0)))
Next i
End Sub
Private Sub cmdcarga_Click
ListBox2.Items.Clear()
AC = 0
C = 0
For i = 1 To Val(TextBox1.Text)
If (Val(ListBox1.Items(i - 1)) >= 10 And Val(ListBox1.Items(i - 1)) <= 80) Then
C = C +1
X(C) = ListBox1.Items(i - 1)
AC = AC + X(C)
ListBox2.Items.Add(Str(X(C)))
End If
Next i
If (C <> 0) Then
PR = AC / C
Else
MsgBox("El vector no tiene datos")
End If
TextBox2.Text = PR
End Sub
Private Sub TextBox1_KeyPress
TextBox1.KeyPress
If e.KeyChar.ToString = 13 Then
cmdgenerar.Focus()

Pag. 162
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

End If
End Sub
Private Sub TextBox1_LostFocus
If (Val(TextBox1.Text) < 1 Or Val(TextBox1.Text) > 500) Then
MsgBox("error de ingreso")
TextBox1.Text = 1
TextBox1.Focus()
End If
End Sub
Private Sub Button1_Click ListBox1.Items.Clear()
ListBox2.Items.Clear()
TextBox1.Text = 0
TextBox2.Text = 0
End Sub
Private Sub Button2_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
End Class

Ejercicio de aplicación No. 4


Desarrolle un algoritmo que permita ingresar 50 números a un arreglo X y 50 números a
otro arreglo Y, una vez cargados los dos vectores, deberá hallar cual fue el mayor
número almacenado en el arreglo X y cual fue el menor número almacenado en el
arreglo Y; finalmente sumarlos y mostrarlos.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Hallar el mayor y menor numero ingresado en dos vectores X y Y, luego sumarlos
y mostrarlos.
ii. ¿Qué datos necesito conocer?
Los 50 números que se ingresarán en X y Y.

2. Planteamiento Lógico.
Deberá cargar los vectores X y Y con 50 números cada uno, luego desarrollar el
código que permita obtener el mayor y menor número de los vectores para
finalmente sumarlos y mostrarlos.

3. Definición de variables de entrada.


La captura de los números será de manera directa a los vectores respectivos.
4. Definición de variables de salida.
En la variable S se guardará la suma del mayor (MY) y menor(MN) número de los
vectores respectivos.

Pag. 163
Fundamentos de programación

5. Diseño de la Solución. INICIO


5.1Pseudocódigo
INICIO MY, MN, i, S: entero
Declaración de variables X: arreglo[1 ..50] – entero
Y: arreglo[1 ..50] – entero
MY, MN, i, S: entero
X: arreglo[1 ..50] – entero
Y: arreglo[1 ..50] – entero Para i=1
Para i = 1 hasta 50 Hasta 50
Escribir(„Ingrese número para el vector
X:‟)
Capturar(X[i])
Escribir(„Ingrese número para el vector
Y:‟) X[i], Y[i]
Capturar(Y[i])
Fin_Para
MY = X[1]
MN = Y[1]
Para i = 2 hasta 50 MY = X[1]
Si (MY < X[i]) entonces MN = Y[1]
MY = X[i]
Fin_Si Para i=2
Si (MN > Y[i]) entonces Hasta 50
MN = Y[i]
Fin_Si
Fin_Para
S = MY + MN MY < X[i]
Mostrar(„La suma del mayor y menor
elemento es:‟, S)
FIN MY = X[i]

MN > Y[i]

MN = Y[i]

S = MY + MN

AP, DS

FIN

Pag. 164
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2Diseño del Formulario

5.3Codificación del Programa


Public Class Form1
Dim X(0 To 49) As Integer
Dim Y(0 To 49) As Integer
Dim i As Byte
Dim Mayor As Integer
Dim MN As Integer
Dim S As Integer
Private Sub cmdcargar_Click
Randomize()
Dim i As Integer
DataGridView1.Item(0, 0).Value = "X(i)"
DataGridView1.Item(0, 1).Value = "Y(i)"
For i = 1 To 49
DataGridView1.Item(i, 0).Value = Format(Rnd() * 100, 0)
DataGridView1.Item(i, 1).Value = Format(Rnd() * 100, 0)
X(i) = DataGridView1.Item(i, 0).Value
Y(i) = DataGridView1.Item(i, 1).Value
Next i
End Sub
Private Sub cmdprocesar_Click
Dim i As Integer
Mayor = X(1)
MN = Y(1)
For i = 1 To 49
If (Mayor < X(i)) Then
Mayor = X(i)
End If
If (MN > Y(i)) Then
MN = Y(i)
End If
Next i
TextBox1.Text = Mayor
TextBox2.Text = MN
S = Mayor + MN
TextBox3.Text = S
End Sub

Pag. 165
Fundamentos de programación

Private Sub Button4_Click


If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub Button3_Click Dim i As Integer
For i = 1 To 49
DataGridView1.Item(i, 0).Value = ""
DataGridView1.Item(i, 1).Value = ""
Next i
TextBox1.Text = 0
TextBox2.Text = 0
TextBox3.Text = 0
End Sub
Private Sub Form1_Load
DataGridView1.RowCount = 3
DataGridView1.ColumnCount = 50
End Sub
End Class

Métodos de Ordenamiento
Los métodos de ordenamiento tienen por finalidad mostrar a los elementos de un vector
ordenados ya sea en forma ascendente o descendente. Para lograr ello se cuentan con
diversos métodos entre los mas conocidos encontramos:

1) Método de la Inserción (Burbuja)


Este método consiste en ir preguntando empezando desde el primer elemento del
vector con el resto de elementos hasta llegar al final, si la pregunta (ya sea si es
mayor o no) es afirmativa se deberá de intercambiar los elementos evaluados en las
posiciones respectivas, sin alterar el resto de elementos; tenga en cuenta que las
preguntas se realizan desde el inicio hasta el final con los elementos que quedan.
Gráficamente se observaría de la siguiente manera:
X
1 2 3 4 5
14 4 1 66 5
X[1]>X[2] si es mayor, intercambio
X
1 2 3 4 5
4 14 1 66 5
X[1]>X[3] si es mayor, intercambio
X
1 2 3 4 5
1 14 4 66 5

Pag. 166
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

X[1]>X[4] no es mayor
X[1]>X[5] no es mayor
X
1 2 3 4 5
1 14 4 66 5
X[2]>X[3] si es mayor, intercambio
X
1 2 3 4 5
1 4 14 66 5
X[2]>X[4] no es mayor
X[2]>X[5] no es mayor
X
1 2 3 4 5
1 4 14 66 5
X[3]>X[4] no es mayor
X[3]>X[5] si es mayor, intercambio
X
1 2 3 4 5
1 4 5 66 14
X[4]>X[5] si es mayor, intercambio
X
1 2 3 4 5
1 4 5 14 66
Por lo tanto el vector quedaría de la siguiente manera: (ordenado de forma
ascendente).
X
1 2 3 4 5
1 4 5 14 66
El Pseudocódigo asociado a este método de ordenamiento es:
Para i = 1 hasta 4
Para j = i + 1 hasta 5
Si (X[i] > X[j]) entonces
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para

Pag. 167
Fundamentos de programación

En general:

Para i = 1 hasta n – 1
Para j = i + 1 hasta n
Si (X[i] > X[j]) entonces
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para

Si desea ordenar en forma descendente se deberían cambiar el operador de relación


de la pregunta SI, es decir “>” por “<”.

2) Método de Shell
Consiste en ir comparando los elementos no contiguos sino por saltos de mayor
tamaño y de esa manera se consigue un ordenamiento mas rápido, para ello se debe
fijar el tamaño de los saltos constantes que deberán de ser de mas de una posición.
Es denominado también de ordenamiento por disminución incremental, fue
nombrado así debido a su inventor Donald Shell.
Ordena subgrupos de elementos separados K unidades (respecto de su posición en
el arreglo) del arreglo original. El valor K es llamado incremento.
Después de que los primeros K subgrupos han sido ordenados (generalmente
utilizando INSERCION DIRECTA), se escoge un nuevo valor de K más pequeño,
y el arreglo es de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de
los subgrupos mayores es ordenado y el proceso se repite de nuevo con un valor
más pequeño de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste
de todo el arreglo ya casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el
último valor debe ser 1.
"Es como hacer un ordenamiento de burbuja pero comparando e intercambiando
elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte
del subgrupo y se aplica inserción directa.
El método se basa en tomar como salto N/2 (siendo N el número de elementos) y
luego se va reduciendo a la mitad en cada repetición hasta que el salto o distancia
vale 1.
El Pseudocódigo asociado a este método de ordenamiento es:

Pag. 168
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Algoritmo Shell Sort


INICIO
Declaración de variables
A : arreglo[1..100] – entero
Inter, N, i, Temp, SW: entero
Escribir(„Ingrese número de elementos de la matriz:‟)
Capturar(N)
Inter = N + 1
Hacer
Inter = Inter Div 2
Hacer
SW = 0
i =1
Hacer
Si (A[i] < A[i + Inter]) entonces
Temp = A[i]
A[i] = A[i + Inter]
A[i + Inter] = Temp
SW = 1
Fin_Si
i =i +1
Hasta que (i + Inter = N + 1)
Hasta que (SW = 0)
Hasta que (Inter = 1)
FIN

Ejercicio de aplicación No. 5


Desarrolle un algoritmo que permita ingresar 100 números, en un arreglo X se deberán
ir almacenando aquellos que son múltiplos de 3; finalmente ordenar el arreglo.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar 100 números de los cuales solo los que son múltiplos de 3 se guardan en
un arreglo X, para finalmente ordenarlos.
ii. ¿Qué datos necesito conocer?
Conocer cuales los 100 números.

Pag. 169
Fundamentos de programación

2. Planteamiento Lógico.
Se deberá cargar los números en el arreglo, teniendo en cuenta que solo
ingresan los que son múltiplos de 3 (resto de la división 0), finalmente se
deberá ordenarlos.

3. Definición de variables de entrada.


El ingreso será directamente en el vector X.
4. Definición de variables de salida.
No existen variables de salida, ya que el tratamiento de los datos es directo en
el vector.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
N, i, j, C, AUX: entero
X: arreglo[1 ..100] – entero
C=0
Para i = 1 hasta 100
Escribir(„Ingrese número:‟)
Capturar(N)
Si (N mod 3) = 0 then
C=C+1
X [C] = N
Fin_Si
Fin_Para
Para i = 1 hasta C – 1
Para j = i + 1 hasta C
Si (X[i] > X[j]) entonces
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para
FIN

Pag. 170
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2 Diagrama de Flujo

INICIO

N, i, j, C, AUX: entero
X: arreglo[1 ..100] – entero

C=0

Para i=1
Hasta 100

N mod 3 = 0

C=C +1
X [C] = N

Para i=1
Hasta C-1

Para j=i+1
Hasta C

X[i] > X[j]

AUX = X[j]
X[j] = X[i]
X[i] = AUX

FIN

Pag. 171
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form1
Dim X(0 To 99) As Integer
Dim AUX As Integer
Dim C As Byte
Dim i As Byte
Dim j As Byte

Private Sub Button1_Click


Dim i As Integer
ListBox1.Items.Clear()
For i = 1 To 100
ListBox1.Items.Add(Format(Rnd() * 100, 0))
Next i
End Sub
Private Sub cmdsalir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub cmdnuevo_Click
ListBox1.Items.Clear()
ListBox2.Items.Clear()
ListBox3.Items.Clear()
End Sub
Private Sub Button3_Click
Dim i, j As Integer
ListBox3.Items.Clear()
For i = 1 To C - 1
For j = i + 1 To C
If (X(i) > X(j)) Then
AUX = X(j)
X(j) = X(i)
X(i) = AUX
End If
Next j
Next i
For i = 1 To C
ListBox3.Items.Add(X(i))

Pag. 172
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Next i
End Sub
Private Sub Button2_Click
Dim i As Integer
ListBox2.Items.Clear()
C = 0
For i = 1 To 99
If ListBox1.Items(i - 1) Mod 3 = 0 Then
C = C + 1
X(C) = ListBox1.Items(i - 1)
ListBox2.Items.Add(X(C))
End If
Next i
End Sub
End Class

Ejercicio de aplicación No. 6


Diseñe un algoritmo que permita ingresar 40 números a cada uno de los arreglos X y Y,
luego en un tercer arreglo se deberá cargar la suma solamente de aquellos números que
sean múltiplos de 2 teniendo en cuenta que estos deberán estar en las mismas posiciones
(índices). Adicionalmente ordenar el vector creado.
Ej:
X
1 2 3 ... 40
1 4 5 66
Y
1 2 3 ... 40
4 2 2 6
Z
1 2
6 72

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar números a 2 arreglos, luego se deberán analizar para finalmente crear
un tercer arreglo en base a los anteriores.
ii. ¿Qué datos necesito conocer?
Cargar los 2 arreglos a analizar con 40 números cada uno.

Pag. 173
Fundamentos de programación

2. Planteamiento Lógico.
Para poder cargar el tercer arreglo se deberá observar si los números que se
encuentran en las mismas posiciones de cada arreglo son pares, solo en ese caso se
suman y se guarda el resultado en el tercer arreglo (ver ejemplo).

3. Definición de variables de entrada.


El ingreso será directamente a los vectores X y Y.
4. Definición de variables de salida.
No existen variables de salida, ya que el tratamiento de los datos será directamente al
tercer vector.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
N, i, j, C, AUX: entero
X: arreglo[1 ..40] – entero
Y: arreglo[1 ..40] – entero
Z: arreglo[1 ..40] – entero
Para i = 1 hasta 40
Escribir(„Ingrese número para el vector X:‟)
Capturar(X[i])
Escribir(„Ingrese número para el vector Y:‟)
Capturar(Y[i])
Fin_Para
C=0
Para i = 1 hasta 40
Si (X[i] mod 2 = 0) and (Y[i] mod 2 = 0) entonces
C= C + 1
Z[C] = X[i] + Y[i]
Fin_Si
Fin_Para
Para i = 1 hasta C – 1
Para j = i + 1 hasta C
Si (Z[i] > Z[j]) entonces
AUX = Z[j]
Z[j] = Z[i]
Z[i] = AUX
Fin_Si
Fin_Para
Fin_Para
FIN

Pag. 174
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

INICIO
5.2 Diagrama de Flujo
N, i, j, C, AUX: entero
X: arreglo[1 ..40] – entero
Y: arreglo[1 ..40] – entero
Z: arreglo[1 ..40] – entero

Para i=1
Hasta 40

X[i], Y[i]

C=0

Para i=1
Hasta 40

X[i] mod 2 = 0 and


Y[i] mod 2 = 0

C=C +1
Z[C] = X[i] + Y[j]

Para i=1
Hasta C-1

Para j=i+1
Hasta C

Z[i] > Z[j]

AUX = Z[j]
Z[j] = Z[i]
Z[i] = AUX

FIN

Pag. 175
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form2
Dim X(0 To 39) As Integer
Dim Y(0 To 39) As Integer
Dim Z(0 To 39) As Integer
Dim AUX As Integer
Dim i As Byte
Dim j As Byte
Dim C As Byte
Private Sub cmdvectorxy_Click
Dim i As Integer
For i = 0 To 39
DataGridView1.Item(i, 0).Value = Format(Rnd() * 100, 0)
DataGridView1.Item(i, 1).Value = Format(Rnd() * 100, 0)
X(i) = DataGridView1.Item(i, 0).Value
Y(i) = DataGridView1.Item(i, 1).Value
Next i
End Sub
Private Sub Form2_Load
Dim i As Integer
DataGridView1.ColumnCount = 40
DataGridView1.RowCount = 3
DataGridView2.ColumnCount = 40
DataGridView2.RowCount = 2
DataGridView3.ColumnCount = 40
DataGridView3.RowCount = 2
For i = 0 To 39
DataGridView1.Columns(i).Width = 30
DataGridView2.Columns(i).Width = 30

Pag. 176
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

DataGridView3.Columns(i).Width = 30
Next i
End Sub
Private Sub cmdnuevo_Click
DataGridView1.Rows.Clear()
DataGridView2.Rows.Clear()
DataGridView3.Rows.Clear()
DataGridView1.RowCount = 3
End Sub
Private Sub cmdvectorz_Click
Dim i As Integer
'DataGridView2.Item(0, 0).Value = "Z(i)"
C = 0
For i = 0 To 39
If (X(i) Mod 2 = 0) And (Y(i) Mod 2 = 0) Then
C = C+ 1
Z(C) = X(i) + Y(i)
DataGridView2.Item(C, 0).Value = Z(C)
End If
Next i
End Sub
Private Sub cmdsalir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub cmdordenar_Click
Dim i, j As Integer
If (C > 0) Then
For i = 1 To C - 1
For j = i + 1 To C
If (Z(i) > Z(j)) Then
AUX = Z(j)
Z(j) = Z(i)
Z(i) = AUX
End If
Next j
Next i
For i = 1 To C
DataGridView3.Item(i, 0).Value = Z(i)
Next i
Else
MsgBox("No tiene datos el vector Z")
End If
End Sub
End Class

Pag. 177
Fundamentos de programación

II. Arreglos Bidimensionales


Denominado también matriz bidimencional, este tipo de arreglos es utilizado
para poder almacenar datos como si se tratase de tablas, es decir su puede almacenar
grandes volúmenes de datos con la sola definición de una matriz de este tipo.
Si tenemos un arreglo con el nombre de variable X de 2 filas por 3 columnas de
elementos, que almacena nombres de personas, este arreglo se denota como sigue:
X(1,1), X(1,2), X(1,3)
X(2,1), X(2,2), X(2,3)

Simbología
X [ i, j ]
Donde:
- X : Nombre del vector.
- i : Índice del vector para las filas.
- j : Índice del vector para las columnas.

Ejemplo Gráfico
Columnas

X 1 2 3 4 ... n-1 n
1 3 56 -14 2 1 12
2 5 -8 0 9 22 7 Índices de
3 Columna
7 3 22 3 8 -7
Filas 4 6 21 0 65 19 2
5 15 12 14 42 20 13
...
n-1 4 11 72 4 1 22
n 6 12 86 62 3 54

Índices de
Fila

Pag. 178
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Operaciones sobre matrices bidimencionales


Sea la matriz:
X
1 2 3 4
1 3 56 -14 2
2 5 -8 0 9
3 7 3 22 3
4 6 21 0 65
5 15 12 14 42

a) Recorrido por Filas. Consiste en trabajar con los valores de la primera fila y así
sucesivamente con el resto de filas hasta llegar al final.
Ejemplo:
Para f = 1 hasta 5
Para c = 1 hasta 4
Mostrar(„Los valores por filas :‟, X[f,c]
Fin_Para
Fin_Para
b) Recorrido por Columnas. Consiste en trabajar con los valores de la primera
columna y así sucesivamente con el resto de columnas hasta llegar al final.
Ejemplo:
Para c = 1 hasta 4
Para f = 1 hasta 5
Mostrar(„Los valores por columnas :‟, X[f,c]
Fin_Para
Fin_Para

Ejercicio de aplicación No. 1


Crear un algoritmo que permita el ingreso de números a un arreglo de 10 filas por 20
columnas.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar números a una matriz de 10*20.
ii. ¿Qué datos necesito conocer?
Los números que se desean ingresar.

Pag. 179
Fundamentos de programación

2. Planteamiento Lógico.
Este es un problema básico que solo mostrará como se desarrolla el ingreso de datos
a la matriz.

3. Definición de variables de entrada.


No se requiere de una variable el ingreso es directo a matriz.
4. Definición de variables de salida.
No existe variable de salida ya que se trata de un simple ingreso de datos a una
matriz.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
f, c: entero
X: arreglo[1 ..10, 1 .. 20] – entero
Para f = 1 hasta 10
Para c = 1 hasta 20
Escribir(„Ingrese el número a guardar en la matriz:‟)
Capturar( X[f,c])
Fin_Para
Fin_Para
FIN

5.2 Diagrama de Flujo


INICIO

Declaración de variables
F, c : entero
X: arreglo[1 ..10,1 ..20] – entero

Para f=1
Hasta 10

Para c=1
Hasta 20

X[f,c]

FIN

Pag. 180
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form3
Dim X(0 To 9, 0 To 19) As Integer
Dim f As Byte
Dim c As Byte
Private Sub cmdcargar_Click
Dim c, f As Integer
For c = 1 To 19
For f = 1 To 9
DataGridView1.Item(c - 1, f - 1).Value = Format(Rnd() * 100, 0)
Next
Next
End Sub
Private Sub Form3_Load Dim i As Integer
DataGridView1.RowCount = 10
DataGridView1.ColumnCount = 20
For i = 0 To 19
DataGridView1.Columns(i).Width = 25
Next i
End Sub
Private Sub cmdsalir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub cmdnuevo_Click
DataGridView1.Rows.Clear()
DataGridView1.RowCount = 11
End Sub
End Class

Pag. 181
Fundamentos de programación

Ejercicio de aplicación No. 2


Desarrolle un algoritmo que permita ingresar: tres notas(nota de practica, nota de
trabajo y examen parcial) de 100 alumnos a una matriz bidimencional, en la misma se
deberá ir calculando el promedio y a medida que se va operando se deberá mostrar un
mensaje: aprobado o desaprobado.
Ej: 13, 15, 14.................... 14.......... “Aprobado”

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar notas a una matriz y luego calcular el promedio además mostrar una
observación.
ii. ¿Qué datos necesito conocer?
Las notas que se pretenden evaluar.

2. Planteamiento Lógico.
El ingreso será de manera directa a la matriz, luego se deberá ir calculando el
promedio para ser almacenado de manera instantánea para finalmente mostrar
el mensaje dependiendo del promedio obtenido.
La matriz esta compuesta por 4 columnas: 3 para las notas 1 para el promedio
y 100 filas para el ingreso de los datos anteriores.

3. Definición de variables de entrada.


No se requiere de una variable, el ingreso es directo a matriz.
4. Definición de variables de salida.
No existe variable de salida ya que se trata de un simple ingreso de datos a
una matriz.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
f: entero
X: arreglo[1 ..100, 1 .. 4] – entero
Para f = 1 hasta 100
Escribir(„Ingrese la nota de practica:‟)
Capturar( X[f,1])
Escribir(„Ingrese la nota de trabajo:‟)
Capturar( X[f,2])
Escribir(„Ingrese la nota de examen:‟)
Capturar( X[f,3])
X[f,4] = (X[f,1] + X[f,2] + X[f,3]) / 3
Si (X[f,4] >= 11) entonces

Pag. 182
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Mostrar(„Aprobado‟)
Sino
Mostrar(„Desaprobado‟)
Fin_Si
Fin_Para
FIN

5.2 Diagrama de Flujo


INICIO

Declaración de variables
F, c : entero
X: arreglo[1 ..100,1 ..4] – entero

Para f=1
Hasta 100

X[f,1], X[f,2], X[f,3]

X[f,4] = (X[f,1] + X[f,2] + X[f,3]) / 3

X[f,4] >= 11

„Desaprobado‟ „Aprobado‟

FIN

5.3 Diseño del Formulario

Pag. 183
Fundamentos de programación

5.4 Codificación del Programa


Public Class Form4
Dim X(0 To 99, 0 To 3) As Integer
Dim f As Byte
Dim c As Byte
Private Sub cmdcargar_Click
Dim f, c As Integer
For f = 0 To 99
DataGridView1.RowCount = DataGridView1.RowCount + 1
For c = 1 To 3
DataGridView1.Item(c - 1, f).Value = Format(Rnd() * 20, 0)
X(f, c) = DataGridView1.Item(c - 1, f).Value
Next c
Next f
End Sub
Private Sub cmdcalcular_Click
For f = 0 To 99
DataGridView1.Item(3, f).Value = Format((X(f, 1) + X(f, 2) + X(f, 3)) / 3, 0)
If Val(DataGridView1.Item(3, f).Value) >= 11 Then
DataGridView1.Item(4, f).Value = "Aprobado"
Else
DataGridView1.Item(4, f).Value = "Desaprobado"
End If
Next f
End Sub
Private Sub cmdnuevo_Click
DataGridView1.Rows.Clear()
End Sub
Private Sub cmdsalir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub Form4_Load
DataGridView1.RowCount = 1
DataGridView1.ColumnCount = 5
DataGridView1.Columns(0).HeaderText = "Práctica"
DataGridView1.Columns(1).HeaderText = "Trabajo"
DataGridView1.Columns(2).HeaderText = "Examen"
DataGridView1.Columns(3).HeaderText = "Promedio"
DataGridView1.Columns(4).HeaderText = "Estado"
For i = 0 To 3
DataGridView1.Columns(i).Width = 55
DataGridView1.Columns(i).DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
Next i
DataGridView1.Columns(4).DefaultCellStyle.BackColor = Color.Salmon
DataGridView1.Columns(3).DefaultCellStyle.BackColor = Color.AliceBlue
End Sub
End Class

Pag. 184
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Ejercicio de aplicación No. 3


Diseñar un algoritmo que permita el ingreso de números a una matriz cuadrada de 100
por 100, luego la suma de los elementos que se encuentran en las diagonales principal y
secundaria se deberá almacenar en un vector Y, tenga en cuenta que solamente se
podrán registrar aquellas sumas que sobrepasen el valor de 10.
Debe validar el ingreso de los números a la matriz, estos deberán ser positivos.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
La suma de los valores que se encuentren en las diagonales principal y
secundaria de una matriz cuadrada, dicha suma se debe almacenar en un vector
siempre en cuando este valor sobrepase de 10.
ii. ¿Qué datos necesito conocer?
Los números respectivos en la matriz cuadrada.

2. Planteamiento Lógico.
Se deberá inicialmente validar el ingreso de los números a la matriz ya que tienen
que ser positivos.
Para poder obtener los números de la diagonal principal y secundaria solamente
debe tener cuidado con los índices de fila – columna.
Una vez que se sabe cuales son ahora deberá sumarlos, pero tenga en cuenta que
antes de registrarlos en el vector deberá verificar que este valor sobre pase 10, solo
en ese caso se registrará en el vector.

3. Definición de variables de entrada.


No se requiere de una variable, el ingreso es directo a matriz.
4. Definición de variables de salida.
No existe variable de salida ya que se trata de un simple ingreso de datos a una
matriz.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
f, c, R: entero
X: arreglo[1 ..100, 1 .. 100] – entero
Y: arreglo[1 ..100] – entero

Pag. 185
Fundamentos de programación

Para f = 1 hasta 100


Para c = 1 hasta 100
Hacer
Escribir(„Ingrese el número:‟)
Capturar(X[f,c])
Hasta que (X[f,c] > 0)
Fin_Para
Fin_Para
R=0
Para f = 1 hasta 100
Para c = 1 hasta 100
Si (f = c) entonces
Si ((X[f,c] + X[f,101-f]) >10) entonces
R=R+1
Y[R] = X[f,c] + X[f,101-f]
Fin_Si
Fin_Si
Fin_Para
Fin_Para
Para f = 1 hasta R
Mostrar(„numero del vector:‟, Y[f])
Fin_Para
FIN

Pag. 186
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2 Diagrama de Flujo

INICIO

f, c, R: entero
X: arreglo[1..100,1..100] – entero
Y: arreglo[1 ..100] – entero

Para f=1
Hasta 100

Para c=1
Hasta 100

X[f,c]

X[f,c] > 0

R=0

Para f=1
Hasta 100

Para c=1
Hasta 100
(X[f,c]+X[f,101-f]) >10

f =c

R=R +1
Y[R] = X[f,c] + X[f,101-f]

Para f=1
Hasta R

Y[f]

FIN

Pag. 187
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form1
Dim X(0 To 99, 0 To 99) As Integer
Dim Y(0 To 99) As Integer
Dim f As Byte
Dim c As Byte
Dim R As Byte
Private Sub cmdcargar_Click
Dim c, f As Integer
For f = 1 To 99
For c = 1 To 99
DataGridView1.Item(c - 1, f - 1).Value = Format(Rnd() * 100, 0)
X(f, c) = DataGridView1.Item(c - 1, f - 1).Value
Next c
Next f
End Sub
Private Sub cmdnuevo_Click
DataGridView1.RowCount = 1
DataGridView1.RowCount = 100
ListBox1.Items.Clear()
End Sub
Private Sub cmdcalcular_Click
Dim c, f As Integer
ListBox1.Items.Clear()
R=0
For f = 1 To 99
For c = 1 To 99
If (f = c) Then
If ((X(f, c) + X(f, 100 - f)) > 10) Then
R=R+1
Y(R) = X(f, c) + X(f, 100 - f)
End If
End If
Next c
Next f
For i = 1 To R
ListBox1.Items.Add(Y(i))
Next i
End Sub
Private Sub cmdsalir_Click

Pag. 188
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then


End
End If
End Sub
Private Sub Form1_Load
DataGridView1.RowCount = 100
DataGridView1.ColumnCount = 100
For i = 0 To 99
DataGridView1.Columns(i).Width = 25
DataGridView1.Columns(i).DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
Next i
End Sub
End Class

Ejercicio de aplicación No. 4


En una matriz bidimensional de 20 por 30, se ingresarán letras, luego muestre cuantas
veces se repitió la letra “A”, la letra “V” y la letra “E”.

Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar letras a una matriz y luego averiguar cuantas de las letras ingresadas
fueron A, V y E.
ii. ¿Qué datos necesito conocer?
Las letras que se ingresarán en la matriz cuadrada.

2. Planteamiento Lógico.
Se debe ingresar las letras en la matriz, luego ir preguntando si cumple con la
condición es decir si es A, V o E, de modo que se puedan ir contando para mostrar al
final cuantos eran.

3. Definición de variables de entrada.


No se requiere de una variable, el ingreso es directo a matriz.
4. Definición de variables de salida.
Las variable de salida serán 3 contadores: C1, C2 y C3.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables

Pag. 189
Fundamentos de programación

f, c, C1, C2, C3: entero


X: arreglo[1 ..20, 1 .. 30] – caracter
Para f = 1 hasta 20
Para c = 1 hasta 30
Escribir(„Ingrese el carácter alfabético:‟)
Capturar(X[f,c])
Fin_Para
Fin_Para
C1 = 0
C2 = 0
C3 = 0
Para f = 1 hasta 20
Para c = 1 hasta 30
Si (X[f,c] = “A” entonces
C1= C1 + 1
Sino
Si (X[f,c] = “V” entonces
C2= C2 + 1
Sino
Si (X[f,c] = “E” entonces
C3= C3 + 1
Fin_Si
Fin_Si
Fin_Si
Fin_Para
Fin_Para
Mostrar(„Fueron letras A:‟, C1)
Mostrar(„Fueron letras V:‟, C2)
Mostrar(„Fueron letras E:‟, C3)
FIN

Pag. 190
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2 Diagrama de Flujo


INICIO

f, c, C1, C2, C3: entero


X: arreglo[1 ..20, 1 .. 30] – caracter

Para f=1
Hasta 20

Para c=1
Hasta 30

X[f,c]

C1 = 0; C2 = 0; C3 = 0

Para f=1
Hasta 20

Para c=1
Hasta 30

X[f,c] = “A”

X[f,c] = “V” C1 = C1 + 1

X[f,c] = “E” C2 = C2 + 1

C3 = C3 + 1

C1, C2, C3

FIN

Pag. 191
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form2
Dim X(0 To 19, 0 To 29) As String
Dim f As Byte
Dim c As Byte
Dim C1 As Byte
Dim C2 As Byte
Dim C3 As Byte
Dim Wlet As Byte
Private Sub CmdSalir_Click()
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub cmdcargar_Click
Dim c, f As Integer
For f = 1 To 19
For c = 1 To 29
Do
Wlet = Format(Rnd() * 100, 0)
Loop Until (Wlet >= 65 And Wlet <= 90)
DataGridView1.Item(c - 1, f - 1).Value = Chr(Wlet)
X(f, c) = DataGridView1.Item(c - 1, f - 1).Value
Next c
Next f
End Sub
Private Sub cmdprocesar_Click
C1 = 0
C2 = 0
C3 = 0
For f = 1 To 19
For c = 1 To 29
If (X(f, c) = "A") Then
C1 = C1 + 1
Else
If (X(f, c) = "V") Then
C2 = C2 + 1
Else

Pag. 192
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

If (X(f, c) = "E") Then


C3 = C3 + 1
End If
End If
End If
Next c
Next f
TextBox1.Text = C1
TextBox2.Text = C2
TextBox3.Text = C3
End Sub
Private Sub cmdnuevo_Click
DataGridView1.RowCount = 1
DataGridView1.RowCount = 20
DataGridView1.ColumnCount = 30
TextBox1.Text = 0
TextBox2.Text = 0
TextBox3.Text = 0
End Sub
Private Sub Form2_Load
DataGridView1.RowCount = 20
DataGridView1.ColumnCount = 30
For i = 0 To 29
DataGridView1.Columns(i).Width = 20
Next i
End Sub
End Class

Ejercicio de aplicación No. 5


Diseñe un algoritmo que permita el ingreso de números a una matriz bidimensional
cuadrada X de 20 por 20, luego la suma de todos los valores de las columnas impares se
deberán almacenar en un vector Y.
Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingrese números a un matriz de 20 por 20 y aquellos valores que forman parte de
la columna impar de sumaran y se guardan en un vector.
ii. ¿Qué datos necesito conocer?
Los números que se guardan en la matriz.

2. Planteamiento Lógico.
Una vez que se encuentran los números en la matriz, se deberá generar una condición
que involucre a los indices de las columnas y si estos son impares sus valores a
asociados se deben ir acumulando para que una vez que se termina de recorrer la fila
se guarde dicho valor en el vector.
Ej: Sean estos los datos: 12, 15, 7, 16, 12, 5, 0, 17
Pag. 193
Fundamentos de programación

Se suman: 12 + 7 + 12 + 0 = 31 (Este valor se almacena en el vector respectivo)

3. Definición de variables de entrada.


No se requiere de una variable, el ingreso es directo a matriz.
4. Definición de variables de salida.
No se requieren de variables de salida, los resultados se almacenan en el vector final.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
f, c, AC, M: entero
X: arreglo[1 ..20, 1 .. 20] – entero
Y: arreglo[1 ..10] – entero
Para f = 1 hasta 20
Para c = 1 hasta 20
Escribir(„Ingrese el número:‟)
Capturar(X[f,c])
Fin_Para
Fin_Para
AC = 0
M= 0
Para c = 1 hasta 20
Si (c mod 2 <> 0) entonces
Para f = 1 hasta 20
AC= AC + X[f,c]
Fin_Para
Fin_Si
M= M+ 1
Y[M] = AC
Fin_Para
Para f = 1 hasta 10
Mostrar(„Numero:‟, Y[f])
Fin_Para
FIN

Pag. 194
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

5.2 Diagrama de Flujo

INICIO

f, c, AC: entero
X: arreglo[1 ..20, 1 .. 20] – entero
Y: arreglo[1 ..20] – entero

Para f=1
Hasta 20

Para c=1
Hasta 20

X[f,c]

AC = 0, M = 0

Para c=1
Hasta 20

c mod 2=0

Para f=1
Hasta 20

AC= AC + X[f,c]

M= M+ 1
Y[f] = AC

Para f=1
Hasta 10

Y[f]

FIN

Pag. 195
Fundamentos de programación

5.3 Diseño del Formulario

5.4 Codificación del Programa


Public Class Form3
Dim X(0 To 19, 0 To 19) As Byte
Dim Y(0 To 9) As Integer
Dim f As Byte
Dim c As Byte
Dim M As Byte
Dim AC As Integer
Private Sub cmdcargar_Click
Dim c, f As Integer
ListBox1.Items.Clear()
For f = 1 To 19
For c = 1 To 19
DataGridView1.Item(c - 1, f - 1).Value = Format(Rnd() * 100, 0)
X(f, c) = DataGridView1.Item(c - 1, f - 1).Value
Next c
Next f
End Sub
Private Sub cmdnuevo_Click
DataGridView1.RowCount = 20
DataGridView1.ColumnCount = 20
ListBox1.Items.Clear()
End Sub
Private Sub cmdvisualizar_Click
Dim c, f As Integer
AC = 0
M=0
For c = 1 To 19
If (c Mod 2 <> 0) Then
For f = 1 To 19
AC = AC + X(f, c)
Next f
Y(M) = AC
M=M+1
End If
Next c
For f = 1 To 9
ListBox1.Items.Add(Y(f))
Next f
End Sub

Pag. 196
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado

Private Sub cmdsalir_Click


If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub Form3_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
DataGridView1.RowCount = 20
DataGridView1.ColumnCount = 20
For i = 0 To 19
DataGridView1.Columns(i).Width = 20
Next i
End Sub
End Class

Pag. 197