Arrays

ARRAYS EN C#

I. INTRODUCCIÓ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.

II. DEFINICION
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

0 1 2 3 4 5 6 7 8 9

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).

III. CLASIFICACIÓN DE ARRAYS

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]

5 4 8 7 3 2 1 6 Elementos del Vector

m[0] m[1] m[2] m[3] m[4] m[5] m[6] m[7] 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
 Arrays

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 Crea un vector de temperaturas de 30

tipo int; es decir, puede almacenar 5 valores enteros; elementos de tipo float.
el primer elemento es m[0], el segundo es m[1],… y el
ultimo es m[4].

Vector m Vector temp Elementos

del Vector
7 2 8 5 3 16.3 18.7 … 19.3 17.4
m[0] m[1] m[2] m[3] m[4] Subíndices
temp [0] temp [1] temp [28] temp [29]
…

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
 Arrays

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
 Arrays

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
 Arrays

//Código para el botón

También
Tambiénpodemos
podemos hacer una asignación
hacer una asignacióncon
con
números
números aleatorios
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 Programa funcionando

los controles

//Código del programa

CURSO: Algoritmos Avanzados y Estructura de Datos 5 DOCENTE: Ing. CIP Fabián Silva Alvarado
 Arrays

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
 Arrays

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
 Arrays

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
 Arrays

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=14 4 8 3 14 5 7
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
 Arrays

Sea el arreglo de enteros A:

Buscar si el elemento 40 se encuentra en la lista A.

-8 4 5 9 12 18 25 40 60 bajo = 0
Clave=40
alto = 8
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]

central = bajo+alto/2 0+8/2 = 4 clave (40) > A[4] (12)

Buscar en la sublista derecha

18 25 40 60 bajo = 5
A[5] A[6] A[7] A[8] alto = 8

central = bajo+alto/2 5+8/2 = 6 clave (40) > A[6] (25)

Buscar en la sublista derecha

40 60 bajo = 7
A[7] A[8] 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
 Arrays

ALGORITMOS DE ORDENAMIENTO
IV. INTRODUCCIÓ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. TIPOS DE ALGORITMOS
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.
2.1. 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:

5 6 1 0 3
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
 Arrays

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 10.000 elementos, entonces son 10.000 comparaciones que
están sobrando. Imaginemos si tenemos 1.000.000 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
 Arrays

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=0 10 20 30
i=1 15 10 25
i=2 20 + 15 = 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=0 10 20 200
i=1 15 10 150
i=2 20 * 15 = 300
.
.
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];
}

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
 Arrays

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 2000.
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.

Codigo[i] Ape_Nomb[i] Sal_Bas[i] Bonif[i] Sal_Parc[i] Descuento[i] Sal_Neto[i]

i=0
i=1
i=2
.
.
.
i=99

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:

15 18 10 14

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/. 20.00.
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
 Arrays

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