Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Find GCD of most occurring and least occurring elements of given Array

  • Difficulty Level : Easy
  • Last Updated : 17 Dec, 2021

Given an array arr[] of size n, The task is to find the GCD of the highest and lowest frequency element in the given array.

Examples:

Input: arr[] = {2, 2, 4, 4, 5, 5, 6, 6, 6, 6}
Output: 2
Explanation: The frequency of the elements in the above array is 
freq(2) = 2, 
freq(4) = 2, 
freq(5) = 2, 
freq(6) = 4, 
The minimum frequency is 2 (of elements 2, 4, and 5). So 2 will be picked as the least among 2, 4, and 5. 
The largest frequency is 4 (of element 6). 
Hence GCD of 2 and 6 = gcd(2, 6) is 2.

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

 

Approach: The idea is to count the frequencies of all elements and store them in a vector and then find the gcd of the highest occurring and the least occurring elements.

Below is the implementation of the above approach:

C++14




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find frequency and find gcd
int find_gcd(vector<int> v, int n)
{
    map<int, int> mp;
 
    // Update the frequency
    for (int i = 0; i < n; i++) {
        mp[v[i]]++;
    }
 
    int mini = v[0], maxi = v[0];
 
    for (auto it : mp) {
        mini = mp[mini] < it.second
                   ? it.first
                   : mini;
    }
    for (auto it : mp) {
        maxi = mp[maxi] > it.second
                   ? it.first
                   : maxi;
    }
 
    // Find gcd
    int res = __gcd(mini, maxi);
    return res;
}
 
// Drive Code
int main()
{
    vector<int> v = { 2, 2, 4, 4, 5, 5, 6, 6, 6, 6 };
    int n = v.size();
    cout << find_gcd(v, n) << endl;
 
    vector<int> v1 = { 3, 2, 2, 44, 44, 44, 44 };
    cout << find_gcd(v1, v1.size()) << endl;
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find frequency and find gcd
static int find_gcd(int []v, int n)
{
    HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();
 
    // Update the frequency
    for (int i = 0; i < n; i++) {
         if(mp.containsKey(v[i])){
                mp.put(v[i], mp.get(v[i])+1);
            }
            else{
                mp.put(v[i], 1);
            }
    }
 
    int mini = v[0], maxi = v[0];
 
    for (Map.Entry<Integer,Integer> it : mp.entrySet()) {
        mini = mp.get(mini) < it.getValue()
                   ? it.getKey()
                   : mini;
    }
    for (Map.Entry<Integer,Integer> it : mp.entrySet()) {
        maxi = mp.get(maxi) > it.getValue()
                   ? it.getKey()
                   : maxi;
    }
 
    // Find gcd
    int res = __gcd(mini, maxi);
    return res;
}
static int __gcd(int a, int b) 
{ 
    return b == 0? a:__gcd(b, a % b);    
}
   
// Drive Code
public static void main(String[] args)
{
    int [] v = { 2, 2, 4, 4, 5, 5, 6, 6, 6, 6 };
    int n = v.length;
    System.out.print(find_gcd(v, n) +"\n");
 
    int [] v1 = { 3, 2, 2, 44, 44, 44, 44 };
    System.out.print(find_gcd(v1, v1.length) +"\n");
}
}
 
// This code is contributed by shikhasingrajput
Python3



# python program for the above approach
import math
 
# Function to find frequency and find gcd
def find_gcd(v, n):
 
    mp = {}
 
    # Update the frequency
    for i in range(0, n):
        if v[i] in mp:
            mp[v[i]] += 1
        else:
            mp[v[i]] = 1
 
    mini = v[0]
    maxi = v[0]
 
    for it in mp:
        if mini in mp and mp[mini] < mp[it]:
            mini = it
 
    for it in mp:
        if mp[maxi] > mp[it]:
            maxi = it
 
        # Find gcd
    res = math.gcd(mini, maxi)
    return res
 
# Drive Code
if __name__ == "__main__":
 
    v = [2, 2, 4, 4, 5, 5, 6, 6, 6, 6]
    n = len(v)
    print(find_gcd(v, n))
 
    v1 = [3, 2, 2, 44, 44, 44, 44]
    print(find_gcd(v1, len(v1)))
 
    # This code is contributed by rakeshsahni
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
    static int __gcd(int a, int b)
    {
        return b == 0 ? a : __gcd(b, a % b);
    }
 
    // Function to find frequency and find gcd
    static int find_gcd(int[] v, int n)
    {
        Dictionary<int, int> mp
            = new Dictionary<int, int>();
 
        // Update the frequency
        for (int i = 0; i < n; i++) {
            if (mp.ContainsKey(v[i])) {
                mp[v[i]] += 1;
            }
            else {
                mp[v[i]] = 1;
            }
        }
 
        int mini = v[0], maxi = v[0];
 
        foreach(KeyValuePair<int, int> it in mp)
        {
            mini = mp[mini] < it.Value ? it.Key : mini;
        }
        foreach(KeyValuePair<int, int> it in mp)
        {
            maxi = mp[maxi] > it.Value ? it.Key : maxi;
        }
 
        // Find gcd
        int res = __gcd(mini, maxi);
        return res;
    }
 
    // Drive Code
    public static void Main()
    {
        int[] v = { 2, 2, 4, 4, 5, 5, 6, 6, 6, 6 };
        int n = v.Length;
        Console.WriteLine(find_gcd(v, n));
 
        int[] v1 = { 3, 2, 2, 44, 44, 44, 44 };
        Console.WriteLine(find_gcd(v1, v1.Length));
    }
}
 
// This code is contributed by ukasp.
Javascript



<script>
       // JavaScript code for the above approach
       function __gcd(a, b) {
           // Everything divides 0
           if (a == 0)
               return b;
           if (b == 0)
               return a;
 
           // base case
           if (a == b)
               return a;
 
           // a is greater
           if (a > b)
               return __gcd(a - b, b);
           return __gcd(a, b - a);
       }
       // Function to find frequency and find gcd
       function find_gcd(v, n) {
           let mp = new Map();
 
           // Update the frequency
           for (let i = 0; i < n; i++) {
 
               if (!mp.has(v[i]))
                   mp.set(v[i], 1);
               else
                   mp.set(v[i], mp.get(v[i]) + 1)
           }
 
           let mini = v[0], maxi = v[0];
 
           for (let [key, val] of mp) {
               mini = mp.get(mini) < val
                   ? key
                   : mini;
           }
           for (let [key, val] of mp) {
               maxi = mp.get(maxi) > val
                   ? key
                   : maxi;
           }
 
           // Find gcd
           let res = __gcd(mini, maxi);
           return res;
       }
 
       // Drive Code
       let v = [2, 2, 4, 4, 5, 5, 6, 6, 6, 6];
       let n = v.length;
       document.write(find_gcd(v, n) + '<br>');
 
       let v1 = [3, 2, 2, 44, 44, 44, 44];
       document.write(find_gcd(v1, v1.length) + '<br>');
 
 // This code is contributed by Potta Lokesh
   </script>
 
 
Output: 
2
1
 
 
Time Complexity: O(n*log(n))
Auxiliary Space: O(n)
 

My Personal Notes
arrow_drop_up
Previous
How Technology Has Influenced the Stock Market?
Next

Sum of all integers in given N ranges
Recommended Articles
Page :
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Queries to calculate difference between the frequencies of the most and least occurring characters in specified substring
05, Jan 21
GCD of elements occurring Fibonacci number of times in an Array
09, Apr 20
Print all array elements occurring at least M times
08, Mar 21
Minimize splits in given Array to find subsets of at most 2 elements with sum at most K
26, Dec 21
Count subarrays having exactly K elements occurring at least twice
03, Mar 21
Find Kth most occurring element in an Array
15, Apr 20
Smallest subsequence having GCD equal to GCD of given array
20, Oct 20
Maximize the product of sum and least power by choosing at most K elements from given value and power Arrays
28, Oct 21
Find N distinct integers with GCD of sequence as 1 and GCD of each pair greater than 1
07, Dec 21
Minimum days to make Array elements with value at least K sum at least X
07, Jul 21
Check if the sum of K least and most frequent array elements are equal or not
26, Jul 21
Print the most occurring character in an array of strings
28, Feb 20
Maximum possible GCD after replacing at most one element in the given array
27, Nov 19
Maximize element at index K in an array with at most sum M and difference between adjacent elements at most 1
22, Jan 21
Count subarrays having each distinct element occurring at least twice
25, Oct 20
Smallest number whose sum of digits is N and every digit occurring at most K times
20, Dec 20
Count of Array elements greater than all elements on its left and at least K elements on its right
29, Jul 20
C++ Program to Count of Array elements greater than all elements on its left and at least K elements on its right
21, Jan 22
Java Program to Count of Array elements greater than all elements on its left and at least K elements on its right
21, Jan 22
Find Binary String of size at most 3N containing at least 2 given strings of size 2N as subsequences
27, Jan 22
Count arrays having at least K elements exceeding XOR of all given array elements by X given operations
17, Feb 21
Count pairs (p, q) such that p occurs in array at least q times and q occurs at least p times
25, Feb 19
Count substrings with each character occurring at most k times
01, Apr 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
bunny09262002
@bunny09262002
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!