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

class Solution:
    def minLength(self, s: str) -> int:
        l = 0
        r = 1
        while True:
            if r >= len(s):
                break
            if (s[l] == 'A' and s[r] == 'B') or (s[l] == 'C' and s[r] == 'D'):
                s = s[:l] + s[r + 1:]
                r = 1
                l = 0
                continue
            l += 1
            r += 1
        return len(s)

public static int minLength(String s) {
    Stack<Character> stack = new Stack<>();
    for (int i = 0; i < s.length(); i++) {
        if(stack.empty()) stack.push(s.charAt(i));
        else {
            if((stack.peek() == 'A' && s.charAt(i) == 'B') || (stack.peek() == 'C' && s.charAt(i) == 'D')) stack.pop();
            else stack.push(s.charAt(i));
        }
    }
    return stack.size();
}

public class Solution {
    public int MinLength(string s) {
    Stack<char> qr = new Stack<char>();
    for (int i = 0; i < s.Length; i++)
    {
      if (qr.Count > 0)
      {
        if ((s[i] == 'B' && qr.Peek() == 'A') || (s[i] == 'D' && qr.Peek() == 'C'))
        {
          qr.Pop();
          continue;
        }
      }
      qr.Push(s[i]);
    }
    return qr.Count;
    }
}

class Solution {
    public int minLength(String s) {
        int len = s.length() - 1;

        while(s.length() != len) {
            len = s.length();
            s = s.replace("AB", "");
            s = s.replace("CD", "");
        }

        return s.length();
    }
}

class Solution {
    const AB = 'AB';
    const CD = 'CD';

    /**
     * @param String $s
     * @return Integer
     */
    function minLength($s) {
        while (strpos($s, self::AB) !== false || strpos($s, self::CD) !== false) {
            $s = str_replace([self::AB, self::CD], '', $s);
        }

        return strlen($s);
    }
}

class Solution:
    def minLength(self, s: str) -> int:
        stack = []
        for c in s:
            if c == 'B' and stack and stack[-1] == 'A':
                stack.pop()
            elif c == 'D' and stack and stack[-1] == 'C':
                stack.pop()
            else:
                stack.append(c)
        return len(stack)

class Solution {
public:
    int minLength(string s) {
        stack<char> myStack;
        for (int i = 0; i < s.length(); i++){
            if (myStack.empty()){
                myStack.push(s[i]);
            }else{
                if ((myStack.top() == 'A' and s[i] == 'B') || (myStack.top() == 'C' and s[i] == 'D')){
                    myStack.pop();
                }else{
                    myStack.push(s[i]);
                }
            }
        }
        return myStack.size();
    }
};

class Solution {
    func minLength(_ s: String) -> Int {
        var stack:[Character] = []
        let map = [Character("B"):Character("A"), Character("D"):Character("C")]
        for c in s {
            if let mapC = map[c] {
                if let last = stack.last, last == mapC {
                    stack.removeLast()
                    continue
                }
            }
            stack.append(c)
        }
        return stack.count
    }
}

class Solution {
    public int minLength(String s) {
        Stack<Character> stack = new Stack();
        int remove = 0;
        for(char c:s.toCharArray()){
            if(!stack.isEmpty()){
                if (c==stack.peek()){
                    stack.pop();
                    remove+=2;
                    continue;
                }
            }
            if(c=='A')
                stack.add('B');
            else if(c=='C')
                stack.add('D');
            else
                stack.clear();
        }
        return s.length() - remove;
    }
}

class Solution {
    public int minLength(String s) {
        Stack<Character> stack = new Stack();
        stack.add('Z');
        for(char c:s.toCharArray()){
            if(c=='B' && stack.peek()=='A'||
                c=='D' && stack.peek()=='C')
                    stack.pop();
            else
                stack.add(c);
        }
        return stack.size()-1;
    }
}

class Solution {
    public int minLength(String s) {
        int n = s.length();
        int res = n;
        int l = 0;
        int r = 1;
        boolean[] removed = new boolean[n];
        while (r < n) {
            char lc = s.charAt(l);
            char rc = s.charAt(r);
            if ((lc == 'A' && rc == 'B') || (lc == 'C' && rc == 'D')) {
                res -= 2;
                removed[l] = true;
                removed[r] = true;
                while (l >= 0 && removed[l] == true) {
                    l--;
                }
                r++;
                if (l < 0) {
                    l = r;
                    r++;
                }

            } else {
                l++;
                while (removed[l] == true) {
                    l++;
                }
                r = l + 1;
            }
        }
        return res;
    }
}

class Solution {
    public int minLength(String s) {
        int n = s.length();
        char[] stack = new char[n];
        int peek=-1;
        for(char c:s.toCharArray()){
            if(peek!=-1){
                if((stack[peek] == 'A' && c=='B') || (stack[peek] == 'C' && c=='D') ) {
                    peek--;
                    continue;
                }
            }
            stack[++peek] = c;
        }
        return peek+1;
    }
}

class Solution {
public:
    int minLength(string s) {
        auto stack = std::vector<char>();
        for (auto& c : s) {
            if (stack.empty()) { stack.push_back(c); continue; }

            if ((c == 'B' && stack.back() == 'A') || (c == 'D' && stack.back() == 'C')) { stack.pop_back(); }
            else stack.push_back(c);
        }
        return stack.size();
    }
};