leetcode查找1

LeetCode 349 Intersection Of Two Arrays 1

给定两个数组nums,求两个数组的公共元素。
如nums1 = [1,2,2,1],nums2 = [2,2] 结果为[2] 结果中每个元素只能出现一次 出现的顺序可以是任意的
由于每个元素只出现一次，因此不需要关注每个元素出现的次数，用set的数据结构就可以了。记录元素的有和无。

LeetCode 350 Intersection Of Two Arrays 2

给定两个数组nums,求两个数组的交集。
如nums1=[1,2,2,1],nums=[2,2]， 结果为[2,2]，出现的顺序可以是任意的

#元素出现的次数有用，那么对于存储次数就是有意义的，所以选择数据结构时，就应该选择dict的结构，通过字典的比较来判断；
#记录每个元素的同时要记录这个元素的频次。
#记录num1的字典，遍历nums2，比较nums1的字典的nums的key是否大于零，从而进行判断。
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        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

LeetCode 242 Intersection Of Two Arrays 2

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例1: 输入: s = “anagram”, t = “nagaram” 输出: true 示例 2: 输入: s = “rat”, t = “car” 输出: false
判断异位词即判断变换位置后的字符串和原来是否相同，那么不仅需要存储元素，还需要记录元素的个数。可以选择dict的数据结构，将字符串s和t都用dict存储，而后直接比较两个dict是否相同。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import Counter
        s=Counter(s)
        t=Counter(t)
        if t==s:
            return True
        else:
            return False

LeetCode 202 Happy number

编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。
示例: 输入: 19 输出: true 解释: 1^2 + 9^2 = 82 8^2 + 2^2 = 68 6^2 + 8^2 = 100 1^2 + 0^2 + 0^2 = 1

class Solution:
    def isHappy(self, n: int) -> bool:
        set0=set()
        while n!=1:
            sum=0
            while n>0:
                temp=n%10
                sum=sum+temp**2
                n//=10
            if sum in set0:
                return False
            else:
                set0.add(sum)
            n=sum
        return True

#将数字转化为字符串处理
class Solution:
    def isHappy(self, n: int) -> bool:
        set0={1}
        while n not in set0:
            set0.add(n)
            n=sum(int(i)**2 for i in str(n))
        return n==1

LeetCode 290 Word Pattern

给出一个模式(pattern)以及一个字符串，判断这个字符串是否符合模式。
示例1: 输入: pattern = “abba”, str = “dog cat cat dog” 输出: true

将原来的dict通过map映射为相同的key，再比较相同key的dict是否相同。

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        str=str.split()
        return list(map(pattern.index,pattern))==list(map(str.index,str))

LeetCode 205 Isomorphic Strings

给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
示例 1: 输入: s = “egg”, t = “add” 输出: true

可以考虑通过建两个dict，比较怎样不同，也可以将不同转化为相同。

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        return list(map(s.index,s)) == list(map(t.index,t))

LeetCode 451 Sort Characters By Frequency

给定一个字符串，请将字符串里的字符按照出现的频率降序排列。
示例 1: 输入: “tree” 输出: “eert”

使用Counter，其中most_common([n])返回一个列表，包含n个最常见的元素及出现次数，按常见程度由高到低排序

class Solution:
    def frequencySort(self, s: str) -> str:
        return ''.join(k*v for k,v in collections.Counter(s).most_common())

LeetCode 35. Search Insert Position

给定排序数组和目标值，如果找到目标，则返回索引。如果不是，则返回按顺序插入索引的位置的索引。 您可以假设数组中没有重复项。
Example 1: Input: [1,3,5,6], 5 Output: 2

#二分法查找
class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left=0
        right=len(nums)-1
        while left<=right:
            mid=(left+right)//2
            if target<nums[mid]:
                right=mid-1
            elif target>nums[mid]:
                left=mid
            else:
                return mid
        return left

LeetCode 410. Split Array Largest Sum

给定一个由非负整数和整数m组成的数组，您可以将该数组拆分为m个非空连续子数组。编写算法以最小化这m个子数组中的最大和。
Input: nums = [7,2,5,10,8] m = 2 Output: 18

class Solution:
    def splitArray(self, nums: List[int], m: int) -> int:

        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

LeetCode540. Single Element in a Sorted Array

您将获得一个仅由整数组成的排序数组，其中每个元素精确出现两次，但一个元素仅出现一次。 找到只出现一次的单个元素。
Example 1: Input: [1,1,2,3,3,4,4,8,8] Output: 2

#暴力法
class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        for i in range(0,len(nums)-2,2):
            if nums[i]!=nums[i+1]:
                return nums[i]
        return nums

#异或
class Solution:
    def singleNonDuplicate(self, nums: List[int]) -> int:
        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]