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

• Last Updated : 16 Dec, 2021

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 = [1, 2, 3]
Output: Yes
Explanation: The array is already sorted in strictly increasing order.

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

Input: arr = [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 ``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 = { 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

 ``

Output

`Yes`

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

My Personal Notes arrow_drop_up