Estructura Datos 2021 - TP03 P01

/* Estructura de Datos - Facultad de Ingenieria - Universidad Nacional de Jujuy
 *
 * @Autor: Equipo 4.1
 */
 /*      @integrantes:                  |    @Carrera:             |   @LU:
   Flores ,Cesar Ismael                 | Lic. en Sistemas         | 1782
   Llampa, Ariel Angel Gabriel          | Ing. Informatica         | 8445
   Machaca, Rodrigo Agustin             | Ing. Informatica         | 8512
   Perez, Emanuel Ismael                | Ing. Informatica         | 8393
   Quispe Rojas, Moises Esteban Nicolas | Ing. Informatica         | 7286

Escribir una función, método o subprograma que reciba como parámetros una cola y un número; debe
devolver una cola en la que se suprimen todas las apariciones de los múltiplos de dicho número. Para la
resolución del ejercicio debe utilizar colas circulares.
Modifique el programa escrito de manera que permita optar entre el ingreso de valores por consola o por
un generador de valores aleatorios.

Indicaciones:
Este ejercicio necesita del objeto scanner para ingresar datos por la consola o teclado, se espera que el
código controle los problemas que normalmente ocurren al operar con la consola o teclado.
Se espera una correcta modularización entre el código que realiza el ingreso y validación de los datos
respecto del código que hace lo que se solicita en el ejercicio.
El ejercicio debe implementar un mecanismo para seleccionar el ingreso de valores por consola o
generados aleatoriamente.
 */
package Queue;

public class ED_E1 {
    private Queue<Integer> queueInteger;

    public static void main(String[] args) {
        (new ED_E1()).open();
    }

    public void open(){
        char option,resp;
        do{
            do{
                System.out.println("Eliminar multiplos de una cola");
                System.out.println("(a) Carga manual de la Queue");
                System.out.println("(b) Carga automatica de la Queue");
                System.out.println("(c) Eliminar multiplos de la Queue");
                System.out.print("Opcion: ");
                option=Helper.getChar();
            }while(validateOption(option));
            do{
                System.out.println("Desea continuar(S/N): ");
                resp=Helper.getChar();
            }while(validateResp(resp));
        }while((resp=='s')|(resp=='S'));
    }

    public boolean validateResp(char resp){
        switch(resp){
            case 's','S': return false;
            case 'n','N': return false;
                default:{
                    System.out.println("Debe ingresar (S/N)");
                    return true;
                }
        }
    }

    public boolean validateOption(char option){
        switch(option){
            case 'a','A':
                registerManual();
                return false;
            case 'b','B':
                registerAutomatic();
                return false;
            case 'c','C':{
                if(getQueueInteger()== null){
                    System.out.println("Debe cargar la Queue primero");
                    return true;
                }else{
                    optionDelete();
                    return false;
                }
            }
                default:{
                    System.out.println("Error...");
                    System.out.println("Intentelo de nuevo");
                    return true;
                }
        }
    }

    public void registerAutomatic(){
        int amount= Helper.random.nextInt(99)+1;
        setQueueInteger(new Queue<Integer>(amount));
        for(int i=0; i<amount;i++){
            getQueueInteger().add((int)(Helper.random.nextDouble()*99+1));
        }
        System.out.println("Cola cargada: "+getQueueInteger());

    }

    public void registerManual(){
        System.out.print("Ingrese cantidad de valores a cargar en la Queue: ");
        int amount= Helper.getIntegerPositive();
        setQueueInteger(new Queue<Integer>(amount));
        for(int i=0;i<amount;i++){
            System.out.print("Ingrese valor: ");
            getQueueInteger().add(Helper.getInteger());
        }
        System.out.println("Cola cargada: "+getQueueInteger());
    }

    public void optionDelete(){
        int delete;
        System.out.print("Ingrese multiplo: ");
        delete=Helper.getIntegerPositive();
        setQueueInteger(deleteElement(getQueueInteger(), delete));
        System.out.println("Nueva Queue suprimidos los multiplos de "+delete+" : "+getQueueInteger());

    }

    // Firma: deleteElement suprime los multiplos de un valor entero a pedido
    // Precondicion: Recibe como parametro una Queue y un valor entero
    // Poscondicion: Retorna la misma Queue
    public Queue deleteElement(Queue<Integer> queueInteger,int delete){
        int remove,leng=getQueueInteger().size();
        for(int i=0;i<leng;i++){
            remove=queueInteger.remove();
            if(remove%delete!=0){
                queueInteger.add(remove);
            }
        }
        return queueInteger;
    }

    public Queue<Integer> getQueueInteger() {
        return queueInteger;
    }

    public void setQueueInteger(Queue<Integer> queueInteger) {
        this.queueInteger = queueInteger;
    }

}