public IComparableP CrearAlumnoAlAzar()
{
Random aleatorio = new Random(); // IComparableP compA
alumno = new Alumno(Nombre_al_azar(), aleatorio.Next(10000000, 99999999), aleatorio.Next(100, 99999), aleatorio.Next(1, 10));
return(alumno);
}
public IComparableP CrearVendedorAlAzar()
{
int max = 100;
vendedor = new Vendedor(GeneradorDeDatosAleatorios.stringAleatorio(4), GeneradorDeDatosAleatorios.numeroAleatorio(max), GeneradorDeDatosAleatorios.numeroAleatorio(max), GeneradorDeDatosAleatorios.numeroAleatorio(max));
return(vendedor);
}
// Ejercicio 6 TP 3
public static void LLenar(IColeccionableTP coleccionable, int opcion)
{
for (int x = 0; x < 20; x++)
{
IComparableP comparable = FabricaCreadorIComprable.CrearAleatorio(opcion);
coleccionable.Agregar(comparable);
}
}
public override bool SosIgual(IComparableP variable)
{
if (((Vendedor)variable).bonus == this.bonus)
{
return(true);
}
else
{
return(false);
}
}
public bool SosIgual(IComparableP comparable, IComparableP comparable2)
{
if (((Alumno)comparable).GetLegajo == ((Alumno)comparable2).GetLegajo)
{
return(true);
}
else
{
return(false);
}
}
public bool SosMenor(IComparableP IComparable, IComparableP IComparable2)
{
if ((((Alumno)IComparable2).GetNombre).CompareTo(((Alumno)IComparable).GetNombre) == -1)
{
return(true);
}
else
{
return(false);
}
}
public bool SosIgual(IComparableP IComparable, IComparableP IComparable2)
{
if (((Alumno)IComparable).GetNombre.CompareTo(((Alumno)IComparable2).GetNombre) == 0)
{
return(true);
}
else
{
return(false);
}
}
public bool SosMayor(IComparableP comparable, IComparableP comparable2)
{
if (((Alumno)comparable2).GetPromedio > ((Alumno)comparable).GetPromedio)
{
return(true);
}
else
{
return(false);
}
}
public bool SosMenor(IComparableP comparable, IComparableP comparable2)
{
if (((Alumno)comparable2).GetDni > ((Alumno)comparable).GetDni)
{
return(true);
}
else
{
return(false);
}
}
public virtual bool SosIgual(IComparableP variable)
{
if (((Persona)variable).dni == this.dni && ((Persona)variable).nombre == this.nombre)
{
return(true);
}
else
{
return(false);
}
}
public bool SosMayor(IComparableP comparable, IComparableP comparable2)
{
if (((Alumno)comparable2).GetDni < ((Alumno)comparable).GetDni)
{
return(true);
}
else
{
Console.WriteLine(((Alumno)comparable2).GetDni + " compare " + ((Alumno)comparable).GetDni);
}
return(false);
}
public bool SosMenor(IComparableP variable)
{
Numero comparable = (Numero)variable;
if (comparable.Valor > this.Valor)
{
return(true);
}
else
{
return(false);
}
}
public void Agregar(IComparableP objeto)
{
if (Listacomparable.Count > 0)
{
if (!Contiene(objeto))
{
Listacomparable.Add(objeto);
}
}
else
{
Listacomparable.Add(objeto);
}
}
public IComparableP Minimo()
{
IComparableP minimo_pila = pila_colecion.Maximo();
IComparableP minimo_Cola = cola_coleccion.Maximo();
if (minimo_Cola.SosMenor(minimo_pila))
{
return(minimo_Cola);
}
else
{
return(minimo_pila);
}
}
public static void Informar(IColeccionableTP coleccionable, int opcion)
{
Console.WriteLine(coleccionable.Cuantos());
Console.WriteLine(coleccionable.Maximo());
Console.WriteLine(coleccionable.Maximo());
IComparableP comparable = FabricaCreadorIComprable.CrearPorTeclado(opcion);
if (coleccionable.Contiene(comparable))
{
Console.WriteLine("El elemento leído está en la colección");
}
else
{
Console.WriteLine("El elemento leído no está en la colección");
}
}
public bool Contiene(IComparableP objeto)
{
bool esta = false;
foreach (IComparableP num in Listacomparable)
{
if (objeto.GetType() == num.GetType())
{
if (num.SosIgual(objeto))
{
esta = true;
}
}
}
return(esta);
}
public IComparableP Minimo()
{
Queue <IComparableP> colas_copia;
colas_copia = Clonar();
IComparableP min = colas_copia.Dequeue();
while (colas_copia.Count > 0)
{
IComparableP comparar = colas_copia.Dequeue();
if (comparar.SosMenor(min))
{
min = comparar;
}
}
return(min);
}
public IComparableP actual()
{
int contador = 0;
IComparableP objetoActual = null;
foreach (IComparableP donde_estoy in diccionario.Keys)
{
if (contador == posicion)
{
return(donde_estoy);
}
contador++;
}
return(objetoActual);
}
public bool Contiene(IComparableP objeto)
{
Queue <IComparableP> colas_copia3;
colas_copia3 = Clonar();
bool aviso = false;
while (colas_copia3.Count > 0)
{
IComparableP comparar = colas_copia3.Dequeue();
if (comparar.SosIgual(objeto))
{
aviso = true;
}
}
return(aviso);
}
public void Agregar(IComparableP objeto)
{
if (diccionario.Count > 0)
{
if (!diccionario.ContainsKey(objeto))
{
diccionario.Add(objeto, objeto);
}
else
{
diccionario[objeto] = objeto;
}
}
else
{
diccionario.Add(objeto, objeto);
}
}
public IComparableP Maximo()
{
Queue <IComparableP> colas_copia2;
colas_copia2 = Clonar();
IComparableP max = colas_copia2.Dequeue();
while (colas_copia2.Count > 0)
{
IComparableP comparar = colas_copia2.Dequeue();
if (comparar.SosMayor(max))
{
max = comparar;
}
}
return(max);
}
public IComparableP Minimo()
{
int contador = 1;
IComparableP primer_tipo_menor = Listacomparable[1];
while (contador < Listacomparable.Count)
{
IComparableP valor_que_cambia = Listacomparable[contador];
if (valor_que_cambia.GetType() == primer_tipo_menor.GetType())
{
if (valor_que_cambia.SosMenor(primer_tipo_menor))
{
primer_tipo_menor = valor_que_cambia;
}
}
contador++;
}
Console.WriteLine("Tomamos el primer tipo de dato ingresado para seleccionar sobre ese tipo cual es el menor");
Console.WriteLine("El tipo de dato comparado es " + primer_tipo_menor.GetType());
return(primer_tipo_menor);
}
//Ejercicio 9 Practica 2
public static void CambiarEstrategia(IColeccionableTP coleccionable, IEstrategia_Comparar_Alumno estrategia)
{
Interador interador = coleccionable.iterador();
while (!interador.fin())
{
IComparableP elemento = interador.actual();
interador.siguiente();
((Alumno)elemento).Estrategia_elegida = estrategia;
((Alumno)elemento).Comparar_Alumnos();
IComparableP alumnoSiguiente = (Alumno)interador.actual();
//si no agregara siguiente seria un bucle infinito
//IEstrategia_Comparar_Alumno cambiandoestrategia = new ContextAlumnoStegy(estrategia);
ContextAlumnoStegy estrategiaalimno = new ContextAlumnoStegy(new Comparar_Alumno_Dni());
Console.WriteLine("el alumno " + elemento + " es el MISMO que " + alumnoSiguiente + " = " + "\n " + estrategiaalimno.SosIgual(elemento, alumnoSiguiente));
Console.WriteLine("el alumno " + elemento + " es MENOR que " + alumnoSiguiente + " = " + "\n " + estrategiaalimno.SosMenor(elemento, alumnoSiguiente));
Console.WriteLine("el alumno " + elemento + " es MAYOR que " + alumnoSiguiente + " = " + "\n " + estrategiaalimno.SosMayor(elemento, alumnoSiguiente));
}
}
public void Agregar(IComparableP objeto)
{
throw new NotImplementedException();
}
public bool SosMenor(IComparableP comparable, IComparableP comparable2)
{
return(this.estrategia.SosMenor(comparable, comparable2));
}
public bool SosIgual(IComparableP comparable, IComparableP comparable2)
{
return(this.estrategia.SosIgual(comparable, comparable2));
}
public Clave_Valor(IComparableP clave, object objetoasociado)
{
Objetoasociado = objetoasociado;
Clave = clave;
}
public IComparableP CrearNumeroAlAzar(int maximo)
{
numero = new Numero(GeneradorDeDatosAleatorios.numeroAleatorio(maximo));
return(numero);
}
public IComparableP CrearNumeroPorTeclado()
{
numero = new Numero(LectorDeDatos.numeroPorTeclado());
return(numero);
}
public bool Contiene(IComparableP objeto)
{
return(cola_coleccion.Contiene(objeto) || pila_colecion.Contiene(objeto));
}
