Roke98

Ejercicio1-Tp1-UNJu

Sep 13th, 2022
707
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5.28 KB | None | 0 0
  1. package Practico1;
  2.  
  3. import Practico1.Helper;
  4. import Practico1.HelperArray;
  5. import java.util.Scanner;
  6.  
  7.  
  8. public class Ejercicio1 {
  9.  
  10.     public static void main(String[] args) {
  11.         // TODO Auto-generated method stub
  12.         menu();
  13.     }
  14.    
  15.     @SuppressWarnings("static-access")
  16.     public static void menu() {
  17.        
  18.         Helper op = new Helper();
  19.         int opcion;
  20.         Character seguir;
  21.          do {  
  22.             int dimen = op.getPositiveInt("Ingrese tamaño de los arreglos");
  23.             System.out.println("1 - Ingresar valores");
  24.             System.out.println("2 - Generar valores aleatorios ");
  25.             opcion = op.getInteger("Ingrese una opcion");
  26.            
  27.             double media;
  28.            
  29.             int[] arrayComp = new int[dimen];
  30.             int[] arrayDef = new int[dimen];
  31.             int arrayDifer[] = new int[dimen];
  32.            
  33.             switch (opcion) {
  34.             case 1:
  35.                
  36.                 System.out.println("Cargar Arreglo de Numeros Compuestos");
  37.                 arrayComp = cargarCompuestos(arrayComp);
  38.                 System.out.println("Cargar Arreglo de Numeros Deficentes");
  39.                 arrayDef = cargarDeficientes(arrayDef);
  40.                 arrayDifer= arregloDiferencia(arrayComp, arrayDef, arrayDifer );
  41.                
  42.                 op.mostrarArrayUnaDimension("Arreglo de compuestos generados", arrayComp, "");
  43.                 op.mostrarArrayUnaDimension("Arreglo de deficientes generados", arrayDef, "");
  44.                 op.mostrarArrayUnaDimension("El arreglo diferencia entre Compuesto y Deficiente", arrayDifer, "");
  45.                
  46.                 media = mediaDifer(arrayDifer);
  47.                 mayorMedia(arrayComp, media);
  48.                 System.out.println();
  49.                 menorMedia(arrayDef, media);
  50.                 System.out.println();
  51.  
  52.                 espera();
  53.                 break;
  54.             case 2:
  55.                
  56.                 arrayComp=generarCompuesto(arrayComp);
  57.                 arrayDef=generarDeficiente(arrayDef);
  58.                 arrayDifer= arregloDiferencia(arrayComp, arrayDef, arrayDifer );
  59.                
  60.                 op.mostrarArrayUnaDimension("Arreglo de compuestos generados", arrayComp, "");
  61.                 op.mostrarArrayUnaDimension("Arreglo de deficientes generados", arrayDef, "");
  62.                 op.mostrarArrayUnaDimension("El arreglo diferencia entre Compuesto y Deficiente", arrayDifer, "");
  63.                
  64.                 media = mediaDifer(arrayDifer);
  65.                 mayorMedia(arrayComp, media);
  66.                 System.out.println();
  67.                 menorMedia(arrayDef, media);
  68.                 System.out.println();
  69.  
  70.                 espera();
  71.                 break;
  72.             default:
  73.                 System.out.println("Opcion No Valida ");
  74.             }
  75.             seguir = op.getCharacter("Desea ingrear otro arreglo??(s/n)");
  76.         }while(!seguir.equals('n'));
  77.         System.out.println("Gracias :D");
  78.     }
  79.    
  80.     public static int[] arregloDiferencia(int[] arrayComp, int[] arrayDef, int[] arrayDifer) {
  81.         for (int i = 0; i < arrayDifer.length; i++) {
  82.             int resta = arrayComp[i] - arrayDef[i];
  83.             arrayDifer[i] = resta;
  84.         }return arrayDifer;
  85.     }
  86.    
  87.     public static int[] cargarCompuestos(int[] arrayComp) {
  88.         int i = 0, numero;
  89.         while(i<arrayComp.length) {
  90.             numero = Helper.getPositiveInt("Ingresar valor positivo");
  91.             if(compuesto(numero)) {
  92.                 arrayComp[i]=numero;
  93.                 i++;
  94.             }else {
  95.                 System.out.println("Numero no valido, intentar de nuevo");
  96.             }
  97.         }return arrayComp;
  98.     }
  99.    
  100.     public static int[] cargarDeficientes(int[] arrayDef) {
  101.         int i = 0, numero;
  102.         while(i<arrayDef.length) {
  103.             numero = Helper.getPositiveInt("Ingresar valor positivo");
  104.             if(deficiente(numero)) {
  105.                 arrayDef[i]=numero;
  106.                 i++;
  107.             }else {
  108.                 System.out.println("Numero no valido, intentar de nuevo");
  109.             }
  110.         }return arrayDef;
  111.     }
  112.    
  113.     public static int[] generarCompuesto(int[] arrayComp) {
  114.         Helper randy=new Helper();
  115.         int i = 0, numero;
  116.         while (i < arrayComp.length) {
  117.             numero = randy.ramdomInt(100);
  118.             if (compuesto(numero)) {
  119.                 arrayComp[i]=numero;
  120.                 i++;
  121.             }
  122.         }
  123.         return arrayComp;
  124.     }
  125.    
  126.     public static int[] generarDeficiente(int[] arrayDef) {
  127.         Helper randy=new Helper();
  128.         int i = 0, numero;
  129.         while (i < arrayDef.length) {
  130.             numero = randy.ramdomInt(100);
  131.             if (deficiente(numero)) {
  132.                 arrayDef[i]=numero;
  133.                 i++;
  134.             }
  135.         }return arrayDef;
  136.     }
  137.    
  138.     public static double mediaDifer(int[] arrayDifer) {
  139.         double media = 0.0;
  140.         for (int i = 0; i < arrayDifer.length; i++) {
  141.             media = media + arrayDifer[i];
  142.         }
  143.         media = media/2;
  144.         return media;
  145.     }
  146.    
  147.     public static void mayorMedia(int[] arrayComp, double media) {
  148.         System.out.println("La media de la diferencia es: " + media);
  149.         System.out.println("Los valores mayores de la media son:");
  150.         for (Integer i:arrayComp) {
  151.             if(media < i) {
  152.                 System.out.print("["+ i +"]");
  153.             }
  154.         }
  155.     }
  156.    
  157.     public static void menorMedia(int[] arrayDef, double media) {
  158.         System.out.println("Los valores menores de la media son:");
  159.         for (Integer i:arrayDef) {
  160.             if(i < media) {
  161.                 System.out.print("[" + i + "]");
  162.             }
  163.         }
  164.     }
  165.    
  166.     public static Boolean deficiente(int numero) {
  167.         int suma = 0, cont = 1;
  168.         while (cont <= numero) {
  169.             if (numero % cont == 0) {
  170.                 suma += cont;
  171.                 return true;
  172.             }cont++;
  173.         }return false;
  174.     }
  175.    
  176.     public static Boolean compuesto(int numero) {
  177.          int contador=2;
  178.             while (contador < numero) {
  179.                 if (numero % contador == 0)
  180.                     return true;
  181.                     contador++;
  182.             }return false;
  183.         }
  184.    
  185.     @SuppressWarnings("resource")
  186.     public static void espera (){ //Este modulo detiene el proceso hasta que el ususario precione "enter"
  187.         Scanner waitForKeypress = new Scanner(System.in);
  188.         System.out.print("Presiona la tecla Enter para continuar....");
  189.         waitForKeypress.nextLine();
  190.     }
  191. }
Advertisement
Add Comment
Please, Sign In to add comment