# Minimum jumps to traverse all integers in range [1, N] such that integer i can jump i steps

Given an integer **N, **the task is to find the minimum steps to visit all integers in the range **[1, N]** by selecting any integer and jump **i** steps at every **i ^{th}** jump.

Note: It is possible to revisit an integer more than once.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

**Examples:**

Input:N = 6Output:3Explanation:

One of the following way is:

First start at first number and visit the integers {1, 2, 4}.

Now start at 2nd number and visit the integers as {2, 3, 5}

Now start at the last number and visit it.

Therefore, in total of 3 steps one can visit all the numbers in the range [1, 6]. And also it is the minimum number of steps needed.

Input:N = 4Output:2

**Naive Approach: **The given problem can be solved based on the following observations:

- In each step the sizes of jumps increases therefore some numbers remains unvisited in a step.
- Starting from the first number and performing the jumps it can be observed that the
maximum size of the jumpis the total number of steps needed to visit every number. As in one move, one cannot visit each number between two unvisited numbers.

Follow the below steps to solve the problem:

- Initialize two variables, say
**count = 1**and**res = 0.** - Traverse over the range
**[1, N]**and increment**i**by**count**and update**res**as**res =max(res, count)**and increment**count**by**1**. - After completing the above steps print the
**res.**

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Utility function to find minimum steps` `int` `minSteps(` `int` `N)` `{` ` ` `// Initialize count and result` ` ` `int` `count = 1, res = 0;` ` ` `// Traverse over the range [1, N]` ` ` `for` `(` `int` `i = 1; i <= N; i += count) {` ` ` `// Update res` ` ` `res = max(res, count);` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `// Return res` ` ` `return` `res;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Input` ` ` `int` `N = 6;` ` ` `// Function call` ` ` `cout << minSteps(N) << ` `"\n"` `;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `class` `GFG` `{` ` ` `// Utility function to find minimum steps` ` ` `static` `int` `minSteps(` `int` `N)` ` ` `{` ` ` `// Initialize count and result` ` ` `int` `count = ` `1` `, res = ` `0` `;` ` ` `// Traverse over the range [1, N]` ` ` `for` `(` `int` `i = ` `1` `; i <= N; i += count)` ` ` `{` ` ` `// Update res` ` ` `res = Math.max(res, count);` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `// Return res` ` ` `return` `res;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `// Input` ` ` `int` `N = ` `6` `;` ` ` `// Function call` ` ` `System.out.println(minSteps(N) );` ` ` `}` `}` `// This code is contributed by Potta Lokesh` |

## Python3

`# Python 3 implementation of the above approach` `# Utility function to find minimum steps` `def` `minSteps(N):` ` ` ` ` `# Initialize count and result` ` ` `count ` `=` `1` ` ` `res ` `=` `0` ` ` `# Traverse over the range [1, N]` ` ` `for` `i ` `in` `range` `(` `1` `, N ` `+` `1` `, count):` ` ` ` ` `# Update res` ` ` `res ` `=` `max` `(res, count)` ` ` ` ` `# Increment count` ` ` `count ` `+` `=` `1` ` ` `# Return res` ` ` `return` `res` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Input` ` ` `N ` `=` `6` ` ` `# Function call` ` ` `print` `(minSteps(N))` ` ` ` ` `# This code is contributed by SURENDRA_GANGWAR.` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` ` ` `// Utility function to find minimum steps` ` ` `static` `int` `minSteps(` `int` `N)` ` ` `{` ` ` `// Initialize count and result` ` ` `int` `count = 1, res = 0;` ` ` `// Traverse over the range [1, N]` ` ` `for` `(` `int` `i = 1; i <= N; i += count)` ` ` `{` ` ` `// Update res` ` ` `res = Math.Max(res, count);` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `// Return res` ` ` `return` `res;` ` ` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `// Input` ` ` `int` `N = 6;` ` ` `// Function call` ` ` `Console.Write(minSteps(N) );` `}` `}` |

## Javascript

`<script>` `// JavaScript implementation of the above approach` `// Utility function to find minimum steps` `function` `minSteps(N) {` ` ` `// Initialize count and result` ` ` `let count = 1,` ` ` `res = 0;` ` ` `// Traverse over the range [1, N]` ` ` `for` `(let i = 1; i <= N; i += count) {` ` ` `// Update res` ` ` `res = Math.max(res, count);` ` ` `// Increment count` ` ` `count++;` ` ` `}` ` ` `// Return res` ` ` `return` `res;` `}` `// Driver Code` `// Input` `let N = 6;` `// Function call` `document.write(minSteps(N));` `</script>` |

**Output**

3

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

**Efficient Approach: ** The above steps can be optimized based on the following observations:

- Suppose an array arr[] as
arr[] ={1, 1, 2, 2, 2, 3, 3, 3, ….].Now the idea is to find the numberKwhich is the maximum size of jump taken in a step.- In above taken array, Since, 1 occurs twice, 2 occurs thrice, 3 occurs four times and so on. (
K – 1)would occurKtimes.- Now let
Koccursctimes, then count of total occurrence must be equal toN.

2 + 3 + 4 +….+ K + c = Nc = N – 2 – 3 – 4 -….- K …..(i)- Then one need to find the greatest
Ksatisfying equation (i) alsoc≥1, then

K^{2 }+ K – 2 × N ≤ 0.- Therefore
, K = (-1 + √(1 + 8 ×N)) / 2

Follow the steps below to solve the problem:

- Print the value
**(-1 + √(1 + 8 *N)) / 2**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Utility function to find minimum steps` `int` `minSteps(` `int` `N)` `{` ` ` `int` `res = (` `sqrt` `(1 + 8 * N) - 1) / 2;` ` ` `return` `res;` `}` `// Driver code` `int` `main()` `{` ` ` `// Input integer` ` ` `int` `N = 6;` ` ` `// Function call` ` ` `cout << minSteps(N) << ` `"\n"` `;` `}` |

## Java

`// Java implementation of the above approach` `import` `java.io.*;` `import` `java.lang.Math;` `class` `GFG{` ` ` `// Utility function to find minimum steps` `static` `int` `minSteps(` `int` `N)` `{` ` ` `int` `res = ((` `int` `)Math.sqrt(` `1` `+ ` `8` `* N) - ` `1` `) / ` `2` `;` ` ` `return` `res;` `}` `// Driver code` `public` `static` `void` `main (String[] args)` `{` ` ` ` ` `// Input integer` ` ` `int` `N = ` `6` `;` ` ` ` ` `// Function call` ` ` `System.out.println(minSteps(N) + ` `"\n"` `);` `}` `}` `// This code is contributed by shivanisinghss2110` |

## Python3

`# Python 3 implementation of the above approach` `from` `math ` `import` `sqrt` `# Utility function to find minimum steps` `def` `minSteps(N):` ` ` `res ` `=` `int` `((sqrt(` `1` `+` `8` `*` `N) ` `-` `1` `) ` `/` `/` `2` `)` ` ` `return` `res` `# Driver code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `# Input integer` ` ` `N ` `=` `6` ` ` `# Function call` ` ` `print` `(minSteps(N))` |

## C#

`// Java implementation of the above approach` `using` `System;` `class` `GFG` `{` ` ` `// Utility function to find minimum steps` `static` `int` `minSteps(` `int` `N)` `{` ` ` `int` `res = ((` `int` `)Math.Sqrt(1 + 8 * N) - 1) / 2;` ` ` `return` `res;` `}` `// Driver code` `public` `static` `void` `Main (String[] args)` `{` ` ` ` ` `// Input integer` ` ` `int` `N = 6;` ` ` ` ` `// Function call` ` ` `Console.Write(minSteps(N) + ` `"\n"` `);` `}` `}` `// This code is contributed by shivanisinghss2110` |

## Javascript

`<script>` `// javascript implementation of the above approach` `// Utility function to find minimum steps` `function` `minSteps(N)` `{` ` ` `var` `res = parseInt((Math.sqrt(1 + 8 * N) - 1) / 2);` ` ` `return` `res;` `}` `// Driver code` ` ` `// Input integer` `var` `N = 6;` `// Function call` `document.write(minSteps(N));` `// This code contributed by shikhasingrajput` `</script>` |

**Output**

3

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