Related Articles

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

• Difficulty Level : Basic
• Last Updated : 18 May, 2021

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

 ``

## Javascript

 ``
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.  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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up