Skip to content
Related Articles

Related Articles

Improve Article

Make an array strictly increasing by repeatedly subtracting and adding arr[i – 1] – (i – 1) to adjacent indices

  • Difficulty Level : Medium
  • Last Updated : 08 Jun, 2021

Given an array arr[] consisting of N positive integers, the task is to check whether the given array arr[] can be made strictly increasing such that for any index i from the range [1, N – 1], if (arr[i – 1] – (i – 1)) is at least 0, then it is added to arr[i] and subtracted from arr[i – 1]. If it is possible to make the array strictly increasing, then print Yes. Otherwise, print No.

Examples:

Input: arr[] = {1, 5, 2, 7, 6}
Output: Yes
Explanation:
Consider the following operations:

  1. Choosing the index 1, the value of arr[i – 1] – (i – 1) is 1, which is at least 0. Adding 1 to arr[1] and subtracting it from arr[0], modifies the array to {0, 6, 2, 7, 6}.
  2. Choosing the index 2, the value of arr[i – 1] – (i – 1) is 5, which is at least 0. Adding 5 to arr[2] and subtracting it from arr[1], modifies the array to {0, 1, 7, 7, 6}.
  3. Choosing the index 3, the value of arr[i – 1] – (i – 1) is 5, which is at least 0. Adding 6 to arr[3] and subtracting it from arr[2], modifies the array to {0, 1, 2, 12, 6}.
  4. Choosing the index 4, the value of arr[i – 1] – (i – 1) is 9, which is at least 0. Adding 9 to arr[4] and subtracted from arr[3], modifies the array to {0, 1, 2, 3, 15}.

After the above operations, the array becomes strictly increasing.

Input: arr[] = {0, 1, 0}
Output: No



Approach: The given problem can be solved by using the Greedy Approach. Follow the steps below to solve the problem

  • Traverse the given array using variable i in range [1, N – 1] and perform the following steps:
    • If arr[i – 1] is at least (i – 1), then perform the following steps:
      • Store the value of arr[i] – arr[i – 1] in a variable, say P.
      • Update arr[i – 1] as arr[i – 1] – P.
      • Update arr[i] as arr[i] + P.
  • After completing the above steps, if the array arr[] is sorted, then print “Yes”. Otherwise, print “No”

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if an array
// can be made strictly increasing
void check(int arr[], int n)
{
    // Traverse the given array arr[]
    for (int i = 1; i < n; i++) {
 
        if (arr[i - 1] >= (i - 1)) {
 
            // Update the value of p,
            // arr[i], and arr[i - 1]
            int p = arr[i - 1] - (i - 1);
            arr[i] += p;
            arr[i - 1] -= p;
        }
    }
 
    // Traverse the given array
    for (int i = 1; i < n; i++) {
 
        // Check if the array arr[] is
        // strictly increasing or not
        if (arr[i] <= arr[i - 1]) {
 
            cout << "No";
            return;
        }
    }
 
    // Otherwise, array is increasing
    // order, print Yes
    cout << "Yes";
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 5, 2, 7, 6 };
    int N = sizeof(arr) / sizeof(arr[0]);
    check(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
 
class GFG{
   
// Function to check if an array
// can be made strictly increasing
static void check(int arr[], int n)
{
     
    // Traverse the given array arr[]
    for(int i = 1; i < n; i++)
    {
        if (arr[i - 1] >= (i - 1))
        {
             
            // Update the value of p,
            // arr[i], and arr[i - 1]
            int p = arr[i - 1] - (i - 1);
            arr[i] += p;
            arr[i - 1] -= p;
        }
    }
 
    // Traverse the given array
    for(int i = 1; i < n; i++)
    {
         
        // Check if the array arr[] is
        // strictly increasing or not
        if (arr[i] <= arr[i - 1])
        {
            System.out.println("No");
            return;
        }
    }
 
    // Otherwise, array is increasing
    // order, print Yes
    System.out.println("Yes");
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 5, 2, 7, 6 };
    int N = arr.length;
     
    check(arr, N);
}
}
 
// This code is contributed by Dharanendra L V.

Python3




# Python3 program for the above approach
 
# Function to check if an array
# can be made strictly increasing
def check(arr, n):
    # Traverse the given array arr[]
    for i in range(1, n):
 
        if (arr[i - 1] >= (i - 1)):
 
            # Update the value of p,
            # arr[i], and arr[i - 1]
            p = arr[i - 1] - (i - 1)
            arr[i] += p
            arr[i - 1] -= p
 
    # Traverse the given array
    for i in range(1, n):
        # Check if the array arr[] is
        # strictly increasing or not
        if (arr[i] <= arr[i - 1]):
 
            print ("No")
            return
 
 
    # Otherwise, array is increasing
    # order, prYes
    print ("Yes")
 
# Driver Code
if __name__ == '__main__':
    arr = [1, 5, 2, 7, 6]
    N = len(arr)
    check(arr, N)
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
   
// Function to check if an array
// can be made strictly increasing
static void check(int []arr, int n)
{
     
    // Traverse the given array arr[]
    for(int i = 1; i < n; i++)
    {
        if (arr[i - 1] >= (i - 1))
        {
             
            // Update the value of p,
            // arr[i], and arr[i - 1]
            int p = arr[i - 1] - (i - 1);
            arr[i] += p;
            arr[i - 1] -= p;
        }
    }
 
    // Traverse the given array
    for(int i = 1; i < n; i++)
    {
         
        // Check if the array arr[] is
        // strictly increasing or not
        if (arr[i] <= arr[i - 1])
        {
            Console.Write("No");
            return;
        }
    }
 
    // Otherwise, array is increasing
    // order, print Yes
    Console.Write("Yes");
}
 
// Driver Code
public static void Main()
{
    int []arr = { 1, 5, 2, 7, 6 };
    int N = arr.Length;
    check(arr, N);
}
}
 
// This code is contributed by SURENDRA_GANGWAR.

Javascript




<script>
 
// Javascript program for the above approach
  
// Function to check if an array
// can be made strictly increasing
function check(arr, n)
{
     
    // Traverse the given array arr
    for(var i = 1; i < n; i++)
    {
        if (arr[i - 1] >= (i - 1))
        {
             
            // Update the value of p,
            // arr[i], and arr[i - 1]
            var p = arr[i - 1] - (i - 1);
            arr[i] += p;
            arr[i - 1] -= p;
        }
    }
 
    // Traverse the given array
    for(var i = 1; i < n; i++)
    {
         
        // Check if the array arr is
        // strictly increasing or not
        if (arr[i] <= arr[i - 1])
        {
            document.write("No");
            return;
        }
    }
 
    // Otherwise, array is increasing
    // order, prvar Yes
    document.write("Yes");
}
 
// Driver Code
var arr = [ 1, 5, 2, 7, 6 ];
var N = arr.length;
 
check(arr, N);
 
// This code is contributed by 29AjayKumar
 
</script>
Output: 
Yes

 

Time Complexity: O(N)
Auxiliary Space: O(1)

 

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
Recommended Articles
Page :