Find number formed by K times alternatively reducing X and adding Y to 0
Last Updated :
06 Sep, 2021
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++
#include <bits/stdc++.h>
using namespace std;
int positionAfterKJumps( int X, int Y, int K)
{
int addY = Y * (K / 2);
int reduceX = -1 * X * (K / 2 + K % 2);
return addY + reduceX;
}
int main()
{
int X = 2, Y = 5, K = 3;
cout << positionAfterKJumps(X, Y, K);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int positionAfterKJumps( int X, int Y, int K)
{
int addY = Y * (K / 2 );
int reduceX = - 1 * X * (K / 2 + K % 2 );
return addY + reduceX;
}
public static void main(String[] args) {
int X = 2 , Y = 5 , K = 3 ;
System.out.print(positionAfterKJumps(X, Y, K));
}
}
|
Python3
def positionAfterKJumps(X, Y, K):
addY = Y * (K / / 2 )
reduceX = - 1 * X * (K / / 2 + K % 2 )
return addY + reduceX
X = 2
Y = 5
K = 3
print (positionAfterKJumps(X, Y, K))
|
C#
using System;
class GFG {
static int positionAfterKJumps( int X, int Y, int K)
{
int addY = Y * (K / 2);
int reduceX = -1 * X * (K / 2 + K % 2);
return addY + reduceX;
}
public static void Main(String[] args)
{
int X = 2, Y = 5, K = 3;
Console.WriteLine(positionAfterKJumps(X, Y, K));
}
}
|
Javascript
<script>
function positionAfterKJumps(X, Y, K) {
let addY = Y * Math.floor(K / 2);
let reduceX = -1 * X * (Math.floor(K / 2) + K % 2);
return addY + reduceX;
}
let X = 2, Y = 5, K = 3;
document.write(positionAfterKJumps(X, Y, K));
</script>
|
Time Complexity: O(1)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...