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

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)