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

- 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

## Recommended Posts:

- Minimum insertions to make a Co-prime array
- Minimum number of changes required to make the given array an AP
- Minimum no. of operations required to make all Array Elements Zero
- Minimum deletions required to make GCD of the array equal to 1
- Minimum operations required to make all the elements distinct in an array
- Minimum operations required to make all the array elements equal
- 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 number of given moves required to make N divisible by 25
- Minimum operations required to make every element greater than or equal to K
- Minimum operations of the given type required to make a complete graph
- Minimum swaps required to make a binary string alternating
- Minimum flip required to make Binary Matrix symmetric

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.