SHARE
TWEET

Untitled

a guest Dec 8th, 2019 86 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.ArrayList;
  2. import java.util.Stack;
  3.  
  4. public class Logica<T extends Comparable> {
  5.  
  6.     private T[] a;
  7.     private T[] b;
  8.     private T[] u;
  9.     private int indiceUnion = 0;
  10.  
  11.     public Logica(T[] a, T[] b) {
  12.         this.a = a;
  13.         this.b = b;
  14.     }
  15.  
  16.     public double getMediaIterativo(T[] a1, T[] a2, int i) {
  17.         double acumulado = 0; //Alternativamente se puede utilizar una pila, pero no es necesario ya que únicamente tenemos que sumar elemento a elemento.
  18.         int total = ( a1.length + a2.length);
  19.         while (i>=0) {
  20.  
  21.             if(a1[0] instanceof Integer){
  22.                 if (i < a1.length) {
  23.                     double t = (Integer) a1[i];
  24.                     Double temp = t/total;
  25.                     acumulado+=temp;
  26.                 }
  27.                 if (i < a2.length) {
  28.                     double t2 = (Integer) a2[i];
  29.                     double temp2 = t2/total;
  30.                     acumulado+=temp2;
  31.                 }
  32.             } // FIN CASO INTEGER
  33.  
  34.  
  35.  
  36.             if(a1[0] instanceof Double){
  37.                 if (i < a1.length) {
  38.                     double t = (Double) a1[i];
  39.                     Double temp = t/total;
  40.                     acumulado+=temp;
  41.                 }
  42.                 if (i < a2.length) {
  43.                     double t2 = (Double) a2[i];
  44.                     double temp2 = t2/total;
  45.                     acumulado+=temp2;
  46.                 }
  47.             }//FIN CASO DOUBLE
  48.  
  49.  
  50.  
  51.             if(a1[0] instanceof Float){
  52.                 if (i < a1.length) {
  53.                     Float t = (Float) a1[i];
  54.                     Float temp = t/total;
  55.                     acumulado+=temp;
  56.                 }
  57.                 if (i < a2.length) {
  58.                     Float t2 = (Float) a2[i];
  59.                     Float temp2 = t2/total;
  60.                     acumulado+=temp2;
  61.                 }
  62.             }//FIN CASO Float
  63.            
  64.             if(a1[0] instanceof String){
  65.                 if (i < a1.length) {
  66.                     String first = (String) a1[i];
  67.                     double temp = (double)first.charAt(0)/total;
  68.                     acumulado+=temp;
  69.                 }
  70.                 if (i < a2.length) {
  71.                     String first2 = (String) a2[i];
  72.                     double temp = (double)first2.charAt(0)/total;
  73.                     acumulado+=temp;
  74.                 }
  75.             }//FIN CASO String
  76.  
  77.             i--;
  78.  
  79.         }
  80.  
  81.             return acumulado;
  82.         }
  83.  
  84.     /**
  85.      * Método que calcula la media de dos arrays, además, junta estos en un array
  86.      * auxiliar que posteriormente se utiliza en el método getMediana(), que calcula
  87.      * la mediana del array combinado.Esto está hecho para optimizar la ejecución
  88.      * del programa. En caso de que queramos calcular la mediana sin calcular la
  89.      * media previamente, hay que llamar al metodo unirArrays() previamente.
  90.      *
  91.      * @param a1
  92.      * @param a2
  93.      * @param i
  94.      * @return
  95.      */
  96.     public double getMedia(T[] a1, T[] a2, int i) {
  97.  
  98.         double ac1 = 0;
  99.         double ac2 = 0;
  100.         int mitad = (a1.length + a2.length);
  101.  
  102.         // CASO DOUBLE
  103.         if (a1[0] instanceof Double) {
  104.             if (i < a1.length) {
  105.                 if (u == null)
  106.                     u = (T[]) new Double[a1.length + b.length];
  107.                 ac1 = (Double) a1[i] / ((double) a1.length + (double) a2.length);
  108.                 u[indiceUnion] = a1[i];
  109.                 indiceUnion++;
  110.             }
  111.  
  112.             if (i < a2.length) {
  113.                 if (u == null)
  114.                     u = (T[]) new Double[a1.length + b.length];
  115.                 ac2 = (Double) a2[i] / ((double) a1.length + (double) a2.length);
  116.                 u[indiceUnion] = a2[i];
  117.                 indiceUnion++;
  118.             }
  119.  
  120.             if (i != 0) {
  121.                 return ac1 + ac2 + getMedia(a1, a2, i - 1);
  122.             } else {
  123.                 return ac1 + ac2;
  124.             }
  125.         } else if (a1[0] instanceof Integer) {
  126.  
  127.             if (i < a1.length) {
  128.                 if (u == null)
  129.                     u = (T[]) new Integer[a1.length + b.length];
  130.                 double temp = (Integer) a1[i];
  131.                 ac1 = Double.valueOf(temp / mitad);
  132.                 u[indiceUnion] = a1[i];
  133.                 indiceUnion++;
  134.             }
  135.  
  136.             if (i < a2.length) {
  137.                 if (u == null)
  138.                     u = (T[]) new Integer[a1.length + b.length];
  139.                 double temp2 = (Integer) a2[i];
  140.                 ac2 = Double.valueOf(temp2 / mitad);
  141.                 u[indiceUnion] = a2[i];
  142.                 indiceUnion++;
  143.             }
  144.             if (i != 0) {
  145.                 return ac1 + ac2 + getMedia(a1, a2, i - 1);
  146.             } else {
  147.                 return ac1 + ac2;
  148.             }
  149.  
  150.         } // CASO FLOAT
  151.         else if (a1[0] instanceof Float) {
  152.  
  153.             if (i < a1.length) {
  154.                 if (u == null)
  155.                     u = (T[]) new Float[a1.length + b.length];
  156.                 Float temp = (Float) a1[i];
  157.                 ac1 = (temp / mitad);
  158.                 u[indiceUnion] = a1[i];
  159.                 indiceUnion++;
  160.             }
  161.  
  162.             if (i < a2.length) {
  163.                 if (u == null)
  164.                     u = (T[]) new Float[a1.length + b.length];
  165.                 Float temp2 = (Float) a2[i];
  166.                 ac2 = Double.valueOf(temp2 / mitad);
  167.                 u[indiceUnion] = a2[i];
  168.                 indiceUnion++;
  169.             }
  170.             if (i != 0) {
  171.                 return ac1 + ac2 + getMedia(a1, a2, i - 1);
  172.             } else {
  173.                 return ac1 + ac2;
  174.             }
  175.  
  176.         } // CASO STRING
  177.         else if (i < a1.length) {
  178.             if (u == null)
  179.                 u = (T[]) new String[a1.length + b.length];
  180.             String first = (String) a1[i];
  181.             ac1 = ((double) first.charAt(0) / mitad);
  182.             u[indiceUnion] = a1[i];
  183.             indiceUnion++;
  184.         }
  185.  
  186.         if (i < a2.length) {
  187.             if (u == null)
  188.                 u = (T[]) new String[a1.length + b.length];
  189.             String first = (String) a2[i];
  190.             ac2 = ((double) first.charAt(0) / mitad);
  191.             u[indiceUnion] = a2[i];
  192.             indiceUnion++;
  193.         }
  194.         if (i != 0) {
  195.             return ac1 + ac2 + getMedia(a1, a2, i - 1);
  196.         } else {
  197.             return ac1 + ac2;
  198.         }
  199.  
  200.     }
  201.  
  202.     public double getMediana() {
  203.         if (u.length == 1)
  204.             return (double) u[0];
  205.         int longitud = u.length;
  206.  
  207.         // Comprueba si es impar, en cuyo caso tiene elemento central
  208.         if ((longitud) % 2 != 0) {
  209.             if (u[0] instanceof Integer)
  210.                 return (Integer) quickSort(u, 0, longitud - 1, longitud / 2);
  211.             if (u[0] instanceof Double)
  212.                 return (Double) quickSort(u, 0, longitud - 1, longitud / 2);
  213.             if (u[0] instanceof Float)
  214.                 return (Float) quickSort(u, 0, longitud - 1, longitud / 2);
  215.             else
  216.                 return 0;
  217.         }
  218.  
  219.         // Si no tiene elemento central, calcula la media de los dos elementos del
  220.         // medio.
  221.         else if (u[0] instanceof Integer) {
  222.             double aux1 = (Integer) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
  223.             double aux2 = (Integer) quickSort(u, 0, longitud - 1, (longitud / 2));
  224.             double resultado = (aux1 + aux2) / 2;
  225.             return resultado;
  226.         }
  227.         if (u[0] instanceof Double) {
  228.             Double aux1 = (Double) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
  229.             Double aux2 = (Double) quickSort(u, 0, longitud - 1, (longitud / 2));
  230.             return ((aux1 + aux2) / 2);
  231.         }
  232.         if (u[0] instanceof Float) {
  233.             Float aux1 = (Float) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
  234.             Float aux2 = (Float) quickSort(u, 0, longitud - 1, (longitud / 2));
  235.             return ((aux1 + aux2) / 2);
  236.         } else
  237.             return 0;
  238.  
  239.     }
  240.  
  241.     private T quickSort(T[] array, int i, int j, int objetivo) {
  242.         int indice = partition(array, i, j);
  243.         if (indice == objetivo)
  244.             return array[indice];
  245.         else if (indice < objetivo)
  246.             return quickSort(array, indice + 1, j, objetivo);
  247.         else
  248.             return quickSort(array, i, indice - 1, objetivo);
  249.     }
  250.  
  251.     /**
  252.      * Método auxiliar para unir los dos arrays, únicamente se utiliza si se quiere
  253.      * calcular la mediana sin haber calculado la media con anterioridad.
  254.      *
  255.      * @param a1 Lista 1
  256.      * @param a2 Lista 2
  257.      */
  258.     private void unirArrays(T[] a1, T[] a2) {
  259.         int size = a1.length + a2.length;
  260.         int max = Integer.max(a1.length, a2.length);
  261.         ArrayList<T> aux = new ArrayList();
  262.         for (int i = 0; i < max; i++) {
  263.             aux.add(a1[i]);
  264.             aux.add(a2[i]);
  265.         }
  266.         u = (T[]) aux.toArray();
  267.  
  268.     }
  269.  
  270.     private int partition(T[] arr, int low, int high) {
  271.         T pivot = arr[high];
  272.         int i = (low - 1);
  273.         for (int j = low; j < high; j++) {
  274.             if (arr[j].compareTo(pivot) <= 0) {
  275.                 i++;
  276.                 T temp = arr[i];
  277.                 arr[i] = arr[j];
  278.                 arr[j] = temp;
  279.  
  280.             }
  281.         }
  282.         T temp = arr[i + 1];
  283.         arr[i + 1] = arr[high];
  284.         arr[high] = temp;
  285.  
  286.         return i + 1;
  287.     }
  288.  
  289. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top