thảo luận Leetcode mỗi ngày

class Solution {
    public int minAddToMakeValid(String s) {
        int count = 0;
        int open = 0;
        
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(')
                open++;

            else if (open > 0)
                open--;
            
            else
                count++;
        }
        
        return count + open;
    }
}

class Solution {
    public int minAddToMakeValid(String s) {
        int open =0;
        int close =0;
        for(char c: s.toCharArray()){
            if(c=='('){
                open++;
            }
            else{
                if(open==0) close++;
                else open--;
            }
        }
        return open +close;
    }
}

class Solution {
    public int minAddToMakeValid(String s) {
        int numberClose = 0;
        int numberOpen = 0;
        int res = 0;
        for(int i = 0; i<s.length();i++){
            if(s.charAt(i) == '('){
                numberOpen++;
            }
            else {
                if(numberOpen == 0)
                    res++;
                else
                    numberOpen--;   
            }
        }
        if(numberOpen>0)
            res+= numberOpen;
        return res;
    }
}

class Solution {
    func minAddToMakeValid(_ s: String) -> Int {
        var result = 0
        var state = 0
        for char in s {
            if char == "(" {
                state += 1
            } else {
                state -= 1
            }
            if state < 0 {
                result += 1
                state = 0
            }
        }
        return result + state
    }
}

var minAddToMakeValid = function(s) {
    let ans = 0, l = 0;
    for (const ch of s) {
        if (ch === '(') {
            l++;
        } else {
            if (l > 0) {
                l--;
            } else {
                ans++;
            }
        }
    }
    return ans + l;
};

class Solution {
    public int minAddToMakeValid(String s) {
        int open = 0;
        int close = 0;
        for(char c:s.toCharArray()){
            if (c=='(')
                    open++;
            else{
                if(open>0)
                    open--;
                else
                    close++;
            }          
        }
        return open+close;
    }
}

class Solution {
    public int minAddToMakeValid(String s) {
        int count = 0, res = 0;

        for (char ch : s.toCharArray()) {
            if (ch == '(') {
                count++;
                res++;
            } else {
                if (count != 0) {
                    count--;
                    res--;
                } else {
                    res++;
                }
            }
        }

        return res;
    }
}

class Solution:
    def maxWidthRamp(self, nums: List[int]) -> int:
        n =len(nums)
        stack = []

        for i, num in enumerate(nums):
            if not stack or stack[-1][0] > num:
                stack.append((num, i))
        
        result = 0
        for i in range(n-1,-1, -1):
            while stack and stack[-1][0] <= nums[i]:
                if result < i - stack[-1][1]:
                    result = i - stack[-1][1]
                stack.pop()
        return result

class Solution {
public:
    int maxWidthRamp(vector<int>& nums) {
        stack<int> st;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            if (st.empty() || nums[i] < nums[st.top()]) {
                st.push(i);
            }
        }
        int ans = 0;
        for (int i = n - 1; i >= 0; i--) {
            while(!st.empty() && nums[i] >= nums[st.top()]) {
                ans = max(ans, i - st.top());
                st.pop();
            }
        }

        return ans;
    }
};

var maxWidthRamp = function (nums) {
    let ans = 0, lm = null;
    const n = nums.length,
        indices = Array.from({ length: n })
            .map((_, idx) => idx)
            .sort((u, v) => nums[u] - nums[v]);
    for (let i = 0; i < n;) {
        const k = nums[indices[i]];
        let clm = lm ?? +Infinity, crm = -1;
        for (; nums[indices[i]] === k; i++) {
            ans = Math.max(ans, indices[i] - clm);
            ans = Math.max(ans, crm - indices[i]);
            clm = Math.min(clm, indices[i]);
            crm = Math.max(crm, indices[i]);
        }
        lm = clm;
    }
    return ans;
};

class Solution {
    public int maxWidthRamp(int[] nums) {
        int n = nums.length;
        int max = 0;
        Stack<Integer> stack = new Stack();
        for (int i = 0; i < n; i++) {
            if (stack.empty() || nums[stack.peek()] > nums[i]) {
                stack.push(i);
            }
        }
        for (int i = n - 1; i >= 0; i--) {
            while (!stack.empty() && nums[i] >= nums[stack.peek()])
                max = Math.max(i - stack.pop(), max);
        }
        return max;
    }
}

class Solution {
    struct SavedIndex {
        let index: Int
        let value: Int
    }
    func maxWidthRamp(_ nums: [Int]) -> Int {
        var stack:[SavedIndex] = []
        var last = Int.max
        for (index, num) in nums.enumerated() {
            if last > num {
                stack.append(SavedIndex(index:index, value: num))
                last = num
            }
        }
        var maxWidth = 0
        for (index, num) in nums.enumerated().reversed() {
            while let lastS = stack.last, lastS.value <= num {
                maxWidth = max(maxWidth, index - lastS.index)
                stack.removeLast() // Due to this is maxwidth for this SavedIndex
            }
        }
        return maxWidth
    }
}

class Solution {
    public int maxWidthRamp(int[] nums) {
        int n = nums.length;
        int res = 0;
        int[] suffix_max = new int[n];
        suffix_max[n-1] = nums[n-1];
        for(int i =n-2;i>=0;i--){
            suffix_max[i] = Math.max(suffix_max[i+1],nums[i]);
        }
        //System.out.println(Arrays.toString(suffix_max));
        int l =0 ;
        int r =0;
        while(r<n){
            while(l<r && nums[l]>suffix_max[r]) l++;
            res= Math.max(res, r-l);
            r++;
        }
        return res;
    }
}

class Solution:
    def maxWidthRamp(self, nums: List[int]) -> int:
        ans = 0
        stack = []
        for i,n in enumerate(nums):
            if not stack or stack[-1][1] > n:
                stack.append((i, n))
        
        for i in range(len(nums) - 1, -1, -1):
            while stack and stack[-1][1] <= nums[i]:
                ans = max(ans, i - stack.pop()[0])
        return ans

class Solution:
    def maxWidthRamp(self, a: List[int]) -> int:
        stack = []
        for i, v in enumerate(a):
            if not stack or a[stack[-1]] > v:
                stack.append(i)
        idx = len(a) - 1
        res = 0
        while idx >= 0:
            while stack and a[stack[-1]] <= a[idx]:
                res = max (res, idx - stack.pop())
            idx -= 1
        return res