哈希表-1160-575-1640-剑指offer03-961-884-705(设计哈希表,拉链法待更新)-1189-1078-219

class Solution(object):
    def countCharacters(self, words, chars):
        """
        :type words: List[str]
        :type chars: str
        :rtype: int
        """
        dic={}
        sum=0
        for i in chars:
            dic[i]=dic.get(i,0)+1
        for i in words:
            cur_dic=dic.copy()
            flag=True
            for j in i:
                if cur_dic.get(j,-1)!=-1:
                    cur_dic[j]=cur_dic[j]-1
                    if cur_dic[j]==0:
                        del cur_dic[j]
                else:
                    flag=False
                    break
            if flag:
                sum+=len(i)
        return sum

class Solution(object):
    def distributeCandies(self, candyType):
        """
        :type candyType: List[int]
        :rtype: int
        """
        if len(set(candyType))>=len(candyType)//2:
            return len(candyType)//2
        else:
            return len(set(candyType))

class Solution(object):
    def canFormArray(self, arr, pieces):
        """
        :type arr: List[int]
        :type pieces: List[List[int]]
        :rtype: bool
        """
        hash_map={}
        for i in range(len(arr)):
            hash_map[arr[i]]=i
        for i in range(len(pieces)):
            if hash_map.get(pieces[i][0]) is None:
                return False
        pieces.sort(key=lambda x :hash_map[x[0]])
      
        cur_idx=0
        for i in range(len(pieces)):
            for j in range(len(pieces[i])):
                if arr[cur_idx]!=pieces[i][j]:
                    return False
                cur_idx+=1
        return True

class Solution(object):
    def findRepeatNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        hash_map={}
        for i in range(len(nums)):
            if hash_map.get(nums[i]) is None:
                hash_map[nums[i]]=1
            else:
                return nums[i]

class Solution(object):
    def repeatedNTimes(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        dic={}
        for i in A:
            if dic.get(i,-1)==-1:
                dic[i]=0
            else:
                return i

class Solution(object):
    def uncommonFromSentences(self, A, B):
        """
        :type A: str
        :type B: str
        :rtype: List[str]
        """
        dic1={}
        dic2={}
        A=A.split()
        for i in A:
            dic1[i]=dic1.get(i,0)+1
        data1=[]
        for k,v in dic1.items():
            if v==1:
                data1.append(k)
       
        B=B.split()
        for i in B:
            dic2[i]=dic2.get(i,0)+1
        data2=[]
        for k,v in dic2.items():
            if v==1:
                data2.append(k)

        res=[]
        for i in data1:
            if dic2.get(i,-1)==-1:
                res.append(i)
        for i in data2:
            if dic1.get(i,-1)==-1:
                res.append(i)
        return res

class Solution(object):
    def uncommonFromSentences(self, A, B):
        """
        :type A: str
        :type B: str
        :rtype: List[str]
        """
        dic={}
        res=[]
        AB=A+' '+B
        for i in AB.split():
            dic[i]=dic.get(i,0)+1
        for k,v in dic.items():
            if v==1:
                res.append(k)
        return res
        

class MyHashSet(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.data=[False]*1000001


    def add(self, key):
        """
        :type key: int
        :rtype: None
        """
        self.data[key]=True


    def remove(self, key):
        """
        :type key: int
        :rtype: None
        """
        self.data[key]=False


    def contains(self, key):
        """
        Returns true if this set contains the specified element
        :type key: int
        :rtype: bool
        """
        return self.data[key]==True



# Your MyHashSet object will be instantiated and called as such:
# obj = MyHashSet()
# obj.add(key)
# obj.remove(key)
# param_3 = obj.contains(key)

class Solution(object):
    def maxNumberOfBalloons(self, text):
        """
        :type text: str
        :rtype: int
        """
        dic={'b':0,'a':0,'l':0,'o':0,'n':0}
        for i in text:
            if dic.get(i,-1)!=-1:
                dic[i]=dic[i]+1
        min_data=[]
        for k,v in dic.items():
            if k in 'lo':
                min_data.append(v//2)
            else:
                min_data.append(v)
        return min(min_data)

```bash
class Solution(object):
    def findOcurrences(self, text, first, second):
        """
        :type text: str
        :type first: str
        :type second: str
        :rtype: List[str]
        """
        text=text.split()
        left=0
        res=[]

        while left<=len(text)-3:
            if text[left]==first:
                if text[left+1]==second:
                    res.append(text[left+2])
                    left+=2
                else:
                    left+=1
            else:
                left+=1
        return res
``

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        dic={}
        for i in range(len(nums)):
            if dic.get(nums[i],-1)==-1:
                dic[nums[i]]=i
            else:
                if k>=i-dic[nums[i]]:
                    return True
                else:
                    dic[nums[i]]=i
        return False