查找1

35.搜索插入位置
题目描述：
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: [1,3,5,6], 5
输出: 2

示例 2:

输入: [1,3,5,6], 2
输出: 1

示例 3:

输入: [1,3,5,6], 7
输出: 4

示例 4:

输入: [1,3,5,6], 0
输出: 0

思路：
这题最简单直接的思路就是遍历数组，因为是排序数组，那么当找到等于或大于target的数时，直接输出其索引即可，若没找到直接输出最后一个数组长度，即最后一个索引值加一。

代码：

class Solution:
    def searchInsert(self, nums: [int], target: int) -> int:
        for i in range(len(nums)):
            if nums[i] >= target:
                return i
        return len(nums)

二分法

class Solution:
    def searchInsert(self, nums: [int], target: int) -> int:
        n = len(nums)
        if n == 0:
            return 0
        pivot = n//2
        left = 0
        right = n-1
        while left <= right:
            if nums[pivot] >= target:
                right = pivot-1
                pivot = (right-left)//2+left
            else:
                left = pivot+1
                pivot = (right-left)//2+left
        return left

202. 快乐数
     编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：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:
        nums = [n]
        while n != 1:
            n = self.sumOfsquare(n)
            if n in nums:
                return False
            nums.append(n)
        return True

    def sumOfsquare(self, n: int) -> int:
        divisor = 10
        debits = [(n % divisor) ** 2]
        while n // divisor != 0:
            n = n // divisor
            debits.append((n % divisor) ** 2)
        return sum(debits)

205. 同构字符串
     给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = "egg", t = "add"
输出: true

示例 2:

输入: s = "foo", t = "bar"
输出: false

示例 3:

输入: s = "paper", t = "title"
输出: true

说明:
你可以假设 s 和 t 具有相同的长度。

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        n = len(s)
        if n != len(t):
            return False
        dic = {}
        for i in range(n):
            if s[i] not in dic.keys():
                if t[i] not in dic.values():
                    dic[s[i]] = t[i]
                else:
                    return False
            else:
                if dic[s[i]] != t[i]:
                    return False
        return True

242. 有效的字母异位词
     题目描述：
     给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

说明:
你可以假设字符串只包含小写字母。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        n = len(s)
        if n != len(t):
            return False
        dic = {}
        for i in range(n):
            if s[i] in dic.keys():
                dic[s[i]] += 1
            else:
                dic[s[i]] = 1
            if t[i] in dic.keys():
                dic[t[i]] -= 1
            else:
                dic[t[i]] = -1
        if any(dic.values()):
            return False
        else:
            return True

思路：
python set方法

290. 单词规律
     题目描述：
     给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true

示例 2:

输入:pattern = "abba", str = "dog cat cat fish"
输出: false

示例 3:

输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false
示例 4:

输入: pattern = "abba", str = "dog dog dog dog"
输出: false

说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。

class Solution:
    def wordPattern(self, pattern: str, str: str) -> bool:
        str_list = str.split(" ")
        n =  len(pattern)
        if n != len(str_list):
            return False
        dic = {}
        for i in range(n):
            if pattern[i] not in dic.keys():
                if str_list[i] in dic.values():
                    return False
                dic[pattern[i]] = str_list[i]
            else:
                if dic[pattern[i]] != str_list[i]:
                    return False
        return True

349. 两个数组的交集
     题目描述：
     给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]

说明：

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

class Solution:
    def intersection(self, nums1: [int], nums2: [int]) -> [int]:
        nums1 = set(nums1)
        nums2 = set(nums2)
        intsect =[]
        for i in nums1:
            if i in nums2:
                intsect.append(i)
        return intsect

350. 两个数组的交集 II
     题目描述：
     给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。

class Solution:
    def intersect(self, nums1: [int], nums2: [int]) -> [int]:
        intsect = []
        for i in nums1:
            if i in nums2:
                intsect.append(i)
                nums2.remove(i)
        return intsect

410. 分割数组的最大值
     题目描述：
     给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。

注意:
数组长度 n 满足以下条件:

1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)
示例:

输入:
nums = [7,2,5,10,8]
m = 2

输出:
18

解释:
一共有四种方法将nums分割为2个子数组。
其中最好的方式是将其分为[7,2,5] 和 [10,8]，
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。1
451. 根据字符出现频率排序
题目描述：
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
"tree"

输出:
"eert"

解释:
'e'出现两次，'r'和't'都只出现一次。
因此'e'必须出现在'r'和't'之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入:
"cccaaa"

输出:
"cccaaa"

解释:
'c'和'a'都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入:
"Aabb"

输出:
"bbAa"

解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意'A'和'a'被认为是两种不同的字符。

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

540. 有序数组中的单一元素
     题目描述：
     给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:

输入: [3,3,7,7,10,11,11]
输出: 10

注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。

class Solution:
    def singleNonDuplicate(self, nums: [int]) -> int:
        l = 0
        h =len(nums)-1
        while l<h:
            mid = l+(h-l)//2
            if mid%2==1:
                mid -= 1
            if nums[mid]==nums[mid+1]:
                l = mid+2
            else:
                h = mid
        return nums[h]