练习

1、如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。

class Solution:
    def isPalindrome(self, s: str) -> bool:
        s=''.join(re.split('[^a-z0-9]+',s.lower()))
        s_re=''.join(s[::-1])
        #s=re.sub(r'[^a-zA-Z0-9]','',s).lower()
        #return s==s[::-1]
        return s==s_re

2、给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。返回 你能获得的 最大 利润 。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        return sum(b-a for a,b in zip(prices,prices[1:]) if b>a)

3、给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        nums=set(nums)
        res=0
        for i in nums:
            if i-1 not in nums:  #只找开头的数字，然后进行累加查找
                j=i+1
                while j in nums:
                    j+=1
                res=max(res,j-i)
        return res

4、给你一个字符串 columnTitle ，表示 Excel 表格中的列名称。返回 该列名称对应的列序号

示例 3:
输入: columnTitle = "ZY"
输出: 701

class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        A_list = list(string.ascii_uppercase)
        A_dic=dict(zip(A_list,[i for i in range(1,len(A_list)+1)]))
        str_new=columnTitle[::-1]
        sum_res=0
        for j in range(len(str_new)):
            sum_res += A_dic[str_new[j]] * 26**j
        return sum_res
        # print(str_new)

或者：
class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        ret_num = 0
        for i, column_word in enumerate(columnTitle[::-1]):
            ret_num += (ord(column_word) - 64) * 26 ** i
        return ret_num

5、给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。

class Solution:
    def isPalindrome(self, s: str) -> bool:
        # clean_s = re.sub(r'[^\w]', '', s)
        # clean_s=clean_s.replace("_","").lower()
        clean_s=re.sub(r'\W|_','',s.lower())
        # clean_s=re.sub(r'[^A-Za-z0-9]','',s)
        # clean_s=clean_s.lower()
        return clean_s==clean_s[::-1]

6、给你一个下标从 0 开始的整数数组 nums ，如果 恰好 删除 一个 元素后，数组 严格递增 ，那么请你返回 true ，否则返回 false 。如果数组本身已经是严格递增的，请你也返回 true 。

from collections import Counter
class Solution:
    def canBeIncreasing(self, nums: List[int]) -> bool:
        if len(nums)>len(set(nums))+1:
            return False   
        for key,value in Counter(nums).items():
            if value >=2:
                for i in range(len(nums)):
                    numss=nums.copy()
                    if numss[i]==key:
                        del numss[i]
                        if numss==sorted(numss):
                            return True
                return False
        for i in range(len(nums)):
            nums_s=nums.copy()
            del nums_s[i]
            if nums_s==sorted(nums_s):
                return True
        return False

7、给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。

class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        s=[value for value in Counter(arr).values()]
        return True if len(s)==len(set(s)) else False

8、编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if "" in strs:
            return ""
        if len(strs)==1:
            return strs[0]
        len_l=[len(i) for i in strs]
        n=min(len_l)
        ex=''
        for i in range(n):
            j=1
            while j<len(strs):
                if strs[0][i]==strs[j][i]:
                    pass
                elif i==0:
                    return ""
                else:
                    return strs[0][:i]
                j+=1
            ex=strs[0][:i+1]
        return ex
#上面是自己写的
#下面的一行代码解决
return os.path.commonprefix(strs)

9、如果两个字符串 word1 和 word2 中从 'a' 到 'z' 每一个字母出现频率之差都 不超过 3 ，那么我们称这两个字符串 word1 和 word2 几乎相等 。给你两个长度都为 n 的字符串 word1 和 word2 ，如果 word1 和 word2 几乎相等 ，请你返回 true ，否则返回 false 。一个字母 x 的出现 频率 指的是它在字符串中出现的次数。

class Solution:
    def checkAlmostEquivalent(self, word1: str, word2: str) -> bool:
        ss=set(word1.lower())
        ss1=set(word2.lower())
        ss.update(ss1)
        for i in ss:
            # if abs(self.tj(word1,i)-self.tj(word2,i))>3:
            #     return False
            if abs(word1.count(i)-word2.count(i))>3:
                return False
        return True

    # def tj(self,str,zm):
    #     nums=0
    #     for i in str:
    #         if i.lower()==zm:
    #             nums+=1
    #     return nums

10、有 n 个人前来排队买票，其中第 0 人站在队伍 最前方 ，第 (n - 1) 人站在队伍 最后方 。给你一个下标从 0 开始的整数数组 tickets ，数组长度为 n ，其中第 i 人想要购买的票数为 tickets[i] 。每个人买票都需要用掉 恰好 1 秒 。一个人 一次只能买一张票 ，如果需要购买更多票，他必须走到 队尾 重新排队（瞬间 发生，不计时间）。如果一个人没有剩下需要买的票，那他将会 离开 队伍。返回位于位置 k（下标从 0 开始）的人完成买票需要的时间（以秒为单位）。

class Solution:
    def timeRequiredToBuy(self, tickets: List[int], k: int) -> int:
        cs=0
        m=tickets[k]
        new_tickets=tickets
        for i in range(m):
            print(i)
            if i == m-1:
                new_tickets=new_tickets[:k+1]
            cs+=len(list(filter(lambda item:item>0,new_tickets)))
            new_tickets=list(map(lambda item:item-1,new_tickets))
        return cs
        #第二种方法
        # time=0
        # for i in range(len(tickets)):
        #     if i<=k:
        #         time+=min(tickets[i],tickets[k])
        #     else:
        #         time+=min(tickets[i],tickets[k]-1)
        # return time

11、我们可以给一个句子添加 从 1 开始的单词位置索引 ，并且将句子中所有单词 打乱顺序 。比方说，句子 "This is a sentence" 可以被打乱顺序得到 "sentence4 a3 is2 This1" 或者 "is2 sentence4 This1 a3" 。给你一个 打乱顺序 的句子 s ，它包含的单词不超过 9 个，请你重新构造并得到原本顺序的句子

class Solution:
    def sortSentence(self, s: str) -> str:
        return ' '.join ([item[:-1] for item in sorted(s.split(),key=lambda k:k[-1])])