组里有个P7，为了防止被裁，把核心计费模块的代码写得晦涩难懂，甚至不提交 Git。 结果CTO直接招了个外包团队，当天就让他走人了!

刚看到个贴子：说有个P7，为了防裁员，把核心计费模块写成天书，还自己加了一堆混淆逻辑，代码从不提 Git，只在服务器留一份，觉得公司动不了他。结果 CTO 招了外包，两个月把模块重写并行验证，确认没问题，直接拿他“违规操作生产环境”的理由开掉，还按最低标准赔。

我觉得这事吧，本质不是技术问题，是心态问题。你把系统当人质，老板自然把你当风险源头。技术人的安全感，不该来自“只有我懂”，而是来自：就算别人能接手，也知道我做得又专业又靠谱。

换个角度想，真有本事的人，敢把文档写清楚、流程跑规范，让谁来接盘都觉得轻松。说到底，职场最稳的护身符，从来不是“别人离不开你”，而是“你走到哪儿都有人要你”。

面 试题：在 LR 字符串中交换相邻字符

昨天晚上十一点多吧，我还在公司楼下抽烟，我们组那个小李突然发微信，说“哥，这题我看着简单，怎么一写就错啊”，我一看题名就笑了，那个……“在 LR 字符串中交换相邻字符”，对吧，就是那种 XL -> LX、RX -> XR 这种挪来挪去的，写起来像在挪人，一不小心就把人挪穿墙了。

这题最坑的点是很多人会想：那我就模拟交换呗，循环找 XL 就换、找 RX 就换，直到不动为止……哎你别说，真有人这么干，然后线上直接卡死，字符串一长就跟你日志里刷屏一样，CPU 嗡嗡的。其实你想想，规则已经把“方向”写死了：L 只能往左挪（因为只有 XL -> LX）， R 只能往右挪（因为只有 RX -> XR），X 就是空位。你模拟交换，其实是在用蛮力做“位置约束检查”。

所以我一般是这么跟小李说的：别看交换，看“人是谁”和“人能不能到那个位置”。先把所有 X 去掉，剩下的顺序必须一模一样，不然你怎么换都不可能把一个 L 变成 R，对吧。比如 start 去掉 X 是 LRR， end 去掉 X 是 RLR，那直接判死刑，别折腾。

然后第二步才是关键：同一个字母在 start 的位置和在 end 的位置，得符合方向。

• 如果是 L，它只能往左走，所以它在 start 里的下标 必须大于等于 它在 end 里的下标（先在右边，才有机会往左挪过去）。
• 如果是  R，它只能往右走，所以它在 start 里的下标 必须小于等于 它在 end 里的下标。

就这么两条，基本把题掐死了。实现上我用双指针，两个指针分别在 start/end 上跑，跳过 X，对齐到真正的 L/R 再比。

Java 我给你写一份我常用的，挺短，也不绕：

public class SwapAdjacentInLRString {

    public boolean canTransform(String start, String end) {
        if (start == null || end == null) returnfalse;
        if


    
 (start.length() != end.length()) returnfalse;

        int n = start.length();
        int i = 0, j = 0;

        while (i < n || j < n) {
            // 跳过空位 X
            while (i < n && start.charAt(i) == 'X') i++;
            while (j < n && end.charAt(j) == 'X') j++;

            // 两边同时走到头，说明都对齐完了
            if (i == n && j == n) returntrue;
            // 只有一边到头，另一边还有 L/R，肯定不行
            if (i == n || j == n) returnfalse;

            char a = start.charAt(i);
            char b = end.charAt(j);

            // 人都不是同一个了，还变啥
            if (a != b) returnfalse;

            // 方向约束：L 只能左移，R 只能右移
            if (a == 'L' && i < j) returnfalse; // L 不能从左往右跑
            if (a == 'R' && i > j) returnfalse; // R 不能从右往左跑

            i++;
            j++;
        }

        returntrue;
    }

    // 你要本地跑一下就加个 main，别老用脑补…我以前就爱脑补，翻车多了
    public static void main(String[] args) {
        SwapAdjacentInLRString s = new SwapAdjacentInLRString();
        System.out.println(s.canTransform("RXXLRXRXL", "XRLXXRRLX")); // true
        System.out.println(s.canTransform("X", "L")); // false
    }
}

你看这段代码，实际上干了三件事：一边跳 X、一边对齐  L/R、最后用下标关系卡死方向。很多人会忘了“去掉 X 顺序一致”这个本质，但我们这里其实隐含做了：因为每次对齐都要求 a == b，一旦顺序不同，中间某次就对不上。

还有个小坑我顺嘴说下（别嫌我啰嗦）：有的人拿计数器统计 L 数量、R 数量，觉得数量一样就行，这不行的，顺序错了也不行。就像排队，人数一样不代表你能把张三换成李四站到那个位置上，对吧。

反正这题你把它当“交换题”就容易写成模拟，把它当“约束题”就很顺，复杂度 O(n)，字符串再长也不怕。行了我先不说了，刚刚外卖到了，等下又凉了我又得骂自己……