Given an integer array *H* which represents heights of buildings and an integer *K*. The task is to reach the last building from the first with the following rules:

- Getting to a building of height
**H**from a building of height_{j}**H**is only possible if_{i}**|H**and the building appears one after another in the array._{i}– H_{j}| <= K - If getting to a building is not possible then a number of buildings of intermediate heights can be inserted in between the two building.

Find the minimum number of insertions done in step 2 to make it possible to go from first building to the last.

**Examples:**

Input:H[] = {2, 4, 8, 16}, K = 3

Output:3

Add 1 building of height 5 between buildings of height 4 and 8.

And add 2 buildings of heights 11 and 14 respectively between buildings of height 8 and 16.

Input:H[] = {5, 55, 100, 1000}, K = 10

Output:97

**Approach:**

- Run a loop from
*1 to n-1*and check whether`abs(H[i] - H[i-1]) <= K`

. - If the above condition is true then skip to the next iteration of the loop.
- If the condition is false, then the insertions required will be equal to
`ceil(diff / K) - 1`

where`diff = abs(H[i] - H[i-1])`

- Print the total insertions in the end.

Below is the implementation of above approach:

## C++

`// CPP implementation of above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to return minimum ` `// number of insertions required ` `int` `minInsertions(` `int` `H[], ` `int` `n, ` `int` `K) ` `{ ` ` ` `// Initialize insertions to 0 ` ` ` `int` `inser = 0; ` ` ` ` ` `for` `(` `int` `i = 1; i < n; ++i) { ` ` ` `float` `diff = ` `abs` `(H[i] - H[i - 1]); ` ` ` ` ` `if` `(diff <= K) ` ` ` `continue` `; ` ` ` `else` ` ` `inser += ` `ceil` `(diff / K) - 1; ` ` ` `} ` ` ` ` ` `// return total insertions ` ` ` `return` `inser; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `H[] = { 2, 4, 8, 16 }, K = 3; ` ` ` `int` `n = ` `sizeof` `(H) / ` `sizeof` `(H[0]); ` ` ` `cout << minInsertions(H, n, K); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of above approach ` ` ` `class` `GFG{ ` `// Function to return minimum ` `// number of insertions required ` `static` `int` `minInsertions(` `int` `[] H, ` `int` `n, ` `int` `K) ` `{ ` ` ` `// Initialize insertions to 0 ` ` ` `int` `inser = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `1` `; i < n; ++i) { ` ` ` `float` `diff = Math.abs(H[i] - H[i - ` `1` `]); ` ` ` ` ` `if` `(diff <= K) ` ` ` `continue` `; ` ` ` `else` ` ` `inser += Math.ceil(diff / K) - ` `1` `; ` ` ` `} ` ` ` ` ` `// return total insertions ` ` ` `return` `inser; ` `} ` ` ` `// Driver program ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` `int` `[] H = ` `new` `int` `[]{ ` `2` `, ` `4` `, ` `8` `, ` `16` `}; ` ` ` `int` `K = ` `3` `; ` ` ` `int` `n = H.length; ` ` ` `System.out.println(minInsertions(H, n, K)); ` `} ` `} ` `// This code is contributed by mits ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation of above approach ` `import` `math ` ` ` `# Function to return minimum ` `# number of insertions required ` `def` `minInsertions(H, n, K): ` ` ` ` ` `# Initialize insertions to 0 ` ` ` `inser ` `=` `0` `; ` ` ` ` ` `for` `i ` `in` `range` `(` `1` `, n): ` ` ` `diff ` `=` `abs` `(H[i] ` `-` `H[i ` `-` `1` `]); ` ` ` ` ` `if` `(diff <` `=` `K): ` ` ` `continue` `; ` ` ` `else` `: ` ` ` `inser ` `+` `=` `math.ceil(diff ` `/` `K) ` `-` `1` `; ` ` ` ` ` `# return total insertions ` ` ` `return` `inser; ` ` ` `# Driver Code ` `H ` `=` `[` `2` `, ` `4` `, ` `8` `, ` `16` `]; ` `K ` `=` `3` `; ` `n ` `=` `len` `(H); ` `print` `(minInsertions(H, n, K)); ` ` ` `# This code is contributed ` `# by mits ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation of above approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` `// Function to return minimum ` `// number of insertions required ` `static` `int` `minInsertions(` `int` `[] H, ` ` ` `int` `n, ` `int` `K) ` `{ ` ` ` `// Initialize insertions to 0 ` ` ` `int` `inser = 0; ` ` ` ` ` `for` `(` `int` `i = 1; i < n; ++i) ` ` ` `{ ` ` ` `float` `diff = Math.Abs(H[i] - H[i - 1]); ` ` ` ` ` `if` `(diff <= K) ` ` ` `continue` `; ` ` ` `else` ` ` `inser += (` `int` `)Math.Ceiling(diff / K) - 1; ` ` ` `} ` ` ` ` ` `// return total insertions ` ` ` `return` `inser; ` `} ` ` ` `// Driver Code ` `static` `void` `Main() ` `{ ` ` ` `int` `[] H = ` `new` `int` `[]{ 2, 4, 8, 16 }; ` ` ` `int` `K = 3; ` ` ` `int` `n = H.Length; ` ` ` `Console.WriteLine(minInsertions(H, n, K)); ` `} ` `} ` ` ` `// This code is contributed by mits ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP implementation of above approach ` ` ` `// Function to return minimum ` `// number of insertions required ` `function` `minInsertions(` `$H` `, ` `$n` `, ` `$K` `) ` `{ ` ` ` `// Initialize insertions to 0 ` ` ` `$inser` `= 0; ` ` ` ` ` `for` `(` `$i` `= 1; ` `$i` `< ` `$n` `; ++` `$i` `) ` ` ` `{ ` ` ` `$diff` `= ` `abs` `(` `$H` `[` `$i` `] - ` `$H` `[` `$i` `- 1]); ` ` ` ` ` `if` `(` `$diff` `<= ` `$K` `) ` ` ` `continue` `; ` ` ` `else` ` ` `$inser` `+= ` `ceil` `(` `$diff` `/ ` `$K` `) - 1; ` ` ` `} ` ` ` ` ` `// return total insertions ` ` ` `return` `$inser` `; ` `} ` ` ` `// Driver Code ` `$H` `= ` `array` `(2, 4, 8, 16 ); ` `$K` `= 3; ` `$n` `= sizeof(` `$H` `); ` `echo` `minInsertions(` `$H` `, ` `$n` `, ` `$K` `); ` ` ` `// This code is contributed ` `// by Akanksha Rai(Abby_akku) ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

3

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.

## Recommended Posts:

- Minimum insertions to make a Co-prime array
- Minimum insertions to make XOR of an Array equal to half of its sum
- Minimum number of changes required to make the given array an AP
- Minimum no. of operations required to make all Array Elements Zero
- Minimum changes required to make all element in an array equal
- Minimum deletions required to make GCD of the array equal to 1
- Minimum changes required to make all Array elements Prime
- Minimum steps required to make an array decreasing
- Minimum operations required to make all Array elements divisible by K
- Minimum operations required to make all the elements distinct in an array
- Minimum operations required to make all the array elements equal
- Minimum increment or decrement operations required to make the array sorted
- Find the minimum number of operations required to make all array elements equal
- Sum of minimum difference between consecutive elements of an array
- Minimum changes required to make two arrays identical
- Minimum number of pairs required to make two strings same
- Minimum removals required to make ranges non-overlapping
- Minimum changes required to make each path in a matrix palindrome
- Minimum operations required to make two numbers equal
- Minimum number of given moves required to make N divisible by 25

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.