Leetcode简单题41~60

41.思路:分别在列表中存放两个单词的索引,再用两次遍历求距离# 给定一个单词列表和两个单词 word1 和 word2,返回列表中这两个单词之间的最短距离。# 示例:# 假设 words = ["practice", "makes", "perfect", "coding", "makes"]# 输入: word1 = “coding”, word2 = “practice”# 输出: 3# 输入: word1 = "makes", word2 = "coding"# 输出: 1#meclass Solution0(object):    def shortestDistance(self, words, word1, word2):        result = []        idwords1 = [id_ for id_,word in enumerate(words) if word == word1]        idwords2 = [id_ for id_,word in enumerate(words) if word == word2]        for id1 in idwords1:            for id2 in idwords2:                result.append(abs(id1-id2))        return min(result)#other 复杂度O(n)class Solution1(object):    def shortestDistance(self, words, word1, word2):        n = m = min_distance = size = len(words)        for i in range(size):            if words[i] == word1:                n = i            elif words[i] == word2:                m = i            if m != size and m != size:                min_distance = min(min_distance, abs(m - n))        return min_distance
*42.思路:奇数移动到奇数、偶数移动到偶数是无消耗的,意思是算奇数和偶数的个数。# 数轴上放置了一些筹码,每个筹码的位置存在数组 chips 当中。# 你可以对 任何筹码 执行下面两种操作之一(不限操作次数,0 次也可以):# 将第 i 个筹码向左或者右移动 2 个单位,代价为 0。# 将第 i 个筹码向左或者右移动 1 个单位,代价为 1。# 最开始的时候,同一位置上也可能放着两个或者更多的筹码。# 返回将所有筹码移动到同一位置(任意位置)上所需要的最小代价。# 示例 1:# 输入:chips = [1,2,3]# 输出:1# 解释:第二个筹码移动到位置三的代价是 1,第一个筹码移动到位置三的代价是 0,总代价为 1。# 示例 2:# 输入:chips = [2,2,2,3,3]# 输出:2# 解释:第四和第五个筹码移动到位置二的代价都是 1,所以最小总代价为 2。#meclass Solution(object):    def minCostToMoveChips(self, chips):        jiShuNum = len([i for i in chips if i%2 == 1])        ouShuNum = len([j for j in chips if j%2 == 0])        return min([jiShuNum,ouShuNum])
43.思路:直述题意# 给定仅有小写字母组成的字符串数组 A,返回列表中的每个字符串中都显示的全部字符(包括重复字符)组成的列表。例如,如果一个字符在每个字符串中出现 3 次,但不是 4 次,则需要在最终答案中包含该字符 3 次。# 你可以按任意顺序返回答案。# 示例 1:# 输入:["bella","label","roller"]# 输出:["e","l","l"]# 示例 2:# 输入:["cool","lock","cook"]# 输出:["c","o"]#meclass Solution0(object):    def commonChars(self, A):        allSigWord = []        for word in A:            for sigword in word:                allSigWord.append(str(sigword))        allReWord = [i for i in allSigWord if allSigWord.count(i)>=len(A)]        result = []        for sigReWord in set(allReWord):            allnum = []            for word in A:                allnum.append(word.count(sigReWord))            for i in range(min(allnum)):                result.append(sigReWord)        return(result)#other#思路:使用Counter得到每个字符串的字典,字典相交,然后转换为list输出#counter是 colletions内的一个类,可以理解为一个简单的计数器,可以统计字符出现的个数from collections import Counterclass Solution1(object):    def commonChars(self, A):        ans = Counter(A[0])        for i in range(1, len(A)):            ans &= Counter(A[i])        return list(ans.elements())#otherclass Solution:    def commonChars(self, A):        return [i for c in set(A[0]) for i in c * min(w.count(c) for w in A)] if A else []
44.思路:直述题意# 给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。# 示例 1:# 输入: S = "loveleetcode", C = ‘e‘# 输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]#meclass Solution0(object):    def shortestToChar(self, S, C):        C_ids = [Id for Id,s in enumerate(S) if s==C]        result = []        for Id,s in enumerate(S):            mid = []            for C_id in C_ids:                mid.append(abs(Id-C_id))            result.append(min(mid))        return result#otherclass Solution1(object):    def shortestToChar(self, S, C):        return [min([abs(i - j) for j in [k for k, c in enumerate(S) if c == C]]) for i in range(len(S))]
45.思路:1.使用列表存放最后两个数的和,2.递归算法# 斐波那契数,通常用 F(n) 表示,形成的序列称为斐波那契数列。该数列由 0 和 1 开始,后面的每一项数字都是前面两项数字的和。也就是:# F(0) = 0,   F(1) = 1# F(N) = F(N - 1) + F(N - 2), 其中 N > 1.# 给定 N,计算 F(N)。# 示例 1:# 输入:2# 输出:1# 解释:F(2) = F(1) + F(0) = 1 + 0 = 1.# 示例 2:# 输入:3# 输出:2# 解释:F(3) = F(2) + F(1) = 1 + 1 = 2.# 示例 3:# 输入:4# 输出:3# 解释:F(4) = F(3) + F(2) = 2 + 1 = 3.#meclass Solution0(object):    def fib(self, N):        resultList = [0,1]        if N == 2:            return 1        else:            while(N):                resultList.append(resultList[-1]+resultList[-2])                N-=1            return resultList[-2]#otherclass Solution1(object):    def fib(N):        if N in [0, 1]:            return N        a, b = 0, 1        while N > 1:            a, b = b, a + b            N -= 1        return bclass Solution2(object):    class Solution():        def Fibnacci(self, n):            if n <= 0:                return 0            if n == 1:                return 1            return self.Fibnacci(n - 1) + self.Fibnacci(n - 2)
46.思路:while循环,直到各个位数相加之和为一位数。# 给定一个非负整数 num,反复将各个位上的数字相加,直到结果为一位数。# 示例:# 输入: 38# 输出: 2# 解释: 各位相加的过程为:3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数,所以返回 2。#meclass Solution0(object):    def addDigits(self, num):        while(len(str(num))-1):            num = sum([int(i) for i in list(str(num))])        return str(num)[-1]#otherclass Solution1(object):    def addDigits(self, num):        while len(str(num)) > 1:            num = eval("+".join(list(str(num))))        return num
47.思路:1.直述题意,2.模拟法(动态规划)#给定一个非负整数 numRows,生成杨辉三角的前 numRows 行。#在杨辉三角中,每个数是它左上方和右上方的数的和#示例:# 输入: 5# 输出:# [#      [1],#     [1,1],#    [1,2,1],#   [1,3,3,1],#  [1,4,6,4,1]# ]#meclass Solution0(object):    def generate(self, numRows):        Result = [(i+1)*[1] for i in range(numRows)]        if numRows <=2:            return Result        else:            for i in range(2,numRows):                for j in range(1,len(Result[i])-1):                    Result[i][j] = Result[i-1][j-1]+Result[i-1][j]            return Result#other# 1.初始化结果数组,numRowsnumRows表示结果数组dpdp的行数,每一行的元素个数等于所处第几行。全部初始化为0# 2.将边界全部初始化为1# 3.遍历dpdp,将为00的位置使用动态规划填入,公式:dp[i][j]=dp[i-1][j-1]+dp[i-1][j]dp[i][j]=dp[i−1][j−1]+dp[i−1][j]class Solution:    def generate(self, numRows):        dp=[[0]*n for n in range(1,numRows+1)]        for i in range(numRows):            dp[i][0]=dp[i][-1]=1        for i in range(0,numRows):            for j in range(i+1):                if(dp[i][j]==0):                    dp[i][j]=dp[i-1][j-1]+dp[i-1][j]        return dp
48.思路:直述题意# 给出一个按 非递减 顺序排列的数组 nums,和一个目标数值 target。假如数组 nums 中绝大多数元素的数值都等于 target,则返回 True,否则请返回 False。# 所谓占绝大多数,是指在长度为 N 的数组中出现必须 超过 N/2 次。#meclass Solution(object):    def isMajorityElement(self, nums, target):        return bool(nums.count(target)>len(nums)//2)
49.思路:先处理"C"操作,再进行其他操作# 你现在是棒球比赛记录员。# 给定一个字符串列表,每个字符串可以是以下四种类型之一:# 1.整数(一轮的得分):直接表示您在本轮中获得的积分数。# 2. "+"(一轮的得分):表示本轮获得的得分是前两轮有效 回合得分的总和。# 3. "D"(一轮的得分):表示本轮获得的得分是前一轮有效 回合得分的两倍。# 4. "C"(一个操作,这不是一个回合的分数):表示您获得的最后一个有效 回合的分数是无效的,应该被移除。# 每一轮的操作都是永久性的,可能会对前一轮和后一轮产生影响。# 你需要返回你在所有回合中得分的总和。# 示例 1:# 输入: ["5","2","C","D","+"]# 输出: 30# 解释:# 第1轮:你可以得到5分。总和是:5。# 第2轮:你可以得到2分。总和是:7。# 操作1:第2轮的数据无效。总和是:5。# 第3轮:你可以得到10分(第2轮的数据已被删除)。总数是:15。# 第4轮:你可以得到5 + 10 = 15分。总数是:30。# 示例 2:# 输入: ["5","-2","4","C","D","9","+","+"]# 输出: 27# 解释:# 第1轮:你可以得到5分。总和是:5。# 第2轮:你可以得到-2分。总数是:3。# 第3轮:你可以得到4分。总和是:7。# 操作1:第3轮的数据无效。总数是:3。# 第4轮:你可以得到-4分(第三轮的数据已被删除)。总和是:-1。# 第5轮:你可以得到9分。总数是:8。# 第6轮:你可以得到-4 + 9 = 5分。总数是13。# 第7轮:你可以得到9 + 5 = 14分。总数是27。#meclass Solution0(object):    def calPoints(self, ops):        for ele in ops:            if ele == ‘C‘:                ops = ops[:ops.index(ele) - 1] + ops[ops.index(ele) + 1:]        result = 0        for i in ops:            if i == ‘D‘:                result += int(ops[ops.index(i) - 1]) * 2                ops[ops.index(i)] = int(ops[ops.index(i) - 1]) * 2            elif i == ‘+‘:                result += (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))                ops[ops.index(i)] = (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))            else:                result += int(i)        return result#otherclass Solution1(object):    def calPoints(self, ops):        stack = []        for op in ops:            if op == ‘+‘:                stack.append(stack[-1] + stack[-2])            elif op == ‘C‘:                stack.pop()            elif op == ‘D‘:                stack.append(2 * stack[-1])            else:                stack.append(int(op))        return sum(stack)
50.思路:转换思想,找出最长的字符串# 给定两个字符串,你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下:该序列为某字符串独有的最长子序列(即不能是其他字符串的子序列)。# 子序列可以通过删去字符串中的某些字符实现,但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列,任何字符串为其自身的子序列。# 输入为两个字符串,输出最长特殊序列的长度。如果不存在,则返回 -1。# 示例 :# 输入: "aba", "cdc"# 输出: 3# 解析: 最长特殊序列可为 "aba" (或 "cdc")#meclass Solution0(object):    def findLUSlength(self, a, b):        na = a if len(a)>len(b) else b        nb = b if len(b)<len(a) else a        result = []        for i in range(len(na)-1):            for j in range(1,len(na)+1):                sub = na[i:j]                print(sub)                if sub not in nb:                    result.append(len(sub))        if result != []:            return max(result)        else:            return -1#otherclass Solution1(object):    def findLUSlength(self, a, b):        if a == b:            return -1        elif len(a) > len(b):            return len(a)        else:            return len(b)
51.思路:转换思想,求差值# 给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。# 说明:# 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?# 示例 1:# 输入: [2,2,1]# 输出: 1# 示例 2:# 输入: [4,1,2,1,2]# 输出: 4#otherclass Solution1(object):    def singleNumber(self, nums):        return sum(set(nums))*2-sum(nums)
52.思路:用集合来判断糖果的种类个数,因为弟弟和妹妹两个人糖果数一样,所以总个数的一半为界# 给定一个偶数长度的数组,其中不同的数字代表着不同种类的糖果,每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。# 示例 1:# 输入: candies = [1,1,2,2,3,3]# 输出: 3# 解析: 一共有三种种类的糖果,每一种都有两个。# 最优分配方案:妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。# 示例 2 :# 输入: candies = [1,1,2,3]# 输出: 2# 解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1],妹妹有两种不同的糖果,弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。#meclass Solution(object):    def distributeCandies(self, candies):        return len(set(candies)) if len(set(candies))<=len(candies)//2 else len(candies)//2
*53.思路:通过栈来实现# 给出由小写字母组成的字符串 S,重复项删除操作会选择两个相邻且相同的字母,并删除它们。# 在 S 上反复执行重复项删除操作,直到无法继续删除。# 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。# 示例:# 输入:"abbaca"# 输出:"ca"# 解释:# 例如,在 "abbaca" 中,我们可以删除 "bb" 由于两字母相邻且相同,这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca",其中又只有 "aa" 可以执行重复项删除操作,所以最后的字符串为 "ca"。#me#栈的思想class Solution(object):    def removeDuplicates(self, S):        Stack = []        for s in S:            if Stack == []:                Stack.append(s)            elif s!= Stack[-1]:                Stack.append(s)            else:                Stack.pop()        return ‘‘.join(Stack)
54.思路:直述题意# 给你两个数组,arr1 和 arr2,# arr2 中的元素各不相同# arr2 中的每个元素都出现在 arr1 中# 对 arr1 中的元素进行排序,使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。# 示例:# 输入:arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]# 输出:[2,2,2,1,4,3,3,9,6,7,19]#meclass Solution(object):    def relativeSortArray(self, arr1, arr2):        orgarr2 = list(arr2)        containList = [i for i in arr1 if i in arr2]        notContainList = sorted([i for i in arr1 if i not in arr2])        for i in containList:            arr2.insert(arr2.index(i),i)        midResult = arr2+notContainList        for i in orgarr2:            midResult.remove(i)        return midResult#otherclass Solution1(object):    def relativeSortArray(self, arr1, arr2):        arr3 = []        set_2 = set(arr2)        for i in arr1[::-1]:            if i not in set_2:                arr1.remove(i)                arr3.append(i)        arr3.sort(reverse = True)        for i in arr2[::-1]:            num = arr1.count(i)            arr3.extend([i for j in range(num)])        return arr3[::-1]
55.思路:直述题意# 给你一份『词汇表』(字符串数组) words 和一张『字母表』(字符串) chars。# 假如你可以用 chars 中的『字母』(字符)拼写出 words 中的某个『单词』(字符串),那么我们就认为你掌握了这个单词。# 注意:每次拼写时,chars 中的每个字母都只能用一次。# 返回词汇表 words 中你掌握的所有单词的 长度之和。# 示例 1:# 输入:words = ["cat","bt","hat","tree"], chars = "atach"# 输出:6# 解释:# 可以形成字符串 "cat" 和 "hat",所以答案是 3 + 3 = 6。# 示例 2:# 输入:words = ["hello","world","leetcode"], chars = "welldonehoneyr"# 输出:10# 解释:# 可以形成字符串 "hello" 和 "world",所以答案是 5 + 5 = 10。#meclass Solution(object):    def countCharacters(self, words, chars):        mid = []        for word in words:            flag = True            for sigWord in word:                if word.count(sigWord)>chars.count(sigWord):                    flag = False                    break            if flag:                mid.append(word)        return len(‘‘.join(mid))#otherimport collectionsclass Solution1(object):    def countCharacters(self, words, chars):        ans = 0        cnt = collections.Counter(chars)        for w in words:            c = collections.Counter(w)            if all([c[i] <= cnt[i] for i in c]):                ans += len(w)        return ans
56.思路:先排序,再计算相邻两个元素的最小绝对差# 给你个整数数组 arr,其中每个元素都 不相同。# 请你找到所有具有最小绝对差的元素对,并且按升序的顺序返回。# 示例 1:# 输入:arr = [4,2,1,3]# 输出:[[1,2],[2,3],[3,4]]# 示例 2:# 输入:arr = [1,3,6,10,15]# 输出:[[1,3]]# 示例 3:# 输入:arr = [3,8,-10,23,19,-4,-14,27]# 输出:[[-14,-10],[19,23],[23,27]]#meclass Solution(object):    def minimumAbsDifference(self, arr):        abslist = sorted(arr)        midresult = []        lastresult = []        for i in range(1, len(abslist)):            midresult.append(abslist[i]-abslist[i-1])        min_abstract = min(midresult)        for Id, result in enumerate(midresult):            mid = []            if result == min_abstract:                mid.append(abslist[Id])                mid.append(abslist[Id+1])                lastresult.append(mid)        return lastresult
57.思路:直述题意# 我们要把给定的字符串 S 从左到右写到每一行上,每一行的最大宽度为100个单位,如果我们在写某个字母的时候会使这行超过了100 个单位,那么我们应该把这个字母写到下一行。我们给定了一个数组 widths ,这个数组 widths[0] 代表 ‘a‘ 需要的单位, widths[1] 代表 ‘b‘ 需要的单位,..., widths[25] 代表 ‘z‘ 需要的单位。# 现在回答两个问题:至少多少行能放下S,以及最后一行使用的宽度是多少个单位?将你的答案作为长度为2的整数列表返回。# 示例 1:# 输入:# widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]# S = "abcdefghijklmnopqrstuvwxyz"# 输出: [3, 60]# 解释:# 所有的字符拥有相同的占用单位10。所以书写所有的26个字母,# 我们需要2个整行和占用60个单位的一行。# 示例 2:# 输入:# widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]# S = "bbbcccdddaaa"# 输出: [2, 4]# 解释:# 除去字母‘a‘所有的字符都是相同的单位10,并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.# 最后一个字母 ‘a‘ 将会被写到第二行,因为第一行只剩下2个单位了。# 所以,这个答案是2行,第二行有4个单位宽度。#otherclass Solution(object):    def numberOfLines(self, widths, S):        line = 1        result = 0        for i in S:            num = ord(i) - 97            result += widths[num]            if result > 100:                result = 0 + widths[num]                line += 1            if result == 100:                result = 0                line += 1        return [line, result]
58.思路:先变为一维向量,再按照列元素个数取值存放# 在MATLAB中,有一个非常有用的函数 reshape,它可以将一个矩阵重塑为另一个大小不同的新矩阵,但保留其原始数据。# 给出一个由二维数组表示的矩阵,以及两个正整数r和c,分别表示想要的重构的矩阵的行数和列数。# 重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。# 如果具有给定参数的reshape操作是可行且合理的,则输出新的重塑矩阵;否则,输出原始矩阵。# 示例 1:# 输入:# nums =# [[1,2],#  [3,4]]# r = 1, c = 4# 输出:# [[1,2,3,4]]# 解释:# 行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。# 示例 2:# 输入:# nums =# [[1,2],#  [3,4]]# r = 2, c = 4# 输出:# [[1,2],#  [3,4]]#meclass Solution0(object):    def matrixReshape(self, nums, r, c):        allNum = []        for i in nums:            allNum += i        result = []        if len(allNum)%r==0:            for sub1 in range(r):                j = len(allNum)//r                subNum = allNum[sub1*j:(sub1+1)*j]                result.append(subNum)            return result        else:            return nums#otherclass Solution1(object):    def matrixReshape(self, nums, r, c):        if len(nums) == 0:            return nums        c0 = len(nums[0])        r0 = len(nums)        if r*c != r0*c0:            return nums        result = [[0]*c for _ in range(r)]        for i in range(r):            for j in range(c):                t = i*c+j                result[i][j] = nums[t//c0][t%c0]        return result
59.思路:将当前元素索引以后的元素存放在列表中,然后查找# 给定两个没有重复元素的数组 nums1 和 nums2 ,其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。# nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在,对应位置输出-1。# 示例 1:# 输入: nums1 = [4,1,2], nums2 = [1,3,4,2].# 输出: [-1,3,-1]# 解释:#     对于num1中的数字4,你无法在第二个数组中找到下一个更大的数字,因此输出 -1。#     对于num1中的数字1,第二个数组中数字1右边的下一个较大数字是 3。#     对于num1中的数字2,第二个数组中没有下一个更大的数字,因此输出 -1。# 示例 2:# 输入: nums1 = [2,4], nums2 = [1,2,3,4].# 输出: [3,-1]# 解释:#    对于num1中的数字2,第二个数组中的下一个较大数字是3。#     对于num1中的数字4,第二个数组中没有下一个更大的数字,因此输出 -1。#meclass Solution0(object):    def nextGreaterElement(self, nums1, nums2):        result = []        for i in nums1:            sub = []            subList = nums2[nums2.index(i):]            for j in subList:                if j > i:                    sub.append(j)            sub1 = [-1] if sub==[] else sub            mid = sub1[0]            result.append(mid)        return result#other# 思路# 遍历nums2,维护一个递减栈# 当得到一个更大的数的时候,将栈里小于它的数都放到哈希表当中# 举例来说,如果nums2里是3,2,1,4,那么栈前三位都是3,2,1,当遍历到4的时候,发现4比1大,这时候,哈希表里要添加hashmap[1] = 4,hashmap[2] = 4,hashmap[3] = 4。含义是,对于1这个数字而言,右边第一个比它大的数字是4。后面几个同理。# 遍历nums1,对每一项查找哈希表,找到第一个比它大的数,并返回一个列表作为答案。如果在哈希表中不存在则返回默认值-1。class Solution1(object):    def nextGreaterElement(self, nums1, nums2):        stack, hashmap = list(), dict()        for i in nums2:            while len(stack) != 0 and stack[-1] < i:hashmap[stack.pop()] = i            stack.append(i)        return [hashmap.get(i,-1) for i in nums1]
60.思路:用两个栈实现,一个栈负责压入,另一个负责弹出# 使用栈实现队列的下列操作:# push(x) -- 将一个元素放入队列的尾部。# pop() -- 从队列首部移除元素。# peek() -- 返回队列首部的元素。# empty() -- 返回队列是否为空。# 示例:# MyQuque queue = new MyQueue();# queue.push(1);# queue.push(2);# queue.peek();  // 返回 1# queue.pop();   // 返回 1# queue.empty(); // 返回 false#meclass MyQueue(object):    def __init__(self):        """        Initialize your data structure here.        """        self.stack1 = []        self.stack2 = []    def push(self, x):        """        Push element x to the back of queue.        :type x: int        :rtype: None        """        self.stack1.append(x)    def pop(self):        """        Removes the element from in front of queue and returns that element.        :rtype: int        """        if self.stack2:            return self.stack2.pop()        else:            while self.stack1:                self.stack2.append(self.stack1.pop())            return self.stack2.pop()    def peek(self):        """        Get the front element.        :rtype: int        """        if self.stack1:            return self.stack1[0]        else:            return self.stack2[-1]    def empty(self):        """        Returns whether the queue is empty.        :rtype: bool        """        if self.stack1 == [] and self.stack2 == []:            return True        else:            return False



原文地址:https://www.cnblogs.com/xhw19950606/p/11965686.html

时间: 2024-11-09 02:05:05

Leetcode简单题41~60的相关文章

leetcode 简单题

堆 (leetcode 703) 数据流中的第k大元素 利用小顶堆 class KthLargest: def __init__(self, k: int, nums: List[int]): self.k = k self.size = len(nums) self.nums = nums heapq.heapify(self.nums) while self.size > k: heapq.heappop(self.nums) self.size -= 1 def add(self, val

Leetcode简单题61~80

61.思路:bin# 编写一个函数,输入是一个无符号整数,返回其二进制表达式中数字位数为 ‘1’ 的个数(也被称为汉明重量).# 示例 1:# 输入:00000000000000000000000000001011# 输出:3# 解释:输入的二进制串 00000000000000000000000000001011 中,共有三位为 '1'.# 示例 2:# 输入:00000000000000000000000010000000# 输出:1# 解释:输入的二进制串 0000000000000000

【leetcode 简单】第十七题 二进制求和

实现 int sqrt(int x) 函数. 计算并返回 x 的平方根,其中 x 是非负整数. 由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去. 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842...,   由于返回类型是整数,小数部分将被舍去. #define PF(w) ((w)*(w)) int mySqrt(int x) { int start = 0; int end = x; double mid = 0; i

【leetcode 简单】 第七十题 有效的字母异位词

给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的一个字母异位词. 示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat", t = "car" 输出: false 说明: 你可以假设字符串只包含小写字母. 进阶: 如果输入字符串包含 unicode 字符怎么办?你能否调整你的解法来应对这种情况? class Solution:

【leetcode 简单】 第七十一题 二叉树的所有路径

给定一个二叉树,返回所有从根节点到叶子节点的路径. 说明: 叶子节点是指没有子节点的节点. 示例: 输入: 1 / 2 3 5 输出: ["1->2->5", "1->3"] 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x

【leetcode 简单】 第七十七题 单词模式

给定一种 pattern(模式) 和一个字符串 str ,判断 str 是否遵循相同的模式. 这里的遵循指完全匹配,例如, pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应模式. 示例1: 输入: pattern = "abba", str = "dog cat cat dog" 输出: true 示例 2: 输入:pattern = "abba", str = "dog cat cat fish&

【leetcode 简单】 第九十六题 最长回文串

给定一个包含大写字母和小写字母的字符串,找到通过这些字母构造成的最长的回文串. 在构造过程中,请注意区分大小写.比如 "Aa" 不能当做一个回文字符串. 注意: 假设字符串的长度不会超过 1010. 示例 1: 输入: "abccccdd" 输出: 7 解释: 我们可以构造的最长的回文串是"dccaccd", 它的长度是 7. class Solution(object): def longestPalindrome(self, s): &quo

【leetcode 简单】 第九十一题 找不同

给定两个字符串 s 和 t,它们只包含小写字母. 字符串 t 由字符串 s 随机重排,然后在随机位置添加一个字母. 请找出在 t 中被添加的字母. 示例: 输入: s = "abcd" t = "abcde" 输出: e 解释: 'e' 是那个被添加的字母. class Solution(object): def findTheDifference(self, s, t): """ :type s: str :type t: str :

leetcode刷题--两数之和(简单)

一.序言 第一次刷leetcode的题,之前从来没有刷题然后去面试的概念,直到临近秋招,或许是秋招结束的时候才有这个意识,原来面试是需要刷题的,面试问的问题都是千篇一律的,只要刷够了题就差不多了,当然你的基础也要扎实,毕竟在技术面的时候很容易露馅的. 所以奉劝各位还未毕业,在大三或大二的师弟师妹早点刷题,心里也有底气进入求职大军,毕竟大四开始刷题的话时间上有些太紧了,推荐刷题的话就是牛客和leetcode. 回归正题,这次记录的是leetcode刷的第一题--两数之和. 二.审题 审题真的很重要