LeetCode刷题总结（Python语言版）

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

009）回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

#-*-coding: utf-8-*-
class Solution:
    def isPalindrome(self, x):
        if x < 0 or (x > 0 and x % 10 == 0): return False
        else:
           x = str(x)
           return x == x[::-1]

007）整数反转

class Solution:
    def reverse(self, x: int) -> int:    # "x: int) -> int:" 为类注释
        if -10 < x < 10:
            return x
        str_x = str(x)           # 强制转为str类型
        if str_x[0] != "-":
            str_x = str_x[::-1]  # 逆序输出
            x = int(str_x)       # 强制转化为int类型
        else:
            str_x = str_x[:0:-1] 
            x = int(str_x)
            x = -x
        return x if -2147483648 < x < 2147483647 else 0
   
if __name__=="__main__":
    a = Solution()               # 创建i对象，将类实例化
    print("the result is", a.reverse(-32326))  # 调用类的方法

349）给定两个数组，编写一个函数来计算它们的交集

示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]

说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
题解：
将数组转为set集合处理，利用set集合可以直接求解交集（&）

class Solution:
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """  
        set1 = set(nums1)
        set2 = set(nums2)
        return (set2 & set1)

344）反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符

class Solution:
    def reverseString(self, s: List[str]) -> None:
        length = len(s)
        if length < 2:
            return 
        for i in range(length//2): # 注意这里的 地板除
            s[i], s[length - i -1] = s[length - i -1], s[i]
        return 

// 称为地板除，两个整数的除法仍然是整数，它总是会舍去小数部分，返回数字序列中比真正的商小的，最接近的数字。
/ 除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数。

387）字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
s = “leetcode”
返回 0.
s = “loveleetcode”,
返回 2.

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

class Solution:
    def firstUniqChar(self, s: str) -> int:
        # hash ,26 个字母为键值的字典
        words = [chr(i) for i in range(97, 123)] #[a - z]
        values = [0] * 26
        wordsDic = dict(zip(words, values))
        for word in s:
            wordsDic[word] += 1
        for i in range(len(s)):
            if wordsDic[s[i]] == 1:
                return i
        return -1

242）有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

输入: s = “anagram”, t = “nagaram”
输出: true

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        words = [chr(i) for i in range(97, 123)]
        values = [0] * 26
        wordsDic_s = dict(zip(words, values)) # 构造一个字典
        # 下述中哪个字符串大，将哪个字符串归为字典组，另一个在这个字典组里去重
        if (len(s) > len(t)):   
            for word in s:
                wordsDic_s[word] += 1 
            for i in range(len(t)):
                wordsDic_s[t[i]] -= 1
            for i in range(len(s)):  # 最后检查去重后的结果，如果有非零值，则FALSE
                if (wordsDic_s[s[i]] != 0):
                    return 0
        else :
            for word in t:
                wordsDic_s[word] += 1 
            for i in range(len(s)):
                wordsDic_s[s[i]] -= 1
            for i in range(len(t)):
                if (wordsDic_s[t[i]] != 0):
                    return 0
        return 1

204）计数质数

统计所有小于非负整数 n 的质数的数量。
示例:
输入: 10
输出: 4
解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。

class Solution:
    def countPrimes(self, n: int) -> int:
        if n < 3:
            return 0     
        else:
            # 首先生成了一个全部为1的列表
            output = [1] * n
            # 因为0和1不是质数,所以列表的前两个位置赋值为0
            output[0],output[1] = 0,0
             # 此时从index = 2开始遍历,output[2]==1,即表明第一个质数为2,然后将2的倍数对应的索引
             # 全部赋值为0. 此时output[3] == 1,即表明下一个质数为3,同样划去3的倍数.以此类推.
            for i in range(2,int(pow(n, 0.5)+1)):  #埃拉托斯特尼筛法已经证明：要得到自然数n以内的全部质数，必须把不大于根号n的所有质数的倍数剔除，剩下的都是质数。
                if output[i] == 1:
                    output[i*i : n : i] = [0] * len(output[i*i : n : i])  #切片：object[start_index : end_index : step], 将所有 i 的倍数(i*i)筛出掉
         # 最后output中的数字1表明该位置上的索引数为质数,然后求和即可.
        return sum(output)