Given an integer **N** and an infinite table where **i ^{th}** row and

**j**column contains the value

^{th}**i *j**. The task is to find the minimum number of moves to reach the cell containing

**N**starting from the cell

**(1, 1)**.

**Note:**From

**(i, j)**only valid moves are

**(i + 1, j)**and

**(i, j + 1)**

**Examples:**

Input:N = 10Output:5

(1, 1) -> (2, 1) -> (2, 2) -> (2, 3) -> (2, 4) -> (2, 5)Input:N = 7Output:6

**Approach:** Note that any cell **(i, j)** can be reached in **i + j – 2** steps. Thus, only the pair **(i, j)** is required with **i * j = N** that minimizes **i + j**. It can be found out by finding all the possible pairs **(i, j)** and check them in **O(√N)**. To do this, without loss of generality, it can be assumed that **i ≤ j** and **i ≤ √N** since **N = i * j ≥ i ^{2}**. So

**√N ≥ i**i.e.

^{2}**√N ≥ i**.

Thus, iterate over all the possible values of

**i**from

**1**to

**√N**and, among all the possible pairs

**(i, j)**, pick the lowest value of

**i + j – 2**and that is the required answer.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the minimum number` `// of moves required to reach the cell` `// containing N starting from (1, 1)` `int` `min_moves(` `int` `n)` `{` ` ` `// To store the required answer` ` ` `int` `ans = INT_MAX;` ` ` `// For all possible values of divisors` ` ` `for` `(` `int` `i = 1; i * i <= n; i++) {` ` ` `// If i is a divisor of n` ` ` `if` `(n % i == 0) {` ` ` `// Get the moves to reach n` ` ` `ans = min(ans, i + n / i - 2);` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `n = 10;` ` ` `cout << min_moves(n);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` ` ` `// Function to return the minimum number` `// of moves required to reach the cell` `// containing N starting from (1, 1)` `static` `int` `min_moves(` `int` `n)` `{` ` ` `// To store the required answer` ` ` `int` `ans = Integer.MAX_VALUE;` ` ` `// For all possible values of divisors` ` ` `for` `(` `int` `i = ` `1` `; i * i <= n; i++)` ` ` `{` ` ` `// If i is a divisor of n` ` ` `if` `(n % i == ` `0` `)` ` ` `{` ` ` `// Get the moves to reach n` ` ` `ans = Math.min(ans, i + n / i - ` `2` `);` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `n = ` `10` `;` ` ` `System.out.println(min_moves(n));` `}` `}` `// This code is contributed by Code_Mech` |

## Python3

`# Python3 implementation of the approach` `import` `sys` `from` `math ` `import` `sqrt` `# Function to return the minimum number` `# of moves required to reach the cell` `# containing N starting from (1, 1)` `def` `min_moves(n) :` ` ` `# To store the required answer` ` ` `ans ` `=` `sys.maxsize;` ` ` `# For all possible values of divisors` ` ` `for` `i ` `in` `range` `(` `1` `, ` `int` `(sqrt(n)) ` `+` `1` `) :` ` ` `# If i is a divisor of n` ` ` `if` `(n ` `%` `i ` `=` `=` `0` `) :` ` ` `# Get the moves to reach n` ` ` `ans ` `=` `min` `(ans, i ` `+` `n ` `/` `/` `i ` `-` `2` `);` ` ` `# Return the required answer` ` ` `return` `ans;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `n ` `=` `10` `;` ` ` `print` `(min_moves(n));` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` ` ` `class` `GFG` `{` ` ` `// Function to return the minimum number` `// of moves required to reach the cell` `// containing N starting from (1, 1)` `static` `int` `min_moves(` `int` `n)` `{` ` ` `// To store the required answer` ` ` `int` `ans = ` `int` `.MaxValue;` ` ` `// For all possible values of divisors` ` ` `for` `(` `int` `i = 1; i * i <= n; i++)` ` ` `{` ` ` `// If i is a divisor of n` ` ` `if` `(n % i == 0)` ` ` `{` ` ` `// Get the moves to reach n` ` ` `ans = Math.Min(ans, i + n / i - 2);` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `n = 10;` ` ` `Console.WriteLine(min_moves(n));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` ` ` `// JavaScript implementation of the approach` ` ` ` ` `// Function to return the minimum number` ` ` `// of moves required to reach the cell` ` ` `// containing N starting from (1, 1)` ` ` `function` `min_moves(n)` ` ` `{` ` ` `// To store the required answer` ` ` `let ans = Number.MAX_VALUE;` ` ` `// For all possible values of divisors` ` ` `for` `(let i = 1; i * i <= n; i++)` ` ` `{` ` ` `// If i is a divisor of n` ` ` `if` `(n % i == 0)` ` ` `{` ` ` `// Get the moves to reach n` ` ` `ans = Math.min(ans, i + parseInt(n / i, 10) - 2);` ` ` `}` ` ` `}` ` ` `// Return the required answer` ` ` `return` `ans;` ` ` `}` ` ` ` ` `let n = 10;` ` ` ` ` `document.write(min_moves(n));` ` ` `</script>` |

**Output:**

5

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**