【学习笔记】LeetCode练习-查找

查找表

list - 数组，无序，可重复
set - 组数，无序，内容不能重复
dict - key-value存储，无序，key不能重复
map - 可以形成新的映射关系
202 Happy number - 快乐数
题目: 编写一个算法来判断一个数是不是“快乐数”。
(“快乐数”：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。)

def isHappy(n):
    already = set()
    while n != 1:
        sum = 0
        while n > 0:
            # 取n的最后一位数
            tmp = n % 10   
            sum += tmp ** 2
            # 将n的最后一位截掉
            n //= 10
        # 如果求的和在过程中出现过
        if sum in already:
            return False
        else:
            already.add(sum)
        n = sum
    return True
print(isHappy(19))

205 Isomorphic Strings - 同构字符串
题目: 给定两个字符串 s 和 t，判断它们是否是同构的。

def isIsomorphic(s,t):
    return list(map(s.index,s)) == list(map(t.index,t))
print(isIsomorphic("egg","cat"))
print(isIsomorphic("egg","add"))

242 Intersection Of Two Arrays 2 - 有效的字母异位词
题目: 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例:
输入: s = “anagram”, t = “nagaram”
输出: true
输入: s = “rat”, t = “car”
输出: false

def isAnagram(s, t):
    from collections import Counter
    s = Counter(s)
    t = Counter(t)
    if s == t:
        return True
    else:
        return False
print(isAnagram("anagram","nagaram"))

290 Word Pattern - 单词规律
题目: 给出一个模式(pattern)以及一个字符串，判断这个字符串是否符合模式.

def wordPattern(pattern, str):
    str = str.split()
    print(list(map(pattern.index,pattern)))
    print(list(map(str.index,str)))
    return list(map(pattern.index,pattern)) == list(map(str.index,str))
print(wordPattern("abba","dog cat cat dog"))
print(wordPattern("abba","dog cat catt dog"))

349 Intersection Of Two Arrays 1 - 两数组交集
题目：给定两个数组nums,求两个数组的公共元素。

def intersection(nums1, nums2):
    set1 = set(nums1)
    set2 = set(nums2)
    return set2 & set1
print(intersection([1,2,2,1],[2,2]))

350 Intersection Of Two Arrays 2 - 两数组交集 II
题目: 给定两个数组nums,求两个数组的交集。

def intersect(nums1, nums2):
    from collections import Counter
    nums1_dict = Counter(nums1)
    res = []
    for num in nums2:
        if nums1_dict[num] > 0:
            res.append(num)
            nums1_dict[num] -= 1
    return res
print(intersect([1,2,2,1],[2,2]))

二分查找

二分查找也称折半查找（Binary Search），查找的时间复杂度是log(n)。一般二分查找的对象是有序或者由有序部分变化的。
35. Search Insert Position - 搜索插入位置
题目：给定排序数组和目标值，如果找到目标，则返回索引。如果不是，则返回按顺序插入索引的位置的索引。

def searchInsert(nums, target):        
    l, r = 0, len(nums)
    while l < r:
        mid = (l + r) // 2
        if nums[mid] < target:
            l = mid + 1
        else:
            r = mid
    return l
print(searchInsert([1,3,5,6], 5))

410. Split Array Largest Sum - 分割数组的最大值
题目：给定一个由非负整数和整数m组成的数组，您可以将该数组拆分为m个非空连续子数组。编写算法以最小化这m个子数组中的最大和。

def splitArray(nums, m): 
    def helper(mid):
        res = tmp = 0
        for num in nums:
            if tmp + num <= mid:
                tmp += num
            else:
                res += 1
                tmp = num
        return res + 1

    lo, hi = max(nums), sum(nums)
    while lo < hi:
        mid = (lo + hi) // 2
        if helper(mid) > m:
            lo = mid + 1
        else:
            hi = mid
    return lo
print(splitArray([7,2,5,10,8],2))

451 Sort Characters By Frequency - 根据字符出现频率排序
题目: 给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
(使用字典统计频率，对字典的value进行排序)

def frequencySort(s):
    from collections import Counter
    s_dict = Counter(s)
    # 对value值由大到小排序
    s = sorted(s_dict.items(), key=lambda item:item[1], reverse = True)
    # 由key和value相乘进行拼接
    res = ''
    for key, value in s:
        res += key * value   
    return res
print(frequencySort("appropriate"))

540 Single Element in a Sorted Array - 有序数组中的单一元素
题目：一个仅由整数组成的排序数组，其中每个元素精确出现两次，但一个元素仅出现一次。 找到只出现一次的单个元素。

def singleNonDuplicate(nums):
    lo, hi = 0, len(nums) - 1
    while lo < hi:
        mid = (lo + hi) // 2
        if nums[mid] == nums[mid ^ 1]:
            lo = mid + 1
        else:
            hi = mid
    return nums[lo]
print(singleNonDuplicate([1,1,2,3,3,4,4,8,8]))