Modify Array such that no element is smaller/greater than half/double of its adjacent elements

Given an array, arr[] of size N. Find the minimum number of elements we need to insert between array elements such that the maximum element from two adjacent elements is not more than twice bigger than the minimum element i.e., max(arr[i], arr[i+1]) ≤ 2 * min(arr[i], arr[i+1]) where 0 ≤ i < N – 1.

Examples:

Input: N = 5, A[] = {1, 2, 3, 4, 3}
Output: 0
Explanation:

• Element 1 whose value is 1 and neighbour value is 2. max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is true, no need to insert anything
• Element 2 whose value is 2 and neighbour value is 3. max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is true, no need to insert anything
• Element 3 whose value is 3 and neighbour value is 4. max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is true, no need to insert anything
• Element 4 whose value is 4 and neighbour value is 3. max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is true, no need to insert anything

Therefore, the minimum number of insertions required is 0.

Input: N = 4, A[] = {4, 2, 10, 1}
Output: 5
Explanation:

• Element 1 whose value is 4 and neighbour value is 2,   max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is true, no need to insert anything.
• Element 2 whose value is 2 and neighbour value is 10, max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is not true, so we can insert 5, 3.
• Element 3 whose value is 10 and neighbour value is 1,   max(arr[i], arr[i+1]) ≤ 2 * (min(arr[i], arr[i+1])) is not true, so we can insert 5, 3, 2

Therefore, the minimum number of insertions required is 0 + 2 + 3 = 5.

Approach: This problem can be solved based on the following idea:

Iterate from the start of the array till the second last element. Inside the loop check, if the Ratio of the maximum element and minimum element between adjacent elements is fulfilling the ideal condition (i.e. ≤ 2), till it is not true try to insert a maximum value that we can insert (i.e. ceil(maxEle/2), ceil will found upper bound if the result is in decimal) and we will also increase the counter by 1 every time.

Follow the steps below to solve the problem:

• Initialize the count = 0, to count the minimum number of insertions required.
• Iterate over the array A[].
• If maxEle / minEle > 2, update the maxEle = ceil(maxEle / 2) and increment the count of insertion.
• After iterating, return the count.

Below is the implementation of the above approach:

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find minimum
// insertion required
int insertion(int A[], int n)
{

    int count = 0;

    // Create float variable as ratio
    // can be in decimal value
    for (int i = 0; i < n - 1; ++i) {

        float minEle = min(A[i], A[i + 1]);
        float maxEle = max(A[i], A[i + 1]);

        // Maximum and minimum from
        // adjacent values
        while (maxEle / minEle > 2.0) {

            // This loop will stop when
            // ratio between maxi/mini <= 2
            maxEle = ceil(maxEle / 2);

            // Decrease maxi and see if we
            // can insert that element in
            // array or not
            count++;

            // Increase insertion
            // counter by 1
        }
    }

    // Return the minimum
    // insertion required
    return count;
}

// Driver code
int main()
{
    int n = 4;
    int A[] = { 4, 2, 10, 1 };

    // Function Call
    cout << insertion(A, n);

    return 0;
}

Java

// Java implementation of above approach
import java.io.*;
import java.util.*;

class GFG {

  // Function to find minimum
  // insertion required
  public static int insertion(int[] A, int n)
  {

    int count = 0;

    // Create float variable as ratio
    // can be in decimal value
    for (int i = 0; i < n - 1; ++i) {

      float minEle = Math.min(A[i], A[i + 1]);
      float maxEle = Math.max(A[i], A[i + 1]);

      // Maximum and minimum from
      // adjacent values
      while (maxEle / minEle > 2.0) {

        // This loop will stop when
        // ratio between maxi/mini <= 2
        maxEle = (float)Math.ceil(maxEle / 2);

        // Decrease maxi and see if we
        // can insert that element in
        // array or not
        count++;

        // Increase insertion
        // counter by 1
      }
    }

    // Return the minimum
    // insertion required
    return count;
  }

  public static void main(String[] args)
  {
    int n = 4;
    int[] A = { 4, 2, 10, 1 };

    // Function Call
    System.out.println(insertion(A, n));
  }
}

// This code is contributed by lokesh.

Python3

# Python code for the above approach
import math

def insertion(A, n):
    # Initialize counter to keep track
    # of the number of insertions
    count = 0

    # Iterate through the elements of the array
    for i in range(n - 1):
        # Find the minimum and maximum of
        # the current pair of adjacent elements
        minEle = min(A[i], A[i + 1])
        maxEle = max(A[i], A[i + 1])

        # Divide maxEle by 2 until the ratio between maxEle and minEle is <= 2
        while maxEle / minEle > 2:
            maxEle = math.ceil(maxEle / 2)
            # Increment counter for each insertion
            count += 1

    # Return the number of insertions required
    return count

# Driver code
n = 4
A = [4, 2, 10, 1]
print(insertion(A, n))

# This code is contributed by Potta Lokesh

C#

// C# code for the above approach:
using System;
using System.Collections.Generic;

public class Gfg
{

  // Function to find minimum
  // insertion required
  static int insertion(int[] A, int n)
  {

    int count = 0;

    // Create float variable as ratio
    // can be in decimal value
    for (int i = 0; i < n - 1; ++i) {

      float minEle = Math.Min(A[i], A[i + 1]);
      float maxEle = Math.Max(A[i], A[i + 1]);

      // Maximum and minimum from
      // adjacent values
      while (maxEle / minEle > 2.0) {

        // This loop will stop when
        // ratio between maxi/mini <= 2
        maxEle = Convert.ToSingle(Math.Ceiling(maxEle / 2));

        // Decrease maxi and see if we
        // can insert that element in
        // array or not
        count++;

        // Increase insertion
        // counter by 1
      }
    }

    // Return the minimum
    // insertion required
    return count;
  }

  // Driver code
  public static void Main(string[] args)
  {
    int n = 4;
    int[] A = { 4, 2, 10, 1 };

    // Function Call
    Console.WriteLine(insertion(A, n));
  }
}

// This code is contributed by ritaagarwal.

Javascript

// Javascript implementation of above approach

// Function to find minimum
// insertion required
function insertion(A, n)
{

    let count = 0;

    // Create float variable as ratio
    // can be in decimal value
    for (let i = 0; i < n - 1; ++i) {

        let minEle = Math.min(A[i], A[i + 1]);
        let maxEle = Math.max(A[i], A[i + 1]);

        // Maximum and minimum from
        // adjacent values
        while (maxEle / minEle > 2.0) {

            // This loop will stop when
            // ratio between maxi/mini <= 2
            maxEle = Math.ceil(maxEle / 2);

            // Decrease maxi and see if we
            // can insert that element in
            // array or not
            count++;

            // Increase insertion
            // counter by 1
        }
    }

    // Return the minimum
    // insertion required
    return count;
}

// Driver code
let n = 4;
let A = [4, 2, 10, 1 ];

// Function Call
console.log(insertion(A, n));

// This code is contributed by poojaagarwal2.

Output

5

Time Complexity: O(N*log(H)), where N is the length of the array and H is the value of the maximum array element
Auxiliary Space: O(1)