力扣00066.加一

发表于 分类于 阅读次数： 本文字数： 1.6k 阅读时长 ≈ 6 分钟
加一、数组、数学、简单

题目描述

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：

输入：digits = [0]
输出：[1]

提示：

  • 1 <= digits.length <= 100
  • 0 <= digits[i] <= 9

解决方法

C++

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

结果

执行用时 : 0 ms, 击败 100.00% 使用 C++ 的用户

内存消耗 : 10.16 MB, 击败 8.56% 使用 C++ 的用户

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
    public int[] plusOne(int[] digits) {
        int n = digits.length;
        int carry = 1;
        for (int i = n - 1; i >= 0; --i) {
            digits[i] += carry;
            if (digits[i] < 10) {
                return digits;
            } else {
                digits[i] = 0;
                carry = 1;
            }
        }
        int[] result = new int[n + 1];
        result[0] = 1;
        return result;
    }
}

结果

执行用时 : 0 ms, 击败 100.00% 使用 Java 的用户

内存消耗 : 40.90 MB, 击败 40.83% 使用 Java 的用户

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        n = len(digits)
        carry = 1
        for i in range(n - 1, -1, -1):
            digits[i] += carry
            if digits[i] < 10:
                return digits
            else:
                digits[i] = 0
                carry = 1
        digits.insert(0, 1)
        return digits

结果

执行用时 : 13 ms, 击败 72.54% 使用 Python 的用户

内存消耗 : 11.50 MB, 击败 28.43% 使用 Python 的用户

Python3

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        n = len(digits)
        carry = 1
        for i in range(n - 1, -1, -1):
            digits[i] += carry
            if digits[i] < 10:
                return digits
            else:
                digits[i] = 0
                carry = 1
        digits.insert(0, 1)
        return digits

结果

执行用时 : 35 ms, 击败 73.11% 使用 Python3 的用户

内存消耗 : 16.39 MB, 击败 57.88% 使用 Python3 的用户

C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* plusOne(int* digits, int digitsSize, int* returnSize) {
    int carry = 1;
    for (int i = digitsSize - 1; i >= 0; --i) {
        digits[i] += carry;
        if (digits[i] < 10) {
            *returnSize = digitsSize;
            return digits;
        } else {
            digits[i] = 0;
            carry = 1;
        }
    }
    int* result = (int*)malloc((digitsSize + 1) * sizeof(int));
    result[0] = 1;
    for (int i = 1; i <= digitsSize; ++i) {
        result[i] = digits[i - 1];
    }
    *returnSize = digitsSize + 1;
    return result;
}

结果

执行用时 : 0 ms, 击败 100.00% 使用 C 的用户

内存消耗 : 5.45 MB, 击败 95.55% 使用 C 的用户

C#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Solution {
    public int[] PlusOne(int[] digits) {
        int carry = 1;
        for (int i = digits.Length - 1; i >= 0; --i) {
            digits[i] += carry;
            if (digits[i] < 10) {
                return digits;
            } else {
                digits[i] = 0;
                carry = 1;
            }
        }
        int[] result = new int[digits.Length + 1];
        result[0] = 1;
        for (int i = 1; i <= digits.Length; ++i) {
            result[i] = digits[i - 1];
        }
        return result;
    }
}

结果

执行用时 : 80 ms, 击败 99.45% 使用 C# 的用户

内存消耗 : 45.35 MB, 击败 40.55% 使用 C# 的用户

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    let carry = 1;
    for (let i = digits.length - 1; i >= 0; i--) {
        digits[i] += carry;
        if (digits[i] < 10) {
            return digits;
        } else {
            digits[i] = 0;
            carry = 1;
        }
    }
    digits.unshift(1);
    return digits;
};

结果

执行用时 : 54 ms, 击败 78.42% 使用 JavaScript 的用户

内存消耗 : 49.06 MB, 击败 62.42% 使用 JavaScript 的用户

TypeScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function plusOne(digits: number[]): number[] {
    let carry = 1;
    for (let i = digits.length - 1; i >= 0; i--) {
        digits[i] += carry;
        if (digits[i] < 10) {
            return digits;
        } else {
            digits[i] = 0;
            carry = 1;
        }
    }
    digits.unshift(1);
    return digits;
}

结果

执行用时 : 58 ms, 击败 75.94% 使用 TypeScript 的用户

内存消耗 : 51.56 MB, 击败 24.44% 使用 TypeScript 的用户

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {

    /**
     * @param Integer[] $digits
     * @return Integer[]
     */
    function plusOne($digits) {
        $n = count($digits);
        $carry = 1;
        for ($i = $n - 1; $i >= 0; $i--) {
            $digits[$i] += $carry;
            if ($digits[$i] < 10) {
                return $digits;
            } else {
                $digits[$i] = 0;
                $carry = 1;
            }
        }
        array_unshift($digits, 1);
        return $digits;
    }
}

结果

执行用时 : 15 ms, 击败 7.69% 使用 PHP 的用户

内存消耗 : 20.30 MB, 击败 5.77% 使用 PHP 的用户

Swift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    func plusOne(_ digits: [Int]) -> [Int] {
        var digits = digits
        var carry = 1
        for i in (0..<digits.count).reversed() {
            digits[i] += carry
            if digits[i] < 10 {
                return digits
            } else {
                digits[i] = 0
                carry = 1
            }
        }
        digits.insert(1, at: 0)
        return digits
    }
}

结果

执行用时 : 5 ms, 击败 22.06% 使用 Swift 的用户

内存消耗 : 15.71 MB, 击败 50.00% 使用 Swift 的用户

Kotlin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    fun plusOne(digits: IntArray): IntArray {
        var carry = 1
        for (i in digits.size - 1 downTo 0) {
            digits[i] += carry
            if (digits[i] < 10) {
                return digits
            } else {
                digits[i] = 0
                carry = 1
            }
        }
        val result = IntArray(digits.size + 1)
        result[0] = 1
        return result
    }
}

结果

执行用时 : 170 ms, 击败 38.64% 使用 Kotlin 的用户

内存消耗 : 34.26 MB, 击败 65.91% 使用 Kotlin 的用户

Dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
  List<int> plusOne(List<int> digits) {
    int carry = 1;
    for (int i = digits.length - 1; i >= 0; i--) {
      digits[i] += carry;
      if (digits[i] < 10) {
        return digits;
      } else {
        digits[i] = 0;
        carry = 1;
      }
    }
    digits.insert(0, 1);
    return digits;
  }
}

结果

执行用时 : 305 ms, 击败 33.33% 使用 Dart 的用户

内存消耗 : 147.55 MB, 击败 50.00% 使用 Dart 的用户

Go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func plusOne(digits []int) []int {
    carry := 1
    for i := len(digits) - 1; i >= 0; i-- {
        digits[i] += carry
        if digits[i] < 10 {
            return digits
        } else {
            digits[i] = 0
            carry = 1
        }
    }
    digits = append([]int{1}, digits...)
    return digits
}

结果

执行用时 : 0 ms, 击败 100.00% 使用 Go 的用户

内存消耗 : 2.11 MB, 击败 27.11% 使用 Go 的用户

Ruby

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# @param {Integer[]} digits
# @return {Integer[]}
def plus_one(digits)
    carry = 1
    (digits.length - 1).downto(0) do |i|
        digits[i] += carry
        if digits[i] < 10
            return digits
        else
            digits[i] = 0
            carry = 1
        end
    end
    digits.unshift(1)
    return digits
end

结果

执行用时 : 51 ms, 击败 83.33% 使用 Ruby 的用户

内存消耗 : 206.24 MB, 击败 100.00% 使用 Ruby 的用户

Scala

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
object Solution {
  def plusOne(digits: Array[Int]): Array[Int] = {
    var carry = 1
    var i = digits.length - 1
    while (i >= 0) {
      digits(i) += carry
      if (digits(i) < 10) {
        return digits
      } else {
        digits(i) = 0
        carry = 1
      }
      i -= 1
    }
    val result = Array.ofDim[Int](digits.length + 1)
    result(0) = 1
    result
  }
}

结果

执行用时 : 609 ms, 击败 25.00% 使用 Scala 的用户

内存消耗 : 57.99 MB, 击败 -% 使用 Scala 的用户

Rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
impl Solution {
    pub fn plus_one(digits: Vec<i32>) -> Vec<i32> {
        let mut digits = digits;
        let mut carry = 1;
        for i in (0..digits.len()).rev() {
            digits[i] += carry;
            if digits[i] < 10 {
                return digits;
            } else {
                digits[i] = 0;
                carry = 1;
            }
        }
        let mut result = vec![0; digits.len() + 1];
        result[0] = 1;
        result
    }
}

结果

执行用时 : 0 ms, 击败 100.00% 使用 Rust 的用户

内存消耗 : 2.18 MB, 击败 14.57% 使用 Rust 的用户

Racket

1
2
3
4
5
6
7
8
9
10
11
12
13
(define/contract (plus-one digits)
  (-> (listof exact-integer?) (listof exact-integer?))
  (let ((carry 1)
        (result '()))
    (do ((i (- (length digits) 1) (- i 1))) ((< i 0) (reverse result))
      (let ((sum (+ (list-ref digits i) carry)))
        (if (< sum 10)
            (set! carry 0)
            (set! sum (- sum 10)))
        (set! result (cons sum result))))
    (if (= carry 1)
        (cons 1 result)
        result)))

结果

执行用时 : 173 ms, 击败 100.00% 使用 Racket 的用户

内存消耗 : 97.84 MB, 击败 100.00% 使用 Racket 的用户

Erlang

暂时未解决

1

结果

执行用时 : ms, 击败 % 使用 Erlang 的用户

内存消耗 : MB, 击败 % 使用 Erlang 的用户

Elixir

暂时未解决

1

结果

执行用时 : ms, 击败 % 使用 Elixir 的用户

内存消耗 : MB, 击败 % 使用 Elixir 的用户