MOISES_QUISPE_ROJAS

Estructura Datos 2021 - TP01 P01

Sep 15th, 2021
552
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /* Estructura de Datos - Facultad de Ingenieria - Universidad Nacional de Jujuy
  2.  *
  3.  * @Autor: Equipo 4.1
  4.  */
  5.  /*      @integrantes:                  |    @Carrera:             |   @LU:
  6.                                         |                          |
  7.    Flores ,Cesar Ismael                 | Lic. en Sistemas         | 1782
  8.    Llampa, Ariel Angel Gabriel          | Ing. Informatica         | 8445
  9.    Machaca, Rodrigo Agustin             | Ing. Informatica         | 8512
  10.    Perez, Emanuel Ismael                | Ing. Informatica         | 8393
  11.    Quispe Rojas, Moises Esteban Nicolas | Ing. Informatica         | 7286
  12.  
  13. Escribir un programa que permita ingresar por la consola o teclado dos arreglos de enteros con la misma
  14. dimensión. En uno de los arreglos se deben ingresar solamente múltiplos de siete y en el otro arreglo se
  15. deben ingresar solamente números primos; el programa debe mostrar el resultado del producto de los
  16. mismos en un tercer vector, la media de cada arreglo y los valores del vector producto que resultan
  17. mayores a la media del primer vector y los valores que resultan menores a los de la media del segundo
  18. vector.
  19.  
  20. Indicaciones:
  21. Este ejercicio necesita del objeto scanner para ingresar datos por la consola o teclado, se espera que el
  22. código controle los problemas que normalmente ocurren al operar con la consola o teclado.
  23. Se espera una correcta modularización entre el código que realiza el ingreso y validación de los datos
  24. respecto del código que hace lo que se solicita en el ejercicio.
  25. El ejercicio debe implementar un mecanismo para seleccionar el ingreso de valores por consola o
  26. generados aleatoriamente.
  27.  
  28.  */
  29.  
  30. package Array;
  31.  
  32. public class ED_E1 {
  33.    
  34.     public static void main(String[] args) {
  35.         (new ED_E1()).open();
  36.     }
  37.    
  38.     public void open(){
  39.         char option;
  40.         do{
  41.             System.out.println("Array Primos - mult. 7");
  42.             System.out.println("(a) Ingreso manual");
  43.             System.out.println("(b) Ingreso automatico");
  44.             System.out.print("Opcion: ");
  45.             option=Helper.getChar();
  46.         }while(run(option));
  47.     }
  48.    
  49.     public void registerAutomatic(){
  50.         int n=Helper.random.nextInt(20)+1;
  51.         float meanVector1,meanVector2;
  52.         System.out.println("Se cargaran de manera automatica "+ n +" elementos");
  53.         int multiplesSeven[] = new int [n];
  54.         int numbersPrime[] = new int [n];
  55.         int productVectors [] = new int[n];
  56.         System.out.println("Carga automatica de multiplos de 7");
  57.         loadMultiplesSevenAutomatic(multiplesSeven);
  58.         System.out.println("Carga automatica de numeros primos");
  59.         loadNumbersPrimeAutomatic(numbersPrime);
  60.         // resultado del producto
  61.         System.out.println("El producto de los vectores:");
  62.         productVectors(multiplesSeven, numbersPrime, productVectors);
  63.          // Media Aritmetica
  64.         meanVector1=arithmeticMean(multiplesSeven);
  65.         meanVector2=arithmeticMean(numbersPrime);
  66.         System.out.println("Media de arreglo 1: "+meanVector1);
  67.         System.out.println("Media de arreglo 2: "+meanVector2);
  68.         // Valores del vector producto que resultan mayores a la media del primer vector
  69.         for(int i=0;i<productVectors.length;i++){
  70.             if(productVectors[i]>meanVector1){
  71.                 System.out.println("v[" + i + "]: "+productVectors[i]+" es mayor a la media aritmetica del 1° vector");
  72.             }
  73.         }
  74.         // Valores del vector producto que resultan menores a los de la media del segundo vector
  75.         for(int i=0;i<productVectors.length;i++){
  76.             if(productVectors[i]<meanVector2){
  77.                 System.out.println("v[" + i + "]: "+productVectors[i]+" es menor a la media aritmetica del 2° vector");
  78.             }
  79.         }
  80.     }
  81.    
  82.     public void loadNumbersPrimeAutomatic(int numbersPrime[]){
  83.         int value,i=0;
  84.         do{
  85.             value=Helper.random.nextInt(200)+1;
  86.             if(primeAutomatic(value)){
  87.                 numbersPrime[i]=value;
  88.                 i++;
  89.             }
  90.         }while(i<numbersPrime.length);
  91.         System.out.println("Se cargo el vector: ");
  92.         for (i = 0; i < numbersPrime.length; i++) {
  93.             System.out.println("v[" + i + "]: " + numbersPrime[i]);
  94.         }
  95.     }
  96.    
  97.     public boolean primeAutomatic(int value){
  98.         if(value==1){
  99.             return false;
  100.         }
  101.         int conta = 1;
  102.         for(int i=2;i<=(value/2);i++){
  103.             if(value%i==0){
  104.                 conta++;
  105.             }
  106.         }
  107.         if(conta == 1){
  108.             return true;
  109.         }else{
  110.             return false;
  111.         }
  112.     }
  113.    
  114.     public void loadMultiplesSevenAutomatic(int multiplesSeven[]){
  115.         int value,i;
  116.         for(i=0;i<multiplesSeven.length;i++){
  117.             value=Helper.random.nextInt(100)+1;
  118.             multiplesSeven[i]=value*7;
  119.         }
  120.         System.out.println("Se cargo el vector: ");
  121.         for (i = 0; i < multiplesSeven.length; i++) {
  122.             System.out.println("v[" + i + "]: " + multiplesSeven[i]);
  123.         }
  124.     }
  125.    
  126.     public void registerManual(){
  127.         int n;
  128.         float meanVector1,meanVector2;
  129.         System.out.print("Cantidad de elementos a ingresar: ");
  130.         n = Helper.getIntegerPositive();
  131.         int multiplesSeven[] = new int [n];
  132.         int numbersPrime[] = new int [n];
  133.         int productVectors [] = new int[n];
  134.         System.out.println("Carga de multiplos de 7");
  135.         loadMultiplesSeven(multiplesSeven);
  136.         System.out.println("Carga de numeros de primos");
  137.         loadNumbersPrime(numbersPrime);
  138.         // resultado del producto
  139.         System.out.println("El producto de los vectores:");
  140.         productVectors(multiplesSeven, numbersPrime, productVectors);
  141.          // Media Aritmetica
  142.         meanVector1=arithmeticMean(multiplesSeven);
  143.         meanVector2=arithmeticMean(numbersPrime);
  144.         System.out.println("Media de arreglo 1: "+meanVector1);
  145.         System.out.println("Media de arreglo 2: "+meanVector2);
  146.         // Valores del vector producto que resultan mayores a la media del primer vector
  147.         for(int i=0;i<productVectors.length;i++){
  148.             if(productVectors[i]>meanVector1){
  149.                 System.out.println("v[" + i + "]: "+productVectors[i]+" es mayor a la media aritmetica del 1° vector");
  150.             }
  151.         }
  152.         // Valores del vector producto que resultan menores a los de la media del segundo vector
  153.         for(int i=0;i<productVectors.length;i++){
  154.             if(productVectors[i]<meanVector2){
  155.                 System.out.println("v[" + i + "]: "+productVectors[i]+" es menor a la media aritmetica del 2° vector");
  156.             }
  157.         }
  158.     }
  159.    
  160.     public float arithmeticMean(int array[]){
  161.         int sum = 0;
  162.         for (int i = 0; i < array.length; i++) {
  163.             sum=sum+array[i];
  164.         }  
  165.         return ((float) sum/array.length);
  166.     }
  167.    
  168.     public void productVectors(int multiplesSeven[],int numbersPrime[], int productVectors[]){
  169.         int i;
  170.         for ( i =0; i<productVectors.length;i++){
  171.             productVectors[i]=multiplesSeven[i]*numbersPrime[i];
  172.         }
  173.         for (i= 0; i < productVectors.length; i++) {
  174.             System.out.println("v[" + i + "]: " + productVectors[i]);
  175.         }  
  176.     }
  177.    
  178.     public  boolean prime(int value){
  179.         if(value==1){
  180.             System.out.println("El numero 1 no es considerado primo");
  181.             return false;
  182.         }
  183.         int conta = 1;
  184.         for(int i=2;i<=(value/2);i++){
  185.             if(value%i==0){
  186.                 conta++;
  187.             }
  188.         }
  189.         if(conta == 1){
  190.             System.out.println("El numero ingresado es primo");
  191.             return true;
  192.         }else{
  193.             System.out.println("El numero no es primo");
  194.             return false;
  195.         }
  196.     }
  197.    
  198.     public void loadNumbersPrime(int numbersPrime[]){
  199.         int value, i = 0;
  200.         do {
  201.             System.out.print("Ingrese v[" + i + "]: ");
  202.             value = Helper.getIntegerPositive();
  203.             if (prime(value)) {
  204.                 numbersPrime[i] = value;
  205.                 i++;
  206.             }
  207.         } while (i < numbersPrime.length);
  208.         System.out.println("Usted cargo el vector: ");
  209.         for (i = 0; i < numbersPrime.length; i++) {
  210.             System.out.println("v[" + i + "]: " + numbersPrime[i]);
  211.         }
  212.     }
  213.  
  214.     public boolean multiplesSeven(int value){
  215.         if (value == 0) {
  216.             System.out.println("0 no es multiplo");
  217.             return false;
  218.         }
  219.         if(value%7 == 0){
  220.             System.out.println("El numero ingresado es multiplo de 7");
  221.             return true;
  222.         }
  223.         System.out.println("No es un multiplo de 7");
  224.         return false;
  225.     }
  226.    
  227.     public void loadMultiplesSeven(int multiplesSeven[]){
  228.         int value,i=0;
  229.         do {
  230.             System.out.print("Ingrese v[" + i + "]: ");
  231.             value = Helper.getInteger();
  232.             if (multiplesSeven(value)) {
  233.                 multiplesSeven[i] = value;
  234.                 i++;
  235.             }
  236.         } while (i < multiplesSeven.length);    
  237.         System.out.println("Usted cargo el vector: ");
  238.         for (i = 0; i < multiplesSeven.length; i++) {
  239.             System.out.println("v[" + i + "]: " + multiplesSeven[i]);
  240.         }
  241.     }
  242.    
  243.     public boolean run(char option){
  244.         switch(option){
  245.             case 'a','A':
  246.                 registerManual();
  247.                 return false;
  248.             case 'b','B':
  249.                 registerAutomatic();
  250.                 return false;
  251.             default:{
  252.                 System.out.println("Opcion no contemplada");
  253.                 return true;
  254.             }    
  255.         }
  256.     }
  257.    
  258. }
  259.  
RAW Paste Data