Open In App
Related Articles

Check whether an array can be made strictly increasing by incrementing and decrementing adjacent pairs

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given an array arr[] of size N consisting of non-negative integers. In one move ith index element of the array is decreased by 1 and (i+1)th index is increased by 1. The task is to check if there is any possibility to make the given array strictly increasing (containing non-negative integers only) by making any number of moves.

Examples: 

Input: arr[3] = [1, 2, 3]
Output: Yes
Explanation: The array is already sorted in strictly increasing order.

Input: arr[2] = [2, 0]
Output: Yes
Explanation: Consider i = 0 for the 1st move arr[0] = 2-1 = 1, arr[1] = 0 + 1 = 1. Now the array becomes, [1, 1].
In 2nd move consider i = 0. So now arr[0] = 1 – 1 = 0, arr[1] = 1 + 1 = 2. 
The final array becomes, arr[2] = [0, 2] which is strictly increasing.

Input: arr[3] = [0, 1, 0]
Output: No
Explanation: This array cannot be made strictly increasing containing only non negative integers by performing any number of moves.

 

Approach: The problem can be solved using the following mathematical observation. 

  • Since all the array elements are non-negative, so minimum strictly increasing order of an array of size N can be: 0, 1, 2, 3 . . . (N-1).
  • So the minimum sum(min_sum) of first i elements (till (i-t)th index) of any such array is min_sum = (i*(i-1))/2.
  • Therefore, the sum of first i elements of given array(cur_sum) must satisfy the condition cur_sum ≥ min_sum .
  • If the condition is not satisfied, then it is not possible to make the given array strictly increasing. Consider the following example

Illustration 1:

arr[]           = 4 5  1   2   3
min_sum   = 0 1  3   6  10
sum(arr)   = 4 9 10 12 15

As this array satisfies the condition for every i, it is possible to convert this array to strictly increasing array

Illustration 2:

arr[]           = 2 3 1 0 2
min_sum   = 0 1 3 6 10
sum(arr)   = 2 5 6 6 8

Here at index 4 the sum of array does not satisfy the condition of having minimum sum 10. So it is not possible to change the array into a strictly increasing one.

Follow the steps mentioned below to implement the concept:

  • Traverse from index = 0 to index = N – 1, and for each i check if sum till that is greater than or equal to (i*(i+1))/2.
  • If the condition is satisfied then the array can be made strictly increasing. Otherwise, it cannot be made strictly increasing.

Follow the below implementation for the above approach:

C++

// C++ code to check if the given array
// can be made strictly increasing
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if
// the array can be made strictly increasing
void CheckStrictlyIncreasing(int arr[],
                             int N)
{
    // variable to store sum till current
    // index element
    int cur_sum = 0;
    bool possible = true;
    for (int index = 0;
         index < N; index++) {
        cur_sum += arr[index];
 
        // Sum of 0, 1, ...(i)th element
        int req_sum = (index * (index + 1)) / 2;
 
        // Check if valid or not
        if (req_sum > cur_sum) {
            possible = false;
            break;
        }
    }
 
    // If can be made strictly increasing
    if (possible)
        cout << "Yes";
    else
        cout << "No";
}
 
// Driver code
int main()
{
    int arr[3] = { 1, 2, 3 };
    int N = 3;
 
    CheckStrictlyIncreasing(arr, N);
    return 0;
}

                    

Java

// Java code to check if the given array
// can be made strictly increasing
import java.util.*;
 
class GFG{
 
// Function to check if
// the array can be made strictly increasing
static void CheckStrictlyIncreasing(int arr[],
                             int N)
{
    // variable to store sum till current
    // index element
    int cur_sum = 0;
    boolean possible = true;
    for (int index = 0;
         index < N; index++) {
        cur_sum += arr[index];
 
        // Sum of 0, 1, ...(i)th element
        int req_sum = (index * (index + 1)) / 2;
 
        // Check if valid or not
        if (req_sum > cur_sum) {
            possible = false;
            break;
        }
    }
 
    // If can be made strictly increasing
    if (possible)
        System.out.print("Yes");
    else
        System.out.print("No");
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3 };
    int N = 3;
 
    CheckStrictlyIncreasing(arr, N);
}
}
 
// This code is contributed by shikhasingrajput

                    

Python3

# Python 3 code to check if the given array
# can be made strictly increasing
 
# Function to check if
# the array can be made strictly increasing
def CheckStrictlyIncreasing(arr,
                            N):
 
    # variable to store sum till current
    # index element
    cur_sum = 0
    possible = True
    for index in range(N):
        cur_sum += arr[index]
 
        # Sum of 0, 1, ...(i)th element
        req_sum = (index * (index + 1)) // 2
 
        # Check if valid or not
        if (req_sum > cur_sum):
            possible = False
            break
 
    # If can be made strictly increasing
    if (possible):
        print("Yes")
 
    else:
        print("No")
 
# Driver code
if __name__ == "__main__":
 
    arr = [1, 2, 3]
    N = 3
 
    CheckStrictlyIncreasing(arr, N)
 
    # This code is contributed by ukasp.

                    

C#

// C# code to check if the given array
// can be made strictly increasing
using System;
 
class GFG{
 
// Function to check if the array can
// be made strictly increasing
static void CheckStrictlyIncreasing(int []arr,
                                    int N)
{
     
    // Variable to store sum till current
    // index element
    int cur_sum = 0;
    bool possible = true;
    for(int index = 0;
            index < N; index++)
    {
        cur_sum += arr[index];
 
        // Sum of 0, 1, ...(i)th element
        int req_sum = (index * (index + 1)) / 2;
 
        // Check if valid or not
        if (req_sum > cur_sum)
        {
            possible = false;
            break;
        }
    }
 
    // If can be made strictly increasing
    if (possible)
        Console.Write("Yes");
    else
        Console.Write("No");
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3 };
    int N = 3;
 
    CheckStrictlyIncreasing(arr, N);
}
}
 
// This code is contributed by shikhasingrajput

                    

Javascript

<script>
       // JavaScript code for the above approach
 
       // Function to check if
       // the array can be made strictly increasing
       function CheckStrictlyIncreasing(arr, N)
       {
            
           // variable to store sum till current
           // index element
           let cur_sum = 0;
           let possible = true;
           for (let index = 0;
               index < N; index++) {
               cur_sum += arr[index];
 
               // Sum of 0, 1, ...(i)th element
               let req_sum = (index * (index + 1)) / 2;
 
               // Check if valid or not
               if (req_sum > cur_sum) {
                   possible = false;
                   break;
               }
           }
 
           // If can be made strictly increasing
           if (possible)
               document.write("Yes");
           else
               document.write("No");
       }
 
       // Driver code
       let arr = [1, 2, 3];
       let N = 3;
 
       CheckStrictlyIncreasing(arr, N);
 
 // This code is contributed by Potta Lokesh
   </script>

                    

Output
Yes

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



Last Updated : 16 Dec, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads