Skip to content
Related Articles

Related Articles

Improve Article

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

  • Last Updated : 20 Apr, 2021

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 = 4
Output: Yes
Explanation:
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 = 2
Output: 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:

  1. Update the value of N to ⌊N/2⌋ + 10 if N > N/2 + 10 and X > 0.
  2. Update the value of N to N – 10 at most Y times.
  3. Check if the updated value of N is less than equal to 0 or not.
  4. 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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :