Skip to content
Related Articles
Frequency Measuring Techniques for Competitive Programming
• Difficulty Level : Medium
• Last Updated : 16 Jun, 2021

Measuring the frequency of elements in an array is a really handy skill and is required a lot of competitive coding problems. We, in a lot of problems, are required to measure the frequency of various elements like numbers, alphabets, symbols, etc. as a part of our problem.

Naive method

Examples:

```Input :  arr[] = {10, 20, 20, 10, 10, 20, 5, 20}
Output : 10 3
20 4
5  1

Input : arr[] = {10, 20, 20}
Output : 10 2
20 1```

We run two loops. For every item count number of times it occurs. To avoid duplicate printing, keep track of processed items.

## C++

 `// C++ program to count frequencies of array items``#include ``using` `namespace` `std;`` ` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``// Mark all array elements as not visited``    ``vector<``int``> visited(n, ``false``);`` ` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < n; i++) {`` ` `        ``// Skip this element if already processed``        ``if` `(visited[i] == ``true``)``            ``continue``;`` ` `        ``// Count frequency``        ``int` `count = 1;``        ``for` `(``int` `j = i + 1; j < n; j++) {``            ``if` `(arr[i] == arr[j]) {``                ``visited[j] = ``true``;``                ``count++;``            ``}``        ``}``        ``cout << arr[i] << ``" "` `<< count << endl;``    ``}``}`` ` `int` `main()``{``    ``int` `arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``countFreq(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies``// of array items``import` `java.util.*;` `class` `GFG``{``static` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``// Mark all array elements as not visited``    ``boolean` `[]visited = ``new` `boolean``[n];` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Skip this element if already processed``        ``if` `(visited[i] == ``true``)``            ``continue``;` `        ``// Count frequency``        ``int` `count = ``1``;``        ``for` `(``int` `j = i + ``1``; j < n; j++)``        ``{``            ``if` `(arr[i] == arr[j])``            ``{``                ``visited[j] = ``true``;``                ``count++;``            ``}``        ``}``        ``System.out.println(arr[i] + ``" "` `+ count);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20` `};``    ``int` `n = arr.length;``    ``countFreq(arr, n);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program to count frequencies``# of array items``def` `countFreq(arr, n):``    ` `    ``# mark all array elements as not visited``    ``visited ``=` `[``False` `for` `i ``in` `range``(n)]``    ` `    ``# Traverse through array elements``    ``# and count frequencies``    ``for` `i ``in` `range``(n):``        ` `        ``# Skip this element if already processed``        ``if` `visited[i] ``=``=` `True``:``            ``continue``            ` `        ``# count frequency``        ``count ``=` `1``        ` `        ``for` `j ``in` `range``(i ``+` `1``, n):``            ``if` `arr[i] ``=``=` `arr[j]:``                ``visited[j] ``=` `True``                ``count ``+``=` `1``        ``print``(arr[i], count)``    ` `# Driver code``a ``=` `[``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20``]` `n ``=` `len``(a)` `countFreq(a, n)` `# This code is contributed``# by Mohit kumar 29`

## C#

 `// C# program to count frequencies``// of array items``using` `System;``    ` `class` `GFG``{``static` `void` `countFreq(``int` `[]arr, ``int` `n)``{``    ``// Mark all array elements as not visited``    ``Boolean []visited = ``new` `Boolean[n];` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// Skip this element if already processed``        ``if` `(visited[i] == ``true``)``            ``continue``;` `        ``// Count frequency``        ``int` `count = 1;``        ``for` `(``int` `j = i + 1; j < n; j++)``        ``{``            ``if` `(arr[i] == arr[j])``            ``{``                ``visited[j] = ``true``;``                ``count++;``            ``}``        ``}``        ``Console.WriteLine(arr[i] + ``" "` `+ count);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 10, 20, 20, 10,``                  ``10, 20, 5, 20 };``    ``int` `n = arr.Length;``    ``countFreq(arr, n);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:

```10 3
20 4
5 1```

Optimized methods :

Measuring frequencies when elements are limited by value
If our input array has small values, we can use array elements as index in a count array and increment count. In below example, elements are maximum 10.

```Input :  arr[] = {5, 5, 6, 6, 5, 6, 1, 2, 3, 10, 10}
limit = 10
Output : 1 1
2 1
3 1
5 3
6 3
10 2```

## C++

 `// C++ program to count frequencies of array items``// having small values.``#include ``using` `namespace` `std;`` ` `void` `countFreq(``int` `arr[], ``int` `n, ``int` `limit)``{``    ``// Create an array to store counts. The size``    ``// of array is limit+1 and all values are``    ``// initially 0``    ``vector<``int``> count(limit+1, 0);`` ` `    ``// Traverse through array elements and``    ``// count frequencies (assuming that elements``    ``// are limited by limit)``    ``for` `(``int` `i = 0; i < n; i++)``        ``count[arr[i]]++;`` ` `    ``for` `(``int` `i = 0; i <= limit; i++)``       ``if` `(count[i] > 0)``        ``cout << i << ``" "` `<< count[i] << endl;``    ` `}`` ` `int` `main()``{``    ``int` `arr[] = {5, 5, 6, 6, 5, 6, 1, 2, 3, 10, 10};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `limit = 10;``    ``countFreq(arr, n, limit);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies of array items``// having small values.``class` `GFG``{``    ` `static` `void` `countFreq(``int` `arr[], ``int` `n, ``int` `limit)``{``    ``// Create an array to store counts. The size``    ``// of array is limit+1 and all values are``    ``// initially 0``    ``int` `[]count = ``new` `int``[limit + ``1``];` `    ``// Traverse through array elements and``    ``// count frequencies (assuming that elements``    ``// are limited by limit)``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``count[arr[i]]++;` `    ``for` `(``int` `i = ``0``; i <= limit; i++)``    ``if` `(count[i] > ``0``)``            ``System.out.println(i + ``" "` `+ count[i]);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = {``5``, ``5``, ``6``, ``6``, ``5``, ``6``, ``1``, ``2``, ``3``, ``10``, ``10``};``    ``int` `n = arr.length;``    ``int` `limit = ``10``;``    ``countFreq(arr, n, limit);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to count frequencies of``# array items having small values.``def` `countFreq(arr, n, limit):``    ` `    ``# Create an array to store counts.``    ``# The size of array is limit+1 and``    ``# all values are initially 0``    ``count ``=` `[``0` `for` `i ``in` `range``(limit ``+` `1``)]` `    ``# Traverse through array elements and``    ``# count frequencies (assuming that``    ``# elements are limited by limit)``    ``for` `i ``in` `range``(n):``        ``count[arr[i]] ``+``=` `1` `    ``for` `i ``in` `range``(limit ``+` `1``):``        ``if` `(count[i] > ``0``):``            ``print``(i, count[i])` `# Driver Code``arr ``=` `[ ``5``, ``5``, ``6``, ``6``, ``5``, ``6``,``        ``1``, ``2``, ``3``, ``10``, ``10` `]``n ``=` `len``(arr)``limit ``=` `10` `countFreq(arr, n, limit)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to count frequencies of``// array items having small values.``using` `System;``    ` `class` `GFG``{``    ` `static` `void` `countFreq(``int` `[]arr,``                      ``int` `n, ``int` `limit)``{``    ``// Create an array to store counts.``    ``// The size of array is limit+1 and``    ``// all values are initially 0``    ``int` `[]count = ``new` `int``[limit + 1];` `    ``// Traverse through array elements and``    ``// count frequencies (assuming that``    ``// elements are limited by limit)``    ``for` `(``int` `i = 0; i < n; i++)``        ``count[arr[i]]++;` `    ``for` `(``int` `i = 0; i <= limit; i++)``    ``if` `(count[i] > 0)``            ``Console.WriteLine(i + ``" "` `+``                              ``count[i]);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = {5, 5, 6, 6, 5, 6,``                 ``1, 2, 3, 10, 10};``    ``int` `n = arr.Length;``    ``int` `limit = 10;``    ``countFreq(arr, n, limit);``}``}` `// This code is contributed``// by Princi Singh`

## Javascript

 ``
Output:
```1 1
2 1
3 1
5 3
6 3
10 2```

## C++

 `// C++ program to count frequencies of array items``#include ``using` `namespace` `std;` `const` `int` `limit = 255;` `void` `countFreq(string str)``{``    ``// Create an array to store counts. The size``    ``// of array is limit+1 and all values are``    ``// initially 0``    ``vector<``int``> count(limit+1, 0);`` ` `    ``// Traverse through string characters and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < str.length(); i++)``        ``count[str[i]]++;`` ` `    ``for` `(``int` `i = 0; i <= limit; i++)``       ``if` `(count[i] > 0)``        ``cout << (``char``)i << ``" "` `<< count[i] << endl;``    ` `}`` ` `int` `main()``{``    ``string str = ``"GeeksforGeeks"``;``    ``countFreq(str);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies of array items``class` `GFG``{``static` `int` `limit = ``255``;` `static` `void` `countFreq(String str)``{``    ``// Create an array to store counts. The size``    ``// of array is limit+1 and all values are``    ``// initially 0``    ``int` `[]count= ``new` `int``[limit + ``1``];` `    ``// Traverse through string characters and``    ``// count frequencies``    ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``count[str.charAt(i)]++;` `    ``for` `(``int` `i = ``0``; i <= limit; i++)``    ``if` `(count[i] > ``0``)``        ``System.out.println((``char``)i + ``" "` `+ count[i]);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String str = ``"GeeksforGeeks"``;``    ``countFreq(str);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to count frequencies of array items``limit ``=` `255``def` `countFreq(``Str``) :` `    ``# Create an array to store counts. The size``    ``# of array is limit+1 and all values are``    ``# initially 0``    ``count ``=` `[``0``] ``*` `(limit ``+` `1``)``  ` `    ``# Traverse through string characters and``    ``# count frequencies``    ``for` `i ``in` `range``(``len``(``Str``)) :``        ``count[``ord``(``Str``[i])] ``+``=` `1``  ` `    ``for` `i ``in` `range``(limit ``+` `1``) :``       ``if` `(count[i] > ``0``) :``        ``print``(``chr``(i), count[i])`` ` `Str` `=` `"GeeksforGeeks"``countFreq(``Str``)` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to count frequencies``// of array items``using` `System;``    ` `class` `GFG``{``static` `int` `limit = 25;` `static` `void` `countFreq(String str)``{``    ``// Create an array to store counts.``    ``// The size of array is limit+1 and``    ``// all values are initially 0``    ``int` `[]count = ``new` `int``[limit + 1];` `    ``// Traverse through string characters``    ``// and count frequencies``    ``for` `(``int` `i = 0; i < str.Length; i++)``        ``count[str[i] - ``'A'``]++;` `    ``for` `(``int` `i = 0; i <= limit; i++)``    ``if` `(count[i] > 0)``        ``Console.WriteLine((``char``)(i + ``'A'``) +``                          ``" "` `+ count[i]);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``String str = ``"GEEKSFORGEEKS"``;``    ``countFreq(str);``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output:
```G 2
e 4
f 1
k 2
o 1
r 1
s 2```

Measuring frequencies when elements are in limited range
For example consider a string containing only upper case alphabets. Elements of string are limited in range from ‘A’ to ‘Z’. The idea is to subtract smallest element (‘A’ in this example) to get index of the element.

## C++

 `// C++ program to count frequencies of array items``#include ``using` `namespace` `std;` `const` `int` `limit = 25;` `void` `countFreq(string str)``{``    ``// Create an array to store counts. The size``    ``// of array is limit+1 and all values are``    ``// initially 0``    ``vector<``int``> count(limit+1, 0);`` ` `    ``// Traverse through string characters and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < str.length(); i++)``        ``count[str[i] - ``'A'``]++;`` ` `    ``for` `(``int` `i = 0; i <= limit; i++)``       ``if` `(count[i] > 0)``        ``cout << (``char``)(i + ``'A'``) << ``" "` `<< count[i] << endl;``    ` `}`` ` `int` `main()``{``    ``string str = ``"GEEKSFORGEEKS"``;``    ``countFreq(str);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies``// of array items``import` `java.util.*;` `class` `GFG``{``static` `int` `limit = ``25``;` `static` `void` `countFreq(String str)``{``    ``// Create an array to store counts.``    ``// The size of array is limit+1 and``    ``// all values are initially 0``    ``int` `[]count = ``new` `int``[limit + ``1``];` `    ``// Traverse through string characters``    ``// and count frequencies``    ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``count[str.charAt(i) - ``'A'``]++;` `    ``for` `(``int` `i = ``0``; i <= limit; i++)``    ``if` `(count[i] > ``0``)``        ``System.out.println((``char``)(i + ``'A'``) +``                           ``" "` `+ count[i]);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String str = ``"GEEKSFORGEEKS"``;``    ``countFreq(str);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python3 program to count frequencies of array items``limit ``=` `25``;``def` `countFreq(``str``):``    ` `    ``# Create an array to store counts. The size``    ``# of array is limit+1 and all values are``    ``# initially 0``    ``count ``=` `[``0` `for` `i ``in` `range``(limit ``+` `1``)]``  ` `    ``# Traverse through string characters and``    ``# count frequencies``    ``for` `i ``in` `range``(``len``(``str``)):  ``        ``count[``ord``(``str``[i]) ``-` `ord``(``'A'``)] ``+``=` `1``  ` `    ``for` `i ``in` `range``(limit ``+` `1``):``       ``if` `(count[i] > ``0``):``           ``print``(``chr``(i ``+` `ord``(``'A'``)), count[i])` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``str` `=` `"GEEKSFORGEEKS"``;``    ``countFreq(``str``);``    ` `# This code is contributed by Pratham76`

## C#

 `// C# program to count frequencies``// of array items``using` `System;``    ` `class` `GFG``{``static` `int` `limit = 25;`` ` `static` `void` `countFreq(String str)``{``    ``// Create an array to store counts.``    ``// The size of array is limit+1 and``    ``// all values are initially 0``    ``int` `[]count = ``new` `int``[limit + 1];`` ` `    ``// Traverse through string characters``    ``// and count frequencies``    ``for` `(``int` `i = 0; i < str.Length; i++)``        ``count[str[i] - ``'A'``]++;`` ` `    ``for` `(``int` `i = 0; i <= limit; i++)``    ``if` `(count[i] > 0)``        ``Console.WriteLine((``char``)(i + ``'A'``) +``                           ``" "` `+ count[i]);``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``String str = ``"GEEKSFORGEEKS"``;``    ``countFreq(str);``}``}`` ` `// This code contributed by PrinciRaj1992`

## Javascript

 ``
Output:
```E 4
F 1
G 2
K 2
O 1
R 1
S 2```

Measuring frequencies if no range and no limit
The idea is to use hashing (unordered_map in C++ and HashMap in Java) to get frequencies.

## C++

 `// C++ program to count frequencies of array items``#include ``using` `namespace` `std;` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``unordered_map<``int``, ``int``> mp;` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < n; i++)``        ``mp[arr[i]]++;` `    ``// Traverse through map and print frequencies``    ``for` `(``auto` `x : mp)``        ``cout << x.first << ``" "` `<< x.second << endl;``}` `int` `main()``{``    ``int` `arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``countFreq(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies of array items``import` `java.util.*;``class` `GFG``{``static` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``HashMapmp = ``new` `HashMap();``                                     ` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = ``0` `; i < n; i++)``    ``{``        ``if``(mp.containsKey(arr[i]))``        ``{``            ``mp.put(arr[i], mp.get(arr[i]) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(arr[i], ``1``);``        ``}``    ``}``    ` `    ``// Traverse through map and print frequencies``    ``for` `(Map.Entry entry : mp.entrySet())``        ``System.out.println(entry.getKey() + ``" "` `+``                           ``entry.getValue());``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20` `};``    ``int` `n = arr.length;``    ``countFreq(arr, n);   ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to count frequencies of array items``def` `countFreq(arr, n):` `    ``mp ``=` `{}`` ` `    ``# Traverse through array elements and``    ``# count frequencies``    ``for` `i ``in` `range``(n):``        ``if` `arr[i] ``in` `mp:``            ``mp[arr[i]] ``+``=` `1``        ``else``:``            ``mp[arr[i]] ``=` `1`` ` `    ``# Traverse through map and print frequencies``    ``for` `x ``in` `sorted``(mp):``        ``print``(x, mp[x])` `# Driver Code``arr ``=` `[ ``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20` `]``n ``=` `len``(arr)` `countFreq(arr, n)` `# This code is contributed by divyesh072019`

## C#

 `// C# program to count frequencies of array items``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `void` `countFreq(``int` `[]arr, ``int` `n)``{``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();``                                    ` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0 ; i < n; i++)``    ``{``        ``if``(mp.ContainsKey(arr[i]))``        ``{``            ``var` `val = mp[arr[i]];``            ``mp.Remove(arr[i]);``            ``mp.Add(arr[i], val + 1);``        ``}``        ``else``        ``{``            ``mp.Add(arr[i], 1);``        ``}``    ``}``    ` `    ``// Traverse through map and print frequencies``    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mp)``        ``Console.WriteLine(entry.Key + ``" "` `+``                          ``entry.Value);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 10, 20, 20, 10,``                  ``10, 20, 5, 20 };``    ``int` `n = arr.Length;``    ``countFreq(arr, n);``}``}` `// This code is contributed by Princi Singh`
Output:

```5 1
10 3
20 4```

Time Complexity : O(n)
Auxiliary Space : O(n)

In above efficient solution, how to print elements in same order as they appear in input?

## C++

 `// C++ program to count frequencies of array items``#include ``using` `namespace` `std;` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``unordered_map<``int``, ``int``> mp;` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0; i < n; i++)``        ``mp[arr[i]]++;` `    ``// To print elements according to first``    ``// occurrence, traverse array one more time``    ``// print frequencies of elements and mark``    ``// frequencies as -1 so that same element``    ``// is not printed multiple times.``    ``for` `(``int` `i = 0; i < n; i++) {``      ``if` `(mp[arr[i]] != -1)``      ``{``          ``cout << arr[i] << ``" "` `<< mp[arr[i]] << endl;``          ``mp[arr[i]] = -1;``      ``}``    ``}``}` `int` `main()``{``    ``int` `arr[] = { 10, 20, 20, 10, 10, 20, 5, 20 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``countFreq(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to count frequencies of array items``import` `java.util.*;` `class` `GFG``{``static` `void` `countFreq(``int` `arr[], ``int` `n)``{``    ``HashMap mp = ``new` `HashMap();` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = ``0` `; i < n; i++)``    ``{``        ``if``(mp.containsKey(arr[i]))``        ``{``            ``mp.put(arr[i], mp.get(arr[i]) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(arr[i], ``1``);``        ``}``    ``}``    ` `    ``// To print elements according to first``    ``// occurrence, traverse array one more time``    ``// print frequencies of elements and mark``    ``// frequencies as -1 so that same element``    ``// is not printed multiple times.``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``if` `(mp.get(arr[i]) != -``1``)``        ``{``            ``System.out.println(arr[i] + ``" "` `+``                               ``mp.get(arr[i]));``            ``mp. put(arr[i], -``1``);``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20` `};``    ``int` `n = arr.length;``    ``countFreq(arr, n);``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program to count frequencies of array items``def` `countFreq(arr, n):``    ``mp ``=` `{}``    ` `    ``# Traverse through array elements and``    ``# count frequencies``    ``for` `i ``in` `range``(n):``        ``if` `arr[i] ``not` `in` `mp:``            ``mp[arr[i]] ``=` `1``        ``else``:``            ``mp[arr[i]] ``+``=` `1` `    ``# To print elements according to first``    ``# occurrence, traverse array one more time``    ``# print frequencies of elements and mark``    ``# frequencies as -1 so that same element``    ``# is not printed multiple times.``    ``for` `i ``in` `range``(n):``        ``if``(mp[arr[i]] !``=` `-``1``):``            ``print``(arr[i], mp[arr[i]])``            ``mp[arr[i]] ``=` `-``1` `# Driver code``arr ``=` `[``10``, ``20``, ``20``, ``10``, ``10``, ``20``, ``5``, ``20` `]``n ``=` `len``(arr)``countFreq(arr, n)` `# This code is contributed by rag2127`

## C#

 `// C# program to count frequencies of array items``using` `System;``using` `System.Collections.Generic;``    ` `class` `GFG``{``static` `void` `countFreq(``int` `[]arr, ``int` `n)``{``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``// Traverse through array elements and``    ``// count frequencies``    ``for` `(``int` `i = 0 ; i < n; i++)``    ``{``        ``if``(mp.ContainsKey(arr[i]))``        ``{``            ``mp[arr[i]] = mp[arr[i]] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(arr[i], 1);``        ``}``    ``}``    ` `    ``// To print elements according to first``    ``// occurrence, traverse array one more time``    ``// print frequencies of elements and mark``    ``// frequencies as -1 so that same element``    ``// is not printed multiple times.``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(mp[arr[i]] != -1)``        ``{``            ``Console.WriteLine(arr[i] + ``" "` `+``                              ``mp[arr[i]]);``            ``mp[arr[i]] = - 1;``        ``}``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 10, 20, 20, 10,``                  ``10, 20, 5, 20 };``    ``int` `n = arr.Length;``    ``countFreq(arr, n);``}``}` `// This code is contributed by Rajput-Ji`
Output:
```10 3
20 4
5 1```

Time Complexity : O(n)
Auxiliary Space : O(n)

In Java, we can get elements in same order using LinkedHashMap. Therefore we do not need an extra loop.
Lot of problems are based on frequency measurement and will be a cheesecake if we know how to calculate frequency of various elements in a given array. For example try the given below problems which are based on frequency measurement:

This article is contributed by Aditya Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up