leetcode刷题Day6

蔡小菜123

于 2024-05-23 17:09:00 发布

阅读量794

点赞数 6

文章标签： leetcode log4j 算法 python

本文链接：https://blog.csdn.net/m0_63318949/article/details/139145777

版权

leetcode刷题Day6

49.各位相加
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果。

示例：输入: num = 38; 输出: 2 ; 解释: 各位相加的过程为： 38 --> 3 + 8 --> 11 11 --> 1 + 1
–> 2 由于 2 是一位数，所以返回 2。

class Solution:
    def addDigits(self, num: int) -> int:
        count = 0
        if num >= 10:
            for i in str(num):
                count += int(i)
            if count < 10: return count
            else: return self.addDigits(count)
        else: return num

50.丑数
丑数就是只包含质因数 2、3 和 5 的正整数。
给你一个整数 n ，请你判断 n 是否为丑数。如果是，返回 true；否则，返回 false。

示例：输入：n = 6; 输出：true; 解释：6 = 2 × 3

class Solution:
    def isUgly(self, n: int) -> bool:
        list1 = [2,3,5]
        if n == 1: return True
        if n <= 0: return False
        list2 = self.prime_factor(n)
        print(list2)
        for i in list2:
            if i not in list1: return False
        return True
        

    def prime_factor(self, num):
        list1 = []
        for i in range(2, num + 1):
            while num % i == 0:
                list1.append(i)
                num //= i
                if num == 1:
                    return list1

以上为先求该数的所有质因数，然后判断是否只含有2，3，5，但是超出时间限制。

class Solution:
    def isUgly(self, n: int) -> bool:
        if n <= 0: return False
        while n % 2 == 0:
            n //= 2
        while n % 3 == 0:
            n //= 3
        while n % 5 == 0:
            n //= 5
        return n == 1

51.丢失的数字
给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

示例：输入：nums = [3,0,1]; 输出：2; 解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2是丢失的数字，因为它没有出现在 nums 中。

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(n+1):
            if i not in nums:
                return i

52.第一个错误的版本
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例：输入：n = 5, bad = 4; 输出：4; 解释：调用 isBadVersion(3) -> false 调用
isBadVersion(5) -> true 调用 isBadVersion(4) -> true 所以，4 是第一个错误的版本。
使用二分查找：

class Solution:
    def firstBadVersion(self, n: int) -> int:
        min_n = 1
        max_n = n
        while min_n <= max_n:
            n = (min_n + max_n) // 2
            if isBadVersion(n):
                max_n = n - 1
            else: min_n = n + 1
        return min_n

53.移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意，必须在不复制数组的情况下原地对数组进行操作。

示例：输入: nums = [0,1,0,3,12]; 输出: [1,3,12,0,0]

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        for i in nums:
            if i == 0:
                nums.remove(0)
                nums.append(i)
        return nums

54.单词规律
给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

示例：输入: pattern = “abba”, s = “dog cat cat dog”; 输出: true

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        list1 = s.split(" ")
        if len(pattern) != len(list1): return False
        p_map = {}
        s_map = {}
        for i in range(len(pattern)):
            p_char = pattern[i]
            s_char = list1[i]
            if p_char in p_map:
                if p_map[p_char] != s_char:
                    return False
            else:
                if s_char in s_map:
                    return False
                p_map[p_char] = s_char
                s_map[s_char] = p_char
        return True

该题逻辑上与Day5的41题相同

55.3的幂
给定一个整数，写一个函数来判断它是否是 3 的幂次方。如果是，返回 true；否则，返回 false 。
整数 n 是 3 的幂次方需满足：存在整数 x 使得 n == 3^x。

示例：输入：n = 27; 输出：true

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        if n < 1 : return False
        while n % 3 == 0:
            n //= 3
        return n == 1

56.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例：输入：s = [“h”,“e”,“l”,“l”,“o”]; 输出：[“o”,“l”,“l”,“e”,“h”]

class Solution:
    def reverseString(self, s: List[str]) -> None:
        s.reverse()
        return s

57.两个数组的交集
给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

示例：输入：nums1 = [1,2,2,1], nums2 = [2,2]; 输出：[2]

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = []
        for i in nums1:
            if i in nums2 and i not in result:
                result.append(i)
        return result

58.两个数组的交集II
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例：输入：nums1 = [1,2,2,1], nums2 = [2,2]; 输出：[2,2]

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        result = []
        nums1.sort()
        nums2.sort()
        length1, length2 = len(nums1), len(nums2)
        index1, index2 = 0, 0
        while index1 < length1 and index2 < length2:
            if nums1[index1] < nums2[index2]:
                index1 += 1
            elif nums1[index1] > nums2[index2]:
                index2 += 1
            else: 
                result.append(nums1[index1])
                index1 += 1
                index2 += 1
        return result

59.有效的完全平方数
给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
完全平方数是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。
不能使用任何内置的库函数，如 sqrt 。

示例：输入：num = 16; 输出：true; 解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。

class Solution:
    def isPerfectSquare(self, num: int) -> bool:
        if num == 1: return True
        for i in range(2, num):
            if num // i == i and num % i == 0:
                return True
            else: continue
        return False

上述代码超出时间限制，改用二分查找。

class Solution:
    def isPerfectSquare(self, num: int) -> bool:
        if num == 1: return True
        min_num, max_num = 1, num-1
        while min_num <= max_num:
            mid = (min_num + max_num) // 2
            if num / (mid * 1.0) == mid:
                return True
            elif num / mid < mid:
                max_num = mid - 1
            else:
                min_num = mid + 1
        return False

60.猜数字大小
我们正在玩猜数字游戏。猜数字游戏的规则如下：
我会从 1 到 n 随机选择一个数字。请你猜选出的是哪个数字。
如果你猜错了，我会告诉你，我选出的数字比你猜测的数字大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有三种可能的情况：

-1：你猜的数字比我选出的数字大（即 num > pick）。
1：你猜的数字比我选出的数字小（即 num < pick）。
0：你猜的数字与我选出的数字相等。（即 num == pick）。
返回我选出的数字。
示例：输入：n = 10, pick = 6; 输出：6

class Solution:
    def guessNumber(self, n: int) -> int:
        min_num, max_num = 1, n
        while min_num <= max_num:
            mid = (min_num + max_num) // 2
            if guess(mid) == 0:
                return mid
            elif guess(mid) == -1:
                max_num = mid - 1
            else: min_num = mid + 1
        return min_num

61.赎金信
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

示例：输入：ransomNote = “a”, magazine = “b”; 输出：false

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        count = collections.Counter(magazine)
        for i in ransomNote:
            count[i] -= 1
            if count[i] < 0:
                return False
        return True

62.字符串中的第一个唯一字符
给定一个字符串 s ，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1 。

示例：输入: s = “leetcode”; 输出: 0

class Solution:
    def firstUniqChar(self, s: str) -> int:
        counter = collections.Counter(s)
        for i in counter:
            if counter[i] == 1:
                return s.index(i)
        return -1

63.找不同
给定两个字符串 s 和 t ，它们只包含小写字母。
字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。

示例：输入：s = “abcd”, t = “abcde”; 输出：“e”; 解释：‘e’ 是那个被添加的字母。

class Solution:
    def findTheDifference(self, s: str, t: str) -> str:
        count = collections.Counter(t)
        for i in s:
            count[i] -= 1
        for i in count:
            if count[i] != 0:
                return i

蔡小菜123

关注

6
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
leetcode刷题Day6

返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。输出结果中的每个元素一定是唯一的。这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。给定一个字符串 s ，找到它的第一个不重复的字符，并返回它的索引。给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
复制链接

扫一扫