【leecode刷题】中级算法-数学

1、快乐树

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        # def cal(n):
        #     if n==1:
        #         return True
        #     n = sum([int(math.pow(int(i),2)) for i in str(n)])
        #     return cal(n) 
        # try:
        #     return cal(n)
        # except Exception as e:
        #     print(e)
        def get_next(n):
            total_sum = 0
            while n > 0:
                n, digit = divmod(n, 10)
                total_sum += digit ** 2
            return total_sum

        seen = set()
        while n != 1 and n not in seen:
            seen.add(n)
            n = get_next(n)

        return n == 1

2、阶乘后的零

class Solution(object):
    def trailingZeroes(self, n):
        """
        :type n: int
        :rtype: int
        """
        # def cal(n):
        #     if n==1:
        #         return 1
        #     return(cal(n-1)*n)
        # if n<=0:
        #     return 0
        # else:
        #     number = cal(n)        
        # count=0
        # flag = True
        # while number>=0 and flag:
        #     if number%10==0:
        #         count=count+1
        #         number=number//10
        #     else:
        #         flag=False
        # return count
        zero_count = 0
        while n > 0:
            n //= 5
            zero_count += n
        return zero_count

3、Excel表列序号

class Solution(object):
    def titleToNumber(self, s):
        """
        :type s: str
        :rtype: int
        """
        import math
        alpha = {}
        k = 1
        for i in range(65,91):
            alpha[chr(i)] = k
            k = k+1
        zhishu = len(s)-1
        result = 0
        for i in s:
            result = result+math.pow(26,zhishu)*alpha[i]
            zhishu = zhishu-1
        return int(result)

4、两数相除

class Solution(object):
    def divide(self, dividend, divisor):
        """
        :type dividend: int
        :type divisor: int
        :rtype: int
        """

        # if dividend<0 and divisor>0:
        #     dividend = -dividend
        #     sign = "-"
        # elif divisor<0 and divisor>0:
        #     divisor = -divisor
        #     sign = "-"       
        # else:
        #     sign = ""
        # return sign+str(int(dividend/divisor))
        # res = 0
        # sign =  1 if divd ^ dior >= 0 else -1
        # divd = abs(divd)
        # dior = abs(dior)
        # while divd >= dior:
        #     res += 1
        #     divd -= dior
        # res = res*sign 
        # return min(max(-2**31, res), 2**31-1)
        # if dividend == 0:
        #     return 0
        # if (dividend < 0 and divisor > 0) or (dividend > 0 and divisor < 0):
        #     f = '-'
        # else:
        #     f = ''
        # dividend = dividend if dividend > 0 else 0 - dividend
        # divisor = divisor if divisor > 0 else 0 - divisor
        # t = divisor
        # i = 1
        # dList = [0]
        # while dividend >= t:
        #     dividend -= t
        #     dList.append(i)
        #     t += divisor
        #     i += 1
        # if dividend < divisor:
        #     return max(min(int(f + str(sum(dList))), (1 << 31) -1), -1 << 31)
        # else:
        #     while dividend < t:
        #         t -= divisor
        #         i -= 1
        #     dList.append(i)
        #     return max(min(int(f + str(sum(dList))), (1 << 31) -1), -1 << 31)
        def recursion(dividend, divisor):
            if dividend < divisor:
                return 0
            if dividend == divisor:
                return 1
            nn = 1
            dd = divisor
            while True:
                if dividend > dd:
                    n = nn
                    nn += nn
                    d = dd
                    dd += dd
                elif dividend == dd:
                    return nn
                else:
                    return n + recursion(dividend - d, divisor)

        if dividend >= 0:
            if divisor > 0:
                positive = True
            else:
                positive = False
        else:
            if divisor > 0:
                positive = False
            else:
                positive = True
        ans = recursion(abs(dividend), abs(divisor))
        if positive:
            if ans > 2 ** 31 - 1:
                return 2 ** 31 - 1
            else:
                return ans
        else:
            return -ans

5、分数变小数

class Solution(object):
    def fractionToDecimal(self, numerator, denominator):
        """
        :type numerator: int
        :type denominator: int
        :rtype: str
        """
        if denominator < 0 and numerator > 0:
            denominator = -denominator
            sign = "-"
        elif numerator < 0 and denominator > 0:
            numerator = -numerator
            sign = "-"
        else:
            sign = ""
        precision = 1000
        pos = 0
        modDict = {}
        frac = []
        is_circulator = False  # 是否存在循环

        div, mod = divmod(numerator, denominator)
        intPart = sign + str(div)

        # 模拟手算的过程，发现有相同的余数就说明发现循环
        while pos < precision and mod != 0:
            modDict[mod] = pos
            mod *= 10
            div, mod = divmod(mod, denominator)
            frac.append(str(div))
            if mod in modDict.keys():
                is_circulator = True
                break
            pos += 1

        if is_circulator:  # 发现循环 
            frac.insert(modDict[mod], '(')
            frac.append(')')
        return intPart + '.' + ''.join(frac) if len(frac) > 0 else intPart