面试复盘：十五分钟拿Offer与一道Lisp语法解析题

十五分钟面完就接offer，HR还专门打电话念了一大段面试评价，这种剧情在今天的招聘市场里，已经算得上是锦鲤附体了。

不得不说，这种即时且正向的反馈真的挺稀有的。现在有多少面试，聊完后就像石头扔进了水沟，连个响儿都听不见。你这边刚起身告辞，人家那边已经完成了对你的优点总结，并且顺手发出了录用通知。这至少说明了两点：一是岗位需求确实比较紧急，二是你的表现确实非常对味，HR在打电话的时候，可能都怕晚一步你被别人抢走。

评论区肯定有人会说，“这公司是不是太缺人了”，也有人会酸一句“先别高兴太早”。这些话也不能说全错，入职前该确认的事项，比如团队氛围、加班强度、试用期规则等，一个都别漏，该问清楚的一定要问。但话说回来，在求职过程中，经历过太多“已读不回”的冷漠后，能碰上这种被认真对待的体验，真的会让人心里一松。找工作最烦的就是悬而未决的状态，这种干脆利落的劲儿，哪个打工人会不喜欢呢？

算法题：Lisp 语法解析

像 (add 1 (mult 2 3)) 这样的表达式，很多人第一反应是用递归来解。但真正动手写起来，十有八九会在处理括号、空格、负数、特别是变量作用域这几个地方翻车。

Lisp 语法解析这道题，真正的难点并不在于“会不会写DFS递归”，而在于你是否把“表达式求值”和“变量作用域”这两个概念分开想清楚了。尤其是 let 表达式最容易写歪：它允许前面定义的变量在后面表达式中使用，并且同名变量还能覆盖上一层的定义。这个地方，我一般不太相信那些上来就暴力切分字符串的解法，后面调试时很容易把自己绕进去。

先看一个最小的例子：

expr = "(let x 2 (mult x (let x 3 y 4 (add x y))))"

外层 x=2，内层又把 x 改成了 3，所以 (add x y) 算出来是 7，最终结果是 2 * 7 = 14。这道题如果没有“环境栈”或者作用域链的意识，代码基本写不稳。

我自己的处理习惯分为两步：

第一步，先把当前表达式拆分成一个个token，但这个拆分不能简单地用 split()，因为括号里的子表达式是一个整体，不能拆散。
第二步，遇到 add、mult 就算两个子表达式的和或积；遇到 let 就按照“成对出现（变量名, 值），最后一个表达式是返回值”的规则来处理。

代码不用写得多么花哨，稳健最重要：

class Solution:
    def evaluate(self, expression: str) -> int:
        return self.eval_expr(expression, {})

    def eval_expr(self, exp: str, env: dict) -> int:
        if exp[0] != '(':
            if exp[0] == '-' or exp[0].isdigit():
                return int(exp)
            return env[exp]

        inner = exp[1:-1]
        parts = self.parse(inner)

        op = parts[0]
        if op == 'add':
            return self.eval_expr(parts[1], env.copy()) + self.eval_expr(parts[2], env.copy())
        if op == 'mult':
            return self.eval_expr(parts[1], env.copy()) * self.eval_expr(parts[2], env.copy())

        scope = env.copy()
        i = 1
        while i < len(parts) - 1:
            if i == len(parts) - 2:
                return self.eval_expr(parts[i], scope)
            name = parts[i]
            val = self.eval_expr(parts[i + 1], scope)
            scope[name] = val
            i += 2
        return self.eval_expr(parts[-1], scope)

    def parse(self, s: str):
        res = []
        bal = 0
        cur = []
        for ch in s:
            if ch == ' ' and bal == 0:
                if cur:
                    res.append(''.join(cur))
                    cur = []
                continue
            if ch == '(':
                bal += 1
            elif ch == ')':
                bal -= 1
            cur.append(ch)
        if cur:
            res.append(''.join(cur))
        return res

这里有两个细节非常关键。

一个是 parse() 函数里用 bal 来记录括号的嵌套层数。只有在 bal == 0 时，遇到空格才是真正的分隔符。这个小地方如果没处理好，像 (add 1 (mult 2 3)) 这样的表达式会被切成一堆碎片。

另一个是 let 表达式的求值顺序。比如：

"(let x 1 y (add x 2) (add x y))"

计算 y 的值 (add x 2) 时，x 已经被赋值为 1 了，所以 y=3，最后 (add x y) 的结果是 4。这也是为什么我在处理 let 时，不是先批量收集所有变量名和值，再统一赋值，而是边计算边将结果塞进当前作用域 scope 里的原因。

这种题目表面上是字符串处理题，实际上更像是一个“微型解释器”。你如果真的把作用域管理、表达式拆分、递归返回值这三件事理顺了，代码不会很长，但会比较稳健。反过来，如果一开始就想着用 split 暴力破解，后面调试半天，问题通常不是括号没对上，就是变量作用域搞串了。这个坑，我在做算法题时见过不少。

回过头看，无论是高效的面试流程，还是解一道需要严谨思维的算法题，核心都在于对细节的把握和对核心概念的理解。把这两点做好了，无论是在职场还是技术学习上，都能走得更稳。如果想探讨更多技术问题或分享求职经验，欢迎来云栈社区交流。