Open In App

Find two co-prime integers such that the first divides A and the second divides B

Improve
Improve
Like Article
Like
Save
Share
Report

Given two integers A and B, the task is to find two co-prime numbers C1 and C2 such that C1 divides A and C2 divides B.
Examples: 
 

Input: A = 12, B = 16 
Output: 3 4 
12 % 3 = 0 
16 % 4 = 0 
gcd(3, 4) = 1
Input: A = 542, B = 762 
Output: 271 381 
 

 

Naive approach: A simple solution is to store all of the divisors of A and B then iterate over all the divisors of A and B pairwise to find the pair of elements which are co-prime.
Efficient approach: If an integer d divides gcd(a, b) then gcd(a / d, b / d) = gcd(a, b) / d. More formally, if num = gcd(a, b) then gcd(a / num, b / num) = 1 i.e. (a / num) and (b / num) are relatively co-prime. 
So in order to find the required numbers, find gcd(a, b) and store it in a variable gcd. Now the required numbers will be (a / gcd) and (b / gcd).
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required numbers
void findNumbers(int a, int b)
{
 
    // GCD of the given numbers
    int gcd = __gcd(a, b);
 
    // Printing the required numbers
    cout << (a / gcd) << " " << (b / gcd);
}
 
// Driver code
int main()
{
    int a = 12, b = 16;
 
    findNumbers(a, b);
 
    return 0;
}


Java




// Java implementation of the approach
import java.math.*;
 
class GFG
{
    public static int findGCD(int a, int b)
    {
        if(b == 0)
            return a;
        else
            return findGCD(b, a % b);
    }
 
    // Function to find the required numbers
    static void findNumbers(int a, int b)
    {
     
        // GCD of the given numbers
        int gcd = findGCD(a, b);
         
        // Printing the required numbers
        System.out.println((a / gcd) + " " +
                           (b / gcd));
         
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a = 12, b = 16;
     
        findNumbers(a, b);
    }
}
 
// This code is contributed by Naman_Garg


Python3




# Python3 implementation of the approach
 
# import gcd function from math module
from math import gcd
 
# Function to find the required numbers
def findNumbers(a, b) :
 
    # GCD of the given numbers
    __gcd = gcd(a, b);
 
    # Printing the required numbers
    print((a // __gcd), (b // __gcd));
 
# Driver code
if __name__ == "__main__" :
 
    a = 12; b = 16;
 
    findNumbers(a, b);
 
# This code is contributed by AnkitRai01


C#




// C# implementation of the approach
using System;
 
class GFG
{
    public static int findGCD(int a, int b)
    {
        if(b == 0)
            return a;
        else
            return findGCD(b, a % b);
    }
 
    // Function to find the required numbers
    static void findNumbers(int a, int b)
    {
     
        // GCD of the given numbers
        int gcd = findGCD(a, b);
         
        // Printing the required numbers
        Console.Write((a / gcd) + " " +
                      (b / gcd));
         
    }
 
    // Driver code
    static public void Main ()
    {
        int a = 12, b = 16;
     
        findNumbers(a, b);
    }
}
 
// This code is contributed by ajit


Javascript




<script>
 
// Javascript implementation of the approach
 
function findGCD(a, b)
{
    if (b == 0)
        return a;
    else
        return findGCD(b, a % b);
}
 
// Function to find the required numbers
function findNumbers(a, b)
{
     
    // GCD of the given numbers
    var gcd = findGCD(a, b);
     
    // Printing the required numbers
    document.write((a / gcd) + " " +
                   (b / gcd));
}
 
// Driver Code
var a = 12, b = 16;
     
findNumbers(a, b);
 
// This code is contributed by Khushboogoyal499
     
</script>


Output

3 4






Time Complexity: O(log(min(a, b))), where a and b are the two parameters of __gcd

Auxiliary Space: O(log(min(a, b)))

Approach:  Use the Euclidean algorithm, which uses recursion to find the GCD of two numbers.

Algorithm steps:

  • Set two variables, x and y, to the values of a and b respectively.
  • While y is not equal to 0, do the following:
    a. Set a to the value of b.
    b. Set b to the remainder of x divided by y.
    c. Set x to the value of y.
    d. Set y to the remainder of a divided by b.
  • Return the value of x, which is the GCD of a and b.

Below is the implementation of the above approach:

C++




//C++ code for the above approach
#include <iostream>
using namespace std;
 
// Function to find the GCD of two numbers
int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}
 
// Function to find the required numbers
void findNumbers(int a, int b) {
    // Find the GCD of the given numbers
    int gcd_ab = gcd(a, b);
 
    // Divide a and b by their GCD
    int num1 = a / gcd_ab;
    int num2 = b / gcd_ab;
 
    // Print the required numbers
    cout << num1 << " " << num2;
}
 
// Driver code
int main() {
    int a = 12, b = 16;
    findNumbers(a, b);
    return 0;
}


Java




import java.util.*;
 
public class GFG {
    // Function to find the GCD of two numbers
    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }
 
    // Function to find the required numbers
    public static void findNumbers(int a, int b) {
        // Find the GCD of the given numbers
        int gcd_ab = gcd(a, b);
 
        // Divide a and b by their GCD
        int num1 = a / gcd_ab;
        int num2 = b / gcd_ab;
 
        // Print the required numbers
        System.out.println(num1 + " " + num2);
    }
 
    // Driver code
    public static void main(String[] args) {
        int a = 12, b = 16;
        findNumbers(a, b);
    }
}


Python3




# Function to find the GCD of two numbers
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)
 
# Function to find the required numbers
def findNumbers(a, b):
    # Find the GCD of the given numbers
    gcd_ab = gcd(a, b)
 
    # Divide a and b by their GCD
    num1 = a // gcd_ab
    num2 = b // gcd_ab
 
    # Print the required numbers
    print(num1, num2)
 
# Driver code
def main():
    a = 12
    b = 16
    findNumbers(a, b)
 
if __name__ == "__main__":
    main()


C#




using System;
 
namespace GCDExample
{
    class Program
    {
        // Function to find the GCD of two numbers
        static int GCD(int a, int b)
        {
            if (b == 0)
            {
                return a;
            }
            return GCD(b, a % b);
        }
 
        // Function to find the required numbers
        static void FindNumbers(int a, int b)
        {
            // Find the GCD of the given numbers
            int gcd_ab = GCD(a, b);
 
            // Divide a and b by their GCD
            int num1 = a / gcd_ab;
            int num2 = b / gcd_ab;
 
            // Print the required numbers
            Console.WriteLine(num1 + " " + num2);
        }
 
        // Driver code
        static void Main(string[] args)
        {
            int a = 12, b = 16;
            FindNumbers(a, b);
        }
    }
}


Javascript




// Function to find the GCD of two numbers
function gcd(a, b) {
    if (b === 0) {
        return a;
    }
    return gcd(b, a % b);
}
 
// Function to find the required numbers
function findNumbers(a, b) {
    // Find the GCD of the given numbers
    const gcd_ab = gcd(a, b);
 
    // Divide a and b by their GCD
    const num1 = a / gcd_ab;
    const num2 = b / gcd_ab;
 
    // Print the required numbers
    console.log(num1 + " " + num2);
}
 
// Driver code
const a = 12, b = 16;
findNumbers(a, b);


Output

3 4






Time Complexity:  O(n), where n is the maximum of the given two numbers a and b, because we are iterating over a range of numbers from 1 to the maximum of the two numbers.

Auxiliary Space:  O(1), because we are not using any additional space to store variables or data structures in the program.



Last Updated : 04 Oct, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads