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

impl Solution {
    pub fn min_length(s: String) -> i32 {
        let mut stack = vec![];
        let (mut pop_count, n) = (0, s.len());

        for bc in s.as_bytes().into_iter().copied() {
            if stack.is_empty() {
                stack.push(bc);
                continue;
            }

            let top = *stack.last().unwrap();

            if (top == b'A' && bc == b'B') || (top == b'C' && bc == b'D') {
                stack.pop();
                pop_count += 1;
                continue;
            }

            stack.push(bc);
        }

        (n - pop_count * 2) as i32
    }
}

class Solution {
    public int minLength(String s) {
        if (s.contains("AB")) {
            return minLength(s.replace("AB", ""));
        } else if (s.contains("CD")) {
            return minLength(s.replace("CD", ""));
        } else {
            return s.length();
        }
    }
}

class Solution:
    def minSwaps(self, s: str) -> int:
        openBracket = 0
        unBalanced = 0
        for char in s:
            if char == '[':
                openBracket+=1
            else:
                if openBracket == 0:
                    unBalanced += 1
                else:
                    openBracket -= 1

        return math.ceil(unBalanced/2)

class Solution:
    def minSwaps(self, s: str) -> int:
        result = 0
        for c in s:
            if c == '[':
                result += 1
            elif result > 0:
                result -= 1
        return (result + 1) // 2

function minSwaps(s: string): number {
    const n = s.length;
    let st = 0
    let res = 0;
    for (let i = 0; i <n ; i++) {
        if (s[i] === '[') st++;
        else {
            if (st) st--;
            else res++
        }
    }
    return (res + 1) >> 1
};

class Solution {
public:
    int minSwaps(string s) {
        int count = 0;
        int n = s.size();
        int res = 0;
        for (int i = 0; i < n; ++i){
            if (s[i] == '[') {
                count += 1;
            }
            if (s[i] == ']') {
                count -= 1;
            }
            if (count < 0) {
                res++;
                count += 2;
            }
            // cout << count << " " << s[i] << "\n";
        }
        return res;
    }
};

class Solution {
    public int minSwaps(String s) {
        int n = s.length();
        int pair = n/2;
        int open = 0;
        int valid=0;
        for(char c: s.toCharArray() ){
            if(c=='[') open++;
            else{
                if(open>0){
                    open--;
                    valid++;
                }
            }
        }
        return (pair-valid)/2 + (pair-valid)%2;
    }
}

class Solution {
    public int minSwaps(String s) {
        int open = 0;
        int bad = 0;
        char c;

        for (int i = 0; i < s.length(); i++) {
            c = s.charAt(i);
            if (c == '[')
                open++;

            else if (open == 0)
                bad++;
                
            else
                open--;
        }

        return bad % 2 == 0 ? bad / 2 : bad / 2 + 1;
    }
}

import java.util.*;

class Solution {
    public int minSwaps(String s) {
        int n = s.length();
        //StringBuilder str = new StringBuilder(s);
        int endOpeningBracket = n-1;
        int numberClose = 0;
        int numberOpen = 0;
        int res = 0;
        for(int i = 0;i<n;i++){
            if(s.charAt(i)==']')
                numberClose++;
            else
                numberOpen++;
            if(numberClose>numberOpen){
                int j = getEndOpeningBracket(s,endOpeningBracket,i);
                // s[i] = '[';
                // s[j] = ']';
                res++;
                numberClose--;
                numberOpen++;
                endOpeningBracket=j-1;
            }
        }
        return res;
    }

    int getEndOpeningBracket(String s, int n, int start){
        for(int i=n; i>=(n-start+1)/2;i--){
            if(s.charAt(i) == '[')
                return i;
        }
        return 0;
    }
}

class Solution {
    public int minSwaps(String s) {
        int count = 0;
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (c == '[') stack.push(c);
            else if (c == ']') {
                if (stack.empty()) count++;
                else stack.pop();
            }
        }
        return (count + 1) / 2;
    }
}

class Solution:
    def minSwaps(self, s: str) -> int:
        open = 0
        close = 0
        for i in range(0, len(s)):
            if s[i] == '[':
                open += 1
            if s[i] == ']':
                if open == 0:
                    close += 1
                else:
                    open -= 1
        return int((close + 1)/ 2)

class Solution:
    def minSwaps(self, s: str) -> int:
        opens = 0
        for c in s:
            if c == ']' :
                if opens > 0 :
                    opens -= 1
            else:
                opens += 1
        
        return (opens + 1) // 2

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

class Solution {
public:
    int minSwaps(string s) {
        int c=0,res=0;
        for(auto x:s){
            if(x==']') c+=1;
            else c-=1;
            res=max(res,(c+1)/2);
        }
        return res;
    }
};