Count all elements in the array which appears at least K times after their first occurrence
Last Updated :
30 Mar, 2023
Given an array arr[] of N integer elements and an integer K. The task is to count all distinct arr[i] such that arr[i] appears at least K times in the index range i + 1 to n – 1.
Examples:
Input: arr[] = {1, 2, 1, 3}, K = 1
Output: 1
arr[0] = 1 is the only element that appears at least once in the index range [1, 3] i.e. arr[2]
Input: arr[] = {1, 2, 3, 2, 1, 3, 1, 2, 1}, K = 2
Output: 2
Naive Approach: Start from i = 0 to n-1, count occurrences of arr[i] in range i+1 to n-1. If the count is greater or equal to K, increment result by 1. Make a hash array to avoid duplicates.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <map>
using namespace std;
int countOccurrence( int n, int arr[], int k)
{
int cnt, ans = 0;
map< int , bool > hash;
for ( int i = 0; i < n; i++) {
cnt = 0;
if (hash[arr[i]] == true )
continue ;
hash[arr[i]] = true ;
for ( int j = i + 1; j < n; j++) {
if (arr[j] == arr[i])
cnt++;
if (cnt >= k)
break ;
}
if (cnt >= k)
ans++;
}
return ans;
}
int main()
{
int arr[] = { 1, 2, 1, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 1;
cout << countOccurrence(n, arr, k);
return 0;
}
|
Java
import java.util.HashMap;
class GFG
{
public static int countOccurrence( int n, int [] arr, int k)
{
int cnt, ans = 0 ;
HashMap<Integer, Boolean> hash = new HashMap<>();
for ( int i = 0 ; i < n; i++)
{
cnt = 0 ;
if (hash.get(arr[i]) != null && hash.get(arr[i]) == true )
continue ;
hash.put(arr[i], true );
for ( int j = i + 1 ; j < n; j++)
{
if (arr[j] == arr[i])
cnt++;
if (cnt >= k)
break ;
}
if (cnt >= k)
ans++;
}
return ans;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 1 , 3 };
int n = arr.length;
int k = 1 ;
System.out.println(countOccurrence(n, arr, k));
}
}
|
Python3
def countOccurrence(n, arr, k):
cnt, ans = 0 , 0
Hash = dict ()
for i in range (n):
cnt = 0
if (arr[i] in Hash .keys()):
continue
Hash [arr[i]] = 1
for j in range (i + 1 , n):
if (arr[j] = = arr[i]):
cnt + = 1
if (cnt > = k):
break
if (cnt > = k):
ans + = 1
return ans
arr = [ 1 , 2 , 1 , 3 ]
n = len (arr)
k = 1
print (countOccurrence(n, arr, k))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public static int countOccurrence( int n,
int [] arr, int k)
{
int cnt, ans = 0;
Dictionary< int ,
Boolean> hash = new Dictionary< int ,
Boolean>();
for ( int i = 0; i < n; i++)
{
cnt = 0;
if (hash.ContainsKey(arr[i]) &&
hash[arr[i]] == true )
continue ;
hash.Add(arr[i], true );
for ( int j = i + 1; j < n; j++)
{
if (arr[j] == arr[i])
cnt++;
if (cnt >= k)
break ;
}
if (cnt >= k)
ans++;
}
return ans;
}
public static void Main(String[] args)
{
int [] arr = {1, 2, 1, 3};
int n = arr.Length;
int k = 1;
Console.WriteLine(countOccurrence(n, arr, k));
}
}
|
Javascript
<script>
function countOccurrence(n, arr, k)
{
let cnt, ans = 0;
let hash = new Map();
for (let i = 0; i < n; i++)
{
cnt = 0;
if (hash.get(arr[i]) != null &&
hash.get(arr[i]) == true )
continue ;
hash.set(arr[i], true );
for (let j = i + 1; j < n; j++)
{
if (arr[j] == arr[i])
cnt++;
if (cnt >= k)
break ;
}
if (cnt >= k)
ans++;
}
return ans;
}
let arr = [1, 2, 1, 3];
let n = arr.length;
let k = 1;
document.write(countOccurrence(n, arr, k));
</script>
|
Time Complexity: O(n2*log(n))
Auxiliary Space: O(n), where n is the size of the given array.
Efficient Approach: Declare another hash map to store the occurrence of all elements and start from n – 1 to 0. If occurrence[arr[i]] ? k then increment the count by 1 otherwise increment occurrence of arr[i] by 1.
Below is the implementation of the above approach:
C++
#include <iostream>
#include <map>
using namespace std;
int countOccurrence( int n, int arr[], int k)
{
int cnt, ans = 0;
map< int , bool > hash;
map< int , int > occurrence;
for ( int i = n - 1; i >= 0; i--) {
if (hash[arr[i]] == true )
continue ;
if (occurrence[arr[i]] >= k) {
ans++;
hash[arr[i]] = true ;
}
else
occurrence[arr[i]]++;
}
return ans;
}
int main()
{
int arr[] = { 1, 2, 1, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 1;
cout << countOccurrence(n, arr, k);
return 0;
}
|
Java
import java.util.HashMap;
class GFG
{
public static int countOccurrence( int n, int [] arr, int k)
{
int ans = 0 ;
HashMap<Integer, Boolean> hash = new HashMap<>();
HashMap<Integer, Integer> occurrence = new HashMap<>();
for ( int i = n- 1 ; i>= 0 ; i--)
{
if (hash.get(arr[i]) != null &&
hash.get(arr[i]) == true )
continue ;
if (occurrence.get(arr[i]) != null &&
occurrence.get(arr[i]) >= k)
{
ans++;
hash.put(arr[i], true );
}
else
{
if (occurrence.get(arr[i]) == null )
occurrence.put(arr[i], 1 );
else
{
int temp = occurrence.get(arr[i]);
occurrence.put(arr[i], ++temp);
}
}
}
return ans;
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 1 , 3 };
int n = arr.length;
int k = 1 ;
System.out.println(countOccurrence(n, arr, k));
}
}
|
Python3
def countOccurrence(n, arr, k) :
ans = 0 ;
hash = dict .fromkeys(arr, 0 );
occurrence = dict .fromkeys(arr, 0 );
for i in range (n - 1 , - 1 , - 1 ) :
if ( hash [arr[i]] = = True ) :
continue ;
if (occurrence[arr[i]] > = k) :
ans + = 1 ;
hash [arr[i]] = True ;
else :
occurrence[arr[i]] + = 1 ;
return ans;
if __name__ = = "__main__" :
arr = [ 1 , 2 , 1 , 3 ];
n = len (arr) ;
k = 1 ;
print (countOccurrence(n, arr, k));
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public static int countOccurrence( int n,
int [] arr,
int k)
{
int ans = 0;
Dictionary< int ,
bool > hash = new Dictionary< int ,
bool >();
Dictionary< int ,
int > occurrence = new Dictionary< int ,
int >();
for ( int i = n - 1; i >= 0; i--)
{
if (hash.ContainsKey(arr[i]) &&
hash[arr[i]] == true )
continue ;
if (occurrence.ContainsKey(arr[i]) &&
occurrence[arr[i]] >= k)
{
ans++;
hash.Add(arr[i], true );
}
else
{
if (!occurrence.ContainsKey(arr[i]))
occurrence.Add(arr[i], 1);
else
{
int temp = occurrence[arr[i]];
occurrence.Add(arr[i], ++temp);
}
}
}
return ans;
}
public static void Main(String[] args)
{
int [] arr = {1, 2, 1, 3};
int n = arr.Length;
int k = 1;
Console.WriteLine(countOccurrence(n, arr, k));
}
}
|
Javascript
<script>
function countOccurrence(n, arr, k)
{
let ans = 0;
let hash = new Map();
let occurrence = new Map();
for (let i = n - 1; i >= 0; i--)
{
if (hash.get(arr[i]) != null &&
hash.get(arr[i]) == true )
continue ;
if (occurrence.get(arr[i]) != null &&
occurrence.get(arr[i]) >= k)
{
ans++;
hash.set(arr[i], true );
}
else
{
if (occurrence.get(arr[i]) == null )
occurrence.set(arr[i], 1);
else
{
let temp = occurrence.get(arr[i]);
occurrence.set(arr[i], ++temp);
}
}
}
return ans;
}
let arr = [ 1, 2, 1, 3 ];
let n = arr.length;
let k = 1;
document.write(countOccurrence(n, arr, k));
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(n), where n is the size of the given array.
Another Efficient Approach (Space Optimization) :
- If element should occur atleast k times after first occurrence , then their frequency in array should be atleast k+1 times .
- First we will sort the array for binary search .
- We can find frequency of arr[i] by using binary search function .
- The frequency of arr[i] will be index of ‘last occurrence – first occurrence’+1.
- So , frequency if atleast k times then increase the count by 1 .
- Then return final answer .
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countOccurrence( int arr[], int n, int k)
{ int count = 0;
sort(arr,arr+n);
for ( int i = 0 ; i < n ;i++)
{
int first_index = lower_bound(arr,arr+n,arr[i])- arr;
int last_index = upper_bound(arr,arr+n,arr[i])- arr-1;
i = last_index;
int fre = last_index-first_index+1;
if (fre >= k+1)
{
count += 1;
}
}
return count;
}
int main()
{
int arr[] = { 1, 2, 1, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 1;
cout << countOccurrence( arr, n, k);
return 0;
}
|
Java
import java.util.Arrays;
public class Main {
static int countOccurrence( int [] arr, int n, int k) {
int count = 0 ;
Arrays.sort(arr);
for ( int i = 0 ; i < n; i++) {
int first_index = Arrays.binarySearch(arr, arr[i]);
if (first_index < 0 ) {
continue ;
}
int last_index = first_index;
while (last_index + 1 < n && arr[last_index + 1 ] == arr[i]) {
last_index++;
}
i = last_index;
int fre = last_index - first_index + 1 ;
if (fre >= k + 1 ) {
count += 1 ;
}
}
return ++count;
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 1 , 3 };
int n = arr.length;
int k = 1 ;
System.out.println(countOccurrence(arr, n, k));
}
}
|
C#
using System;
class MainClass {
static int countOccurrence( int [] arr, int n, int k) {
int count = 0;
Array.Sort(arr);
for ( int i = 0; i < n; i++) {
int first_index = Array.BinarySearch(arr, arr[i]);
if (first_index < 0) {
continue ;
}
int last_index = first_index;
while (last_index + 1 < n && arr[last_index + 1] == arr[i]) {
last_index++;
}
i = last_index;
int fre = last_index - first_index + 1;
if (fre >= k + 1) {
count += 1;
}
}
return ++count;
}
public static void Main() {
int [] arr = { 1, 2, 1, 3 };
int n = arr.Length;
int k = 1;
Console.WriteLine(countOccurrence(arr, n, k));
}
}
|
Python3
def countOccurrence(arr, n, k):
count = 0
arr.sort()
i = 0
while i < n:
first_index = arr.index(arr[i])
last_index = n - arr[:: - 1 ].index(arr[i]) - 1
i = last_index
fre = last_index - first_index + 1
if fre > = k + 1 :
count + = 1
i + = 1
return count
arr = [ 1 , 2 , 1 , 3 ]
n = len (arr)
k = 1
print (countOccurrence(arr, n, k))
|
Javascript
function countOccurrence(arr, n, k) {
let count = 0;
arr.sort((a, b) => a - b);
for (let i = 0; i < n; i++) {
let first_index = arr.indexOf(arr[i]);
let last_index = arr.lastIndexOf(arr[i]);
i = last_index;
let fre = last_index - first_index + 1;
if (fre >= k + 1) {
count += 1;
}
}
return count;
}
let arr = [1, 2, 1, 3];
let n = arr.length;
let k = 1;
console.log(countOccurrence(arr, n, k));
|
Time Complexity: O(n*log2n)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...