LeetCode简单题目(#172 #189 #190 #191 #198 #202)-6道（序列、数字）

我就是我 2023-06-15 15:27 96阅读 0赞

leetcode题库中共有350道简单题目。
本文记录已解决的题目和代码。
本文中的序号是leetcode题目中的真实序号。

文章目录

  • 172 阶乘后的零
    • 描述
    • 代码
    • 官方解答
  • 189 旋转数组
    • 描述
    • 代码
    • 大神代码
  • 190 颠倒二进制位
    • 描述
    • 代码
    • 大神代码
  • 191 位1的个数
    • 描述
    • 代码
    • 大神代码-多种解法
  • 198 打家劫舍
    • 描述
    • 代码-动态规划
    • 详解
  • 202 快乐数
    • 描述
    • 代码
    • 大神代码

172 阶乘后的零

描述

给定一个整数 n，返回 n! 结果尾数中零的数量。
示例 1:
输入: 3
输出: 0
解释: 3! = 6, 尾数中没有零。

示例 2:
输入: 5
输出: 1
解释: 5! = 120, 尾数中有 1 个零.
说明: 你算法的时间复杂度应为 O(log n) 。

代码

  1. class Solution:
  2.     def trailingZeroes(self, n: int) -> int:
  3.         i,zero_count = 1,0
  4.         temp = pow(5,1)
  5.         while temp <= n:
  6.             zero_count += n // temp
  7.             i += 1
  8.             temp = pow(5,i)
  9.         return zero_count
  10.         # count = 0
  11.         # while n >= 5:
  12.         #     count += n // 5
  13.         #     n //= 5
  14.         # return count

官方解答

https://leetcode-cn.com/problems/factorial-trailing-zeroes/solution/q172-factorial-trailing-zeroes-by-ronhou/

189 旋转数组

描述

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]

示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。

代码

  1. class Solution:
  2.     def rotate(self, nums: List[int], k: int) -> None:
  3.         """
  4.         Do not return anything, modify nums in-place instead.
  5.         """
  6.         for i in range(k):
  7.             nums.insert(0,nums.pop())   # insert方法耗时O(n^2)

大神代码

  1. # O(n)算法
  2. # 作者：zhu_shi_fu
  3. # 链接：https://leetcode-cn.com/problems/rotate-array/solution/san-ci-fan-zhuan-fu-yi-xie-pythonicde-jie-fa-pytho/
  5. '''
  6. 三次反转
  7. 对于[1,2,3,4,5,6,7]，
  8. 根据k=k%n，将数组分为两段：
  10. 第一段，对应数组下标范围[0,n-k-1][0,n−k−1]段，即[1,2,3,4][1,2,3,4]
  11. 第二段，对应数组下标范围[n-k,n-1][n−k,n−1]，即[5,6,7][5,6,7]
  12. 分为三步：
  14. 反转第一段，[4,3,2,1,5,6,7]
  15. 反转第二段，[4,3,2,1,7,6,5]
  16. 反转整体，[5,6,7,1,2,3,4]
  17. '''
  18. # list切片方法
  19. class Solution:
  20.     def rotate(self, nums: List[int], k: int) -> None:
  21.         """
  22.         Do not return anything, modify nums in-place instead.
  23.         """
  24.         n = len(nums)
  25.         k %= n
  26.         nums[:] = nums[::-1]
  27.         nums[:k] = nums[:k][::-1]
  28.         nums[k:] = nums[k:][::-1]
  29. # list切片简单方法
  30. class Solution:
  31.     def rotate(self, nums: List[int], k: int) -> None:
  32.         n=len(nums)
  33.         k%=n
  34.         nums[:]=nums[n-k:]+nums[:n-k]

190 颠倒二进制位

描述

颠倒给定的 32 位无符号整数的二进制位。
示例 1：

输入: 00000010100101000001111010011100
输出: 00111001011110000010100101000000
解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。
示例 2：
输入：11111111111111111111111111111101
输出：10111111111111111111111111111111
解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。
提示：
请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825

代码

  1. class Solution:
  2.     # @param n, an integer
  3.     # @return an integer
  4.     def reverseBits(self, n):
  5.         n = bin(n)[2:]
  6.         return int(n[::-1]+'0'*(32 - len(n)),2)

大神代码

作者：jalan
链接：https://leetcode-cn.com/problems/reverse-bits/solution/python-de-liang-chong-jie-fa-by-jalan/

  1. class Solution:
  2.     # @param n, an integer
  3.     # @return an integer
  4.     def reverseBits(self, n):
  5.         return int(bin(n)[2:].zfill(32)[::-1], base=2)  
  6. # zfill方法，str.zfill(width)，返回指定长度的字符串，原字符串右对齐，前面填充0
  8. class Solution:
  9.     # @param n, an integer
  10.     # @return an integer
  11.     def reverseBits(self, n):
  12.         res = 0
  13.         count = 32
  15.         while count:
  16.             res <<= 1
  17.             # 取出 n 的最低位数加到 res 中
  18.             res += n&1
  19.             n >>= 1
  20.             count -= 1
  22.         return int(bin(res), 2)

191 位1的个数

描述

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

代码

  1. class Solution(object):
  2.     def hammingWeight(self, n):
  3.         """
  4.         :type n: int
  5.         :rtype: int
  6.         """
  7.         one_count = 0
  8.         for i in range(32):
  9.             if n&1:
  10.                 one_count += 1
  11.             n >>= 1
  12.         return one_count
  14. # 优化算法
  15. # https://leetcode-cn.com/u/xiao-xue-66/
  16. class Solution(object):
  17.     def hammingWeight(self, n):
  18.         """
  19.         :type n: int
  20.         :rtype: int
  21.         """
  22.         result = 0
  23.         while n != 0:
  24.             result += 1
  25.             n &= (n-1)      # 可以将二进制最后一位变为0
  26.         return result

大神代码-多种解法

作者：jalan
链接：https://leetcode-cn.com/problems/number-of-1-bits/solution/python-de-si-chong-xie-fa-by-jalan/

  1. class Solution(object):
  2.     def hammingWeight(self, n):
  3.         """
  4.         :type n: int
  5.         :rtype: int
  6.         """
  7.         return bin(n).count('1')
  9. class Solution(object):
  10.     def hammingWeight(self, n):
  11.         """
  12.         :type n: int
  13.         :rtype: int
  14.         """
  15.         count = 0
  16.         while n:
  17.             count += n&1
  18.             n >>= 1
  19.         return count

198 打家劫舍

描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

代码-动态规划

  1. class Solution:
  2.     def rob(self, nums: List[int]) -> int:
  3.         pre_max = 0
  4.         cur_max = 0
  5.         for n in nums:
  6.             temp = cur_max
  7.             cur_max = max(pre_max + n, cur_max)
  8.             pre_max = temp
  9.         return cur_max

详解

https://leetcode-cn.com/problems/house-robber/solution/da-jia-jie-she-by-leetcode/

202 快乐数

描述

编写一个算法来判断一个数是不是“快乐数”。
一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。
示例:

输入: 19
输出: true
解释:
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

代码

  1. class Solution:
  2.     def isHappy(self, n: int) -> bool:
  3.         n_list = []
  4.         while n not in n_list:
  5.             n_list.append(n)
  6.             sum_n = sum([int(i)**2 for i in str(n)])
  7.             n = sum_n
  8.             if n == 1:
  9.                 return True
  10.         return False

大神代码

作者：000sheldon
链接：https://leetcode-cn.com/problems/happy-number/solution/python-jie-fa-by-000sheldon-2/

  1. while True:
  2.     n = sum([int(i)**2 for i in str(n)])
  3.     if n == 4:
  4.         return False
  5.     if n == 1:
  6.         return True

发表评论

表情：
评论列表 （有 0 条评论，96人围观）

还没有评论，来说两句吧...

相关阅读

    相关 LeetCode 172

    问题描述： 给定一个整数 n，返回 n! 结果尾数中零的数量。 示例 1: 输入: 3 输出: 0 解释: 3! = 6, 尾数中没有零。 示例 2: 输入

    墨蓝墨蓝/ 0 赞/ 374 阅读

    相关 LeetCode 189

    给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 示例 1: 输入: \[1,2,3,4,5,6,7\] 和 k = 3 输出: \[5,6,7,

    朱雀朱雀/ 0 赞/ 245 阅读

    相关 LeetCode 198

    问题描述： 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷

    待我称王封你为后i待我称王封你为后i/ 0 赞/ 269 阅读