Skip to content
Related Articles

Related Articles

Maximise occurrence of an element after K replacements within Array elements

Improve Article
Save Article
  • Last Updated : 12 Apr, 2022
Improve Article
Save Article

Given an array arr[] having N integers, and an integer K, the task is to find an array such that it contains a single elements maximum number of times possible after K replacements within array elements.

Examples: 

Input: N = 7, arr[] = {1, 2, 1, 5, 1, 6, 7}, K = 3
Output: {1, 1, 1, 1, 1, 1, 7}
Explanation: We can replace element on index 1, 3, and 5 with 1, i.e. A[1] = A[0], A[3] = A[0] and A[5] = A[0]

Input: N = 6, arr[] = {2, 2, 2, 5, 1, 6 }, K = 3
Output: {2, 2, 2, 2, 2, 2 }

 

Approach: The approach to solve this problem is based on following idea:

  • If we dont do any replacement, and if there are duplicates present in the array, then there will be an element present already occurring maximum number of times in the array.
     
  • Now when K replacements are allowed, we can simply try to change replace elements not equal to maximum occurring element with maximum occurring element K times, to get the desired array.

Following is the algorithm to implement above discussed approach:

Below is the implementation of the above approach:

C++




// C++ code for the above discussed approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to maximizeTheElements
vector<int> maximizeTheElements(
    int N, vector<int> arr, int K)
{
 
    // Map tp store the frequency
    // of the elements
    unordered_map<int, int> mp;
 
    int max_freq = 0, max_element = -1;
    for (auto x : arr) {
        mp[x]++;
 
        // Getting max_element
        if (mp[x] > max_freq) {
            max_freq = mp[x];
            max_element = x;
        }
    }
 
    for (int i = 0; i < N && K > 0; i++) {
 
        // If the element is not equal
        // to the max_element
        if (arr[i] != max_element) {
 
            // Decrease its frequency from the map
            mp[arr[i]] -= 1;
 
            // Assign the max frequency element
            arr[i] = max_element;
 
            // Increase its frequency in the map
            mp[arr[i]] += 1;
 
            // Decrease the operation by 1
            K -= 1;
        }
    }
 
    // Return the modified array
    return arr;
}
 
// Driver Function
int main()
{
 
    int N = 7;
    vector<int> arr = { 1, 2, 1, 5, 1, 6, 7 };
    int K = 3;
 
    // Function call
    vector<int> res = maximizeTheElements(N, arr, K);
 
    for (auto x : res) {
        cout << x << " ";
    }
    cout << endl;
 
    return 0;
}


Java




// Java code for the above discussed approach
import java.util.*;
 
class GFG {
 
  // Function to maximizeTheElements
  static int[] maximizeTheElements(
    int N, int arr[], int K)
  {
 
    // Map tp store the frequency
    // of the elements
    HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
    int max_freq = 0, max_element = -1;
    for(int i = 0; i  < arr.length; i++){
      if(m.containsKey(arr[i])){
        m.put(arr[i], m.get(arr[i]) + 1);
      }
      else{
        m.put(arr[i],1);
      }
 
      // Getting max_element
      if (m.get(arr[i]) > max_freq) {
        max_freq = m.get(arr[i]);
        max_element = arr[i];
      }
    }
 
    for (int i = 0; i < N; i++) {
      if(K <= 0)break;
      // If the element is not equal
      // to the max_element
      if (arr[i] != max_element) {
 
        // Decrease its frequency from the map
        m.put(arr[i], m.get(arr[i]) - 1);
 
        // Assign the max frequency element
        arr[i] = max_element;
 
        // Increase its frequency in the map
        m.put(arr[i], m.get(arr[i]) + 1);
 
        // Decrease the operation by 1
        K -= 1;
      }
    }
 
    // Return the modified array
    return arr;
  }
 
  // Driver Function
  public static void main (String[] args) {
    int N = 7;
    int  arr[] = { 1, 2, 1, 5, 1, 6, 7 };
    int K = 3;
 
    // Function call
    int res[] = maximizeTheElements(N, arr, K);
 
    for (int x : res) {
      System.out.print(x + " ");
    }
 
  }
}
 
// This code is contributed by hrithikgarg03188.


Python3




# Python3 code for the above discussed approach
 
# Function to maximizeTheElements
def maximizeTheElements(N, arr, K):
 
        # Map tp store the frequency
        # of the elements
    mp = {}
 
    max_freq, max_element = 0, -1
    for x in arr:
        mp[x] = mp[x] + 1 if x in mp else 1
 
        # Getting max_element
        if (mp[x] > max_freq):
            max_freq = mp[x]
            max_element = x
 
    for i in range(0, N):
        if K <= 0:
            break
            # If the element is not equal
            # to the max_element
        if (arr[i] != max_element):
 
                        # Decrease its frequency from the map
            mp[arr[i]] -= 1
 
            # Assign the max frequency element
            arr[i] = max_element
 
            # Increase its frequency in the map
            mp[arr[i]] += 1
 
            # Decrease the operation by 1
            K -= 1
 
        # Return the modified array
    return arr
 
# Driver Function
if __name__ == "__main__":
 
    N = 7
    arr = [1, 2, 1, 5, 1, 6, 7]
    K = 3
 
    # Function call
    res = maximizeTheElements(N, arr, K)
 
    for x in res:
        print(x, end=" ")
 
    # This code is contributed by rakeshsahni


C#




// C# code for the above discussed approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to maximizeTheElements
  static int[] maximizeTheElements(int N, int[] arr,
                                   int K)
  {
 
    // Map to store the frequency
    // of the elements
    var m = new Dictionary<int, int>();
    int max_freq = 0, max_element = -1;
    for (int i = 0; i < arr.Length; i++) {
      if (m.ContainsKey(arr[i])) {
        m[arr[i]] += 1;
      }
      else {
        m[arr[i]] = 1;
      }
 
      // Getting max_element
      if (m[arr[i]] > max_freq) {
        max_freq = m[arr[i]];
        max_element = arr[i];
      }
    }
 
    for (int i = 0; i < N; i++) {
      if (K <= 0)
        break;
 
      // If the element is not equal
      // to the max_element
      if (arr[i] != max_element) {
 
        // Decrease its frequency from the map
        m[arr[i]] -= 1;
 
        // Assign the max frequency element
        arr[i] = max_element;
 
        // Increase its frequency in the map
        m[arr[i]] += 1;
 
        // Decrease the operation by 1
        K -= 1;
      }
    }
 
    // Return the modified array
    return arr;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int N = 7;
    int[] arr = { 1, 2, 1, 5, 1, 6, 7 };
    int K = 3;
 
    // Function call
    int[] res = maximizeTheElements(N, arr, K);
 
    for (int i = 0; i < res.Length; i++) {
      Console.Write(res[i] + " ");
    }
  }
}
 
// This code is contributed by phasing17


Javascript




<script>
       // JavaScript code for the above approach
 
       // Function to maximizeTheElements
       function maximizeTheElements(
           N, arr, K) {
 
           // Map tp store the frequency
           // of the elements
           let mp = new Map();
 
           let max_freq = 0, max_element = -1;
           for (let x of arr) {
               if (!mp.has(x)) {
                   mp.set(x, 1)
               }
               else {
                   mp.set(x, mp.get(x) + 1)
               }
 
               // Getting max_element
               if (mp.get(x) > max_freq) {
                   max_freq = mp.get(x);
                   max_element = x;
               }
           }
 
           for (let i = 0; i < N && K > 0; i++) {
 
               // If the element is not equal
               // to the max_element
               if (arr[i] != max_element) {
 
                   // Decrease its frequency from the map
                   mp.set(arr[i], mp.get(arr[i]) - 1)
 
                   // Assign the max frequency element
                   arr[i] = max_element;
 
                   // Increase its frequency in the map
                   mp.set(arr[i], mp.get(arr[i]) + 1)
 
                   // Decrease the operation by 1
                   K -= 1;
               }
           }
 
           // Return the modified array
           return arr;
       }
 
       // Driver Function
       let N = 7;
       let arr = [1, 2, 1, 5, 1, 6, 7];
       let K = 3;
 
       // Function call
       let res = maximizeTheElements(N, arr, K);
 
       for (let x of res) {
           document.write(x + " ");
       }
 
   // This code is contributed by Potta Lokesh
   </script>


Output

1 1 1 1 1 1 7 

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!