Необходимо проверить, что скобки в данном массиве сбалансированы или нет

Чтобы сделать это правильно, вам нужен stack для поддержания открывающих скобок. Когда вы получите открывающую скобку, положите ее на стопку. Когда вы получите закрывающую скобку, вытолкните верхнюю открывающую скобку из стопки и убедитесь, что они совпадают. Когда вы закончите анализ строки, stack должно быть пустым.

enum Balance {
    case balanced
    case unbalanced(String)
}

func checkBalance(_ str: String) -> Balance {
    var stack = [Character]()

    for char in str {
        if ["{", "(", "["].contains(char) {
            stack.append(char)
        } else if ["}", ")", "]"].contains(char) {
            if let top = stack.popLast() {
                switch (top, char) {
                case ("{", "}"), ("(", ")"), ("[", "]"):
                    break
                default:
                    return .unbalanced("mismatched braces: \(top), \(char)")
                }
            } else {
                return .unbalanced("unexpected close brace: \(char)")
            }
        }
    }
    if !stack.isEmpty {
        return .unbalanced("missing \(stack.count) closing braces")
    }
    return .balanced
}

Тесты:

checkBalance("{ [ ( ) ] }")

.balanced

checkBalance("{ [ ] { } }")

.balanced

checkBalance("[(")

[ 116]

checkBalance("{ [ ( ) }")

.unbalanced("mismatched braces: [, }")

checkBalance("}")

.unbalanced("unexpected close brace: }")

---

Примечание:

[ 1122] checkBalance возвращает перечисление типа Balance. Чтобы проверить, равен ли результат .balanced, вы должны сделать это следующим образом:

if case .balanced = checkBalance("() { [ ] }") {
    // handle balanced case
} 

или можете использовать switch:

switch checkBalance("() { [ ] }") {
case .balanced:
    // do something if balanced
case .unbalanced(let reason):
    print("Not balanced: \(reason)")
}

Просто для удовольствия. Может не содержать длинные строки (~ 60 уровней левых символов, но идеально подходит для большинства случаев редактирования).

Это то же самое, что и стек. 2 целых числа составляют стек. 00 - пусто, 11, 01, 10 из каждой самой правильной цифры, представляющей «(« «[« и «{». Скажите, есть ли ошибка. Надеемся, что она работает быстрее, чем концептуальный стек.

Например, «» (({} [])) "Изначально это 0 0 как целые числа в стеке.

        0 0
 "(" -> 1 1.  (  0<<1 + 1 , 0<<1 + 1 ) //push
 "(" -> 3 3   (  1<<1 + 1 , 1<<1 + 1 ) //push
 "{" -> 7 6.  (  3<<1 + 1,  3<<1 + 0 ) //push
 "}" -> 3 3.  (  7>>1 ,  6 >>1) //pop
 "[" -> 6 7.  (  3<<1 + 0, 3<<1 + 1) //push
 "]" -> 3 3.  (  6>>1 , 7>>1 ) //pop
 ")" -> 1 1.  (  3>>1 , 3>>1 ) //pop
 ")" -> 0 0.  (  1>>1 , 1>>1 ) //pop

Он сбалансирован.

    func test(_ s: String) -> Bool{
        var os1 : Int = 0;   var os2 : Int = 0
        for c in s{
            switch (c, os1 & 0x1, os2 & 0x1) {
            case ("(",_,_):  os1 <<= 0x1 ;  os1 |= 0x1 ; os2 <<= 0x1 ; os2 |= 0x1
            case ("[",_,_):  os1 <<= 0x1 ;  os1 |= 0x0 ; os2 <<= 0x1 ; os2 |= 0x1
            case ("{", _,_): os1 <<= 0x1 ;  os1 |= 0x1 ; os2 <<= 0x1 ; os2 |= 0x0
            case (")",0x1, 0x1), ("]",0x0, 0x1),("}",0x1, 0x0):  os1 >>= 0x1 ;  os2 >>= 0x1
            case (")",_ ,_),("]", _, _), ("}", _, _):  return false
            default: break
            }
        }
        return os1 == 0 && os2 == 0
    }


    print (test("[((([])))]"))
    print (test("[[[[]]]][[[[]]]]")) 

Будут переданы другие символы, так что это может быть используется в развивающихся ситуациях.

    print (test("[((hello([]))my)]")) 

Вот решение, которое я придумал:

func checkParentheses(s: String) -> Bool {
    let pairs: [Character: Character] = ["(": ")", "[": "]", "{": "}"]
    var stack: [Character] = []
    for char in s {
        if let match = pairs[char] {
            stack.append(match)
        } else if stack.last == char {
            stack.popLast()
        } else {
            return false
        }
    }
    return stack.isEmpty
}

Тестовые случаи:

print(checkParentheses(s: "((({[]})))")) // True (Balanced)
print(checkParentheses(s: "((({[]}))")) // False (Not Balanced)
print(checkParentheses(s: "(]")) // False (Not Balanced)

Все, что мы здесь делаем, это итерация по каждому Character в String , Если мы найдем начальную скобку т.е. "(", тогда мы помещаем конечную скобку в стек, т. е. ")". Мы делаем это до тех пор, пока текущий символ является начальной скобкой.

Как только мы находим конечную скобку, она должна быть последним символом в стеке в зависимости от того, как мы их добавляли. Если это правда, тогда круглые скобки были действительны, и мы можем продолжить.

Если ничего из вышеперечисленного не соответствует действительности, у нас либо есть недопустимый символ (не скобки), либо случай, когда скобки не сбалансированы. С этим, как говорится, мы можем return false здесь.

После итерации каждого символа в строке наш стек будет пустым, если круглые скобки были сбалансированы. Если стек не пустой, это означает, что скобки не сбалансированы.