Orddenamiento Burbija (Bubblesort)

El ordenamiento de burbuja es uno de los tipos de ordenamiento más sencillos por su facilidad de comprensión, a continuación una clase que lo implementa

class Ordenamiento
{
int[] _vec;

int interc, comp;

public Ordenamiento(int[] v)
{
interc = 0;
comp = 0;
_vec = new int[v.Length];
for (int i = 0; i < v.Length; i++)
{
_vec[i] = v[i];
}
}

public int Comp
{
get { return comp; }
}

public int Inter
{
get { return interc; }
}

public int[] BurbujaA()
{
comp = 0;
interc = 0;
int temp = 0;
bool listo = true;
for (int i = 1; i < _vec.Length; i++)
{
listo = true;
for (int j = 0; j < _vec.Length - i; j++)
{
comp++;
if (_vec[j] > _vec[j + 1])
{
interc++;
temp = _vec[j];
_vec[j] = _vec[j + 1];
_vec[j + 1] = temp;
listo = false;
}

}
if (listo)
return _vec;
}
return _vec;
}

public int[] BurbujaD()
{
comp = 0;
interc = 0;
int temp = 0;
bool listo = true;
for (int i = 1; i < _vec.Length; i++)
{
listo = true;
for (int j = 0; j < _vec.Length - i; j++)
{
comp++;
if (_vec[j] < _vec[j + 1])
{
interc++;
temp = _vec[j];
_vec[j] = _vec[j + 1];
_vec[j + 1] = temp;
listo = false;
}

}
if (listo)
return _vec;
}
return _vec;
}

}

Recursividad Invertir Cadenas

Este proyecto sirve para invertir cadenas de texto, está implementado usando recursividad,

class Cadena
{
char[] aux;
int i;

public Cadena()
{
aux = new char[50];
i = 0;
}

public Cadena(int n)
{
aux = new char[n];
i = 0;
}

public char[] Copiar(char[] cad, int n)
{
if (n == 0)
aux[n] = cad[n];
else
{
aux[n] = cad[n];
Copiar(cad, n - 1);
}
return aux;
}

public char[] Invertir(char[] cad, int n)
{
if (n == 0)
aux[i] = cad[n];
else
{
aux[i++] = cad[n];
Invertir(cad, n - 1);
}
return aux;

}

public char[] Invertir(string cad, int n)
{
if (n == 0)
aux[i] = cad[n];
else
{
aux[i++] = cad[n];
Invertir(cad, n - 1);
}
return aux;

}

}

Esta clase sirve para invertir las cadenas de texto

puedes descargar el proyecto completo desde el enlace
http://www.mediafire.com/?z3lkef5k9zo2fm6

Recursividad

Esta clase Matemáticas contiene varios métodos que hacen uso de la recursividad para resolver problemas, el código es el siguiente:

class MatematicasR
{
   

Este método obtiene el factorial de un número

static public int Factorial(int n)
{
int f = 1;
if (n == 0 || n == 1)
return 1;
else
f = n * Factorial(n - 1);
return f;
}

Este método obtiene la sumatoria de los numeros hasta el limite proporcionado

static public int Sumatoria(int n)
{
int f = 1;
if (n == 0 || n == 1)
return 1;
else
f = n + Sumatoria(n - 1);
return f;
}

static public int Fibonacci(int n)
{
if (n == 1 || n == 2)
return 1;
else
return Fibonacci(n - 1) + Fibonacci(n - 2);
}

Este método invierte un número

static public void Invertir(int n, ref int r)
{
r += n % 10;

if (n >= 10)
{
r *= 10;
Invertir(n / 10, ref r);
}
}
}

Puedes descargar el proyecto completo desde acá:
http://www.mediafire.com/?irk282e4w4ty7wr

Movimiento de gráficos

Este pequeño proyecto es un juego en el que se usan elementos de la clase graphics, además se usan las medidas de la forma para poder dar movimiento a los gráficos, a continuación el proyecto:

Puedes descargar el proyecto completo de aquí:
http://www.mediafire.com/?a4x2n536yyr8nzh

Aplicacion de las Pilas Zapatería

Este es un simulador de una zapateria donde se puede trabajar con los elementos del alamacen de zapatos, el proyecto es el siguiente

Puedes descargar el proyecto desde el siguiente enlace:
http://www.mediafire.com/?vvwbtkk3413mot8

Aplocación de colas

Este es un ejemplo sencillo del uso de las colas, es un simulador de una cola de impresión,

Puedes descargarlo para analizarlo aquí
http://www.mediafire.com/?z3fh8c0jl2wy2ul

Notación Polaca

En este ejemplo se encuentra el código par convertir de una notacion normal a una notación polaca, el código es el siguiente

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;


enum Simbolo { OPRENANDO=0, PIZQ, PDER,SUMRES, MULTDIV, POW};
class Polaca
{

Este método es el que realiza todo el trabajo de convertir de una notación infija a una posfija (polaca)

public StringBuilder Convertir_a_Posfija(string Ei)
{
char[] Epos = new char[Ei.Length];
int tam = Ei.Length;
Pila<int> stack = new Pila<int>(Ei.Length);//para guardar el valor del operando
int i, pos = 0;
for (i = 0; i < Epos.Length; i++)
{
char car = Ei[i];
//simbolo actual = tipo y precedencia(car);

Simbolo actual = Tipo_y_Precedencia(car);

switch (actual)
{
case Simbolo.OPRENANDO: Epos[pos++] = car; break;

case Simbolo.SUMRES:
{
while(!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope())>=actual)
Epos[pos++]= (char)stack.Pop();
stack.Push(car);
}
break;

case Simbolo.MULTDIV:
{
while (!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope()) >= actual)
Epos[pos++] = (char)stack.Pop();
stack.Push(car);
}
break;

case Simbolo.POW:
{
while (!stack.Vacia && Tipo_y_Precedencia((char)stack.Tope()) >= actual)
Epos[pos++] = (char)stack.Pop();
stack.Push(car);
}
break;

case Simbolo.PIZQ: stack.Push(car); break;

case Simbolo.PDER:
{
char x = (char)stack.Pop();
while (Tipo_y_Precedencia(x) != Simbolo.PIZQ)
{
Epos[pos++] = x;
x = (char)stack.Pop();
}
}
break;
}
}

while (!stack.Vacia)
{
//por que esta ocasionando problemas con indice fuera de rango
if (pos < Epos.Length)
Epos[pos++] = (char)stack.Pop();
else
break;
}
StringBuilder regresa = new StringBuilder(Ei);
for(int r=0;r<Epos.Length;r++)
regresa[r] = Epos[r];
return regresa;
}

public Simbolo Tipo_y_Precedencia(char s)
{
Simbolo simbolo;
switch (s)
{
case '+': simbolo = Simbolo.SUMRES; break;
case '-': simbolo = Simbolo.SUMRES; break;
case '*': simbolo = Simbolo.MULTDIV; break;
case '/': simbolo = Simbolo.MULTDIV; break;
case '^': simbolo = Simbolo.POW; break;
case '(': simbolo = Simbolo.PIZQ; break;
case ')': simbolo = Simbolo.PDER; break;
default: simbolo = Simbolo.OPRENANDO; break;
}
return simbolo;
}
}

Si deseas revisar el proyecto descárgalo aquí:
http://www.mediafire.com/?7527lugw7beh1b6

Cola simple

Este es un ejemplo de una cola simple, la cual no es ni circular ni está implementada con listtas enlazadas

class Cola_Alternativa
{
int[] _datos;
int _ultimo;
bool _vacia, _llena;

public Cola_Alternativa(int size)
{
_datos = new int[size];
_ultimo = -1;
_vacia = true;
_llena = false;
}

public Cola_Alternativa(Cola_Alternativa cola, int size)
:this(size)
{
int length = cola._ultimo + 1 < size ? cola._ultimo + 1 : size;
for (int i = 0; i < length; i++)
this._datos[i] = cola._datos[i];
this._ultimo = length - 1;
  }

Este método sirve para agregar datos a la cola simple

public void Agregar(int dato)
{
if (_ultimo+1 < _datos.Length)
{
_datos[++_ultimo] = dato;
_vacia = false;
if (_ultimo == _datos.Length)
_llena = true;
}
else
throw new ApplicationException("Overflow");
  }

Este método sirve para extraer datos de la cola simple

public int Extraer()
{
if (_ultimo >= 0)
{
int temp = _datos[0];
Avanzar();
_ultimo--;
return temp;
}
else
throw new ApplicationException("Underflow");
  }

Este es un método crucial para el funcionamiento de esta cola, ya que permite que los elementos avancen el la cola

private void Avanzar()
{
for (int i = 0; i < _ultimo; i++)
_datos[i] = _datos[i + 1];
}

public override string ToString()
{
string s = "";
for (int i = 0; i <= _ultimo; i++)
s += _datos[i] + " ";
return s;
}
}

Descarga el proyecto completo desde aquí
http://www.mediafire.com/?p63yaccm7drgzgh

Pila con listas enlazadas

La ventaja de una pila con listas enlazadas es que no tiene límites arbitrarios que puedan causar problemas a causa de falta de tamaño y tampoco producen gasto de memoria innecesaria, a continuación la implementación de una pila con liostas enlazadas

public class Elemento
{
public int v;
public Elemento s;
public Elemento (int v1, Elemento s1)
{
v = v1;
s = s1;
}
}

public class PilaEnlazada
{
Elemento e1;
public PilaEnlazada()
{
e1 = null;
}

Este método sirve para agregar un elemento a una pila

public void Agregar(int v1)
{
Elemento nuevo = new Elemento(v1,e1);
e1 = nuevo;
}

Este metodo sirve para extraer un elemento de una pila

public int Extraer()
{
Elemento naux;
int v1;
if(e1 == null)
return -1;
naux = e1;
e1 = naux.s;
v1 = naux.v;
return v1;
}
public override string ToString ()
{
Elemento aux = e1;
string s = "";

while(aux != null)
{
s += aux.v;
s += "->";
aux = aux.s;
}
s+="null";
return s;

}

}

Puedes descargar el ejemplo completo desde el siguiente enlace:
http://www.mediafire.com/?n6225gk5vkz9218

Cola circular

La cola circular es la más eficiente de las colas que se pueden realizar con arreglos de datos predefinidos, a continuación muestro un ejemplo:

class Cola<t>
{
int _noElems;
int _p;
int _u;
t[] _a;
bool _vacia, _llena;

public Cola(int tamaño)
{
_a = new t[tamaño];
_p = 0;
_u = 0;
_vacia = true;
_llena = false;
}

public Cola()
  { }

Este método sirve para agregar un elemento a la cola circular

public void Agregar(t dato)
{
if (!_llena)
{
if (_u == _a.Length)
_u = 0; ;
_a[_u++] = dato;
_noElems++;
_vacia = false;
if (_noElems == _a.Length)
_llena = true;
}
else
throw new ApplicationException("Overflow");
  }

Este método sirve para extraer un elemento de la cola circular

public t Extraer()
{
if (!_vacia)
{
if (_p == _a.Length)
_p = 0;
t temp = _a[_p++];
_noElems--;
_llena = false;
if (_noElems == 0)
_vacia = true;
return temp;
}
else
throw new ApplicationException("Underflow");
}

Este método es una sobrecarga del método ToString() que ayuda a visualizar todos los elementos de una cola circular

public override string ToString()
{
string a = "";
int uT = _u > _p ? _u : _a.Length;
for (int i = _p; i < uT; i++)
{
a += _a[i];
a += " ";
}
if (_u < _p)
{
for (int i = 0; i < _u; i++)
{
a += _a[i];
a += " ";
}
}
return a;
}
}

Puedes descargar el proyecto que hace uso de esta clase aquí:
http://www.mediafire.com/?hmwbrb3hbmspca0

Listas Enlazadas

Este es un ejemplo de las listas enlazadas simples, diseñado desde unas clases a medida que debes revisar

Descárgalo acá:
http://www.mediafire.com/?f2p067kg1w7do3b

Método de Gauss-Jordan

Este programa contiene el argoritmo para resolver sistemas de ecuaciones mediante el método de Gauss-Jordan, requiere que se le den los valores de la matriz desde el código

Puedes descargarlo haciendo click en el siguiente link
http://www.mediafire.com/?c6lf7wcpa7aazm2

Manejo de Matrices y Vectores

Este ejemplo muestra la utilidad de los arreglos para las tareas comunes

Puedes descargar el archivo dando click acá:
http://www.mediafire.com/?9h9il4b4bae6c4a

Proyecto: Una Agenda

Este pequeño proyecto es una agenda donde se pueden agregar registros y hacer busquedas inteligentes entre ellos, lo principal de este proyecto es reforsar el uso de cadenas y de archivos

Puedes descargar el proyecto completo desde el siguiente link

Archivos de texto

Al igual que los archivos binarios, los archivos de texto se manejan de manera muy sencilla desde c#, este es un ejemplo de como leer y escribir archivos de texto

public partial class Form1 : Form 

{
public Form1()
{
InitializeComponent();
  }

Este botón sirve para leer un archivo de texto y mostrarlo en un textbox

private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog opd = new OpenFileDialog();
string open;
if (opd.ShowDialog() == DialogResult.OK)
{
open = opd.FileName;
FileStream fs = null;// = new FileStream(open, FileMode.Open, FileAccess.Read);
StreamReader sr=null;// = new StreamReader(fs);
try
{

fs = new FileStream(open, FileMode.Open, FileAccess.Read);
sr = new StreamReader(fs);
textBox1.Text = sr.ReadToEnd();

}
catch (IOException io)
{
MessageBox.Show(io.Message);
}
finally
{
if (fs != null)
{
sr.Close();
fs.Close();

}
}
}
}

La función de este botón es escribir un archivo de texto con el contenido de un textbox

private void button2_Click(object sender, EventArgs e)
{
SaveFileDialog sfd = new SaveFileDialog();
string save;
if (sfd.ShowDialog() == DialogResult.OK)
{
save = sfd.FileName;
FileStream fs = new FileStream(save, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
try
{
sw.WriteLine(textBox1.Text);
}
catch(IOException io)
{
MessageBox.Show(io.Message);
}

finally
{
sw.Close();
fs.Close();
textBox1.Clear();
}
}
}
}

si deseas descargar el archivo de texto puedes hacerlo desde el siguiente enlace
http://www.mediafire.com/?y5pfcaq9xk4xxqh

Archivos binarios

En C# es muy facil crear archivos binarios con los datos que deseemos, a continuacion se muestra un ejemplo de como crearlos haciendo uso de la clase FileStream

class Program
{
static void Main(string[] args)
{
string archivo = @"misDatos.mov";
EscribirArchivo(archivo);
LeerArchivo(archivo);
Console.ReadKey();
}

Este metodo sirve para escribir una serie de numeros enteros a un archivo binario

public static void EscribirArchivo(string nomArch)
{
FileStream fs = null;
BinaryWriter bw = null;
try
{
fs = new FileStream(nomArch,FileMode.Create, FileAccess.Write);
bw = new BinaryWriter(fs);
Random r = new Random();
int n=5, i=0;
int val;
do
{
val = r.Next(10, 100);
Console.WriteLine("Dato insertado en el Archivo : " + val);
bw.Write(val);
i++;
} while(i<n);
}
catch (IOException ex)
{
Console.WriteLine("Error: " + ex.Message);
}
finally
{
if (bw != null)
{
bw.Close();
fs.Close();
}
}
}

Este método sirve para leer una serie de números enteros desde un archivo binario y mostrarlos en la consola

public static void LeerArchivo(string nomArch)
{
BinaryReader br = null;
try
{
if (File.Exists(nomArch))
{
br = new BinaryReader(new FileStream(nomArch, FileMode.Open, FileAccess.Read));
int val;
do
{
val = br.ReadInt32();
Console.WriteLine("Dato: " + val);
} while(true);
}
else
{
Console.WriteLine("El archivo no existe");
}
}
catch (EndOfStreamException)
{
Console.WriteLine("fin del archivo");
}
finally
{
if (br != null)
{
br.Close();
}
}
}
}

Puedes descargar el proyecto de Visual Studio desde el siguiente link
http://www.mediafire.com/?2ypu5by9b6mzzi3

Manejo de Matrices (Clase matriz)

El siguiente proyecto completo en cuanto al uso de matrices bidimencionales de la clase matriz propia

Puedes revisar el proyecto en el siguiente link:
http://www.mediafire.com/?3wc6rggg8c4e459

Matrices Bidimensionales (Clase propia)

En esta ocasión explica como crear una clase Matriz cuya instancia nos facilite trabajar con arreglos de dos dimensiones, además incluye métodos que realizan operaciones básicas con una sola matriz

La clase Matriz es la siguiente:

class Matriz
{
int[,] _mat;
int _renglones;
int _columnas;

public Matriz()
{
_mat = new int[3, 3];
_renglones = 3;
_columnas = 3;
}

Esta propiedad nos devuelve el número de renglones que posee la matriz

public int Renglones
{
get { return _renglones; }
}

Esta propiedad nos devuelve el numero de columnas que posee la matriz

public int Columnas
{
get { return _columnas; }
}

public Matriz(int renglones, int columnas)
{
_mat = new int[renglones, columnas];
_renglones = renglones;
_columnas = columnas;
}

public int this[int renglon, int columna]
{
get { return _mat[renglon, columna]; }
set { _mat[renglon, columna] = value; }
  }

Este metodo nos devuelve el promedio de la diagonal de la matriz en caso de que sea cuadrada

 

public int Diagonal()
{
if (_renglones != _columnas)
return 0;
int prom = 0;
for (int i = 0; i < _renglones; i++)
prom += _mat[i, i];
prom /= _columnas;
return prom;
}

Este método nos devuelve el promedio de la diagonal invertida de la matriz en caso de que sea cuadrada

public int DiagonalInvertida()
{
if (_renglones != _columnas)
return 0;
int prom = 0;
int col = _columnas-1;
for (int i = 0; i < _renglones; i++)
prom += _mat[i, col--];
prom /= _columnas;
return prom;
}

}

Aqui incluyo un pequeño programa que hace uso de esta matriz:

class Program

{

static void Main(string[] args)

{

int r = Leer("renglones");

int c = Leer("Columnas");

Matriz m = new Matriz(r, c);

LlenarMatriz(m);

MostrarMatriz(m);

Promedios(m);

Console.ReadKey();

}

public static void Promedios(Matriz m)

{

int d = m.Diagonal();

int i = m.DiagonalInvertida();

if (d != 0)

Console.WriteLine("El promedio de la diagonal es: " + d.ToString());

else

Console.WriteLine("No se puede obtener el promedio de diagonal");

if (i != 0)

Console.WriteLine("El promedio de la diagonal invertida es: " + i.ToString());

else

Console.WriteLine("No se puede obtener el promedio de diagonal invertida");

}

public static void MostrarMatriz(Matriz m)

{

string linea = "";

for (int i = 0; i < m.Renglones; i++)

{

for (int j = 0; j < m.Columnas; j++)

{

linea += m[i, j].ToString() + "\t";

}

Console.WriteLine(linea);

linea = "";

}

}

public static void LlenarMatriz(Matriz m)

{

Random r = new Random();

for (int i = 0; i < m.Renglones; i++)

for (int j = 0; j < m.Columnas; j++)

m[i, j] = r.Next(10, 99);

}

public static int Leer(string leerQue)

{

while (true)

{

Console.WriteLine("Numero de {0}", leerQue);

int a = Int32.Parse(Console.ReadLine());

if (a < 3 || a > 10)

{

Console.WriteLine("Error...");

Console.Clear();

continue;

}

else

return a;

}

}

} 

 Si deseas revisar con más detenimiento el proyecto puedes descargarlo completo en el siguiente enlace:
http://www.mediafire.com/?i9djv9pecoxwvie

Trabajando con arreglos bidimensionales

Este proyecto hace uso de la clase StringBuilder asi como de arreglos bidimensionales para hacer operaciones simples en una matriz, el código es el siguiente

static void Main(string[] args)
{

Creamos los datos con los que vamos a trabajar

int r = Leer("renglones");
int c = Leer("columnas");
int[,] m = new int[r, c];
StringBuilder primos = new StringBuilder();
StringBuilder nones = new StringBuilder();
int p=0;
  int n=0;

Se llena ma matriz de números aleatorios y al mismo tiempo usamos los metodos de la clase matematicas (especificada más adelante) para saber que numeros son primos y cuales de ellos son nones.

Random ran = new Random();
for (int i = 0; i < r; i++)
{
for (int j = 0; j < c; j++)
{
m[i, j] = ran.Next(10, 100);
if (Matematicas.EsPrimo(m[i, j]))
{
primos.Append(m[i, j] + ", ");
p++;
}
if (Matematicas.EsNon(m[i, j]))
{
nones.Append(m[i, j] + ", ");
n++;
}
Console.Write("\t" + m[i, j]);
}
Console.WriteLine("\n\r");
}
Console.WriteLine("Los {0} numeros primos son: {1}\n\rLos {2} numeros nones son: {3}", p, primos.ToString(), n, nones.ToString());
Console.ReadKey();
}

public static int Leer(string leerQue)
{
while (true)
{
Console.WriteLine("Numero de {0}", leerQue);
int a = Int32.Parse(Console.ReadLine());
if (a < 3 || a > 10)
{
Console.WriteLine("Error...");
Console.Clear();
continue;
}
else
return a;
}
} 

La clase Matematicas utilizada en este proyecto es la siguiente :

 public class Matematicas
{
   
static public bool EsNon(int n)
{
if (Convert.ToBoolean(n % 2))
return true;
return false;
}

    static public bool EsPrimo(int n)
{
int div = 2;
int r1 = n % div;
int r2 = n / div;
while (div < n)
{
if ((n % div) == 0)
return false;
div++;
}
return true;
}
}

Puedes descargar el proyecto completo desde aquí:
http://www.mediafire.com/?nwyrz2o2151jknf

Trabajando con cadenas StartsWith()

Este método muestra el uso del método StartsWith() de la clase string, el cual es muy util cuando se trabaja con cadenas ya que permite saber si una cadena tiene como primer elemento cierto caracter, para ello implementamos el siguiente método que nos ayuda a encontrar todos les elementos que empiecen con cierto caracter en una columna de un objeto DataGridView para devolvernoslo los resultados de la búsqueda completamente listos en una cadena.

El método es el siguiente:

private string Seek(string c, int columna, DataGridView dGV)
{
string resultado="";
string temp="";
c= c[0].ToString().ToUpper();
for (int i = 0; i < dGV.Rows.Count-1; i++)
{
temp = dGV[columna,i].Value.ToString();
if (temp.StartsWith(c))
resultado += (dGV[0, i].Value.ToString() + " " + dGV[1, i].Value.ToString() + " " + dGV[2, i].Value.ToString() + "\r\n");
}
return resultado;

}

Para verlo en acción puedes descargar el siguiente proyecto:

Link: http://www.mediafire.com/?wqvigvchr4a8rg6

Codificación simple de una cadena

Este es un ejemplo de codificación simple de una cadena, la cual facilmente puedes utilizar en tus proyectos para añadirles un plus de seguridad :-)

Está basado en la clase ordenamiento, la cual se muestra a continuación:

class CodeText 

{

Este método es el encargado de codificar una cadena, como podemos observar, es simplemente jugar con los códigos ASCII de cada caracter para que la cadena quede ilegible.

public static string Code(string text, int key)
{
char[] cadC = text.ToLower().ToCharArray();
for (int i = 0; i < cadC.Length; i++)
{
if (cadC[i] >= 97 && cadC[i] <= 122)
{
cadC[i] += (char)key;
if (cadC[i] > 122)
cadC[i] -= (char)26;
}
}
return CharArrayToString(cadC);
}

Este método es el encargado de decodificar una cadena, se trata de hacer a la inversa lo que se realizó en el proceso de codificación

public static string Decode(string text, int key)
{
char[] cadC = text.ToLower().ToCharArray();
for (int i = 0; i < cadC.Length; i++)
{
if (cadC[i] >= 97 && cadC[i] <= 122)
{
cadC[i] -= (char)key;
if (cadC[i] > 122)
cadC[i] -= (char)26;
}
}
return CharArrayToString(cadC);
  } }

Además  adjunto un pequeño proyecto en Visual Studio que muestra claramente el uso de esta clase.

Puedes descargar el proyecto en el siguiente link:
http://www.mediafire.com/?zzloy3nai15tbm6

Clase Vector con plantillas (templates)

En esta ocación tenemos la clase Vector ya analizada en la entrada anterior pero con algunas modificaciones, entre ellas las plantillas, las cuales sirven para crear instancias de una misma clase que puedan tener atributos con diferentes tipos de datos, la nueva clase es la siguiente:

public class Vector<t>
{
t[] _vec;
int _noElems;

public Vector()
{
_vec = new t[0];
_noElems = 0;
}

public Vector(int size)
{
_vec = new t[size];
_noElems = size;
}

public double GetAverage()
{
double a = 0;
for (int i = 0; i < _noElems; i++)
a += Convert.ToDouble(_vec[i]);
a /= _noElems;
return a;
}

public void Add(t value)
{
t[] temp = new t[_vec.Length + 1];
for (int i = 0; i < _vec.Length; i++)
temp[i] = _vec[i];
temp[temp.Length - 1] = value;
_noElems++;
_vec = null;
_vec = temp;
temp = null;
}

public int NoElems
{
get { return _noElems; }
}

public override string ToString()
{
StringBuilder s = new StringBuilder();
for (int i = 0; i < _vec.Length; i++)
s.Append(_vec[i].ToString() + " ,");
return s.ToString();
}

public t this[int index]
{
get { return _vec[index]; }
set { _vec[index] = value; }
}

public t GetMax()
{
t n;
t m = _vec[0];
for (int i = 1; i < _vec.Length; i++)
{
n = _vec[i];
if (Convert.ToDouble(n) > Convert.ToDouble(m))
m = n;
}
return m;
}

public t GetMin()
{
t n;
t m = _vec[0];
for (int i = 1; i < _vec.Length; i++)
{
n = _vec[i];
if (Convert.ToDouble(n) < Convert.ToDouble(m))
m = n;
}
return m;
}

Al mismo tiempo la utilizamos para un pequeño programa que calcula información acerca de calificaciones de alumnos:

El programa es muy sencillo y lo puedes revisar descargandolo desde el siguiente enlace:
http://www.mediafire.com/?32g7drfox9fscvi

Operaciones Matemáticas

Esta clase llamada Matematicas contiene ciertos metodos que realizan operaciones sencillas, pero que ayudan a poner a punto nuestra lógica de programación, la clase es la siguiente:

class Matematicas
{

Este método simplemente sirve para devolver el numero de euler e , base del logaritmo natural o neperiano

static public double BaseE()
{
int i = 0;
double ee = 0.0;
double ve = Math.E;
do
{
ee += (double)1/ Matematicas.Factorial(i++);
}
while(ee <= Math.E);
return ee;
}

Este método devuelve el factorial de un número siempre y cuando sea igual o menor a 13 (dadas las limitaciones de una variable de tipo int (entero 4 bytes)

static public double Factorial(double n)
{// sin limitaciones acerca de calcular el factorial mayor a 13
double acomular = 1;
for (int i = 1; i <= n; i++)
acomular *= i;
return acomular;
}

Este método devuelve el factorial de un número, sin las limitaciones del anterior

static public int Factorial(int n)
{// limitado a calcular el factorial menor a 13
int acomular = 1;
for (int i = 1; i <= n; i++)
acomular *= i;
return acomular;
  }

Este método devuelve si sí o no es un número primo

static public bool EsPrimo(int n)
{
int div = 2;
int r1 = n % div;
int r2 = n / div;
while (div < n)
{
if ((n % div) == 0)
return false;
div++;
}
return true;
}
}

Aquí dejo disponible un proyecto de Visual Studio que hace uso de esta clase
Link: http://www.mediafire.com/?1p2p02ip1ej6z7l

Clase Vector

Este ejercicio muestra el uso de una clase vector, la cual facilita el uso de arreglos unidimensionales, la clase Vector es la siguiente:

class Vector

  {

  int[] vec; 

  public Vector(int n)

{
if (n > 0)
vec = new int[n];
}

public Vector()
{ vec = new int[5]; }

public int this[int index]
{
get { return vec[index]; }
set { vec[index] = value; }
}

Este método sirve para leer el valor que se encuentra en una posicion específica del vector

public int Read(int index)
{
if (index >= vec.Length)
return -1;
else
return vec[index];
 }

Este método añade al vector un dato en el primer lugar libre

public void Add(int data)
{
for (int i = 0; i < vec.Length; i++)
{
if (vec[i] == 0)
{
vec[i] = data;
break;
}
}
}

Este método sirve para agregar un dato al vector en la posición deseada

public void Add(int data, int index)
{
vec[index] = data;
  }

Este método sirve para obtener el valor máximo del vector

public int GetMax()
{
int n = 0;
int m = vec[0];
for (int i = 1; i < vec.Length; i++)
{
n = vec[i];
if (n > m)
m = n;
}
return m;
}

 Este es un métod estático que sirve para obtener el máximo de un arreglo unidimensional

  static public int GetMax(int[] a)
{
int n = 0;
int m = a[0];
for (int i = 1; i < a.Length; i++)
{
n = a[i];
if (n > m)
m = n;
}
return m;
}

Este método sirve para obtener el mínimo del vector

public int GetMin()
{
int n = 0;
int m = vec[0];
for (int i = 1; i < vec.Length; i++)
{
n = vec[i];
if (n < m)
m = n;
}
return m;
}

 Este método sirve para encontrar el valor más repetido en el vector

public int MoreRepeated()
{
int[] temp = new int[vec.Length];
for (int i = 0; i < vec.Length; i++)
for (int j = 0; j < vec.Length; j++)
if (vec[i] == vec[j])
temp[i]++;
return vec[temp.Max()];
}

public int Length
{
get { return vec.Length; }
}
}

Dejo disponible un pequeño proyecto de Visual Studio que hace uso de ésta clase
Link: http://www.mediafire.com/?6u6s7of2y2l9bxf