# Reduce N to 0 or less by given X and Y operations

Given three integers **N**, **X, **and **Y, **the task is to check if it is possible to reduce **N** to 0 or less by the following operations:

- Update
**N**to**⌊N/2⌋ + 10,**at most**X**times - Update
**N**to**N – 10,**at most**Y**times.

**Example:**

Input:N = 100, X = 3, Y = 4Output:YesExplanation:

Update N = 100 to ⌊100/2⌋ + 10 = 60.

Update N = 60 to 60 − 10 = 50.

Update N = 50 to ⌊50/2⌋ + 10 = 35.

Update N = 35 to ⌊35/2⌋ + 10 = 27.

Update N = 27 to 27 − 10 = 17.

Update N = 17 to 17 − 10 = 7.

Update N = 7 to 7 − 10 = −3.

Input:N = 50, X = 1, Y = 2Output:No

**Approach:** This problem can be solved based on the following observations:

**Case 1:**If**⌊N/2⌋ + 10 >= N**, then perform only second operation as the first operation will increase the value**N**.**Case 2:**If first operation is performed followed by the second operation then the result is:

Operation 1: N = ⌊N/2⌋ + 10

Operation 2: (⌊N/2⌋ + 10) – 10 = ⌊N/2⌋

- The value of
**N**is reduced to**(⌊N/2⌋)**. **Case 3:**If second operation is performed followed by the first operation then the result is:

Operation 2: N = N – 10

Operation 1: ⌊(N – 10)/2⌋ + 10 = (⌊N/2⌋ – 5 + 10) = (⌊N/2⌋ + 5)

- The value of
**N**is reduced to**(⌊N/2⌋ + 5)**.

From the above two observations, if **N > N/2 +10**, then it can be concluded that, to reduce the value of **N** to** 0** or less, the first operation must be performed before the second operation to decrease the value of **N**.

Follow the steps below to solve the problem:

- Update the value of
**N**to**⌊N/2⌋ + 10**if N > N/2 + 10 and X > 0. - Update the value of
**N**to**N – 10**at most Y times. - Check if the updated value of
**N**is less than equal to 0 or not. - If N ≤ 0, then print
**“Yes”**. Otherwise, print**“No”**.

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if N can be` `// reduced to <= 0 or not` `bool` `NegEqu(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` `// Update N to N/2 + 10 at most X times` ` ` `while` `(X-- and N > N/2 + 10) {` ` ` `N = N / 2 + 10;` ` ` `}` ` ` `// Update N to N - 10 Y times` ` ` `while` `(Y--) {` ` ` `N = N - 10;` ` ` `}` ` ` `if` `(N <= 0)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 100;` ` ` `int` `X = 3;` ` ` `int` `Y = 4;` ` ` `if` `(NegEqu(N, X, Y)) {` ` ` `cout << ` `"Yes"` `;` ` ` `}` ` ` `else` `{` ` ` `cout << ` `"No"` `;` ` ` `}` `}` |

## Java

`// Java program to implement` `// the above approach` `class` `GFG{` `// Function to check if N can be` `// reduced to <= 0 or not` `static` `boolean` `NegEqu(` `int` `N, ` `int` `X, ` `int` `Y)` `{` ` ` ` ` `// Update N to N/2 + 10 at most X times` ` ` `while` `(X > ` `0` `&& (N > N / ` `2` `+ ` `10` `))` ` ` `{` ` ` `N = N / ` `2` `+ ` `10` `;` ` ` `X -= ` `1` `;` ` ` `}` ` ` `// Update N to N - 10 Y times` ` ` `while` `(Y > ` `0` `)` ` ` `{` ` ` `N = N - ` `10` `;` ` ` `Y -= ` `1` `;` ` ` `}` ` ` `if` `(N <= ` `0` `)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `100` `;` ` ` `int` `X = ` `3` `;` ` ` `int` `Y = ` `4` `;` ` ` `if` `(NegEqu(N, X, Y))` ` ` `{` ` ` `System.out.println(` `"Yes"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `System.out.println(` `"No"` `);` ` ` `}` `}` `}` `// This code is contributed by jana_sayantan` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to check if N can be` `# reduced to <= 0 or not` `def` `NegEqu(N, X, Y):` ` ` `# Update N to N/2 + 10 at most X times` ` ` `while` `(X ` `and` `N > N ` `/` `/` `2` `+` `10` `):` ` ` `N ` `=` `N ` `/` `/` `2` `+` `10` ` ` `X ` `-` `=` `1` ` ` `# Update N to N - 10 Y times` ` ` `while` `(Y):` ` ` `N ` `=` `N ` `-` `10` ` ` `Y ` `-` `=` `1` ` ` `if` `(N <` `=` `0` `):` ` ` `return` `True` ` ` `return` `False` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `N ` `=` `100` ` ` `X ` `=` `3` ` ` `Y ` `=` `4` ` ` `if` `(NegEqu(N, X, Y)):` ` ` `print` `(` `"Yes"` `)` ` ` `else` `:` ` ` `print` `(` `"No"` `)` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `// Function to check if N can be` `// reduced to <= 0 or not` `public` `static` `bool` `NegEqu(` `int` `N, ` `int` `X,` ` ` `int` `Y)` `{` ` ` ` ` `// Update N to N/2 + 10 at most X times` ` ` `while` `(X > 0 && (N > N / 2 + 10))` ` ` `{` ` ` `N = N / 2 + 10;` ` ` `X -= 1;` ` ` `}` ` ` `// Update N to N - 10 Y times` ` ` `while` `(Y > 0)` ` ` `{` ` ` `N = N - 10;` ` ` `Y -= 1;` ` ` `}` ` ` `if` `(N <= 0)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` ` ` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `N = 100;` ` ` `int` `X = 3;` ` ` `int` `Y = 4;` ` ` `if` `(NegEqu(N, X, Y))` ` ` `{` ` ` `Console.WriteLine(` `"Yes"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `Console.WriteLine(` `"No"` `);` ` ` `}` `}` `}` `// This code is contributed by jana_sayantan` |

## Javascript

`<script>` `// JavaScript implementation of the above approach` `// Function to check if N can be` `// reduced to <= 0 or not` `function` `NegEqu(N, X, Y)` `{` ` ` ` ` `// Update N to N/2 + 10 at most X times` ` ` `while` `(X > 0 && (N > N / 2 + 10))` ` ` `{` ` ` `N = N / 2 + 10;` ` ` `X -= 1;` ` ` `}` ` ` ` ` `// Update N to N - 10 Y times` ` ` `while` `(Y > 0)` ` ` `{` ` ` `N = N - 10;` ` ` `Y -= 1;` ` ` `}` ` ` ` ` `if` `(N <= 0)` ` ` `return` `true` `;` ` ` ` ` `return` `false` `;` `}` `// Driver code` ` ` ` ` `let N = 100;` ` ` `let X = 3;` ` ` `let Y = 4;` ` ` ` ` `if` `(NegEqu(N, X, Y))` ` ` `{` ` ` `document.write(` `"Yes"` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `document.write(` `"No"` `);` ` ` `}` ` ` ` ` `// This code is contributed by code_hunt.` `</script>` |

**Output:**

Yes

** Time Complexity: **O(X + Y)

**Auxiliary Space**:O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.