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

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++ 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 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 

# 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# 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 

 <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>

Yes

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

geekyss

Follow

Improve

Article Tags :

• Pattern Searching
• Mathematical
• DSA
• Arrays
• Sequence and Series

+1 More

Practice Tags :

• Arrays
• Mathematical
• Pattern Searching