##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1909.html

# 1909. Remove One Element to Make the Array Strictly Increasing

Easy

## Description

Given a 0-indexed integer array nums, return true if it can be made strictly increasing after removing exactly one element, or false otherwise. If the array is already strictly increasing, return true.

The array nums is strictly increasing if nums[i - 1] < nums[i] for each index (1 <= i < nums.length).

Example 1:

Input: nums = [1,2,10,5,7]

Output: true

Explanation: By removing 10 at index 2 from nums, it becomes [1,2,5,7]. [1,2,5,7] is strictly increasing, so return true.

Example 2:

Input: nums = [2,3,1,2]

Output: false

Explanation:

[3,1,2] is the result of removing the element at index 0.

[2,1,2] is the result of removing the element at index 1.

[2,3,2] is the result of removing the element at index 2.

[2,3,1] is the result of removing the element at index 3.

No resulting array is strictly increasing, so return false.

Example 3:

Input: nums = [1,1,1]

Output: false

Explanation: The result of removing any element is [1,1].

[1,1] is not strictly increasing, so return false.

Example 4:

Input: nums = [1,2,3]

Output: true

Explanation: [1,2,3] is already strictly increasing, so return true.

Constraints:

• 2 <= nums.length <= 1000
• 1 <= nums[i] <= 1000

## Solution

For each index, try to remove the element at the index and check whether the remaining elements are strictly increasing. If there exists at least one element that makes the remaining elements strictly increasing, return true. Otherwise, return false.

If the array is already strictly increasing, then after removing any element, the remaining elements are also strictly increasing, so return true.

• class Solution {
public boolean canBeIncreasing(int[] nums) {
int length = nums.length;
for (int i = 0; i < length; i++) {
if (isIncreasing(nums, i))
return true;
}
return false;
}

public boolean isIncreasing(int[] nums, int index) {
int length = nums.length;
int prev = -1;
for (int i = 0; i < length; i++) {
if (i != index) {
int curr = nums[i];
if (curr <= prev)
return false;
prev = curr;
}
}
return true;
}
}

############

class Solution {
public boolean canBeIncreasing(int[] nums) {
int i = 1, n = nums.length;
for (; i < n && nums[i - 1] < nums[i]; ++i)
;
return check(nums, i - 1) || check(nums, i);
}

private boolean check(int[] nums, int i) {
int prev = Integer.MIN_VALUE;
for (int j = 0; j < nums.length; ++j) {
if (i == j) {
continue;
}
if (prev >= nums[j]) {
return false;
}
prev = nums[j];
}
return true;
}
}

• // OJ: https://leetcode.com/problems/remove-one-element-to-make-the-array-strictly-increasing/
// Time: O(N^2)
// Space: O(1)
class Solution {
public:
bool canBeIncreasing(vector<int>& A) {
int N = A.size();
for (int i = 0; i < N; ++i) {
bool good = true;
int prev = 0;
for (int j = 0; j < N && good; ++j) {
if (i == j) continue;
good = A[j] > prev;
prev = A[j];
}
if (good) return true;
}
return false;
}
};

• class Solution:
def canBeIncreasing(self, nums: List[int]) -> bool:
def check(nums, i):
prev = -inf
for j, num in enumerate(nums):
if i == j:
continue
if prev >= nums[j]:
return False
prev = nums[j]
return True

i, n = 1, len(nums)
while i < n and nums[i - 1] < nums[i]:
i += 1
return check(nums, i - 1) or check(nums, i)

############

# 1909. Remove One Element to Make the Array Strictly Increasing
# https://leetcode.com/problems/remove-one-element-to-make-the-array-strictly-increasing/

class Solution:
def canBeIncreasing(self, arr: List[int]) -> bool:
count = 0
n = len(arr)

for i in range(n):
valid = True
last = 0
for j in range(n):
if j == i: continue
if arr[j] <= last:
valid = False
break

last = arr[j]

if valid: count += 1

return count != 0

• func canBeIncreasing(nums []int) bool {
i, n := 1, len(nums)
for ; i < n && nums[i-1] < nums[i]; i++ {

}
return check(nums, i-1) || check(nums, i)
}

func check(nums []int, i int) bool {
prev := 0
for j := 0; j < len(nums); j++ {
if i == j {
continue
}
if prev >= nums[j] {
return false
}
prev = nums[j]
}
return true
}

• function canBeIncreasing(nums: number[]): boolean {
const check = (p: number) => {
let prev = undefined;
for (let j = 0; j < nums.length; j++) {
if (p != j) {
if (prev !== undefined && prev >= nums[j]) {
return false;
}
prev = nums[j];
}
}
return true;
};
for (let i = 0; i < nums.length; i++) {
if (nums[i - 1] >= nums[i]) {
return check(i - 1) || check(i);
}
}
return true;
}

• impl Solution {
pub fn can_be_increasing(nums: Vec<i32>) -> bool {
let check = |p: usize| -> bool {
let mut prev = None;
for j in 0..nums.len() {
if p != j {
if let Some(value) = prev {
if value >= nums[j] {
return false;
}
}
prev = Some(nums[j]);
}
}
true
};
for i in 1..nums.len() {
if nums[i-1] >= nums[i] {
return check(i-1) || check(i)
}
}
true
}
}