Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximum GCD among all pairs (i, j) of first N natural numbers

  • Last Updated : 20 Apr, 2021

Given a positive integer N > 1, the task is to find the maximum GCD among all the pairs (i, j) such that i < j < N.
Examples:

Input: N = 3
Output: 3
Explanation:
All the possible pairs are: (1, 2) (1, 3) (2, 3) with GCD 1.
Input: N = 4
Output: 2
Explanation:
Out of all the possible pairs the pair with max GCD is (2, 4) with a value 2.

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.

Naive Approach: Generate all possible pair of integers from the range [1, N] and calculate GCD of all pairs. Finally, print the maximum GCD obtained.

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 maximum gcd
// of all pairs possible from
// first n natural numbers
int maxGCD(int n)
{
    // Stores maximum gcd
    int maxHcf = INT_MIN;
 
    // Iterate over all possible pairs
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
 
            // Update maximum GCD
            maxHcf
                = max(maxHcf, __gcd(i, j));
        }
    }
 
    return maxHcf;
}
 
// Driver Code
int main()
{
    int n = 4;
    cout << maxGCD(n);
 
    return 0;
}
Java



// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to find maximum gcd
// of all pairs possible from
// first n natural numbers
static int maxGCD(int n)
{
  // Stores maximum gcd
  int maxHcf = Integer.MIN_VALUE;
 
  // Iterate over all possible pairs
  for (int i = 1; i <= n; i++)
  {
    for (int j = i + 1; j <= n; j++)
    {
      // Update maximum GCD
      maxHcf = Math.max(maxHcf,
                        __gcd(i, j));
    }
  }
 
  return maxHcf;
}
   
static int __gcd(int a, int b) 
{ 
  return b == 0 ? a :
         __gcd(b, a % b);    
}
   
// Driver Code
public static void main(String[] args)
{
  int n = 4;
  System.out.print(maxGCD(n));
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 program for
# the above approach
def __gcd(a, b):
    if(b == 0):
        return a;
    else:
        return __gcd(b, a % b);
 
# Function to find maximum gcd
# of all pairs possible from
# first n natural numbers
def maxGCD(n):
   
    # Stores maximum gcd
    maxHcf = -2391734235435;
 
    # Iterate over all possible pairs
    for i in range(1, n + 1):
        for j in range(i + 1, n + 1):
           
            # Update maximum GCD
            maxHcf = max(maxHcf, __gcd(i, j));
    return maxHcf;
 
# Driver Code
if __name__ == '__main__':
    n = 4;
    print(maxGCD(n));
 
# This code is contributed by gauravrajput1
C#



// C# program for
// the above approach
using System;
class GFG{
 
// Function to find maximum gcd
// of all pairs possible from
// first n natural numbers
static int maxGCD(int n)
{
  // Stores maximum gcd
  int maxHcf = int.MinValue;
 
  // Iterate over all possible pairs
  for (int i = 1; i <= n; i++)
  {
    for (int j = i + 1; j <= n; j++)
    {
      // Update maximum GCD
      maxHcf = Math.Max(maxHcf,
                        __gcd(i, j));
    }
  }
 
  return maxHcf;
}
   
static int __gcd(int a, int b) 
{ 
  return b == 0 ? a :
         __gcd(b, a % b);    
}
   
// Driver Code
public static void Main(String[] args)
{
  int n = 4;
  Console.Write(maxGCD(n));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
// javascript program for
// the above approach
 
    // Function to find maximum gcd
    // of all pairs possible from
    // first n natural numbers
    function maxGCD(n) {
        // Stores maximum gcd
        var maxHcf = Number.MIN_VALUE;
 
        // Iterate over all possible pairs
        for (i = 1; i <= n; i++) {
            for (j = i + 1; j <= n; j++) {
                // Update maximum GCD
                maxHcf = Math.max(maxHcf, __gcd(i, j));
            }
        }
 
        return maxHcf;
    }
 
    function __gcd(a , b) {
        return b == 0 ? a : __gcd(b, a % b);
    }
 
    // Driver Code
     
        var n = 4;
        document.write(maxGCD(n));
 
// This code contributed by umadevi9616
</script>
Output: 
2
Time Complexity: O(N 2 log N) 
Auxiliary Space: O(1)
Efficient Approach: The GCD of N and N / 2 is N / 2 which is the maximum of all GCDs possible for any pair from 1 to N.
Below is the implementation of the above approach:
C++



// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum GCD
// among all the pairs from
// first n natural numbers
int maxGCD(int n)
{
 
    // Return max GCD
    return (n / 2);
}
 
// Driver Code
int main()
{
    int n = 4;
    cout << maxGCD(n);
 
    return 0;
}
Java



// Java implementation of the above approach
class GFG{
 
// Function to find the maximum GCD
// among all the pairs from
// first n natural numbers
static int maxGCD(int n)
{
     
    // Return max GCD
    return (n / 2);
}
 
// Driver code
public static void main(String[] args)
{
    int n = 4;
 
    System.out.print(maxGCD(n));
}
}
 
// This code is contributed by Dewanti
Python3



# Python3 implementation of the
# above approach
 
# Function to find the maximum GCD
# among all the pairs from first n
# natural numbers
def maxGCD(n):
 
    # Return max GCD
    return (n // 2);
 
# Driver code
if __name__ == '__main__':
     
    n = 4;
 
    print(maxGCD(n));
 
# This code is contributed by Amit Katiyar
C#



// C# implementation of
// the above approach
using System;
class GFG{
 
// Function to find the maximum GCD
// among all the pairs from
// first n natural numbers
static int maxGCD(int n)
{
  // Return max GCD
  return (n / 2);
}
 
// Driver code
public static void Main(String[] args)
{
  int n = 4;
  Console.Write(maxGCD(n));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript implementation of the above approach
 
// Function to find the maximum GCD
// among all the pairs from
// first n natural numbers
function maxGCD(n)
{
 
    // Return max GCD
    return parseInt(n / 2);
}
 
// Driver Code
var n = 4;
document.write( maxGCD(n));
 
// This code is contributed by rrrtnx.
</script>
Output: 
2
Time Complexity: O(1)
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Product of all numbers up to N that are co-prime with N
Next

Maximize length of subarray of equal elements by performing at most K increment operations
Recommended Articles
Page :
Maximum LCM among all pairs (i, j) of first N natural numbers
23, Oct 19
Pair of integers having least GCD among all given pairs having GCD exceeding K
16, Sep 20
Modify sequence of first N natural numbers to a given array by replacing pairs with their GCD
02, Dec 20
Print N lines of 4 numbers such that every pair among 4 numbers has a GCD K
27, Oct 18
Count pairs of natural numbers with GCD equal to given number
25, Jan 17
Kth element in permutation of first N natural numbers having all even numbers placed before odd numbers in increasing order
03, Mar 21
Minimum LCM and GCD possible among all possible sub-arrays
25, Feb 19
Minimum and Maximum LCM among all pairs (i, j) in range [L, R]
28, Oct 21
Number of pairs from the first N natural numbers whose sum is divisible by K
12, Mar 19
Count of pairs with sum N from first N natural numbers
15, Jul 20
Minimize product of first N - 1 natural numbers by swapping same positioned bits of pairs
16, Oct 20
Sort a permutation of first N Natural Numbers by swapping pairs satisfying given conditions
09, Jun 21
Count of pairs from first N natural numbers with remainder at least K
03, Aug 21
Permutation of first N natural numbers having product of Bitwise AND of adjacent pairs exceeding 0
15, Jan 21
Split N natural numbers into two sets having GCD of their sums greater than 1
06, May 20
Find the permutation of first N natural numbers such that sum of i % Pi is maximum possible
26, Sep 19
Permutation of first N natural numbers having given array as the prefix maximum array
23, Mar 21
Maximum set of number from the first N natural numbers whose Bitwise AND is positive
21, Oct 21
Find maximum N such that the sum of square of first N natural numbers is not more than X
13, Mar 19
Bitwise XOR of first N natural numbers that are product of two distinct Prime Numbers
03, Jun 21
Minimize sum of numbers required to convert an array into a permutation of first N natural numbers
14, Jun 21
Count all possible values of K less than Y such that GCD(X, Y) = GCD(X+K, Y)
13, Jan 21
Sum of bit differences among all pairs
06, Oct 15
Print all increasing sequences of length k from first n natural numbers
17, Oct 14
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
spp____
@spp____
Vote for difficulty





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!