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

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 ` `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

 ``

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next