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

我就是我 2023-06-15 15:27 69阅读 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) 。

## 代码 ##

class Solution:
        def trailingZeroes(self, n: int) -> int:
            i,zero_count = 1,0
            temp = pow(5,1)
            while temp <= n:
                zero_count += n // temp
                i += 1
                temp = pow(5,i)
            return zero_count
            # count = 0
            # while n >= 5:
            #     count += n // 5
            #     n //= 5
            # 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) 的 原地 算法。

## 代码 ##

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

## 大神代码 ##

# O(n)算法
    # 作者：zhu_shi_fu
    # 链接：https://leetcode-cn.com/problems/rotate-array/solution/san-ci-fan-zhuan-fu-yi-xie-pythonicde-jie-fa-pytho/
    
    '''
    三次反转
    对于[1,2,3,4,5,6,7]，
    根据k=k%n，将数组分为两段：
    
    第一段，对应数组下标范围[0,n-k-1][0,n−k−1]段，即[1,2,3,4][1,2,3,4]
    第二段，对应数组下标范围[n-k,n-1][n−k,n−1]，即[5,6,7][5,6,7]
    分为三步：
    
    反转第一段，[4,3,2,1,5,6,7]
    反转第二段，[4,3,2,1,7,6,5]
    反转整体，[5,6,7,1,2,3,4]
    '''
    # list切片方法
    class Solution:
        def rotate(self, nums: List[int], k: int) -> None:
            """
            Do not return anything, modify nums in-place instead.
            """
            n = len(nums)
            k %= n
            nums[:] = nums[::-1]
            nums[:k] = nums[:k][::-1]
            nums[k:] = nums[k:][::-1]
    # list切片简单方法
    class Solution:
        def rotate(self, nums: List[int], k: int) -> None:
            n=len(nums)
            k%=n
            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

## 代码 ##

class Solution:
        # @param n, an integer
        # @return an integer
        def reverseBits(self, n):
            n = bin(n)[2:]
            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/

class Solution:
        # @param n, an integer
        # @return an integer
        def reverseBits(self, n):
            return int(bin(n)[2:].zfill(32)[::-1], base=2)  
    # zfill方法，str.zfill(width)，返回指定长度的字符串，原字符串右对齐，前面填充0

class Solution:
        # @param n, an integer
        # @return an integer
        def reverseBits(self, n):
            res = 0
            count = 32
            
            while count:
                res <<= 1
                # 取出 n 的最低位数加到 res 中
                res += n&1
                n >>= 1
                count -= 1
                
            return int(bin(res), 2)

# 191 位1的个数 #

## 描述 ##

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

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

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

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

## 代码 ##

class Solution(object):
        def hammingWeight(self, n):
            """
            :type n: int
            :rtype: int
            """
            one_count = 0
            for i in range(32):
                if n&1:
                    one_count += 1
                n >>= 1
            return one_count

# 优化算法
    # https://leetcode-cn.com/u/xiao-xue-66/
    class Solution(object):
        def hammingWeight(self, n):
            """
            :type n: int
            :rtype: int
            """
            result = 0
            while n != 0:
                result += 1
                n &= (n-1)      # 可以将二进制最后一位变为0
            return result

## 大神代码-多种解法 ##

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

class Solution(object):
        def hammingWeight(self, n):
            """
            :type n: int
            :rtype: int
            """
            return bin(n).count('1')

class Solution(object):
        def hammingWeight(self, n):
            """
            :type n: int
            :rtype: int
            """
            count = 0
            while n:
                count += n&1
                n >>= 1
            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 。

## 代码-动态规划 ##

class Solution:
        def rob(self, nums: List[int]) -> int:
            pre_max = 0
            cur_max = 0
            for n in nums:
                temp = cur_max
                cur_max = max(pre_max + n, cur_max)
                pre_max = temp
            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

## 代码 ##

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

## 大神代码 ##

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

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