TP01E1_Definitivo

/*
 * Estructura de Datos - Facultad de Ingeniería - Universidad Nacional de Jujuy
  =============================================================================
 */

/**
 * @Autor: Equipo 5.1 Estructura de Datos.
/*      @Integrantes:                  |    @Carrera:             |   @DNI:
                                       |                          |
  Camacho, Mauro Rodrigo               | Ing. Informática         | 41.654.090
  Cabana, Mario Ariel Fernando         | Ing. Informática         | 42.268.639
  Cruz, Facundo Emanuel                | Ing. Informática         | 41.609.573
  López, Juan Carlos                   | Ing. Informática         | 41.400.550
  Machaca, Aldo Martin                 | Ing. Informática         | 31.455.538

 * @Ingeniera: Perez Ibarra.
 * @Fecha: 14/09/2020.
 */

 /*
   Trabajo Práctico N°1 / Arreglos, Arreglos Dinámicos, Objetos Básicos / Ejercicio 1
  ---------------------   ---------------------------------------------   ------------
  * Objetivo General: Ingresar 2 vectores, almacenar la suma de los mismo en un tercer vector y mostrar.
  * Metodología Empleada: Ingresar por la consola o teclado dos arreglos enteros con la misma dimensión.
                          En uno de los arreglos se deben ingresar solamente divisores de 1000
                          y en el otro arreglo se deben ingresar solamente números primos.
                          Mostrar la suma de los mismos en un tercer vector, la media de cada arreglo,
                          los valores del vector suma menores a la media del primer vector
                          y los mayores a la media del segundo vector.
  * El funcionamiento será a traves del entorno de desarrollo integrado Eclipse 2020-06(4.16)-(IDE for Java Developers), empleando el leguaje de programación Orientado a Objeto Java.
  * Api a utilizar. Paquete:- Java.Util / Clase:- Scanner y - Random.
  */
import java.util.Scanner;
import java.util.Random;
public class Tp01E01 {
//----------------Variables para toda la clase Tp01E1----------------//
    public static Scanner entrada = new Scanner(System.in);
    public static int i,j;
    public static String respuesta;
//-------------------------Principal - main--------------------------//
    public static void main(String[] args) {
        int dimencion, mediaA, mediaB, mediaC;
        System.out.println("Vectores A (primos), B(divisores de 1000), C(suma de A y B)\n==================");
        dimencion=validarDato("dimención de los vectores: ");
        int vectorA[]=new int [dimencion];
        int vectorB[]=new int [dimencion];
        int vectorC[]=new int [dimencion];
        procesoCargar(vectorA,vectorB);
        CargarVector3(vectorA,vectorB,vectorC);
        MostrarTodosVectores(vectorA,vectorB,vectorC);
        mediaA=CalcularMedia(vectorA);
        mediaB=CalcularMedia(vectorB);
        mediaC=CalcularMedia(vectorC);
        mostrarMedias(mediaA,mediaB,mediaC);
        menorMayorqueMedia(vectorC,mediaA,mediaB);
    }
//------------------------- Validar Entradas-------------------------//
    public static int validarDato(String mensaje) {//Proceso de validación a un entero.
        int dato;
        do {
            System.out.println("Ingrese la "+ mensaje);
            dato=validarValor(entrada.nextLine());
        }while(dato==0);
        return dato;
    }

    public static int validarValor(String entrada){//Módulo dedicado a reconocer si un número es natural.
        int posible;
        try {
             posible=Integer.parseInt(entrada);
        } catch (NumberFormatException nfe) {
            posible=0;
        } // fin catch.
        if (posible>0) {
            return posible;
        }else {
            System.out.println("ERROR, debe ingresar un entero positivo");
            return 0;
        }
    }
//--------------------------Vector - Cargar--------------------------//
    public static void procesoCargar(int[] v1,int[] v2) {//Proceso para llenar los vectores principales A y B.
        boolean vectorprimo;
        System.out.println("\nProceso cargar Vectores\n------------------------\nCargar vector A");
        vectorprimo=true;
        comoCargar(v1,"A",vectorprimo);
        System.out.println("Cargar vector B");
        vectorprimo=false;
        comoCargar(v2,"B",vectorprimo);
    }
    public static void comoCargar(int[] v,String aob,boolean esVectorA) {//Permite elejir si llena un vector por consola o automaticamente.
        System.out.println("¿Desea generar valores en el vector "+ aob +" automaticamente?(SI/NO)");
        respuesta=entrada.nextLine().toUpperCase();
        if (respuesta.equals("SI")){
            if (esVectorA) {
                cargarRandomA(v);
            }else {
                cargarRandomB(v);
            }
        }else {
            System.out.println("Ingrese números para el vector "+ aob +":");
            if (esVectorA) {
                cargarIndividualA(v);
            }else {
                cargarIndividualB(v);
            }

        }
    }
    public static void CargarVector3(int[] v1,int[] v2,int[] v3) {//Carga en el vector C la suma de A y B.
        for(i=0;i<v3.length;i++) {
            v3[i]=v1[i]+v2[i];
        }
    }
//-----------------------Vector - Tipo de Carga-----------------------//
    public static void cargarRandomA(int[] v) {//Almacena valores aleatorios en el vector A.
        Random rnd=new Random();
        int valorA;
        for (i=0;i<v.length;i++) {
            valorA=CalculaPrimo(rnd.nextInt(1000));
            if(valorA!=0) {
                v[i]=valorA;
            }
            else {
                i--;
            }
        }
    }
    public static void cargarRandomB(int[] v) {//Almacena valores aleatorios en el vector B.
        Random rnd=new Random();
        int valorB;
        for (i=0;i<v.length;i++) {
            valorB=CalculaDivisor(rnd.nextInt(1000));
            if(valorB!=0) {
                v[i]=valorB;
            }
            else {
                i--;
            }
        }
    }
    public static void cargarIndividualA(int[] v) {//Carga el vector A por consola.
        int valorA;
        for (i=0;i<v.length;i++) {
            valorA=CalculaPrimo(validarDato("posición A("+(i+1)+"):"));
            if(valorA!=0) {
                v[i]=valorA;
            }
            else {
                System.out.println("El número ingresado no es primo");
                i--;
            }
        }
    }
    public static void cargarIndividualB(int[] v) {//Carga el vector B por consola.
        int valorB;
        for (i=0;i<v.length;i++) {
            valorB=CalculaDivisor(validarDato("posición B("+(i+1)+"):"));
            if(valorB!=0) {
                v[i]=valorB;
            }
            else {
                System.out.println("El número ingresado no es divisor de 1000");
                i--;
            }
        }
    }
    public static int CalculaPrimo(int posiblePrimo) {//Calcula si un número es primo a traves de sus divisores.
         int divisores=0;
         for(j=1;j<=posiblePrimo;j++) {
             if(posiblePrimo%j==0)
                 divisores++;
         }
         if(divisores==2)
             return posiblePrimo;
         else
             return 0;
    }
    public static int CalculaDivisor(int num) {//Calcula si un número es divisor de 1000.
        if(1000%num==0)
            return num;
        else
            return 0;
    }

//--------------------------Vector - Mostrar-------------------------//
    public static void MostrarTodosVectores(int[] v1,int[] v2,int[] v3) {//Proceso para mostrar todos los vectores.
        System.out.println("\nMostrar Vectores\n-----------------");
        MostrarVector(v1,"A");
        MostrarVector(v2,"B");
        MostrarVector(v3,"C");
    }
    public static void MostrarVector(int[] v,String abc){//Muestra solo un vector.
        System.out.print("El Vector "+ abc +" es : {");
        for(int numero:v) {
            System.out.print("|"+numero+"| ");
        }
        System.out.println("}\n");
    }

//--------------------Media - Calcular y Mostrar --------------------//
    public static int CalcularMedia(int[] v) {//Calcula promedio entero de un vector.
        int acumulador=0;
        for(i=0;i<v.length;i++) {
            acumulador+=v[i];
        }
        return acumulador/v.length;
    }
    public static void mostrarMedias(int mA,int mB,int mC) {//Muestra el promedio de cada vector.
        System.out.println("Mostrar la media de cada Vector\n--------------------------------");
        System.out.println("La media del vector A es : "+ mA);
        System.out.println("La media del vector B es : "+ mB);
        System.out.println("La media del vector C es : "+ mC);
    }
//Valores de C: menores y mayores a la Media de A y B respectivamente//
    public static void menorMayorqueMedia(int[] v3,int mA,int mB) {//Proceso adicional.
        System.out.print("\nAdicionales\n------------");
        MenorMedia(v3, mA);
        MayorMedia(v3, mB);
    }
    public static void MenorMedia(int[] v3,int media) {//Obtiene valores de C menores que la media de A y los muestra.
        System.out.print("\nLos valores del vector C menores a la media del vector A son : { ");
        for(i=0;i<v3.length;i++) {
            if(v3[i]<media) {
                System.out.print("|"+v3[i]+"| ");
            }
        }
        System.out.print("}");
    }
    public static void MayorMedia(int[] v3,int media) {//Obtiene valores de C mayores que la media de B y los muestra.
        System.out.print("\nLos valores del vector C mayores a la media del vector B son : { ");
        for(i=0;i<v3.length;i++) {
            if(v3[i]>media) {
                System.out.print("|"+v3[i]+"| ");
            }
        }
        System.out.print("}");
    }
}