TP01E1_Beta

import java.util.Scanner;
import java.util.Random;
public class Tp01E01 {
//----------Variables para toda la clase Tp01E3----------//
    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 , B, C\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);
    }
//----------Vector - Definir y Validar Entradas----------//
    public static int validarDato(String mensaje) {//Proceso de validación a un número 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 tipo exception, dedicado a reconocer un valor numérico correcto.
        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) {//Procedimiento para llenar los vectores principales.
        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 usuario 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);
            }

        }
    }
//-----------------Vector - Tipo de Carga-----------------//
    public static void cargarRandomA(int[] v) {//Llena el vector A con valores aleatorios.
        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) {//Llena el vector B con valores aleatorios.
        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) {//Llena el vector A por el usuario.
        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("Numero no primo");
                i--;
            }
        }
    }
    public static void cargarIndividualB(int[] v) {//Llena el vector B por el usuario.
        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("Número no 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 numero es divisor de 1000.
        if(1000%num==0)
            return num;
        else
            return 0;
    }
    public static void CargarVector3(int[] v1,int[] v2,int[] v3) {//carga el vector SUma.
        for(i=0;i<v3.length;i++) {
            v3[i]=v1[i]+v2[i];
        }
    }
//--------------------Vector - Mostrar-------------------//
    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");
    }
    public static void MostrarTodosVectores(int[] v1,int[] v2,int[] v3) {//Muestra todos lo vec.
        System.out.println("\nMostrar Vectores\n-----------------");
        MostrarVector(v1,"A");
        MostrarVector(v2,"B");
        MostrarVector(v3,"C");
    }
//---------Media - Calcular , Mostrar y Adicional--------//
    public static int CalcularMedia(int[] v) {//Calcula promedio entero de un vect.
        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 Todo med.
        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);
    }
    public static void menorMayorqueMedia(int[] v3,int mA,int mB) {//Procedimiento para adicionales.
        System.out.print("\nAdicionales\n------------");
        MenorMedia(v3, mA);
        MayorMedia(v3, mB);
    }
    public static void MenorMedia(int[] v3,int media) {//Obtienen valor menores que la media.
        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) {//Obtienen valor mayores que la media.
        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("}");
    }
}