Skip to content
Related Articles

Related Articles

Improve Article
Minimum increment operations to make the array in increasing order
  • Difficulty Level : Easy
  • Last Updated : 23 Apr, 2021

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;
}
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
 
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 industry experts, please refer DSA Live Classes



My Personal Notes
arrow_drop_up
Next

Divide binary array into three equal parts with same value
Recommended Articles
Page :
Minimum Increment operations to make Array unique
26, Nov 18
Minimum number of increment-other operations to make all array elements equal.
05, Oct 17
Minimum increment or decrement operations required to make the array sorted
15, Oct 19
Minimum pair merge operations required to make Array non-increasing
25, Aug 20
Minimum increment by k operations to make all elements equal
04, Mar 18
Minimum increment/decrement operations required to make Median as X
02, Jul 20
Minimum range increment operations to Sort an array
03, Dec 18
Arrange the array such that upon performing given operations an increasing order is obtained
04, Feb 20
Minimum number of increment/decrement operations such that array contains all elements from 1 to N
28, Nov 18
Minimum increment/decrement operations required on Array to satisfy given conditions
19, Aug 20
Minimum Increment / decrement to make array elements equal
15, Nov 18
Minimum value of X to make all array elements equal by either decreasing or increasing by X
22, Apr 19
Minimum operations to make XOR of array zero
18, Sep 17
Minimum operations to make GCD of array a multiple of k
07, May 18
Minimum gcd operations to make all array elements one
19, Nov 17
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Minimum operations to make counts of remainders same in an array
13, Feb 19
Minimum delete operations to make all elements of array same
09, Dec 16
Make all the array elements odd with minimum operations of given type
13, Jan 20
Minimum number of operations on an array to make all elements 0
05, Feb 19
Minimum no. of operations required to make all Array Elements Zero
08, Oct 18
Minimum operations to make all elements equal using the second array
07, May 20
Minimum operations required to make all Array elements divisible by K
02, Jul 20
Find minimum operations needed to make an Array beautiful
20, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pawan_asipu
@pawan_asipu
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox