CareerCup

public static ArrayList<Integer> getTopThree(ArrayList<Integer> numArray, Hashtable<Integer, Integer> h) {
		int firstPlace = 0;
		int firstPlaceNum = 0;
		int secondPlace = 0;
		int secondPlaceNum = 0;
		int thirdPlace = 0;
		int thirdPlaceNum = 0;
		
		for(int i = 0; i < numArray.size(); i++) {
			int num = numArray.get(i);
			int value;
			
			if(h.get(num) != null) {
				value = h.get(num);
				h.put(num, value + 1);
				int newValue = value + 1;
				if(newValue > firstPlace) {
					firstPlace = newValue;
					firstPlaceNum = num;
				} else if(newValue <= firstPlace && newValue > secondPlace) {
					secondPlace = newValue;
					secondPlaceNum = num;
				} else if(newValue <= secondPlace && newValue > thirdPlace) {
					thirdPlace = newValue;
					thirdPlaceNum = num;
				}
			} else {
				h.put(num, 1);
				if(firstPlace == 0) {
					firstPlace = 1;
					firstPlaceNum = num;
				} else if(secondPlace == 0) { 
					secondPlace = 1;
					secondPlaceNum = num;
				} else if(thirdPlace == 0) {
					thirdPlace = 1;
					thirdPlaceNum = num;
				}
			}
		}
		
		ArrayList<Integer> topThree = new ArrayList<Integer>();
		topThree.add(firstPlace);
		topThree.add(secondPlace);
		topThree.add(thirdPlace);
		
		return topThree;
	}

Questions like this must be answered by giving various approaches:-
1> As suggested, Hashtable with key as value from array and value being the count.
Then sort the hashtable.(Min Heap of size 3 , iterate thorugh all the keys and in accordance through count put them in heap)
2>similarly Balanced BST with frequency as additional value in node. then inorder traversal and putting values in heap

use strict;
use warnings;

my @array = (20,20,20,20,3,4,2,4,2,2,3,1,4,5,7,5,3,9);
my %hash;
my $len;
$len = scalar(@array);
my $i;
foreach(@array)
{
$hash{$_}++;
}
my @arr;
@arr = (sort { $hash{$b} <=> $hash{$a} } keys %hash)[0..3];
foreach(@arr)
{
print $_ ."=>". $hash{$_}."\n";
}

Make a vector <pair<number, count>> (O(n) - space and O(n) time)
then do quickselect on this vector with k = size of the vector, size - 1, size - 2. (all 3 take O(n) time).

Thus, O(n) space and O(n) time

if the numbers are not very large we can use an array of length = the max of the numbers.
for each element in the given array increment the value from the position "element" in the new array. Now go 3 times and pick the max value from our array, putting an invalid value in its place and memorizing the position of the max.

return those 3 positions.

I think my code could solve some what of this problem.
public static void main(String args[]){
int RAM[] ={20,8,3,7,8,9,20,6,4,6,20,8,20};

for(int i=0;i<RAM.length;i++){
int count = 0;
for(int j=0;j<RAM.length;j++){

if(RAM[i]==RAM[j]){
count = count+1;
}
}

if(count >= 2){
System.out.println(RAM[i]+ " :) " + count + " :) ");
}
}
}

Hashmap. The array elements will be the keys and count will be the value. Get the 3 highest values and print corresponding keys.

May be a HashMap with keyvalue pairs

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;


public class Repeat {
	public static void main(String args[]){
		final int RAM[] = {20,8,3,7,8,9,20,6,4,6,20,8,20};
		topRepeat(RAM);
	}
	
	public static int[] topRepeat(int input[]){
		int times[] = {0,0,0};
		int output[] = {0,0,0};
		LinkedList<Integer> list = new LinkedList<Integer>();
		
		for(int i : input){
			if(list.contains(i))
				continue;
			list.add(i);
		}
		
		HashMap<Integer, Integer> hashMap = 
				new HashMap<Integer, Integer>();
		for(int i : input){
			if(hashMap.containsKey(i))
				hashMap.put(i, hashMap.get(i) + 1);
			else
				hashMap.put(i, 1);
		}
		
		Iterator<Integer> it = list.iterator(); 
		
		while(it.hasNext()){
			int i = it.next();
			int time = hashMap.get(i);
			if(time > times[2]){
				if(time > times[1]){
					if(time > times[0]){
						times[2] = times[1];
						times[1] = times[0];
						times[0] = time;
						output[0] = i;
						continue;
					}
					times[2] = times[1];
					times[1] = time;
					output[1] = i;
					continue;
				}
				times[2] = time;
				output[2] = i;
			}
		}
		
		for(int i = 0; i < 3; i++)
			System.out.printf("%d is repeated %d times\n", output[i], times[i]);
		return output;
	}
}

.