# Minimum array insertions required to make consecutive difference <= K

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:

1. Getting to a building of height Hj from a building of height Hi is only possible if |Hi – Hj| <= K and the building appears one after another in the array.
2. 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `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); ` `    ``cout << minInsertions(H, n, K); ` `    ``return` `0; ` `} `

## 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 `

## 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 `

## 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 `

## PHP

 ` `

Output:

```3
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Improved By : Mithun Kumar, Akanksha_Rai

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.