Estructura Datos 2021 - TP01 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 un programa que permita ingresar por la consola o teclado dos arreglos de enteros con la misma
dimensión. En uno de los arreglos se deben ingresar solamente múltiplos de siete y en el otro arreglo se
deben ingresar solamente números primos; el programa debe mostrar el resultado del producto de los
mismos en un tercer vector, la media de cada arreglo y los valores del vector producto que resultan
mayores a la media del primer vector y los valores que resultan menores a los de la media del segundo
vector.

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 Array;

public class ED_E1 {

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

    public void open(){
        char option;
        do{
            System.out.println("Array Primos - mult. 7");
            System.out.println("(a) Ingreso manual");
            System.out.println("(b) Ingreso automatico");
            System.out.print("Opcion: ");
            option=Helper.getChar();
        }while(run(option));
    }

    public void registerAutomatic(){
        int n=Helper.random.nextInt(20)+1;
        float meanVector1,meanVector2;
        System.out.println("Se cargaran de manera automatica "+ n +" elementos");
        int multiplesSeven[] = new int [n];
        int numbersPrime[] = new int [n];
        int productVectors [] = new int[n];
        System.out.println("Carga automatica de multiplos de 7");
        loadMultiplesSevenAutomatic(multiplesSeven);
        System.out.println("Carga automatica de numeros primos");
        loadNumbersPrimeAutomatic(numbersPrime);
        // resultado del producto
        System.out.println("El producto de los vectores:");
        productVectors(multiplesSeven, numbersPrime, productVectors);
         // Media Aritmetica
        meanVector1=arithmeticMean(multiplesSeven);
        meanVector2=arithmeticMean(numbersPrime);
        System.out.println("Media de arreglo 1: "+meanVector1);
        System.out.println("Media de arreglo 2: "+meanVector2);
        // Valores del vector producto que resultan mayores a la media del primer vector
        for(int i=0;i<productVectors.length;i++){
            if(productVectors[i]>meanVector1){
                System.out.println("v[" + i + "]: "+productVectors[i]+" es mayor a la media aritmetica del 1° vector");
            }
        }
        // Valores del vector producto que resultan menores a los de la media del segundo vector
        for(int i=0;i<productVectors.length;i++){
            if(productVectors[i]<meanVector2){
                System.out.println("v[" + i + "]: "+productVectors[i]+" es menor a la media aritmetica del 2° vector");
            }
        }
    }

    public void loadNumbersPrimeAutomatic(int numbersPrime[]){
        int value,i=0;
        do{
            value=Helper.random.nextInt(200)+1;
            if(primeAutomatic(value)){
                numbersPrime[i]=value;
                i++;
            }
        }while(i<numbersPrime.length);
        System.out.println("Se cargo el vector: ");
        for (i = 0; i < numbersPrime.length; i++) {
            System.out.println("v[" + i + "]: " + numbersPrime[i]);
        }
    }

    public boolean primeAutomatic(int value){
        if(value==1){
            return false;
        }
        int conta = 1;
        for(int i=2;i<=(value/2);i++){
            if(value%i==0){
                conta++;
            }
        }
        if(conta == 1){
            return true;
        }else{
            return false;
        }
    }

    public void loadMultiplesSevenAutomatic(int multiplesSeven[]){
        int value,i;
        for(i=0;i<multiplesSeven.length;i++){
            value=Helper.random.nextInt(100)+1;
            multiplesSeven[i]=value*7;
        }
        System.out.println("Se cargo el vector: ");
        for (i = 0; i < multiplesSeven.length; i++) {
            System.out.println("v[" + i + "]: " + multiplesSeven[i]);
        }
    }

    public void registerManual(){
        int n;
        float meanVector1,meanVector2;
        System.out.print("Cantidad de elementos a ingresar: ");
        n = Helper.getIntegerPositive();
        int multiplesSeven[] = new int [n];
        int numbersPrime[] = new int [n];
        int productVectors [] = new int[n];
        System.out.println("Carga de multiplos de 7");
        loadMultiplesSeven(multiplesSeven);
        System.out.println("Carga de numeros de primos");
        loadNumbersPrime(numbersPrime);
        // resultado del producto
        System.out.println("El producto de los vectores:");
        productVectors(multiplesSeven, numbersPrime, productVectors);
         // Media Aritmetica
        meanVector1=arithmeticMean(multiplesSeven);
        meanVector2=arithmeticMean(numbersPrime);
        System.out.println("Media de arreglo 1: "+meanVector1);
        System.out.println("Media de arreglo 2: "+meanVector2);
        // Valores del vector producto que resultan mayores a la media del primer vector
        for(int i=0;i<productVectors.length;i++){
            if(productVectors[i]>meanVector1){
                System.out.println("v[" + i + "]: "+productVectors[i]+" es mayor a la media aritmetica del 1° vector");
            }
        }
        // Valores del vector producto que resultan menores a los de la media del segundo vector
        for(int i=0;i<productVectors.length;i++){
            if(productVectors[i]<meanVector2){
                System.out.println("v[" + i + "]: "+productVectors[i]+" es menor a la media aritmetica del 2° vector");
            }
        }
    }

    public float arithmeticMean(int array[]){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum=sum+array[i];
        }
        return ((float) sum/array.length);
    }

    public void productVectors(int multiplesSeven[],int numbersPrime[], int productVectors[]){
        int i;
        for ( i =0; i<productVectors.length;i++){
            productVectors[i]=multiplesSeven[i]*numbersPrime[i];
        }
        for (i= 0; i < productVectors.length; i++) {
            System.out.println("v[" + i + "]: " + productVectors[i]);
        }
    }

    public  boolean prime(int value){
        if(value==1){
            System.out.println("El numero 1 no es considerado primo");
            return false;
        }
        int conta = 1;
        for(int i=2;i<=(value/2);i++){
            if(value%i==0){
                conta++;
            }
        }
        if(conta == 1){
            System.out.println("El numero ingresado es primo");
            return true;
        }else{
            System.out.println("El numero no es primo");
            return false;
        }
    }

    public void loadNumbersPrime(int numbersPrime[]){
        int value, i = 0;
        do {
            System.out.print("Ingrese v[" + i + "]: ");
            value = Helper.getIntegerPositive();
            if (prime(value)) {
                numbersPrime[i] = value;
                i++;
            }
        } while (i < numbersPrime.length);
        System.out.println("Usted cargo el vector: ");
        for (i = 0; i < numbersPrime.length; i++) {
            System.out.println("v[" + i + "]: " + numbersPrime[i]);
        }
    }

    public boolean multiplesSeven(int value){
        if (value == 0) {
            System.out.println("0 no es multiplo");
            return false;
        }
        if(value%7 == 0){
            System.out.println("El numero ingresado es multiplo de 7");
            return true;
        }
        System.out.println("No es un multiplo de 7");
        return false;
    }

    public void loadMultiplesSeven(int multiplesSeven[]){
        int value,i=0;
        do {
            System.out.print("Ingrese v[" + i + "]: ");
            value = Helper.getInteger();
            if (multiplesSeven(value)) {
                multiplesSeven[i] = value;
                i++;
            }
        } while (i < multiplesSeven.length);
        System.out.println("Usted cargo el vector: ");
        for (i = 0; i < multiplesSeven.length; i++) {
            System.out.println("v[" + i + "]: " + multiplesSeven[i]);
        }
    }

    public boolean run(char option){
        switch(option){
            case 'a','A':
                registerManual();
                return false;
            case 'b','B':
                registerAutomatic();
                return false;
            default:{
                System.out.println("Opcion no contemplada");
                return true;
            }
        }
    }

}