Trouver l'élément le plus populaire dans le tableau int []
int[] a = new int[10]{1,2,3,4,5,6,7,7,7,7};
comment puis-je écrire une méthode et renvoyer 7?
Je veux le garder natif sans l'aide de listes, de cartes ou d'autres aides .
public int getPopularElement(int[] a)
{
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;
}
}
return popular;
}
Essayez cette réponse. Tout d'abord, les données:
int[] a = {1,2,3,4,5,6,7,7,7,7};
Ici, nous construisons une carte comptant le nombre de fois où chaque nombre apparaît:
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i : a) {
Integer count = map.get(i);
map.put(i, count != null ? count+1 : 0);
}
Maintenant, nous trouvons le nombre avec la fréquence maximale et le renvoyons:
Integer popular = Collections.max(map.entrySet(),
new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
return o1.getValue().compareTo(o2.getValue());
}
}).getKey();
Comme vous pouvez le constater, le nombre le plus populaire est sept:
System.out.println(popular);
> 7
MODIFIER
Voici ma réponse sans en utilisant des cartes, des listes, etc. et en n'utilisant que des tableaux; bien que je trie le tableau sur place. C'est la complexité de O (n log n), meilleure que la solution acceptée par O (n ^ 2).
public int findPopular(int[] a) {
if (a == null || a.length == 0)
return 0;
Arrays.sort(a);
int previous = a[0];
int popular = a[0];
int count = 1;
int maxCount = 1;
for (int i = 1; i < a.length; i++) {
if (a[i] == previous)
count++;
else {
if (count > maxCount) {
popular = a[i-1];
maxCount = count;
}
previous = a[i];
count = 1;
}
}
return count > maxCount ? a[a.length-1] : popular;
}
- Prendre une carte pour cartographier un élément -> compter
- Itérer dans un tableau et traiter la carte
- Parcourez la carte et découvrez le populaire
En supposant que votre tableau soit trié (comme celui que vous avez posté), vous pouvez simplement parcourir le tableau et compter le plus long segment d'éléments. C'est quelque chose comme le message de @ narek.gevorgyan mais sans le tableau extrêmement volumineux, et il utilise la même quantité de mémoire quelle que soit la taille du tableau:
private static int getMostPopularElement(int[] a){
int counter = 0, curr, maxvalue, maxcounter = -1;
maxvalue = curr = a[0];
for (int e : a){
if (curr == e){
counter++;
} else {
if (counter > maxcounter){
maxcounter = counter;
maxvalue = curr;
}
counter = 0;
curr = e;
}
}
if (counter > maxcounter){
maxvalue = curr;
}
return maxvalue;
}
public static void main(String[] args) {
System.out.println(getMostPopularElement(new int[]{1,2,3,4,5,6,7,7,7,7}));
}
Si le tableau n'est pas trié, triez-le avec Arrays.sort(a);
Celui-ci sans cartes:
public class Main {
public static void main(String[] args) {
int[] a = new int[]{ 1, 2, 3, 4, 5, 6, 7, 7, 7, 7 };
System.out.println(getMostPopularElement(a));
}
private static int getMostPopularElement(int[] a) {
int maxElementIndex = getArrayMaximumElementIndex(a);
int[] b = new int[a[maxElementIndex] + 1]
for (int i = 0; i < a.length; i++) {
++b[a[i]];
}
return getArrayMaximumElementIndex(b);
}
private static int getArrayMaximumElementIndex(int[] a) {
int maxElementIndex = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] >= a[maxElementIndex]) {
maxElementIndex = i;
}
}
return maxElementIndex;
}
}
Vous ne devez modifier du code que si votre tableau peut avoir des éléments qui sont < 0. Et cet algorithme est utile lorsque vos éléments de tableau ne sont pas de grands nombres.
Utilisation Java 8 Streams
int data[] = { 1, 5, 7, 4, 6, 2, 0, 1, 3, 2, 2 };
Map<Integer, Long> count = Arrays.stream(data)
.boxed()
.collect(Collectors.groupingBy(Function.identity(), counting()));
int max = count.entrySet().stream()
.max((first, second) -> {
return (int) (first.getValue() - second.getValue());
})
.get().getKey();
System.out.println(max);
Explication
Nous convertissons le tableau int[] data en un flux entier en boîte. Ensuite, nous collectons par groupingBy sur l'élément et utilisons un collecteur de comptage secondaire pour compter après la groupBy.
Enfin, nous trions la carte du nombre d'éléments -> en fonction du nombre à l'aide d'un comparateur de flux et de lambda.
La valeur des éléments de tableau doit être inférieure à la longueur du tableau pour celui-ci:
public void findCounts(int[] arr, int n) {
int i = 0;
while (i < n) {
if (arr[i] <= 0) {
i++;
continue;
}
int elementIndex = arr[i] - 1;
if (arr[elementIndex] > 0) {
arr[i] = arr[elementIndex];
arr[elementIndex] = -1;
}
else {
arr[elementIndex]--;
arr[i] = 0;
i++;
}
}
Console.WriteLine("Below are counts of all elements");
for (int j = 0; j < n; j++) {
Console.WriteLine(j + 1 + "->" + Math.Abs(arr[j]));
}
}
La complexité temporelle de ce sera O(N) et la complexité de l’espace sera O(1).
Si vous ne souhaitez pas utiliser de carte, procédez comme suit:
- Trier le tableau (en utilisant
Arrays.sort()) - Utilisez une variable pour contenir l'élément le plus populaire (mostPopular), une variable pour conserver son nombre d'occurrences dans le tableau (mostPopularCount) et une variable pour contenir le nombre d'occurrences du nombre actuel dans l'itération (currentCount)
- Itérer dans le tableau. Si l'élément en cours est identique à mostPopular, incrémentez currentCount. Sinon, réinitialisez currentCount à 1. Si currentCount est> mostPopularCount, définissez mostPopularCount sur currentCount et mostPopular sur l'élément en cours.
Mine linéaire O (N)
Utiliser map pour sauvegarder tous les éléments présents dans le tableau et enregistrer le nombre de fois, puis obtenir le maximum de la carte.
import Java.util.HashMap;
import Java.util.Map;
public class MosftOftenNumber {
// for O(N) + map O(1) = O(N)
public static int mostOftenNumber(int[] a)
{
Map m = new HashMap<Integer,Integer>();
int max = 0;
int element = 0;
for(int i=0; i<a.length; i++){
//initializing value for the map the value will have the counter of each element
//first time one new number its found will be initialize with zero
if (m.get(a[i]) == null)
m.put(a[i],0);
//save each value from the array and increment the count each time its found
m.put(a[i] , (int)m.get(a[i]) + 1);
//check the value from each element and comparing with max
if ((int)m.get(a[i])>max){
max = (int) m.get(a[i]);
element = a[i];
}
}
return element;
}
public static void main(String args[]) {
// int[] array = {1,1,2,1,1};
// int[] array = {2,2,1,2,2};
int[] array = {2,2,1,3,3,5,5,6,6,7,7,9,9,10,10,10,10,11,12,13,14,15,15,1,15,15,1,15,15};
System.out.println(mostOftenNumber(array));
}
}
La meilleure approche consistera à utiliser map où key sera l'élément et la valeur sera le nombre de chaque élément. Parallèlement à cela, conservez un tableau de taille qui contiendra l'index de l'élément le plus populaire. Remplissez ce tableau pendant la construction de la carte, de sorte que nous n'ayons plus à parcourir la carte.
Approche 2: -
Si quelqu'un veut partir avec deux boucles, voici l'improvisation à partir d'une réponse acceptée où il n'est pas nécessaire de commencer la deuxième boucle à partir d'une boucle
public class TestPopularElements {
public static int getPopularElement(int[] a) {
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 = i+1; j < a.length; j++) {
if (temp == a[j])
tempCount++;
}
if (tempCount > count) {
popular = temp;
count = tempCount;
}
}
return popular;
}
public static void main(String[] args) {
int a[] = new int[] {1,2,3,4,5,6,2,7,7,7};
System.out.println("count is " +getPopularElement(a));
}
}
package frequent;
import Java.util.HashMap;
import Java.util.Map;
public class Frequent_number {
//Find the most frequent integer in an array
public static void main(String[] args) {
int arr[]= {1,2,3,4,3,2,2,3,3};
System.out.println(getFrequent(arr));
System.out.println(getFrequentBySorting(arr));
}
//Using Map , TC: O(n) SC: O(n)
static public int getFrequent(int arr[]){
int ans=0;
Map<Integer,Integer> m = new HashMap<>();
for(int i:arr){
if(m.containsKey(i)){
m.put(i, m.get(i)+1);
}else{
m.put(i, 1);
}
}
int maxVal=0;
for(Integer in: m.keySet()){
if(m.get(in)>maxVal){
ans=in;
maxVal = m.get(in);
}
}
return ans;
}
//Sort the array and then find it TC: O(nlogn) SC: O(1)
public static int getFrequentBySorting(int arr[]){
int current=arr[0];
int ansCount=0;
int tempCount=0;
int ans=current;
for(int i:arr){
if(i==current){
tempCount++;
}
if(tempCount>ansCount){
ansCount=tempCount;
ans=i;
}
current=i;
}
return ans;
}
}
On dirait que vous recherchez la valeur Mode (Mode statistique), jetez un coup d'œil à Docs d'Apache pour les fonctions statistiques.
import Java.util.Scanner;
public class Mostrepeatednumber
{
public static void main(String args[])
{
int most = 0;
int temp=0;
int count=0,tempcount;
Scanner in=new Scanner(System.in);
System.out.println("Enter any number");
int n=in.nextInt();
int arr[]=new int[n];
System.out.print("Enter array value:");
for(int i=0;i<=n-1;i++)
{
int n1=in.nextInt();
arr[i]=n1;
}
//!!!!!!!! user input concept closed
//logic can be started
for(int j=0;j<=n-1;j++)
{
temp=arr[j];
tempcount=0;
for(int k=1;k<=n-1;k++)
{
if(temp==arr[k])
{
tempcount++;
}
if(count<tempcount)
{
most=arr[k];
count=tempcount;
}
}
}
System.out.println(most);
}
}
En supposant que votre tableau int est trié, je le ferais ...
int count = 0, occur = 0, high = 0, a;
for (a = 1; a < n.length; a++) {
if (n[a - 1] == n[a]) {
count++;
if (count > occur) {
occur = count;
high = n[a];
}
} else {
count = 0;
}
}
System.out.println("highest occurence = " + high);
le code ci-dessous peut être mis dans une méthode principale
// TODO Auto-generated method stub
Integer[] a = { 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 1, 2, 2, 2, 2, 3, 4, 2 };
List<Integer> list = new ArrayList<Integer>(Arrays.asList(a));
Set<Integer> set = new HashSet<Integer>(list);
int highestSeq = 0;
int seq = 0;
for (int i : set) {
int tempCount = 0;
for (int l : list) {
if (i == l) {
tempCount = tempCount + 1;
}
if (tempCount > highestSeq) {
highestSeq = tempCount;
seq = i;
}
}
}
System.out.println("highest sequence is " + seq + " repeated for " + highestSeq);
public static void main(String[] args) {
int[] myArray = {1,5,4,4,22,4,9,4,4,8};
Map<Integer,Integer> arrayCounts = new HashMap<>();
Integer popularCount = 0;
Integer popularValue = 0;
for(int i = 0; i < myArray.length; i++) {
Integer count = arrayCounts.get(myArray[i]);
if (count == null) {
count = 0;
}
arrayCounts.put(myArray[i], count == 0 ? 1 : ++count);
if (count > popularCount) {
popularCount = count;
popularValue = myArray[i];
}
}
System.out.println(popularValue + " --> " + popularCount);
}
public class MostFrequentIntegerInAnArray {
public static void main(String[] args) {
int[] items = new int[]{2,1,43,1,6,73,5,4,65,1,3,6,1,1};
System.out.println("Most common item = "+getMostFrequentInt(items));
}
//Time Complexity = O(N)
//Space Complexity = O(N)
public static int getMostFrequentInt(int[] items){
Map<Integer, Integer> itemsMap = new HashMap<Integer, Integer>(items.length);
for(int item : items){
if(!itemsMap.containsKey(item))
itemsMap.put(item, 1);
else
itemsMap.put(item, itemsMap.get(item)+1);
}
int maxCount = Integer.MIN_VALUE;
for(Entry<Integer, Integer> entry : itemsMap.entrySet()){
if(entry.getValue() > maxCount)
maxCount = entry.getValue();
}
return maxCount;
}
}
int largest = 0;
int k = 0;
for (int i = 0; i < n; i++) {
int count = 1;
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j]) {
count++;
}
}
if (count > largest) {
k = a[i];
largest = count;
}
}
Donc ici n est la longueur du tableau, et a[] est votre tableau.
Tout d’abord, prenons le premier élément et vérifions combien de fois il se répète et augmentons le nombre de compteurs (count) pour voir combien de fois il se produit . changez ensuite la variable la plus grande (pour stocker le nombre maximal de répétitions) et si vous souhaitez également stocker la variable, vous pouvez le faire dans une autre variable (ici k).
Je sais que ce n’est pas le plus rapide, mais le moyen le plus facile de comprendre.
public static int getMostCommonElement(int[] array) {
Arrays.sort(array);
int frequency = 1;
int biggestFrequency = 1;
int mostCommonElement = 0;
for(int i=0; i<array.length-1; i++) {
frequency = (array[i]==array[i+1]) ? frequency+1 : 1;
if(frequency>biggestFrequency) {
biggestFrequency = frequency;
mostCommonElement = array[i];
}
}
return mostCommonElement;
}