0207leetcode刷题5道python

剑指offer43

题目描述：
输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。
例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。

示例：

解答：

class Solution:
    def countDigitOne(self, n: int) -> int:
        a, b, one_count = 1, 10, 0
        while n >= a:
            x, y = divmod(n, b)
            
            if y >= a * 2:
                one_count += (x + 1) * a
            elif y >= a:
                one_count += y + 1 + (x - 1) * a
            else:
                one_count += x * a 

            a, b = b, b*10 
        
        return one_count

剑指offer45

题目描述：
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

示例：

解答：

class cmpSmaller(str):
    def __lt__(self, y):
        return self + y < y + self  # 字符串拼接比较(两两比较)
    # 按由小到大来排列

class Solution:
    def minNumber(self, nums: List[int]) -> str:
        res=sorted(map(str, nums),key=cmpSmaller)
        smallest = ''.join(res)
        return smallest

剑指offer49

题目描述：
我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。

示例：

解答：

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        #记录上一个时刻乘以（2/3/5）的最小时刻，下个丑数及对应的每个时刻乘以2/3/5的最小数
        ugly = [1]    # 利用数组记录
        i2 = i3 = i5 =0
        while n>1:
            u2, u3, u5 = ugly[i2]*2, ugly[i3]*3, ugly[i5]*5
            umin = min(u2, u3, u5)
            if umin == u2:
                i2 += 1
            if umin == u3:
                i3 += 1
            if umin == u5:
                i5 += 1
            n -= 1
            ugly.append(umin)
        return ugly[-1]

剑指offer51

题目描述：
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例：

解答：

class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        if len(nums) <2:
            return 0
        res = []
        def mergesort(nums,res):
            size = len(nums)
            if size <2:
                return nums
            middle = size //2
            left = mergesort(nums[:middle],res)
            right = mergesort(nums[middle:],res)
            j = 0
            count = 0
            for i in range(len(left)):
                while j < len(right):
                    if left[i] > right[j]:
                        count += len(right) - j 
                        break
                    else:
                        j += 1
                if j >= len(right):
                    break
            res.append(count)
            left += right
            left.sort(reverse = True)
            return left
        mergesort(nums,res)
        return sum(res)

剑指offer52

题目描述：

示例：

解答：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        node1, node2 = headA, headB
        
        while node1 != node2:
            node1 = node1.next if node1 else headB
            node2 = node2.next if node2 else headA

        return node1