leetcode刷题Day8

1.字符串中的单词数
统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
请注意，你可以假定字符串里不包括任何不可打印的字符。
示例:
输入: “Hello, my name is John”
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 “Hello,” 算作 1 个单词。

class Solution:
    def countSegments(self, s: str) -> int:
        return len(s.split())

注意：split()的时候，多个空格当成一个空格；split(’ ')的时候，多个空格也要分割，会分割出来空。

2.排列硬币
你总共有 n 枚硬币，并计划将它们按阶梯状排列。对于一个由 k 行组成的阶梯，其第 i 行必须正好有 i 枚硬币。阶梯的最后一行 可能 是不完整的。
给你一个数字 n ，计算并返回可形成 完整阶梯行 的总行数。
示例：

class Solution:
    def arrangeCoins(self, n: int) -> int:
        for i in range(1, n+1):
            if n - i < 0:
                return i - 1
            elif n - i == 0:
                return i
            else: n = n - i

3.找到所有数组中消失的数字
给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
示例：
输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        num = len(nums)
        result = []
        counter = set(nums)
        for i in range(1, num+1):
            if i not in counter:
                result.append(i)
        return result

注意：先用set()去重，不然遍历的时候数量太多，超出时间限制。

4.分发饼干
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例：
输入: g = [1,2,3], s = [1,1]
输出: 1
解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。所以你应该输出1。

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        n = len(g)  # 孩子的数量
        m = len(s)  # 饼干的数量
        res = 0
        for i in range(m):
            if res < n and g[res] <= s[i]:
                res += 1
        return res

5.重复的子字符串
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例：
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        return True if s in (s+s)[1:-1] else False

注：如果s中含有重复子串，则s+s去头去尾后仍含有s，反之，则不含有重复子串。

6.汉明距离
两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。
给你两个整数 x 和 y，计算并返回它们之间的汉明距离。
示例：
输入：x = 1, y = 4
输出：2

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        x_bytes_seq = x.to_bytes(length=1, byteorder='big', signed=False)
        x_binary_string = ''.join(f'{byte:08b}' for byte in x_bytes_seq)
        y_bytes_seq = y.to_bytes(length=1, byteorder='big', signed=False)
        y_binary_string = ''.join(f'{byte:08b}' for byte in y_bytes_seq)
        num = 0
        for i in range(len(x_binary_string)):
            if x_binary_string[i] != y_binary_string[i]:
                num += 1
        return num

执行出错，遇到整数太大的情况，无法转换。
改用异或解决问题。

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        return bin(x^y).count("1")

7.数字的补数
对整数的二进制表示取反（0 变 1 ，1 变 0）后，再转换为十进制表示，可以得到这个整数的补数。
例如，整数 5 的二进制表示是 “101” ，取反后得到 “010” ，再转回十进制表示得到补数 2 。
给你一个整数 num ，输出它的补数。

class Solution:
    def findComplement(self, num: int) -> int:
        num_binary = format(num, "b")
        res_binary = ""
        for i in range(len(num_binary)):
            if num_binary[i] == "0":
                res_binary += "1"
            elif num_binary[i] == "1":
                res_binary += "0"
        return int(res_binary, 2)

8.密钥格式化
给定一个许可密钥字符串 s，仅由字母、数字字符和破折号组成。字符串由 n 个破折号分成 n + 1 组。你也会得到一个整数 k 。
我们想要重新格式化字符串 s，使每一组包含 k 个字符，除了第一组，它可以比 k 短，但仍然必须包含至少一个字符。此外，两组之间必须插入破折号，并且应该将所有小写字母转换为大写字母。
返回 重新格式化的许可密钥 。
示例：
输入：S = “5F3Z-2e-9-w”, k = 4
输出：“5F3Z-2E9W”
解释：字符串 S 被分成了两个部分，每部分 4 个字符；
注意，两个额外的破折号需要删掉。

class Solution:
    def licenseKeyFormatting(self, s: str, k: int) -> str:
        s = s.replace("-","")
        res = ""
        num = len(s)
        y_num = num % k
        if y_num == 0:
            for i in range(0, num, k):
                res = res + s[i:i+k] + "-"
        else:
            res = s[0:y_num] + "-"
            for i in range(y_num, num, k):
                res = res + s[i:i+k] + "-"
        res = res[:-1]
        return res.upper()

9.最大连续1的个数
给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。
示例：
输入：nums = [1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        max_num = 0
        num = 0
        for i in nums:
            if i == 1:
                num += 1
                if max_num < num:
                    max_num = num
            else: num = 0
        return max_num

10.下一个更大元素I
nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。
给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。
对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。
返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。
示例：
输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：

• 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
• 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。
• 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res = []
        num = len(nums2)   
        for i in nums1:
            temp = -1
            index = nums2.index(i)
            for j in nums2[index+1:]:
                if j > i:
                    temp = j
                    break
            res.append(temp)
        return res