Skip to content
Related Articles

Related Articles

Print all array elements having frequencies equal to powers of K in ascending order
  • Last Updated : 26 Mar, 2021

Given an array arr[] consisting of N integers and a positive integer K, the task is to find the array elements having frequencies in the power of K i.e., K1, K2, K3, and so on.

Examples:

Input: arr[] = {1, 3, 2, 1, 2, 2, 2, 3, 3, 4}, K = 2
Output: 1 2
Explanation:
The frequency of 1 is 2, that can be represented as the power of K( = 2), i.e., 21.
The frequency of 2 is 4, that can be represented as the power of K( = 2), i.e., 22.

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

Naive Approach: The simplest approach is to count the frequencies of each array element and if the frequency of any element is a perfect power of K, then print that element. Otherwise, check for the next element.



Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by using Hashing for storing the frequency of arrays elements in a HashMap and then check for the required conditions. Follow the steps below to solve the given problem:

  • Traverse the given array arr[] and store the frequency of each array element in a Map, say M.
  • Now, traverse the map and perform the following steps:
    • Store the frequency of each value in the map in a variable, say F.
    • If the value of (log F)/(log K) and K(log F)/(log K) are the same, then the current element has the frequency as the perfect power of K. Therefore, print the current element.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the array elements
// whose frequency is a power of K
void countFrequency(int arr[], int N,
                    int K)
{
    // Stores the frequency of each
    // array elements
    unordered_map<int, int> freq;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of
        // array elements
        freq[arr[i]]++;
    }
 
    // Traverse the map freq
    for (auto i : freq) {
 
        // Calculate the log value of the
        // current frequency with base K
        int lg = log(i.second) / log(K);
 
        // Find the power of K of log value
        int a = pow(K, lg);
 
        // If the values are equal
        if (a == i.second) {
 
            // Print the current element
            cout << i.first << " ";
        }
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 4, 4, 2,
                  1, 2, 3, 2, 2 };
    int K = 2;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    countFrequency(arr, N, K);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
    // Function to find the array elements
    // whose frequency is a power of K
    static void countFrequency(int arr[], int N, int K)
    {
 
        // Stores the frequency of each
        // array elements
        HashMap<Integer, Integer> freq = new HashMap<>();
 
        // Traverse the array
        for (int i = 0; i < N; i++) {
 
            // Update frequency of
            // array elements
            freq.put(arr[i],
                     freq.getOrDefault(arr[i], 0) + 1);
        }
 
        // Traverse the map freq
        for (int key : freq.keySet()) {
 
            // Calculate the log value of the
            // current frequency with base K
            int lg = (int)(Math.log(freq.get(key))
                           / Math.log(K));
 
            // Find the power of K of log value
            int a = (int)(Math.pow(K, lg));
 
            // If the values are equal
            if (a == freq.get(key)) {
 
                // Print the current element
                System.out.print(key + " ");
            }
        }
    }
    // Driver Code
    public static void main(String[] args)
    {
 
        int arr[] = { 1, 4, 4, 2, 1, 2, 3, 2, 2 };
        int K = 2;
        int N = arr.length;
 
        // Function Call
        countFrequency(arr, N, K);
    }
}

Python3




# Python3 program for the above approach
 
# Function to find the array elements
from math import log
 
def countFrequency(arr, N, K):
   
    # Stores the frequency of each
    # array elements
    freq = {}
 
    # Traverse the array
    for i in range(N):
       
        # Update frequency of
        # array elements
        if (arr[i] in freq):
            freq[arr[i]] += 1
        else:
            freq[arr[i]] = 1
 
    # Traverse the map freq
    for key,value in freq.items():
       
        # Calculate the log value of the
        # current frequency with base K
        lg = log(value) // log(K)
 
        # Find the power of K of log value
        a = pow(K, lg)
 
        # If the values are equal
        if (a == value):
           
            # Print the current element
            print(key, end = " ")
 
# Driver Code
if __name__ == '__main__':
    arr = [1, 4, 4, 2, 1, 2, 3, 2, 2]
    K = 2
    N = len(arr)
 
    # Function Call
    countFrequency(arr, N, K)
 
    # This code is contributed by bgangwar59.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
  
// Function to find the array elements
// whose frequency is a power of K
static void countFrequency(int []arr, int N,
                           int K)
{
     
    // Stores the frequency of each
    // array elements
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update frequency of
        // array elements
        if (freq.ContainsKey(arr[i]))
            freq[arr[i]] += 1;
        else
            freq[arr[i]] = 1;
    }
 
    // Traverse the map freq
    foreach (KeyValuePair<int, int> entry in freq)
    {
        int temp = entry.Key;
         
        // Calculate the log value of the
        // current frequency with base K
        int lg = (int)(Math.Log(entry.Value) /
                       Math.Log(K));
 
        // Find the power of K of log value
        int a = (int)Math.Pow(K, lg);
 
        // If the values are equal
        if (a == entry.Value)
        {
             
            // Print the current element
            Console.Write(entry.Key + " ");
        }
    }
}
 
// Driver Code
public static void Main()
{
    int []arr = { 1, 4, 4, 2,
                  1, 2, 3, 2, 2 };
    int K = 2;
    int N = arr.Length;
     
    // Function Call
    countFrequency(arr, N, K);
}
}
 
// This code is contributed by SURENDRA_GANGWAR
Output: 
3 2 1 4

 

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :