Búsqueda De Múltiples Modos En Una Matriz

Estoy tratando de escribir un método java que se encuentra todos los modos de transporte en una matriz. Yo sé que hay un método sencillo para encontrar el modo de una matriz, pero cuando hay más de un modo único, mi método de salidas sólo uno de ellos. He tratado de encontrar una manera de hacer, pero estoy nit seguro de cómo abordar este problema. Alguien me puede ayudar a encontrar todos los modos en la matriz? Gracias.

Sí aquí está mi código que genera sólo un modo incluso si hay varios modos de existir.

public static int mode(int a[]){
  int maxValue=0, maxCount=0;   
  for (int i = 0; i < a.length; ++i){
    int count = 0;
    for (int j = 0; j < a.length; ++j){
      if (a[j] == a[i]) ++count;
    }
    if (count > maxCount){
      maxCount = count;
      maxValue = a[i];
    }
  }
  return maxValue;
}

bueno aquí está un ejemplo:
30
30
30
34
34
23

En este conjunto de números sólo hay un modo, que es de 30.

30
30
30
34
34
34
23

Pero en este juego hay dos modos, 30 y 34. Quiero que mi código sea capaz de salida de dos de ellos, mientras que sólo se imprime una. Imprime sólo 30.

  • ¿A qué te refieres con modo ? ¿Cuál es ese método sencillo para encontrar el modo de en una matriz a la que se refiere. Cualquier código de su método, que sólo salidas de uno de ellos ?
  • sí aquí está mi código que genera sólo un modo, incluso si hay más de uno existe. public static int mode(int a[]) { int maxValue=0, maxCount=0; for (int i = 0; i < a.length; ++i) { int cuenta = 0; for (int j = 0; j < a.length; j++) {if (a[j] == a[i]) ++contador; } if (count > maxCount) { maxCount = count; maxValue = a[i]; } } return maxValue; }
  • no poner el código en los comentarios; acaba de editar su pregunta.
  • sí, lo siento yo alterado.
  • Y cuál es la relación entre ese trozo de código y su pregunta ? Que el código sólo devuelve la int que se produce la mayoría de las veces en la matriz, mientras que usted desea encontrar múltiples modos’ en una matriz. Qué quiere decir usted desea devolver un array sin duplicados ? Que se explica here. Si quieres decir algo más, por favor refinar su pregunta
  • eso es lo que la mode es – el elemento en el array («set» en la terminología matemática) que se produce más a menudo. En el caso de un lazo donde 2 elementos están apareciendo el mismo número de veces que la matriz es bimodal y si hay más de 2 elementos que aparecen el mismo número de veces, multimodal
  • muchas gracias, ahora creo que por fin entiendo la pregunta
  • sí, tengo una matriz con más de uno de los modos, y quiero ser capaz de imprimir todos ellos.

InformationsquelleAutor Daniel Cook | 2012-01-13

4 Kommentare

  1. 1

    El siguiente código devolverá una Integer[] que contiene los modos. Si usted necesita un int[] en su lugar, usted todavía necesita para convertir el Integer instancias de ints manualmente. Probablemente no es el más eficiente de la versión, pero sus partidos de cerca a su código de

    public static Integer[] mode(int a[]){
      List<Integer> modes = new ArrayList<Integer>(  );
      int maxCount=0;   
      for (int i = 0; i < a.length; ++i){
        int count = 0;
        for (int j = 0; j < a.length; ++j){
          if (a[j] == a[i]) ++count;
        }
        if (count > maxCount){
          maxCount = count;
          modes.clear();
          modes.add( a[i] );
        } else if ( count == maxCount ){
          modes.add( a[i] );
        }
      }
      return modes.toArray( new Integer[modes.size()] );
    }
    • Sí, tú eres bastante bloqueado en O(n^2). La única optimización que puedo pensar es que si usted fuera a utilizar maxCount para limitar el bucle interno; si ((j.length - (j + 1)) + count) < maxCount puede fianza.
  2. 1

    Después de una larga noche de la programación, yo finalidad tengo un programa que imprima el modo o los modos de una matriz. O incluso le dirá si es que no hay un modo (es decir, si no hay ninguna entrada ocurrido más de una vez o todos los insumos que se produjo la misma cantidad de veces: ex. 1, 1, 2, 2, 3, 3, 4, 4). Algunas limitaciones del programa son que usted debe ingresar más de un número, y usted no puede entrar más de 10000 números o un número negativo (si se quisiera introducir un número negativo, usted sólo tiene que ajustar todos los bucles for que involucran los valores[][] matriz. Algunas cosas interesantes acerca de mi programa que imprime cuántas veces cada uno de ustedes las entradas se ha producido junto con el modo de su matriz. Y todas las salidas de impresión de la gramática cambiar de acuerdo a la cantidad de info (Ex. El modo de la matriz es 2; Los modos de su matriz 1 & 2; Los modos de la matriz son 0, 2, 5, & 8). También hay una especie de burbuja ejemplo de la función en el programa para cualquier persona que pensaron que necesitaban un clasificador en función de su modo de programa. Espero que esto ayude, he incluido una gran cantidad de pseudo-código para ayudar a cualquier persona que no ve cómo mi lógica de progreso a lo largo del programa. (FYI: es java, y fue compilado en BlueJ)

    import java.util.Scanner;
    public class Mode
    {
        public static void main (String args [])
        {
            Scanner scan = new Scanner(System.in);
            int MAX_INPUTS = 10000; boolean flag = false;
            System.out.print ("Input the size of your array: ");
            int size; //How many nubers will be in the user array
            do
            {
                size = scan.nextInt();
                if (size == 1)
                {
                    System.out.print ("\nError. You must enter a number more than 1.\n\n"); 
                    continue;
                }
                else if (size > MAX_INPUTS || size < 0)
                {
                    System.out.print ("\nError. You muste enter a number less than " + MAX_INPUTS + " or greater than 0\n\n");
                    continue;
                }
                else
                    flag = true; //a ligit answer has been entered.
            }
            while (flag != true);
            int array[] = new int[size], values[][] = new int[2][MAX_INPUTS + 1], ticks = 0;
    
            System.out.print ("\nNow input the numbers for your array.\n\n");
    
            /* Taking inputs from the user */        
            while (ticks < size)
            {
                System.out.print ("Number " + (ticks + 1) + ": ");
                array[ticks] = scan.nextInt();
                if (array[ticks] > MAX_INPUTS || array[ticks] < 0)
                {
                    System.out.print ("\nError. Number cannot be greater than " + MAX_INPUTS + " or less than 0\n\n");
                    continue;
                }               
                ++ticks;
            }
    
            /* 
             * values[][] array will hold the info for how many times numbers 0 - 10000 appear in array[]. Column 0 will hold numbers from 0 -1000, and column 1 will hold the number of
             * of repititions the number in column 0 occured in the users inputed array.
             */
    
            for (int i = 0; i < MAX_INPUTS; ++i) //Initalize Column zero with numbers starting at zeor, and ending and MAX_INPUTS.
                values[0][i] = i;
    
            for (int i = 0; i < size; ++i) //Find the repatitions of the numbers in array[] that correspond to the number in column zere of values[][].
                for (int j = 0; j < MAX_INPUTS; ++j)
                    if (array[i] == j)
                        ++values[1][j];
    
            sort (array, size);
            System.out.print ("\n\nHere are the numbers you entered.\n\n"); //show the values the user entered in ascending order.
    
            for (int i = 0; i < size; ++i)
            {
                if (i == size - 1) //the last inputed number
                    System.out.print (array[i]); //don't allow an extra comma.
                else
                    System.out.print (array[i] + ", ");
            }
    
            //Show the user how many times each of the values he/she entered occured.
    
            System.out.print ("\n\nThis is the amount of times each of the values you entered occured:\n");
    
            for (int i = 0; i < MAX_INPUTS; ++i)
            {
                if (values[1][i] == 1)
                    System.out.print (i + " was entered " + values[1][i] + " time\n"); //avoid: 2 was entered 1 times
                else if (values[1][i] != 0)
                    System.out.print (i + " was entered " + values[1][i] + " times\n"); //avoid: 2 was entered 2 time
            }
    
    
            /* -------------------------------------------------------------------- | Finding the Mode/Modes | -------------------------------------------------------------------- */
            /* The process begins with creating a second array that is the exactly the same as the values[][] (First for loop). Then I sort the duplicate[] array to find the mode 
             * (highest number in the duplicate[]/values[][] arrays. Int max is then assigned the highest number. Remembering that the values[][] array: column 0 contains numbers ranging
             * from 1 to 10000, it keeps track of where the numbers in column were originally located, in which you can compare to the duplicate array which is sorted. Then I can set 
             * up a flag that tells you whether there is more than one mode. If so, the printing of these modes will look neater and the grammar can be changed accordingly.
             */
    
            int duplicate[] = new int [10001], mode[] = new int [size], max, mode_counter = 0;
            boolean multi_mode = false, all_same;
    
            for (int i = 0; i < MAX_INPUTS; ++i)
                duplicate[i] = values[1][i]; //copy values array.
    
            sort (duplicate, MAX_INPUTS);
            max = duplicate[MAX_INPUTS - 1]; //the last number in the sorted array is the greatest.
            all_same = test (duplicate, MAX_INPUTS, size, max); //this is the test to see if all the numbers in the user array occured the same amount of times.
            int c = 0; //a counter
    
            /* The mode of the user inputed array will be recorded in the values array. The sort of the duplicate array told me what was the higest number in that array. Now I can 
             * see where that highest number used to be in the original values array and recored the corresponding number in the column zero, which was only filled with numbers 0 -
             * 10000. Thus telling me the mode/modes.
             */
    
            for (int i = 0; i < MAX_INPUTS; ++i)
            {
                if (values[1][i] == max)
                {
                    mode[c++] = values[0][i];
                    ++mode_counter;
                }
            }
    
            if (mode[1] != 0) //mode[0] (the first cell, has a number stored from the last for loop. If the second cell has a number other than zero, that tells me there is more than 1 mode.
                multi_mode = true;
    
            if (multi_mode == false)
                System.out.print ("\nThe mode of your array is " + mode[0]); //For correct grammer.
            else if (all_same == true)
                System.out.print ("\nAll of the numbers entered appeared the same amount of times. "); //See the boolean function for more details
            else //If here there is more than one mode.
            {
                System.out.print ("\nThe modes of yoru array are ");
                for (int i = 0; i < mode_counter; ++i)
                {
                    if (mode_counter > 2 && i == (mode_counter - 1))  //If there is more than two modes and the final mode is to be printed.
                        System.out.print ("& " + mode[i]);
                    else if (mode_counter == 2)
                    { //This is true if there is two modes. The else clause will print the first number, and this will print the amper sign and the second mode.
                        System.out.print (mode[0] + " & " + mode[1]); 
                        break;
                    }
                    else
                        System.out.print (mode[i] + ", ");
                }
            }
        }
    
        public static void sort (int list[], int max) //Its the bubble sort if you're wondering.
        {
            int place, count, temp;        
            for (place = 0; place < max; ++place)
                for (count = max - 1; count > place; --count)
                    if (list[count - 1] > list[count])
                    {
                            temp = list[count-1];
                            list[count - 1] = list[count];
                            list[count] = temp;
                    }
        }
    
        /* The test to see if there isn't a mode. If the amount of the mode number is the same as the amount of numbers there are in the array is true, or if the size entered by the 
         * user (input) modulo the mode value is equal to zero (say, all the numbers in an array of ten were entered twice: 1, 1, 2, 2, 3, 3, 4, 4, 5, 5). */
        public static boolean test (int list[], int limit, int input, int max)
        {
            int counter = 0, anti_counter = 0;
            for (int i = 0; i < limit; ++i)
                if (list[i] == max)
                    ++counter; //count the potential modes
                else if (list[i] !=0 && list[i] != max)
                    ++anti_counter; //count every thing else except zeros.
    
    
            if (counter == input || (input % max == 0 && anti_counter == 0) )
                return true;
            else
                return false;
        }
    }
  3. 0

    Aunque esto probablemente no es la solución más eficiente, se imprimirá todos los modos más altos:

    public static int mode(int a[]) {
        int maxValue=-1, maxCount=0;
        for (int i = 0; i < a.length; i++) {
            int count = 0;
            for (int j = 0; j < a.length; j++) {
                if (a[j] == a[i])
                    count++;
                }
            }
            if (count > maxCount) {
                maxCount = count;
                maxValue = a[i];
            }
        }
    
        //loop again and print only the highest modes
        for (int i = 0; i < a.length; i++) {
            int count = 0;
            for (int j = 0; j < a.length; j++) {
                if (a[j] == a[i])
                    count++;
                }
            }
            if (count == maxCount) {
                System.out.println(a[i]);
            }
        }
    }
    • Decir lo que … esto no hace ninguna diferencia
    • tienes razón, que solo hace lo mismo que mi anterior código.
    • Actualizado mi solución. Esto va a funcionar ahora. No estoy seguro si fueron sólo quieren imprimir a ellos o los han devuelto. Esta solución imprime.
    • uh esta solución es la impresión de los modos, el número de veces que se produce, mientras que yo quiero que se imprime sólo una vez. Gracias, aunque ahora tengo una idea general de cómo este código funciona.
  4. 0

    Espero que esto ayude. Esta es mi respuesta. Espero que ayude

    public List mode(double[] m) {
        HashMap<Double, Double> freqs = new HashMap<Double, Double>();
        for (double d : m) {
            Double freq = freqs.get(d);
            freqs.put(d, (freq == null ? 1 : freq + 1));
        }
        List<Double> mode = new ArrayList<Double>();
        List<Double> frequency = new ArrayList<Double>();
        List<Double> values = new ArrayList<Double>();
    
        for (Map.Entry<Double, Double> entry : freqs.entrySet()) {
            frequency.add(entry.getValue());
            values.add(entry.getKey());
        }
        double max = Collections.max(frequency);
    
        for(int i=0; i< frequency.size();i++)
        {
            double val =frequency.get(i);
            if(max == val )
            {
                mode.add(values.get(i));
            }
        }
        return mode;
    }

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea