Scrivi un metodo mode in Java per trovare l’elemento che si verifica più frequentemente in un array

La domanda è:

Scrivi un metodo chiamato mode che restituisce l’elemento che si verifica più frequentemente in un array di numeri interi. Supponiamo che l’array abbia almeno un elemento e che ogni elemento dell’array abbia un valore compreso tra 0 e 100 inclusi. Rompere le cravatte scegliendo il valore più basso.

Ad esempio, se la matrice passata contiene i valori {27, 15, 15, 11, 27}, il metodo dovrebbe restituire 15. (Suggerimento: potresti avere voglia di guardare il programma Tally di prima in questo capitolo per avere un’idea di come risolvere questo problema.)

Di seguito è riportato il mio codice che funziona quasi eccetto gli array di elementi singoli

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; } 

Modifica : finalmente capito. count1 = 0; modificato1 count1 = 0; count1 = 1; tutto funziona ora!

    Dovresti usare una hashmap per questi problemi. occorrerà O (n) tempo per inserire ciascun elemento nella hashmap e o (1) per recuperare l’elemento. Nel codice dato, sto fondamentalmente prendendo un massimo globale e confrontandolo con il valore ricevuto su “ottieni” dall’hashmap, ogni volta che inserisco un elemento in esso, date un’occhiata:

    hashmap ha due parti, una è la chiave, il secondo è il valore quando si esegue un’operazione get sulla chiave, il suo valore viene restituito.

     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; } 

    Dovresti essere in grado di farlo in N operazioni, cioè in un solo passaggio, O (n) tempo.

    Usa una mappa o int [] (se il problema è solo per ints) per incrementare i contatori, e usa anche una variabile che mantiene la chiave con il conteggio massimo visto. Ogni volta che si incrementa un contatore, chiedere quale sia il valore e confrontarlo con la chiave utilizzata per ultima, se il valore è maggiore, aggiornare la chiave.

     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; } 

    controlla questo .. Breve: scegli ogni elemento della matrice e confrontalo con tutti gli elementi dell’array, tempo è uguale alla scelta o meno.

      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. 

    Vorrei usare questo codice. Include una funzione instancesOf e scorre attraverso ogni numero.

     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})); } } 

    Ho notato che il codice pubblicato da Gubatron non funziona sul mio computer; mi ha dato una ArrayIndexOutOfBoundsException .

    Ecco la mia risposta.

     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; } 

    So che questa domanda è di qualche tempo fa, ma volevo aggiungere una risposta che, a mio avviso, espande la domanda originale. L’addendum a questa domanda era di scrivere il metodo mode senza fare affidamento su un intervallo preimpostato (in questo caso, da 0 a 100). Ho scritto una versione per la modalità che utilizza l’intervallo di valori nell’array originale per generare l’array di conteggi.

     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 } 

    Di recente ho creato un programma che calcola alcune statistiche diverse, inclusa la modalità. Mentre la codifica può essere rudimentale, funziona per qualsiasi array di int e può essere modificata per essere doppia, float, ecc. La modifica all’array si basa sull’eliminazione di indici nella matrice che non sono i valori della modalità finale. . Questo ti permette di mostrare tutte le modalità (se ce ne sono molte) e di avere la quantità di occorrenze (ultimo elemento nella matrice delle modalità). Il codice seguente è il metodo getMode e il metodo deleteValueIndex necessari per eseguire questo codice

     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; } 

    Sulla base della risposta di @ codemania23 e di Java Docs per HashMap, ho scritto questo codice ritagliato e test di un metodo che restituisce il numero più frequente in una matrice di numeri.

     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; } } 

    Test di unità

     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)); } } 

    Questo non è il metodo più veloce intorno al blocco, ma è abbastanza semplice da capire se non vuoi coinvolgerti in HashMaps e vuoi anche evitare di usare 2 cicli for per problemi di complessità ….

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

    Qui, ho codificato utilizzando il loop singolo. Stiamo ricevendo la modalità da [j-1] perché localCount è stato aggiornato di recente quando j era j-1. Anche N è la dimensione dell’array e i conteggi sono inizializzati 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]; } } 

    import java.util.HashMap;

    public class 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; } 

    }

    QUESTO CODICE CALCOLA MODALITÀ, MEDIA E SIGNIFICATO. È TESTATO E FUNZIONA. È un programma completo dall’inizio alla fine e verrà compilato.

     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(); } }