【力扣：新动计划，编程入门 —— 题解 ④】

本文链接：https://blog.youkuaiyun.com/m0_73983707/article/details/146200707

努力的意义不仅是成功，还有不留遗憾

—— 25.3.12

258. 各位相加

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

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

0 <= num <= 231 - 1

进阶：你可以不使用循环或者递归，在 O(1) 时间复杂度内解决这个问题吗？

方法一递归判断

思路与算法

将输入 num 进行判断，如果 num 小于10，题目要求 num 为非负整数，所以数字必为 0 - 9 区间，定义两个变量 a 和 b，a 存储数字num小数点向前移动一位，b 数字存储数字num个位上的数字，将两个数字 a 和 b 相加传入递归函数 addDigits

终止条件：当数字小于10时，直接返回该数字。
分解步骤：将数字分解为高位部分（a = num // 10）和个位（b = num % 10）。
递归相加：将高位部分与个位相加，递归处理新生成的数字。

class Solution:
    def addDigits(self, num: int) -> int:
        if num < 10:
            return num
        # a存储数字num小数点向前移动一位，b数字存储数字num个位上的数字
        a, b = num // 10, num % 10
        return self.addDigits(a + b)

1281. 整数的各位积和之差

给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。

示例 1：
输入：n = 234
输出：15 
解释：
各位数之积 = 2 * 3 * 4 = 24 
各位数之和 = 2 + 3 + 4 = 9 
结果 = 24 - 9 = 15
示例 2：
输入：n = 4421
输出：21
解释： 
各位数之积 = 4 * 4 * 2 * 1 = 32 
各位数之和 = 4 + 4 + 2 + 1 = 11 
结果 = 32 - 11 = 21
提示：

1 <= n <= 10^5

方法一遍历

思路与算法

初始化变量：
- mul：用于存储各位数字的乘积，初始值为 1（因为乘积的初始值不能为 0）。
- sum：用于存储各位数字的和，初始值为 0。
逐位处理数字：
- 使用 while 循环，每次取出 n 的个位数字（通过 n % 10），然后更新 mul 和 sum。
- 将 n 去掉个位数字（通过 n //= 10），继续处理下一位，直到 n 变为 0。
返回结果：
- 计算并返回 mul - sum，即各位数字的乘积减去各位数字的和。

class Solution:
    def subtractProductAndSum(self, n: int) -> int:
        mul = 1
        sum = 0
        while n:
            mul *= n % 10
            sum += n % 10
            n //= 10 
        return mul - sum

867. 转置矩阵

给你一个二维整数数组 matrix，返回 matrix 的 转置矩阵 。

矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：
输入：matrix = [[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]
提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 1000
1 <= m * n <= 105

方法一逐列遍历原始矩阵

思路与算法

初始化结果矩阵：
- 使用一个空列表 ans 来存储转置后的矩阵。
逐列处理：
- 使用外层循环遍历原始矩阵的列（range(len(matrix[0]))）。
- 对于每一列，使用内层循环遍历原始矩阵的行（range(len(matrix))），并将该列的元素依次添加到临时列表 temp 中。
构建转置矩阵：
- 将每一列生成的临时列表 temp 添加到结果矩阵 ans 中。
返回结果：
- 返回转置后的矩阵 ans。

class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        ans = []
        for i in range(len(matrix[0])):
            temp = []
            for j in range(len(matrix)):
                temp.append(matrix[j][i])
            ans.append(temp)                
        return ans

方法二新建数组，将对应的值直接赋值

思路与算法

获取矩阵的维度：
- m：矩阵的行数（len(matrix)）。
- n：矩阵的列数（len(matrix[0])）。
预分配转置矩阵的空间：
- 使用列表推导式创建一个大小为 n x m 的二维列表 ans，并初始化为 None。
填充转置矩阵：
- 使用双重循环遍历原始矩阵的每一个元素。
- 将原始矩阵中 (low, rol) 位置的元素赋值给转置矩阵中 (rol, low) 的位置。
返回结果：
- 返回转置后的矩阵 ans。

class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        m = len(matrix)
        n = len(matrix[0])
        ans = [[None] * m for _ in range(n)]
        for low in range(m):
            for rol in range(n):
                ans[rol][low] = matrix[low][rol]
        return ans

852. 山脉数组的峰顶索引

给定一个长度为 n 的整数山脉数组 arr ，其中的值递增到一个 峰值元素 然后递减。

返回峰值元素的下标。

你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。

示例 1：
输入：arr = [0,1,0]
输出：1
示例 2：
输入：arr = [0,2,1,0]
输出：1
示例 3：
输入：arr = [0,10,5,2]
输出：1
提示：

3 <= arr.length <= 105
0 <= arr[i] <= 106
题目数据保证 arr 是一个山脉数组

方法一二分查找

思路与算法

初始化指针：
- l：左指针，初始为 0。
- r：右指针，初始为 len(arr) - 1。
二分查找：
- 计算中间索引 mid = (l + r) // 2。
- 如果 arr[mid] 是峰值（即 arr[mid-1] < arr[mid] 且 arr[mid+1] < arr[mid]），返回 mid。
- 如果 arr[mid-1] > arr[mid]，说明峰值在左侧，更新右指针 r = mid。
- 否则，说明峰值在右侧，更新左指针 l = mid。
终止条件：
- 当 l > r 时，循环结束。

class Solution:
    def peakIndexInMountainArray(self, arr: List[int]) -> int:
        l = 0
        r = len(arr) - 1
        while l <= r:
            mid = (l + r) // 2
            if arr[mid - 1] < arr[mid] and arr[mid + 1] < arr[mid]:
                return mid
            elif arr[mid - 1] > arr[mid]:
                r = mid
            else:
                l = mid