66.加一：模拟（附简单题必备——Python一行版）

【LetMeFly】66.加一：模拟（附简单题必备——Python一行版）

力扣题目链接：https://leetcode.cn/problems/plus-one/

给定一个表示 大整数 的整数数组 digits，其中 digits[i] 是整数的第 i 位数字。这些数字按从左到右，从最高位到最低位排列。这个大整数不包含任何前导 0。

将大整数加 1，并返回结果的数字数组。

 

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
加 1 后得到 123 + 1 = 124。
因此，结果应该是 [1,2,4]。

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
加 1 后得到 4321 + 1 = 4322。
因此，结果应该是 [4,3,2,2]。

示例 3：

输入：digits = [9]
输出：[1,0]
解释：输入数组表示数字 9。
加 1 得到了 9 + 1 = 10。
因此，结果应该是 [1,0]。

 

提示：

  • 1 <= digits.length <= 100
  • 0 <= digits[i] <= 9
  • digits 不包含任何前导 0。

解题方法：模拟

使用一个初始值为$1$的整数cnt代表加法运算过程中的进位值，然后就可以愉快地开始模拟啦！

幼儿园学习加法的过程中我们了解到，多位数加上一个个位数，将个位数加到多位数的个位，若大于$9$则不断向高位进位。

  • 时间复杂度$O(len(digits))$
  • 空间复杂度$O(1)$

AC代码

C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * @LastEditTime: 2026-01-01 15:44:13
 */
class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int cnt = 1;
        for (int i = digits.size() - 1; i >= 0; i--) {
            digits[i] += cnt;
            cnt = digits[i] / 10;
            digits[i] %= 10;
        }
        if (cnt) {
            digits.insert(digits.begin(), cnt);
        }
        return digits;
    }
};

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''
LastEditTime: 2026-01-01 15:54:44
'''
from typing import List

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        cnt = 1
        for i in range(len(digits) - 1, -1, -1):
            digits[i] += cnt
            cnt = digits[i] // 10
            digits[i] %= 10
        if cnt:
            digits = [1] + digits
        return digits

Python - 一行版

1
2
3
4
5
6
7
8
9
10
11
12
'''
LastEditTime: 2026-01-01 16:03:01
'''
from typing import List

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        return list(map(int, str(int(''.join(map(str, digits))) + 1)))

# if __name__ == '__main__':
#     sol = Solution()
#     print(sol.plusOne([1,2,3]))

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
 * @LastEditTime: 2026-01-01 15:59:15
 */
class Solution {
    public int[] plusOne(int[] digits) {
        int cnt = 1;
        for (int i = digits.length - 1; i >= 0; i--) {
            digits[i] += cnt;
            cnt = digits[i] / 10;
            digits[i] %= 10;
        }
        if (cnt > 0) {
            int[] ans = new int[digits.length + 1];
            ans[0] = cnt;
            for (int i = 0; i < digits.length; i++) {
                ans[i + 1] = digits[i];
            }
            return ans;
        }
        return digits;
    }
}

Go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 * @LastEditTime: 2026-01-01 16:09:18
 */
package main

func plusOne(digits []int) []int {
    cnt := 1
    for i := len(digits) - 1; i >= 0; i-- {
        digits[i] += cnt
        cnt = digits[i] / 10
        digits[i] %= 10
    }
    if cnt > 0 {
        return append([]int{cnt}, digits...)
    }
    return digits
}

Rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
 * @LastEditTime: 2026-01-01 16:06:45
 */
impl Solution {
    pub fn plus_one(mut digits: Vec<i32>) -> Vec<i32> {
        let mut cnt: i32 = 1;
        for i in (0..digits.len()).rev() {
            digits[i] += cnt;
            cnt = digits[i] / 10;
            digits[i] %= 10;
        }
        if cnt > 0 {
            digits.insert(0, cnt);
        }
        digits
    }
}

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源