def isBalanced(s):
    left, right = ["(", "{", "["], [")", "}", "]"]
    stack = []
    for char in s:
        # add opening brackets to the stack
        if char in left:
            stack.append(char)
        # if it's a right bracket:
        else:       
            # closing bracket appears without an opening bracket
            if not stack:
                return "NO"     
            # check the last opening bracket in the stack
            idx = right.index(char) 
            if stack.pop() == left[idx]:    # remove last bracket in-place
                continue
            return "NO"    # closing bracket didn't find an opening match
    return "NO" if stack else "YES"     # "YES" if stack is empty  

string isBalanced(string s) {
    unordered_map<char, char> map = {
        {'(', ')'},
        {'{', '}'},
        {'[', ']'}
    };
    
    stack<char> sc;
    for (char c : s) {
        if (map.count(c))
            sc.push(map[c]);
        else {
            if (sc.empty() || sc.top() != c)
                return "NO";
            sc.pop();
        }
    }
    
    return (sc.empty()) ? "YES" : "NO";
}

s = list(s)
    if len(s) % 2 != 0:
        return ('NO')
    char_dict = {"{":"}","[":"]",'(':')'}
    left_pt = 0

    while s != []:
        starting = s[left_pt]
        if starting not in char_dict.keys():
            return ('NO')
        target = char_dict[starting]
        if s[left_pt+1] == target:
            s.pop(left_pt)
            s.pop(left_pt)
            left_pt = 0
        else:
            left_pt += 1
            if left_pt == len(s)-1 and s != []:
                return ('NO')
    return ('YES')

function isBalanced(s: string): string {
    let s_memo = ''

    while (s_memo != s && s.length > 0) {
        s_memo = s
        s = s.replace(/(\[\]|\{\}|\(\))/g, '')
    }

    return s.length > 0 ? 'NO' : 'YES'
}