【Leetcode】数值运算

---

66. Plus One(大数加一)

Solution:

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        ret = digits[:]

        _len = len(ret)

        jin = 1
        ge = ret[-1]
        curr = -1
        idx = -2
        while True:
            _sum = ge + jin
            jin = _sum // 10
            ge = _sum % 10
            if jin == 0:
                ret[curr] = ge
                return ret
            else:
                ret[curr] = ge
                if abs(idx) > _len:
                    ret.insert(0, jin)
                    return ret
                else:
                    ge = ret[idx]

                    curr -= 1
                    idx -= 1

---

989. Add to Array-Form of Integer

Solution 1

基于上面 Plus One 的实现（速度较慢！）

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        [...code from 66. Plus One..]

    def addToArrayForm(self, A: List[int], K: int) -> List[int]:
        cnt = 0
        ret = A[:]
        for cnt in range(K):
            ret = self.plusOne(ret)
        return ret

Solution 2 - n/a

---

67. Add Binary（二进制加）

Solution:

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        l1 = [int(_) for _ in a]
        l2 = [int(_) for _ in b]
        
        ret = []
        l1_f = False
        l2_f = False

        l1.reverse()
        l2.reverse()
        i = 0
        j = 0
        r = 0
        jin = 0
        while True:
            try:
                _a = l1[i]
            except IndexError:
                l1_f = True
                _a = 0
            try:
                _b = l2[j]
            except IndexError:
                l2_f = True
                _b = 0

            if l1_f and l2_f:
                if jin:
                    ret.append(jin)
                break

            s = _a + _b + jin
            if s >= 2:
                ret.append(0 if s==2 else 1)
                jin = 1
            else:
                ret.append(s)
                jin = 0
            i += 1
            j += 1
            r += 1
        ret.reverse()
        return ''.join([str(_) for _ in ret])

---

415. Add Strings（大数相加）

Solution:

基于上面的二进制相加，修改了底数，没有什么特别的。

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        l1 = [int(_) for _ in num1]
        l2 = [int(_) for _ in num2]
        
        ret = []
        l1_f = False
        l2_f = False

        l1.reverse()
        l2.reverse()
        i = 0
        jin = 0
        while True:
            try:
                _a = l1[i]
            except IndexError:
                l1_f = True
                _a = 0
            try:
                _b = l2[i]
            except IndexError:
                l2_f = True
                _b = 0

            if l1_f and l2_f:
                if jin:
                    ret.append(jin)
                break

            s = _a + _b + jin
            jin = s // 10
            s = s % 10
            ret.append(s)
            i += 1
        ret.reverse()
        return ''.join([str(_) for _ in ret])

---

349. Intersection of Two Arrays

Solution:

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

---

504. Base 7 – 换算成 7 进制数

Solution:

def mod(i, j):
    ret1 = i // j
    ret2 = i % j
    return (ret1, ret2)

class Solution:
    def convertToBase7(self, num: int) -> str:
        ret = []
        div = abs(num)
        while div >= 7:
            div, _mod = mod(div, 7)
            ret.append(_mod)

        ret.append(div)
        ret.reverse()
        return "-" + "".join([str(_) for _ in ret]) if num < 0 else "".join([str(_) for _ in ret])

---

728. Self Dividing Numbers

Solution:

普通的暴力遍历解法：

class Solution:
    def is_self_divid_number(self, num):
        s = str(num)
        for i in s:
            try:
                if num % int(i) != 0:
                    return False
            except ZeroDivisionError:
                return False

        return True

    def selfDividingNumbers(self, left: int, right: int) -> List[int]:
        return [i for i in range(left, right+1) if self.is_self_divid_number(i)]

---