Leetcode简单题61~80

Posted 2020-11-24 xhw19950606

61.思路：bin
# 编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
# 示例 1：
# 输入：00000000000000000000000000001011
# 输出：3
# 解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1‘。
# 示例 2：
# 输入：00000000000000000000000010000000
# 输出：1
# 解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1‘。
# 示例 3：
# 输入：11111111111111111111111111111101
# 输出：31
# 解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1‘。
#me
class 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"
# ]
#me
class 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
#me
class 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 操作）。
#other
import collections
class 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]。
#other
class 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
#me
class 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"]
#other
class 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
#me
class 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
#me
class 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‘ 是那个被添加的字母。
#me
class 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.
#other
class 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"]
#me
class 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"]
#me
class 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 re
class 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 。
#me
class 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
#other
class 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
# 解释：
# 数组中不存在仅出现一次的整数。
#me
class 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")。
#me
class 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。
#other
class 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]
# 说明:
# 必须在原数组上操作，不能拷贝额外的数组。
# 尽量减少操作次数。
#me
class 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"
#me
class 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 不是好数, 因为他们在旋转之后不变。
#me
class 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