Skip to content
Related Articles
Open in App
Not now

Related Articles

Find number formed by K times alternatively reducing X and adding Y to 0

Improve Article
Save Article
  • Last Updated : 06 Sep, 2021
Improve Article
Save Article

Given three positive integers K, X, and Y, the task is to find the number formed by alternatively subtracting X and adding Y to 0 total K number of times.

Examples:

Input: X = 2, Y = 5, K = 3
Output: 1
Explanation:
Following are the operations perform K(= 3) number of times on 0:
Operation 1: Reduce the value 0 by X(= 2) modifies it to 0 – 2 = 2.
Operation 2: Increment the value -2 by Y(= 5) modifies it to -2 + 5 = 3.
Operation 3: Reduce the value 3 by X(= 2) modifies it to 3 – 2 = 1.
The value obtained after modifying the value is 1.

Input: X = 1, Y = 100, K = 4
Output: 198

Naive Approach: The given problem can be solved by performing the given operations K number of times and print the result obtained.

Time Complexity: O(K)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by finding the total value that is decremented(using the value of X) and incremented(using the value of Y) in K number of moves and then print the sum of these values as the result.

The value that must be added to the result is calculated by:

addY = Y*(K/2)
where, K/2 number of times addition operation is performed.

The value that must be subtracted to the result is calculated by:

addY = Y*(K/2 + K&1)
where, K/2 number of times subtraction operation is performed if the number of operation is odd, then additional subtraction is performed.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the value obtained
// after alternatively reducing X and
// adding Y to 0 total K number of times
int positionAfterKJumps(int X, int Y, int K)
{
    // Stores the final result after
    // adding only Y to 0
    int addY = Y * (K / 2);
 
    // Stores the final number after
    // reducing only X from 0
    int reduceX = -1 * X * (K / 2 + K % 2);
 
    // Return the result obtained
    return addY + reduceX;
}
 
// Driver Code
int main()
{
    int X = 2, Y = 5, K = 3;
    cout << positionAfterKJumps(X, Y, K);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG {
 
    // Function to find the value obtained
    // after alternatively reducing X and
    // adding Y to 0 total K number of times
    static int positionAfterKJumps(int X, int Y, int K)
    {
       
        // Stores the final result after
        // adding only Y to 0
        int addY = Y * (K / 2);
 
        // Stores the final number after
        // reducing only X from 0
        int reduceX = -1 * X * (K / 2 + K % 2);
 
        // Return the result obtained
        return addY + reduceX;
    }
 
    // Driver Code
    public static void main(String[] args) {
         
        int X = 2, Y = 5, K = 3;
        System.out.print(positionAfterKJumps(X, Y, K));
    }
}
 
// This code is contributed by code_hunt.

Python3




# Python program for the above approach
 
# Function to find the value obtained
# after alternatively reducing X and
# adding Y to 0 total K number of times
def positionAfterKJumps(X, Y, K):
   
    # Stores the final result after
    # adding only Y to 0
    addY = Y * (K // 2)
 
    # Stores the final number after
    # reducing only X from 0
    reduceX = -1 * X * (K // 2 + K % 2)
 
   # Return the result obtained
    return addY + reduceX
 
# Driver Code
X = 2
Y = 5
K = 3
print(positionAfterKJumps(X, Y, K))
 
# This code is contributed by subhammahato348.

C#




// C# program for the above approach
using System;
class GFG {
 
    // Function to find the value obtained
    // after alternatively reducing X and
    // adding Y to 0 total K number of times
    static int positionAfterKJumps(int X, int Y, int K)
    {
       
        // Stores the final result after
        // adding only Y to 0
        int addY = Y * (K / 2);
 
        // Stores the final number after
        // reducing only X from 0
        int reduceX = -1 * X * (K / 2 + K % 2);
 
        // Return the result obtained
        return addY + reduceX;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int X = 2, Y = 5, K = 3;
        Console.WriteLine(positionAfterKJumps(X, Y, K));
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to find the value obtained
        // after alternatively reducing X and
        // adding Y to 0 total K number of times
        function positionAfterKJumps(X, Y, K) {
            // Stores the final result after
            // adding only Y to 0
            let addY = Y * Math.floor(K / 2);
 
            // Stores the final number after
            // reducing only X from 0
            let reduceX = -1 * X * (Math.floor(K / 2) + K % 2);
 
            // Return the result obtained
            return addY + reduceX;
        }
 
        // Driver Code
 
        let X = 2, Y = 5, K = 3;
        document.write(positionAfterKJumps(X, Y, K));
 
// This code is contributed by Potta Lokesh
    </script>

 
 

Output: 

1

 

 

Time Complexity: O(1)
Auxiliary Space: O(1)

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!