Arrays

ARRAYS EN C#
I. INTRODUCCIN

En las sesiones anteriores, los datos manejados en los programas han sido datos simples (carcter, entero,
reales). En un gran nmero de problemas es necesario manejar un conjunto de datos ms o menos grande
que estn 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 homogneo 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.
Recprocamente si reside en un soporte externo (disquete, disco, cd, memoria USB, cinta, se denomina
estructura de datos externa.
La estructura de datos ms importante desde el punto de vista de utilizacin es un arreglo, que es
implementado en la totalidad de lenguajes de programacin.
Esta estructura corresponde con los conceptos matemticos de vector, matriz o poliedro.

II. DEFINICION

Un array o arreglo es una secuencia de datos del mismo tipo (estructura homognea), 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 ms subndices.
array m

Un arreglo puede contener, por ejemplo, la edad de los estudiantes de una clase, las horas diarias laboradas
por un trabajador, el nmero de estudiantes por ciclo de Ingeniera de Sistemas, etc.
En general, la representacin de un arreglo se hace mediante variables suscritas o de subndices y pueden
tener una o varias dimensiones (subndices).

III. CLASIFICACIN DE ARRAYS

Los Arrays se dividen en 2 grupos, los vectores y las matrices. Los vectores son arreglos que contienen una
sola dimensin y las matrices 2 o ms dimensiones.

ARRAYS UNIDIMENSIONALES (Vectores)

1. DEFINICIN:
Son arreglos de una sola dimensin, tienen un solo ndice. Cada elemento del vector se accesa mediante
su nombre seguido del nmero correspondiente al subndice 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

m[0]

m[1]

m[2]

m[3]

m[4]

m[5]

m[6]

m[7]

Elementos del Vector

Subndices

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 regin 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 tamao del
arreglo menos 1.
Igual que sucede con otras variables, antes de utilizar un arreglo primero hay que declararla. La
declaracin 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

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

2. DECLARAR Y CREAR UN ARREGLO UNIDIMENSIONAL

La declaracin 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 genricamente as:

tipoDato[] nombreVariable = new tipoDato[tamao];

tipoDato indica el tipo de datos de los elementos del arreglo, que pueden ser de cualquier tipo
primitivo o referenciado; los corchetes modifican la definicin 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 sern tratadas
como cualquier otro objeto.
y tamao es una expresin entera que especifica los nmeros de elementos
Las siguientes lneas de cdigo crean los arreglos de una dimensin 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].

Vector m

Crea un vector de temperaturas de 30

elementos de tipo float.

Vector temp

16.3

18.7

m[0]

m[1]

m[2]

m[3]

m[4]

temp [0]

temp [1]

Elementos
del Vector

19.3

17.4

temp [28]

temp [29]

Subndices

Ms 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 automticamente iniciados,
igual que suceda con las variables miembro de una clase. Si el arreglo es numrico sus elementos son
iniciados a 0 y si no es numrico, a un valor anlogo 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 teora vamos a realizar un programa que asigne datos a un arreglo unidimensional
miarreglo de nElementos y, a continuacin, como comprobacin del trabajo realizado, escriba el
contenido de dicho arreglo. La solucin ser similar a la siguiente:
CURSO: Algoritmos Avanzados y Estructura de Datos

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

Para ello, en primer lugar definimos la variable tamao para fijar el nmero de elementos del arreglo,
creamos el arreglo miarreglo con el tamao que ser ingresado por teclado.
int tamao=0;
Console.Write("\nIndique el Tamao del Arreglo: ");
tamao=int.Parse(Console.ReadLine());
//declarar y crear el arreglo
int[] miarreglo=new int[tamao];
El paso siguiente es asignar un valor desde el teclado a cada elemento del arreglo.
for (int i = 0; i < tamao; i++)
{
Console.Write("miarreglo["+ i +"] = ");
miarreglo[i]= int.Parse(Console.ReadLine());
}
Una vez ledo los elementos para el arreglo visualizamos para comprobar el trabajo realizado.
Console.Write("\nElementos del arreglo\n");
Console.WriteLine();
for (int i = 0; i < tamao; i++)
{
Console.Write(miarreglo[i]+" ");
}
El Programa completo se muestra a continuacin:
class Program
{
static void Main(string[] args)
{
int tamao=0;
Console.Write("\nIndique el Tamao del Arreglo: ");
tamao=int.Parse(Console.ReadLine());
Console.WriteLine();
//declarar y crear el arreglo
int[] miarreglo=new int[tamao];
//asignar datos
for (int i = 0; i < tamao; 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 < tamao; i++)
{
Console.Write(miarreglo[i]+" ");
}
Console.Read();
}
}

CURSO: Algoritmos Avanzados y Estructura de Datos

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

4. TAMAO 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 podramos escribirla
tambin 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:
Disear la siguiente interfaz y agregue el siguiente cdigo para el botn.

//Cdigo para el botn

2. Programa que incluye un arreglo de enteros y los datos son asignados directamente en el cdigo:

CURSO: Algoritmos Avanzados y Estructura de Datos

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

//Cdigo para el botn

Tambin
una asignacin
asignacincon
con
Tambinpodemos
podemos hacer
hacer una
nmeros
nmeros aleatorios
aleatorios

3. Programa que incluye un arreglo de enteros y los datos son asignados desde un cuadro de texto:
Disee el formulario teniendo en cuenta el nombre de
los controles

Programa funcionando

//Cdigo del programa

CURSO: Algoritmos Avanzados y Estructura de Datos

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

Modifique el cdigo de tal manera

que solo permita ingresar
nmeros enteros.
Tambin tener en cuenta el
tamao del arreglo para el
ingreso de datos.

Ahora implemente lo siguiente mtodos:

- Suma de los elementos ingresados al arreglo:

Hallar el Mximo Valor:

COMPLETE LOS METODOS PARA OBTENER EL PROMEDIO Y EL VALOR MINIMO.

Ahora completamos el cdigo para el botn Calcular:

Ahora complete el cdigo para el Botn Nuevo y para el botn Salir, guarde y pruebe su aplicacin

CURSO: Algoritmos Avanzados y Estructura de Datos

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

CREANDO UN ARREGLO DE 3 COLUMNAS

Diseo de la Interfaz

Programa en Ejecucin

//cdigo de la aplicacin
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

DOCENTE: Ing. CIP Fabin 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

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

ALGORITMO DE BUSQUEDA

BUSQUEDA LINEAL
Consiste en encontrar un elemento determinado dentro de una coleccin dada. La bsqueda se realiza sobre
una estructura de datos de tamao fijo y conocido, por ejemplo, un vector.
Los algoritmos sirven para hacer bsquedas 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

14

A[0]

A[1]

A[2]

A[3]

A[4]

A[5]

Valor devuelto, ndice 3

La codificacin 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, "Actualizacin", MessageBoxButtons.OK,
MessageBoxIcon.Information);
else
MessageBox.Show("Dato no encontrado", "Actualizacin", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}

BUSQUEDA BINARIA
El mtodo ms eficiente de bsqueda en una tabla secuencial sin utilizar ndices o tablas auxiliares es la
bsqueda binaria. Para poder llevarse acabo esta, necesita tener el arreglo ordenado. Bsicamente, el
argumento se compara con la llave del elemento intermedio de la tabla. Si son iguales, la bsqueda 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 divisin entera
2. Comparar el valor de este elemento central con la clave
Clave

bajo

central
Clave Encontrada

Clave

alto

bajo

Clave

central
Bsqueda lista inferior

CURSO: Algoritmos Avanzados y Estructura de Datos

alto

bajo

central

alto

Bsqueda lista superior

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

Sea el arreglo de enteros A:

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

-8

12

18

25

40

60

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

bajo = 0
alto = 8

clave (40) > A[4] (12)

Buscar en la sublista derecha

central = bajo+alto/2

18

25

40

60

A[5]

A[6]

A[7]

A[8]

5+8/2 = 6

bajo = 5
alto = 8

clave (40) > A[6] (25)

Buscar en la sublista derecha

central = bajo+alto/2

40

60

A[7]

A[8]

7+8/2 = 7

bajo = 7
alto = 8

clave (40) = A[7] (40)

El Algoritmo ha requerido tres comparaciones frente a ocho comparaciones que se hubieran realizado con la
bsqueda secuencial.
La codificacin 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, "Bsqueda", MessageBoxButtons.OK,
MessageBoxIcon.Information);
else
MessageBox.Show("Dato no encontrado", "Bsqueda", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}

CURSO: Algoritmos Avanzados y Estructura de Datos

10

DOCENTE: Ing. CIP Fabin Silva Alvarado

Arrays

ALGORITMOS DE ORDENAMIENTO
IV. INTRODUCCIN
Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar. En este caso, nos servirn para
ordenar vectores o matrices con valores asignados aleatoriamente. Nos centraremos en los mtodos ms populares,
analizando la cantidad de comparaciones que suceden, el tiempo que demora y revisando el cdigo, escrito en Java,
de cada algoritmo.
Este informe nos permitir conocer ms a fondo cada mtodo distinto de ordenamiento, desde uno simple hasta el
ms complejo. Se realizaran comparaciones en tiempo de ejecucin, pre-requisitos de cada algoritmo, funcionalidad,
alcance, etc.

V. TIPOS DE ALGORITMOS
Para poder ordenar una cantidad determinada de nmeros almacenadas en un vector o matriz, existen distintos
mtodos (algoritmos) con distintas caractersticas y complejidad.
Existe desde el mtodo mas simple, como el Bubblesort (o Mtodo Burbuja), que son simples iteraciones, hasta el
Quicksort (Mtodo Rpido), que al estar optimizado usando recursin, su tiempo de ejecucin es menor y es ms
efectivo.

2.1. METODOS ITERATIVOS

Estos mtodos 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
Insercin
Seleccin
Shellsort

METODO DE LA BURBUJA
El mtodo de la burbuja es uno de los ms simples, es tan fcil 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 posicin.
Por ejemplo, imaginemos que tenemos los siguientes valores:

Lo que hara 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 posicin. 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 condicin 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 estn 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 Fabin Silva Alvarado

Arrays

2. BURBUJA OPTIMIZADA
Una nueva versin del mtodo de la burbuja seria limitando el nmero de comparaciones, es intil que se
compare consigo misma. Si tenemos una lista de 10.000 elementos, entonces son 10.000 comparaciones que
estn sobrando. Imaginemos si tenemos 1.000.000 de elementos. El mtodo 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 estn detrs del que se esta comparando, ya estn ordenados, las comparaciones
serian aun menos y el mtodo 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 estn ordenados. Entonces
optimizamos mas aun el algoritmo, quedando nuestra versin 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 ordenacin por insercin 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 mtodo es una mejora del algoritmo de ordenamiento por Insercin (Insertsort). Si tenemos en cuenta que
el ordenamiento por insercin es mucho ms eficiente si nuestra lista de nmeros esta semi-ordenada y que
desplaza un valor una nica posicin a la vez.
Durante la ejecucin de este algoritmo, los nmeros de la lista se van casi-ordenando y finalmente, el ultimo
paso o funcin de este algoritmo es un simple mtodo por insercin que, al estar casi-ordenados los nmeros, es
ms 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 Fabin 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
i=0
i=1
i=2

B
10
15
20

C
20
10
15

30
25
35

i=n-1

X+Y

C[i]= A[i] + B[i]

En Cdigo:

II. PRODUCTO DE 2 ARREGLOS

A
i=0
i=1
i=2

for(i=0;i<n;i++)
{
C[i]= A[i] + B[i];
}

B
10
15
20

C
20
10
15

200
150
300

.
.

i=n-1

X*Y

C[i]= A[i] * B[i]

En Cdigo:

for(i=0;i<n;i++)
{
C[i]= A[i] * B[i];
}

III. DIFERENCIA DE 2 ARREGLOS

En Cdigo:

for(i=0;i<n;i++)
{
C[i]= A[i] - B[i];
}

IV. DIVISION DE 2 ARREGLOS

En Cdigo:

for(i=0;i<n;i++)
{
C[i]= A[i] / B[i];
}

CURSO: Algoritmos Avanzados y Estructura de Datos

13

DOCENTE: Ing. CIP Fabin 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)
b)
c)
d)
e)
f)

Cada trabajador se identifica con su nombre y su cdigo

Cada Trabajador tiene un salario bsico (SAL_BAS) entre 1000 y 2000.
Cada trabajador tiene una bonificacin (BONIF) del 12% del Salario Basico
El Salario Parcial (SAL_PARC) es igual a SAL_BAS+ BONIF.
Cada trabajador tiene un descuento (DSCTO) del 9% del SAL_PARC
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 solucin que permita ingresar y almacenar las notas de 4 prcticas de un estudiante. Determinar
el promedio de cada alumno sabiendo que se duplica su nota ms 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 dems importes necesarios para n obreros
de una empresa quienes estn identificados por un cdigo y se rigen a las siguientes condiciones:
a. Cada trabajador tiene una tarifa por hora de S/. 20.00.
b. El salario bsico se calcula en base a las horas laboradas en el mes y la tarifa x hora.
c. Todos reciben una bonificacin del 20% con respecto al Salario Bsico
d. Salario Parcial es igual a Salario Bsico + bonificacin
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 Fabin Silva Alvarado

Arrays

El formato de salida es:

--------------------------------------------------------------------------------------------------------------------------------------------------------------PLANILLA DEL MES DE MAYO 2009
--------------------------------------------------------------------------------------------------------------------------------------------------------------Cdigo
Trabajador
Horas_Lab Sal_Basico Bonific
Sal_Parc
Desc AFP
Sal_Neto
---------------------------------------------------------------------------------------------------------------------------------------------------------------

****
****
****
****

********************
********************
********************
********************

**
**
**
**

****.**
****.**
****.**
****.**

***.**
***.**
***.**
***.**

****.**
****.**
****.**
****.**

***.**
***.**
***.**
***.**

****.**
****.**
****.**
****.**

----------------------------------------------------------------------------------------------------------------------------------------------------------- ---TOTAL PLANILLA: ****.** *****.**

--------------------------------------------------------------------------------------------------------------------------------------------------------------3.

Agregar una opcin para realizar una bsqueda por cdigo del trabajador empleando el algoritmo de bsqueda
lineal
Agregue una opcin para realizar el ordenamiento por Nombre del trabajador en forma Ascendente utilizando
el Algoritmo de Insercin
Agregue una opcin para realizar el ordenamiento por Salario Neto del trabajador en forma Descendente
utilizando el Algoritmo de Insercin
Ubique a la persona que obtuvo un mayor sueldo neto.

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
--------------------------------------------------------------------------------------------------------------------------------------------------------------Cdigo
Apellidos y Nombres
EP
EF
PP
PF
Observacin
---------------------------------------------------------------------------------------------------------------------------------------------------------------

****
****
****
****

********************
********************
********************
********************

**
**
**
**

**
**
**
**

**
**
**
**

**.*
**.*
**.*
**.*

*********
*********
*********
*********

--------------------------------------------------------------------------------------------------------------------------------------------------------------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 funcin a: PF=(2EP+3EF+2PP)/7
b. Completa la columna observacin segn 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 opcin para realizar una bsqueda por cdigo del trabajador empleando el algoritmo de bsqueda
Binaria
e. Agregue una opcin para realizar el ordenamiento por Apellidos y Nombres del Estudiante en forma Ascendente
utilizando el Algoritmo SHELLSORT
f. Agregue una opcin 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 opcin para poder realizar un filtrado con todos los datos del estudiante segn sea la observacin del
estudiante.

CURSO: Algoritmos Avanzados y Estructura de Datos

15

DOCENTE: Ing. CIP Fabin Silva Alvarado