Open in App
Not now

# First element occurring k times in an array

• Difficulty Level : Easy
• Last Updated : 14 Mar, 2023

Given an array of n integers. The task is to find the first element that occurs k number of times. If no element occurs k times the print -1. The distribution of integer elements could be in any range.
Examples:

Input: {1, 7, 4, 3, 4, 8, 7}, k = 2
Output: 7
Explanation: Both 7 and 4 occur 2 times. But 7 is the first that occurs 2 times.

Input: {4, 1, 6, 1, 6, 4}, k = 1
Output: -1

Naive Approach: The idea is to use two nested loops. one for the selection of element and other for counting the number of time the selected element occurs in the given array.

Algorithm:

• Define a function firstElement that takes an integer array arr, an integer n representing the size of the array, and an integer k representing the number of times an element must occur in the array.
• Iterate through each element in the array arr using a for loop with index i.
• For each element arr[i], count how many times it occurs in the array by iterating through the array again using another for loop with index j.
• If the count of the current element arr[i] is equal to k, return the element arr[i].
• If no element occurs k times in the array, return -1.
• In the main function, initialize an integer array arr, its size n, and the value of k.
• Call the firstElement function with arr, n, and k as arguments, and print the returned value.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find first` `// element occurring k times` `#include ` `using` `namespace` `std;`   `// Function to find the first element` `// occurring k number of times` `int` `firstElement(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// This loop is used for selection` `    ``//  of elements` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Count how many time selected element` `        ``// occurs` `        ``int` `count = 0;` `        ``for` `(``int` `j = 0; j < n; j++) {` `            ``if` `(arr[i] == arr[j])` `                ``count++;` `        ``}`   `        ``// Check, if it occurs k times or not` `        ``if` `(count == k)` `            ``return` `arr[i];` `    ``}`   `    ``return` `-1;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 7, 4, 3, 4, 8, 7 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `k = 2;` `    ``cout << firstElement(arr, n, k);` `    ``return` `0;` `}`

## Java

 `public` `class` `GFG {` `    ``// Java implementation to find first` `    ``// element occurring k times`   `    ``// Function to find the first element` `    ``// occurring k number of times` `    ``public` `static` `int` `firstElement(``int``[] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// This loop is used for selection` `        ``// of elements` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// Count how many time selected element` `            ``// occurs` `            ``int` `count = ``0``;` `            ``for` `(``int` `j = ``0``; j < n; j++) {` `                ``if` `(arr[i] == arr[j]) {` `                    ``count++;` `                ``}` `            ``}`   `            ``// Check, if it occurs k times or not` `            ``if` `(count == k) {` `                ``return` `arr[i];` `            ``}` `        ``}`   `        ``return` `-``1``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7` `};` `        ``int` `n = arr.length;` `        ``int` `k = ``2``;` `        ``System.out.print(firstElement(arr, n, k));` `    ``}` `}`   `// This code is contributed by Aarti_Rathi`

## Python3

 `# Python3 implementation to ` `# find first element ` `# occurring k times`   `# function to find the ` `# first element occurring ` `# k number of times` `def` `firstElement(arr, n, k):`   `    ``# dictionary to count` `    ``# occurrences of ` `    ``# each element` `    ``for` `i ``in` `arr:` `      ``count``=``0` `      ``for` `j ``in` `arr:` `        ``if` `i``=``=``j:` `          ``count``=``count``+``1` `      ``if` `count ``=``=` `k:` `        ``return` `i` `            `  `    ``# no element occurs k times` `    ``return` `-``1`   `# Driver Code` `if` `__name__``=``=``"__main__"``:`   `    ``arr ``=` `[``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7``];` `    ``n ``=` `len``(arr)` `    ``k ``=` `2` `    ``print``(firstElement(arr, n, k))`   `# This code is contributed by Arpit Jain`

## C#

 `// C# implementation to find first` `// element occurring k times` `using` `System;`   `public` `class` `GFG {`   `    ``// Function to find the first element` `    ``// occurring k number of times` `    ``public` `static` `int` `firstElement(``int``[] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// This loop is used for selection` `        ``// of elements` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// Count how many time selected element` `            ``// occurs` `            ``int` `count = 0;` `            ``for` `(``int` `j = 0; j < n; j++) {` `                ``if` `(arr[i] == arr[j]) {` `                    ``count++;` `                ``}` `            ``}`   `            ``// Check, if it occurs k times or not` `            ``if` `(count == k) {` `                ``return` `arr[i];` `            ``}` `        ``}`   `        ``return` `-1;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr = { 1, 7, 4, 3, 4, 8, 7 };` `        ``int` `n = arr.Length;` `        ``int` `k = 2;` `        ``Console.Write(firstElement(arr, n, k));` `    ``}` `}`   `// This code is contributed by Abhijeet Kumar(abhijeet19403)`

## Javascript

 `class GFG` `{` `    ``// javascript implementation to find first` `    ``// element occurring k times` `    ``// Function to find the first element` `    ``// occurring k number of times` `    ``static firstElement(arr, n, k)` `    ``{` `    `  `        ``// This loop is used for selection` `        ``// of elements` `        ``for` `(``var` `i = 0; i < n; i++)` `        ``{` `        `  `            ``// Count how many time selected element` `            ``// occurs` `            ``var` `count = 0;` `            ``for` `(``var` `j=0; j < n; j++)` `            ``{` `                ``if` `(arr[i] == arr[j])` `                ``{` `                    ``count++;` `                ``}` `            ``}` `            `  `            ``// Check, if it occurs k times or not` `            ``if` `(count == k)` `            ``{` `                ``return` `arr[i];` `            ``}` `        ``}` `        ``return` `-1;` `    ``}` `    `  `    ``// Driver Code` `    ``static main(args)` `    ``{` `        ``var` `arr = [1, 7, 4, 3, 4, 8, 7];` `        ``var` `n = arr.length;` `        ``var` `k = 2;` `        ``console.log(GFG.firstElement(arr, n, k));` `    ``}` `}` `GFG.main([]);`   `// This code is contributed by aadityaburujwale.`

Output

`7`

Time complexity: O(n2).
Auxiliary space: O(1) as it is using constant space for variables

Efficient Approach: Use unordered_map for hashing as the range is not known. Steps:

1. Traverse the array of elements from left to right.
2. While traversing increment their count in the hash table.
3. Again traverse the array from left to right and check which element has a count equal to k. Print that element and stop.
4. If no element has a count equal to k, print -1.

Below is a dry run of the above approach:

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find first` `// element occurring k times` `#include `   `using` `namespace` `std;`   `// function to find the first element` `// occurring k number of times` `int` `firstElement(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// unordered_map to count` `    ``// occurrences of each element` `    ``unordered_map<``int``, ``int``> count_map;` `    ``for` `(``int` `i=0; i

## Java

 `import` `java.util.HashMap;`   `// Java implementation to find first` `// element occurring k times` `class` `GFG {`   `// function to find the first element` `// occurring k number of times` `    ``static` `int` `firstElement(``int` `arr[], ``int` `n, ``int` `k) {` `        ``// unordered_map to count` `        ``// occurrences of each element`   `        ``HashMap count_map = ``new` `HashMap<>();` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``int` `a = ``0``;` `            ``if``(count_map.get(arr[i])!=``null``){` `                ``a = count_map.get(arr[i]);` `            ``}` `            `  `            ``count_map.put(arr[i], a+``1``);` `        ``}` `        ``//count_map[arr[i]]++;`   `        ``for` `(``int` `i = ``0``; i < n; i++) ``// if count of element == k ,then` `        ``// it is the required first element ` `        ``{` `            ``if` `(count_map.get(arr[i]) == k) {` `                ``return` `arr[i];` `            ``}` `        ``}`   `        ``// no element occurs k times` `        ``return` `-``1``;` `    ``}`   `// Driver program to test above` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `arr[] = {``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7``};` `        ``int` `n = arr.length;` `        ``int` `k = ``2``;` `        ``System.out.println(firstElement(arr, n, k));` `    ``}` `}`   `//this code contributed by Rajput-Ji`

## Python3

 `# Python3 implementation to ` `# find first element ` `# occurring k times`   `# function to find the ` `# first element occurring ` `# k number of times` `def` `firstElement(arr, n, k):`   `    ``# dictionary to count` `    ``# occurrences of ` `    ``# each element` `    ``count_map ``=` `{};` `    ``for` `i ``in` `range``(``0``, n):` `        ``if``(arr[i] ``in` `count_map.keys()):` `            ``count_map[arr[i]] ``+``=` `1` `        ``else``:` `            ``count_map[arr[i]] ``=` `1` `        ``i ``+``=` `1` `    `  `    ``for` `i ``in` `range``(``0``, n): ` `        `  `        ``# if count of element == k ,` `        ``# then it is the required` `        ``# first element ` `        ``if` `(count_map[arr[i]] ``=``=` `k):` `            ``return` `arr[i]` `        ``i ``+``=` `1` `            `  `    ``# no element occurs k times` `    ``return` `-``1`   `# Driver Code` `if` `__name__``=``=``"__main__"``:`   `    ``arr ``=` `[``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7``];` `    ``n ``=` `len``(arr)` `    ``k ``=` `2` `    ``print``(firstElement(arr, n, k))`   `# This code is contributed ` `# by Abhishek Sharma`

## C#

 `// C# implementation to find first ` `// element occurring k times ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{ `   `    ``// function to find the first element ` `    ``// occurring k number of times ` `    ``static` `int` `firstElement(``int` `[]arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``// unordered_map to count ` `        ``// occurrences of each element `   `        ``Dictionary<``int``, ``int``> count_map = ``new` `Dictionary<``int``,``int``>(); ` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{ ` `            ``int` `a = 0; ` `            ``if``(count_map.ContainsKey(arr[i]))` `            ``{ ` `                ``a = count_map[arr[i]]; ` `                ``count_map.Remove(arr[i]);` `                ``count_map.Add(arr[i], a+1);` `            ``} ` `            ``else` `                ``count_map.Add(arr[i], 1); ` `        ``} ` `        ``//count_map[arr[i]]++; `   `        ``for` `(``int` `i = 0; i < n; i++) ``// if count of element == k ,then ` `        ``// it is the required first element ` `        ``{ ` `            ``if` `(count_map[arr[i]] == k) ` `            ``{ ` `                ``return` `arr[i]; ` `            ``} ` `        ``} `   `        ``// no element occurs k times ` `        ``return` `-1; ` `    ``} `   `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `[]arr = {1, 7, 4, 3, 4, 8, 7}; ` `        ``int` `n = arr.Length; ` `        ``int` `k = 2; ` `        ``Console.WriteLine(firstElement(arr, n, k)); ` `    ``} ` `} `   `// This code has been contributed by 29AjayKumar `

## Javascript

 `

Output

`7`

Time Complexity: O(n)
Auxiliary Space: O(n) because we are using an auxiliary array of size n to store the count

Method 3:Using Built-in Python functions:

• Count the frequencies of every element using Counter function
• Traverse in frequency dictionary
• Checks which element has a count equal to k. Print that element and stop.
• If no element has a count equal to k, print -1.

## C++

 `// C++ implementation to find first` `// element occurring k times` `#include ` `using` `namespace` `std;`   `// function to find the first element` `// occurring k number of times` `int` `firstElement(``int` `arr[], ``int` `n, ``int` `k)` `{`   `  ``// unordered_map to count` `  ``// occurrences of each element` `  ``map<``int``, ``int``> count_map;` `  ``for` `(``int` `i = 0; i < n; i++) {`   `    ``count_map[arr[i]]++;` `  ``}` `  ``// count_map[arr[i]]++;`   `  ``for` `(``int` `i = 0; i < n;` `       ``i++) ``// if count of element == k ,then` `    ``// it is the required first element` `  ``{` `    ``if` `(count_map.find(arr[i]) != count_map.end()) {` `      ``if` `(count_map[arr[i]] == k)` `        ``return` `arr[i];` `    ``}` `  ``}`   `  ``// no element occurs k times` `  ``return` `-1;` `}`   `// Driver code` `int` `main()` `{` `  ``int` `arr[] = { 1, 7, 4, 3, 4, 8, 7 };` `  ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `  ``int` `k = 2;` `  ``cout << (firstElement(arr, n, k));` `  ``return` `0;` `}`   `// This code is contributed by Rajput-Ji`

## Java

 `// java implementation to find first ` `// element occurring k times ` `import` `java.util.*;` `class` `GFG ` `{ `   `  ``// function to find the first element ` `  ``// occurring k number of times ` `  ``static` `int` `firstElement(``int` `[]arr, ``int` `n, ``int` `k) ` `  ``{ `   `    ``// unordered_map to count ` `    ``// occurrences of each element ` `    ``HashMap count_map = ``new` `HashMap<>(); ` `    ``for` `(``int` `i = ``0``; i < n; i++)` `    ``{ ` `      ``if``(count_map.containsKey(arr[i]))` `      ``{ `   `        ``count_map.put(arr[i], count_map.get(arr[i])+``1``);` `      ``} ` `      ``else` `        ``count_map.put(arr[i], ``1``); ` `    ``} ` `    ``//count_map[arr[i]]++; `   `    ``for` `(``int` `i = ``0``; i < n; i++) ``// if count of element == k ,then ` `      ``// it is the required first element ` `    ``{ ` `      ``if` `(count_map.containsKey(arr[i]) ) ` `      ``{ ` `        ``if``(count_map.get(arr[i]) == k)` `          ``return` `arr[i]; ` `      ``} ` `    ``} `   `    ``// no element occurs k times ` `    ``return` `-``1``; ` `  ``} `   `  ``// Driver code ` `  ``public` `static` `void` `main(String[] args) ` `  ``{ ` `    ``int` `[]arr = {``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7``}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``2``; ` `    ``System.out.print(firstElement(arr, n, k)); ` `  ``} ` `} `   `// This code contributed by Rajput-Ji`

## Python3

 `# importing counter from collections` `from` `collections ``import` `Counter`   `# Python3 implementation to find ` `# first element occurring k times` `# function to find the  first element ` `# occurring  k number of times` `def` `firstElement(arr, n, k):`   `    ``# calculating frequencies using Counter` `    ``count_map ``=` `Counter(arr)`   `    ``for` `i ``in` `range``(``0``, n):`   `        ``# If count of element == k ,` `        ``# then it is the required` `        ``# first element` `        ``if` `(count_map[arr[i]] ``=``=` `k):` `            ``return` `arr[i]` `        ``i ``+``=` `1`   `    ``# No element occurs k times` `    ``return` `-``1`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``7``, ``4``, ``3``, ``4``, ``8``, ``7``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `2` `    ``print``(firstElement(arr, n, k))`   `# This code is contributed by vikkycirus`

## C#

 `// C# implementation to find first ` `// element occurring k times ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{ `   `    ``// function to find the first element ` `    ``// occurring k number of times ` `    ``static` `int` `firstElement(``int` `[]arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``// unordered_map to count ` `        ``// occurrences of each element `   `        ``Dictionary<``int``, ``int``> count_map = ``new` `Dictionary<``int``,``int``>(); ` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{ ` `            ``int` `a = 0; ` `            ``if``(count_map.ContainsKey(arr[i]))` `            ``{ ` `                ``a = count_map[arr[i]]; ` `                ``count_map.Remove(arr[i]);` `                ``count_map.Add(arr[i], a+1);` `            ``} ` `            ``else` `                ``count_map.Add(arr[i], 1); ` `        ``} ` `        ``//count_map[arr[i]]++; `   `        ``for` `(``int` `i = 0; i < n; i++) ``// if count of element == k ,then ` `        ``// it is the required first element ` `        ``{ ` `            ``if` `(count_map[arr[i]] == k) ` `            ``{ ` `                ``return` `arr[i]; ` `            ``} ` `        ``} `   `        ``// no element occurs k times ` `        ``return` `-1; ` `    ``} `   `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `[]arr = {1, 7, 4, 3, 4, 8, 7}; ` `        ``int` `n = arr.Length; ` `        ``int` `k = 2; ` `        ``Console.WriteLine(firstElement(arr, n, k)); ` `    ``} ` `} `   `// This code is contributed by avijitmondal1998.`

## Javascript

 ``

Output

`7`

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

This article is contributed by Ayush Jauhari. 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.