LeetCode 896. Monotonic Array (Easy)

LeetCode 896. Monotonic Array: Hey there, coding enthusiasts! Welcome back to another exciting coding session. Today’s problem is a treat—literally! We’re going to solve the “Monotonic Array” or “LeetCode .896”

Approach for Leetcode 898: Monotonic Array

1. Initialization: We initialize a variable called check to 0, representing an unknown state. 1 denotes increasing, and -1 denotes decreasing.
2. Iterating Through the Array: We traverse the input array, starting from the second element.
3. Checking Monotonicity: For each pair of adjacent elements, we compare them to determine if the array is monotonic:
   • If the current element is greater than the previous one, we mark it as increasing.
   • If the current element is less than the previous one, we mark it as decreasing.
4. Validity Check: While checking, if we encounter a conflict (e.g., switching from increasing to decreasing), we return false, indicating the array is not monotonic.
5. Conclusion: If we successfully traverse the entire array without conflicts, we return true, indicating that the array is monotonic.

This solution solves the Leetcode problem 898, which checks if an array is monotonic, i.e., either entirely non-increasing or non-decreasing.

Codes : Approach for Leetcode 898

C++ : Leetcode 898: Monotonic Array

class Solution {
public:
    bool isMonotonic(vector<int>& nums) {
        if (nums.size() < 2) return true;

        int check = 0;  // 0 means unknown, 1 means increasing, -1 means decreasing

        for (size_t i = 1; i < nums.size(); i++) {
            if (nums[i] > nums[i-1]) {  // increasing
                if (check == 0) check = 1; 
                
                else if (check == -1) return false;
            } 
            
            else if (nums[i] < nums[i-1]) {  // decreasing
                
                if (check == 0) check = -1;
                else if (check == 1) return false;
            }
        }

        return true;
    }
};

LeetCode 905. Sort Array By Parity (Easy)

Java: Leetcode 898: Monotonic Array

import java.util.*;

public class Solution {
    public boolean isMonotonic(int[] nums) {
        if (nums.length < 2) return true;

        int check = 0;  // 0 means unknown, 1 means increasing, -1 means decreasing

        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {  // increasing
                if (check == 0) check = 1;
                else if (check == -1) return false;
            } else if (nums[i] < nums[i - 1]) {  // decreasing
                if (check == 0) check = -1;
                else if (check == 1) return false;
            }
        }

        return true;
    }
}

Leetcode 775. Find The Global and Local Inversions (Medium)

Python: Leetcode 898: Monotonic Array

class Solution:
    def isMonotonic(self, nums: List[int]) -> bool:
        if len(nums) < 2:
            return True

        check = 0  # 0 means unknown, 1 means increasing, -1 means decreasing

        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:  # increasing
                if check == 0:
                    check = 1
                elif check == -1:
                    return False
            elif nums[i] < nums[i - 1]:  # decreasing
                if check == 0:
                    check = -1
                elif check == 1:
                    return False

        return True

Leet Code: Rotate Array C++ Python || JavaScript || Java solution

JavaScript: Leetcode 898: Monotonic Array

var isMonotonic = function(nums) {
    if (nums.length < 2) return true;

    let check = 0;  // 0 means unknown, 1 means increasing, -1 means decreasing

    for (let i = 1; i < nums.length; i++) {
        if (nums[i] > nums[i - 1]) {  // increasing
            if (check == 0) check = 1;
            else if (check == -1) return false;
        } else if (nums[i] < nums[i - 1]) {  // decreasing
            if (check == 0) check = -1;
            else if (check == 1) return false;
        }
    }

    return true;
};

Result Analysis Leetcode 898: Monotonic Array