身处奇瑞看三星：既“开卷“又“起火“，却更难受了

三星"起火"

这几天奇瑞的事情，让大家破防了，纷纷表示国内的就业市场环境普遍恶劣。

那我们转个眼，看看海外企业的情况。

最近一周，三星频频登上新闻，颇有"起火"之势。

在刚步入下半年的 7 月 1 日，三星就向韩国雇佣劳动部提交特别申请：要求延长 IT、人工智能开发、Micro 项目团队等部门的工作时间，将上限调整为每周 64 小时。目前韩国劳动法规的每周工作时长上限是 52 小时。

至于三星"开卷"的原因，业内人员分析，大致是因为面对日益激烈的 OLED 业务，不得已做的战略调整。

个人觉得这分析有点站不住脚，三星作为一家成立了超过半个世纪的公司，是「技术驱动」的典范，因为竞争激烈就将战略调整为「增加员工工作时间，大力出奇迹」，不太符合一贯作风，我更愿意相信这是高管更替，导致的决策差异。既然如此，建议韩国把我们国内的 996 文化借鉴过去，全力申遗，并全国推广。

哪里有压迫，哪里就有反抗。

也是 7 月 1 日，三星的工会发起总罢工，要求增加带薪年假和薪酬提升。

这是三星（1938 年）成立以来的首次罢工，涉及人员超过 2.8 万人。

三星工会的诉求十分简单直接：加薪幅度从 5.1% 提升至 6.5%，额外增加一天的带薪年假。若要求不能得到满足，全面罢工将会持续下去。简单来说就是：不给钱，不干活。

由此可见，无论国内还是海外，劳务纠纷都是普遍存在的。

只不过有人选择了忍让，有人选择了反抗。

...

回归主题。

来一道拷打周四的题目。

题目描述

平台：LeetCode

题号：592

给定一个表示分数加减运算的字符串 expression，你需要返回一个字符串形式的计算结果。

这个结果应该是不可约分的分数，即最简分数。 如果最终结果是一个整数，例如 2，你需要将它转换成分数形式，其分母为 1。所以在上述例子中, 2 应该被转换为 2/1。

示例 1:

输入: expression = "-1/2+1/2"

输出: "0/1"

示例 2:

输入: expression = "-1/2+1/2+1/3"

输出: "1/3"

示例 3:

输入: expression = "1/3-1/2"

输出: "-1/6"

提示:

• 输入和输出字符串只包含  '0' 到  '9' 的数字，以及  '/', '+' 和  '-'。
• 输入和输出分数格式均为  ±分子/分母。如果输入的第一个分数或者输出的分数是正数，则  '+' 会被省略掉。
• 输入只包含合法的最简分数，每个分数的分子与分母的范围是  。 如果分母是 1，意味着这个分数实际上是一个整数。
• 输入的分数个数范围是 。
• 最终结果的分子与分母保证是 32 位整数范围内的有效整数。

表达式计算

为了方便，令 expression 为 s。

由于给定的表达式中只有 + 和 -，因此无须考虑优先级问题，直接从前往后计算即可。

使用变量 ans 代指计算过程中的结果，从前往后处理表达式 s，每次以 ±分子/分母 的形式取出当前操作数（若为表达式的首个操作数，且为正数时，需要手动补一个 +）。

假设当前取出的操作数为 num，根据 ans 的情况进行运算：

• 若 ans 为空串，说明 num 是首个操作数，直接将 num 赋值给 ans 即可
• 若 ans 不为空串，此时计算 num 和 ans 的计算结果赋值给 ans

考虑实现一个计算函数 String calc(String a, String b) 计算两个操作 a 和 b 的结果，其中入参 a 和 b 以及返回值均满足 ±分子/分母 形式。

首先通过读取 a 和 b 的首个字符，得到两操作数的正负情况。若为一正一负，通过交换的形式，确保 a 为正数，b 为负数。

然后通过 parse 方法拆解出字符串操作数的分子和分母，parse 使用指针扫描的方式实现即可，以数组形式将结果返回（第 0 位为分子数值，第 1 位分母数值）。

假设操作数 a 对应的值为 p[0]/p[1]，操作数的值为 q[0]/q[1]，先将其转换为 p[0]*q[1] / p[1]*q[1] 和 q[0]*p[1] / q[1]*p[1]，进行运算后，再通过求最大公约数 gcd 的方式进行化简。

Java 代码：

class Solution {
    public String fractionAddition(String s) {
        int n = s.length();
        char[] cs = s.toCharArray();
        String ans = "";
        for (int i = 0; i < n; ) {
            int j = i + 1;
            while (j < n && cs[j] != '+' && cs[j] != '-') j++;
            String num = s.substring(i, j);
            if (cs[i] != '+' && cs[i] != '-') num = "+" + num;
            if (!ans.equals("")) ans = calc(num, ans);
            else ans = num;
            i = j;
        }
        return ans.charAt(0) == '+' ? ans.substring(1) : ans;
    }
    String calc(String a, String b) {
        boolean fa = a.charAt(0) == '+', fb = b.charAt(0) == '+';
        if (!fa && fb) return calc(b, a);
        long[] p = parse(a), q = parse(b);
        long p1 = p[0] * q[1], q1 = q[0] * p[1];
        if (fa && fb) {
            long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);
            return "+" + (r1 / c) + "/" + (r2 / c);
        } else if (!fa && !fb) {
            long r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2);
            return "-" + (r1 / c) + "/" + (r2 / c);
        } else {
            long r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2);
            String ans = (r1 / c) + "/" + (r2 / c);
            if (p1 >= q1) ans = "+" + ans;
            return ans;
        }
    }
    long[] parse(String s) {
        int n = s.length(), idx = 1;
        while (idx < n && s.charAt(idx) != '/') idx++;
        long a = Long.parseLong(s.substring(1, idx)), b = Long.parseLong(s.substring(idx + 1));
        return new long[]{a, b};
    }
    long gcd(long a, long b) {
        return b == 0 ? a : gcd(b, a % b);
    }
}

C++ 代码：

class Solution {
public:
    string fractionAddition(string s) {
        int n = s.length();
        string ans = "";
        for (int i = 0; i < n; ) {
            int j = i + 1;
            while (j < n && s[j] != '+' && s[j] != '-') j++;
            string num = s.substr(i, j - i);
            if (s[i] != '+' && s[i] != '-') num = "+" + num;
            if (!ans.empty()) ans = calc(num, ans);
            else ans = num;
            i = j;
        }
        return ans.front() == '+' ? ans.substr(1) : ans;
    }
    string calc(string a, string b) {
        bool fa = a.front() == '+', fb = b.front() == '+';
        if (!fa && fb) return calc(b, a);
        auto p = parse(a), q = parse(b);
        long long p1 = p.first * q.second, q1 = q.first * p.second;
        if (fa && fb) {
            long long r1 = p1 + q1, r2 = p.second * q.second, c = gcd(r1, r2);
            return "+" + to_string(r1 / c) + "/" + to_string(r2 / c);
        } else if (!fa && !fb) {
            long long r1 = p1 + q1, r2 = p.second * q.second, c = gcd(r1, r2);
            return "-" + to_string(r1 / c) + "/" + to_string(r2 / c);
        } else {
            long long r1 = p1 - q1, r2 = p.second * q.second, c = gcd(abs(r1), r2);
            string ans = to_string(r1 / c) + "/" + to_string(r2 / c);
            if (p1 >= q1) ans = "+" + ans;
            return ans;
        }
    }
    pair<long long, long long> parse(string s) {
        int idx = 1;
        while (idx < s.length() && s[idx] != '/') idx++;
        long long a = stoll(s.substr(1, idx - 1)), b = stoll(s.substr(idx + 1));
        return {a, b};
    }
    long long gcd(long long a, long long b) {
        return b == 0 ? a : gcd(b, a % b);
    }
};

TypeScript 代码：

function fractionAddition(s: string): string {
    const n = s.length
    let ans = ""
    for (let i = 0; i < n; ) {
        let j = i + 1
        while (j < n && s[j] != '+' && s[j] != '-') j++
        let num = s.substring(i, j)
        if (s[i] != '+' && s[i] != '-') num = "+" + num
        if (ans != "") ans = calc(num, ans)
        else ans = num
        i = j
    }
    return ans[0] == "+" ? ans.substring(1) : ans
};
function calc(a: string, b: string): string {
    const fa = a[0] == "+", fb = b[0] == "+"
    if (!fa && fb) return calc(b, a)
    const p = parse(a), q = parse(b)
    const p1 = p[0] * q[1], q1 = q[0] * p[1]
    if (fa && fb) {
        const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)
        return "+" + (r1 / c) + "/" + (r2 / c)
    } else if (!fa && !fb) {
        const r1 = p1 + q1, r2 = p[1] * q[1], c = gcd(r1, r2)
        return "-" + (r1 / c) + "/" + (r2 / c)
    } else {
        const r1 = p1 - q1, r2 = p[1] * q[1], c = gcd(Math.abs(r1), r2)
        let ans = (r1 / c) + "/" + (r2 / c)
        if (p1 > q1) ans = "+" + ans
        return ans
    }
}
function parse(s: string): number[] {
    let n = s.length, idx = 1
    while (idx < n && s[idx] != "/") idx++
    const a = Number(s.substring(1, idx)), b = Number(s.substring(idx + 1))
    return [a, b]
}
function gcd(a: number, b: number): number {
    return b == 0 ? a : gcd(b, a % b)
}

• 时间复杂度：
• 空间复杂度：

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉