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): """ :type A: List[str] :rtype: List[str] """ 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
