Given an array arr[] of integers N, the task is to find the GCD of all numbers for which it’s value is equal to its frequency in the array.
Examples;
Input: arr={2, 3, 4, 2, 3, 3} N=6
Output: 1
Explanation: Here 2 is occurring 2 times and 3 is occurring 3 times.
Hence GCD of 2, 3, is 1. So our output is 1.
Input: arr={2, 3, 4, 4, 3, 5, 4, 4, 2, 8} N=10
Output: 2
Explanation: Here 2 is occurring 2 times, 4 is occurring 4 times.
HenceGCD of 2, 4, is 2. So our output is 2.
Approach: The idea to solve the problem is as following:
Find the elements whose value is equal to its frequency. Then calculate the GCD of those number.
Follow the steps mentioned below to solve the problem:
- Find frequencies of all the numbers of the array.
- From the array find the numbers having frequency same as its value and store them.
- Calculate the GCD of those numbers.
- Return the GCD.
Below is the implementation of the above approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to find GCD int findGcd( int arr[], int n)
{ vector< int > v;
// Declaration of map
unordered_map< int , int > m1;
for ( int i = 0; i < n; i++) {
m1[arr[i]]++;
}
unordered_map< int , int >::iterator it;
for (it = m1.begin(); it != m1.end();
++it) {
if (it->second == it->first)
// Pushing superior numbers
// into vector.
v.push_back(it->first);
}
int hcf;
if (v.size() == 0)
return 0;
else if (v.size() == 1)
return v[0];
else if (v.size() == 2) {
hcf = __gcd(v[0], v[1]);
return hcf;
}
else if (v.size() > 2) {
hcf = __gcd(v[0], v[1]);
for ( int i = 2; i < v.size(); i++) {
hcf = __gcd(v[i], hcf);
}
return hcf;
}
return 1;
} // Driver Code int main()
{ int N = 10;
int arr[N] = { 2, 3, 4, 4, 3,
5, 4, 4, 2, 8 };
// Function call
cout << findGcd(arr, N);
return 0;
} |
// Java code to implement the approach import java.io.*;
import java.util.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
class GFG {
public static int gcd( int a, int b)
{
if (b == 0 )
return a;
return gcd(b, a % b);
}
// Function to find GCD
public static int findGcd( int arr[], int n)
{
ArrayList<Integer> v = new ArrayList<Integer>();
// Declaration of map
HashMap<Integer, Integer> m1
= new HashMap<Integer, Integer>();
for ( int i = 0 ; i < n; i++) {
if (m1.get(arr[i]) != null )
m1.put(arr[i], m1.get(arr[i]) + 1 );
else
m1.put(arr[i], 1 );
}
Iterator<Entry<Integer, Integer> > iter
= m1.entrySet().iterator();
// Iterating every set of entry in the HashMap
while (iter.hasNext()) {
Map.Entry<Integer, Integer> it
= (Map.Entry<Integer, Integer>)iter.next();
if (it.getValue() == it.getKey())
// Pushing superior numbers
// into vector.
v.add(it.getKey());
}
int hcf = 0 ;
if (v.size() == 0 )
return 0 ;
else if (v.size() == 1 )
return v.get( 0 );
else if (v.size() == 2 ) {
hcf = gcd(v.get( 0 ), v.get( 1 ));
return hcf;
}
else if (v.size() > 2 ) {
hcf = gcd(v.get( 0 ), v.get( 1 ));
for ( int i = 2 ; i < v.size(); i++) {
hcf = gcd(v.get(i), hcf);
}
return hcf;
}
return 1 ;
}
public static void main(String[] args)
{
int N = 10 ;
int arr[] = { 2 , 3 , 4 , 4 , 3 , 5 , 4 , 4 , 2 , 8 };
// Function call
System.out.print(findGcd(arr, N));
}
} // This code is contributed by Rohit Pradhan |
# Python3 code to implement the approach import math
# Function to find GCD def findGcd(arr, n):
v = []
# Declaration of map/dictionary
m1 = dict ()
for i in range (n):
if arr[i] in m1:
m1[arr[i]] + = 1
else :
m1[arr[i]] = 1
for it in m1:
if m1[it] = = it:
v.append(it)
if len (v) = = 0 :
return 0
elif len (v) = = 1 :
return v[ 0 ]
elif len (v) = = 2 :
hcf = math.gcd(v[ 0 ], v[ 1 ])
return hcf
elif len (v) > 2 :
hcf = math.gcd(v[ 0 ], v[ 1 ])
for i in range ( 2 , len (v)):
hcf = math.gcd(hcf, v[i])
return hcf
return 1
# driver code N = 10
arr = [ 2 , 3 , 4 , 4 , 3 , 5 , 4 , 4 , 2 , 8 ]
# function call print (findGcd(arr, N))
# This code is contributed by phasing17. |
// C# code to implement the approach using System;
using System.Collections.Generic;
public class GFG
{ // Function to calculate GCD
public static int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
// Function to find GCD
public static int findGcd( int [] arr, int n)
{
List< int > v = new List< int >();
// Declaration of dictionary
IDictionary< int , int > m1
= new Dictionary< int , int >();
// building the frequency dictionary
for ( int i = 0; i < n; i++) {
if (m1.ContainsKey(arr[i]))
m1[arr[i]] += 1;
else
m1[arr[i]] = 1;
}
// iterating over each entry in m1
// to find which keys have equivalent values
foreach (KeyValuePair< int , int > entry in m1)
{
if (entry.Value == entry.Key)
v.Add(entry.Value);
}
// calculating gcd
int hcf = 0;
if (v.Count == 0)
return 0;
if (v.Count == 1)
return v[0];
if (v.Count == 2) {
hcf = gcd(v[0], v[1]);
return hcf;
}
if (v.Count > 2) {
hcf = gcd(v[0], v[1]);
for ( int i = 2; i < v.Count; i++) {
hcf = gcd(v[i], hcf);
}
return hcf;
}
return 1;
}
// Driver code
public static void Main( string [] args)
{
int N = 10;
int [] arr = { 2, 3, 4, 4, 3, 5, 4, 4, 2, 8 };
// Function call
Console.WriteLine(findGcd(arr, N));
}
} // this code is contributed by phasing17 |
<script> // JavaScript code to implement the approach 'use strict' ;
// Function for calculating gcd function gcd(a, b)
{ if (b == 0)
return a;
return gcd(b, a % b);
} // Function to find GCD function findGcd(arr, n)
{ var v = [];
// Declaration of map
var m1 = {};
for ( var i = 0; i < n; i++)
{
if (m1.hasOwnProperty(arr[i]))
m1[arr[i]] += 1;
else
m1[arr[i]] = 1;
}
//iterating through all the keys of m1
for (const it of Object.keys(m1))
{
if (m1[it] == it)
v.push(it);
}
if (v.length == 0)
return 0;
else if (v.length == 1)
return v[0];
else if (v.length == 2)
{
var hcf = gcd(v[0], v[1]);
return hcf;
}
else if (v.length > 2)
{
var hcf = math.gcd(v[0], v[1]);
for ( var i = 2; i < v.length; i++)
hcf = math.gcd(hcf, v[i]);
return hcf;
}
return 1;
} // driver code var N = 10;
var arr = [2, 3, 4, 4, 3, 5, 4, 4, 2, 8];
// function call document.write(findGcd(arr, N)); // This code is contributed by phasing17. </script> |
2
Time Complexity: time required for finding gcd of all the elements in the vector will be overall time complexity. vector at a time can have maximum number of unique elements from the array.
so
- time needed to find gcd of two elements log(max(two numbers))
- so time required to find gcd of all unique elements will be O(unique elements *log(max(two numbers)))
So time complexity will be O(total unique elements*log(max(both numbers)))
in broader way ,we can say Time Complexity should be O(total number of unique elements* Log(n)) or we can say O(n*log(n)).
Auxiliary Space: O(N)