guia 05 completa 2016 - unicauca.edu.co

1

5. ARREGLOS Y REGISTROS

5.1. Vectores CONCEPTO DE VECTOR. Un array (también conocido como arreglo) y en nuestro caso concreto un vector,

es un elemento especial para manejar una gran cantidad de datos del mismo tipo bajo un mismo nombre o

identificador. Por ejemplo, mediante la sentencia:

S[250]

Se declara un vector que llamamos S en el que se reserva espacio para 250 variables. Las 250 variables se

llaman S y se accede a una u otra por medio de un subíndice, que es una expresión entera escrita a

continuación del nombre entre corchetes [...]. En nuestros ejemplos, los elementos se numeran desde 0

hasta (número de elementos - 1).

S . . . . . .

Posición

1 S[0]

Posición 2

S[1] Posición

100 S[99]

Posición 249

S[248]

Posición 250

S[249]

Para acceder a un elemento del vector basta incluir en una expresión su nombre seguido del subíndice entre

corchetes.

Si queremos acceder al primer elemento del vector S, escribiremos: S[0]

Si queremos acceder al segundo elemento del vector S, escribiremos: S[1]

Si queremos acceder al centésimo elemento del vector S, escribiremos: S[99]

Si queremos acceder al penúltimo elemento del vector S, escribiremos: S[248]

Si queremos acceder al último elemento del vector S, escribiremos: S[249]

En cada casilla se guarda un valor

Para acceder a cada casilla debo indicar el nombre del vector y valor del índice o posición

Siler Amador Donado

2

----------------------------------------------------------------------------------------------------------------------------------------- 00. Ejemplo en el que se pide al usuario el tamaño del vector y los elementos para cargar ese vector; también se muestra el vector lleno, usando subprogramas. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Una de las ventajas de los vectores, es que permiten almacenar información que se va a necesitar posteriormente, la cual se perdería si utilizamos variables planas durante el proceso repetitivo de lectura. Aquí se presenta el manejo de operaciones básicas de un vector: inicializar, cargar y mostrar el contenido de un vector. 2. Análisis. 2.1. Datos de Entrada: El tamaño efectivo del vectorà N

Cada uno de los elementos a incluir en el vector à V[i] 2.2. Datos de Salida: Cada uno de los elementos que fueron incluidos en el vector. 2.3. Procesos: identificamos los sub-problemas. Sub-problema 1: Se solicita al usuario cuántas casillas tendrá el vector. Para ello se elabora un subprograma que lea y entregue ese valor. Sub-problema 2: Vamos a “cargar” o “llenar” un vector, esa es una de las operaciones fundamentales. Para ello se utiliza un ciclo “PARA” que va desde 0 hasta (N-1). En cada iteración se le solicita al usuario el valor a incluir y se guardará en la posición correspondiente, la cual estará etiquetada por la variable de iteración. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; en su interior se hará el proceso de carga del vector. Sub-problema 3: Ahora se procede a “mostrar” todos y cada uno de los valores incluidos. Para ello se utiliza un ciclo “PARA” que va desde 0 hasta (N-1). En cada iteración se imprimirá el valor contenido en la posición correspondiente, la cual estará etiquetada por la variable de iteración. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; en su interior se hará el proceso imprimir cada elemento del vector. 3. Representación de la alternativa de solución en un estándar. Vista General: Inicio N = Tamano_Vector() //Esta función solicita el tamaño y lo devuelve a la variable N Cargar_Vector( Vector , N ) //Procedimiento para llenar el vector //parámetros: Entrada/Salida: el vector(que es de entrada y salida) // Entrada: el tamaño N

Mostrar_Vector( Vector , N ) //Procedimiento para imprimir el vector //parámetros: Entrada: el vector (con sus elementos) y el tamaño N Fin Vista detallada (subprogramas): Solución al sub-problema 1: función que pide el tamaño que tendrá el vector. Entero funcion Tamano_Vector() Inicio Leer tamano Devolver (tamano) Fin_Funcion

3

Solución al sub-problema 2: procedimiento que llena un vector Para ello necesitamos un ciclo FOR que va de 0 a (N-1) ya que son N valores. Al interior del ciclo se hace la lectura de un valor y en la respectiva casilla del vector (cuyo valor lo controla la variable i) se copia el dato correspondiente (esta clase de proceso de denomina “cargar” el vector, ya que llenamos cada casilla con los valores que se necesiten). procedimiento Cargar_Vector (E/S real: V[] ; E entero: tam) Inicio

Para ( i=0 hasta tam-1 ) hacer Leer V[i] Fin_para

Fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: procedimiento que imprime un vector Para ello necesitamos un ciclo FOR que va de 0 a (N-1) ya que son N valores. Al interior del ciclo imprime la respectiva casilla del vector (cuyo valor lo controla la variable i). procedimiento Mostrar_Vector (E real: V[] ; E entero: tam) Inicio

Para ( i=0 hasta tam-1 ) hacer Imprimir V[i] Fin_para

Fin_procedimiento

4

----------------------------------------------------------------------------------------------------------------------------------------- 01. Una empresa tiene 250 empleados, por cada uno de ellos tenemos un registro que trae grabado dos datos, el nombre del empleado, y su correspondiente salario mensual (los datos en este registro ya están validados). Elabore los algoritmos que determinen cuántos empleados ganan más del promedio salarial de la empresa. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo de diversas operaciones de un vector como son: cargar un vector, calcular el promedio de los valores almacenados en el vector y hacer comparaciones con cada uno de esos elementos. 2. Análisis. 2.1. Datos de Entrada: Los 250 registros, cada uno con:

Nombre del Empleado à NOM Salario mensual del empleado à SAL 2.2. Datos de Salida: Cantidad de empleados que ganan más del promedio salarial de la empresa à CON 2.3. Procesos: Identificamos los sub-problemas. Sub-problema 1: Leer los 250 registros y copiar los 250 salarios en un vector. Vamos a “cargar” o “llenar” un vector, esa es una de las operaciones fundamentales. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; en su interior se hará el proceso de carga del vector. Sub-problema 2: Calcular el promedio salarial de la empresa. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; en su interior se calcula la suma de elementos, y el promedio. Se debe recorrer el vector y sumar todos sus valores, para posteriormente calcular el promedio que será: PROMEDIO = SUMA / 250. El promedio es el valor que devuelve el subprograma. Sub-problema 3: Una vez calculado el promedio, se debe comparar este promedio contra cada uno de los salarios. Cada salario estará guardado en una casilla del vector, y se llevará la cuenta de los que superen dicho promedio. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector, su tamaño y el valor del promedio. En su interior se compara el valor del promedio con cada elemento del vector y se contabilizará cada elemento que sea superior al promedio, de la siguiente manera:

Si ( V[i] > PRO ) entonces CON = CON + 1

Fin_Si

El conteo es el valor que devuelve el subprograma. Una vez efectuado ese conteo, se procede a mostrar cuántos empleados ganan más del promedio. 3. Representación de la alternativa de solución en un estándar. Vista General: Inicio Cargar_Vector( Vector , 250 ) //Procedimiento para llenar el vector //parámetros: Entrada/Salida: el vector(que es de entrada y salida) // Entrada: el tamaño (250)

Promedio = Promedio_Vector( Vector , 250 ) //Esta es una función (debe entregar un único resultado: el promedio, que se guarda en la variable //“Promedio”) parámetros: Entrada: el vector(cargado) y el tamaño (250)

Conteo = Comparar_Elementos_Vector(Vector, 250, Promedio)

//Esta es una función (debe entregar un único resultado: el conteo de los que superen el promedio, //que se guarda en la variable “Conteo”)

//parámetros: Entrada: vector, tamaño y el promedio que se tiene para hacer la comparación Imprimir Conteo Fin

5

Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que llena un vector Para ello necesitamos un ciclo FOR que va de 0 a 249 ya que son 250 registros los que debemos procesar. Al interior de ese ciclo se hace la lectura de un registro y en la respectiva casilla del vector (cuyo valor lo controla la variable i) se copia el dato correspondiente a cada salario (esta clase de proceso de denomina “cargar” el vector, ya que llenamos cada casilla con los valores que se necesiten). procedimiento Cargar_Vector (E/S real: V[] ; E entero: tam) Inicio

Para ( i=0 hasta tam-1 ) hacer Leer SAL V[i] = SAL Fin_para

Fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: función que calcula el promedio de los elementos de un vector • Para esta función necesitaremos una variable de proceso que lleve la suma de salarios la cual denominaremos SUM.

Para efectuar la suma de los valores del vector (los salarios), debe hacerse al interior de un ciclo FOR que va de 0 a 249 ya que son 250 valores los que debemos procesar.

• Al terminar de procesar los 250 registros, calculamos el promedio, de modo que necesitamos otra variable de proceso la cual denominaremos PRO.

• El promedio es el cociente entre la suma de salarios y la cantidad de empleados, en nuestro caso PRO = SUM / 250. • El valor almacenado en PRO es el valor que debe devolver la función. real funcion Promedio_Vector(E real: V[]; E entero: tam) inicio SUM = 0

Para ( i=0 hasta tam-1 ) hacer SUM = SUM + V[i] Fin_para

PRO = (SUM / 250)

devolver (PRO) fin_funcion ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: función que cuenta los elementos cuyo valor sea superior al promedio

• Para hacer la comparación necesitaremos recorrer el vector casilla a casilla, y comparar el valor almacenado en cada

casilla con respecto al promedio salarial que ha sido calculado. • Para ello necesitamos de nuevo un ciclo FOR que vaya de 0 a 249 ya que esas son las casillas del vector, y al interior

del ciclo se compara el valor almacenado en la casilla con el promedio salarial, con la condición ¿V[i]>PRO? • En caso afirmativo aumentamos en 1 la variable CON, la cual lleva ese conteo (debe inicializarse en cero al comienzo). • Cuando se haya recorrido TODO el vector, termina el ciclo y la función devolverá el valor que tenga la variable CON. entero funcion Comparar_Elementos_Vector (E real: V[]; E entero: tamano; E real: PRO) inicio CON = 0

Para ( i=0 hasta tamano-1 ) hacer Si ( V[i] > PRO ) entonces CON = CON + 1 Fin_Si

Fin_para devolver (CON) fin_funcion

6

--------------------------------------------------------------------------------------------------------------------------------------- 02. Elabore los algoritmos necesarios para resolver lo siguiente: Leer un vector de n elementos, grabados en un solo registro (o cargados en una sola lectura), que averigüe e imprima cuál es el mayor y en qué posición se encuentra, y cuál es el menor y en qué posición se encuentra. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Se maneja el proceso de recorrer un vector para diversas operaciones como son: cargar un vector y hacer comparaciones con cada uno de esos elementos para identificar aquellos elementos de ese vector que cumplan con alguna característica en particular. 2. Análisis. 2.1. Datos de Entrada: El tamaño del vector à n

Cada de uno de los n elementos que conforman el vector. 2.2. Datos de Salida: Elemento mayor à MAY

Posición del vector en la que se encuentra el elemento mayor à P1 Elemento menor à MEN Posición del vector en la que se encuentra el elemento menor à P2

2.3. Procesos: Identificamos los sub-problemas. Sub-problema 1: se solicita al usuario cuántas casillas tendrá el vector. Para ello se elabora un subprograma que lea y entregue ese valor. Sub-problema 2: Vamos a “cargar” un vector, leyendo cada uno de los números. Se debe utilizar un ciclo repetitivo FOR, exclusivamente para esta función. Ese ciclo FOR va de 0 hasta (n-1) y al interior de ese ciclo leemos el respectivo elemento para asignarlo a la casilla cuyo valor estará dado por la variable de iteración que controla el ciclo FOR. Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; en su interior se hará el proceso de carga del vector. Sub-problema 3: Ahora iniciamos el proceso para saber quiénes son el valor mayor (MAY) y su posición (P1) junto con el valor menor (MEN) y su posición (P2).

Para ello se elabora un subprograma que tenga como parámetros de entrada el vector y su tamaño; y como parámetros de salida las variables MAY, P1, MEN, P2. Antes de invocar el subprograma se declara que el primer elemento es tanto el mayor como el menor. O sea que tendremos:

MAY = Vector[0] y su posición P1 = 0 MEN = Vector [0] y su posición P2 = 0

En el programa cliente, imprimiremos: El valor mayor que estará almacenado en la variable MAY y su posición (P1) El valor menor que estará almacenado en la variable MEN y su posición (P2). Vista General: Inicio

N = Tamano_Vector() Cargar_Vector( Vector , N ) MAY = Vector[0] P1 = 0 MEN = Vector[0] P2 = 0 Mayor_Menor_Vector( Vector, N, MAY, P1, MEN, P2) Imprimir MAY, P1, MEN, P2

Fin

7

Vista detallada (subprogramas): Solución al sub-problema 1: función que pide el tamaño que tendrá el vector. Entero funcion Tamano_Vector() Inicio Leer tamano Devolver (tamano) Fin_Funcion ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que llena un vector Para ello necesitamos un ciclo FOR que va de 0 a (N-1) ya que son N valores. Al interior del ciclo se hace la lectura de un valor y en la respectiva casilla del vector (cuyo valor lo controla la variable i) se copia el dato correspondiente (esta clase de proceso de denomina “cargar” el vector, ya que llenamos cada casilla con los valores que se necesiten). procedimiento Cargar_Vector (E/S real: V[] ; E entero: tam) Inicio

Para ( i=0 hasta tam-1 ) hacer Leer V[i] Fin_para

Fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: procedimiento para identificar al mayor y al menor del vector y sus posiciones Ahora iniciamos el recorrido que irá desde 1 hasta el último elemento (n-1), durante ese recorrido hacemos lo siguiente:

Comparamos el elemento V[i] con el valor almacenado en la variable MAY, Si V[i] es mayor que el valor almacenado en MAY entonces

V[i] es el nuevo mayor y lo copiaremos en la variable MAY, Igualmente el valor que tenga la variable i es la posición del nuevo mayor y lo copiamos en P1.

En caso contrario:

Preguntamos si V[i] es menor que el valor almacenado en MEN entonces V[i] es el nuevo menor y lo copiaremos en la variable MEN,

El valor que tenga la variable i es la posición en donde está el nuevo menor y lo copiamos en P2. Y esto se hará hasta que recorramos el vector en su totalidad. El recorrido terminará cuando i SUPERE el valor de n y entonces saldremos del ciclo FOR.

procedimiento Mayor_Menor_Vector(E real: V[]; E entero: tam;

S real: MAY; S entero:P1; S real: MEN; S entero: P2) Inicio

Para (i=1 hasta tam-1) hacer Si (V[i]>MAY) entonces MAY = V[i] P1 = i Si_no Si (A[i]<MEN) entonces MEN = V[i] P2 = i Fin_si Fin_si Fin_Para

Fin_procedimiento

8

--------------------------------------------------------------------------------------------------------------------------------------- 03. Elabore los algoritmos necesarios para resolver lo siguiente: Leer un vector A de n elementos, grabados en un solo registro (o cargados en una sola lectura). Estos elementos son números enteros y positivos. Debe crear dos nuevos vectores, B y C, de modo tal que en el vector B queden todos los números impares, y en el vector C todos los múltiplos de 3. Al final debe imprimir los tres vectores, cada uno en un renglón diferente, de tal forma que todos los elementos de un vector queden en un mismo renglón. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo dinámico de vectores que contendrán elementos que cumplan con alguna característica en particular. 2. Análisis. 2.1. Datos de Entrada: El tamaño del vector A à n

Cada de uno de los n elementos que conforman el vector A. 2.2. Datos de Salida: Vector con números impares à B

Vector con números múltiplos de 3 à C 2.3. Procesos. Para este ejercicio necesitamos: Sub-problema 1: Determinar el tamaño del vector A. Sub-problema 2: Llenar el vector A (validando que solo admita valores positivos). Sub-problema 3: Recorrer el Vector A para identificar elementos que puedan ir al vector B y/o al vector C. También hay que llenar dinámicamente un vector con los elementos que se piden. Sub-problema 4: Imprimir un vector.

Vista General: Algoritmo Principal var

entero: A[], B[], C[], N, tb=-1, tc=-1 Inicio

N = tamano()

Cargar_Vector_positivos (A, N) NO_multiplos(A, N, 2, B, tb) Multiplos(A, N, 3, C, tc) Mostrar_Vector (A, N) Mostrar_Vector (B, tb) Mostrar_Vector (C, tc)

Fin

Vista detallada (subprogramas): Solución al sub-problema 1: función que pide el tamaño que tendrá el vector A. Entero funcion Tamano_Vector() Inicio Leer tamano Devolver (tamano) Fin_Funcion

9

Solución al sub-problema 2: procedimiento que llena un vector procedimiento Cargar_Vector_positivos (E/S entero: V[] ; E entero: tam) Inicio

Para ( i=0 hasta tam-1 ) hacer Leer V[i]

Mientras (V[i] <= 0) hacer Imprimir “NO VÁLIDO” Leer V[i] Fin_Mientras Fin_para

Fin_procedimiento -----------------------------------------------------------------------------------------------------------------------------------

Solución al sub-problema 3: procedimiento que identifica elementos de un vector que sean pares y/o múltiplos de 3. Veamos una primera (pero horrorosa e inaceptable) aproximación: procedimiento identificar_elementos( E entero: V[], tam ;

S entero: B[], C[], j, k ) var

entero: i, D inicio Para ( i=0 hasta tam-1 ) hacer

D = [ V[i]/2 ] * 2

Si (V[i] ≠ D) entonces j = j + 1

B[j] = V[i] Fin_si

D = [ V[i]/3 ] * 3

Si (V[i]=D) entonces k = k + 1

C[k] = V[i] Fin_si Fin_Para fin_procedimiento ¿Por qué no es aceptable? Porque la cantidad de parámetros en el encabezado de un subprograma no debe variar. En este caso concreto se piden 2 vectores de salida, pero si piden solo uno o si piden tres, o cuatro o más, (por ejemplo, que no sean múltiplos de 5, que sí sean múltiplos de 7, etc.) el encabezado no debe variar en su cantidad de parámetros. Lo que debe hacerse es volverlo genérico y se invoca (EXTERNAMENTE) la cantidad de veces que sea necesario. Hay que redefinirla, y generar 2 procedimientos de la siguiente manera:

10

Uno para los que SÍ sean múltiplos de un valor determinado:

procedimiento multiplos(E entero: V[], tam, val; S entero: Z[],tZ) Donde: V[] es el vector de entrada, tam es el tamaño del vector de entrada, val es el número a partir del cual se evalúa si el elemento del vector V[] SÍ sea múltiplo, Z[] es el vector de salida que tendrá los elementos de V[] que sean múltiplos de val, tZ es la variable que llevará el tamaño del vector Z.

Y otro para los que NO sean múltiplos de un valor determinado:

procedimiento NO_multiplos(E entero: V[], tam, val; S entero: Z[],tZ) Donde: V[] es el vector de entrada, tam es el tamaño del vector de entrada, val es el número a partir del cual se evalúa si el elemento del vector V[] NO sea múltiplo, Z[] es el vector de salida que tendrá los elementos de V[] que NO sean múltiplos de val, tZ es la variable que llevará el tamaño del vector Z.

Se procede a implementarlos: procedimiento multiplos(E entero: V[], tam, val; S entero: Z[],tZ) inicio Para ( i=0 hasta tam-1 ) hacer

D = [ V[i]/val ] * val Si (V[i]=D) entonces tZ = tZ + 1 //abrimos el espacio

Z[tZ] = V[i] //insertamos el elemento en la nueva posicion Fin_si Fin_Para

tZ = tZ + 1 fin_procedimiento procedimiento NO_multiplos(E entero: V[], tam, val; S entero: Z[],tZ) inicio Para ( i=0 hasta tam-1 ) hacer

D = [ V[i]/ val ] * val Si (V[i] ≠ D) entonces tZ = tZ + 1 //abrimos el espacio

Z[tZ] = V[i] //insertamos el elemento en la nueva posicion Fin_si

Fin_Para tZ = tZ + 1

fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 4: procedimiento que imprime un vector procedimiento Mostrar_Vector (E entero: V[] ; E entero: tam) Inicio


Fin_procedimiento

11

--------------------------------------------------------------------------------------------------------------------------------------- 04. Elabore los algoritmos necesarios para resolver lo siguiente: Leer un vector A de n elementos. Dichos elementos pueden ser cualquier clase de caracter. El vector A tiene muchos elementos repetidos. El programa debe crear e imprimir un nuevo vector que contenga todos los elementos de A, sin que haya repetidos. Por ejemplo, si el elemento ‘z’ aparece 5 veces en A, debe aparecer 1 vez en el nuevo vector. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo dinámico de vectores que contendrán elementos que cumplan con alguna característica en particular. 2. Análisis. 2.1. Datos de Entrada: Vector de n elementos (con muchos repetidos) à A 2.2. Datos de Salida: Vector con elementos únicos à B 2.3. Procesos: Para este ejercicio necesitamos:

Sub-problema 1: Determinar el tamaño del vector A. Sub-problema 2: Llenar el vector A (validando que solo admita valores positivos). Sub-problema 3: Generar el vector con los elementos únicos (filtrados) del vector A. Sub-problema 4: Imprimir un vector.


entero: A[], B[], N, tb=1 Inicio

N = tamano()

Cargar_Vector (A, N) Quitar_Repetidos(A, N, B, tb) Mostrar_Vector (B, tb)

Fin Vista detallada (subprogramas): Solución al sub-problema 1: función que pide el tamaño que tendrá el vector. Entero funcion Tamano_Vector() Inicio Leer tamano Devolver (tamano) Fin_Funcion ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que llena un vector procedimiento Cargar_Vector_positivos (E/S entero: V[] ; E entero: tam) Inicio



Fin_procedimiento

12

Solución al sub-problema 3: procedimiento que genera un nuevo vector (Z) que contenga todos los elementos del original (V), sin que haya repetidos. El vector Z se inicializa con el primer elemento del vector V. La variable tz servirá como índice del vector Z, ya que no sabemos cómo crecerá, es decir, no en todas las iteraciones Z va a recibir elementos nuevos ya que en V hay elementos repetidos y Z solo guarda elementos únicos. Iniciamos el recorrido del vector V el cual controlaremos con un ciclo FOR que irá desde 1 hasta tam-1. Al interior de este ciclo se procesará lo siguiente:

A medida que va creciendo el vector Z, cada elemento de V se compara con todos los de Z para ver si ya está incluido. Esto se logra mediante otro ciclo FOR que estará anidado con respecto al primero. Este ciclo interno controla el recorrido del vector Z, teniendo el cuidado que el tamaño de Z es variable (recordemos que el tamaño del vector Z estará guardado en la variable tz). También utilizamos un variable bandera (flag) para detectar si el elemento del vector V, en estudio, está ya incluido en el vector Z, si ya está, entonces la variable flag cambiará de valor. Cabe anotar que esa variable llamada flag debemos inicializarla cada vez que vayamos a revisar un elemento del vector V y por consiguiente debe inicializarse en cero apenas ingresamos al ciclo FOR externo. En este punto revisamos la variable flag : si ha cambiado de valor significa que el elemento ya estaba incluido en el vector Z, de lo contrario procedemos a incluir ese elemento del vector V en el vector Z. Insertamos el elemento del vector V en el nuevo vector, y aumentamos en 1 la variable que controla su tamaño, es decir hacemos tz = tz+1.

Al salir del ciclo, tendremos el vector Z con un tamaño de tz elementos. procedimiento Quitar_Repetidos (E entero: V[], tam; S entero: Z[],tZ) inicio

Z[0] = V[0]

Para (i=1 hasta tam-1) hacer flag = 0

Para (k=0 hasta tz-1) hacer Si (V[i]=Z[k]) entonces flag = 1 k = tz+1 //rompemos el ciclo Fin_si Fin_Para Si (flag = 0) entonces

Z[tZ] = V[i] //insertamos el elemento en la nueva posicion tZ = tZ + 1 //Con esta operacion se "actualiza" el tamaño del vector

Fin_si Fin_Para

fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 4: procedimiento que imprime un vector procedimiento Mostrar_Vector (E entero: V[] ; E entero: tam) Inicio


Fin_procedimiento

13

--------------------------------------------------------------------------------------------------------------------------------------- 05. Elabore los algoritmos necesarios para resolver lo siguiente: Leer dos vectores, un vector A de m elementos que contiene el código de todos los estudiantes que perdieron Cálculo II, y un vector B de n elementos con el código de los estudiantes que perdieron Álgebra Lineal. Crear un nuevo vector C con el código de todos los estudiantes que perdieron las dos materias, ordenarlo de mayor a menor e imprimirlo. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo dinámico de un vector que contendrán elementos de otros 2 vectores suministrados como entradas. Manejo de un algoritmo de ordenamiento de los elementos de un vector de acuerdo a un criterio, en este caso, de mayor a menor. 2. Análisis. 2.1. Datos de Entrada: Vector de m elementos à A

Vector de n elementos à B 2.2. Datos de Salida: Vector con los códigos de los estudiantes que perdieron las 2 asignaturas à C Ordenado de mayor a menor. 2.3. Procesos: Para este ejercicio necesitamos:

Sub-problema 1: Determinar el tamaño del vector A y el tamaño del vector B. Sub-problema 2: Cargar el vector A y el vector B. Sub-problema 3: Generar un nuevo vector con los elementos que están tanto en A como en B. Sub-problema 4: Ordenar el nuevo vector de mayor a menor. Sub-problema 5: Imprimir el nuevo vector.


entero: A[], B[], C[], NA, NB, tc=0 Inicio

NA = tamano() Cargar_Vector (A, NA) NB = tamano()

Cargar_Vector (B, NB) Elementos_Dos_Vectores(A, NA, B, NB, C, tc) Ordenar_Vector_Mayor_Menor(C, tc) Mostrar_Vector(C, tc)

Fin Vista detallada (subprogramas): Solución al sub-problema 1: función que pide el tamaño que tendrá el vector. Entero funcion Tamano_Vector() Inicio Leer tamano Devolver (tamano) Fin_Funcion

14

Solución al sub-problema 2: procedimiento que llena un vector procedimiento Cargar_Vector_positivos (E/S entero: V[] ; E entero: tam) Inicio



Fin_procedimiento -----------------------------------------------------------------------------------------------------------------------------------

Solución al sub-problema 3: procedimiento que genera un nuevo vector con los elementos que están tanto en A como en B. Si un estudiante perdió las dos materias, su código debe aparecer en los dos vectores, por lo tanto debemos comparar cada elemento de un vector con todos los del otro vector. Esto se hace por medio de dos ciclos anidados, de modo tal que mientras el índice del ciclo externo (que va de 0 hasta tamV-1) identifica un elemento del vector V, el índice del ciclo interno (que va de 0 hasta tamW-1) va recorriendo uno a uno todos los elementos del vector W, comparándolos con el elemento del vector V. Cuando se encuentre que son iguales, se debe pasar ese código al vector Z, para el que usaremos la variable tz como subíndice del vector Z. La operación es de la siguiente manera:

Insertamos el elemento del vector W en el nuevo vector, y aumentamos en 1 la variable que controla su tamaño, es decir hacemos tz = tz+1.

Al final de este proceso el tamaño del vector Z estará en el contador tz.

procedimiento Elementos_Dos_Vectores ( E entero: V[], W[], tamV, tamW; S entero: Z[], tZ )

Inicio Para (i=0 hasta tamV-1) hacer

Para (k=0 hasta tamW-1) hacer

Si (V[i] = W[k]) entonces

Z[tz] = W[k] //insertamos el elemento en la nueva posicion tz = tz + 1 //actualizamos el índice

k = tamW + 1 //para romper el ciclo

Fin_Si

Fin_Para

Fin_Para

Fin_procedimiento

15

Solución al sub-problema 4: procedimiento que ordena un vector de Mayor a Menor Ahora debemos proceder a ordenar un vector antes de imprimirlo. Para esto utilizaremos el método de la Burbuja, el cual consiste en comparar el primer elemento del vector con todos los demás y cada vez que aparezca uno mayor se pasa a la primera posición, y el que estaba en la primera se pasa a la posición que ocupaba el elemento que resultó ser mayor. Pero debemos tener cuidado de sacar copia (en otra variable) de uno de los elementos a mover ya que de lo contrario se perderá. Para ello nos apoyamos en una operación que se denomina intercambio, en la que:

1. Tomamos uno de los elementos a intercambiar, en este caso el menor y lo copiamos en una variable temporal que llamaremos TEM.

2. El elemento mayor lo pasamos a la posición que tenía el menor. 3. El valor almacenado en la variable TEM lo enviamos a la posición que tenía el mayor.

Una vez terminada esta comparación tendremos en la primera posición el mayor de todos, entonces repetimos el anterior procedimiento olvidándonos del primer elemento, y partiendo desde el segundo, luego partiendo desde el tercero, y así sucesivamente hasta ordenar el vector. Lo anterior se hace mediante dos ciclos anidados, de modo tal que mientras el índice del ciclo externo se ubica en un elemento del vector, el índice del ciclo interno recorre los demás elementos comparándolos entre sí e intercambiándolos de posición cuando sea requerido. procedimiento Ordenar_Vector_Mayor_Menor (E/S entero: V[] ; E entero: tam) Inicio

Para (i=0 hasta tam-2) hacer Para (k=i+1 hasta tam-1) hacer

Si(V[k]>V[i]) entonces TEM = V[i] V[i] = V[k]

V[k] = TEM Fin_Si Fin_Para Fin_Para fin_procedimiento ----------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 5: procedimiento que imprime un vector procedimiento Mostrar_Vector (E entero: V[] ; E entero: tam) Inicio


Fin_procedimiento

16


5.2. Matrices CONCEPTO DE MATRIZ. Las matrices se utilizan en el cálculo numérico, en la resolución de sistemas de ecuaciones lineales, de las ecuaciones diferenciales y de las derivadas parciales. Además de su utilidad para el estudio de sistemas de ecuaciones lineales, las matrices aparecen de forma natural en geometría, estadística, economía, informática, física, etc. La utilización de matrices constituye actualmente una parte esencial en los lenguajes de programación, ya que la mayoría de los datos se introducen en los computadores como tablas organizadas en filas y columnas: hojas de cálculo, bases de datos, etc. Una matriz es un conjunto de elementos de cualquier naturaleza aunque, en general, suelen ser números organizados en filas y columnas. Se llama matriz de orden "m × n" a un conjunto rectangular de elementos dispuestos en m filas y en n columnas. El orden de una matriz también se denomina dimensión o tamaño, siendo m y n números naturales. Un elemento genérico de una matriz A que ocupe la fila i y la columna j se escribe A[i,j]. Representación. Vamos a representar cómo se referencia cada posición en esta matriz de 3 filas × 4 columnas, la cual llamaremos A (como puede verse, esta matriz en particular tiene menos filas que columnas):

Columna 0

Columna 1

Columna 2

Columna 3

Fila 0 A[0,0] A[0,1] A[0,2] A[0,3]

Fila 1 A[1,0] A[1,1] A[1,2] A[1,3]

Fila 2 A[2,0] A[2,1] A[2,2] A[2,3]

Ahora vamos a representar cómo se referencia cada posición en esta matriz de 4 filas × 3 columnas, la cual llamaremos B (como puede verse, esta matriz en particular tiene más filas que columnas):

Columna 0

Columna 1

Columna 2

Fila 0 B[0,0] B[0,1] B[0,2]

Fila 1 B[1,0] B[1,1] B[1,2]

Fila 2 B[2,0] B[2,1] B[2,2]

Fila 3 B[3,0] B[3,1] B[3,2]

Cuando la cantidad de filas es igual a la cantidad de columnas se dice que es una matriz cuadrada. Debido a que la posición dentro de una matriz se define mediante la utilización de dos subíndices, cuando se necesite recorrer uno a uno sus elementos, se requiere la utilización de dos ciclos FOR anidados, de modo tal que mientras un índice se desplaza sobre las filas, el otro lo hace sobre las columnas, simulando la secuencia lógica de los subíndices de cada elemento.

17

----------------------------------------------------------------------------------------------------------------------------------------- 00. Ejemplo en el que se pide al usuario las dimensiones de la matriz y los elementos para cargarla; también se muestra la matriz llena y se ordena de mayor a menor el contenido de esa matriz; todo usando subprogramas. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Aquí se presenta el manejo de operaciones básicas de una matriz: inicializar, cargar, ordenar de mayor a menor y mostrar su contenido. 2. Análisis. 2.1. Datos de Entrada: Las dimensiones de la matriz à FILAS, COLUMNAS

Cada uno de los elementos a incluir en la matriz à A[ i ][ j ] 2.2. Datos de Salida: Cada uno de los elementos que fueron incluidos en la Matriz. 2.3. Procesos: identificamos los sub-problemas.

• Sub-problema 1: Se solicita al usuario cuántas filas y cuántas columnas tendrá la matriz. Para ello se elabora un subprograma que lea y entregue esos valores.

• Sub-problema 2: Vamos a “cargar” o “llenar” la matriz. • Sub-problema 3: Vamos a ordenar los elementos de la matriz de mayor a menor. • Sub-problema 4: Ahora se procede a “mostrar” todos y cada uno de los valores incluidos.

3. Representación de la alternativa de solución en un estándar. Vista General: Inicio

Dimensiones(fil , col) Cargar_Matriz( A , fil, col ) Mostrar_Matriz( A , fil, col ) Ordenar_Matriz_Mayor_Menor( A , fil, col ) Mostrar_Matriz( A , fil, col )

Fin Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que pide las dimensiones de la matriz procedimiento Dimensiones(S entero: F, C) Inicio

Leer F Leer C Fin_Procedimiento -------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que llena una matriz

Para ello se utilizan dos ciclos PARA anidados. Un ciclo “PARA” externo que va desde 0 hasta (filas-1) y uno interno que va desde 0 hasta (columnas-1). En cada iteración se le solicita al usuario el valor a incluir y se guardará en la posición correspondiente, la cual estará etiquetada por las variable de iteración. Para ello se elabora un subprograma que tenga como parámetros de entrada la matriz y sus dimensiones; en su interior se hará el proceso de carga de la matriz.

procedimiento Cargar_Matriz (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( i=0 hasta F-1 ) hacer Para ( j=0 hasta C-1 ) hacer Leer M[i][j]

Fin_para Fin_para

Fin_procedimiento

18

Solución al sub-problema 3: procedimiento que ordena los elementos de una matriz de mayor a menor

Para garantizar un movimiento homólogo al de los vectores, se requieren 4 ciclos for anidados. Los 2 más externos (usando las variables i , j ) on para recorrer la matriz y el elemento denotado por este recorrido más interno lo llamamos A[i] [j]. Los 2 ciclos más externos (usando las variables x , y ) también son para recorrer la matriz y el elemento denotado por este recorrido más interno lo llamamos A[x] [y] y se va comparando con cada elemento A[i] [j]. Si el elemento A[i] [j] es mayor que el elemento A[x] [y] habrá que intercambiarlos.

Cuando se terminen los 2 FOR más internos, se habrá obtenido el mayor elemento de la matriz, ahora se compara

al segundo elemento de la matriz con los demás y se reiniciarán nuevamente los 2 ciclos FOR más internos. Cada vez que se completen los 2 FOR más internos se irá obteniendo el elemento correspondiente (el segundo

mayor, el tercer mayor, etc.) y esos ciclos internos se reptirán hasta que se acaben los ciclos externos, lo cual indica que se habrá terminado el proceso de recorrido y comparaciones.

procedimiento Ordenar_Matriz_Mayor_Menor (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( i=0 hasta F-1 ) hacer Para ( j=0 hasta C-1 ) hacer

Para ( x=0 hasta F-1 ) hacer Para ( y=0 hasta C-1 ) hacer

Si (M[i][j]>M[x][y]) entonces

mayor = M[i][j] M[i][j] = M[x][y] M[x][y] = mayor

Fin_Si

Fin_para

Fin_para Fin_para

Fin_para Fin_procedimiento -------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 4: procedimiento que muestra los elementos de una matriz

Para ello se utilizan dos ciclos PARA anidados. Un ciclo “PARA” externo que va desde 0 hasta (filas-1) y uno interno que va desde 0 hasta (columnas-1). En cada iteración se imprimirá el valor contenido en la posición correspondiente, la cual estará etiquetada por la variable de iteración. Para ello se elabora un subprograma que tenga como parámetros de entrada la matriz y sus dimensiones; en su interior se hará el proceso de imprimir cada elemento de la matriz.

procedimiento Mostrar_Matriz (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( i=0 hasta F-1 ) hacer Para ( j=0 hasta C-1 ) hacer Imprimir M[i][j]

Fin_para

Fin_para Fin_procedimiento

19

----------------------------------------------------------------------------------------------------------------------------------------- 01. Elabore los algoritmos necesarios para resolver lo siguiente: Leer una matriz A de m filas y n columnas y que calcule e imprima la suma de cada una de sus filas, y cada una de sus columnas. Junto con el resultado de la suma imprimir la palabra “fila” o “columna”, y su número correspondiente. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo de los recorridos de una matriz tanto por filas como por columnas lo cual implica una correcta manipulación de índices. 2. Análisis. 2.1. Datos de Entrada: Los m registros, cada registro con n datos, para un total de (m × n) datos. 2.2. Datos de Salida: La suma de los valores de cada fila. De modo que serán m sumas y por lo tanto m valores a imprimir. La suma de los valores de cada columna. De modo que serán n sumas y por lo tanto n valores a imprimir. 2.3. Procesos: identificamos los sub-problemas. • Sub-problema 1: Se solicita al usuario cuántas filas y cuántas columnas tendrá la matriz. Para ello se elabora un

subprograma que lea y entregue esos valores. • Sub-problema 2: Vamos a “cargar” o “llenar” la matriz. • Sub-problema 3: recorrer la matriz para obtener los suma de los valores de cada fila. Cuando se tenga la suma de los

valores de una Fila específica de la Matriz, se imprime directamente. • Sub-problema 4: recorrer la matriz para obtener los suma de los valores de cada columna. Cuando se tenga la suma

de los valores de una columna específica de la Matriz, se imprime directamente. 3. Representación de la alternativa de solución en un estándar. Vista General: Inicio

Dimensiones(fil , col) Cargar_Matriz( A , fil, col ) Suma_Filas_Matriz( A , fil, col ) Suma_Columnas_Matriz( A , fil, col )

Fin Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que pide las dimensiones de la matriz

procedimiento Dimensiones(S entero: F, C) Inicio

Leer F Leer C Fin_Procedimiento

-------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que llena una matriz




Fin_para Fin_para

Fin_procedimiento

20

Solución al sub-problema 3: Obtener la suma de los valores de cada fila de la matriz Este subprograma tiene como parámetros la matriz y sus dimensiones (F y C). Con el fin de calcular la suma de las filas, se hace el recorrido horizontalmente, o sea que el índice del ciclo externo se utiliza para las filas, y el del ciclo interno para las columnas. Los resultados se imprimen a la salida del ciclo interno.

El ciclo externo irá de i=0 hasta F-1, al interior de ese ciclo haremos lo siguiente: 1. Inicializamos en cero la variable que llevará la suma, la cual llamaremos S. 2. Viene el ciclo interno, que irá de k=0 hasta C-1, al interior de ese ciclo haremos lo siguiente:

El elemento de la matriz M[i,k] lo sumamos a la variable S y el resultado lo asignamos a esa misma variable: S = S + M[i,k].

3. Al salir del ciclo interno, tendremos el resultado de la suma de los valores de la fila “i” almacenado en la variable S y los imprimimos junto con la palabra “fila”: “Fila”, i, S.

Esas 3 instrucciones se repetirán hasta que salgamos del ciclo externo.

procedimiento Suma_Filas_Matriz (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( i=0 hasta F-1 ) hacer S = 0

Para ( k=0 hasta C-1 ) hacer

S = S + M[i,k]

Fin_para Imprimir “Fila”, i, S

Fin_para Fin_procedimiento ---------------------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 4: Obtener la suma de los valores de cada columna de la matriz Este subprograma tiene como parámetros la matriz y sus dimensiones (F y C). Con el fin de calcular la suma de las columnas, el recorrido se hace verticalmente, es decir, el índice del ciclo externo será para las columnas, y el del interno para las filas. Los resultados se imprimen a la salida del ciclo interno.

El ciclo externo irá de k=0 hasta C-1, al interior de ese ciclo haremos lo siguiente: 1. Inicializamos en cero la variable que llevará la suma, la cual llamaremos S. 2. Viene el ciclo interno, que irá de i=0 hasta F-1, al interior de ese ciclo haremos lo siguiente:

El elemento de la matriz M[i,k] lo sumamos a la variable S y el resultado lo asignamos a esa misma variable: S = S + M[i,k].

3. Al salir del ciclo interno, tendremos el resultado de la suma de los valores de la columna “k” almacenado en la variable S y los imprimimos junto con la palabra “columna”: “Columna”, k, S.

Esas 3 instrucciones se repetirán hasta que salgamos del ciclo externo.

procedimiento Suma_Columnas_Matriz (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( k=0 hasta C-1 ) hacer S = 0

Para ( i=0 hasta F-1 ) hacer

S = S + M[i,k]

Fin_para Imprimir “Columna”, k, S

Fin_para Fin_procedimiento

21

----------------------------------------------------------------------------------------------------------------------------------------- 03. Elabore los algoritmos necesarios para resolver lo siguiente: Leer una matriz cuadrada A de m filas y m columnas. Calcular e imprimir la suma de los elementos que aparezcan en cada una de las siguientes regiones: La Diagonal Principal de la Matriz, la región Triangular Inferior, la región Triangular Superior y la región Diagonal Secundaria. --------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Manejo de los recorridos de una matriz. En esos recorridos se deben identificar los elementos que correspondan con las regiones mencionadas. El identificar tales elementos depende de sus índices. Estas regiones solo tienen sentido en matrices cuadradas. Se señalan en el siguiente esquema:

(0,0) (1,1) (0,1) (0,2) (0,3) (0,4)

(1,1) (1,2) (1,3) (1,4)

(2,2) (2,3) (2,4)

(3,3) (3,4)

(4,4)

Diagonal Principal Triangular Superior

(0,4)

(1,0) (1,3)

(2,0) (2,1) (2,2)

(3,0) (3,1) (3,2) (3,1)

(4,0) (4,1) (4,2) (4,3) (4,0)

Triangular Inferior Diagonal Secundaria

2. Análisis. 2.1. Datos de Entrada: La dimensión de la matriz (m) y sus (m × m) datos. 2.2. Datos de Salida: Suma de los elementos de la Diagonal Principal à DP Suma de los elementos de la Triangular Inferior à TI Suma de los elementos de la Triangular Superior à TS Suma de los elementos de la Diagonal Secundaria à DS 2.3. Procesos: identificamos los sub-problemas. • Sub-problema 1: Se solicita al usuario las dimesiones de la matriz. En este caso hay una variación, puesto que la

matriz es cuadrada entonces se pedirá un solo valor para evitar inconsistencias. • Sub-problema 2: Vamos a “cargar” o “llenar” la matriz. • Sub-problema 3: Recorrer la matriz para obtener la suma de los valores correspondientes a cada región. Cuando se

tenga la suma esos valores el subprograma los imprime directamente. 3. Representación de la alternativa de solución en un estándar. Vista General: Inicio

Dimensiones_cuadrada(fil) Cargar_Matriz( A , fil, fil ) Suma_Elementos_Regiones( A , fil, fil )

Fin

22

Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que pide las dimensiones de la matriz

procedimiento Dimensiones_cuadrada(S entero: F) Inicio

Leer F Fin_Procedimiento

-------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que llena una matriz




Fin_para Fin_para

Fin_procedimiento -------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: Obtener la suma de los valores de cada región Este subprograma tiene como parámetros la matriz y sus dimensiones (F). Necesitamos las variables que almacenen las sumas solicitadas (DP, TI, TS, DS). Como las sumas que nos piden son resultados globales, las inicializamos en cero antes de iniciar los recorridos sobre la matriz. Los elementos que conforman cada una de las cuatro áreas de la matriz solicitadas en el enunciado, tienen su propia característica que los identifican. Si identificamos las filas de la matriz con la variable i, y las columnas con la variable k, entonces cualquier elemento de la matriz se identifica M[i,k].

Los elementos que pertenecen a la Diagonal Principal (DP), tienen la característica que i = k . Los elementos que pertenecen a la Triangular Superior (TS), son los que se encuentran encima de la Diagonal Principal, y se caracterizan porque i < k. Los elementos de la Triangular Inferior (TI), son los que se encuentran debajo de la Diagonal Principal, y se caracterizan porque i > k. Los elementos de la Diagonal Secundaria (DS), son los que van desde la esquina superior derecha de la matriz, hasta la esquina inferior izquierda y se identifican porque i+k = F-1.

De acuerdo con lo anterior, utilizamos los dos ciclos anidados para recorrer la matriz, uno con la variable i como índice (para las filas), y el otro con la variable k (para las columnas). Durante ese recorrido comparamos los dos índices y de acuerdo con el resultado obtenido lo vamos sumando en el correspondiente acumulador. Durante el proceso de comparación hay que tener en cuenta que los tres primeros casos son excluyentes, o sea que ningún elemento puede estar en más de uno de ellos. Solo en el caso de la Diagonal Secundaria se presenta la posibilidad que cualquiera de sus elementos puede estar en cualquiera de los otros tres casos, por lo tanto esta última comparación se debe hacer independiente de las otras. Para los casos de Diagonal Principal, Triangular Superior y Triangular Inferior, podemos establecer lo siguiente: Si (i = k) el elemento M[i,k] es de la Diagonal Principal y lo sumamos a DP. DP = DP + M[i,k] Si no, evaluamos: si (i<k) el elemento M[i,k] es de la Triangular Superior y lo sumamos a TS. TS = TS + M[i,k]

En caso contrario, significa que (i>k) entonces el elemento M[i,k] es de la Triangular Inferior y lo sumamos a TI. TI = TI + M[i,k]

23

El último caso (Diagonal Secundaria) debe evaluarse por separado de los casos anteriores y la condición a establecer es que si (i+k = F-1) entonces el elemento M[i,k] pertenece a la diagonal secundaria. Una vez terminado el recorrido, se imprimen los valores que tengan las variables DP, TI, TS y DS. procedimiento Suma_Elementos_Regiones (E/S entero: M[][] ; E entero: F, C) Inicio

Para ( i=0 hasta F-1 ) hacer Para ( k=0 hasta C-1 ) hacer

Si (i>k) entonces TI = TI + M[i,k] Si_no Si (i=k) entonces DP = DP + M[i,k]

Si_no

TS = TS + M[i,k]

Fin_si Fin_si

Si (i+k=F-1) entonces

DS = DS + M[i,k]

Fin_si

Fin_para Fin_para Imprimir DP, TS, TI, DS

Fin_procedimiento

24


5.3. Registros CONCEPTO DE REGISTRO. Una estructura (o registro) es una forma de agrupar un conjunto de datos de distinto tipo bajo un mismo nombre o identificador. Por ejemplo, supóngase que se desea diseñar una estructura que guarde los datos correspondientes a un alumno. Esta estructura, a la que se llamará alumno, deberá guardar el código del estudiante, los nombres, los apellidos, la dirección, el teléfono y las notas en las 6 asignaturas que matriculó en el semestre. Cada uno de estos datos se denomina miembro o campo de la estructura. El modelo o patrón de esta estructura puede crearse del siguiente modo: Estructura alumno{

entero largo : codigo cadena : nombres[40] cadena : apellidos[40] cadena : direccion[50] entero largo : telefono real : notas[6]

} El seudocódigo anterior crea el tipo de dato alumno, pero aún no hay ninguna variable declarada con este nuevo tipo. Para declarar dos variables (en C++) de tipo alumno se debe hacer lo siguiente:

alumno alumno1, alumno2; // esto es en C++ donde tanto alumno1 como alumno2 son una estructura, Y CADA UNA podrá almacenar:

• El código de un estudiante. • Un nombre de hasta 40 caracteres. • Un apellidos de hasta 40 caracteres • Una dirección de hasta 50 caracteres. • El número de teléfono. • Las notas de las 6 asignaturas.

Que gráficamente lo podemos representar así: alumno1 codigo nombres apellidos direccion telefono notas

alumno2 codigo nombres apellidos direccion telefono notas

También podrían haberse definido alumno1 y alumno2 al mismo tiempo que se definía la estructura de tipo alumno. Para ello bastaría haber hecho: Estructura alumno{


} alumno1, alumno2;

25

Para acceder a los miembros de una estructura se utiliza el operador punto (.), precedido por el nombre de la estructura y seguido del nombre del miembro. Por ejemplo, para dar valor al teléfono del alumno alumno1 con el valor 8999999, se escribirá:

alumno1.telefono = 8999999; Y para guardar la dirección de este mismo alumno, se escribirá:

alumno1.direccion = "Calle 3N # 12 - 35"; Y para guardar una nota en el campo denominado notas, se puede escribir:

alumno1.notas[0] = 4.3; alumno1.notas[1] = 3.0; Esto debido a que el campo “notas” es un vector de flotantes, por tanto hay que indicar también la casilla. El tipo de estructura creado se puede utilizar para definir más variables o estructuras de tipo alumno, así como vectores de estructuras de este tipo. Por ejemplo:

struct alumno clase[300];

En este caso, nuevo_alumno es una estructura de tipo alumno, y clase[300] es un vector de estructuras con espacio para almacenar los datos de 300 alumnos. El código del alumno que se encuentra en la casilla 264 podrá ser accedido como

clase[264].codigo Que podemos representarlo de la siguiente manera:

clase

0

codigo nombres apellidos direccion telefono notas

o

1


O

. . .

264


o

. . .

298


o

299


o

26

Los miembros de las estructuras pueden ser variables de cualquier tipo, incluyendo vectores y matrices, e incluso otras estructuras previamente definidas. Las estructuras se diferencian de los arrays (vectores y matrices) en varios aspectos. Por una parte, los arrays contienen información múltiple pero homogénea, mientras que los miembros de las estructuras pueden ser de naturaleza muy diferente. Además, las estructuras permiten ciertas operaciones globales que no se pueden realizar con arrays. Por ejemplo, la sentencia siguiente:

clase[298] = nuevo_alumno; hace que se copien todos los miembros de la estructura nuevo_alumno en los miembros correspondientes de la estructura clase[298]. Estas operaciones globales no son posibles con arreglos. Una estructura puede inicializarse en el momento de la declaración de modo análogo a como se inicializan los vectores y matrices, por medio de valores encerrados entre llaves { }. Por ejemplo, una forma de declarar e inicializar a la vez la estructura nuevo_alumno podría ser la siguiente: Estructura alumno{


}nuevo_alumno = {46051023, "Mariana", "Suarez Agredo", "Calle 3N # 12 - 35", 8159631}; donde, como no se proporciona valor para las notas, éstas se inicializan a cero.

27

-----------------------------------------------------------------------------------------------------------------------------------------

01. Sean los números complejos z = a + bi y w = c + di. Definimos las siguientes operaciones: Suma. Para sumar dos o más números complejos se suman las partes real e imaginaria de cada uno de ellos. z + w = (a + bi) + (c + di) = (a+c) + (b+d)i Multiplicación. Se aplica la propiedad distributiva teniendo en cuenta que i2 = -1

z * w = (a + bi) * (c + di) = (ac-bd) + (ad+bc)i Elabore los algoritmos necesarios para implementar esas operaciones. ----------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Se manejan varios procesos para operar dos registros. Aquí se verá que es posible efectuar un cálculo matemático y asignar su resultado en el campo correspondiente del registro diseñado para tal fin. 2. Análisis. 2.1. Datos de Entrada: Por cada número complejo: Parte Real (RE),

Parte Imaginaria (IM) . 2.2. Datos de Salida: El número complejo que representa la suma de los complejos z y w à SC .

El número complejo que representa el producto de los complejos z y w à PC. 2.3. Procesos: Antes de identificar los subproblemas es fundamental definir cuáles son los campos del struct o registro. Para este ejemplo son 2: la parte real y la parte imaginaria que conforman un número complejo.

Estructura complejo { real : RE real : IM

} Todos y cada uno de los elementos tipo complejo tendrán esos 2 campos. Identificamos los sub-problemas. • Sub-problema 1: Leer cada número complejo. • Sub-problema 2: Calcular la suma de los 2 números complejos z y w. • Sub-problema 3: Calcular el producto de los 2 números complejos z y w. • Sub-problema 4: Mostrar los números complejos (los originales) y los resultantes. 3. Representación de la alternativa de solución en un estándar. Vista General:

Inicio Leer_complejo(Z) Leer_complejo(W) suma_complejo(Z, W, SC) producto_complejo(Z, W, PC) mostrar_complejo(Z) mostrar_complejo(W) mostrar_complejo(SC) mostrar_complejo(PC)

Fin

28

Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que lee un número complejo

Se tiene como parámetro de entrada/salida un elemento complejo. Y cada uno de sus campos debe leerse en una instrucción por separado. Una vez se ha leído esos valore, el elemento complejo queda “actualizado” con los valores suministrados por el usuario.

procedimiento Leer_complejo(E/S complejo: C) Inicio

Leer C.RE Leer C.IM Fin_Procedimiento ------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que suma 2 números complejos

Se tienen como parámetros de entrada los elemento complejo a sumar (A y B). Se tiene como parámetro de entrada/salida un elemento complejo que almacenará el resultado de la suma (que denominaremos C). Para efectuar esa suma es necesario procesar las partes real e imaginaria por separado. Para obtener la parte real del complejo C, se suman los campos RE de cada complejo A y B, almacenando el resultado en el campo RE del complejo C. C.RE = A.RE + B.RE Para obtener la parte imaginaria del complejo C, se suman los campos IM de cada complejo A y B, almacenando el resultado en el campo IM del complejo C. C.IM = A.IM + B.IM Una vez hechas estas operaciones, el complejo C queda “actualizado” con el resultado.

procedimiento suma_complejo(E complejo: A, B; E/S complejo: C) Inicio

C.RE = A.RE + B.RE C.IM = A.IM + B.IM

Fin_Procedimiento ------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: procedimiento que multiplica 2 números complejos

Se tienen como parámetros de entrada los elemento complejo a multiplicar (A y B). Se tiene como parámetro de entrada/salida un elemento complejo que almacenará el resultado de la multiplicación (que denominaremos C). Para efectuar esa multiplicación es necesario procesar las partes real e imaginaria por separado. Para obtener la parte real del complejo C:

Se multiplican los campos RE de cada complejo A y B. después se multiplican los campos IM de cada complejo A y B. Posteriomente se efectúa la resta de esos 2 valores obtenidos, almacenando el resultado en el campo RE del complejo C.

C.RE = (A.RE*B.RE) - (A.IM*B.IM)

29

Para obtener la parte imaginaria del complejo C: Se multiplica el campo RE de A por el campo IM de B Se multiplica el campo IM de A por el campo RE de B

Posteriomente se efectúa la suma de esos 2 valores obtenidos, almacenando el resultado en el campo IM del complejo C.

C.IM = (A.RE*B.IM) + (A.IM*B.RE)

Una vez hechas estas operaciones, el complejo C queda “actualizado” con el resultado. procedimiento producto_complejo(E complejo: A, B; E/S complejo: C) Inicio

C.RE = (A.RE*B.RE) - (A.IM*B.IM) C.IM = (A.RE*B.IM) + (A.IM*B.RE)

Fin_Procedimiento ------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 4: procedimiento que muestra un número complejo

Se tiene como parámetro de entrada un elemento complejo. Y cada uno de sus campos debe imprimirse en una instrucción por separado.

procedimiento mostrar_complejo(E/S complejo: C) Inicio

Imprimir C.RE Imprimir C.IM Fin_Procedimiento -------------------------------------------------------------------------------------------------------------------------

30

----------------------------------------------------------------------------------------------------------------------------------------- 02. En un curso de 40 alumnos la nota definitiva se calcula así:

La nota de quices vale el 10%. El primer parcial vale el 20%. El segundo parcial vale el 30%. El tercer parcial vale el 40%.

Por cada estudiante leeremos seis datos: El código del estudiante, el nombre y las 4 notas en el orden antes descrito. Elabore los algoritmos necesarios para resolver lo siguiente: Calcular la nota definitiva de cada alumno y la imprima en forma ordenada de mayor a menor, junto con el respectivo código y el nombre del estudiante. ----------------------------------------------------------------------------------------------------------------------------------------- 1. Dominio del Problema. Se manejan varios procesos para un conjunto de registros, los cuales estarán almacenados en un vector. Aquí se verá que es posible efectuar un cálculo matemático y asignar su resultado en el campo correspondiente del registro diseñado para tal fin. 2. Análisis. 2.1. Datos de Entrada: Por cada estudiante leeremos:

el código (COD), el nombre (NOM), nota de quices (Q), primer parcial (P1), segundo parcial (P2) y tercer parcial (P3).

2.2. Datos de Salida: Vector de registros de los estudiantes ordenado de mayor a menor en razón a la nota definitiva à A 2.3. Procesos: Antes de identificar los subproblemas es fundamental definir cuáles son los campos del struct o registro. Para este ejemplo son 3: el código del estudiante, el nombre del estudiante y la nota definitiva.

Estructura estudiante { cadena : codigo cadena : nombre real : definitiva

} Todos y cada uno de los elementos tipo estudiante tendrán esos 3 campos. Identificamos los sub-problemas: Como se requiere manejar una cantidad considerable de alumnos y la información de cada alumno se guarda en un registro individual, no tiene sentido declarar muchas variables sueltas tipo estructura, por lo tanto se requiere manejar un vector de registros y eso permite un manejo mucho más fácil de ese conjunto de datos. • Sub-problema 1: Cargar el vector de registros con los N estudiantes requeridos. • Sub-problema 2: Ordenar el vector de registros de mayor a menor teniendo como campo clave la nota

definitiva. • Sub-problema 3: Ahora se procede a “mostrar” el vector de registros. 3. Representación de la alternativa de solución en un estándar. Vista General: Inicio

estudiante V[k] //se crea un vector de registros llamado V con tamaño k cargar_vector_registros( V , k) ordenar_vector_registros( V , k) mostrar_vector_registros( V , k)

Fin

31

Vista detallada (subprogramas): Solución al sub-problema 1: procedimiento que carga el vector de registros

Se tiene como parámetro de entrada/salida el vector de registros el cual llamaremos Ve, el cual tiene en cada una de sus casillas un registro con 3 campos: el código del estudiante, el nombre del estudiante y la nota definitiva. Se tiene un parámetro de entrada tVe que indica el tamaño del vector. Para llenar ese vector usamos un ciclo Para con i=0 hasta tVe-1 . Al interior de ese ciclo se efectúa lo siguiente:

Se lee el código del estudiante y se almacena en el vector en la casilla i en el campo código, así: Leer Ve[i].codigo

Se lee el nombre del estudiante y se almacena en el vector en la casilla i en el campo código, así: Leer Ve[i].nombre

Se lee la nota de quices: Leer Q Se lee la nota del parcial 1: Leer P1 Se lee la nota del parcial 2: Leer P2 Se lee la nota del parcial 3: Leer P3 Ahora se calcula definitiva:

Ve[i].definitiva = (0.1*Q) + (0.2*P1) + (0.3*P2) + (0.4*P3)

Una vez terminado el ciclo, se tendrá el vector cargado con cada uno de los registros correspondientes a los estudiantes

procedimiento cargar_vector_registros (E/S estudiante: Ve; E entero: tVe) Inicio Para (i=0 hasta tVe-1) hacer

Leer Ve[i].codigo Leer Ve[i].nombre Leer Q Leer P1 Leer P2 Leer P3 Ve[i].definitiva = (0.1*Q) + (0.2*P1) + (0.3*P2) + (0.4*P3)

Fin_Para Fin_Procedimiento ------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 2: procedimiento que ordena el vector de registros de mayor a menor teniendo como campo clave la nota definitiva

Se tiene como parámetro de entrada/salida el vector de registros el cual llamaremos Ve, el cual tiene en cada una de sus casillas un registro con 3 campos: el código del estudiante, el nombre del estudiante y la nota definitiva. Se tiene un parámetro de entrada tVe que indica el tamaño del vector. Para ordenar de mayor a menor de este vector, se utiliza el método burbuja ya descrito en la sección de vectores. El campo clave es la nota definitiva y la expresión de comparación debe ser: Si (Ve[k].definitiva > Ve[i].definitiva) entonces intercambie los registros

32

procedimiento ordenar_vector_registros (E/S estudiante: Ve; E entero: tVe) Inicio

Para (i=0 hasta tVe-2) hacer Para (k=i+1 hasta tVe-1) hacer

Si(Ve[k].definitiva > Ve[i].definitiva) entonces TEM = Ve[i]

Ve[i] = Ve[k] Ve[k] = TEM

Fin_Si Fin_Para Fin_Para Fin_Procedimiento ------------------------------------------------------------------------------------------------------------------------- Solución al sub-problema 3: procedimiento que muestra el vector de registros

Se tiene como parámetro de entrada/salida el vector de registros el cual llamaremos Ve, el cual tiene en cada una de sus casillas un registro con 3 campos: el código del estudiante, el nombre del estudiante y la nota definitiva. Se tiene un parámetro de entrada tVe que indica el tamaño del vector. Para ello necesitamos un ciclo FOR que va de 0 a (tVe-1). Al interior del ciclo imprime la respectiva casilla del vector (cuyo valor lo controla la variable i).

procedimiento mostrar_vector_registros (E/S estudiante: Ve; E entero: tVe) Inicio

Para ( i=0 hasta tVe-1 ) hacer

Imprimir Ve[i].codigo Imprimir Ve[i].nombre Imprimir Ve[i].definitiva

Fin_para

Fin_Procedimiento

----------------------- FIN DEL DOCUMENTO

guia 05 completa 2016 - unicauca.edu.co

Documents