Escriba un método de modo en Java para encontrar el elemento más frecuente en una matriz

La pregunta es:

Escriba un método llamado modo que devuelve el elemento más frecuente de una matriz de enteros. Supongamos que la matriz tiene al menos un elemento y que cada elemento de la matriz tiene un valor entre 0 y 100 inclusive. Rompe lazos al elegir el valor más bajo.

Por ejemplo, si el conjunto pasado contiene los valores {27, 15, 15, 11, 27}, su método debe devolver 15. (Sugerencia: Puede consultar el progtwig Tally de este capítulo para hacerse una idea de Cómo resolver este problema.)

A continuación está mi código que casi funciona, excepto para arreglos de un solo elemento

public static int mode(int[] n) {     Arrays.sort(n);     int count2 = 0; int count1 = 0; int pupular1 =0; int popular2 =0; for (int i = 0; i < n.length; i++) { pupular1 = n[i]; count1 = 0; //see edit for (int j = i + 1; j  count2) { popular2 = pupular1; count2 = count1; } else if(count1 == count2) { popular2 = Math.min(popular2, pupular1); } } return popular2; } 

Editar : finalmente lo descubrí. Se modificó count1 = 0; count1 = 1; ¡Todo funciona ahora!

Debe usar un hashmap para tales problemas. tomará O (n) tiempo para ingresar cada elemento en el hashmap y o (1) para recuperar el elemento. En el código dado, estoy básicamente tomando un máximo global y comparándolo con el valor recibido en ‘get’ del hashmap, cada vez que ingreso un elemento en él, eche un vistazo:

hashmap tiene dos partes, una es la clave, la segunda es el valor cuando haces una operación get en la tecla, se devuelve su valor.

 public static int mode(int []array) { HashMap hm = new HashMap(); int max = 1; int temp = 0; for(int i = 0; i < array.length; i++) { if (hm.get(array[i]) != null) { int count = hm.get(array[i]); count++; hm.put(array[i], count); if(count > max) { max = count; temp = array[i]; } } else hm.put(array[i],1); } return temp; } 

Debería poder hacer esto en N operaciones, lo que significa que en una sola pasada, O (n) tiempo.

Use un mapa o int [] (si el problema es solo para ints) para incrementar los contadores, y también use una variable que mantenga la clave que tiene el conteo máximo visto. Cada vez que incremente un contador, pregunte cuál es el valor y compárelo con la última clave que utilizó. Si el valor es mayor, actualice la clave.

 public class Mode { public static int mode(final int[] n) { int maxKey = 0; int maxCounts = 0; int[] counts = new int[n.length]; for (int i=0; i < n.length; i++) { counts[n[i]]++; if (maxCounts < counts[n[i]]) { maxCounts = counts[n[i]]; maxKey = n[i]; } } return maxKey; } public static void main(String[] args) { int[] n = new int[] { 3,7,4,1,3,8,9,3,7,1 }; System.out.println(mode(n)); } } 
 public int mode(int[] array) { int mode = array[0]; int maxCount = 0; for (int i = 0; i < array.length; i++) { int value = array[i]; int count = 1; for (int j = 0; j < array.length; j++) { if (array[j] == value) count++; if (count > maxCount) { mode = value; maxCount = count; } } } return mode; } 

revisa esto … Breve: selecciona cada elemento de la matriz y compáralo con todos los elementos de la matriz, el clima es igual al elegido o no.

  int popularity1 = 0; int popularity2 = 0; int popularity_item, array_item; //Array contains integer value. Make it String if array contains string value. for(int i =0;i= popularity2){ popularity_item = array_item; popularity2 = popularity1; } popularity1 = 0; } //"popularity_item" contains the most repeted item in an array. 

Yo usaría este código. Incluye una función instancesOf y se ejecuta a través de cada número.

 public class MathFunctions { public static int mode(final int[] n) { int maxKey = 0; int maxCounts = 0; for (int i : n) { if (instancesOf(i, n) > maxCounts) { maxCounts = instancesOf(i, n); maxKey = i; } } return maxKey; } public static int instancesOf(int n, int[] Array) { int occurences = 0; for (int j : Array) { occurences += j == n ? 1 : 0; } return occurences; } public static void main (String[] args) { //TODO Auto-generated method stub System.out.println(mode(new int[] {100,200,2,300,300,300,500})); } } 

Noté que el código que Gubatron publicó no funciona en mi computadora; me dio una ArrayIndexOutOfBoundsException .

Aquí está mi respuesta.

 public static int mode(int[] arr) { int max = 0; int maxFreq = 0; Arrays.sort(arr); max = arr[arr.length-1]; int[] count = new int[max + 1]; for (int i = 0; i < arr.length; i++) { count[arr[i]]++; } for (int i = 0; i < count.length; i++) { if (count[i] > maxFreq) { maxFreq = count[i]; } } for (int i = 0; i < count.length; i++) { if (count[i] == maxFreq) { return i; } } return -1; } 

Sé que esta pregunta es de hace un tiempo, pero quería agregar una respuesta que, en mi opinión, se amplía a la pregunta original. La adición a esta pregunta fue para escribir el método de modo sin depender de un rango preestablecido (en este caso, de 0 a 100). He escrito una versión para modo que usa el rango de valores en la matriz original para generar la matriz de conteo.

 public static int mode(int[] list) { //Initialize max and min value variable as first value of list int maxValue = list[0]; int minValue = list[0]; //Finds maximum and minimum values in list for (int i = 1; i < list.length; i++) { if (list[i] > maxValue) { maxValue = list[i]; } if (list[i] < minValue) { minValue = list[i]; } } //Initialize count array with (maxValue - minValue + 1) elements int[] count = new int[maxValue - minValue + 1]; //Tally counts of values from list, store in array count for (int i = 0; i < list.length; i++) { count[list[i] - minValue]++; //Increment counter index for current value of list[i] - minValue } //Find max value in count array int max = count[0]; //Initialize max variable as first value of count for (int i = 1; i < count.length; i++) { if (count[i] > max) { max = count[i]; } } //Find first instance where max occurs in count array for (int i = 0; i < count.length; i++) { if (count[i] == max) { return i + minValue; //Returns index of count adjusted for min/max list values - this is the mode value in list } } return -1; //Only here to force compilation, never actually used } 

Recientemente hice un progtwig que calcula algunas estadísticas diferentes, incluido el modo. Si bien la encoding puede ser rudimentaria, funciona para cualquier conjunto de entradas, y podría modificarse para ser dobles, flotantes, etc. La modificación de la matriz se basa en la eliminación de índices en la matriz que no son los valores de modo final (es) . Esto le permite mostrar todos los modos (si hay varios) así como también la cantidad de ocurrencias (último elemento en la matriz de modos). El siguiente código es el método getMode y el método deleteValueIndex necesarios para ejecutar este código

 import java.io.File; import java.util.Scanner; import java.io.PrintStream; public static int[] getMode(final int[] array) { int[] numOfVals = new int[array.length]; int[] valsList = new int[array.length]; //initialize the numOfVals and valsList for(int ix = 0; ix < array.length; ix++) { valsList[ix] = array[ix]; } for(int ix = 0; ix < numOfVals.length; ix++) { numOfVals[ix] = 1; } //freq table of items in valsList for(int ix = 0; ix < valsList.length - 1; ix++) { for(int ix2 = ix + 1; ix2 < valsList.length; ix2++) { if(valsList[ix2] == valsList[ix]) { numOfVals[ix] += 1; } } } //deletes index from valsList and numOfVals if a duplicate is found in valsList for(int ix = 0; ix < valsList.length - 1; ix++) { for(int ix2 = ix + 1; ix2 < valsList.length; ix2++) { if(valsList[ix2] == valsList[ix]) { valsList = deleteValIndex(valsList, ix2); numOfVals = deleteValIndex(numOfVals, ix2); } } } //finds the highest occurence in numOfVals and sets it to most int most = 0; for(int ix = 0; ix < valsList.length; ix++) { if(numOfVals[ix] > most) { most = numOfVals[ix]; } } //deletes index from valsList and numOfVals if corresponding index in numOfVals is less than most for(int ix = 0; ix < numOfVals.length; ix++) { if(numOfVals[ix] < most) { valsList = deleteValIndex(valsList, ix); numOfVals = deleteValIndex(numOfVals, ix); ix--; } } //sets modes equal to valsList, with the last index being most(the highest occurence) int[] modes = new int[valsList.length + 1]; for(int ix = 0; ix < valsList.length; ix++) { modes[ix] = valsList[ix]; } modes[modes.length - 1] = most; return modes; } public static int[] deleteValIndex(int[] array, final int index) { int[] temp = new int[array.length - 1]; int tempix = 0; //checks if index is in array if(index >= array.length) { System.out.println("I'm sorry, there are not that many items in this list."); return array; } //deletes index if in array for(int ix = 0; ix < array.length; ix++) { if(ix != index) { temp[tempix] = array[ix]; tempix++; } } return temp; } 

En base a la respuesta de @codemania23 y los Java Docs para HashMap , escribí este código recortado y las pruebas de un método que devuelve el número más frecuente en una matriz de números.

 import java.util.HashMap; public class Example { public int mostOcurrentNumber(int[] array) { HashMap map = new HashMap<>(); int result = -1, max = 1; for (int arrayItem : array) { if (map.putIfAbsent(arrayItem, 1) != null) { int count = map.get(arrayItem) + 1; map.put(arrayItem, count); if (count > max) { max = count; result = arrayItem; } } } return result; } } 

Pruebas unitarias

 import org.junit.Test; import static junit.framework.Assert.assertEquals; public class ExampleTest extends Example { @Test public void returnMinusOneWhenInputArrayIsEmpty() throws Exception { int[] array = new int[0]; assertEquals(mostOcurrentNumber(array), -1); } @Test public void returnMinusOneWhenElementsUnique() { int[] array = new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; assertEquals(-1, mostOcurrentNumber(array)); } @Test public void returnOne() throws Exception { int[] array = new int[]{0, 1, 0, 0, 1, 1, 1}; assertEquals(1, mostOcurrentNumber(array)); } @Test public void returnFirstMostOcurrentNumber() throws Exception { int[] array = new int[]{0, 1, 0, 1, 0, 0, 1, 1}; assertEquals(0, mostOcurrentNumber(array)); } } 

Este no es el método más rápido en todo el bloque, pero es bastante simple de entender si no quiere involucrarse en HashMaps y también quiere evitar el uso de 2 bucles para problemas de complejidad ….

  int mode(int n, int[] ar) { int personalMax=1,totalMax=0,maxNum=0; for(int i=0;i 

Aquí, he codificado usando solo lazo. Estamos obteniendo el modo de [j-1] porque localCount se actualizó recientemente cuando j era j-1. También N es el tamaño de la matriz y los recuentos se inicializan a 0.

  //After sorting the array i = 0,j=0; while(i!=N && j!=N){ if(ar[i] == ar[j]){ localCount++; j++; } else{ i++; localCount = 0; } if(localCount > globalCount){ globalCount = localCount; mode = ar[j-1]; } } 
  Arrays.sort(arr); int max=0,mode=0,count=0; for(int i=0;imax) { max=count; mode = arr[i]; } } 

importar java.util.HashMap;

clase pública SmallestHighestRepeatedNumber {static int arr [] = {9, 4, 5, 9, 2, 9, 1, 2, 8, 1, 1, 7, 7};

 public static void main(String[] args) { int mode = mode(arr); System.out.println(mode); } public static int mode(int[] array) { HashMap hm = new HashMap(); int max = 1; int temp = 0; for (int i = 0; i < array.length; i++) { if (hm.get(array[i]) != null) { int count = hm.get(array[i]); count++; hm.put(array[i], count); if (count > max || temp > array[i] && count == max) { temp = array[i]; max = count; } } else hm.put(array[i], 1); } return temp; } 

}

ESTE CÓDIGO CALCULA EL MODO, MEDIANO Y MEDIO. SE PRUEBA Y FUNCIONA. Es un progtwig completo de principio a fin y comstackrá.

 import java.util.Arrays; import java.util.Random; import java.math.*; /** * * @author Mason */ public class MODE{ public static void main(String args[]) { System.out.print("Enter the quantity of random numbers ===>> "); int listSize = Expo.enterInt(); System.out.println(); ArrayStats intStats = new ArrayStats(listSize); intStats.randomize(); intStats.computeMean(); intStats.computeMedian(); intStats.computeMode(); intStats.displayStats(); System.out.println(); } } class ArrayStats { private int list[]; private int size; private double mean; private double median; private int mode; public ArrayStats(int s)//initializes class object { size = s; list = new int[size]; } public void randomize() { //This will provide same numbers every time... If you want to randomize this, you can Random rand = new Random(555); for (int k = 0; k < size; k++) list[k] = rand.nextInt(11) + 10; } public void computeMean() { double accumulator=0; for (int index=0;index= popularity2){ mode = array_item; popularity2 = popularity1; } popularity1 = 0; }} public void displayStats() { System.out.println(Arrays.toString(list)); System.out.println(); System.out.println("Mean: " + mean); System.out.println("Median: " + median); System.out.println("Mode: " + mode); System.out.println(); } }