content: /* Integrantes:
   * Garcia Delgado Jorge Alberto
   * Lopez Sanchez Ary Daniel
   * 
   * Repositorio Github:
   * https://github.com/Alberto2425/SimuladordeProcesos
   */
  import java.util.Scanner;
  import java.util.Random;
  import java.util.ArrayList;
  import java.util.Collections;
  public class Main {
  	static Reporte r=new Reporte();
  	static Random random = new Random();
  	static I Comparator=new I();
  	static ArrayList<Proceso> c2=new ArrayList<Proceso>();
  	static int tiempoM=random.nextInt(11)+18;
  	static int nUsuarios = 2;
  	static int quantum=random.nextInt(4)+1;
  	public static void main(String[] args) {
  		Scanner leer=new Scanner(System.in);
  		String cadena;
  		int tipoPlanificacion;
  		int tipoAlgoritmo;
  		Random random = new Random();
  		int nProcesos = random.nextInt(5) + 5;
  		ArrayList<Proceso>procesos=new ArrayList<Proceso>();
  
  		//menu
  		do{
  			for(int i=0; i<nProcesos; i++) {
  				Proceso p=new Proceso(quantum);
  				procesos.add(p);
  			}
  
  			System.out.println("Que tipo de algoritmo de planificacion usar por default?");
  			System.out.println("1.- apropiativo \n2.- no apropiativo\n3.- Cerrar programa");
  
  			do{
  				cadena=leer.nextLine();
  				if(isNumeric(cadena)==true){
  					tipoPlanificacion = Integer.parseInt(cadena);
  				}else{
  					tipoPlanificacion=3;
  				}
  				if(tipoPlanificacion<1 || tipoPlanificacion>3){
  					System.out.println("Agregue un dato entero entre 1 y 3 para continuar.\n1.- apropiativo n\2.- no apropiativo\2.- Cerrar Programa");
  				}
  			}while(tipoPlanificacion<1 || tipoPlanificacion>3);
  			if(tipoPlanificacion==3){break;}
  				
  			System.out.println("Que algoritmo usaras?");
  			System.out.println("1.- Round-robin\n2.- Prioridades\n3.- Multiples colar de prioridad\n4.- Proceso mas corto primero\n5.- Participacion garantizada\n6.-Boletos de Loteria\n7.- Participacion equitativa");
  			do{
  				cadena=leer.nextLine();
  				if(isNumeric(cadena)==true){
  					tipoAlgoritmo = Integer.parseInt(cadena);
  				}else{
  					tipoAlgoritmo=7;
  				}
  				if(tipoAlgoritmo<1 || tipoAlgoritmo>6){
  					System.out.println("Agregue un dato entero entre 1 al 7.");
  					System.out.println("1.- Round-robin\n2.- Prioridades\n3.- Multiples colar de prioridad\n4.- Proceso mas corto primero\n5.- Planificación garantizada\n6.-Boletos de Loteria\n7.- Participacion equitativa");
  				}
  			}while(tipoAlgoritmo<1 || tipoAlgoritmo>7);
  
  			
  			imprimirEspecificacionesGenerales(procesos, tipoPlanificacion, tipoAlgoritmo, nProcesos);
  
  			switch (tipoAlgoritmo) {
  				case 1:
  					//Llamar al metodo RoundRobin
  					roundRobin(procesos, tipoPlanificacion);
  					break;
  				case 2:
  					// Llamar al método de Prioridades
  					prioridades(procesos, tipoPlanificacion);
  					break;
  				case 3:
  					// Llamar al método de Múltiples colas de prioridad
  					prioridadesMultiples(procesos, tipoPlanificacion);
  					break;
  				case 4:
  					// Llamar al método de Proceso más corto primero
  					cortoF(procesos,tipoPlanificacion);
  					break;
  				case 5:
  					// Llamar al método de Planificacion Garantizada
  					planificacionG(procesos, tipoPlanificacion);
  					break;
  				case 6:
  					// Llamar al método de Boletos de loteria
  					boletos(procesos, tipoPlanificacion);
  					break;
  				case 7:
  					// Llamar al método de Participacion equitativa
  					participacionEquitativa(procesos, tipoPlanificacion);
  					break;
  				default:
  					System.out.println("Opción no válida");
  			}
  				Ejecuto(procesos);
  			r.imprimirReporte();
  			imprimirProcesos(procesos);
  			tiempoM=random.nextInt(11)+15;
  
  			nProcesos = random.nextInt(10) + 1;
  		}while(tipoPlanificacion!=3);
  
  		leer.close();
  	}
  		
  	//Round-Robin
  	public static void roundRobin(ArrayList<Proceso>c,int tipoPlanificacion) {
  		System.out.println("El tiempo de simulacion es : "+tiempoM);
  		imprimirProcesos(c);
  		if(tipoPlanificacion==1/*Apropiativo */){
  			//con cada iteracion entra un proceso nuevo.
  			for(int i=0;i<c.size();i++){
  				if(tiempoM<=0){break;}
  				r.setD(1);
  				System.out.print(". Entra Proceso "+c.get(i).getId()+" ");
  				//se verifica que el proceso este listo
  				if(c.get(i).getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					c.get(i).setEstado(random.nextInt(2)+1);
  				}
  				if(c.get(i).getEstado()==2){
  					//si el proceso esta listo se resta el valor del quantum al tiempo restante
  					c.get(i).setTiempoR(c.get(i).getTiempoR()-c.get(i).getQuantum());
  					tiempoM-=c.get(i).getQuantum();
  					if(tiempoM<=0){
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-tiempoM);
  						tiempoM=0;
  					}
  					if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  						r.setA(c.get(i).getId());
  						System.out.print(", se ejecuta "+(c.get(i).getQuantum()+c.get(i).getTiempoR())+" unidades y termina\n");
  						tiempoM-=c.get(i).getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(i);/*se remueve el proceso de la lista*/
  						i--;
  					}else{
  						System.out.print(", se ejecuta "+c.get(i).getQuantum()+" unidades\n");
  						c.get(i).setQuantum(c.get(i).getQuantum()*2);/*Si el proceso no termino el quantum se dobla*/
  					}
  				}else{
  					System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */
  				}
  				if(i==c.size()-1){i=-1;}
  			}
  		}else{/*No Apropiativo */
  			int x=0;
  			int xaux=0;
  			for(int i=0;i<c.size();i++){
  				if(tiempoM<=0){break;}
  				r.setD(1);
  				System.out.print(". Entra Proceso "+c.get(i).getId()+" ");
  				//se verifica que el proceso este listo
  				if(c.get(i).getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					c.get(i).setEstado(random.nextInt(2)+1);
  				}
  				if(c.get(i).getEstado()==2){
  					//si el proceso esta listo se resta el valor un valor aleatorio al tiempo restante
  					for(int j=0;j<200;j++){
  						x=random.nextInt(3)+2;
  						xaux+=x;
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-x);
  						tiempoM-=x;
  						if(tiempoM<=0){
  							c.get(i).setTiempoR(c.get(i).getTiempoR()-tiempoM);
  							xaux+=tiempoM;
  							tiempoM=0;
  						}
  					if(tiempoM<=0){
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-tiempoM);
  						xaux+=tiempoM;
  						tiempoM=0;
  					}
  						if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  							xaux+=c.get(i).getTiempoR();
  							break;
  						}
  						c.get(i).setEstado(random.nextInt(2)+1);
  						if(c.get(i).getEstado()!=2){
  							c.get(i).setEstado(random.nextInt(2)+1);
  							break;
  						}
  					}
  					if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  						System.out.print(", se ejecuta "+xaux+" unidades y termina\n");
  						r.setA(c.get(i).getId());
  						tiempoM=tiempoM-c.get(i).getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(i);/*se remueve el proceso de la lista*/
  						i--;
  					}else{
  						System.out.print(", se ejecuta "+xaux+" unidades\n");
  						/*Si el proceso no termino*/
  					}
  				}else{System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */}
  				x=0;
  				xaux=0;
  				if(i==c.size()-1){i=-1;}
  			}
  		}
  	}
  	
  	//método de Prioridades
  	public static void prioridades(ArrayList<Proceso>c,int tipoPlanificacion) {
  		Collections.sort(c);
  		roundRobin(c, tipoPlanificacion);
  	}
  
  	//método de Múltiples colas de prioridad
  	public static void prioridadesMultiples(ArrayList<Proceso>c,int tipoPlanificacion) {
  		ArrayList<Proceso> p4=new ArrayList<Proceso>();
  		ArrayList<Proceso> p3=new ArrayList<Proceso>();
  		ArrayList<Proceso> p2=new ArrayList<Proceso>();
  		ArrayList<Proceso> p1=new ArrayList<Proceso>();
  		for(int i=0;i<c.size();i++){
  			if(c.get(i).getPrioridad()==4){
  				p4.add(c.get(i));
  			}
  			if(c.get(i).getPrioridad()==3){
  				p3.add(c.get(i));
  			}
  			if(c.get(i).getPrioridad()==2){
  				p2.add(c.get(i));
  			}
  			if(c.get(i).getPrioridad()==1){p1.add(c.get(i));}
  		}
  		roundRobin(p4, tipoPlanificacion);
  		roundRobin(p3, tipoPlanificacion);
  		roundRobin(p2, tipoPlanificacion);
  		roundRobin(p1, tipoPlanificacion);
  
  		for(int i=c.size()-1;i>-1;i--){
  			c.remove(0);
  		}
  		for(int i=0;i<p4.size();i++){
  			c2.add(p4.get(i));
  		}
  		for(int i=0;i<p3.size();i++){
  			c2.add(p3.get(i));
  		}
  		for(int i=0;i<p2.size();i++){
  			c2.add(p2.get(i));
  		}
  			for(int i=0;i<p1.size();i++){
  			c2.add(p1.get(i));
  		}
  		for(int i=0;i<c2.size();i++){
  			c.add(c2.get(i));
  		}
  
  	}
  
  	// 4 - método de Proceso más corto primero
  	public static void cortoF(ArrayList<Proceso>c,int tipoPlanificacion){
  		System.out.println("El tiempo de simulacion es : "+tiempoM);
  		imprimirProcesos(c);
  
  		Collections.sort(c,Comparator);
  		roundRobin(c, tipoPlanificacion); 
  	}
  
  	//método de Planificacion Garantizada
  	public static void planificacionG(ArrayList<Proceso>c,int tipoPlanificacion) {
  		ArrayList<Proceso> usuario1 = new ArrayList<Proceso>();
  		ArrayList<Proceso> usuario2 = new ArrayList<Proceso>();
  		
  		for(int i=0;i<c.size();i++){
  			if(c.get(i).getPrioridad()==4 || c.get(i).getPrioridad()==2){
  				usuario1.add(c.get(i));
  			}
  			if(c.get(i).getPrioridad()==3 || c.get(i).getPrioridad()==1){
  				usuario2.add(c.get(i));
  			}
  		}
  
  		imprimirProcesos(usuario1);
  		imprimirProcesos(usuario2);
  		recoridoDeParticiones(usuario1, tipoPlanificacion, 2);
  		recoridoDeParticiones(usuario2, tipoPlanificacion, 2);
      }
  
  	// 6 - método de Boletos de loteria
  	public static void boletos(ArrayList<Proceso>c,int tipoPlanificacion) {
  		System.out.println("El tiempo de simulacion es : "+tiempoM);
  		imprimirProcesos(c);
  		
  		System.out.println("\nInforme de ejecución con Boletos de Lotería:");
  		if(tipoPlanificacion==1){
  			do{
  				if(c.size() <= 0){
  					break;
  				}
  				Proceso proceso = calcularSorteoBoleto(c);
  				r.setD(1);
  				System.out.print("Entra Proceso "+proceso.getId()+" ");
  				if(proceso.getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					proceso.setEstado(random.nextInt(2)+1);
  				}
  				if(proceso.getEstado()==2){
  					//si el proceso esta listo se resta el valor del quantum al tiempo restante
  					proceso.setTiempoR(proceso.getTiempoR()-proceso.getQuantum());
  					tiempoM-=proceso.getQuantum();
  					if(tiempoM<=0){
  						proceso.setTiempoR(proceso.getTiempoR()-tiempoM);
  						tiempoM=0;
  					}
  					if(proceso.getTiempoR()<=0/*El proceso termino*/){
  						r.setA(proceso.getId());
  						System.out.print(", se ejecuta "+(proceso.getQuantum()+proceso.getTiempoR())+" unidades y termina\n");
  						tiempoM-=proceso.getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(proceso);
  					}else{
  						System.out.print(", se ejecuta "+proceso.getQuantum()+" unidades\n");
  						proceso.setQuantum(proceso.getQuantum()*2);/*Si el proceso no termino el quantum se dobla*/
  					}
  				}else{
  					System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */
  				}
  			}while(tiempoM > 0);
  		
  		}else{/*No Apropiativo */
  			do{
  				int x=0;
  				int xaux=0;
  				if(tiempoM<=0){break;}
  				if(c.size() <= 0){break;}
  				r.setD(1);
  				Proceso proceso = calcularSorteoBoleto(c);
  				System.out.print("Entra Proceso "+proceso.getId()+" ");
  				//se verifica que el proceso este listo
  				if(proceso.getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					proceso.setEstado(random.nextInt(2)+1);
  				}
  				if(proceso.getEstado()==2){
  					//si el proceso esta listo se resta el valor un valor aleatorio al tiempo restante
  					for(int j=0;j<200;j++){
  						x=random.nextInt(3)+2;
  						xaux+=x;
  						proceso.setTiempoR(proceso.getTiempoR()-x);
  						tiempoM-=x;
  					if(tiempoM<=0){
  						proceso.setTiempoR(proceso.getTiempoR()-tiempoM);
  						xaux+=tiempoM;
  						tiempoM=0;
  					}
  						if(proceso.getTiempoR()<=0/*El proceso termino*/){
  							xaux+=proceso.getTiempoR();
  							break;
  						}
  						proceso.setEstado(random.nextInt(2)+1);
  						if(proceso.getEstado()!=2){
  							proceso.setEstado(random.nextInt(2)+1);
  							break;
  						}
  					}
  					if(proceso.getTiempoR()<=0/*El proceso termino*/){
  						System.out.print(", se ejecuta "+xaux+" unidades y termina\n");
  						r.setA(proceso.getId());
  						tiempoM=tiempoM-proceso.getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(proceso);
  					}else{
  						System.out.print(", se ejecuta "+xaux+" unidades\n");
  						/*Si el proceso no termino*/
  					}
  				}else{System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */}
  			}while(tiempoM > 0);
  		}	
      }
  	
  	// 7 - método de Participacion Equitativa
  	public static void participacionEquitativa(ArrayList<Proceso>c,int tipoPlanificacion) {
  		int nProcesosUsuario1=0;
  		int nProcesosUsuario2=0;
  		ArrayList<Proceso> usuario1 = new ArrayList<Proceso>();
  		ArrayList<Proceso> usuario2 = new ArrayList<Proceso>();
  		
  		for(int i=0;i<c.size();i++){
  			if(c.get(i).getPrioridad()==4 || c.get(i).getPrioridad()==2){
  				usuario1.add(c.get(i));
  				nProcesosUsuario1++;
  			}
  			if(c.get(i).getPrioridad()==3 || c.get(i).getPrioridad()==1){
  				usuario2.add(c.get(i));
  				nProcesosUsuario2++;
  			}
  		}
  
  		imprimirProcesos(usuario1);
  		imprimirProcesos(usuario2);
  		recoridoDeParticiones(usuario1, tipoPlanificacion, nProcesosUsuario1);
  		recoridoDeParticiones(usuario2, tipoPlanificacion, nProcesosUsuario2);
      
      }
  
  	// static Proceso indica el tipo de valor que este método va a devolver 
  	private static Proceso calcularSorteoBoleto(ArrayList<Proceso> c) {
  		int total = 0;			
  		for(int i=0;i<c.size();i++){
  			total += c.get(i).getBoletos();
  		}
  		int boletoGanador = random.nextInt(total) + 1;
  		int acumulador = 0;
  		for(int i=0;i<c.size();i++){
  			acumulador += c.get(i).getBoletos();
  			if (boletoGanador <= acumulador) {
  				return c.get(i);
  			}
  		}
  		return null;
  	}
  
  	public static boolean isNumeric(String cadena) {
          boolean resultado;
  
          try {
              Integer.parseInt(cadena);
              resultado = true;
          } catch (NumberFormatException excepcion) {
              resultado = false;
          }
  
          return resultado;
      }
  
  	public static void Ejecuto(ArrayList<Proceso>c){
  		for(int i=0;i<c.size();i++){
  			if(c.get(i).getSeEjecuto()==true){
  				r.setC(c.get(i).getId());
  			}
  			if(c.get(i).getSeEjecuto()==false){
  				r.setB(c.get(i).getId());
  			}
  		}
  	}
  	
  	public static void imprimirProcesos(ArrayList<Proceso>c){
  		System.out.println("=================================================");
  		System.out.println("|| proceso || TiempoRes || estado || prioridad ||");
  		System.out.println("=================================================");
  		for(int i=0;i<c.size();i++){
  			System.out.println(c.get(i).toString());		
  		}
  		System.out.println("=================================================");
  	}
  
  	public static void imprimirEspecificacionesGenerales(ArrayList<Proceso> c, int tipoPlanificacion, int tipoAlgoritmo, int nProcesos){
  		int total = 0;			
  		for(int i=0;i<c.size();i++){
  			total += c.get(i).getBoletos();
  		}
  		System.out.println("**************************************************");
  		System.out.println("************ESPECIFICACIONES GENERALES************");
  		if(tipoPlanificacion == 1){
  			System.out.println("tipo planificacion: APROPIATIVO");
  		}else{
  			System.out.println("tipo planificacion: NO APROPIATIVO");
  		}
  		switch (tipoAlgoritmo) {
  			case 1:
  				System.out.println("tipo planificacion: Round-Robin");
  				break;
  			case 2:
  				System.out.println("tipo planificacion: Prioridades");
  				break;
  			case 3:
  				System.out.println("tipo planificacion: Múltiples colas de prioridad");
  				break;
  			case 4:
  				System.out.println("tipo planificacion: Proceso más corto primero");
  				break;
  			case 5:
  				System.out.println("tipo planificacion: Planificacion Garantizada");
  				break;
  			case 6:
  				System.out.println("tipo planificacion: Boletos de loteria");
  				break;
  			case 7:
  				System.out.println("tipo planificacion: Participacion equitativa");
  				break;
  		}
  		System.out.println("tipo algoritmo: "+tipoAlgoritmo);
  		System.out.println("quantum: "+quantum);
  		System.out.println("prioridad:");
  		if((tipoAlgoritmo == 1 ) || (tipoAlgoritmo == 2 ) || (tipoAlgoritmo == 4 ) || (tipoAlgoritmo == 6 )){
  			System.out.println("No. Usuarios:"+ 1);
  		}else if(tipoAlgoritmo == 3){
  			System.out.println("No. Usuarios:"+ 4);
  		}else{ // 5 - Planificacion Garantizada, 7 - Participacion Equitativa
  			System.out.println("No. Usuarios:"+ nUsuarios);
  		}
  		System.out.println("No. Procesos:"+ nProcesos);
  		if(tipoAlgoritmo == 6){
  			System.out.println("boletos:" + total);
  		}
  		System.out.println("**************************************************");
  	}
  
  	public static void recoridoDeParticiones(ArrayList<Proceso> c, int tipoPlanificacion, int nCantidad){
  		
  		int cpuPorProceso = tiempoM / nCantidad;
  		
  		if(tipoPlanificacion==1/*Apropiativo */){
  			//con cada iteracion entra un proceso nuevo.
  			for(int i=0;i<c.size();i++){
  				if(cpuPorProceso<=0){break;}
  				r.setD(1);
  				System.out.print(". Entra Proceso "+c.get(i).getId()+" ");
  				//se verifica que el proceso este listo
  				if(c.get(i).getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					c.get(i).setEstado(random.nextInt(2)+1);
  				}
  				if(c.get(i).getEstado()==2){
  					//si el proceso esta listo se resta el valor del quantum al tiempo restante
  					c.get(i).setTiempoR(c.get(i).getTiempoR()-c.get(i).getQuantum());
  					cpuPorProceso-=c.get(i).getQuantum();
  					if(cpuPorProceso<=0){
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-cpuPorProceso);
  						cpuPorProceso=0;
  					}
  					if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  						r.setA(c.get(i).getId());
  						System.out.print(", se ejecuta "+(c.get(i).getQuantum()+c.get(i).getTiempoR())+" unidades y termina\n");
  						cpuPorProceso-=c.get(i).getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(i);/*se remueve el proceso de la lista*/
  						i--;
  					}else{
  						System.out.print(", se ejecuta "+c.get(i).getQuantum()+" unidades\n");
  						c.get(i).setQuantum(c.get(i).getQuantum()*2);/*Si el proceso no termino el quantum se dobla*/
  					}
  				}else{
  					System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */
  				}
  				if(i==c.size()-1){i=-1;}
  			}
  		}else{/*No Apropiativo */
  			int x=0;
  			int xaux=0;
  			for(int i=0;i<c.size();i++){
  				if(cpuPorProceso<=0){break;}
  				r.setD(1);
  				System.out.print(". Entra Proceso "+c.get(i).getId()+" ");
  				//se verifica que el proceso este listo
  				if(c.get(i).getEstado()!=2){
  					//si el proceso aun no esta listo se genera un random para saber si se desbloqueo
  					c.get(i).setEstado(random.nextInt(2)+1);
  				}
  				if(c.get(i).getEstado()==2){
  					//si el proceso esta listo se resta el valor un valor aleatorio al tiempo restante
  					for(int j=0;j<200;j++){
  						x=random.nextInt(3)+2;
  						xaux+=x;
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-x);
  						cpuPorProceso-=x;
  						if(cpuPorProceso<=0){
  							c.get(i).setTiempoR(c.get(i).getTiempoR()-cpuPorProceso);
  							xaux+=cpuPorProceso;
  							cpuPorProceso=0;
  						}
  					if(cpuPorProceso<=0){
  						c.get(i).setTiempoR(c.get(i).getTiempoR()-cpuPorProceso);
  						xaux+=cpuPorProceso;
  						cpuPorProceso=0;
  					}
  						if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  							xaux+=c.get(i).getTiempoR();
  							break;
  						}
  						c.get(i).setEstado(random.nextInt(2)+1);
  						if(c.get(i).getEstado()!=2){
  							c.get(i).setEstado(random.nextInt(2)+1);
  							break;
  						}
  					}
  					if(c.get(i).getTiempoR()<=0/*El proceso termino*/){
  						System.out.print(", se ejecuta "+xaux+" unidades y termina\n");
  						r.setA(c.get(i).getId());
  						cpuPorProceso=cpuPorProceso-c.get(i).getTiempoR();/*si el proceso termino el tiempo de simulacion se le suma el resto del tiempo restante*/
  						c.remove(i);/*se remueve el proceso de la lista*/
  						i--;
  					}else{
  						System.out.print(", se ejecuta "+xaux+" unidades\n");
  						/*Si el proceso no termino*/
  					}
  				}else{System.out.print(", no se ejcuta porque sigue bloqueado \n");/*el proceso nu uso la CPU */}
  				x=0;
  				xaux=0;
  				if(i==c.size()-1){i=-1;}
  			}
  		}
  	}
  } 
  