CODEWITHSUNDEEP
javaarrays
user2381114
user2381114

Reputation: 471

Count occurrence of integers in an array

I have an integer array: int[] numbers = new int[...n]; // n being limitless.

Where all the numbers are between 0 and 100.

Say numbers[] was equal to: [52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0];

I want to count how often each of those numbers occur.

I've got a second array: int[] occurrences = new int[100];.

I'd like to be able to store the amounts like such:

for(int i = 0; i < numbers.length; i++) {
   // Store amount of 0's in numbers[] to occurrences[0] 
   // Store amount of 1's in numbers[] to occurrences[1]
}

So that occurrences[0] would be equal to 3, occurrences[1] would be equal to 0 etc.

Is there any efficient way of doing this without having to resort to external libraries? thanks.

Upvotes: 0

Views: 14308

Answers (4)

Amit Kumar Sharma
Amit Kumar Sharma

Reputation: 61

This method is useful for knowing occurrences of all elements You can reduce the space by finding the length of new array using sorting and taking value of last element + 1 

import java.util.Arrays;

    public class ArrayMain {

        public static void main(String[] args) {
            int a[] = {52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0};
            Arrays.sort(a);
            int len=a[a.length-1]+1;
            int count[]=new int[len];
            for(int n:a){
                count[n]++;
            }
            for(int j=0;j<count.length;j++){
                if(count[j]>=1){
                System.out.println("count:"+j+"---"+count[j]);
                }
            }

        }

    }

Time Complexity : O(n) Space Complexity : O(R) // last element value +1

Note : Creating new array may not be good idea if you have extreme numbers like 1, 2 and 96, 99 etc in terms of space. For this case sorting and comparing next element is better approach

Upvotes: 1

ECM
ECM

Reputation: 1

import java.util.Scanner;

public class CountNumOccurences {
   public static void main(String[] args){
      Scanner input = new Scanner(System.in);

      int[] frequency = new int[100];


      System.out.println("Enter the first integer: ");
      int number = input.nextInt();

      //Enter up to 100 integers, 0 to terminate
      while (number != 0){
         ++frequency[number];

         //read the next integer
            System.out.print(
                "Enter the next int value (zero to exit): ");
            number = input.nextInt();
      } 
      input.close();

      System.out.println("Value\tFrequency");
      for (int i = 0; i < frequency.length; i++) {
         if (frequency[i] > 0){
            if (frequency[i] > 1)  
               System.out.println(i + " occurs " + frequency[i] + " times");
            else
               System.out.println(i + " occurs " + frequency[i] + " time");
         }
      }
   }
}

Upvotes: 0

aliteralmind
aliteralmind

Reputation: 20163

Updated to put results in the 100-array.

import  java.util.Iterator;
import  java.util.Map;
import  java.util.Set;
import  java.util.TreeMap;

/**
   <P>{@code java IntOccurancesInArray}</P>
 **/
public class IntOccurancesInArray  {
   public static final void main(String[] igno_red)  {
      int[] ai = new int[]{52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0};
      Map<Integer,Integer> mpNumWHits = new TreeMap<Integer,Integer>();
      for(int i = 0; i < ai.length; i++)  {
         int iValue = ai[i];
         if(!mpNumWHits.containsKey(iValue))  {
            mpNumWHits.put(iValue, 1);
         }  else  {
            mpNumWHits.put(iValue, (mpNumWHits.get(iValue) + 1));
         }
      }

      Set<Integer> stInts = mpNumWHits.keySet();
      Iterator<Integer> itrInts = stInts.iterator();

      int[] ai100 = new int[100];

      int i = 0;
      while(itrInts.hasNext())  {
         int iValue = itrInts.next();
         int iHits = mpNumWHits.get(iValue);
         System.out.println(iValue + " found " + iHits + " times");
         ai100[iValue] = iHits;
      }

      for(int j = 0; j < ai100.length; j++)  {
         if(ai100[j] > 0)  {
            System.out.println("ai100[" + j + "]=" + ai100[j]);
         }
      }
   }
}

Output:

[C:\java_code\]java IntOccurancesInArray
0 found 3 times
2 found 1 times
3 found 1 times
5 found 1 times
12 found 1 times
21 found 1 times
32 found 2 times
43 found 1 times
52 found 1 times
67 found 1 times
ai100[0]=3
ai100[2]=1
ai100[3]=1
ai100[5]=1
ai100[12]=1
ai100[21]=1
ai100[32]=2
ai100[43]=1
ai100[52]=1
ai100[67]=1

Upvotes: 1

arshajii
arshajii

Reputation: 129477

You can simply do something like this:

for (int a : numbers) {
    occurrences[a]++;
}

Also, if you mean 0 to 100 inclusive then occurrences will need to be of size 101 (i.e. 100 will need to be the maximum index).

You might also want to perform an "assertion" to ensure that each element of numbers is indeed in the valid range before you update occurrences.

Upvotes: 11

Related Questions