ARRAYS EN C# Vector m Acceso al cuarto elemento es m[3] m[0] m[1] m[2] m[3] m[4] m[5] m[6] m[7]

Transcripción

1 ARRAYS EN C# I. I N T R O D U C C I Ó N En las sesiones anteriores, los datos manejados en los programas han sido datos simples (carácter, entero, reales). En un gran número de problemas es necesario manejar un conjunto de datos más o menos grande que están relacionados entre sí, de tal forma que constituyen una unidad para su tratamiento. Por ejemplo si se quiere manipular una lista de 100 edades de personas, es conveniente tratar el conjunto de datos de forma unitaria en lugar de utilizar 100 variables para cada dato simple.. Un conjunto de datos homogéneo que se tratan como una sola unidad se denomina estructura de datos. Si una estructura de datos reside en memoria central (memoria RAM), se llama estructura de datos interna. Recíprocamente si reside en un soporte externo (disquete, disco, cd, memoria USB, cinta, se denomina estructura de datos externa. La estructura de datos más importante desde el punto de vista de utilización es un arreglo, que es implementado en la totalidad de lenguajes de programación. Esta estructura corresponde con los conceptos matemáticos de vector, matriz o poliedro. I I. D E F I N I C I O N Un array o arreglo es una secuencia de datos del mismo tipo (estructura homogénea), los datos se llaman elementos del arreglo enumerados consecutivamente 0,1,2,3,. y se encuentran almacenados consecutivamente en memoria. Cada elemento puede ser accedido directamente por el nombre de la variable matriz seguido de uno o más subíndices. array m Un arreglo puede contener, por ejemplo, la edad de los estudiantes de una clase, las horas diarias laboradas por un trabajador, el número de estudiantes por ciclo de Ingeniería de Sistemas, etc. En general, la representación de un arreglo se hace mediante variables suscritas o de subíndices y pueden tener una o varias dimensiones (subíndices). I I I. C L A S I F I C A C I Ó N D E A R R A Y S Los Arrays se dividen en 2 grupos, los vectores y las matrices. Los vectores son arreglos que contienen una sola dimensión y las matrices 2 o más dimensiones. ARRAYS UNIDIMENSIONALES (Vectores) 1. DEFINICIÓN: Son arreglos de una sola dimensión, tienen un solo índice. Cada elemento del vector se accesa mediante su nombre seguido del número correspondiente al subíndice que se escribe entre corchetes. Por ejemplo, supongamos que tenemos un vector de entero llamado m, el cual contiene 8 elementos. Estos elementos se identificaran de la siguiente forma: Vector m Acceso al cuarto elemento es m[3] m[0] m[1] m[2] m[3] m[4] m[5] m[6] m[7] Elementos del Vector Subíndices El arreglo unidimensional tiene ocho elementos: m[0] contiene 5, m[1] contiene 4, m[2] contiene 8, m[3] contiene 7, m[4] contiene 3, m[5] contiene 2, m[6] contiene 1, m[7] contiene 6. El diagrama representa realmente una región de la memoria de la computadora, ya que un arreglo se almacena siempre con sus elementos en una secuencia de posiciones de memoria contigua. En C#, los índices del arreglo siempre tienen como limite inferior 0, y como índice superior el tamaño del arreglo menos 1. Igual que sucede con otras variables, antes de utilizar un arreglo primero hay que declararla. La declaración de un arreglo especifica el nombre del arreglo y el tipo de elemento de la misma. Para crear y utilizar un arreglo hay que realizar tres operaciones: declararla, crearla e iniciarla. CURSO: Algoritmos Avanzados y Estructura de Datos 1 DOCENTE: Ing. CIP Fabián Silva Alvarado

2 2. DECLARAR Y CREAR UN ARREGLO UNIDIMENSIONAL La declaración de un arreglo es muy similar a la de una variable, crear un arreglo significa reservar la cantidad de memoria necesaria para contener todos sus elementos y asignar al nombre del arreglo una referencia a ese bloque. Esto puede expresarse genéricamente así: tipodato[] nombrevariable = new tipodato[tamaño]; tipodato indica el tipo de datos de los elementos del arreglo, que pueden ser de cualquier tipo primitivo o referenciado; los corchetes modifican la definición normal del identificador para que sea interpretado por el compilador como un arreglo. nombrevariable es un identificador que nombra al arreglo, Operador new significa que C# implementa los arreglos como objetos, por lo tanto serán tratadas como cualquier otro objeto. y tamaño es una expresión entera que especifica los números de elementos Las siguientes líneas de código crean los arreglos de una dimensión declaradas en el ejemplo anterior: int[] m = new int [5]; float[] temp = new float[30]; Crea un vector identificado por m con 5 elementos de tipo int; es decir, puede almacenar 5 valores enteros; el primer elemento es m[0], el segundo es m[1], y el ultimo es m[4]. Crea un vector de temperaturas de 30 elementos de tipo float. Vector m m[0] m[1] m[2] m[3] m[4] Vector temp temp [0] temp [1] temp [28] temp [29] Elementos del Vector Subíndices Más Ejemplos: int[] Edad = new int[100]; Declara un arreglo llamado Edad que contiene 100 elementos de tipo enteros (int). String[] Nombres = new String[25] ; Declara un arreglo llamado Nombres que puede almacenar 25 nombres. double[] Salario = new double[50] ; Declara un arreglo llamado Salario que puede almacenar 25 elementos de tipo doublé. 3. INICIAR UN ARREGLO UNIDIMENSIONAL Un arreglo es un objeto, por lo tanto, cuando es creada, sus elementos son automáticamente iniciados, igual que sucedía con las variables miembro de una clase. Si el arreglo es numérico sus elementos son iniciados a 0 y si no es numérico, a un valor análogo a 0; por ejemplo un elemento booleano es inicializado a false y las referencias a objetos a null. Si deseamos iniciar un arreglo con otros valores diferentes a los predeterminados, podemos hacerlo de la siguiente forma: double[] ingresos =1000,5000,7000,10000,12000,15000; el ejemplo crea un arreglo ingresos de tipo double con tantos elementos como valores se hayan especificado entre llaves. Para practicar la teoría vamos a realizar un programa que asigne datos a un arreglo unidimensional miarreglo de nelementos y, a continuación, como comprobación del trabajo realizado, escriba el contenido de dicho arreglo. La solución será similar a la siguiente: CURSO: Algoritmos Avanzados y Estructura de Datos 2 DOCENTE: Ing. CIP Fabián Silva Alvarado

3 Para ello, en primer lugar definimos la variable tamaño para fijar el número de elementos del arreglo, creamos el arreglo miarreglo con el tamaño que será ingresado por teclado. int tamaño=0; Console.Write("\nIndique el Tamaño del Arreglo: "); tamaño=int.parse(console.readline()); //declarar y crear el arreglo int[] miarreglo=new int[tamaño]; El paso siguiente es asignar un valor desde el teclado a cada elemento del arreglo. for (int i = 0; i < tamaño; i++) Console.Write("miarreglo["+ i +"] = "); miarreglo[i]= int.parse(console.readline()); Una vez leído los elementos para el arreglo visualizamos para comprobar el trabajo realizado. Console.Write("\nElementos del arreglo\n"); Console.WriteLine(); for (int i = 0; i < tamaño; i++) Console.Write(miarreglo[i]+" "); El Programa completo se muestra a continuación: class Program static void Main(string[] args) int tamaño=0; Console.Write("\nIndique el Tamaño del Arreglo: "); tamaño=int.parse(console.readline()); Console.WriteLine(); //declarar y crear el arreglo int[] miarreglo=new int[tamaño]; //asignar datos for (int i = 0; i < tamaño; i++) Console.Write("miarreglo["+ i +"] = "); miarreglo[i]= int.parse(console.readline()); //visualizar los elementos del arreglo Console.Write("\nElementos del arreglo\n"); Console.WriteLine(); for (int i = 0; i < tamaño; i++) Console.Write(miarreglo[i]+" "); Console.Read(); CURSO: Algoritmos Avanzados y Estructura de Datos 3 DOCENTE: Ing. CIP Fabián Silva Alvarado

4 4. TAMAÑO DE UN ARREGLO. Atributo length Java considera cada arreglo como un objeto, debido a ello se puede conocer el numero de elementos de un arreglo accediendo al campo length. Por ejemplo, la última parte del ejercicio anterior podríamos escribirla también así. //visualizar los elementos del arreglo Console.Write("\nElementos del arreglo\n"); Console.WriteLine(); for (int i = 0; i < miarreglo.length; i++) Console.Write(miarreglo[i]+" "); APLICACIONES EMPLEANDO ARRAYS UNIDIMENSIONALES 1. Programa que incluye un arreglo con elementos inicializados con valores diferentes a los predeterminados: Diseñar la siguiente interfaz y agregue el siguiente código para el botón. //Código para el botón 2. Programa que incluye un arreglo de enteros y los datos son asignados directamente en el código: CURSO: Algoritmos Avanzados y Estructura de Datos 4 DOCENTE: Ing. CIP Fabián Silva Alvarado

5 //Código para el botón También podemos hacer una asignación con números aleatorios 3. Programa que incluye un arreglo de enteros y los datos son asignados desde un cuadro de texto: Diseñe el formulario teniendo en cuenta el nombre de los controles Programa funcionando //Código del programa CURSO: Algoritmos Avanzados y Estructura de Datos 5 DOCENTE: Ing. CIP Fabián Silva Alvarado

6 Modifique el código de tal manera que solo permita ingresar números enteros. También tener en cuenta el tamaño del arreglo para el ingreso de datos. Ahora implemente lo siguiente métodos: - Suma de los elementos ingresados al arreglo: - Hallar el Máximo Valor: COMPLETE LOS METODOS PARA OBTENER EL PROMEDIO Y EL VALOR MINIMO. Ahora completamos el código para el botón Calcular: Ahora complete el código para el Botón Nuevo y para el botón Salir, guarde y pruebe su aplicación CURSO: Algoritmos Avanzados y Estructura de Datos 6 DOCENTE: Ing. CIP Fabián Silva Alvarado

7 CREANDO UN ARREGLO DE 3 COLUMNAS Diseño de la Interfaz Programa en Ejecución //código de la aplicación namespace Arreglos_04 public partial class FrmListas : Form public FrmListas() InitializeComponent(); static int tam = 50; //crear los arreglos String[] codigo = new String[tam]; String[] vendedor = new String[tam]; double[] ventames = new double[tam]; int indice = 0; //var. utilizado para el indice de los elem. double suma_ventas = 0; //var. utilizado para acumular las ventas. private void btnagregar_click(object sender, EventArgs e) //AGREGAR AL ARREGLO codigo[indice] = textbox1.text; vendedor[indice] = textbox2.text; ventames[indice] = double.parse(textbox3.text); //ACUMULA suma_ventas += ventames[indice]; //agregar a las listas listbox1.items.add(codigo[indice]); listbox2.items.add(vendedor[indice]); listbox3.items.add(string.format("0:c", ventames[indice])); // indice++; //INCREMENTAR INDICE //muestra el total de las ventas textbox4.text = string.format("0:c", suma_ventas); this.limpia_controles(); public void limpia_controles() textbox1.text = ""; textbox2.text = ""; textbox3.text = ""; textbox1.focus(); CURSO: Algoritmos Avanzados y Estructura de Datos 7 DOCENTE: Ing. CIP Fabián Silva Alvarado

8 private void btnmayor_click(object sender, EventArgs e) int pos = 0; double max = ventames[0]; for (int i = 1; i < indice; i++) if (max < ventames[i]) max = ventames[i]; pos = i; MessageBox.Show(vendedor[pos] + ", acumuló: " + string.format("0:c", max), "Mayor Venta Mes", MessageBoxButtons.OK, MessageBoxIcon.Information); private void btnmenor_click(object sender, EventArgs e) int pos = 0; double min = ventames[0]; for (int i = 1; i < indice; i++) if (min > ventames[i]) min = ventames[i]; pos = i; MessageBox.Show(vendedor[pos] + ", acumuló: " + string.format("0:c", min), "Menor Venta Mes", MessageBoxButtons.OK, MessageBoxIcon.Information); private void btnpromedio_click(object sender, EventArgs e) double sum = 0, prom = 0; for (int i = 0; i < indice; i++) sum += ventames[i]; prom = sum / indice; MessageBox.Show("Promedio Ventas del Mes: " + string.format("0:c", prom), "Ventas", MessageBoxButtons.OK, MessageBoxIcon.Information); private void btnsalir_click(object sender, EventArgs e) this.close(); CURSO: Algoritmos Avanzados y Estructura de Datos 8 DOCENTE: Ing. CIP Fabián Silva Alvarado

9 ALGORITMO DE BUSQUEDA BUSQUEDA LINEAL Consiste en encontrar un elemento determinado dentro de una colección dada. La búsqueda se realiza sobre una estructura de datos de tamaño fijo y conocido, por ejemplo, un vector. Los algoritmos sirven para hacer búsquedas sobre cualquier tipo de datos, siempre que sea posible realizar comparaciones ( igualdad, menor que ) sobre este tipo. Buscar si el elemento 14 se encuentra en la lista A. Clave= A[0] A[1] A[2] A[3] A[4] A[5] Valor devuelto, índice 3 La codificación en C # public void busqueda_lineal() rpta = InputBox.Show("Ingrese el numero a buscar", "Busqueda", "", new InputBoxValidatingHandler(inputBox_Validating)); double clave = double.parse(rpta.text); int i = 0; bool encontrado; for (i = 0; i < indice; i++) if (clave == miarreglo[i]) encontrado = true; break; if (encontrado==true) MessageBox.Show("Dato Encontrado en la pos: "+ i, "Actualización", MessageBoxButtons.OK, MessageBoxIcon.Information); else MessageBox.Show("Dato no encontrado", "Actualización", MessageBoxButtons.OK, MessageBoxIcon.Error); BUSQUEDA BINARIA El método más eficiente de búsqueda en una tabla secuencial sin utilizar índices o tablas auxiliares es la búsqueda binaria. Para poder llevarse acabo esta, necesita tener el arreglo ordenado. Básicamente, el argumento se compara con la llave del elemento intermedio de la tabla. Si son iguales, la búsqueda termina exitosamente; en caso contrario, debe buscarse en la mitad superior o inferior en la tabla en una forma similar. En un arreglo, donde los índices de la lista son bajo = 0 y alto = n-1, donde n es el numero de elementos del arreglo. 1. Calcular el índice del punto central del array central = (bajo+alto)/2 división entera 2. Comparar el valor de este elemento central con la clave Clave Clave Clave bajo central alto bajo central alto bajo central alto Clave Encontrada Búsqueda lista inferior Búsqueda lista superior CURSO: Algoritmos Avanzados y Estructura de Datos 9 DOCENTE: Ing. CIP Fabián Silva Alvarado

10 Sea el arreglo de enteros A: Buscar si el elemento 40 se encuentra en la lista A. Clave= A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] bajo = 0 alto = 8 central = bajo+alto/2 0+8/2 = 4 clave (40) > A[4] (12) Buscar en la sublista derecha A[5] A[6] A[7] A[8] bajo = 5 alto = 8 central = bajo+alto/2 5+8/2 = 6 clave (40) > A[6] (25) Buscar en la sublista derecha A[7] A[8] bajo = 7 alto = 8 central = bajo+alto/2 7+8/2 = 7 clave (40) = A[7] (40) El Algoritmo ha requerido tres comparaciones frente a ocho comparaciones que se hubieran realizado con la búsqueda secuencial. La codificación en C # public void busqueda_binaria() rpta = InputBox.Show("Ingrese el numero a buscar", "Busqueda", "", new InputBoxValidatingHandler(inputBox_Validating)); double clave = double.parse(rpta.text); int bajo, alto, central; bajo = 0; alto = indice - 1; central = (bajo + alto) / 2; while ((bajo <= alto) && (miarreglo[central]!= clave)) if (clave < miarreglo[central]) alto = central - 1; else bajo = central + 1; central = (bajo + alto) / 2; if (miarreglo[central]==clave) MessageBox.Show("Dato Encontrado en la pos: " + central, "Búsqueda", MessageBoxButtons.OK, MessageBoxIcon.Information); else MessageBox.Show("Dato no encontrado", "Búsqueda", MessageBoxButtons.OK, MessageBoxIcon.Error); CURSO: Algoritmos Avanzados y Estructura de Datos 10 DOCENTE: Ing. CIP Fabián Silva Alvarado

11 ALGORITMOS DE ORDENAMIENTO Arrays I V. I N T R O D U C C I Ó N Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar. En este caso, nos servirán para ordenar vectores o matrices con valores asignados aleatoriamente. Nos centraremos en los métodos más populares, analizando la cantidad de comparaciones que suceden, el tiempo que demora y revisando el código, escrito en Java, de cada algoritmo. Este informe nos permitirá conocer más a fondo cada método distinto de ordenamiento, desde uno simple hasta el más complejo. Se realizaran comparaciones en tiempo de ejecución, pre-requisitos de cada algoritmo, funcionalidad, alcance, etc. V. T I P O S D E A L G O R I T M O S Para poder ordenar una cantidad determinada de números almacenadas en un vector o matriz, existen distintos métodos (algoritmos) con distintas características y complejidad. Existe desde el método mas simple, como el Bubblesort (o Método Burbuja), que son simples iteraciones, hasta el Quicksort (Método Rápido), que al estar optimizado usando recursión, su tiempo de ejecución es menor y es más efectivo METODOS ITERATIVOS Estos métodos son simples de entender y de programar ya que son iterativos, simples ciclos y sentencias que hacen que el vector pueda ser ordenado. Dentro de los Algoritmos iterativos encontramos: Burbuja Inserción Selección Shellsort METODO DE LA BURBUJA El método de la burbuja es uno de los más simples, es tan fácil como comparar todos los elementos de una lista contra todos, si se cumple que uno es mayor o menor a otro, entonces los intercambia de posición. Por ejemplo, imaginemos que tenemos los siguientes valores: Lo que haría una burbuja simple, seria comenzar recorriendo los valores de izq. a derecha, comenzando por el 5. Lo compara con el 6, con el 1, con el 0 y con el 3, si es mayor o menor (dependiendo si el orden es ascendiente o descendiente) se Intercambian de posición. Luego continua con el siguiente, con el 6, y lo compara con todos los elementos de la lista, esperando ver si se cumple o no la misma condición que con el primer elemento. Así, sucesivamente, hasta el último elemento de la lista. 1º. BURBUJA SIMPLE Como lo describimos en el ítem anterior, la burbuja mas simple de todas es la que compara todos con todos, generando comparaciones extras, por ejemplo, no tiene sentido que se compare con sigo mismo o que se compare con los valores anteriores a el, ya que supuestamente, ya están ordenados. public void orden_asc(int[] vector, int nelem) for (int i = 1; i < nelem; i++) for (int j = 0; j < (nelem - 1); j++) if (vector[j] > vector[j + 1]) int temp = vector[j]; vector[j] = vector[j + 1]; vector[j + 1] = temp; CURSO: Algoritmos Avanzados y Estructura de Datos 11 DOCENTE: Ing. CIP Fabián Silva Alvarado

12 2º. BURBUJA OPTIMIZADA Una nueva versión del método de la burbuja seria limitando el número de comparaciones, es inútil que se compare consigo misma. Si tenemos una lista de elementos, entonces son comparaciones que están sobrando. Imaginemos si tenemos de elementos. El método seria mucho mas optimo con n comparaciones menos (n = total de elementos). Si a este cambio anterior le sumamos otro cambio, el hecho que los elementos que están detrás del que se esta comparando, ya están ordenados, las comparaciones serian aun menos y el método seria aun mas efectivo. Si tenemos una lista de 10 elementos y estamos analizando el quinto elemento, que sentido tiene que el quinto se compare con el primero, el segundo o el tercero, si supuestamente, ya están ordenados. Entonces optimizamos mas aun el algoritmo, quedando nuestra versión final del algoritmo optimizado de la siguiente manera: public void orden_asc(int[] vector, int nelem) for (int i = 0; i < nelem; i++) for (int j = 0; j < i; j++) if (vector[i] < vector[j]) int temp = vector[j]; vector[j] = vector[i]; vector[i] = temp; METODO DE INSERCION El bucle principal de la ordenación por inserción va examinando sucesivamente todos los elementos de la matriz desde el segundo hasta el n-ésimo, e inserta cada uno en el lugar adecuado entre sus predecesores dentro de la matriz. public void orden_asc(int[] vector, int nelem) for (int i = 1; i < nelem; i++) int temp = vector[i]; int j = i - 1; while (j >= 0 && temp < vector[j]) vector[j + 1] = vector[j]; j--; vector[j + 1] = temp; METODO SHELLSORT Este método es una mejora del algoritmo de ordenamiento por Inserción (Insertsort). Si tenemos en cuenta que el ordenamiento por inserción es mucho más eficiente si nuestra lista de números esta semi-ordenada y que desplaza un valor una única posición a la vez. Durante la ejecución de este algoritmo, los números de la lista se van casi-ordenando y finalmente, el ultimo paso o función de este algoritmo es un simple método por inserción que, al estar casi-ordenados los números, es más eficiente. public void orden_asc(int[] vector, int nelem) for (int incremento = nelem / 2; incremento > 0; incremento = (incremento == 2? 1 : (int)math.round(incremento / 2.2))) for (int i = incremento; i < nelem; i++) for (int j = i; j >= incremento && vector[j - incremento] > vector[j]; j -= incremento) CURSO: Algoritmos Avanzados y Estructura de Datos 12 DOCENTE: Ing. CIP Fabián Silva Alvarado

13 int temp = vector[j]; vector[j] = vector[j - incremento]; vector[j - incremento] = temp; OPERACIONES CON ARREGLOS: I. SUMA DE 2 ARREGLOS A B C i= i= i= = 35. i=n-1 X Y X+Y C[i]= A[i] + B[i] En Código: for(i=0;i<n;i++) C[i]= A[i] + B[i]; II. PRODUCTO DE 2 ARREGLOS A B C i= i= i=2 20 * 15 = i=n-1 X Y X*Y En Código: C[i]= A[i] * B[i] for(i=0;i<n;i++) C[i]= A[i] * B[i]; III. DIFERENCIA DE 2 ARREGLOS En Código: for(i=0;i<n;i++) C[i]= A[i] - B[i]; IV. DIVISION DE 2 ARREGLOS En Código: for(i=0;i<n;i++) C[i]= A[i] / B[i]; CURSO: Algoritmos Avanzados y Estructura de Datos 13 DOCENTE: Ing. CIP Fabián Silva Alvarado

14 Ejemplo: Imprimir la planilla de salarios de los trabajadores de una empresa de acuerdo al siguiente formato: PLANILLA DEL MES DE JULIO 2009 CODIGO APELLIDOS Y NOMBRES SAL_BAS BONIF SAL_PARC DSCTO SAL_NETO **** ****************** ****.** ***.** ****.** ***.** ****.** **** ****************** ****.** ***.** ****.** ***.** ****.** **** ****************** ****.** ***.** ****.** ***.** ****.** **** ******************* ****.** ***.** ****.** ***.** ****.** TOTALES *****.** ******.** Especificaciones: a) Cada trabajador se identifica con su nombre y su código b) Cada Trabajador tiene un salario básico (SAL_BAS) entre 1000 y c) Cada trabajador tiene una bonificación (BONIF) del 12% del Salario Basico d) El Salario Parcial (SAL_PARC) es igual a SAL_BAS+ BONIF. e) Cada trabajador tiene un descuento (DSCTO) del 9% del SAL_PARC f) El Salario Neto (SAL_NETO) es igual a SAL_PARC DSCTO. i=0 i=1 i=2... i=99 Codigo[i] Ape_Nomb[i] Sal_Bas[i] Bonif[i] Sal_Parc[i] Descuento[i] Sal_Neto[i] Implementar en C# PRACTICA DE ARREGLOS 1. Desarrollar una solución que permita ingresar y almacenar las notas de 4 prácticas de un estudiante. Determinar el promedio de cada alumno sabiendo que se duplica su nota más alta y se elimina la nota mas baja. Mostrar el promedio redondeado a 1 decimal. Validar el ingreso de datos. CALCULO DEL PROMEDIO Nota[1]= 15 Nota[2]= 18 Nota[3]= 10 Nota[4]= 14 Notas Ingresadas Estudiante: Nota menor: 10.0 Nota Mayor: 18.0 El Promedio es: 16.3 //(15+(2*18)+14)/4 2. Desarrollar un programa que imprima los salarios netos junto con los demás importes necesarios para n obreros de una empresa quienes están identificados por un código y se rigen a las siguientes condiciones: a. Cada trabajador tiene una tarifa por hora de S/ b. El salario básico se calcula en base a las horas laboradas en el mes y la tarifa x hora. c. Todos reciben una bonificación del 20% con respecto al Salario Básico d. Salario Parcial es igual a Salario Básico + bonificación e. Descuento del 12% del Salario Parcial por concepto de AFP f. Salario Neto es igual a Salario Parcial Descuento CURSO: Algoritmos Avanzados y Estructura de Datos 14 DOCENTE: Ing. CIP Fabián Silva Alvarado

15 El formato de salida es: PLANILLA DEL MES DE MAYO 2009 Código Trabajador Horas_Lab Sal_Basico Bonific Sal_Parc Desc AFP Sal_Neto **** ******************** ** ****.** ***.** ****.** ***.** ****.** **** ******************** ** ****.** ***.** ****.** ***.** ****.** **** ******************** ** ****.** ***.** ****.** ***.** ****.** **** ******************** ** ****.** ***.** ****.** ***.** ****.** TOTAL PLANILLA: ****.** *****.** - Agregar una opción para realizar una búsqueda por código del trabajador empleando el algoritmo de búsqueda lineal - Agregue una opción para realizar el ordenamiento por Nombre del trabajador en forma Ascendente utilizando el Algoritmo de Inserción - Agregue una opción para realizar el ordenamiento por Salario Neto del trabajador en forma Descendente utilizando el Algoritmo de Inserción - Ubique a la persona que obtuvo un mayor sueldo neto. 3. Determinar el promedio final de cada estudiante para el curso de Algoritmos Avanzados y mostrar el resultado de acuerdo al siguiente formato: NOTAS FINALES DEL CURSO DE FUNDAMENTOS DE PROGRAMACION Código Apellidos y Nombres EP EF PP PF Observación **** ******************** ** ** ** **.* ********* **** ******************** ** ** ** **.* ********* **** ******************** ** ** ** **.* ********* **** ******************** ** ** ** **.* ********* DONDE: EP: Examen Parcial EF: Examen Final PP: Promedio de Practicas El programa trabajara bajo las siguientes condiciones: a. El Promedio Final se calcula en función a: PF=(2EP+3EF+2PP)/7 b. Completa la columna observación según sea el caso: APROBADO, APLAZADO o DESAPROBADO i. Un estudiante aprueba el curso si su promedio final es mayor o igual a 10.5 ii. Un estudiante tiene derecho a ir a examen de aplazados si su promedio final es mayor o igual a 7 iii. Un estudiante desaprueba el curso si su promedio es menor a 7 c. Al final mostrar un resumen indicando: i. El Numero de Estudiantes procesados, aprobados, desaprobados y cuantos van a aplazados. d. Agregar una opción para realizar una búsqueda por código del trabajador empleando el algoritmo de búsqueda Binaria e. Agregue una opción para realizar el ordenamiento por Apellidos y Nombres del Estudiante en forma Ascendente utilizando el Algoritmo SHELLSORT f. Agregue una opción para realizar el ordenamiento por Apellidos y Nombres del Estudiante en forma Descendente utilizando el Algoritmo SHELLSORT g. Muestre en un cuadro de mensaje a los 2 Primeros Puestos h. Muestre en un cuadro de mensaje a los 2 Últimos Puestos i. Agregue una opción para poder realizar un filtrado con todos los datos del estudiante según sea la observación del estudiante. CURSO: Algoritmos Avanzados y Estructura de Datos 15 DOCENTE: Ing. CIP Fabián Silva Alvarado