Given two integers **A** and **B**. the task is to find the minimum number of operations required to make A and B equal. In each operation, either of the below steps can be performed:

- Increment either A or B with its initial value.
- Increment both A and B with their initial value

**Examples:**

Input:A = 4, B = 10Output:4Explanation:

Initially A = 4, B = 10

Operation 1: Increment A only: A = A + 4 = 8

Operation 2: Increment A only: A = A + 4 = 12

Operation 3: Increment A only: A = A + 4 = 16

Operation 4: Increment A and B: A = A + 4 = 20 and B = B + 10 = 20

They are equal now.Input:A = 7, B = 23Output:22Explanation:

Initially A = 7, B = 23

Operation 1 – 7: Increment A and B: A = 56 and B = 161

Operation 8 – 22: Increment A: A = 161 and B = 161

They are equal now.

**Approach:** This problem can be solved using GCD.

- If A is greater than B, then swap A and B.
- Now reduce B, such that gcd of A and B becomes 1.
- Hence the minimum operations required to reach equal value is (B – 1).

**For example:** If A = 4, B = 10:

*Step 1:*Compare 4 and 10, as we always need B as the greater value. Here already B is greater than A. So, now no swap is required.*Step 2:*GCD(4, 10) = 2. So, we reduce B to B/2. Now A = 4 and B = 5.

GCD(4, 5) = 1, which was the target.*Step 3:*(Current value of B – 1) will be the required count. Here, Current B = 5. So (5 – 1 = 4), i.e. total 4 operations are required.

Below is the implementation of the above approach.

## C++

`// C++ program to find minimum` `// operations required to` `// make two numbers equal` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the` `// minimum operations required` `long` `long` `int` `minOperations(` ` ` `long` `long` `int` `A,` ` ` `long` `long` `int` `B)` `{` ` ` `// Keeping B always greater` ` ` `if` `(A > B)` ` ` `swap(A, B);` ` ` `// Reduce B such that` ` ` `// gcd(A, B) becomes 1.` ` ` `B = B / __gcd(A, B);` ` ` `return` `B - 1;` `}` `// Driver code` `int` `main()` `{` ` ` `long` `long` `int` `A = 7, B = 15;` ` ` `cout << minOperations(A, B)` ` ` `<< endl;` ` ` `return` `0;` `}` |

## Java

`// Java program to find minimum` `// operations required to` `// make two numbers equal` `class` `GFG{` ` ` `// Function to return the` `// minimum operations required` `static` `int` `minOperations(` ` ` `int` `A,` ` ` `int` `B)` `{` ` ` ` ` `// Keeping B always greater` ` ` `if` `(A > B) {` ` ` `A = A+B;` ` ` `B = A-B;` ` ` `A = A-B;` ` ` `}` ` ` ` ` `// Reduce B such that` ` ` `// gcd(A, B) becomes 1.` ` ` `B = B / __gcd(A, B);` ` ` ` ` `return` `B - ` `1` `;` `}` `static` `int` `__gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `return` `b == ` `0` `? a:__gcd(b, a % b); ` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A = ` `7` `, B = ` `15` `;` ` ` ` ` `System.out.print(minOperations(A, B)` ` ` `+` `"\n"` `);` ` ` `}` `}` `// This code contributed by sapnasingh4991` |

## Python3

`# Python program to find minimum` `# operations required to` `# make two numbers equal` `import` `math` `# Function to return the` `# minimum operations required` `def` `minOperations(A, B):` ` ` `# Keeping B always greater` ` ` `if` `(A > B):` ` ` `swap(A, B)` ` ` `# Reduce B such that` ` ` `# gcd(A, B) becomes 1.` ` ` `B ` `=` `B ` `/` `/` `math.gcd(A, B);` ` ` `return` `B ` `-` `1` `# Driver code` `A ` `=` `7` `B ` `=` `15` `print` `(minOperations(A, B))` `# This code is contributed by Sanjit_Prasad` |

## C#

`// C# program to find minimum` `// operations required to` `// make two numbers equal` `using` `System;` `class` `GFG{` ` ` `// Function to return the` `// minimum operations required` `static` `int` `minOperations(` ` ` `int` `A,` ` ` `int` `B)` `{` ` ` ` ` `// Keeping B always greater` ` ` `if` `(A > B) {` ` ` `A = A+B;` ` ` `B = A-B;` ` ` `A = A-B;` ` ` `}` ` ` ` ` `// Reduce B such that` ` ` `// gcd(A, B) becomes 1.` ` ` `B = B / __gcd(A, B);` ` ` ` ` `return` `B - 1;` `}` `static` `int` `__gcd(` `int` `a, ` `int` `b) ` `{ ` ` ` `return` `b == 0? a:__gcd(b, a % b); ` `}` ` ` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `A = 7, B = 15;` ` ` ` ` `Console.Write(minOperations(A, B)` ` ` `+` `"\n"` `);` `}` `}` `// This code is contributed by sapnasingh4991` |

## Javascript

`<script>` `// javascript program to find minimum` `// operations required to` `// make two numbers equal ` `// Function to return the` ` ` `// minimum operations required` ` ` `function` `minOperations(A, B)` `{` ` ` `// Keeping B always greater` ` ` `if` `(A > B) {` ` ` `A = A + B;` ` ` `B = A - B;` ` ` `A = A - B;` ` ` `}` ` ` `// Reduce B such that` ` ` `// gcd(A, B) becomes 1.` ` ` `B = B / __gcd(A, B);` ` ` `return` `B - 1;` ` ` `}` ` ` `function` `__gcd(a , b) {` ` ` `return` `b == 0 ? a : __gcd(b, a % b);` ` ` `}` ` ` `// Driver code` ` ` `var` `A = 7, B = 15;` ` ` `document.write(minOperations(A, B) + ` `"\n"` `);` `// This code is contributed by Rajput-Ji` `</script>` |

**Output:**

14

**Time Complexity:** O(log(max(A, B))

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