字符串相加&字符串相减&字符串相乘——模拟

# 字符串相加

这个用一个carry代表进位，其他的模拟竖式加法即可

```go
func addStrings(num1 string, num2 string) string {
    p1 := len(num1)-1
    p2 := len(num2)-1
    carry := byte(0)
    result := make([]byte, 0)
    for p1 >= 0 || p2 >= 0 || carry > 0 {
        x, y := byte(0), byte(0)
        if p1 >= 0 {
            x = num1[p1] - '0'
            p1--
        }
        if p2 >= 0 {
            y = num2[p2] - '0'
            p2--
        }
        sum := x + y + carry
        carry = sum / 10
        result = append(result, sum % 10 + '0')
    }
    for l, r := 0, len(result)-1; l < r; l, r = l+1, r-1 {
        result[l], result[r] = result[r], result[l]
    }
    return string(result)
}
```

# 字符串相减

这个需要考虑到借位，当前位减掉之后小于0需要让carry等于1，也就是计算后续位的时候要多减一个1。

还需要考虑到被减数比减数小的情况，这个可以通过长度和字符串大小判断两个结合得到更小的数，然后我们交换这两个数并加一个符号位sign即可。

```go
func isSmaller(a, b string) bool {
	if len(a) != len(b) {
		return len(a) < len(b)
	}
	return a < b
}

func subtractStrings(a, b string) string {
	sign := ""
	// 如果 a < b，交换并加负号
	if isSmaller(a, b) {
		a, b = b, a
		sign = "-"
	}

// 从低位到高位做减法
	res := []byte{}
	carry := 0
	i := len(a) - 1
	j := len(b) - 1

for i >= 0 || j >= 0 {
		digitA := 0
		if i >= 0 {
			digitA = int(a[i] - '0')
		}
		digitB := 0
		if j >= 0 {
			digitB = int(b[j] - '0')
		}

d := digitA - digitB - carry
		if d < 0 {
			d += 10
			carry = 1
		} else {
			carry = 0
		}
		res = append(res, byte(d)+'0')
		i--
		j--
	}

// 去除前导0并反转结果
	for len(res) > 1 && res[len(res)-1] == '0' {
		res = res[:len(res)-1]
	}
	// reverse
	for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
		res[i], res[j] = res[j], res[i]
	}

return sign + string(res)
}
```

# 字符串相乘

这个其实就是模拟竖式计算，我们可以开一个 n+m 大小的数组用来保存结果，因为$num1 < 10^n且num2 < 10^m$，所以 $num1*num2 < 10^{n+m}$

然后我们需要像竖式计算那样，把上式分别乘以下式的最后一位，倒数第二位......

然后分别把对应的数字累加，并且要进位累加

所以有了下面的模拟代码，i+j+1 是当前位，i+j 是进位：

```go
func multiply(num1 string, num2 string) string {
    n, m := len(num1), len(num2)
    res := make([]int, n+m)
    for i := n-1; i >= 0; i-- {
        for j := m-1; j >= 0; j-- {
            mul := int(num1[i]-'0') * int(num2[j]-'0')
            p1, p2 := i+j, i+j+1
            sum := mul + res[p2]
            res[p2] = sum % 10
            res[p1] += sum / 10
        }
    }
    isZero := true
    ret := []byte{}
    for i := range res {
        if res[i] == 0 && isZero {
            continue
        }
        isZero = false
        ret = append(ret, byte(res[i]+'0'))
    }
    if len(ret) == 0 {
        return "0"
    }
    return string(ret)
}
```

Last modification：August 6, 2025