Ecrivez une méthode de mode en Java pour trouver l'élément le plus fréquent dans un tableau
La question est:
Ecrivez une méthode appelée mode qui renvoie l’élément le plus fréquent d’un tableau d’entiers. Supposons que le tableau comporte au moins un élément et que chaque élément du tableau a une valeur comprise entre 0 et 100 inclus. Rompez les liens en choisissant la valeur inférieure.
Par exemple, si le tableau passé contient les valeurs {27, 15, 15, 11, 27}, votre méthode doit en retourner 15. (Indice: vous pouvez consulter le programme Tally plus tôt dans ce chapitre pour avoir une idée Comment résoudre ce problème.)
Ci-dessous, mon code qui fonctionne presque sauf pour les tableaux à un seul élément
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 < n.length; j++)
{
if (pupular1 == n[j]) count1++;
}
if (count1 > count2)
{
popular2 = pupular1;
count2 = count1;
}
else if(count1 == count2)
{
popular2 = Math.min(popular2, pupular1);
}
}
return popular2;
}
Edit : a finalement compris. count1 = 0; remplacé par count1 = 1; tout fonctionne maintenant!
Vous devriez utiliser un hashmap pour de tels problèmes. il faudra O(n) temps pour entrer chaque élément dans la table de hachage et o(1) pour récupérer l'élément. Dans le code donné, je prends un maximum global et le compare à la valeur reçue sur 'get' dans la table de hachage. Chaque fois que je saisis un élément, regardez:
hashmap a deux parties, l'une est la clé, la seconde est la valeur lorsque vous effectuez une opération get sur la clé, sa valeur est renvoyée.
public static int mode(int []array)
{
HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
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;
}
Vous devriez pouvoir le faire en N opérations, c’est-à-dire en un seul passage, temps O(n).
Utilisez une mappe ou int [] (si le problème concerne uniquement les entiers) pour incrémenter les compteurs, et utilisez également une variable qui conserve la clé qui a le nombre max vu. Chaque fois que vous incrémentez un compteur, demandez quelle est la valeur et comparez-la à la dernière clé utilisée. Si la valeur est supérieure, mettez à jour la clé.
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;
}
check this .. Brief: Choisissez chaque élément du tableau et comparez-le avec tous les éléments du tableau, qu'il soit égal ou non
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<array.length;i++){
array_item = array[i];
for(int j =0;j<array.length;j++){
if(array_item == array[j])
popularity1 ++;
{
if(popularity1 >= popularity2){
popularity_item = array_item;
popularity2 = popularity1;
}
popularity1 = 0;
}
//"popularity_item" contains the most repeted item in an array.
Arrays.sort(arr);
int max=0,mode=0,count=0;
for(int i=0;i<N;i=i+count) {
count = 1;
for(int j=i+1; j<N; j++) {
if(arr[i] == arr[j])
count++;
}
if(count>max) {
max=count;
mode = arr[i];
}
}
Je sais que cette question a été posée il y a quelque temps, mais je voulais ajouter une réponse qui, à mon avis, développe la question initiale. Le complément à cette question consistait à écrire la méthode de mode sans s'appuyer sur une plage prédéfinie (dans ce cas, 0 à 100). J'ai écrit une version pour le mode qui utilise la plage de valeurs du tableau d'origine pour générer le tableau de comptage.
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
}
Ici, j'ai codé en utilisant une seule boucle. Nous obtenons le mode d'un [j-1] car localCount a été récemment mis à jour alors que j était j-1. De plus, N est la taille du tableau et les comptes sont initialisés à 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];
}
}
Ce n'est pas la méthode la plus rapide du bloc, mais elle est assez simple à comprendre si vous ne voulez pas vous impliquer dans HashMaps et que vous voulez également éviter d'utiliser 2 boucles for pour les problèmes de complexité ....
int mode(int n, int[] ar) {
int personalMax=1,totalMax=0,maxNum=0;
for(int i=0;i<n-1;i++)
{
if(ar[i]==ar[i+1])
{
personalMax++;
if(totalMax<personalMax)
{
totalMax=personalMax;
maxNum=ar[i];
}
}
else
{
personalMax=1;
}
}
return maxNum;
}
Basé sur la réponse de @ codemania23 et du Java Docs pour HashMap j'ai écrit ce code extrait et les tests d'une méthode qui renvoie le nombre le plus occurrent dans un tableau de nombres.
import Java.util.HashMap;
public class Example {
public int mostOcurrentNumber(int[] array) {
HashMap<Integer, Integer> 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;
}
}
Tests unitaires
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));
}
}
Je voudrais utiliser ce code. Il inclut une fonction instancesOf et parcourt chaque nombre.
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}));
}
}
J'ai remarqué que le code affiché par Gubatron ne fonctionne pas sur mon ordinateur. cela m'a donné une ArrayIndexOutOfBoundsException.
importer Java.util.HashMap;
classe publique 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<Integer, Integer> hm = new HashMap<Integer, Integer>();
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;
}
}
Voici ma réponse.
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;
}
J'ai récemment créé un programme qui calcule quelques statistiques différentes, y compris le mode. Bien que le codage puisse être rudimentaire, il fonctionne pour n’importe quel tableau d’entités et peut être modifié pour devenir un double, un nombre à virgule flottante, etc. . Cela vous permet d'afficher tous les modes (s'il y en a plusieurs) ainsi que le nombre d'occurrences (dernier élément du tableau de modes). Le code ci-dessous est la méthode getMode ainsi que la méthode deleteValueIndex nécessaire pour exécuter ce code.
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;
}