Given an infinite number line from the range **[-INFINITY, +INFINITY]** and an integer **N**, the task is to find the minimum count of moves required to reach the **N**, starting from **0**, by either moving **i** steps forward or **1** steps backward in every **i ^{th}** move.

**ENamples:**

Input:N = 18Output:6Explanation:To reach to the given value of N, perform the operations in the fullowing sequence: 1 – 1 + 3 + 4 + 5 + 6 = 18Therefore, a total of 6 operations are required.

Input:N = 3Output:2Explanation:To reach to the given value of N, perform the operations in the fullowing sequence: 1 + 2 = 3Therefore, a total of 2 operations are required.

**Approach: **The idea is to initially, keep adding **1, 2, 3 . . . . K**, until it is greater than or equal to required value **N**. Then, calculate the required number to be subtracted from the current sum. Fullow the steps below to sulve the problem:

- Initially, increment by
**K**until**N**is greater than the current value. Now, stop at some position**pos = 1 + 2 + …………. + steps = steps ∗ (steps + 1) / 2 ≥ N.**. Otherwise, the last step wasn’t possible.**Note:**0 ≤ pos – N < steps**Case 1:**If**pos = N**then, ‘steps’ is the required answer.**Case 2:**If**pos ≠ N**, then replace any iteration of**K**with -1.

- By repacing any
**K**with**-1**, the modified value of**pos = pos – (K + 1)**. Since**K ∈ [1, steps]**, then**pos ∈ [pos – steps – 1, pos – 2]**. - It is clear that
**pos – step < N**. If**N < pos – 1**, then choose the corresponding**K = pos – N – 1**and replace**K**with**-1**and get straight to the point**N**. - If
**N + 1 = pos**, only one**-1**operation is required.

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 minimum steps` `// required to reach N by either moving` `// i steps forward or 1 steps backward` `int` `minimumsteps(` `int` `N)` `{` ` ` `// Stores the required count` ` ` `int` `steps = 0;` ` ` `// IF total moves required` ` ` `// is less than double of N` ` ` `while` `(steps * (steps + 1) < 2 * N) {` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `// Steps required to reach N` ` ` `if` `(steps * (steps + 1) / 2 == N + 1) {` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `cout << steps;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given value of N` ` ` `int` `N = 18;` ` ` `minimumsteps(N);` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program for the above approach ` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to find the minimum steps` `// required to reach N by either moving` `// i steps forward or 1 steps backward` `static` `void` `minimumsteps(` `int` `N)` `{` ` ` `// Stores the required count` ` ` `int` `steps = ` `0` `;` ` ` `// IF total moves required` ` ` `// is less than double of N` ` ` `while` `(steps * (steps + ` `1` `) < ` `2` `* N)` ` ` `{` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `// Steps required to reach N` ` ` `if` `(steps * (steps + ` `1` `) / ` `2` `== N + ` `1` `) ` ` ` `{` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `System.out.println(steps);` `}` ` ` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` ` ` `// Given value of N` ` ` `int` `N = ` `18` `;` ` ` `minimumsteps(N);` `}` `}` `// This code is contributed by code_hunt.` |

*chevron_right*

*filter_none*

## Python3

`# Function to find the minimum steps` `# required to reach N by either moving` `# i steps forward or 1 steps backward` `def` `minimumsteps(N) :` ` ` `# Stores the required count` ` ` `steps ` `=` `0` ` ` `# IF total moves required` ` ` `# is less than double of N` ` ` `while` `(steps ` `*` `(steps ` `+` `1` `) < ` `2` `*` `N) :` ` ` `# Update steps` ` ` `steps ` `+` `=` `1` ` ` `# Steps required to reach N` ` ` `if` `(steps ` `*` `(steps ` `+` `1` `) ` `/` `2` `=` `=` `N ` `+` `1` `) :` ` ` `# Update steps` ` ` `steps ` `+` `=` `1` ` ` `print` `(steps)` `# Driver code` `N ` `=` `18` `;` `minimumsteps(N)` `# This code is contributed by Dharanendra L V` |

*chevron_right*

*filter_none*

## C#

`// C# program for the above approach ` `using` `System;` `class` `GFG {` ` ` `// Function to find the minimum steps` ` ` `// required to reach N by either moving` ` ` `// i steps forward or 1 steps backward` ` ` `static` `void` `minimumsteps(` `int` `N)` ` ` `{` ` ` `// Stores the required count` ` ` `int` `steps = 0;` ` ` `// IF total moves required` ` ` `// is less than double of N` ` ` `while` `(steps * (steps + 1) < 2 * N) {` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `// Steps required to reach N` ` ` `if` `(steps * (steps + 1) / 2 == N + 1) {` ` ` `// Update steps` ` ` `steps++;` ` ` `}` ` ` `Console.WriteLine(steps);` ` ` `}` ` ` `// Driver code` ` ` `static` `public` `void` `Main()` ` ` `{` ` ` `// Given value of N` ` ` `int` `N = 18;` ` ` `minimumsteps(N);` ` ` `}` `}` `// This code is contributed by Dharanendra LV` |

*chevron_right*

*filter_none*

**Output:**

6

**Time CompleNity: **O(sqrt(N))**AuNiliary 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.