# Minimum steps in which N can be obtained using addition or subtraction at every step

Given N, print the sequence of a minimum number of steps in which N can be obtained starting from 0 using addition or subtraction of the step number.

**Note**: At each step we can add or subtract a number equal to the step number from the current position. For example, at step 1 we can add 1 or -1. Similarily at step 2 we add 2 or -2 and so on.

Below diagram shows all possible positions that can be reached from 0 in 3 steps by performing the specified operations.

**Examples : **

Input: n = -4 Output: Minimum number of Steps: 3 Step sequence: 1 -2 -3Explanation: Step 1: At step 1 we add 1 to move from 0 to 1. Step 2: At step 2 we add (-2) to move from 1 to -1. Step 3: At step 3 we add (-3) to move from -1 to -4. Input: n = 11 Output: Minimum number of steps = 4 Step sequence: 1 -2 3 4 5

**Approach:** The approach to solve the above problem is to mark the step numbers where we have to subtract or add where if N is positive or negative respectively. If N is positive, add numbers at every step, until the sum exceeds N. Once the sum exceeds N, check if sum-N is even or not. If sum-N is even, then at step number (sum-N)/2, subtraction is to be done. If sum-N is an odd number, then check if the last step at which sum exceeded N was even or odd. If it was odd, perform one more step else perform two steps. If sum = N at any step, then additin or subtraction at every step will give the answer.

Let N = 11, then 1+2+3+4+5=15 exceeds 11. Subtract 15-11 to get 4, which is equivalent to performing subtraction at step 2. Hence the sequence of steps is 1 -2 3 4 5

Let N=12, then 1+2+3+4+5=15 exceeds 11. Subtract 15-12 to get 3, which cannot be performed at any step. So add two more steps, one is the 6^{th} step and 7^{th} step. The target is to make sum-N even, so perform addition at 6th step and subtraction at 7th step, which combines to subtract 1 from the sum. Now sum-N is even, 14-12=2 which is equivalent to performing subtraction at step 1. Hence the sequence of steps are -1 2 3 4 5 6 -7

Let N=20, then 1+2+3+4+5+6 exceeds 20. Subtract 21-20 to get 1, so add 7 to 21 to get 28. Performing addition at next step will do as (sum-n) is odd. sum-N gives 8 which is equivalent to performing subtraction at step 4. Hence the sequence of steps is 1 2 3 -4 5 6 7.

Below is the illustration of the above approach:

## C++

`// C++ program to print the sequence ` `// of minimum steps in which N can be ` `// obtained from 0 using addition or ` `// subtraction of the step number. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return the vector ` `// which stores the step sequence ` `vector<` `int` `> findSteps(` `int` `n) ` `{ ` ` ` `// Steps sequence ` ` ` `vector<` `int` `> ans; ` ` ` ` ` `// Current sum ` ` ` `int` `sum = 0; ` ` ` ` ` `// Sign of the number ` ` ` `int` `sign = (n >= 0 ? 1 : -1); ` ` ` `n = ` `abs` `(n); ` ` ` ` ` `int` `i; ` ` ` `// Basic steps required to get sum >= required value. ` ` ` `for` `(i = 1; sum < n; i++) { ` ` ` `ans.push_back(sign * i); ` ` ` `sum += i; ` ` ` `} ` ` ` `cout << i << endl; ` ` ` ` ` `// Reached ahead of N ` ` ` `if` `(sum > sign * n) { ` ` ` ` ` `// If the last step was an odd number ` ` ` `if` `(i % 2) { ` ` ` `sum -= n; ` ` ` ` ` `// sum-n is odd ` ` ` `if` `(sum % 2) { ` ` ` `ans.push_back(sign * i); ` ` ` `sum += i++; ` ` ` `} ` ` ` `// subtract the equivalent sum-n ` ` ` `ans[(sum / 2) - 1] *= -1; ` ` ` `} ` ` ` `else` `{ ` ` ` `sum -= n; ` ` ` ` ` `// sum-n is odd ` ` ` `if` `(sum % 2) { ` ` ` ` ` `// since addition of next step and subtraction ` ` ` `// at the next next step will give sum = sum-1 ` ` ` `sum--; ` ` ` `ans.push_back(sign * i); ` ` ` `ans.push_back(sign * -1 * (i + 1)); ` ` ` `} ` ` ` `// subtract the equivalent sum-n ` ` ` `ans[(sum / 2) - 1] *= -1; ` ` ` `} ` ` ` `} ` ` ` `// returns the vector ` ` ` `return` `ans; ` `} ` ` ` `// Function to print the steps ` `void` `printSteps(` `int` `n) ` `{ ` ` ` `vector<` `int` `> v = findSteps(n); ` ` ` ` ` `// prints the number of steps which is the size of vector ` ` ` `cout << ` `"Minimum number of Steps: "` `<< v.size() << ` `"\n"` `; ` ` ` ` ` `cout << ` `"Step sequence:"` `; ` ` ` ` ` `// prints the steps stored ` ` ` `// in the vector ` ` ` `for` `(` `int` `i = 0; i < v.size(); i++) ` ` ` `cout << v[i] << ` `" "` `; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `n = 20; ` ` ` `printSteps(n); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to print the ` `// sequence of minimum steps ` `// in which N can be obtained ` `// from 0 using addition or ` `// subtraction of the step ` `// number. ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` `// Function to return the ` `// Arraylist which stores ` `// the step sequence ` `static` `ArrayList<Integer> findSteps(` `int` `n) ` `{ ` ` ` `// Steps sequence ` ` ` `ArrayList<Integer> ans = ` `new` `ArrayList<Integer>(); ` ` ` ` ` `// Current sum ` ` ` `int` `sum = ` `0` `; ` ` ` ` ` `// Sign of the number ` ` ` `int` `sign = (n >= ` `0` `? ` `1` `: -` `1` `); ` ` ` `n = Math.abs(n); ` ` ` ` ` `int` `i; ` ` ` `// Basic steps required to ` ` ` `// get sum >= required value. ` ` ` `for` `(i = ` `1` `; sum < n; i++) ` ` ` `{ ` ` ` `ans.add(sign * i); ` ` ` `sum += i; ` ` ` `} ` ` ` `System.out.println( i ); ` ` ` ` ` `// Reached ahead of N ` ` ` `if` `(sum > sign * n) ` ` ` `{ ` ` ` ` ` `// If the last step ` ` ` `// was an odd number ` ` ` `if` `(i % ` `2` `!= ` `0` `) ` ` ` `{ ` ` ` `sum -= n; ` ` ` ` ` `// sum-n is odd ` ` ` `if` `(sum % ` `2` `!= ` `0` `) ` ` ` `{ ` ` ` `ans.add(sign * i); ` ` ` `sum += i++; ` ` ` `} ` ` ` ` ` `// subtract the ` ` ` `// equivalent sum-n ` ` ` `ans.set((sum / ` `2` `) - ` `1` `, ` ` ` `ans.get((sum / ` `2` `) - ` `1` `) * -` `1` `); ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `sum -= n; ` ` ` ` ` `// sum-n is odd ` ` ` `if` `(sum % ` `2` `!= ` `0` `) ` ` ` `{ ` ` ` ` ` `// since addition of next ` ` ` `// step and subtraction at ` ` ` `// the next next step will ` ` ` `// give sum = sum-1 ` ` ` `sum--; ` ` ` `ans.add(sign * i); ` ` ` `ans.add(sign * -` `1` `* (i + ` `1` `)); ` ` ` `} ` ` ` ` ` `// subtract the ` ` ` `// equivalent sum-n ` ` ` `ans.set((sum / ` `2` `) - ` `1` `, ` ` ` `ans.get((sum / ` `2` `) - ` `1` `) * -` `1` `); ` ` ` `} ` ` ` `} ` ` ` ` ` `// returns the Arraylist ` ` ` `return` `ans; ` `} ` ` ` `// Function to print the steps ` `static` `void` `printSteps(` `int` `n) ` `{ ` ` ` `ArrayList<Integer> v = findSteps(n); ` ` ` ` ` `// prints the number of steps ` ` ` `// which is the size of Arraylist ` ` ` `System.out.println(` `"Minimum number "` `+ ` ` ` `"of Steps: "` `+ ` ` ` `v.size()); ` ` ` ` ` `System.out.print(` `"Step sequence:"` `); ` ` ` ` ` `// prints the steps stored ` ` ` `// in the Arraylist ` ` ` `for` `(` `int` `i = ` `0` `; i < v.size(); i++) ` ` ` `System.out.print(v.get(i) + ` `" "` `); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` ` ` `int` `n = ` `20` `; ` ` ` `printSteps(n); ` `} ` `} ` `// This code is contributed ` `// by Arnab Kundu ` |

*chevron_right*

*filter_none*

**Output :**

7 Minimum number of Steps: 7 Step sequence:1 2 3 -4 5 6 7

**Time Complexity :** O(sqrt(N))

**Auxiliary Space : ** O(sqrt(N))

**Note:** sum = i*(i+1)/2 is equivalent or greater than N, which gives i as sqrt(N).

## Recommended Posts:

- Minimum steps to reach target by a Knight | Set 2
- Find minimum steps required to reach the end of a matrix | Set 2
- Count number of steps to cover a distance if steps can be taken in powers of 2
- Maximum array sum that can be obtained after exactly k changes
- Subtraction of the alternate nodes of Linked List
- Print the DFS traversal step-wise (Backtracking also)
- Number of Co-prime pairs obtained from the sum of digits of elements in the given range
- Find i’th index character in a binary string obtained after n iterations | Set 2
- Delete odd and even numbers at alternate step such that sum of remaining elements is minimized
- Maximum money that can be withdrawn in two steps
- A variation of Rat in a Maze : multiple steps or jumps allowed
- Minimum adjacent swaps to move maximum and minimum to corners
- Steps required to visit M points in order on a circular ring of N points
- Number of steps required to convert a binary number to one
- Find the value of N when F(N) = f(a)+f(b) where a+b is the minimum possible and a*b = N

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.