Location>code7788 >text

66th question - add one

Popularity：60 ℃/2025-03-05 22:31:00

1. Positively deduct question 66: Add one

1.1 Question description

Given a non-negative integer represented by a non-empty array composed of integers, add one on the basis of that number.

 The highest digit is stored at the first digit of the array, and each element in the array stores only a single digit.

 You can assume that this integer does not start with zero except for the integer 0.

 

 Example 1:

 Input: digits = [1,2,3]
 Output: [1,2,4]
 Explanation: The input array represents the number 123.
 Example 2:

 Input: digits = [4,3,2,1]
 Output: [4,3,2,2]
 Explanation: The input array represents the number 4321.
 Example 3:

 Enter: digits = [9]
 Output: [1,0]
 Explanation: The input array represents the number 9.
 Adding 1 gives 9 + 1 = 10.
 Therefore, the result should be [1,0].
 

 hint:

 1 <= <= 100
 0 <= digits[i] <= 9

1.2 Question analysis

First of all, the description of the question is relatively simple, which is to use an array to represent non-negative integers. For example, [1, 2, 3] represents integer 123, and [0] represents integer 0,.

Then the question gives us an array. We need to calculate the integer represented by this array and add one, then represent it as an array, and finally get the result array and return it back.

This problem is actually relatively simple. In Python, we have two solutions: the first solution is to use the mutual conversion between integers and strings; the second method is to obtain the required value in the end, let's take a look at it one by one.

1.3 Problem solving methods and codes

1.3.1 Methods of converting strings and integers into each other - Time complexity O(N)

  1. Code ideas
    We first convert each integer in the original list into a string, then splice them all together, then convert the integer to an integer, add one, and then convert the integer with one added into a string, divide the string into a character list, and finally convert each element of the character list into an integer and then return, pay attention to dealing with the situation where the first bit is equal to 0.
  2. Code implementation
class Solution:
     def plusOne(self, digits: List[int]) -> List[int]:
         # Use strings and integers to convert each other
         string_list = ''.join([str(item) for item in digits])
         if string_list[0] == '0':
             Return [1]
         else:
             number = int(string_list)
             number += 1
             string = str(number)
             number_lst = [int(item) for item in string]
             return number_lst

1.3.2 Mathematical calculations - Time complexity O(N)

  1. Code ideas
    First, we need to calculate the number represented by the list based on the original list, so we can use a formula:
    ∑(digits[i] * (10 ^ length - i - 1))
    iniIndicates the offset of the array, from0arrivelen(digits)-1, where ^ represents the meaning of multiplication, such as2 ^ 3 = 8
    If you don’t understand the above formula, you can draw a picture by yourself and take it in one by one. The final result is the number represented by this array.
    After converting it into a number, just represent the number as an array. The conversion method is also a very common algorithm. It is mentioned at the end of the article, you must see the end!

  2. Code implementation
    Directly upload the code:

class Solution:
     def plusOne(self, digits: List[int]) -> List[int]:
         # calculate
         if digits[0] == 0:
             Return [1]
         if digits[-1] != 9:
             digits[-1] = digits[-1] + 1
             Return digits
         number_origin = 0

         # Calculate the data stored in the array to obtain integers
         for i in range(len(digits)-1, -1, -1):
             number_origin += digits[i] * (10 ** (len(digits) - i - 1))
         # Add one integer to the number related to the list that needs to be returned
         number_origin += 1
         return_list = []
         while number_origin > 0:
             n = number_origin // 10 # rounding
             return_list.append(number_origin % 10)
             number_origin = n
         return return_list[::-1]

2. Supplementary:

The following algorithm can print 123 in a 3 2 1 way! Note that printing out is in reverse order. After we store these data into the array in turn, we also have inverse order. We need to reorder the reverse order again!

## Print the number of single digits, ten digits, and hundreds digits in turn...
 number = 123
 while number > 0:
	 n = number // 10
	 print(number % 10)
	 number = n
## Inversely order a list
 ## In python it is easy to reverse order a list: reverse_list = a_list[::-1]

 # Use code to reverse the list
 a_list = [1,2,3,4,6,5]
 n = len(a_list)
 for i in range(n // 2):
	 a_list[i], a_list[n - i - 1] = a_list[n - i - 1], a_list[i]
 print(a_list)

3. Summary

The questions here can be solved by converting strings and integers into each other. This method is easy to understand and practice. However, students with conditions still recommend using mathematical calculation methods. First, to cultivate their own mathematical and computer thinking, and second, to be familiar with the programming language used. Okay, that’s all today. I wish you all a lot of wealth and weight loss, and a blessing!

<Previous Next>