void Start()
{
pila = Pila.getInstan();
seeRecords();
}
private void inicializarEstado()
{
pc = 0; //Contador de programa
pila = new Pila(cab.nLocals); //Pila
heap.RemoveRange(cab.nConst, heap.Count - cab.nConst); //Memoria dinámica
//Valores de retorno
retInt = 0;
retFloat = 0F;
retBool = false;
retString = "";
}
public static void Run(int TipoEstrategia)
{
Generar generar = new Generar();
Cola personas = new Cola();
Pila alumnos = new Pila();
//Hardcodeo Creacion Personas
Persona p1 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p2 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p3 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p4 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p5 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p6 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p7 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p8 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p9 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
//Fin creacion de Personas
personas.agregar(p1); personas.agregar(p2); personas.agregar(p3); personas.agregar(p4); personas.agregar(p5); personas.agregar(p6);
personas.agregar(p7); personas.agregar(p8); personas.agregar(p9);
//Crea Alumnos
Alumno a1 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a2 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a3 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a4 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a5 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a6 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a7 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a8 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a9 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
// Fin crea Alumnos
alumnos.agregar(a1); alumnos.agregar(a2); alumnos.agregar(a3); alumnos.agregar(a4); alumnos.agregar(a5); alumnos.agregar(a6); alumnos.agregar(a7);
alumnos.agregar(a8); alumnos.agregar(a9);
switch (TipoEstrategia)
{
case 1:
break;
case 2:
cambioEstrategia(personas, new StratComparacion_DNI());
cambioEstrategia(alumnos, new StratComparacion_DNI());
break;
case 3:
cambioEstrategia(personas, new StratComparacion_Legajo());
cambioEstrategia(alumnos, new StratComparacion_Legajo());
break;
case 4:
cambioEstrategia(personas, new StratComparacion_Promedio());
cambioEstrategia(alumnos, new StratComparacion_Promedio());
break;
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\n\tComparamos a1 con a2:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + a1.sosIgual(a2) + "\n" +
"\tsosMenor: " + a1.sosMenor(a2) + "\n" +
"\tsosMayor: " + a1.sosMayor(a2));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\tComparamos a3 con a4:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + a3.sosIgual(a4) + "\n" +
"\tsosMenor: " + a3.sosMenor(a4) + "\n" +
"\tsosMayor: " + a3.sosMayor(a4));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\tComparamos a5 con a6:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + a5.sosIgual(a6) + "\n" +
"\tsosMenor: " + a5.sosMenor(a6) + "\n" +
"\tsosMayor: " + a5.sosMayor(a6));
if (!TipoEstrategia.Equals(3) && !TipoEstrategia.Equals(4))
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\tComparamos p1 con p2:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + p1.sosIgual(p2) + "\n" +
"\tsosMenor: " + p1.sosMenor(p2) + "\n" +
"\tsosMayor: " + p1.sosMayor(p2));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\tComparamos p3 con p4:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + p3.sosIgual(p4) + "\n" +
"\tsosMenor: " + p3.sosMenor(p4) + "\n" +
"\tsosMayor: " + p3.sosMayor(p4));
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\tComparamos p5 con p6:");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\tsosIgual: " + p5.sosIgual(p6) + "\n" +
"\tsosMenor: " + p5.sosMenor(p6) + "\n" +
"\tsosMayor: " + p5.sosMayor(p6));
}
}
public PilaIterator(Pila parametro)
{
this.pila = parametro;
}
public static void Main(string[] args)
{
Pila P = new Pila();
int opt = 0;
do
{
Console.WriteLine("|1.-Pila |");
Console.WriteLine("|2.-Cola |");
Console.WriteLine("|3.-SALIR |");
opt = int.Parse(Console.ReadLine());
switch (opt)
{
case 1:
do
{
Console.WriteLine(" |1.-Insertar |");
Console.WriteLine(" |2.-Buscar |");
Console.WriteLine(" |3.-Modificar |");
Console.WriteLine(" |4.-Eliminar |");
Console.WriteLine(" |5.-Desplegar |");
Console.WriteLine(" |6.-Salir |");
opt = int.Parse(Console.ReadLine());
switch (opt)
{
case 1:
Console.WriteLine("\n\n Insrte nodo en la pila \n");
P.insertarNodo();
break;
case 2:
Console.WriteLine("\n\n Buscar nodo en la Pila \n");
P.BuscarNodo();
break;
case 3:
Console.WriteLine("\n\n Modificar nodo en la Pila\n");
P.ModificarNodo();
break;
case 4:
Console.WriteLine("\n\n Eliminar nodo en la Pila\n");
P.EliminarNodo();
break;
case 5:
Console.WriteLine("\n\n Desplegar nodos de la pila\n");
P.DesplegarPila();
break;
}
} while (opt != 6);
break;
case 2:
do
{
Console.WriteLine(" |1.-Insertar |");
Console.WriteLine(" |2.-Buscar |");
Console.WriteLine(" |3.-Modificar |");
Console.WriteLine(" |4.-Eliminar |");
Console.WriteLine(" |5.-Desplegar |");
Console.WriteLine(" |6.-Salir |");
opt = int.Parse(Console.ReadLine());
switch (opt)
{
case 1:
Console.WriteLine("\n\n Insrte nodo en la Cola \n");
P.InsertarNodoCola();
break;
case 2:
Console.WriteLine("\n\n Buscar nodo en la Cola \n");
P.buscarnodo();
break;
case 3:
Console.WriteLine("\n\n Modificar nodo en la Cola\n");
P.modificarnodo();
break;
case 4:
Console.WriteLine("\n\n Eliminar nodo en la Cola\n");
P.eliminarcola();
break;
case 5:
Console.WriteLine("\n\n Desplegar nodos de la Cola\n");
P.desplegarCola();
break;
}
} while (opt != 6);
break;
}
} while (opt != 3);
}
public abstract Carta jugarUnaMano(Pila mazo, Persona player);
public Usuario(string nUsuario, int tipoUsuario, Pila miLista)
{
this.nUsuario = nUsuario;
this.tipoUsuario = tipoUsuario;
this.miLista = miLista;
}
static void Main(string[] args)
{
bool ciclo = false, opcion = false;
while (opcion == false)
{
Console.WriteLine("Escoja un tipo de estructura \n1.-Pila \n2.-Cola \n3.-Salir");
string estructura = Console.ReadLine();
switch (estructura)
{
case "1":
Pila pila = new Pila();
ciclo = false;
while (ciclo == false)
{
Console.WriteLine("Escoja una accion para la Pila \n1.-Ingresar Dato \n2.-Eliminar Dato " +
"\n3.-Vaciar Pila \n4.-Imprimir Pila \n5.-Salir");
string op = Console.ReadLine();
switch (op)
{
case "1":
pila.Insertar();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "2":
pila.Eliminar();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "3":
pila.Vaciar();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "4":
pila.Mostrar();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "5":
ciclo = true;
break;
default:
Console.WriteLine("No se Escogio ninguna opcion, escoja una opcion valida");
Console.WriteLine("Presione un tecla para continuar");
break;
}
Console.Clear();
}
break;
case "2":
//cola
Cola cola = new Cola();
ciclo = false;
while (ciclo == false)
{
Console.WriteLine("Escoja una accion para la cola \n1.-Ingresar Dato \n2.-Eliminar Dato " +
"\n3.-Vaciar cola \n4.-Imprimir cola \n5.-Salir");
string op = Console.ReadLine();
switch (op)
{
case "1":
cola.Insertarcola();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "2":
cola.Eliminarcola();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "3":
cola.Vaciarcola();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "4":
cola.Mostrarcola();
Console.WriteLine("Presione un tecla para continuar");
Console.ReadKey();
break;
case "5":
ciclo = true;
break;
default:
Console.WriteLine("No se Escogio ninguna opcion, escoja una opcion valida");
Console.WriteLine("Presione un tecla para continuar");
break;
}
Console.Clear();
}
break;
case "3":
opcion = true;
break;
default:
Console.WriteLine("No se Escogio ninguna opcion, escoja una opcion valida");
Console.WriteLine("Presione un tecla para continuar");
break;
}
Console.Clear();
}
}
internal List <ErrorCompilacion> AnalizarUnSoloPaso()
{
List <ErrorCompilacion> retorno = new List <ErrorCompilacion>();
if (!(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila()))
{
RellenarCadenaEntrada();
if (Pila.ObtenerTope().GetType() == typeof(Terminal))
{
Terminal term = (Terminal)Pila.ObtenerTope();
if (CadenaEntrada.ObtenerPrimerTerminal().Equals(Pila.ObtenerTope()))
{
if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisApertura)
{
cantParentesisAbiertos++;
}
else if (term.Componente.Token == ComponenteLexico.TokenType.ParentesisClausura)
{
cantParentesisAbiertos--;
}
//flanzani 8/1/2012
//tokens repetidos
//Antes de pasar por el semantico, lo que hago es fijarme si el terminal justo no esta repetido,
//pq eso me caga todo el parseo de errores del sintactico
//Esto puede arrojar una excepcion sintactica
ChequearTokensRepetidosEnCadena(term);
if (HabilitarSemantico)
{
retorno = ArbolSemantico.CalcularAtributos(CadenaEntrada.ObtenerPrimerTerminal());
}
Pila.DescartarTope();
GlobalesCompilador.UltFila = CadenaEntrada.ObtenerPrimerTerminal().Componente.Fila;
GlobalesCompilador.UltCol = CadenaEntrada.ObtenerPrimerTerminal().Componente.Columna;
EstadoSintactico.AgregarTerminal(term);
CadenaEntrada.EliminarPrimerTerminal();
}
else
{
if (term.NoEsLambda())
{
StringBuilder strbldr = new StringBuilder(string.Empty);
strbldr.Append("Se esperaba ");
strbldr.Append(EnumUtils.stringValueOf(term.Componente.Token));
strbldr.Append(" pero se encontro ");
strbldr.Append(EnumUtils.stringValueOf(CadenaEntrada.ObtenerPrimerTerminal().Componente.Token));
strbldr.Append(".");
if (term.Equals(Terminal.ElementoFinSentencia()))
{
//Descarto el ; de la pila pq asumo que simplemente se le olvido
strbldr.Append(" Se asume fin de sentencia para continuar con analisis.");
}
throw new ErrorSintacticoException(strbldr.ToString(),
AnalizadorLexico.FilaActual(),
AnalizadorLexico.ColumnaActual(),
true,
false,
false);
}
else
{
retorno = AnalizarPila();
}
}
}
else
{
retorno = AnalizarPila();
}
}
return(retorno);
}
static void Main(string[] args)
{
int menú;
do
{
Console.WriteLine("\n>>>>>>>>>>>>MENÚ PRINCIPAL <<<<<<<<<\n" +
"1.- Cola\n" +
"2.- Pila\n" +
"3.- Salir\n");
Console.WriteLine("Elija una opcion");
menú = int.Parse(Console.ReadLine());
switch (menú)
{
case 1:
Cola cola = new Cola();
int menu;
do
{
Console.WriteLine("\n>>>>>>>>>>MENÚ DE LA COLA<<<<<<<\n" +
"1) Insertar\n" +
"2) Buscar\n" +
"3) Modificar\n" +
"4) Eliminar\n" +
"5) Desplegar\n" +
"6) Salir del menú\n");
Console.WriteLine("Elija una de las opción");
menu = int.Parse(Console.ReadLine());
switch (menu)
{
case 1:
Console.WriteLine("\nInsertar nodo en la LISTA\n");
cola.InsertarNodo();
break;
case 2:
Console.WriteLine("\nBuscar nodo en la LISTA\n");
cola.buscarnodo();
break;
case 3:
Console.WriteLine("\nModificar nodo en la LISTA\n");
cola.modificarnodo();
break;
case 4:
Console.WriteLine("\nEliminar nodo de la LISTA\n");
cola.eliminarcola();
break;
case 5:
Console.WriteLine("\nDespleglar nodo de la LISTA\n");
cola.desplegarCola();
break;
case 6:
Console.WriteLine("\nFin de COLA\n");
break;
default:
Console.WriteLine("\n Por favor ingresar opcion valida \n");
break;
}
} while (menu != 6);
break;
case 2:
Pila pil = new Pila();
int menu2;
do
{
Console.WriteLine("\n <+<+<+<+<+<+<+<+MENÚ PILA>+>+>+>+>+>+>+>+>\n" +
"1) Insertar\n" +
"2) Buscar\n" +
"3) Modificar\n" +
"4) Eliminar\n" +
"5) Desplegar\n" +
"6) Salir del menú\n");
Console.WriteLine("Elija una opción");
menu2 = int.Parse(Console.ReadLine());
switch (menu2)
{
case 1:
Console.WriteLine("\nInsertar en la Lista\n");
pil.insertarNodoPila();
break;
case 2:
Console.WriteLine("\nBuscar en la Lista\n");
pil.BuscarNodoPila();
break;
case 3:
Console.WriteLine("\nModificar en la Lista\n");
pil.ModificarNodoPila();
break;
case 4:
Console.WriteLine("\nEliminar en la Lista\n");
pil.EliminarNodoPila();
break;
case 5:
Console.WriteLine("\nDesplegar en la Lista\n");
pil.DesplegarPila();
break;
case 6:
Console.WriteLine("\nFInal PILA\n");
break;
default:
Console.WriteLine("\nPor favor ingresar opcion valida\n");
break;
}
} while (menu2 != 6);
break;
case 3:
break;
default:
Console.WriteLine("\nPor favor ingresar opcion valida\n");
break;
}
} while (menú != 3);
}
public void Borrar(int dato)
{
NodoA nodo = Busca(dato);
if (nodo == raiz)
{
if ((nodo.Izq == null) && (nodo.Der == null))
{
raiz = null;
}
else if ((nodo.Izq != null) && (nodo.Der == null))
{
raiz = nodo.Izq;
}
else if ((nodo.Izq == null) && (nodo.Der != null))
{
raiz = nodo.Der;
}
else if ((nodo.Izq != null) && (nodo.Der != null))
{
Pila miPila = new Pila();
miPila = alaPila(nodo, miPila);
raiz = null;
while (!miPila.PilaVacia())
{
int n;
if ((n = (Convert.ToInt32(miPila.Pop()))) != dato)
{
Insertar(n);
}
}
}
}
else if (nodo != raiz)
{
if (nodo.Izq == null && (nodo.Der == null))
{
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = null;
}
else
{
nodo.Padre.Der = null;
nodo.Padre = null;
}
}
else if ((nodo.Izq != null && (nodo.Der == null)))
{
nodo.Izq.Padre = nodo.Padre;
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = nodo.Izq;
}
else
{
nodo.Padre.Der = nodo.Izq;
}
}
else
{
if ((nodo.Izq == null) && (nodo.Der != null))
{
nodo.Der.Padre = nodo.Padre;
if ((nodo.Padre.Izq) == nodo)
{
nodo.Padre.Izq = nodo.Der;
}
else
{
nodo.Padre.Der = nodo.Der;
}
}
else
{
if ((nodo.Izq != null) && nodo.Der != null)
{
Pila miPila = new Pila();
miPila = alaPila(nodo, miPila);
if (nodo.Padre.Izq == nodo)
{
nodo.Padre.Izq = null;
}
else
{
nodo.Padre.Der = null;
}
while (!miPila.PilaVacia())
{
int n;
if ((n = Int32.Parse(miPila.Pop().ToString())) != dato)
{
Insertar(n);
}
}
}
}
}
}
//MessageBox.Show("Borrado exitoso");
}
public IteradorDePila(Pila pila)
{
this._pila = pila.getPila().ToList <Icomparable>();;
this._posicionActual = 0;
}
protected Movie getMovieActual()
{
String name = Request.QueryString["name"];
try
{
movies = (LinkedListDouble)Session["movies"];
watchLater = (Pila)Session["watchLater"];
myList = (Cola)Session["myList"];
}
catch (Exception)
{
}
if (name.Length > 0)
{
//Colocar si existe en Mi Lista
try
{
Cola myList2 = myList.Clone();
while (myList2.getPrimero() != null)
{
Movie primero = (Movie)myList2.pop();
String currentName = primero.Name;
if (name == currentName)
{
isInMyList = true;
break;
}
}
}
catch (Exception)
{
}
//Colocar si existe en ver mas tarde
try
{
Pila watchLaterList = watchLater.Clone();
while (watchLaterList.getPrimero() != null)
{
Movie primero = (Movie)watchLaterList.pop();
String currentName = primero.Name;
if (name == currentName)
{
isInWatchLater = true;
break;
}
}
}
catch (Exception)
{
}
// Obtener la pelicula Actual
try
{
movies.iniciarPrimero();
while (movies.getActual() != null)
{
Movie movie;
movie = (Movie)movies.getActual();
String movieName = movie.Name;
if (movieName == name)
{
return(movie);
}
movies.next();
}
}
catch (Exception)
{
}
}
return(null);
}
/// <summary>
/// Guardars the informacion.
/// </summary>
/// <param name="encuesta">The encuesta.</param>
public void GuardarInformacion(Pila encuesta)
{
this.stackEncuesta.Push(encuesta);
}
//METODO QUE REGRESA UN StringBuilder (EXPRESION A POSTFIJA) Y RECIBE UN STRING(EXPRESION INFIJA)
public StringBuilder ConvertirPosFija(string Ei)
{
// notacion_polaca objeto = new notacion_polaca();
char[] Epos = new char[Ei.Length];
int tam = Ei.Length;
Pila <int> stack = new Pila <int>(Ei.Length);
int i, pos = 0;
for (i = 0; i < Epos.Length; i++)
{
char car = Ei[i];
Simbolo actual = Tipo_y_Prescedencia(car);
switch (actual)
{
case Simbolo.OPERANDO: Epos[pos++] = car; break;
case Simbolo.SUMRES:
{
while (!stack.esta_Vacia() && Tipo_y_Prescedencia((char)stack.Tope()) >= actual)
{
Epos[pos++] = (char)stack.Pop();
}
stack.Push(car);
}
break;
case Simbolo.MULTDIV:
{
while (!stack.esta_Vacia() && Tipo_y_Prescedencia((char)stack.Tope()) >= actual)
{
Epos[pos++] = (char)stack.Pop();
}
stack.Push(car);
}
break;
case Simbolo.POW:
{
while (!stack.esta_Vacia() && Tipo_y_Prescedencia((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_Prescedencia(x) != Simbolo.PIZQ)
{
Epos[pos++] = x;
x = (char)stack.Pop();
}
}
break;
}
}
while (!stack.esta_Vacia())
{
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);
}
private bool ChequearQueNoSeEsteOperandoLaPilaParaUnErrorSintactico(Produccion prod)
{
bool retorno = false;
bool pararChequeo = false;
if (prod.ProduceElementoVacio())
{
int posPila = 1;
while (!(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila()) && (Pila.Count > posPila) && !pararChequeo)
{
if (Pila.ObtenerPosicion(posPila).GetType() == typeof(Terminal))
{
Terminal term = (Terminal)Pila.ObtenerPosicion(posPila);
if (CadenaEntrada.ObtenerPrimerTerminal().Equals(Pila.ObtenerPosicion(posPila)))
{
//No hay error pq coincide el terminal, y se va a poder descartar en el proximo paso.
retorno = false;
pararChequeo = true;
}
else
{
if (term.NoEsLambda())
{
//Hay error pq el terminal no coindiria con el de la cadena de entrada.
retorno = true;
pararChequeo = true;
}
}
}
else
{
Terminal t = CadenaEntrada.ObtenerPrimerTerminal();
NoTerminal nt = (NoTerminal)Pila.ObtenerPosicion(posPila);
bool generaProdVacia = false;
//Que es esto??
if (!PerteneceNoTerminalesNoEscapeables(nt))
{
generaProdVacia = gramatica.NoTerminalGeneraProduccionVacia(nt);
}
Produccion prodAux = tabla.BuscarEnTablaProduccion(nt, t, false, generaProdVacia);
if (prodAux != null)
{
if (prodAux.ProduceElementoVacio())
{
posPila++;
}
else
{
//Significa que llegue a algo concreto con el terminal que tengo en el tope, y dejo seguir.
retorno = false;
pararChequeo = true;
}
}
else
{
//Significa que en la tabla ni figura, o sea que es un error
retorno = true;
pararChequeo = true;
}
}
}
if (posPila > Pila.Count)
{
//Hubo error pq el terminal tope no servia para nada de la pila
retorno = true;
}
}
return(retorno);
}
public abstract void mezclarMazo(Pila mazo);
public bool EsFinAnalisisSintactico()
{
return(CadenaEntrada.EsFinDeCadena() && Pila.EsFinDePila());
}
static void Main(string[] args)
{
Pila pila = new Pila();
Cola cola = new Cola();
Opciones op = new Opciones();//Constructor de la clase Opciones
Console.Write("\t\t\t\tTAREA TDA COLA TDA PILA");
Console.WriteLine("\n\t\tIngrese el numero correspondiente al tipo de TDA con el que " +
"\n\t\tdesea trabajar" +
"\n\t\t\t (1).- PILA" +
"\n\t\t\t (2).- COLA" +
"\n\t\t\t (3).- SALIR");
Console.Write("\t\t\t\tOpcion: ");
op.Option = Convert.ToByte(Console.ReadLine());
/*---------------------------------------------------------------------------------------------------------------------------------------*/
if (op.Option == 1)
{
Console.Clear();
do
{
Console.WriteLine("\t\t-------------------------------------------------------");
Console.WriteLine("\t\t|\t\t\tTDA PILA ORIENTADA A OBJETOS");
Console.WriteLine("\t\t|Ingrese opcion:" +
"\n\t\t|\t(1) Apilar datos (String) en la Pila" +
"\n\t\t|\t(2) Imprimir datos (String) de la Pila:" +
"\n\t\t|\t(3) Desapilar datos (String) de la pila" +
"\n\t\t|\t(4) Mostrar la cima o tope (String) de la pila");
Console.Write("\t\t|\t\t\tOption: "); op.OptionPila = Convert.ToByte(Console.ReadLine());
Console.WriteLine("\t\t-------------------------------------------------------");
switch (op.OptionPila)
{
case 1: pila.Apilar();
break;
case 2: pila.Imprimir(); break;
case 3: pila.Desapilar(); break;
case 4: pila.Cima(); break;
}
} while (op.Option != 7);
}
/*---------------------------------------------------------------------------------------------------------------------------------------*/
if (op.Option == 2)
{
Console.Clear();
do
{
Console.WriteLine("\t\t-------------------------------------------------------");
Console.WriteLine("\t\t|\t\t\tTDA COLA ORIENTADA A OBJETOS");
Console.WriteLine("\t\t|Ingrese opcion:" +
"\n\t\t|\t(1) Encolar datos (String) en la Cola" +
"\n\t\t|\t(2) Imprimir datos (String) de la Cola:" +
"\n\t\t|\t(3) Desencolar datos (String) de la Cola" +
"\n\t\t|\t(4) Mostrar la cima o tope de la Cola");
Console.Write("\t\t|\t\t\tOption: "); op.Optioncola = Convert.ToByte(Console.ReadLine());
Console.WriteLine("\t\t-------------------------------------------------------");
switch (op.Optioncola)
{
case 1: cola.Encolar(); break;
case 2: cola.Imprimir(); break;
case 3: cola.Desencolar(); break;
case 4: cola.Cima(); break;
}
} while (op.Option != 5);
}
else
{
Console.ReadKey();
}
}
public static void Run(int TipoEstrategia)
{
Generar generar = new Generar();
//List<Persona> personas = new List<Persona>();
//List<Persona> alumnos = new List<Persona>();
IColeccionable <I_Comparable> personas = new Cola();
IColeccionable <I_Comparable> alumnos = new Pila();
//--------------------- Creacion de algunas Personas
Persona p1 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p2 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p3 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p4 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p5 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p6 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p7 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p8 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
Persona p9 = new Persona(generar.Gen_Nombre(), generar.Gen_DNI());
//--------------------- Fin de creacion de Personas
personas.agregar(p1); personas.agregar(p2); personas.agregar(p3); personas.agregar(p4); personas.agregar(p5); personas.agregar(p6);
personas.agregar(p7); personas.agregar(p8); personas.agregar(p9);
//--------------------- Creacion de algunas Alumnos
Alumno a1 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a2 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a3 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a4 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a5 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a6 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a7 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a8 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
Alumno a9 = new Alumno(generar.Gen_Nombre(), generar.Gen_DNI(), generar.Gen_Legajo(), generar.Gen_Promedio());
//--------------------- Fin de creacion de Alumnos
alumnos.agregar(a1); alumnos.agregar(a2); alumnos.agregar(a3); alumnos.agregar(a4); alumnos.agregar(a5); alumnos.agregar(a6); alumnos.agregar(a7);
alumnos.agregar(a8); alumnos.agregar(a9);
switch (TipoEstrategia)
{
case 1:
break;
case 2:
cambioEstrategia(personas, new StratComparacion_DNI());
//cambioEstrategia((IColeccionable<Persona>)personas, new StratComparacion_DNI());
//cambioEstrategia((IColeccionable<Persona>)alumnos, new StratComparacion_DNI());
cambioEstrategia(alumnos, new StratComparacion_DNI());
break;
case 3:
cambioEstrategia(personas, new StratComparacion_Legajo());
//cambioEstrategia((IColeccionable<Persona>)personas, new StratComparacion_Legajo());
//cambioEstrategia((IColeccionable<Persona>)alumnos, new StratComparacion_Legajo());
cambioEstrategia(alumnos, new StratComparacion_Legajo());
break;
case 4:
cambioEstrategia(personas, new StratComparacion_Promedio());
//cambioEstrategia((IColeccionable<Persona>)personas, new StratComparacion_Promedio());
//cambioEstrategia((IColeccionable<Persona>)alumnos, new StratComparacion_Promedio());
cambioEstrategia(alumnos, new StratComparacion_Promedio());
break;
}
Console.WriteLine("Comparamos a1 con a2: \n" +
"sosIgual: " + a1.sosIgual(a2) + "\n" +
"sosMenor: " + a1.sosMenor(a2) + "\n" +
"sosMayor: " + a1.sosMayor(a2) + "\n\n" +
"Comparamos a3 con a4: \n" +
"sosIgual: " + a3.sosIgual(a4) + "\n" +
"sosMenor: " + a3.sosMenor(a4) + "\n" +
"sosMayor: " + a3.sosMayor(a4) + "\n\n" +
"Comparamos a5 con a6: \n" +
"sosIgual: " + a5.sosIgual(a6) + "\n" +
"sosMenor: " + a5.sosMenor(a6) + "\n" +
"sosMayor: " + a5.sosMayor(a6) + "\n\n"
);
if (!TipoEstrategia.Equals(3) && !TipoEstrategia.Equals(4))
{
Console.WriteLine("Comparamos p1 con p2: \n" +
"sosIgual: " + p1.sosIgual(p2) + "\n" +
"sosMenor: " + p1.sosMenor(p2) + "\n" +
"sosMayor: " + p1.sosMayor(p2) + "\n\n" +
"Comparamos p3 con p4: \n" +
"sosIgual: " + p3.sosIgual(p4) + "\n" +
"sosMenor: " + p3.sosMenor(p4) + "\n" +
"sosMayor: " + p3.sosMayor(p4) + "\n\n" +
"Comparamos p5 con p6: \n" +
"sosIgual: " + p5.sosIgual(p6) + "\n" +
"sosMenor: " + p5.sosMenor(p6) + "\n" +
"sosMayor: " + p5.sosMayor(p6) + "\n\n"
);
}
}
static void Main(string[] args)
{
int menugeneral;
do
{
Console.WriteLine("\n------MENÚ GENERAL------\n" +
"1.- Cola\n" +
"2.- Pila\n" +
"3.- Salir\n");
Console.WriteLine("Escoja una de las opciones");
menugeneral = int.Parse(Console.ReadLine());
switch (menugeneral)
{
case 1:
Cola c = new Cola();
int menu;
do
{
Console.WriteLine("\n------MENÚ DE LA COLA-----\n" +
"1.- Insertar\n" +
"2.- Buscar\n" +
"3.- Modificar\n" +
"4.- Eliminar\n" +
"5.- Desplegar\n" +
"6.- Salir del menú\n");
Console.WriteLine("Escoja una de las opciones");
menu = int.Parse(Console.ReadLine());
switch (menu)
{
case 1:
Console.WriteLine("\nINSERTAR NODO EN LA LISTA\n");
c.InsertarNodo();
break;
case 2:
Console.WriteLine("\nBUSCAR NODO EN LA LISTA\n");
c.buscarnodo();
break;
case 3:
Console.WriteLine("\nMODIFICAR NODO EN LA LISTA\n");
c.modificarnodo();
break;
case 4:
Console.WriteLine("\nELIMINAR NODO EN LA LISTA\n");
c.eliminarcola();
break;
case 5:
Console.WriteLine("\nDESPLEGAR NODOS DE LA LISTA\n");
c.desplegarCola();
break;
case 6:
Console.WriteLine("\nFIN DEL PROGRAMA DE LA COLA\n");
break;
default:
Console.WriteLine("\nINGRESE OPCIÓN VÁLIDA\n");
break;
}
} while (menu != 6);
break;
case 2:
Pila p = new Pila();
int menu2;
do
{
Console.WriteLine("\n------MENÚ DE LA PILA------\n" +
"1.- Insertar\n" +
"2.- Buscar\n" +
"3.- Modificar\n" +
"4.- Eliminar\n" +
"5.- Desplegar\n" +
"6.- Salir del menú\n");
Console.WriteLine("Escoja una de las opciones");
menu2 = int.Parse(Console.ReadLine());
switch (menu2)
{
case 1:
Console.WriteLine("\nINSERTAR NODO EN LA LISTA\n");
p.insertarNodoPila();
break;
case 2:
Console.WriteLine("\nBUSCAR NODO EN LA LISTA\n");
p.BuscarNodoPila();
break;
case 3:
Console.WriteLine("\nMODIFICAR NODO EN LA LISTA\n");
p.ModificarNodoPila();
break;
case 4:
Console.WriteLine("\nELIMINAR NODO EN LA LISTA\n");
p.EliminarNodoPila();
break;
case 5:
Console.WriteLine("\nDESPLEGAR NODOS DE LA LISTA\n");
p.DesplegarPila();
break;
case 6:
Console.WriteLine("\nFIN DEL PROGRAMA DE LA PILA\n");
break;
default:
Console.WriteLine("\nINGRESE OPCIÓN VÁLIDA\n");
break;
}
} while (menu2 != 6);
break;
case 3:
break;
default:
Console.WriteLine("\nINGRESE OPCIÓN VÁLIDA\n");
break;
}
} while (menugeneral != 3);
}
public void RequestGame(Pila p, string t, Cola c)
{
c.fillQueue();
Ad.MatchUp(p, t, c);
}
protected void Page_Load(object sender, EventArgs e)
{
LoadMovies();
Movie movie;
LinkedListDouble movies = (LinkedListDouble)Session["movies"];
Pila watchLater = (Pila)Session["watchLater"];
Cola myList = (Cola)Session["myList"];
movies.iniciarPrimero();
while (movies.getActual() != null)
{
movie = (Movie)movies.getActual();
if (movie.Category == "TV para niños")
{
String movieName = movie.Name;
if (movieName.Length > 32)
{
movieName = movieName.Substring(0, 33) + "...";
}
String search = "";
if (Request.QueryString["search"] != null)
{
search = Request.QueryString["search"].ToLower();
}
if (search == "" || (search != "" && movieName.ToLower().Contains(search)))
{
tvForChildren += "<div class='item'><a href='Views/Title.aspx?name=" + movieName + "&category=" + movie.Category + "&boton=0'><img src='" + movie.Picture + "' width='280' height='150' /></a><span title='" + movie.Name + "'><center><b>" + movieName + "</b></center></span></div>";
}
}
else if (movie.Category == "Drama")
{
String movieName = movie.Name;
if (movieName.Length > 32)
{
movieName = movieName.Substring(0, 33) + "...";
}
String search = "";
if (Request.QueryString["search"] != null)
{
search = Request.QueryString["search"].ToLower();
}
if (search == "" || (search != "" && movieName.ToLower().Contains(search)))
{
drama += "<div class='item'><a href='Views/Title.aspx?name=" + movieName + "&category=" + movie.Category + "&boton=0'><img src='" + movie.Picture + "' width='280' height='150' /></a><span title='" + movie.Name + "'><center><b>" + movieName + "</b></center></span></div>";
}
}
else if (movie.Category == "Acción y Aventura")
{
String movieName = movie.Name;
if (movieName.Length > 32)
{
movieName = movieName.Substring(0, 33) + "...";
}
String search = "";
if (Request.QueryString["search"] != null)
{
search = Request.QueryString["search"].ToLower();
}
if (search == "" || (search != "" && movieName.ToLower().Contains(search)))
{
actionNAdventure += "<div class='item'><a href='Views/Title.aspx?name=" + movieName + "&category=" + movie.Category + "&boton=0'><img src='" + movie.Picture + "' width='280' height='150' /></a><span title='" + movie.Name + "'><center><b>" + movieName + "</b></center></span></div>";
}
}
movies.next();
}
//Mostrar peliculas de Continuar viendo
try
{
Pila watchLaterMovies = watchLater.Clone();
while (watchLaterMovies.getPrimero() != null)
{
movie = (Movie)watchLaterMovies.getPrimero();
String movieName = movie.Name;
if (movieName.Length > 32)
{
movieName = movieName.Substring(0, 33) + "...";
}
String search = "";
if (Request.QueryString["search"] != null)
{
search = Request.QueryString["search"].ToLower();
}
if (search == "" || (search != "" && movieName.ToLower().Contains(search)))
{
strWatchLater += "<div class='item'><a href='Views/Title.aspx?name=" + movieName + "&category=" + movie.Category + "&boton=2'><img src='" + movie.Picture + "' width='280' height='150' /></a><span title='" + movie.Name + "'><center><b>" + movieName + "</b></center></span></div>";
}
watchLaterMovies.pop();
}
}
catch (Exception)
{
}
//Mostrar Peliculas de Mi lista
try
{
Cola myListMovies = myList.Clone();
while (myListMovies.getPrimero() != null)
{
movie = (Movie)myListMovies.getPrimero();
String movieName = movie.Name;
if (movieName.Length > 32)
{
movieName = movieName.Substring(0, 33) + "...";
}
String search = "";
if (Request.QueryString["search"] != null)
{
search = Request.QueryString["search"].ToLower();
}
if (search == "" || (search != "" && movieName.ToLower().Contains(search)))
{
strMyList += "<div class='item'><a href='Views/Title.aspx?name=" + movieName + "&category=" + movie.Category + "'&boton=0><img src='" + movie.Picture + "' width='280' height='150' /></a><span title='" + movie.Name + "'><center><b>" + movieName + "</b></center></span></div>";
}
myListMovies.pop();
}
}
catch (Exception)
{
}
}
public void createGame(Pila p, Cola c)
{
Debug.Log(p.pop() + " vs " + p.pop() + " se jugará en: " + c.rotate());
}
public void cargarPrograma(string path)
{
BinaryReader fent = new BinaryReader(
new FileStream(path,
FileMode.Open, FileAccess.Read));
//Cabecera
cab.magic = fent.ReadInt32();
cab.version = fent.ReadInt32();
cab.revision = fent.ReadInt32();
cab.programName = fent.ReadString();
cab.stackSize = fent.ReadInt32();
cab.heapSize = fent.ReadInt32();
cab.nLocals = fent.ReadInt32();
cab.nConst = fent.ReadInt32();
//Inicialización de estructuras
pc = 0;
codigo = new List<float>();
pila = new Pila(cab.nLocals);
heap = new List<string>(cab.heapSize);
//Literales
for (int i = 0; i < cab.nConst; i++)
{
heap.Add(fent.ReadString());
}
//Código
while (fent.PeekChar() != -1)
{
codigo.Add(fent.ReadSingle());
}
fent.Close();
}
public Form1()
{
InitializeComponent();
miPila = new Pila();
}
public ConcreteIterator_Pila(Pila in_lista)
{
this.lista = in_lista;
}
public ColeccionMultiple(Pila p, Cola c)
{
this.pila_colecion = p;
this.cola_coleccion = c;
}
public static void Run4()
{
// Verificacion del ejercicio 6 practica 3
// ------------------------------------- Llenar Pila --------------------------------------------------------------
Pila newPila = new Pila();
Console.Clear();
Console.WriteLine("1) Persona. \n" +
"2) Alumno. \n" +
"3) Numero. \n");
Console.Write("Por favor, ingrese que tipo de Comparable desea crear para llenar la Pila: ");
int eleccion_p = new LectorDeDatos(null).numeroPorTeclado();
llenar(newPila, eleccion_p);
//Console.Write("\nDesea mostrar los elementos que se generaron? (S/N): ");
//string eleccion_str = new LectorDeDatos().stringPorTeclado();
//if ("S".Equals(eleccion_str.ToUpper()))
//{
// Console.WriteLine("La Pila se llenó con los siguientes elementos: ");
//}
// ------------------------------------------------------------------------------------------------------------------
//-----------------------------------Llenar Cola --------------------------------------------------------------------
Cola newCola = new Cola();
Console.Clear();
Console.WriteLine("1) Persona. \n" +
"2) Alumno. \n" +
"3) Numero. \n");
Console.Write("Por favor, ingrese que tipo de Comparable desea crear para llenar la Cola: ");
int eleccion_c = new LectorDeDatos(null).numeroPorTeclado();
llenar(newCola, eleccion_c);
//Console.Write("\nDesea mostrar los elementos que se generaron? (S/N): ");
//eleccion_str = new LectorDeDatos().stringPorTeclado();
//if ("S".Equals(eleccion_str.ToUpper()))
//{
// Console.WriteLine("La Cola se llenó con los siguientes elementos: ");
// informar(newCola, eleccion);
//}
// --------------------------------------------------------------------------------------------------------------------
// --------------------------------- Llenar Conjunto ------------------------------------------------------------------
Conjunto newConjunto = new Conjunto();
Console.Clear();
Console.WriteLine("1) Persona. \n" +
"2) Alumno. \n" +
"3) Numero. \n");
Console.Write("Por favor, ingrese que tipo de Comparable desea crear para llenar el Conjunto: ");
int eleccion_cj = new LectorDeDatos(null).numeroPorTeclado();
llenar(newConjunto, eleccion_cj);
//Console.Write("\nDesea mostrar los elementos que se generaron? (S/N): ");
//eleccion_str = new LectorDeDatos().stringPorTeclado();
//if ("S".Equals(eleccion_str.ToUpper()))
//{
// Console.WriteLine("El Conjunto se llenó con los siguientes elementos: ");
// informar(newConjunto, eleccion);
//}
// --------------------------------------------------------------------------------------------------------------------
// --------------------------- Llenar Diccionario ---------------------------------------------------------------------
Diccionario newDiccionario = new Diccionario();
Console.Clear();
Console.WriteLine("1) Persona. \n" +
"2) Alumno. \n" +
//"3) ClaveValor (Este comparable es compuesto por Numero como Clave y Persona como Valor). \n" +
"3) Numero. \n");
Console.Write("Por favor, ingrese que tipo de Comparable desea crear para llenar el Diccionario: ");
int eleccion_d = new LectorDeDatos(null).numeroPorTeclado();
llenar(newDiccionario, eleccion_d);
//Console.Write("\nDesea mostrar los elementos que se generaron? (S/N): ");
//eleccion_str = new LectorDeDatos().stringPorTeclado();
//if ("S".Equals(eleccion_str.ToUpper()))
//{
// Console.WriteLine("El Diccionario se llenó con los siguientes elementos: ");
// informar(newDiccionario, eleccion);
//}
//---------------------------------------------------------------------------------------------------------------------
// ------------------------------------------- Informar Pila ----------------------------------------------------------
Console.Clear();
informar(newPila, eleccion_p);
Console.ReadKey();
// --------------------------------------------------------------------------------------------------------------------
// ------------------------------------------- Informar Cola ----------------------------------------------------------
Console.Clear();
informar(newCola, eleccion_c);
Console.ReadKey();
// --------------------------------------------------------------------------------------------------------------------
// ------------------------------------------- Informar Conjunto ----------------------------------------------------------
Console.Clear();
informar(newConjunto, eleccion_cj);
Console.ReadKey();
// --------------------------------------------------------------------------------------------------------------------
// ------------------------------------------- Informar Diccionario ----------------------------------------------------------
// ------------- Arreglar el informar para Diccionario.
//Console.Clear();
//informar(newDiccionario, eleccion_d);
//Console.ReadKey();
// --------------------------------------------------------------------------------------------------------------------
}
public PilaTests()
{
this.sut = new Pila();
}
