Multiple most frequent elements in array

Suppose we have a list of integers. I would like to detect and print on the screen the most frequently repeated item . I know how to do it when the most common element is only one. However, if we have such a list which contains these elements:

10, 5, 2, 1, 2, 4, 6, 6, 6, 6, 10, 10, 10 

i want to print a six and a ten so I mean I want to print all the most frequently repeated elements no matter how many there are..

nums = [10, 5, 2, 1, 2, 4, 6, 6, 6, 6, 10, 10, 10]

def most_recurrent_ints(arr):
    log = {}
    for i in arr:
        if i in log:
            log[i] += 1
        else:
            log[i] =  1
    current_max = 0
    for i in log.values():
        if i > current_max:
            current_max = i
    results = []
    for k, v in log.items():
        if v == current_max:
            results.append(k)
    return results
    
print(most_recurrent_ints(nums))

I'm bad at Java but this is the Python solution, maybe someone can translate. I can do it in JS if you need.

Have you considered using a dictionary-type data structure? I am not a java person, so this may not be pretty, but it does what you are looking for:

    final int[] array = new int[]{ 10, 5, 2, 1, 2, 4, 6, 6, 6, 6, 10, 10, 10 };

    Map<Integer, Integer> dictionary = new HashMap<Integer,Integer>(); 
    
    for(int i = 0; i < array.length; ++i){
        int val = array[i];
        if(dictionary.containsKey(val)){
            dictionary.put(val, dictionary.get(val) + 1);
        }else{
            dictionary.put(val, 1);
        }
    }

    for(Map.Entry<Integer,Integer> entry : dictionary.entrySet()){
        System.out.println(entry.getKey() + ": " + entry.getValue());
    }

This would output:

1: 1
2: 2
4: 1
5: 1
6: 4
10: 4

public static void main(String[] args) {
	MostFrequent(new Integer[] {10, 5, 2, 1, 2, 4, 6, 6, 6, 6, 10, 10, 10});
}

static void MostFrequent(Integer[] arr)	{
	Map<Integer, Integer> count = new HashMap<Integer, Integer>();
	
	for (Integer element : arr) {
		if (!count.containsKey(element)) {
			count.put(element,0);
		}
		count.put(element, count.get(element) + 1);
	}

	Map.Entry<Integer, Integer> maxEntry = null;
	ArrayList<Integer> list = new ArrayList<Integer>();

	for (Map.Entry<Integer, Integer> entry : count.entrySet()) {
		if (maxEntry == null || entry.getValue() > maxEntry.getValue()) {
			list.clear();
			list.add(entry.getKey());
			maxEntry = entry;
		}
		else if (entry.getValue() == maxEntry.getValue()) {
			list.add(entry.getKey());
		}
	}

	for (Integer item: list) {
		System.out.println(item); 
	}		
}

Output:

6
10

You would need a map (aka dictionary) data structure to solve this problem. This is the fastest and most concise solution I could come up with.

public static void main(String[] args){
    int[] arr = new int[]{10, 5, 2, 1, 2, 4, 6, 6, 6, 6, 10, 10, 10};
    printMostFrequent(arr);
}
 
private static void printMostFrequent(int[] arr){
    // Key: number in input array
    // Value: amount of times that number appears in the input array
    Map<Integer, Integer> counts = new HashMap<>();

    // The most amount of times the same number appears in the input array. In this example, it's 4.
    int highestFrequency = 0;
    
    // Iterate through input array, populating map.
    for (int num : arr){
        
        // If number doesn't exist in map already, its frequency is 1. Otherwise, add 1 to its current frequency.
        int currFrequency = counts.getOrDefault(num, 0) + 1;
        
        // Update frequency of current number.
	    counts.put(num, currFrequency);
	    
	    // If the current number has the highest frequency so far, store its frequency for later use.
	    highestFrequency = Math.max(currFrequency, highestFrequency);
    }

    // Iterate through unique numbers in array (remember, a Map in Java allows no duplicate keys).
    for (int key : counts.keySet()){
        
        // If the current number has the highest frequency, then print it to console.
	    if (counts.get(key) == highestFrequency){
		    System.out.println(key);
	    }
    }
}

Output

6
10