61.思路：bin# 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。# 示例 1：# 输入：00000000000000000000000000001011# 输出：3# 解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1‘。# 示例 2：# 输入：00000000000000000000000010000000# 输出：1# 解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1‘。# 示例 3：# 输入：11111111111111111111111111111101# 输出：31# 解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1‘。#meclass Solution(object): def hammingWeight(self, n): return bin(n).count(‘1‘)
62.思路：直述题意# 写一个程序，输出从 1 到 n 数字的字符串表示。# 1. 如果 n 是3的倍数，输出“Fizz”；# 2. 如果 n 是5的倍数，输出“Buzz”；# 3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。# 示例：# n = 15,# 返回:# [# "1",# "2",# "Fizz",# "4",# "Buzz",# "Fizz",# "7",# "8",# "Fizz",# "Buzz",# "11",# "Fizz",# "13",# "14",# "FizzBuzz"# ]#meclass Solution(object): def fizzBuzz(self, n): result = [] for i in range(1,n+1): if i%3==0 and i%5!=0: result.append(‘Fizz‘) elif i%5==0 and i%3!=0: result.append(‘Buzz‘) elif i%3==0 and i%5==0: result.append(‘FizzBuzz‘) else: result.append(str(i)) return result
63.思路：计算balloon中各字母的个数# 给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 "balloon"（气球）。# 字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 "balloon"。# 示例 1：# 输入：text = "nlaebolko"# 输出：1# 示例 2：# 输入：text = "loonbalxballpoon"# 输出：2# 示例 3：# 输入：text = "leetcode"# 输出：0#meclass Solution(object): def maxNumberOfBalloons(self, text): return min(text.count(‘b‘), text.count(‘a‘), text.count(‘l‘)//2, text.count(‘o‘)//2, text.count(‘n‘))
64.思路：collections.deque()引入队列# 使用队列实现栈的下列操作：# push(x) -- 元素 x 入栈# pop() -- 移除栈顶元素# top() -- 获取栈顶元素# empty() -- 返回栈是否为空# 注意:# 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。# 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。# 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。#otherimport collectionsclass MyStack: def __init__(self): self.data = collections.deque() def push(self, x): """ Push element x onto stack. :type x: int :rtype: None """ self.data.append(x) for i in range(len(self.data) - 1): self.data.append(self.data.popleft()) def pop(self): """ Removes the element on top of the stack and returns that element. :rtype: int """ return self.data.popleft() def top(self): """ Get the top element. :rtype: int """ return self.data[0] def empty(self): """ Returns whether the stack is empty. :rtype: bool """ return not len(self.data)
65.思路：数学推导# 排排坐，分糖果。# 我们买了一些糖果 candies，打算把它们分给排好队的 n = num_people 个小朋友。# 给第一个小朋友 1 颗糖果，第二个小朋友 2 颗，依此类推，直到给最后一个小朋友 n 颗糖果。# 然后，我们再回到队伍的起点，给第一个小朋友 n + 1 颗糖果，第二个小朋友 n + 2 颗，依此类推，直到给最后一个小朋友 2 * n 颗糖果。# 重复上述过程（每次都比上一次多给出一颗糖果，当到达队伍终点后再次从队伍起点开始），直到我们分完所有的糖果。注意，就算我们手中的剩下糖果数不够（不比前一次发出的糖果多），这些糖果也会全部发给当前的小朋友。# 返回一个长度为 num_people、元素之和为 candies 的数组，以表示糖果的最终分发情况（即 ans[i] 表示第 i 个小朋友分到的糖果数）。# 示例 1：# 输入：candies = 7, num_people = 4# 输出：[1,2,3,1]# 解释：# 第一次，ans[0] += 1，数组变为 [1,0,0,0]。# 第二次，ans[1] += 2，数组变为 [1,2,0,0]。# 第三次，ans[2] += 3，数组变为 [1,2,3,0]。# 第四次，ans[3] += 1（因为此时只剩下 1 颗糖果），最终数组变为 [1,2,3,1]。# 示例 2：# 输入：candies = 10, num_people = 3# 输出：[5,2,3]# 解释：# 第一次，ans[0] += 1，数组变为 [1,0,0]。# 第二次，ans[1] += 2，数组变为 [1,2,0]。# 第三次，ans[2] += 3，数组变为 [1,2,3]。# 第四次，ans[0] += 4，最终数组变为 [5,2,3]。#otherclass Solution(object): def distributeCandies(self, candies, num_people): ans = [0 for i in range(num_people)] x = 1 while candies > 0: for i in range(num_people): if candies > x: ans[i] += x candies -= x x += 1 else: ans[i] += candies candies = 0 return ans
66.思路：计算字母偶数个数# 给定一个字符串，判断该字符串中是否可以通过重新排列组合，形成一个回文字符串。# 示例 1：# 输入: "code"# 输出: false# 示例 2：# 输入: "aab"# 输出: true# 示例 3：# 输入: "carerac"# 输出: true#meclass Solution(object): def canPermutePalindrome(self, s): s_set = set(s) s_num_list = [] for sub in s_set: s_num_list.append(s.count(sub)) num = 0 for s_num in s_num_list: if s_num%2==0: num+=1 return True if num>=(len(s_num_list)-1) else False
67.思路：直述题意，str.lower(),str.upper()# 给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。# 示例:# 输入: S = "a1b2"# 输出: ["a1b2", "a1B2", "A1b2", "A1B2"]# 输入: S = "3z4"# 输出: ["3z4", "3Z4"]# 输入: S = "12345"# 输出: ["12345"]#otherclass Solution(object): def letterCasePermutation(self, S): res = [‘‘] for ch in S: if ch.isalpha(): res = [old+new for old in res for new in [ch.lower(), ch.upper()]] #print(res) else: res = [old+ch for old in res] print(res) return res
68.思路：直述题意# 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。# 你可以假设数组是非空的，并且给定的数组总是存在多数元素。# 示例 1:# 输入: [3,2,3]# 输出: 3# 示例 2:# 输入: [2,2,1,1,1,2,2]# 输出: 2#meclass Solution(object): def majorityElement(self, nums): return [i for i in set(nums) if nums.count(i)>len(nums)//2][0]
69.思路：直述题意，依次比较相邻两个述# 给定一个正整数，检查他是否为交替位二进制数：换句话说，就是他的二进制数相邻的两个位数永不相等。# 示例 1:# 输入: 5# 输出: True# 解释:# 5的二进制数是: 101# 示例 2:# 输入: 7# 输出: False# 解释:# 7的二进制数是: 111# 示例 3:# 输入: 11# 输出: False# 解释:# 11的二进制数是: 1011# 示例 4:# 输入: 10# 输出: True# 解释:# 10的二进制数是: 1010#meclass Solution(object): def hasAlternatingBits(self, n): str_n = str(bin(n)[2:]) flag = True for i in range(1,len(str_n)): if str_n[i] == str_n[i-1]: flag = False break return flag
70.思路：直述题意# 给定两个字符串 s 和 t，它们只包含小写字母。# 字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。# 请找出在 t 中被添加的字母。# 示例:# 输入：# s = "abcd"# t = "abcde"# 输出：# e# 解释：# ‘e‘ 是那个被添加的字母。#meclass Solution(object): def findTheDifference(self, s, t): for i in t: if s.count(i) != t.count(i): return i
*71.思路：转换思维# 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。# 字符 数值# I 1# V 5# X 10# L 50# C 100# D 500# M 1000# 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。# 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：# I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。# X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 # C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。# 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。# 示例 1:# 输入: "III"# 输出: 3# 示例 2:# 输入: "IV"# 输出: 4# 示例 3:# 输入: "IX"# 输出: 9# 示例 4:# 输入: "LVIII"# 输出: 58# 解释: L = 50, V= 5, III = 3.# 示例 5:# 输入: "MCMXCIV"# 输出: 1994# 解释: M = 1000, CM = 900, XC = 90, IV = 4.#otherclass Solution(object): def romanToInt(self, s): d = {‘I‘: 1, ‘IV‘: -1, ‘V‘: 5, ‘IX‘: -1, ‘X‘: 10, ‘XL‘: -10, ‘L‘: 50, ‘XC‘: -10, ‘C‘: 100, ‘CD‘: -100, ‘D‘: 500, ‘CM‘: -100, ‘M‘: 1000} return sum(d.get(s[i: i + 2], d[s[i]]) for i in range(len(s)))
72.思路：直述题意# 给定两个句子 A 和 B 。 （句子是一串由空格分隔的单词。每个单词仅由小写字母组成。）# 如果一个单词在其中一个句子中只出现一次，在另一个句子中却没有出现，那么这个单词就是不常见的。# 返回所有不常用单词的列表。# 您可以按任何顺序返回列表。# 示例 1：# 输入：A = "this apple is sweet", B = "this apple is sour"# 输出：["sweet","sour"]# 示例 2：# 输入：A = "apple apple", B = "banana"# 输出：["banana"]#meclass Solution0(object): def uncommonFromSentences(self, A, B): sig_word_A = [i for i in A.split(‘ ‘)] sig_word_B = [i for i in B.split(‘ ‘)] result = [] for sigA in sig_word_A: if sig_word_A.count(sigA) == 1: if sigA not in sig_word_B: result.append(sigA) for sigB in sig_word_B: if sig_word_B.count(sigB) == 1: if sigB not in sig_word_A: result.append(sigB) return result
73.思路：直述题意# 给出第一个词 first 和第二个词 second，考虑在某些文本 text 中可能以 "first second third" 形式出现的情况，其中 second 紧随 first 出现，third 紧随 second 出现。# 对于每种这样的情况，将第三个词 "third" 添加到答案中，并返回答案。# 示例 1：# 输入：text = "alice is a good girl she is a good student", first = "a", second = "good"# 输出：["girl","student"]# 示例 2：# 输入：text = "we will we will rock you", first = "we", second = "will"# 输出：["we","rock"]#meclass Solution0(object): def findOcurrences(self, text, first, second): return [text.split(‘ ‘)[i] for i in range(2,len(text.split(‘ ‘))) if text.split(‘ ‘)[i-2]==first and text.split(‘ ‘)[i-1]==second]#other#正则表达式import reclass Solution1(object): def findOcurrences(self, text, first, second): return re.findall("(?<={first} {second} )\S*", text)
74.思路：直述题意# 给定一个正整数 N，找到并返回 N 的二进制表示中两个连续的 1 之间的最长距离。 # 如果没有两个连续的 1，返回 0 。# 示例 1：# 输入：22# 输出：2# 解释：# 22 的二进制是 0b10110 。# 在 22 的二进制表示中，有三个 1，组成两对连续的 1 。# 第一对连续的 1 中，两个 1 之间的距离为 2 。# 第二对连续的 1 中，两个 1 之间的距离为 1 。# 答案取两个距离之中最大的，也就是 2 。# 示例 2：# 输入：5# 输出：2# 解释：# 5 的二进制是 0b101 。# 示例 3：# 输入：6# 输出：1# 解释：# 6 的二进制是 0b110 。# 示例 4：# 输入：8# 输出：0# 解释：# 8 的二进制是 0b1000 。# 在 8 的二进制表示中没有连续的 1，所以返回 0 。#meclass Solution0(object): def binaryGap(self, N): strBinN = str(bin(N))[2:] index_1 = [Id for Id, strn in enumerate(strBinN) if strn==‘1‘] resultList = [] for i in range(1, len(index_1)): resultList.append(index_1[i]-index_1[i-1]) return max(resultList) if resultList != [] else 0#otherclass Solution1(object): def binaryGap(self, N): return max([len(i) + 1 for i in bin(N)[2:].split(‘1‘)[1:-1]] + [0])
75.思路：直述题意# 给你一个整数数组 A，请找出并返回在该数组中仅出现一次的最大整数。# 如果不存在这个只出现一次的整数，则返回 -1。# 示例 1：# 输入：[5,7,3,9,4,9,8,3,1]# 输出：8# 解释：# 数组中最大的整数是 9，但它在数组中重复出现了。而第二大的整数是 8，它只出现了一次，所以答案是 8。# 示例 2：# 输入：[9,9,8,8]# 输出：-1# 解释：# 数组中不存在仅出现一次的整数。#meclass Solution(object): def largestUniqueNumber(self, A): return max([i for i in A if A.count(i)==1]) if [i for i in A if A.count(i)==1]!=[] else -1
76.思路：直述题意# 我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。# 例如，若 s = "dcce"，那么 f(s) = 2，因为最小的字母是 "c"，它出现了 2 次。# 现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。# 示例 1：# 输入：queries = ["cbd"], words = ["zaaaz"]# 输出：[1]# 解释：查询 f("cbd") = 1，而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。# 示例 2：# 输入：queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]# 输出：[1,2]# 解释：第一个查询 f("bbb") < f("aaaa")，第二个查询 f("aaa") 和 f("aaaa") 都 > f("cc")。#meclass Solution(object): def numSmallerByFrequency(self, queries, words): midqueries = [i.count(min(i)) for i in queries] midwords = [j.count(min(j)) for j in words] result = [] for subquer in midqueries: num = 0 for subword in midwords: if subquer<subword: num+=1 result.append(num) return result
*77.思路：转换思维，先将所有的偶数都减去，再相加进行判断# 给出一个整数数组 A 和一个查询数组 queries。# 对于第 i 次查询，有 val = queries[i][0], index = queries[i][1]，我们会把 val 加到 A[index] 上。然后，第 i 次查询的答案是 A 中偶数值的和。# （此处给定的 index = queries[i][1] 是从 0 开始的索引，每次查询都会永久修改数组 A。）# 返回所有查询的答案。你的答案应当以数组 answer 给出，answer[i] 为第 i 次查询的答案。# 示例：# 输入：A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]# 输出：[8,6,2,4]# 解释：# 开始时，数组为 [1,2,3,4]。# 将 1 加到 A[0] 上之后，数组为 [2,2,3,4]，偶数值之和为 2 + 2 + 4 = 8。# 将 -3 加到 A[1] 上之后，数组为 [2,-1,3,4]，偶数值之和为 2 + 4 = 6。# 将 -4 加到 A[0] 上之后，数组为 [-2,-1,3,4]，偶数值之和为 -2 + 4 = 2。# 将 2 加到 A[3] 上之后，数组为 [-2,-1,3,6]，偶数值之和为 -2 + 6 = 4。#otherclass Solution(object): def sumEvenAfterQueries(self, A, queries): S = sum(x for x in A if x % 2 == 0) ans = [] for x, k in queries: if A[k] % 2 == 0: # 关键在这里，要换一个思维角度，不要像方法二一样分类，只要是偶数先减掉再说 S -= A[k] print(S) A[k] += x if A[k] % 2 == 0: # 只要是偶数就加上 S += A[k] print(S) ans.append(S) return ans
*78.思路：进行遍历，遇到0就进行剔除并添加# 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。# 示例:# 输入: [0,1,0,3,12]# 输出: [1,3,12,0,0]# 说明:# 必须在原数组上操作，不能拷贝额外的数组。# 尽量减少操作次数。#meclass Solution(object): def moveZeroes(self, nums): for i in nums: if i == 0: nums.append(0) nums.remove(0) return nums
79.思路：直述题意# 给定一个由空格分割单词的句子 S。每个单词只包含大写或小写字母。# 我们要将句子转换为 “Goat Latin”（一种类似于 猪拉丁文 - Pig Latin 的虚构语言）。# 山羊拉丁文的规则如下：# 如果单词以元音开头（a, e, i, o, u），在单词后添加"ma"。# 例如，单词"apple"变为"applema"。# 如果单词以辅音字母开头（即非元音字母），移除第一个字符并将它放到末尾，之后再添加"ma"。# 例如，单词"goat"变为"oatgma"。# 根据单词在句子中的索引，在单词最后添加与索引相同数量的字母‘a‘，索引从1开始。# 例如，在第一个单词后添加"a"，在第二个单词后添加"aa"，以此类推。# 返回将 S 转换为山羊拉丁文后的句子。# 示例 1:# 输入: "I speak Goat Latin"# 输出: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"# 示例 2:# 输入: "The quick brown fox jumped over the lazy dog"# 输出: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"#meclass Solution(object): def toGoatLatin(self, S): resultlist = [] for i,s in enumerate(S.split(‘ ‘)): if s[0] in [‘a‘, ‘e‘, ‘i‘, ‘o‘, ‘u‘, ‘A‘, ‘E‘, ‘I‘, ‘O‘, ‘U‘]: s += ‘ma‘ else: s = s[1:]+s[0] s += ‘ma‘ s += ‘a‘*(i+1) resultlist.append(s) return ‘ ‘.join(resultlist)
*80.思路：利用子集来进行判断A.issubset(B)# 我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后，我们仍可以得到一个有效的，且和 X 不同的数。要求每位数字都要被旋转。# 如果一个数的每位数字被旋转以后仍然还是一个数字， 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己；2 和 5 可以互相旋转成对方；6 和 9 同理，除了这些以外其他的数字旋转以后都不再是有效的数字。# 现在我们有一个正整数 N, 计算从 1 到 N 中有多少个数 X 是好数？# 示例:# 输入: 10# 输出: 4# 解释:# 在[1, 10]中有四个好数： 2, 5, 6, 9。# 注意 1 和 10 不是好数, 因为他们在旋转之后不变。#meclass Solution(object): def rotatedDigits(self, N): allnum = {0, 1, 8, 2, 5, 6, 9} k = 0 for n in range(N+1): n_nums = set([int(i) for i in str(n)]) if n_nums.issubset(allnum) and not n_nums.issubset({0,1,8}): k+=1 return k
原文地址：https://www.cnblogs.com/xhw19950606/p/12008650.html
时间： 2024-10-04 09:59:35