# Check if N and M can be made equal by increasing N by A and decreasing M by B

Given four numbers **M**, **N**, **A** and **B**, the task is to check whether **M** and **N** can be made equal to each other by doing any of the below operations:

**M**can be increased by**A**and**N**can be decreased by**B**- Leave both of them as it is.

**Examples:**

Input:M = 2, N = 8, A = 3, B = 3Output:YesExplanation:

After first Operation:

M can be increased by A. Therefore, M = 2 + 3 = 5

N can be decreased by B. Therefore, N = 8 – 3 = 5

Finally, M = N = 5.

Input:M = 6, N = 4, A = 2, B = 1Output:No

**Approach:** On careful observation, it can be observed that since we are increasing M and decreasing N, they can be made equal only when M is less than N. Therefore when M is less than N, there are two cases at each step:

- M can be increased by A and N can be decreased by B.
- Leave both of them as it is.

Another observation which can be made is that when **M** is increased and **N** is decreased, the absolute distance between **M** and **N** is reduced by the factor of **A + B**. For example:

Let M = 2, N = 14, A = 3 and B = 3.

- In step 1, M = 5 and N = 11. The absolute distance between M and N got reduced by 6. That is, initially, the absolute distance was 12(14 – 2). After performing the given step, the absolute distance became 6(11 – 5).
- In step 2, M = 8 and N = 8. The absolute distance between M and N again got reduced by 6 thereby making M and N equal.

From the above example, we can come to the conclusion that this problem can be solved in a constant time only by checking if the absolute distance between **M** and **N** is a multiple of **(A + B)** or not.

- If it is a multiple, then M and N can be made equal.
- Else, they cannot be made equal.

Below is the implementation of the above approach:

## C++

`// C++ program to check if two numbers` `// can be made equal by increasing` `// the first by a and decreasing` `// the second by b` ` ` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Function to whether the numbers` `// can be made equal or not` `bool` `checkEqualNo(` `int` `m, ` `int` `n, ` `int` `a, ` `int` `b)` `{` ` ` `if` `(m <= n) {` ` ` ` ` `// Check whether the numbers can reach` ` ` `// an equal point or not` ` ` `if` `((n - m) % (a + b) == 0) {` ` ` `return` `true` `;` ` ` `}` ` ` `else` `{` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` `else` `{` ` ` ` ` `// M and N cannot be made equal by` ` ` `// increasing M and decreasing N when` ` ` `// M is already greater than N` ` ` `return` `false` `;` ` ` `}` `}` ` ` `// Driver code` `int` `main()` `{` ` ` `int` `M = 2, N = 8;` ` ` `int` `A = 3, B = 3;` ` ` ` ` `if` `(checkEqualNo(M, N, A, B)) ` ` ` `cout << ` `"Yes"` `<< endl;` ` ` `else` ` ` `cout << ` `"No"` `<< endl;` ` ` `return` `0;` `}` |

## Java

`// Java program to check if two numbers` `// can be made equal by increasing` `// the first by a and decreasing` `// the second by b` `class` `GFG ` `{` ` ` ` ` `// Function to whether the numbers` ` ` `// can be made equal or not` ` ` `static` `boolean` `checkEqualNo(` `int` `m, ` `int` `n, ` `int` `a, ` `int` `b)` ` ` `{` ` ` `if` `(m <= n) {` ` ` ` ` `// Check whether the numbers can reach` ` ` `// an equal point or not` ` ` `if` `((n - m) % (a + b) == ` `0` `) {` ` ` `return` `true` `;` ` ` `}` ` ` `else` `{` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` `else` `{` ` ` ` ` `// M and N cannot be made equal by` ` ` `// increasing M and decreasing N when` ` ` `// M is already greater than N` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `int` `M = ` `2` `, N = ` `8` `;` ` ` `int` `A = ` `3` `, B = ` `3` `;` ` ` ` ` `if` `(checkEqualNo(M, N, A, B) == ` `true` `) ` ` ` `System.out.println(` `"Yes"` `);` ` ` `else` ` ` `System.out.println(` `"No"` `);` ` ` ` ` `}` `}` ` ` `// This code is contributed by Yash_R` |

## Python3

`# Python3 program to check if two numbers` `# can be made equal by increasing` `# the first by a and decreasing` `# the second by b` ` ` `# Function to whether the numbers` `# can be made equal or not` `def` `checkEqualNo(m, n, a, b) :` ` ` `if` `(m <` `=` `n) :` ` ` ` ` `# Check whether the numbers can reach` ` ` `# an equal point or not` ` ` `if` `((n ` `-` `m) ` `%` `(a ` `+` `b) ` `=` `=` `0` `) :` ` ` `return` `True` `;` ` ` ` ` `else` `:` ` ` `return` `False` `;` ` ` ` ` `else` `:` ` ` ` ` `# M and N cannot be made equal by` ` ` `# increasing M and decreasing N when` ` ` `# M is already greater than N` ` ` `return` `False` `;` ` ` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `M ` `=` `2` `; N ` `=` `8` `;` ` ` `A ` `=` `3` `; B ` `=` `3` `;` ` ` ` ` `if` `(checkEqualNo(M, N, A, B)) :` ` ` `print` `(` `"Yes"` `);` ` ` `else` `:` ` ` `print` `(` `"No"` `);` ` ` `# This code is contributed by Yash_R` |

## C#

`// C# program to check if two numbers` `// can be made equal by increasing` `// the first by a and decreasing` `// the second by b` `using` `System;` ` ` `class` `GFG ` `{` ` ` ` ` `// Function to whether the numbers` ` ` `// can be made equal or not` ` ` `static` `bool` `checkEqualNo(` `int` `m, ` `int` `n, ` `int` `a, ` `int` `b)` ` ` `{` ` ` `if` `(m <= n) {` ` ` ` ` `// Check whether the numbers can reach` ` ` `// an equal point or not` ` ` `if` `((n - m) % (a + b) == 0) {` ` ` `return` `true` `;` ` ` `}` ` ` `else` `{` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` `else` `{` ` ` ` ` `// M and N cannot be made equal by` ` ` `// increasing M and decreasing N when` ` ` `// M is already greater than N` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main (String[] args)` ` ` `{` ` ` `int` `M = 2;` ` ` `int` `N = 8;` ` ` `int` `A = 3;` ` ` `int` `B = 3;` ` ` ` ` `if` `(checkEqualNo(M, N, A, B) == ` `true` `) ` ` ` `Console.WriteLine(` `"Yes"` `);` ` ` `else` ` ` `Console.WriteLine(` `"No"` `);` ` ` `}` `}` ` ` `// This code is contributed by Yash_R` |

**Output:**

Yes

Attention reader! Don’t stop learning now. Participate in the **Scholorship Test for First-Step-to-DSA Course for Class 9 to 12 students**.