高精度

加法

python

# 高精度整数相加
def add(a: str, b: str):
    if len(a) < len(b):
        return add(b, a)

    # 从个位开始累加
    a_list = [int(c) for c in reversed(list(a))]
    b_list = [int(c) for c in reversed(list(b))]

    ans_list = list()
    t = 0
    for i in range(len(a)):
        t += a_list[i]
        if i < len(b):
            t += b_list[i]
        ans_list.append(t % 10)
        t //= 10

    ans = ""
    if not t:
        while ans_list:
            ta = str(ans_list.pop())
            if ta == '0':
                continue
            else:
                ans = ta
                break
    else:
        ans = str(t)

    while ans_list:
        ans += str(ans_list.pop())

    return ans


if __name__ == '__main__':
    from random import randint

    for _ in range(1024):
        a = randint(100000, 1000000)
        b = randint(100, 10000)
        if add(str(a), str(b)) != str(a + b):
            print(a, b, add(str(a), str(b)), a + b)

go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    var reader = bufio.NewReader(os.Stdin)
    var x = readArray(reader)
    var y = readArray(reader)
    fmt.Println(add(x, y))
}

func add(x, y []int) string {
    if len(x) > len(y) {
        x, y = y, x
    }
    var (
        jw     int
        i      int
        length = len(x)
        ly     = len(y)
        ans    string
        sum    int
    )

    for i < length {
        sum = x[length-i-1] + y[ly-i-1] + jw
        jw = sum / 10
        ans = strconv.Itoa(sum%10) + ans
        i++
    }

    for i < ly {
        sum = y[ly-i-1] + jw
        jw = sum / 10
        ans = strconv.Itoa(sum%10) + ans
        i++
    }

    if jw == 1 {
        ans = "1" + ans
    }
    return ans
}

func readLine(reader *bufio.Reader) string {
    var line, _ = reader.ReadString('\n')
    return strings.TrimRight(line, "\n")
}

func readArray(reader *bufio.Reader) []int {
    var line = readLine(reader)
    var strList = strings.Split(line, "")
    var nums = make([]int, 0)
    var err error
    var v int
    for i := 0; i < len(strList); i++ {
        if v, err = strconv.Atoi(strList[i]); err != nil {
            continue
        }
        nums = append(nums, v)
    }
    return nums
}

减法

python

# a >= b; a>=0. b>=0
def sub(a, b):
    a_list = [int(c) for c in reversed(list(a))]
    b_list = [int(c) for c in reversed(list(b))]

    ans_list = list()
    t = 0
    for i in range(len(a)):
        t = a_list[i] - t
        if i < len(b):
            t -= b_list[i]
        ans_list.append((t + 10) % 10)
        if t < 0:
            t = 1
        else:
            t = 0

    ans = str()
    if not t:
        while ans_list:
            ta = str(ans_list.pop())
            if ta == '0':
                continue
            else:
                ans = ta
                break
    else:
        ans = str(t)

    while ans_list:
        ans += str(ans_list.pop())

    return ans


if __name__ == '__main__':
    from random import randint

    for _ in range(1024):
        a = randint(10000, 1000000)
        b = randint(100, 10000)
        if sub(str(a), str(b)) != str(a - b):
            print(a, b)

go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    var reader = bufio.NewReader(os.Stdin)
    var x = readArray(reader)
    var y = readArray(reader)
    fmt.Println(sub(x, y))
}

// 1: x > y
// 0 x == y
//-1 x < y
func checkXY(x, y []int) int {
    if len(x) > len(y) {
        return 1
    } else if len(x) < len(y) {
        return -1
    }
    var i int
    for i < len(x) {
        if x[i] > y[i] {
            return 1
        } else if x[i] < y[i] {
            return -1
        }
        i++
    }
    return 0
}

func sub(x, y []int) string {
    var flag bool
    var code = checkXY(x, y)
    if code == 0 {
        return "0"
    }
    if code == -1 {
        x, y = y, x
        flag = true
    }
    var (
        jw     int
        i      int
        length = len(x)
        ly     = len(y)
        ans    string
        sum    int
    )

    for i < ly {
        sum = x[length-i-1] - y[ly-i-1] - jw
        jw = 0
        if sum < 0 {
            jw = 1
            sum += 10
        }
        ans = strconv.Itoa(sum) + ans
        i++
    }

    for i < length {
        sum = x[length-i-1] - jw
        jw = 0
        if sum < 0 {
            jw = 1
            sum += 10
        }
        ans = strconv.Itoa(sum) + ans
        i++
    }

    for ans[0] == '0' {
        ans = ans[1:]
    }

    if flag {
        ans = "-" + ans
    }
    return ans
}

func readLine(reader *bufio.Reader) string {
    var line, _ = reader.ReadString('\n')
    return strings.TrimRight(line, "\n")
}

func readArray(reader *bufio.Reader) []int {
    var line = readLine(reader)
    var strList = strings.Split(line, "")
    var nums = make([]int, 0)
    var err error
    var v int
    for i := 0; i < len(strList); i++ {
        if v, err = strconv.Atoi(strList[i]); err != nil {
            continue
        }
        nums = append(nums, v)
    }
    return nums
}

乘法

python

# 高精度整数乘整数
def mul(a: str, b: int):
    a_list = [int(c) for c in reversed(list(a))]

    ans_list = list()
    t = 0
    for c in a_list:
        x = ((c * b) + t) % 10
        ans_list.append(str(x))
        t = ((c * b) + t) // 10
    # print(ans_list)
    ans = str()

    if not t:
        while ans_list:
            ta = ans_list.pop()
            if ta == '0':
                continue
            else:
                ans = ta
                break
    else:
        ans = str(t)

    while ans_list:
        ans += ans_list.pop()

    # print(ans)
    return ans


if __name__ == '__main__':
    from random import randint

    for _ in range(1024):
        a = randint(100000, 1000000)
        b = randint(100, 10000)
        if mul(str(a), b) != str(a * b):
            print(a, b)

go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    var reader = bufio.NewReader(os.Stdin)
    var x = readArray(reader)
    var y, _ = strconv.Atoi(readLine(reader))
    fmt.Println(mul(x, y))
}

func mul(x []int, y int) string {
    if y == 0 || len(x) <= 0 {
        return "0"
    }

    var (
        lx  = len(x)
        ans string
        i   int
        j   int
        jw  int
        sum int
    )

    for i < lx {
        sum = x[lx-i-1]*y + jw
        jw = sum / 10
        ans = strconv.Itoa(sum%10) + ans
        i++
    }
    j++

    if jw > 0 {
        ans = strconv.Itoa(jw) + ans
    }

    return ans
}

func readLine(reader *bufio.Reader) string {
    var line, _ = reader.ReadString('\n')
    return strings.TrimRight(line, "\n")
}

func readArray(reader *bufio.Reader) []int {
    var line = readLine(reader)
    var strList = strings.Split(line, "")
    var nums = make([]int, 0)
    var err error
    var v int
    for i := 0; i < len(strList); i++ {
        if v, err = strconv.Atoi(strList[i]); err != nil {
            continue
        }
        nums = append(nums, v)
    }
    return nums
}

除法

python

# 高精度整数除以整数
def div(a: str, b: int):
    t = 0
    ans_list = list()
    for c in a:
        ans_list.append(str((t * 10 + int(c)) // b))
        t = (t * 10 + int(c)) % b

    ans = str()
    index = 0
    while index < len(ans_list):
        if ans_list[index] == '0':
            index += 1
            continue
        else:
            ans = ans_list[index]
            index += 1
            break

    while index < len(ans_list):
        ans += ans_list[index]
        index += 1
    return ans


if __name__ == '__main__':
    from random import randint

    for _ in range(1024):
        a = randint(100000, 1000000)
        b = randint(100, 10000)
        if div(str(a), b) != str(a // b):
            print(a, b, div(str(a), b), a // b)

go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    var reader = bufio.NewReader(os.Stdin)
    var x = readArray(reader)
    var y, _ = strconv.Atoi(readLine(reader))
    var a, b = div(x, y)
    fmt.Println(a)
    fmt.Println(b)
}

func div(x []int, y int) (string, int) {

    var (
        lx  = len(x)
        ans string
        i   int
        t   int
        sum int
    )

    for i < lx {
        sum = x[i] + t*10
        ans += strconv.Itoa(sum / y)
        t = sum % y
        i++
    }

    for len(ans) > 1 && ans[0] == '0' {
        ans = ans[1:]
    }

    return ans, t
}

func readLine(reader *bufio.Reader) string {
    var line, _ = reader.ReadString('\n')
    return strings.TrimRight(line, "\n")
}

func readArray(reader *bufio.Reader) []int {
    var line = readLine(reader)
    var strList = strings.Split(line, "")
    var nums = make([]int, 0)
    var err error
    var v int
    for i := 0; i < len(strList); i++ {
        if v, err = strconv.Atoi(strList[i]); err != nil {
            continue
        }
        nums = append(nums, v)
    }
    return nums
}