Counting occurrences of integers in an array

Question

I'm writing a program that counts the occurrences of integers entered into an array, eg if you entered 1 1 1 1 2 1 3 5 2 3, the program would print out the distinct numbers followed by their occurrences, like this:

1 occurs 5 times, 2 occurs 2 times, 3 occurs 2 times, 5 occurs 1 time

And it's almost finished, aside from one problem I can't figure out:

import java.util.Scanner;
import java.util.Arrays;
public class CountOccurrences
{
   public static void main (String [] args)
   { 

    Scanner scan = new Scanner (System.in);

    final int MAX_NUM = 10;  

    final int MAX_VALUE = 100;

    int [] numList;

    int num;

    int numCount;

    int [] occurrences; 

    int count[];

    String end;

    numList = new int [MAX_NUM];

    occurrences = new int [MAX_NUM];

    count = new int [MAX_NUM];

 do
  {
     System.out.print ("Enter 10 integers between 1 and 100: ");

     for (num = 0; num < MAX_NUM; num++)
     {
        numList[num] = scan.nextInt();
     }

     Arrays.sort(numList);

     count = occurrences (numList); 

     System.out.println();   

     for (num = 0; num < MAX_NUM; num++)
     {
        if (num == 0)
        {
           if (count[num] <= 1)
              System.out.println (numList[num] + " occurs " + count[num] + " time");

           if (count[num] > 1)
              System.out.println (numList[num] + " occurs " + count[num] + " times");
        } 

        if (num > 0 && numList[num] != numList[num - 1])
        {
           if (count[num] <= 1)
              System.out.println (numList[num] + " occurs " + count[num] + " time");

           if (count[num] > 1)
              System.out.println (numList[num] + " occurs " + count[num] + " times");
        }   
     }          

     System.out.print ("\nContinue? <y/n> ");
     end = scan.next(); 

  } while (!end.equalsIgnoreCase("n"));
}


 public static int [] occurrences (int [] list)
 {
      final int MAX_VALUE = 100;

      int num;

      int [] countNum = new int [MAX_VALUE];

      int [] counts = new int [MAX_VALUE];

      for (num = 0; num < list.length; num++)
  {
     counts[num] = countNum[list[num]] += 1;
  }

  return counts;
 } 
}

The problem I'm having is that no matter what the current value for 'num' is, 'count' only prints out 1, and the problem isn't in the method that counts the occurrences, because when you enter numbers in the place of the variable, the value changes.

Is there any way that I can alter this so that it'll print out the occurrences properly, or should I try something else? And the simpler the solution, the better, as I haven't yet gone past single dimension arrays.

Thanks for the help!

Please use this as opportunity to learn debugging. All IDEs(eclipse,Netbeans,IntellIJ,..) comes with neat debugging tools. — Jayan, Nov 01 '15 at 04:59
The issue is in your occurences function. the line `counts[num] = countNum[list[num]] += 1;` is not doing what you think it is doing. It is moving through the array putting the count of the number in separate indexes. Example with your current input the `counts` array has a value of `[1, 2, 3, 4, 5, 1, 2, 1, 2, 1, ... 0]`. the first `[1, 2, 3, 4, 5` is because there are 5 counts of `1` in your array, the next `1, 2` is because there are 2 counts of `2` in your array, etc. You need to rewrite your `occurrences` function. Would've left this as an answer but question was closed. — Shadow, Nov 01 '15 at 06:21

Irfan · Answer 1 · 2015-11-01T06:01:27.650

3

Try HashMap. For this type of problem hashes is very efficient and fast.

I write this function which take array and return a HashMap whose key is the number and value is the occurance of that number.

public static HashMap<Integer, Integer> getRepetitions(int[] testCases) {    
    HashMap<Integer, Integer> numberAppearance = new HashMap<Integer, Integer>();

    for(int n: testCases) {
        if(numberAppearance.containsKey(n)) {
            int counter = numberAppearance.get(n);
            counter = counter+1;
            numberAppearance.put(n, counter);
        } else {
            numberAppearance.put(n, 1);
        }
    }
    return numberAppearance;
}

Now iterate throught hashmap and print occurance of numbers like this :

HashMap<Integer, Integer> table = getRepetitions(testCases);

for (int key: table.keySet()) {
        System.out.println(key + " occur " + table.get(key) + " times");
}

Output:

edited Nov 01 '15 at 06:01

answered Nov 01 '15 at 05:10

Irfan

5,070
1
28
32

2

Use of `HashTable` is discouraged. Use `HashMap` instead. – Ghazanfar Nov 01 '15 at 05:40
@MohammadGhazanfar when you say "discouraged", what do you mean? – smac89 Nov 01 '15 at 06:12
@Smac89 Please read [this](http://docs.oracle.com/javase/8/docs/api/java/util/Hashtable.html). `As of the Java 2 platform v1.2, this class was retrofitted to ...` – Ghazanfar Nov 01 '15 at 07:55

Andre Gregori · Answer 2 · 2015-11-01T06:04:21.740

I'd use a Bag, a collection that counts the number of times an item appears in the collection. Apache Commons has an implementation of it. Here's their interface, and here's a sorted tree implementation.

You'd do something like this:

Bag<Integer> bag = new TreeBag<Integer>();
for (int i = 0; i < numList.length; i++) {
    bag.add(numList[i]);
}
for (int uniqueNumber: bag.uniqueSet()) {
    System.out.println("Number " + uniqueNumber + " counted " + bag.getCount(uniqueNumber) + " times");
}

The example above takes elements from your numList array and adds them to the Bag for purposes of generating the counts, but de rigueur you don't even need the array. Just add the elements to the Bag directly. Something like:

// Make your bag.
Bag<Integer> bag = new TreeBag<Integer>();

...

// Populate your bag.
for (num = 0; num < MAX_NUM; num++) {
    bag.add(scan.nextInt());
}

...

// Print the counts for each unique item in your bag.
for (int uniqueNumber: bag.uniqueSet()) {
    System.out.println("Number " + uniqueNumber + " counted " + bag.getCount(uniqueNumber) + " times");
}

Elliott Frisch · Answer 3 · 2015-11-01T07:26:17.313

You could start by initializing an array of values between MIN and MAX. Then you can add to each element of the array when that value occurs¹. Something like,

Scanner scan = new Scanner(System.in);
final int MAX_NUM = 10;
final int MAX_VALUE = 100;
final int MIN_VALUE = 1;
final int SIZE = MAX_VALUE - MIN_VALUE;
int[] numList = new int[SIZE];
System.out.printf("Enter %d integers between %d and %d:%n", 
        MAX_NUM, MIN_VALUE, MAX_VALUE);
for (int i = 0; i < MAX_NUM; i++) {
  System.out.printf("Please enter number %d: ", i + 1);
  System.out.flush();
  if (!scan.hasNextInt()) {
    System.out.printf("%s is not an int%n", scan.nextLine());
    i--;
    continue;
  }
  int v = scan.nextInt();
  if (v < MIN_VALUE || v > MAX_VALUE) {
    System.out.printf("%d is not between %d and %d%n", 
            v, MIN_VALUE, MAX_VALUE);
    continue;
  }
  numList[v - MIN_VALUE]++;
}
boolean first = true;
for (int i = 0; i < SIZE; i++) {
  if (numList[i] > 0) {
    if (!first) {
      System.out.print(", ");
    } else {
      first = false;
    }
    if (numList[i] > 1) {
      System.out.printf("%d occurs %d times", 
              i + MIN_VALUE, numList[i]);
    } else {
      System.out.printf("%d occurs once", i + MIN_VALUE);
    }
  }
}
System.out.println();

^{1_{See also radix sort counting sort.}}

score 1 · Accepted Answer · answered Nov 01 '15 at 06:29

What I have to say is, it took me a while to figure out what the two variables count and countNum represent for, maybe some comments are needed. But finally I find out the bug.

Suppose input ten numbers are: 5, 6, 7, 8, 5, 6, 7, 8, 5, 6

After sort, numList is : 5, 5, 5, 6, 6, 6, 7, 7, 8, 8

The array count returned by occurrences()should be: [1, 2, 3, 1, 2, 3, 1, 2, 1, 2]

Actually the only useful numbers in this result array are:

count[2]: 3     count number for numList[2]: 5
count[5]: 3     count number for numList[5]: 6
count[7]: 2     count number for numList[7]: 7
count[9]: 2     count number for numList[9]: 8

The other numbers, like the first two numbers 1, 2 before 3, are only used to calculate the sum occurrences incrementally, right? So, your loop logic should be changed as following:

remove the first if code block:

if (num == 0)
{
   if (count[num] <= 1)
      System.out.println (numList[num] + " occurs " + count[num] + " time");

   if (count[num] > 1)
      System.out.println (numList[num] + " occurs " + count[num] + " times");
}

Change the second if condition to:

if ((num + 1) == MAX_NUM || numList[num] != numList[num + 1]) {
    ......
}

After this, your code should work well as expected.

BTW, you really don't need to do it so intricately. Just try HashMap :)

This is exactly what I needed, thank you! And I'll be sure to add comments the next time I have a question :) — Len, Nov 01 '15 at 15:34

Alexander · Answer 5 · 2015-11-01T06:02:21.997

I think you can simplify your code a lot if you use this approach. You still have to modify to include the MAX_NUM and MAX_VALUE.

public static void main(String[] args) {

    Integer[] array = {1,2,0,3,4,5,6,6,7,8};
    Stack stack = new Stack();

    Arrays.sort(array, Collections.reverseOrder());

    for(int i : array){
        stack.push(i);
    }

    int currentNumber = Integer.parseInt(stack.pop().toString()) , count = 1;

    try {
        while (stack.size() >= 0) {
            if (currentNumber != Integer.parseInt(stack.peek().toString())) {
                System.out.printf("%d occurs %d times, ", currentNumber, count);
                currentNumber = Integer.parseInt(stack.pop().toString());
                count = 1;
            } else {
                currentNumber = Integer.parseInt(stack.pop().toString());
                count++;
            }
        }
    } catch (EmptyStackException e) {
         System.out.printf("%d occurs %d times.", currentNumber, count);
    }
}

Counting occurrences of integers in an array

5 Answers5

Linked