Indices

Utilize generics ya que los tipos de datos de los nodos en algun momento podrian cambiar. Asi nos ahorramos el tener que crear otra clase.

Esta es la clase Nodo

using System;
using System.Collections.Generic;
using System.Text;

namespace Generics
{
class Node<K,T,V,H>
{
public K Indice;
public T Campo1;
public V Campo2;
public H Campo3;
public Node<K, T, V, H> NextNode;
public Node()
{
Indice = default(K);
Campo1 = default(T);
Campo2 = default(V);
Campo3 = default(H);
NextNode = null;
}
/// <summary>
/// nodo registro
/// </summary>
/// <param name="indice"></param>
/// <param name="campo1"></param>
/// <param name="campo2"></param>
/// <param name="campo3"></param>
/// <param name="nextNode"></param>
public Node(K indice, T campo1,V campo2,H campo3, Node<K, T, V, H> nextNode)

{

Indice = indice;

Campo1 = campo1;

Campo2 = campo2;

Campo3 = campo3;

NextNode = nextNode;

}



}

}

La Clase ListaEnlazada

using System;

using System.Collections.Generic;

using System.Text;

namespace Generics

{

class ListaEnlazada<K,T,V,H> where K: IComparable<K>

{

Node<K, T, V, H> m_Head;

Node<K, T, V, H>[] nodeArray;

public static int count = 0;

public ListaEnlazada()

{

m_Head = new Node<K, T, V, H>();



}

public void AddHead(K indice, T campo1,V campo2,H campo3)

{

Node<K, T, V, H> newNode = new Node<K, T,V,H>(indice, campo1,campo2,campo3,
m_Head.NextNode);

m_Head.NextNode = newNode;

ListaEnlazada<K, T, V, H>.count++;

}

public Node<K,T,V,H>[] llenarArray()

{

int i = 0;

Node<K, T, V, H> current = m_Head;

nodeArray = new Node<K, T, V, H>[count];

while (current.NextNode != null)

{

nodeArray[i] = current;

current = current.NextNode;

i++;

}

return nodeArray;

}

public Node<K, T, V, H> Find(object key,int tipo)

{

Node<K, T, V, H> current = m_Head;

switch (tipo)

{

case 1:

while (current.NextNode != null)

{

if (current.Campo1 != null )

{

if ( current.Campo1.Equals((T)key))

{

break;

}

current = current.NextNode;

}

else

current = current.NextNode;



}

break;

case 0:

while (current.NextNode != null)

{

if (current.Indice.CompareTo((K)key) == 0)

break;

else

current = current.NextNode;

}

break;

case 2:

while (current.NextNode != null)

{

if (current.Campo1 != null)

{

if (current.Campo2.Equals((V)key))

{

break;

}

current = current.NextNode;

}

else

current = current.NextNode;

}

break;

case 3:

while (current.NextNode != null)

{

if (current.Campo1 != null)

{

if (current.Campo3.Equals((H)key))

{

break;

}

current = current.NextNode;

}

else

current = current.NextNode;

}

break;

}

return current;

}

}

}

EDatos - Practica //Tema IV

IV. a. Consistia en hallar los primeros 100 primos. Bueno aqui lo tengo un poquitin mas generico, para cualquier cantidad de numeros primos que desees hallar. Con este cuando el profesor lo dio en el curso se me abrio el pecho. Asi que vi por ahi que era mejor encontrar los != a primos y los restantes por ende son primos. En vez de tratar de validar cuando es primo.

Los problemas de tema 4.

public void numeroPrimos(long longitud)
{
//contador de la cantidad primos insertados.
long count = 1;
//empezamos desde 2 a probar los numeros hasta que el contador llegue a su limite.
long numeros = 2;
//declaramos el arreglo segun la longitud que se ha pasado como parametro.
long[] primos = new long[longitud];
// el #1 es un numero primo so vamos a entrar :).
primos[0] = 1;
//hasta que el contador llegue al limite.
while (count <= longitud - 1)
{

bool primo = true; long multi = 2;
//buscar un factor que sea mas grande que la raiz del numero a evaluar.
while ( multi * multi <= numeros )
{
//dividimos el numero por cualquier divisor posible. si el residuo es zero
//no es primo
if ( numeros % multi == 0 )
{
Console.WriteLine("no soy primo:"+numeros);
primo = false; break;
}
multi++;
}
if (primo)
{
primos[count] = numeros;
count++;
}

numeros++;
}

}

B. Hallar la raiz. =) public int getRaiz(int numero)

{

int result = 0;

for (int i = 1; i <>

{

if (i * i == numero)

{

result = i;

}

}

return result;

}

C. El Mayor de 3 numeros. EZ.

public int mayorNumero(int x,int y,int z)

{

if (x > y)

y = x;

if (y > z)

return y;

else

return z;

}

D. Problema de 5 estudiantes 4 materias 3 notas. Promedio.

//Esta es la clase del main. Donde se va a llamar el metodo

class Program

{

static void Main(string[] args)

{

tema4 tema = new tema4();

int[,,] calificacion1 = new int[5,4,3];

int x = 0;

int y = 0;

while (y < 5)

{

Console.WriteLine("Este es el Alumno " + y.ToString());

while (x < 4)

{

Console.WriteLine("Inserte las 3 notas para la materia " + x.ToString());

calificacion1[y, x, 0] = Convert.ToInt32(Console.ReadLine());

calificacion1[y, x, 1] = Convert.ToInt32(Console.ReadLine());

calificacion1[y, x, 2] = Convert.ToInt32(Console.ReadLine());

x++;

}

x = 0;

y++;

}

Matriz m = new Matriz();

m = tema.MatrizEstudiantes(calificacion1);

}

}

/// <summary>

/// Creo mi propia estructura llamada matriz. Que forma un arrelo tridimencional.

/// con las dimenciones 5,4,3.

/// </summary>

public class Matriz

{

public int[, ,] ArregloInterno;

public Matriz()

{

this.ArregloInterno = new int[5, 4, 3];

}

public int this[int i, int j, int k]

{

get { return this.ArregloInterno[i, j, k]; }

set { this.ArregloInterno[i, j, k] = value; }

}

}

/// <summary>

/// Devuelve una matriz. Con los estudiantes.

/// </summary>

/// <param name="calificacion"></param>

/// <returns></returns>

public Matriz MatrizEstudiantes(int[,,] calificacion)

{

Matriz m = new Matriz();

int[] result = new int[3];



for (int k = 0; k < 5; k++)

{

for (int i = 0; i < 4; i++)

{

for (int j = 0; j < 3; j++)

{

m[k, i, j] = calificacion[k,i, j];

}

}

}

for (int k = 0; k < 5; k++)

{

Console.WriteLine(" // EL ALUMNO // " + k + " ");

for (int i = 0; i < 4; i++)

{

Console.Write(" ||Materia|| " + i + " ");

for (int j = 0; j < 3; j++)

{

result[j] = m[k, i, j];

}

int final = (result[0] + result[1] + result[2]) / 3;

Console.WriteLine(" Resultado " + final);

}

}



return m;

}

EDatos - Practica //Tema III

Dias de la semana
string[] days;
Edad de una persona
int edad;
Lista del SuperMercado
string[,] super;
Archivo de Texto;
File text;

EDatos - Practica //Tema II

Tema II. Aqui les posteo el palindromo por ahi vienen mas. Cualquier pregunta no duden en comentar.

La clase de los problemas

public bool Palindromo(string palabra)

{

//declarando las variables

bool estado = false;

int largo = palabra.Length;

string[] izquierda = new string[largo];

string[] derecha = new string[largo];

int f = 0;

//bucle que llenara el arreglo de las palabras de izquierda a derecha

for (int i = 0; i <>

{

izquierda[i] = palabra.Substring(i, 1);

}

//bucle que llenara el arreglo de las palabras de derecha a izquierda

for (int j = largo-1; j >= 0; j--)

{

derecha[f] = palabra.Substring(j, 1);

f++;

}

//bucle que iterara por los 2 arreglos para comprobar la condicion de que sean iguales.

// de lo contrario se rompe y retorna falso.

for ( int k = 0; k <>

{

if (izquierda[k] == derecha[k])

{

estado = true;

}

else

{

estado = false;

break;

}

}

return estado;

}

b. Factorial. Este es cortito y sencillo delen un check out chicos

public double Factorial(int numero)

{

//reclarando el resultado

double resultado = 1;

//iterando en retroceso por el numero

for (int i = numero; i > 0; i--)

{

resultado *= i;

}

return resultado;

}

EDatos - Practica //Tema I

1. Defina

1. Variables
2. Constantes
3. Tipos de datos
4. Algoritmo
5. OOP
6. Clase
7. Polimorfismo

I. Defina a. Variables son estructuras de datos que, como su nombre indica, cambian a lo largo de la ejecución de un programa. Una variable corresponde a un área reservada en la memoria principal del ordenador, longitud fija o variable, en donde el programa puede almacenar valores.

b. Constante Es un número arbitrario que no cambia.

c. Podemos definir un tipo de dato a partir de los valores permitidos y las operaciones que se puedan llevar a cabo sobre estos valores.

d. Un algoritmo es un conjunto finito de instrucciones o pasos que sirven para ejecutar una tarea o resolver un problema

e. La programación orientada a objetos expresa un programa como un conjunto de estos objetos, que se comunican entre ellos para realizar tareas. Esto difiere de los lenguajes procedurales tradicionales, en los que los datos y los procedimientos están separados y sin relación. Estos métodos están pensados para hacer los programas y módulos más fáciles de escribir, mantener y reutilizar.

f. Clases: Son templates para objectos que describen el tipo de cantidad de data que un objecto va a contener, pero, pero representan ninguna instancia particular de un objecto. Describe propiedades y comportamientos de objetos que ellos representan por miembros.Miembros son metodos, campos, propiedades y eventos. Campos y propiedades son data sobre el objecto.

g. Se denomina polimorfismo a la capacidad del código de un programa para ser utilizado con diferentes tipos de datos u objetos. También se puede aplicar a la propiedad que poseen algunas operaciones de tener un comportamiento diferente dependiendo del objeto (o tipo de dato) sobre el que se aplican.