1909. Remove One Element to Make the Array Strictly Increasing

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`

1909. Remove One Element to Make the Array Strictly Increasing
``````struct Solution;

impl Solution {
fn can_be_increasing(nums: Vec<i32>) -> bool {
let n = nums.len();
for i in 0..n {
let mut v = vec![];
for j in 0..n {
if i == j {
continue;
}
v.push(nums[j]);
}
if Self::is_increasing(&v) {
return true;
}
}
false
}

fn is_increasing(nums: &[i32]) -> bool {
let n = nums.len();
for i in 1..n {
if nums[i] <= nums[i - 1] {
return false;
}
}
true
}
}

#[test]
fn test() {
let nums = vec![1, 2, 10, 5, 7];
let res = true;
assert_eq!(Solution::can_be_increasing(nums), res);
let nums = vec![2, 3, 1, 2];
let res = false;
assert_eq!(Solution::can_be_increasing(nums), res);
let nums = vec![1, 1, 1];
let res = false;
assert_eq!(Solution::can_be_increasing(nums), res);
let nums = vec![1, 2, 3];
let res = true;
assert_eq!(Solution::can_be_increasing(nums), res);
}
``````