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

class Solution {
    public boolean areSentencesSimilar(String sentence1, String sentence2) {
        String shorterStr, longerStr;
        if (sentence1.split(" ").length < sentence2.split(" ").length) {
            shorterStr = sentence1;
            longerStr = sentence2;
        } else {
            shorterStr = sentence2;
            longerStr = sentence1;
        }

        String[] arr1 = shorterStr.split(" "), arr2 = longerStr.split(" ");
        int n = arr1.length, m = arr2.length;

        int idx = 0;
        while (idx < n) {
            if (!arr1[idx].equals(arr2[idx])) {
                break;
            }
            idx++;
        }

        while (idx < n) {
            if (!arr1[idx].equals(arr2[m - n + idx])) {
                return false;
            }
            idx++;
        }

        return true;
    }
}

class Solution {
    public boolean areSentencesSimilar(String s1, String s2) {
        if (s1 == s2 || s1.equals(s2)) return true;
        return s1.length() < s2.length() ? isSimilar(s1, s2) : isSimilar(s2, s1);
    }
    static boolean isSimilar(String s1, String s2) {
        String[] a1 = s1.split(" "), a2 = s2.split(" ");
        int l1 = -1, l2 = -1;
        while (++l1 < a1.length && ++l2 < a2.length) if (!a1[l1].equals(a2[l2])) break;
        if (l1 == a1.length) return true;
        int r1 = a1.length - 1, r2 = a2.length - 1;
        while (r1 >= l1 && r2 >= l2) if (!a2[r2--].equals(a1[r1--])) return false;
        return r1 < l1;
    }
}

class Solution:
    # 2 pointers, if L_short == R_short => similar
    # len(s1) > len(s2)
    def _areSentencesSimilar(self, s1, s2):
        l2, r2 = 0, len(s2) - 1
        l1, r1 = 0, len(s1) - 1

        while l2 <= r2:
            if s2[l2] != s1[l1] and s2[r2] != s1[r1]:
                return False
            elif s2[l2] == s1[l1]:
                l1, l2 = l1 + 1, l2 + 1
            elif s2[r2] == s1[r1]:
                r1, r2 = r1 - 1, r2 - 1
            elif s2[l2] != s1[l1]:
                r1, r2 = r1 - 1, r2 - 1
            elif s2[r2] != s1[r1]:
                l1, l2 = l1 + 1, l2 + 1

        return True

    def areSentencesSimilar(self, sentence1: str, sentence2: str) -> bool:
        s1 = sentence1.split(" ")
        s2 = sentence2.split(" ")
       
        if len(s1) > len(s2):
            return self._areSentencesSimilar(s1, s2)
        else:
            return self._areSentencesSimilar(s2, s1)

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

        return n

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

        return len(charStack)

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

function minLength(s: string): number {
    const st: string[] = [];
    for (let i = 0; i < s.length; i++) {
        if(!st.length) {
            st.push(s[i]);
            continue;
        }
        if (s[i] === 'B' && st[st.length - 1]  === 'A') st.pop();
        else if (s[i] === 'D' && st[st.length - 1] === 'C') st.pop();
        else st.push(s[i])
    }
    return st.length;
};

class Solution {
    public int minLength(String s) {
        Stack<Character> stack = new Stack<>();

        for (char c: s.toCharArray()) {
            if (!stack.isEmpty() && ((c == 'B' && stack.peek() == 'A') || (c == 'D' && stack.peek() == 'C'))) {
                stack.pop();
            } else {
                stack.push(c);
            }
        }

        return stack.size();
    }
}

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

public int minLength(String s) {
    int i;
    StringBuilder builder = new StringBuilder(s);
    while ((i = builder.indexOf("AB")) != -1 || (i = builder.indexOf("CD")) != -1) {
        builder.delete(i, i + 2);
    }
    return builder.length();
}