# data[].attributes.attachment_link.title
PROBLEMAS PREPARACION EXAMEN DE LIBERACION

# data[].attributes.attachment_link.readable_text
package main;

public class main {

	public static void main(String[] args) {
		//COMPETIDORES
		Participante m1 = new Participante("M1", 0);
        Participante m2 = new Participante("M2", 0);
        Participante m3 = new Participante("M3", 0);
        
        Participante c1 = new Participante("C1", 1);
        Participante c2 = new Participante("C2", 1);
        Participante c3 = new Participante("C3", 1);
        //-----------------------------------------
        Participante s1 = new Participante("S1", 0);
        Participante s2 = new Participante("S2", 0);
        Participante s3 = new Participante("S3", 0);
        
        Participante sc1 = new Participante("SC1", 1);
        //--------------------------------------------
        Participante i1 = new Participante("I1", 0);
        Participante i2 = new Participante("I2", 0);
        //-----------------------------------------
        Participante p1 = new Participante("P1", 0);
        Participante p2 = new Participante("P2", 0);
        Participante p3 = new Participante("P3", 0);
        
        Participante cp1 = new Participante("CP1", 1);
        Participante cp2 = new Participante("CP2", 1);
        //--------------------------------------------
        Participante ch1 = new Participante("CH1", 0);
        Participante ch2 = new Participante("CH2", 0);
        
        Participante chc1 = new Participante("CHC1", 1);
        //--------------------------------------------
        Participante q1 = new Participante("Q1", 0);
        Participante q2 = new Participante("Q2", 0);
        Participante q3 = new Participante("Q3", 0);
        
        Participante cq1 = new Participante("CQ1", 1);
        Participante cq2 = new Participante("CQ2", 1);
        //---------------------------------------------
        Participante o1 = new Participante("O1", 0);
        Participante o2 = new Participante("O2", 0);
        //-----------------------------------------
        Participante mo1 = new Participante("MO1", 0);
        Participante mo2 = new Participante("MO2", 0);
        Participante mo3 = new Participante("MO3", 0);
        //---------------------------------------------
        Participante d1 = new Participante("D1", 0);
        //-----------------------------------------------
        Participante ctf1 = new Participante("CTF1", 0);
        Participante ctf2 = new Participante("CTF2", 0);
        
        Participante ctc1 = new Participante("CTC1", 1);
        Participante ctc2 = new Participante("CTC2", 1);
        //---------------------------------------------
        
        Participante h1 = new Participante("H1", 0);
        Participante h2 = new Participante("H2", 0);
        Participante h3 = new Participante("H3", 0);
        
        Participante hc1 = new Participante("CH1", 1);
        Participante hc2 = new Participante("CH2", 1);
        
        //---------------------------------------------
        
        Participante ma1 = new Participante("MA1", 0);
        Participante ma2 = new Participante("MA2", 0);
        
        Participante mac1 = new Participante("MAC1", 1);
        Participante mac2 = new Participante("MAC2", 1);
        //---------------------------------------------
        //PILAS
        PilaParticipantes pilaM = new PilaParticipantes();
        PilaParticipantes pilaS = new PilaParticipantes();
        PilaParticipantes pilaI = new PilaParticipantes();
        PilaParticipantes pilaP = new PilaParticipantes();
        PilaParticipantes pilaCH = new PilaParticipantes();
        PilaParticipantes pilaQ = new PilaParticipantes();
        PilaParticipantes pilaO = new PilaParticipantes();
        PilaParticipantes pilaMO = new PilaParticipantes();
        PilaParticipantes pilaD = new PilaParticipantes();
        PilaParticipantes pilaCTF = new PilaParticipantes();
        PilaParticipantes pilaH = new PilaParticipantes();
        PilaParticipantes pilaMA = new PilaParticipantes();
        
        //ADICION
        pilaM.adicionar(m1);
        pilaM.adicionar(m2);
        pilaM.adicionar(m3);

        pilaS.adicionar(s1);
        pilaS.adicionar(s2);
        pilaS.adicionar(s3);

        pilaI.adicionar(i1);
        pilaI.adicionar(i2);

        pilaP.adicionar(p1);
        pilaP.adicionar(p2);
        pilaP.adicionar(p3);

        pilaCH.adicionar(ch1);
        pilaCH.adicionar(ch2);

        pilaQ.adicionar(q1);
        pilaQ.adicionar(q2);
        pilaQ.adicionar(q3);

        pilaO.adicionar(o1);
        pilaO.adicionar(o2);

        pilaMO.adicionar(mo1);
        pilaMO.adicionar(mo2);
        pilaMO.adicionar(mo3);

        pilaD.adicionar(d1);

        pilaCTF.adicionar(ctf1);
        pilaCTF.adicionar(ctf2);

        pilaH.adicionar(h1);
        pilaH.adicionar(h2);
        pilaH.adicionar(h3);

        pilaMA.adicionar(ma1);
        pilaMA.adicionar(ma2);
        
        
        PilaParticipantes pilaC = new PilaParticipantes();
        pilaC.adicionar(c1);
        pilaC.adicionar(c2);
        pilaC.adicionar(c3);

        PilaParticipantes pilaSC = new PilaParticipantes();
        pilaSC.adicionar(sc1);

        PilaParticipantes pilaCP = new PilaParticipantes();
        pilaCP.adicionar(cp1);
        pilaCP.adicionar(cp2);

        PilaParticipantes pilaCHC = new PilaParticipantes();
        pilaCHC.adicionar(chc1);

        PilaParticipantes pilaCQ = new PilaParticipantes();
        pilaCQ.adicionar(cq1);
        pilaCQ.adicionar(cq2);

        PilaParticipantes pilaCTC = new PilaParticipantes();
        pilaCTC.adicionar(ctc1);
        pilaCTC.adicionar(ctc2);

        PilaParticipantes pilaHC = new PilaParticipantes();
        pilaHC.adicionar(hc1);
        pilaHC.adicionar(hc2);

        PilaParticipantes pilaMAC = new PilaParticipantes();
        pilaMAC.adicionar(mac1);
        pilaMAC.adicionar(mac2);
        
        //equipos
        
        Equipo maquinolas = new Equipo(10, "Los Maquinolas", pilaM, pilaC);
        Equipo sabrosos = new Equipo(11, "Sabrosos", pilaS, pilaSC);
        Equipo mas_icpc = new Equipo(12, "MAS-ICPC", pilaI, new PilaParticipantes());
        Equipo perritos_m = new Equipo(13, "Perritos Malvados", pilaP, pilaCP);
        Equipo inChavola = new Equipo(14, "inChavola", pilaCH, pilaCHC);
        Equipo queperdio = new Equipo(15, "Que Perdio", pilaQ, pilaCQ);
        Equipo owo = new Equipo(16, "OWO", pilaO, new PilaParticipantes());
        Equipo monkeys = new Equipo(17, "Los Monkeys", pilaMO, new PilaParticipantes());
        Equipo don_gato = new Equipo(18, "Don Gato", pilaD, new PilaParticipantes());
        Equipo ctf = new Equipo(19, "CTF", pilaCTC, pilaCTC);
        Equipo heladito = new Equipo(20, "Heladito???", pilaH, pilaHC);
        Equipo manco_ders = new Equipo(21, "Manco-ders", pilaMA, pilaMAC);
        //nodos
        NodoA siete = new NodoA(7,maquinolas);  
        NodoA dos = new NodoA(2,sabrosos);  
        NodoA uno = new NodoA(1, mas_icpc);  
        NodoA cinco = new NodoA(5,perritos_m);  
        NodoA seis = new NodoA(6,inChavola);  
        NodoA nueve = new NodoA(9,queperdio);  
        NodoA ocho = new NodoA(8,owo);  
        NodoA diez = new NodoA(10,monkeys);  
        NodoA tres = new NodoA(3,don_gato);  
        NodoA cuatro = new NodoA(4,ctf);  
        NodoA catorce = new NodoA(14,heladito);  
        NodoA trece = new NodoA(13,manco_ders);  
        
        ArbolBinario bst1 = new ArbolBinario();
        bst1.insertar(new NodoA(7, maquinolas));
        bst1.insertar(new NodoA(2, sabrosos));
        bst1.insertar(new NodoA(1, mas_icpc));
        bst1.insertar(new NodoA(9, queperdio));
        bst1.insertar(new NodoA(8, owo));
        bst1.insertar(new NodoA(5, perritos_m));
        bst1.insertar(new NodoA(10, monkeys));

        ArbolBinario bst2 = new ArbolBinario();
        bst2.insertar(new NodoA(8, owo));
        bst2.insertar(new NodoA(3, don_gato));
        bst2.insertar(new NodoA(10, monkeys));
        bst2.insertar(new NodoA(14, heladito));
        bst2.insertar(new NodoA(1, mas_icpc));
        bst2.insertar(new NodoA(6, inChavola));
        bst2.insertar(new NodoA(4, ctf));
        bst2.insertar(new NodoA(7, maquinolas));
        bst2.insertar(new NodoA(13, manco_ders));
        
        ArbolBinario bst3 = new ArbolBinario();
        bst3.insertar(new NodoA(2, sabrosos));
        bst3.insertar(new NodoA(1, mas_icpc));
        bst3.insertar(new NodoA(4, ctf));
        bst3.insertar(new NodoA(3, don_gato));
        bst3.insertar(new NodoA(5, perritos_m));
        bst3.insertar(new NodoA(7, maquinolas));

        Bosque bosque = new Bosque(bst1);
        bosque.setAr(1, bst2);
        bosque.setAr(2, bst3);
        //bosque.mostrar();
        
        System.out.println("\n -------------------------------------------LISTA-------------------------------------------");
        ColaProblemas cola0 = new ColaProblemas();
        ColaProblemas cola1 = new ColaProblemas();
        ColaProblemas cola2 = new ColaProblemas();
        ColaIntento ac1 = new ColaIntento();
        ac1.adicionar(10);
        ac1.adicionar(11);
        ac1.adicionar(18);
        ColaIntento wa1 = new ColaIntento();
        wa1.adicionar(10);
        wa1.adicionar(13);
        wa1.adicionar(17);
        ColaIntento ce1 = new ColaIntento();
        ce1.adicionar(13);
        ce1.adicionar(16);
        //ce1.adicionar(15);
        ce1.adicionar(17);
        PilaCola pc1 = new PilaCola();
        pc1.adicionar(ac1);
        pc1.adicionar(wa1);
        pc1.adicionar(ce1);
        Problema pro1 =  new Problema(1, "PRO1", pc1);
        
        ColaIntento ac2 = new ColaIntento();
        ac2.adicionar(13);
        ac2.adicionar(15);
        ac2.adicionar(18);
        ColaIntento wa2 = new ColaIntento();
        wa2.adicionar(17);
        wa2.adicionar(13);
        ColaIntento ce2 = new ColaIntento();
        ce2.adicionar(10);
        PilaCola pc2 = new PilaCola();
        pc2.adicionar(ac2);
        pc2.adicionar(wa2);
        pc2.adicionar(ce2);
        Problema pro2 =  new Problema(2, "PRO2", pc2);
        
        ColaIntento ac3 = new ColaIntento();
        ac3.adicionar(11);
        ac3.adicionar(17);
        ac3.adicionar(15);
        ColaIntento wa3 = new ColaIntento();
        wa3.adicionar(10);
        //wa3.adicionar(15);
        wa3.adicionar(17);
        ColaIntento ce3 = new ColaIntento();
        ce3.adicionar(10);
        ce3.adicionar(13);
        PilaCola pc3 = new PilaCola();
        pc3.adicionar(ac3);
        pc3.adicionar(wa3);
        pc3.adicionar(ce3);
        Problema pro3 =  new Problema(3, "PRO3", pc3);
        
        ColaIntento ac8 = new ColaIntento();
        ac8.adicionar(16);
        ac8.adicionar(18);
        ac8.adicionar(12);
        ColaIntento wa8 = new ColaIntento();
        wa8.adicionar(20);
        wa8.adicionar(17);
        wa8.adicionar(21);
        ColaIntento ce8 = new ColaIntento();
        ce8.adicionar(16);
        ce8.adicionar(10);
        PilaCola pc8 = new PilaCola();
        pc8.adicionar(ac8);
        pc8.adicionar(wa8);
        pc8.adicionar(ce8);
        Problema pro8=  new Problema(8, "PRO8", pc8);
        
        ColaIntento ac9 = new ColaIntento();
        ac9.adicionar(19);
        ac9.adicionar(14);
        ac9.adicionar(16);
        ColaIntento wa9 = new ColaIntento();
        wa9.adicionar(14);
        wa9.adicionar(12);
        wa9.adicionar(20);
        ColaIntento ce9 = new ColaIntento();

        PilaCola pc9 = new PilaCola();
        pc9.adicionar(ac9);
        pc9.adicionar(wa9);
        pc9.adicionar(ce9);
        Problema pro9=  new Problema(9, "PRO9", pc9);
        
        ColaIntento ac10 = new ColaIntento();
        ac10.adicionar(20);
        ac10.adicionar(14);
        ac10.adicionar(18);
        ColaIntento wa10 = new ColaIntento();
        wa10.adicionar(16);
        wa10.adicionar(12);
        wa10.adicionar(20);
        ColaIntento ce10 = new ColaIntento();
        ce10.adicionar(20);
        PilaCola pc10 = new PilaCola();
        pc10.adicionar(ac10);
        pc10.adicionar(wa10);
        pc10.adicionar(ce10);
        Problema pro10=  new Problema(10, "PRO10", pc10);
        
        ColaIntento ac11 = new ColaIntento();
        ac11.adicionar(11);
        ac11.adicionar(12);
        ac11.adicionar(18);
        ColaIntento wa11 = new ColaIntento();
        wa11.adicionar(10);
        wa11.adicionar(14);
        wa11.adicionar(19);
        ColaIntento ce11 = new ColaIntento();
        ce11.adicionar(13);
        PilaCola pc11 = new PilaCola();
        pc10.adicionar(ac11);
        pc10.adicionar(wa11);
        pc10.adicionar(ce11);
        Problema pro11=  new Problema(11, "PRO11", pc10);
        cola0.adicionar(pro1);
        cola0.adicionar(pro2);
        cola0.adicionar(pro3);
        
        cola1.adicionar(pro8);
        cola1.adicionar(pro9);
        cola1.adicionar(pro10);
        
        cola2.adicionar(pro1);
        cola2.adicionar(pro11);
        
        LDC_SETS lista = new LDC_SETS();
        lista.anadir(cola0);
        lista.anadir(cola1);
        lista.anadir(cola2);
        lista.mostrar();
        
        System.out.println();
        
        
        //Dado un ID de problema y un aÃ±o, verifica si el problema estÃ¡ en la lista y muestra su tÃ­tulo.
        
        /*int idX = Leer.datoInt();
        int anoX = Leer.datoInt();
        System.out.println(estaEnAno(anoX, idX, lista));
        */
        
        //Del primer aÃ±o, dado un ID de problema, el nombre de un equipo y el resultado del intento (AC, WA o CE), agrega el equipo a la cola correspondiente.
        /*int ranking = Leer.datoInt();
        int idX = Leer.datoInt();
        int resultado = Leer.datoInt(); // 1 AC, 2 WA, 3 CE
        System.out.println("----------------------------------------------------------");
        lista.mostrar();
        agregarIntento(ranking, idX, resultado, lista, bosque);
        System.out.println("----------------------------------------------------------");
        lista.mostrar();*/
        
        //Para un problema con ID X especÃ­fico en un aÃ±o, cuenta cuÃ¡ntos intentos hay en cada categorÃ­a (AC, WA, CE).
        
        /*int idX = Leer.datoInt();
        int anoX = Leer.datoInt();
        int can_ac = cantidadEnvios(idX, anoX, lista, 1);
        int can_wa = cantidadEnvios(idX, anoX, lista, 2);
        int can_ce = cantidadEnvios(idX, anoX, lista, 3);
        
        System.out.println(can_ac+" "+can_wa+" "+can_ce);*/
        
        //Dado el ranking de un equipo y un aÃ±o, verifica si aparece en alguna cola WA o CE.
        int ranking = Leer.datoInt();
        int anoX = Leer.datoInt();
        int idE = obtIdE(bosque.getAr(anoX).getRaiz(), ranking);
        boolean sw = envioWAoCE(idE, anoX, lista);
        System.out.println(sw);
	}

	private static boolean envioWAoCE(int idE, int anoX, LDC_SETS lista) {
		boolean sw = false;
		NodoL r =lista.getRaiz();
		if(r == null) {
			return false;
		}
		else {
			NodoL actual = r;
			int i = 0;
			while(actual.getSig() != r) {
				if(i == anoX) {
					ColaProblemas cp = actual.getCp();
					ColaProblemas aux = new ColaProblemas();
					while(!cp.esvacia()) {
						Problema pro = cp.eliminar();
						PilaCola pc = pro.getPilaC();
						PilaCola paux =  new PilaCola();
						int j = 3;
						while(!pc.esvacia()) {
							ColaIntento ci = pc.eliminar();
							ColaIntento pci = new ColaIntento();
							if(j >= 2) {
								while(!ci.esvacia()) {
									int intento = ci.eliminar();
									if(intento == idE) {
										sw = true;
									}
									pci.adicionar(intento);
								}
								ci.vaciar(pci);
							}
							paux.adicionar(ci);
							j--;
						}
						pc.vaciar(paux);
						aux.adicionar(pro);
						pro.setPilaC(pc);
					}
					cp.vaciar(aux);
					actual.setCp(cp);
				}
				
				i++;
				actual = actual.getSig();
			}
			if(i == anoX) {
				ColaProblemas cp = actual.getCp();
				ColaProblemas aux = new ColaProblemas();
				while(!cp.esvacia()) {
					Problema pro = cp.eliminar();
					PilaCola pc = pro.getPilaC();
					PilaCola paux =  new PilaCola();
					int j = 3;
					while(!pc.esvacia()) {
						ColaIntento ci = pc.eliminar();
						ColaIntento pci = new ColaIntento();
						if(j >= 2) {
							while(!ci.esvacia()) {
								int intento = ci.eliminar();
								if(intento == idE) {
									sw = true;
								}
								pci.adicionar(intento);
							}
							ci.vaciar(pci);
						}
						paux.adicionar(ci);
						j--;
					}
					pc.vaciar(paux);
					aux.adicionar(pro);
					pro.setPilaC(pc);
				}
				cp.vaciar(aux);
				actual.setCp(cp);
			}
		}
		
		return sw;
	}

	private static int cantidadEnvios(int idX, int anoX, LDC_SETS lista, int tipo) {
		int cantidad = 0;
		NodoL r =  lista.getRaiz();
		if(r == null) {
			return -1;
		}
		else {
			NodoL actual = r;
			int i = 0;
			while(actual.getSig() != r) {
				if(i == anoX) {
					ColaProblemas cp = actual.getCp();
					ColaProblemas aux =  new ColaProblemas();
					while(!cp.esvacia()) {
						Problema pro = cp.eliminar();
						if(pro.getId() == idX) {
							PilaCola pc = pro.getPilaC();
							PilaCola paux = new PilaCola();
							int j = 3;
							while(!pc.esvacia()) {
								ColaIntento ci = pc.eliminar();
								if(j == tipo) {
									cantidad = ci.nroelem();
								}
								paux.adicionar(ci);
								j--;
							}
							pc.vaciar(paux);
							
						}
						aux.adicionar(pro);						
					}
					cp.vaciar(aux);
				}
				actual  = actual.getSig();	
				i++;
			}
			if(i == anoX) {
				ColaProblemas cp = actual.getCp();
				ColaProblemas aux =  new ColaProblemas();
				while(!cp.esvacia()) {
					Problema pro = cp.eliminar();
					if(pro.getId() == idX) {
						PilaCola pc = pro.getPilaC();
						PilaCola paux = new PilaCola();
						int j = 3;
						while(!pc.esvacia()) {
							ColaIntento ci = pc.eliminar();
							if(j == tipo) {
								cantidad = ci.nroelem();
							}
							paux.adicionar(ci);
							j--;
						}
						pc.vaciar(paux);
						
					}
					aux.adicionar(pro);						
				}
				cp.vaciar(aux);
			}
		}
		return cantidad;
	}

	private static void agregarIntento(int ranking, int idX, int resultado, LDC_SETS lista, Bosque bosque) {
		ArbolBinario a = bosque.getAr(0);
		int idE = obtIdE(a.getRaiz(), ranking);
		if(idE == 0) {
			System.out.println("No existe el Equipo con Ranking"+ranking);
		}
		else {
			NodoL r = lista.getRaiz();
			if(r == null) {
				System.out.println("La lista esta vacia");
			}
			else {
				NodoL actual = r;
				int i = 0;
				while(actual.getSig() != r) {
					if(i == 0) {
						ColaProblemas cp = actual.getCp();
						ColaProblemas aux = new ColaProblemas();
						while(!cp.esvacia()) {
							Problema pro = cp.eliminar();
							if(pro.getId() == idX) {
								PilaCola p = pro.getPilaC();
								PilaCola paux = new PilaCola();
								int j = 3;
								while(!p.esvacia()) {
									ColaIntento ci = p.eliminar();
									if(j == resultado) {
										ci.adicionar(idE);
									}
									j--;
									paux.adicionar(ci);
								}
								p.vaciar(paux);
								pro.setPilaC(p);
							}
							aux.adicionar(pro);
						}
						cp.vaciar(aux);
					}
					i++;
					actual = actual.getSig();
				}
				if(i == 0) {
					ColaProblemas cp = actual.getCp();
					ColaProblemas aux = new ColaProblemas();
					while(!cp.esvacia()) {
						Problema pro = cp.eliminar();
						if(pro.getId() == idX) {
							PilaCola p = pro.getPilaC();
							PilaCola paux = new PilaCola();
							int j = 3;
							while(!p.esvacia()) {
								ColaIntento ci = p.eliminar();
								if(j == resultado) {
									ci.adicionar(idE);
								}
								j--;
								paux.adicionar(ci);
							}
							p.vaciar(paux);
							pro.setPilaC(p);
						}
						aux.adicionar(pro);
					}
					cp.vaciar(aux);
				}
				i++;
				
			}
		}
	}

	private static int obtIdE(NodoA raiz, int ranking) {
		if(raiz == null) {
			return 0;
		}
		if(raiz.getRanking() == ranking) {
			return raiz.getE().getId();
		}
		if(ranking < raiz.getRanking()) {
			return obtIdE(raiz.getIzq(), ranking);
		}
		else {
			return obtIdE(raiz.getDer(), ranking);
		}
	}

	private static String estaEnAno(int anoX, int idX, LDC_SETS lista) {
		String res = "No existe ese problema en el aÃ±o";
		NodoL r = lista.getRaiz();
		if(r == null) {
			return "La lista esta vacia";
		}
		else {
			NodoL actual = r;
			int i = 0;
			while(actual.getSig() != r) {
				if(i == anoX) {
					ColaProblemas cp = actual.getCp();
					ColaProblemas aux = new ColaProblemas();
					while(!cp.esvacia()) {
						Problema pro = cp.eliminar();
						if(pro.getId() == idX) {
							res = pro.getTitulo();
						}
						aux.adicionar(pro);
					}
					cp.vaciar(aux);
					actual.setCp(cp);
				}
				actual = actual.getSig();
				i++;
			}
			if(i == anoX) {
				ColaProblemas cp = actual.getCp();
				ColaProblemas aux = new ColaProblemas();
				while(!cp.esvacia()) {
					Problema pro = cp.eliminar();
					if(pro.getId() == idX) {
						res = pro.getTitulo();
					}
					aux.adicionar(pro);
				}
				cp.vaciar(aux);
				actual.setCp(cp);
			}
			actual = actual.getSig();
			i++;
		}
		
		return res;
	}
	
}
