Arrays.sort(arr);
int max=1,m=1;
for(int i=1;i<arr.length;i++){
    if(arr[i]==arr[i-1]){
        max++;
    }
    else{
        if(max>m){
            m=max;
            max=1;
        }
       
    }
}
if(max>m){
    m=max;
   
}

return m;

C'est une fonction que j'ai créée. Cela devrait renvoyer le nombre de fois où l'élément le plus fréquent se produit. Par exemple, si le tableau est 1,2,2,3,3,3, alors il doit renvoyer 3. Mais il échoue dans de nombreux cas, par exemple pour l'entrée 1 2 3 1 2 3 3 3, ce code échoue et renvoie 5, ce qui est la mauvaise sortie.

1
QUEST275 30 août 2020 à 00:32

6 réponses

Meilleure réponse

Trier d'abord le tableau et compter les exécutions du même nombre est une bonne idée. Votre logique n'a pas vraiment de sens.

Vous devez garder une trace de la longueur de la course en cours et de la longueur de la plus longue course. Votre exécution actuelle doit être réinitialisée lorsque la valeur du tableau est différente de la valeur précédente; et votre plus longue course doit être mise à jour lorsque la course actuelle est plus longue qu'elle.

Quelque chose comme ça:

if (arr.length==0) {
    return 0;
}
Arrays.sort(arr);
int currentRun = 1;
int longestRun = 1;
for (int i = 1; i < arr.length; i++){
    if (arr[i]==arr[i-1]){
        ++currentRun;
        if (currentRun > longestRun) {
            longestRun = currentRun;
        }
    } else {
        currentRun = 1;
    }
}

return longestRun;
1
khelwood 29 août 2020 à 23:56

Vous devez comparer max à m pour chaque itération. Et l'utilisation de continue ici simplifie la logique. Imprime -1 sur un tableau vide.

int[] arr = {1, 2, 3, 1, 2, 3, 3, 3}; 
Arrays.sort(arr);                       
int max = 1;                            
int m = arr.length == 0 ? -1 : 1;                             
for (int i = 1; i < arr.length; i++) {  
    if (arr[i] == arr[i - 1]) {         
        max++;                          
        if (max > m) {                  
            m = max;                    
        }                               
        continue;                       
    }                                   
    max = 1;                            
}                                       
                                                                         
System.out.println(m);

Impressions

4
0
WJS 30 août 2020 à 00:23

Votre logique est totalement correcte sauf une ligne. ==> si (max> m). Dans ce cas, vous ne réinitialisez pas la valeur de max si max == m.

Remplacer if(max>m){ par if(max>=m){

0
codeNdebug 29 août 2020 à 21:42

C'est peut-être ce que vous voulez ... Tous les nombres que vous souhaitez utiliser sont contenus dans le tableau a.

public class Main {
public static void main(String[] args) {
    int[] a = {1,2,3,4,5,6,7,7,7,7};
    int count = 1, tempCount;
    int popular = a[0];
    int temp = 0;
    for (int i = 0; i < (a.length - 1); i++) {
        temp = a[i];
        tempCount = 0;
        for (int j = 1; j < a.length; j++) {
            if (temp == a[j])
                tempCount++;
        }
        if (tempCount > count) {
            popular = temp;
            count = tempCount;
        }
    }
    System.out.println(popular);
}
}
0
HugoS 29 août 2020 à 21:40

Une autre façon d'utiliser les flux, qui utilise essentiellement une carte pour suivre la fréquence des occurrences et saisit la valeur la plus élevée après le tri de cette carte.

public static Long getMostFrequentCount( int ... values ) {
    return Arrays.stream(values).boxed().collect(Collectors.groupingBy(Function.identity(),
            Collectors.counting())).values().stream().max(Long::compareTo).orElse( null );
}

EDIT: amélioré grâce à l'excellente suggestion de @ saka1029

1
Gryphon 30 août 2020 à 00:08

Je peux le coder pour que vous répondiez à votre question à l'aide de l'interface de la carte. Je vérifierai chaque valeur et s'il existe déjà une clé pour cette valeur, elle incrémentera la valeur de 1. Sinon, elle créera la clé et lui attribuera une valeur de 1.

Une fois terminé, je n'ai qu'à demander à la carte quelle était la valeur la plus élevée, ce que je pense que vous recherchez. Et je peux aussi renvoyer la valeur qui était la plus fréquente, si vous le souhaitez.

Voici le code testé. Une classe pour la méthode de travail, puis la classe du pilote avec la méthode principale

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;

public class FindMostFrequent {

    public static Integer returnFromArrayHighestFrequency(int[] inArray) {
        HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>();

        for (int i = 0; i < inArray.length; i++) {
            if (hashMap.containsKey(inArray[i])) {
                hashMap.put(inArray[i], hashMap.get(inArray[i]) + 1);
            } else {
                hashMap.put(inArray[i], 1);
            }
        }
        Integer maxValue = Collections.max(hashMap.values());

        return maxValue;
    }

}

Et voici la classe de pilote:

    public static void main(String[] args) {
        int[] testArray = { 1, 2, 2, 3, 3, 3 };

        Integer max = FindMostFrequent.returnFromArrayHighestFrequency(testArray);
        System.out.println("highest frequency is:  " + max);

    }

J'aime cette technique car elle permet d'obtenir facilement le minimum ou une autre valeur et sa clé que l'on souhaite.

2
K. hervey 29 août 2020 à 23:10