这是我喜欢解决的 LeetCode 问题之一。我用 Golang 解决了这个问题，而且我已经是一个 Go 新手了，刚开始学习一周。

直觉

这个问题是实现计算器程序的另一个版本，该程序接受一个字符串并对其进行计算。您必须通过评估内部括号和外部括号来解决问题，直到得到最终结果。这些问题最好用堆栈来描述，您只需实现一个 CallStack，当打开新括号时，您将 Push 到堆栈，而当关闭它时，您只需从堆栈中 Pop 。最后关闭时我们调用 Eval 来获得最终结果。

我们的计算器中有3个操作可以完成，并且有一些关于它们的已知事实：

• AND：在找到假之前都是真（一个假就够了）
• OR：在找到 true 之前它是 false（一个 true 就足够了）
• Not：与 it 的论证相反。

所以，我们不需要维护每个操作的所有值来知道它的最终结果。 如果我们正在解决 AND，只要找到一个是否为假，如果OR，则维护是否找到真值，如果NOT，那么它已经是您要评估的一个值到它的对面。

方法

我们实现一个自定义结构：CallStack，它有 2 个切片，一个用于操作，一个用于我们要评估的值。
调用堆栈有方法：

• Push：用于将值和操作推送到我们拥有的 2 个切片。操作将新值推送到 2 个切片，并且值（t 或 f）仅修改值切片中最后输入的值。
• Pop：从2个切片中删除最后一个值，使用弹出操作评估弹出的值，并使用结果修改new弹出后的最后一个值。
• Eval：当它是最后一个右括号时调用，以使用操作切片中的最后一个剩余操作来评估值切片中的最后一个剩余值。

一旦发现错误，就结束 Ands 的评估，一旦找到 true，就结束对 Ors 的评估，可以进一步优化解决方案，如果您愿意，我会将其留给您做:)

复杂

• 时间复杂度：
  在）

• 空间复杂度：
  在）

代码

type CallStack struct {
    operations []string
    values []int
}

func NewCallStack() *CallStack {
    return &CallStack{
        operations: make([]string, 0),
        values:     make([]int, 0),
    }
}

func (s *CallStack) pushOperation(op string) {
    s.operations = append(s.operations, op)
    var newVal int 
    switch op {
    case Not: 
        newVal = 0
    default: 
        newVal = 1
    }
    s.values = append(s.values, newVal)
}

func (s *CallStack) pushValue(op string, char string) {
    switch op {
    case And: 
        if char == "f" {
            s.values[len(s.values)-1] = -1
        } 
    case Or: 
        if char == "t" {
            s.values[len(s.values)-1] = -1
        } 
    default: // Not
        if char == "t" {
            s.values[len(s.values)-1] = 1
        } else {
            s.values[len(s.values)-1] = -1
        }
    }
}

func (s *CallStack) Push(char string) {
    switch char {
    case Not, And, Or:
        s.pushOperation(char)
    default:
        s.pushValue(s.operations[len(s.operations) - 1], char)
    }
}

func eval(op string, val int) bool {
    switch op {
    case And:
        if val == 1 {
            return true
        } else {
            return false
        }
    case Or:
        if val == -1 {
            return true
        } else {
            return false
        } 
    default: // Not 
        if val