Largest element in the array that is repeated exactly k times
Last Updated :
01 Dec, 2022
Given an array of integers and an integer 'k', the task is to find the largest element from the array that is repeated exactly 'k' times.
Examples:
Input: arr = {1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6}, k = 2
Output: 5
The elements that exactly occur 2 times are 1, 3 and 5
And, the largest element among them is 5.
Input: arr = {1, 2, 3, 4, 5, 6}, k = 2
Output: No such element
There isn't any element in the array
that occurs exactly 2 times.
A simple approach:
- Sort the array.
- Start traversing the array from the end (as we're interested in the largest element that satisfies the condition) and count the frequencies of each element by comparing the element with its neighbour elements.
- The first element from the right that occurs exactly 'k' times is the answer.
- If no element is found that occurs exactly 'k' times then print 'No such element'.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function that finds the largest
// element which is repeated 'k' times
void solve(int arr[], int n, int k)
{
// sort the array
sort(arr, arr + n);
// if the value of 'k' is 1 and the
// largest appears only once in the array
if (k == 1 && arr[n - 2] != arr[n - 1]) {
cout << arr[n - 1] << endl;
return;
}
// counter to count
// the repeated elements
int count = 1;
for (int i = n - 2; i >= 0; i--) {
// check if the element at index 'i'
// is equal to the element at index 'i+1'
// then increase the count
if (arr[i] == arr[i + 1])
count++;
// else set the count to 1
// to start counting the frequency
// of the new number
else
count = 1;
// if the count is equal to k
// and the previous element
// is not equal to this element
if (count == k && (i == 0 || (arr[i - 1] != arr[i]))) {
cout << arr[i] << endl;
return;
}
}
// if there is no such element
cout << "No such element" << endl;
}
// Driver code
int main()
{
int arr[] = { 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 };
int k = 2;
int n = sizeof(arr) / sizeof(int);
// find the largest element
// that is repeated K times
solve(arr, n, k);
return 0;
}
// Java implementation of the above approach
import java.util.Arrays ;
public class GFG {
// Function that finds the largest
// element which is repeated 'k' times
static void solve(int arr[], int n, int k)
{
// sort the array
Arrays.sort(arr);
// if the value of 'k' is 1 and the
// largest appears only once in the array
if (k == 1 && arr[n - 2] != arr[n - 1]) {
System.out.println(arr[n - 1]);
return;
}
// counter to count
// the repeated elements
int count = 1;
for (int i = n - 2; i >= 0; i--) {
// check if the element at index 'i'
// is equal to the element at index 'i+1'
// then increase the count
if (arr[i] == arr[i + 1])
count++;
// else set the count to 1
// to start counting the frequency
// of the new number
else
count = 1;
// if the count is equal to k
// and the previous element
// is not equal to this element
if (count == k && (i == 0 || (arr[i - 1] != arr[i]))) {
System.out.println(arr[i]);
return;
}
}
// if there is no such element
System.out.println("No such element");
}
// Driver code
public static void main(String args[])
{
int arr[] = { 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 };
int k = 2;
int n = arr.length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
}
// This code is contributed by ANKITRAI1
}
# Python 3 implementation of the approach
# Function that finds the largest
# element which is repeated 'k' times
def solve(arr, n, k):
# sort the array
arr.sort()
# if the value of 'k' is 1 and the
# largest appears only once in the array
if (k == 1 and arr[n - 2] != arr[n - 1]):
print( arr[n - 1] )
return
# counter to count
# the repeated elements
count = 1
for i in range(n - 2, -1, -1) :
# check if the element at index 'i'
# is equal to the element at index 'i+1'
# then increase the count
if (arr[i] == arr[i + 1]):
count += 1
# else set the count to 1
# to start counting the frequency
# of the new number
else:
count = 1
# if the count is equal to k
# and the previous element
# is not equal to this element
if (count == k and (i == 0 or
(arr[i - 1] != arr[i]))):
print(arr[i])
return
# if there is no such element
print("No such element")
# Driver code
if __name__ == "__main__":
arr = [ 1, 1, 2, 3, 3, 4,
5, 5, 6, 6, 6 ]
k = 2
n = len(arr)
# find the largest element
# that is repeated K times
solve(arr, n, k)
# This code is contributed
# by ChitraNayal
// C# implementation of the above approach
using System;
class GFG
{
// Function that finds the largest
// element which is repeated 'k' times
static void solve(int []arr, int n, int k)
{
// sort the array
Array.Sort(arr);
// if the value of 'k' is 1 and the
// largest appears only once in the array
if (k == 1 && arr[n - 2] != arr[n - 1])
{
Console.WriteLine(arr[n - 1]);
return;
}
// counter to count
// the repeated elements
int count = 1;
for (int i = n - 2; i >= 0; i--)
{
// check if the element at index 'i'
// is equal to the element at index 'i+1'
// then increase the count
if (arr[i] == arr[i + 1])
count++;
// else set the count to 1
// to start counting the frequency
// of the new number
else
count = 1;
// if the count is equal to k
// and the previous element
// is not equal to this element
if (count == k && (i == 0 ||
(arr[i - 1] != arr[i])))
{
Console.WriteLine(arr[i]);
return;
}
}
// if there is no such element
Console.WriteLine("No such element");
}
// Driver code
static public void Main ()
{
int []arr = { 1, 1, 2, 3, 3, 4,
5, 5, 6, 6, 6 };
int k = 2;
int n = arr.Length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
}
}
// This code is contributed
// by Sach_Code
<?php
// PHP implementation of the approach
// Function that finds the largest
// element which is repeated 'k' times
function solve(&$arr, $n, $k)
{
// sort the array
sort($arr);
// if the value of 'k' is 1 and the
// largest appears only once in the array
if ($k == 1 && $arr[$n - 2] != $arr[$n - 1])
{
echo $arr[$n - 1] ;
echo ("\n");
return;
}
// counter to count
// the repeated elements
$count = 1;
for ($i = $n - 2; $i >= 0; $i--)
{
// check if the element at index 'i'
// is equal to the element at index 'i+1'
// then increase the count
if ($arr[$i] == $arr[$i + 1])
$count++;
// else set the count to 1
// to start counting the frequency
// of the new number
else
$count = 1;
// if the count is equal to k
// and the previous element
// is not equal to this element
if ($count == $k && ($i == 0 ||
($arr[$i - 1] != $arr[$i])))
{
echo ($arr[$i]);
echo ("\n");
return;
}
}
// if there is no such element
echo ("No such element");
echo ("\n");
}
// Driver code
$arr = array(1, 1, 2, 3, 3, 4,
5, 5, 6, 6, 6 );
$k = 2;
$n = sizeof($arr);
// find the largest element
// that is repeated K times
solve($arr, $n, $k);
// This code is contributed
// by Shivi_Aggarwal
?>
<script>
// Javascript implementation of the approach
// Function that finds the largest
// element which is repeated 'k' times
function solve(arr, n, k)
{
// sort the array
arr.sort((a,b)=> a-b)
// if the value of 'k' is 1 and the
// largest appears only once in the array
if (k == 1 && arr[n - 2] != arr[n - 1]) {
cout << arr[n - 1] << endl;
return;
}
// counter to count
// the repeated elements
var count = 1;
for (var i = n - 2; i >= 0; i--) {
// check if the element at index 'i'
// is equal to the element at index 'i+1'
// then increase the count
if (arr[i] == arr[i + 1])
count++;
// else set the count to 1
// to start counting the frequency
// of the new number
else
count = 1;
// if the count is equal to k
// and the previous element
// is not equal to this element
if (count == k && (i == 0 || (arr[i - 1] != arr[i]))) {
document.write( arr[i] + "<br>");
return;
}
}
// if there is no such element
document.write( "No such element" );
}
// Driver code
var arr = [ 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 ];
var k = 2;
var n = arr.length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
</script>
Time Complexity: O(N*log(N))
Auxiliary Space: O(1)
Efficient approach:
- Create a map and store the frequency of each element in the map.
- Then, traverse the array and find out the largest element that has frequency equal to 'k'.
- If found, print the number
- Else, print 'No such element'.
Below is the implementation of the above approach:
C++
// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
// Function that finds the largest
// element that occurs exactly 'k' times
void solve(int arr[], int n, int k)
{
// store the frequency
// of each element
unordered_map<int, int> m;
for (int i = 0; i < n; i++) {
m[arr[i]]++;
}
// to store the maximum element
int max = INT_MIN;
for (int i = 0; i < n; i++) {
// if current element has frequency 'k'
// and current maximum hasn't been set
if (m[arr[i]] == k && max == INT_MIN) {
// set the current maximum
max = arr[i];
}
// if current element has
// frequency 'k' and it is
// greater than the current maximum
else if (m[arr[i]] == k && max < arr[i]) {
// change the current maximum
max = arr[i];
}
}
// if there is no element
// with frequency 'k'
if (max == INT_MIN)
cout << "No such element" << endl;
// print the largest element
// with frequency 'k'
else
cout << max << endl;
}
// Driver code
int main()
{
int arr[] = { 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 };
int k = 4;
int n = sizeof(arr) / sizeof(int);
// find the largest element
// that is repeated K times
solve(arr, n, k);
return 0;
}
// Java implementation of above approach
import java.util.HashMap;
import java.util.Map;
class GfG
{
// Function that finds the largest
// element that occurs exactly 'k' times
static void solve(int arr[], int n, int k)
{
// store the frequency of each element
HashMap<Integer, Integer> m = new HashMap<>();
for (int i = 0; i < n; i++)
{
if (!m.containsKey(arr[i]))
m.put(arr[i], 0);
m.put(arr[i], m.get(arr[i]) + 1);
}
// to store the maximum element
int max = Integer.MIN_VALUE;
for (int i = 0; i < n; i++)
{
// If current element has frequency 'k'
// and current maximum hasn't been set
if (m.get(arr[i]) == k && max == Integer.MIN_VALUE)
{
// set the current maximum
max = arr[i];
}
// if current element has
// frequency 'k' and it is
// greater than the current maximum
else if (m.get(arr[i]) == k && max < arr[i])
{
// change the current maximum
max = arr[i];
}
}
// if there is no element
// with frequency 'k'
if (max == Integer.MIN_VALUE)
System.out.println("No such element");
// print the largest element
// with frequency 'k'
else
System.out.println(max);
}
// Driver code
public static void main(String []args)
{
int arr[] = { 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 };
int k = 4;
int n = arr.length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
}
}
// This code is contributed by Rituraj Jain
# Python implementation of above approach
import sys
# Function that finds the largest
# element that occurs exactly 'k' times
def solve(arr, n, k):
# store the frequency
# of each element
m = {};
for i in range(0, n - 1):
if(arr[i] in m.keys()):
m[arr[i]] += 1;
else:
m[arr[i]] = 1;
i += 1;
# to store the maximum element
max = sys.maxsize;
for i in range(0, n - 1):
# if current element has frequency 'k'
# and current maximum hasn't been set
if (m[arr[i]] == k and
max == sys.maxsize):
# set the current maximum
max = arr[i];
# if current element has
# frequency 'k' and it is
# greater than the current maximum
elif (m[arr[i]] == k and max < arr[i]):
# change the current maximum
max = arr[i];
i += 1
# if there is no element
# with frequency 'k'
if (max == sys.maxsize):
print("No such element");
# print the largest element
# with frequency 'k'
else:
print(max);
# Driver code
arr = [ 1, 1, 2, 3, 3, 4,
5, 5, 6, 6, 6 ]
k = 4;
n = len(arr)
# find the largest element
# that is repeated K times
solve(arr, n, k)
# This code is contributed
# by Shivi_Aggarwal
// C# Implementation of the above approach
using System;
using System.Collections.Generic;
class GfG
{
// Function that finds the largest
// element that occurs exactly 'k' times
static void solve(int []arr, int n, int k)
{
// store the frequency of each element
Dictionary<int,int> m = new Dictionary<int,int>();
for (int i = 0 ; i < n; i++)
{
if(m.ContainsKey(arr[i]))
{
var val = m[arr[i]];
m.Remove(arr[i]);
m.Add(arr[i], val + 1);
}
else
{
m.Add(arr[i], 1);
}
}
// to store the maximum element
int max = int.MinValue;
for (int i = 0; i < n; i++)
{
// If current element has frequency 'k'
// and current maximum hasn't been set
if (m[arr[i]] == k && max ==int.MinValue)
{
// set the current maximum
max = arr[i];
}
// if current element has
// frequency 'k' and it is
// greater than the current maximum
else if (m[arr[i]] == k && max < arr[i])
{
// change the current maximum
max = arr[i];
}
}
// if there is no element
// with frequency 'k'
if (max == int.MinValue)
Console.WriteLine("No such element");
// print the largest element
// with frequency 'k'
else
Console.WriteLine(max);
}
// Driver code
public static void Main(String []args)
{
int []arr = { 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 };
int k = 4;
int n = arr.Length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
}
}
// This code contributed by Rajput-Ji
<script>
// Javascript implementation of above approach
// Function that finds the largest
// element that occurs exactly 'k' times
function solve(arr, n, k)
{
// store the frequency
// of each element
var m = new Map();
for (var i = 0; i < n; i++) {
m.set(arr[i], m.get(arr[i])+1);
}
// to store the maximum element
var max = -1000000000;
for (var i = 0; i < n; i++) {
// if current element has frequency 'k'
// and current maximum hasn't been set
if (m.get(arr[i]) == k && max == -1000000000) {
// set the current maximum
max = arr[i];
}
// if current element has
// frequency 'k' and it is
// greater than the current maximum
else if (m.get(arr[i]) == k && max < arr[i]) {
// change the current maximum
max = arr[i];
}
}
// if there is no element
// with frequency 'k'
if (max == -1000000000)
document.write( "No such element");
// print the largest element
// with frequency 'k'
else
document.write( max);
}
// Driver code
var arr = [ 1, 1, 2, 3, 3, 4, 5, 5, 6, 6, 6 ];
var k = 4;
var n = arr.length;
// find the largest element
// that is repeated K times
solve(arr, n, k);
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Smallest element in an array that is repeated exactly 'k' times.
Given an array of size n, the goal is to find out the smallest number that is repeated exactly 'k' times where k > 0? Assume that array has only positive integers and 1 <= arr[i] < 1000 for each i = 0 to n -1. Examples: Input : arr[] = {2 2 1 3 1} k = 2 Output: 1 Explanation: Here in array,
15+ min read
K’th Smallest/Largest Element in Unsorted Array | Expected Linear Time
Given an array of distinct integers and an integer k, where k is smaller than the array's size, the task is to find the k'th smallest element in the array.Examples:Input: arr = [7, 10, 4, 3, 20, 15], k = 3Output: 7Explanation: The sorted array is [3, 4, 7, 10, 15, 20], so the 3rd smallest element is
10 min read
K'th Smallest/Largest Element in Unsorted Array | Set 2 (Expected Linear Time)
Given an array and a number k where k is smaller than the size of the array, we need to find the k’th largest element in the given array. It is given that all array elements are distinct. We recommend reading the following post as a prerequisite to this post. K’th Smallest/Largest Element in Unsorte
9 min read
Smallest element repeated exactly ‘k’ times (not limited to small range)
Given an array of size n, the goal is to find out the smallest number that is repeated exactly ‘k’ times where k > 0? And Examples: Input : a[] = {2, 1, 3, 1, 2, 2} k = 3 Output : 2 Input : a[] = {3, 4, 3, 2, 1, 5, 5} k = 2 Output : 3 Explanation: As 3 is smaller than 5. So 3 should be printed.Re
5 min read
Largest possible Subset from an Array such that no element is K times any other element in the Subset
Given an array arr[] consisting of N distinct integers and an integer K, the task is to find the maximum size of a subset possible such that no element in the subset is K times any other element of the subset(i.e. no such pair {n, m} should be present in the subset such that either m = n * K or n =
7 min read
Remove an occurrence of most frequent array element exactly K times
Given an array arr[], the task is to remove an occurrence of the most frequent array element exactly K times. If multiple array elements have maximum frequency, remove the smallest of them. Print the K deleted elements. Examples: Input: arr[] = {1, 3, 2, 1, 4, 1}, K = 2Output: 1 1Explanation: The fr
12 min read
Modify array by removing (arr[i] + arr[i + 1])th element exactly K times
Given an array arr[] consisting of first N natural numbers, where arr[i] = i ( 1-based indexing ) and a positive integer K, the task is to print the array arr[] obtained after removing every (arr[i] + arr[i + 1])th element from the array in every ith operation exactly K times. Examples: Input: arr[]
9 min read
Remove elements from the array which appear more than k times
Given an array of integers, remove all the occurrences of those elements which appear strictly more than k times in the array.Examples: Input : arr[] = {1, 2, 2, 3, 2, 3, 4} k = 2Output : 1 3 3 4Input : arr[] = {2, 5, 5, 7} k = 1Output : 2 7Approach: Take a hash map, which will store the frequency o
8 min read
Remove elements that appear strictly less than k times
Given an array of integers, remove all the elements which appear strictly less than k times. Examples: Input : arr[] = {1, 2, 2, 3, 2, 3, 4} k = 2 Output : 2 2 3 2 3 Explanation : {1, 4} appears less than 2 times. Approach : Take a hash map, which will store the frequency of all the elements in the
12 min read
Maximize Kth largest element after splitting the given Array at most C times
Given an array arr[] and two positive integers K and C, the task is to maximize the Kth maximum element obtained after splitting an array element arr[] into two parts(not necessarily an integer) C number of times. Print -1 if there doesn't exist Kth maximum element. Note: It is compulsory to do spli
7 min read