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., **K ^{1}, K^{2}, K^{3}, and so on**.

**Examples:**

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

The frequency of 1 is 2, that can be represented as the power of K( = 2), i.e., 2^{1}.

The frequency of 2 is 4, that can be represented as the power of K( = 2), i.e., 2^{2}.

Input:arr[] = {6, 1, 3, 1, 2, 2, 1}, K = 2Output: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(N^{2})**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**are the same, then the current element has the frequency as the perfect power of^{(log F)/(log K)}**K**. Therefore, print the current element.

- Store the frequency of each value in the map in a variable, say

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****.**