Minimum increment operations to make the array in increasing order

Given an array of size N and X. Find minimum moves required to make the array in increasing order. In each move one can add X to any element in the array.

Examples: 

Input : a = { 1, 3, 3, 2 }, X = 2
Output : 3
Explanation : Modified array is { 1, 3, 5, 6 }

Input : a = { 3, 5, 6 }, X = 5
Output : 0

Observation:

Let’s take two numbers a and b. a >= b and convert this into a < b by adding some number X. 
so, a < b + k*X 
( a – b ) / x < k
so, the minimum possible value of k is ( a – b ) / x + 1. 

Approach :

Iterate over the given array and take two numbers when a[i] >= a[i-1] 
and apply above observation.

Below is the implementation of the above approach: 

C++

// C++ program to find minimum moves required
// to make the array in increasing order
#include <bits/stdc++.h>
using namespace std;

// function to find minimum moves required
// to make the array in increasing order
int MinimumMoves(int a[], int n, int x)
{
    // to store answer
    int ans = 0;

    // iterate over an array
    for (int i = 1; i < n; i++) {

        // non- increasing order
        if (a[i] <= a[i - 1]) {
            int p = (a[i - 1] - a[i]) / x + 1;

            // add moves to answer
            ans += p;

            // increase the element
            a[i] += p * x;
        }
    }

    // return required answer
    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 3, 3, 2 };
    int x = 2;
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << MinimumMoves(arr, n, x);

    return 0;
}

C

// C program to find minimum moves required
// to make the array in increasing order
#include <stdio.h>

// function to find minimum moves required
// to make the array in increasing order
int MinimumMoves(int a[], int n, int x)
{
    // to store answer
    int ans = 0;

    // iterate over an array
    for (int i = 1; i < n; i++) {

        // non- increasing order
        if (a[i] <= a[i - 1]) {
            int p = (a[i - 1] - a[i]) / x + 1;

            // add moves to answer
            ans += p;

            // increase the element
            a[i] += p * x;
        }
    }

    // return required answer
    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 3, 3, 2 };
    int x = 2;
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("%d",MinimumMoves(arr, n, x));

    return 0;
}

// This code is contributed by kothavvsaakash.

Java

// Java program to find minimum moves required
// to make the array in increasing order
import java.util.*;
import java.lang.*;
import java.io.*;

class GFG{
// function to find minimum moves required
// to make the array in increasing order
static int MinimumMoves(int a[], int n, int x)
{
    // to store answer
    int ans = 0;

    // iterate over an array
    for (int i = 1; i < n; i++) {

        // non- increasing order
        if (a[i] <= a[i - 1]) {
            int p = (a[i - 1] - a[i]) / x + 1;

            // add moves to answer
            ans += p;

            // increase the element
            a[i] += p * x;
        }
    }

    // return required answer
    return ans;
}

// Driver code
public static void main(String args[])
{
    int arr[] = { 1, 3, 3, 2 };
    int x = 2;
    int n = arr.length;

    System.out.println(MinimumMoves(arr, n, x));

}
}

Python3

# Python3 program to find minimum
# moves required to make the array
# in increasing order

# function to find minimum moves required
# to make the array in increasing order
def MinimumMoves(a, n, x) :

    # to store answer
    ans = 0

    # iterate over an array
    for i in range(1, n) :

        # non- increasing order
        if a[i] <= a[i - 1] :

            p = (a[i - 1] - a[i]) // x + 1

            # add moves to answer
            ans += p

            # increase the element
            a[i] += p * x

    # return required answer
    return ans

# Driver code
if __name__ == "__main__" :

    arr = [1, 3, 3, 2]
    x = 2
    n = len(arr)

    print(MinimumMoves(arr, n, x))


# This code is contributed by ANKITRAI1

C#

// C# program to find minimum moves required
// to make the array in increasing order
using System;

class GFG {

// function to find minimum moves required
// to make the array in increasing order
static int MinimumMoves(int[] a, int n, int x)
{

    // to store answer
    int ans = 0;

    // iterate over an array
    for (int i = 1; i < n; i++) {

        // non- increasing order
        if (a[i] <= a[i - 1]) {

            int p = (a[i - 1] - a[i]) / x + 1;

            // add moves to answer
            ans += p;

            // increase the element
            a[i] += p * x;
        }
    }

    // return required answer
    return ans;
}

// Driver code
public static void Main()
{

    int[] arr = {1, 3, 3, 2};
    int x = 2;
    int n = arr.Length;

    Console.Write(MinimumMoves(arr, n, x));

}
}

// This code is contributed by ChitraNayal

PHP

<?php
// PHP program to find minimum
// moves required to make the
// array in increasing order

// function to find minimum
// moves required to make the
// array in increasing order
function MinimumMoves(&$a, $n, $x)
{
    // to store answer
    $ans = 0;

    // iterate over an array
    for ($i = 1; $i < $n; $i++)
    {

        // non- increasing order
        if ($a[$i] <= $a[$i - 1])
        {
            $p = ($a[$i - 1] - $a[$i]) / $x + 1;

            // add moves to answer
            $ans += $p;

            // increase the element
            $a[$i] += $p * $x;
        }
    }

    // return required answer
    return $ans;
}

// Driver code
$arr = array(1, 3, 3, 2 );
$x = 2;
$n = sizeof($arr);

echo ((int)MinimumMoves($arr, $n, $x));

// This code is contributed
// by Shivi_Aggarwal
?>

Javascript

<script>

// Javascript program to find minimum
// moves required to make the array in
// increasing order

// Function to find minimum moves required
// to make the array in increasing order
function MinimumMoves(a, n, x)
{

    // To store answer
    var ans = 0;

    // Tterate over an array
    for(i = 1; i < n; i++)
    {

        // Non- increasing order
        if (a[i] <= a[i - 1])
        {
            var p = parseInt((a[i - 1] -
                              a[i]) / x + 1);

            // Add moves to answer
            ans += p;

            // Increase the element
            a[i] += p * x;
        }
    }

    // Return required answer
    return ans;
}

// Driver code
var arr = [ 1, 3, 3, 2 ];
var x = 2;
var n = arr.length;

document.write(MinimumMoves(arr, n, x));

// This code is contributed by aashish1995

</script>

Output

3

Complexity  Analysis:

• Time Complexity: O(n), to iterate over the array where n is the size of the array
• Auxiliary Space: O(1), as no extra space is required