 GFG App
Open App Browser
Continue

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