Skip to content

Commit aa1a162

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.0989,0991 (#4130)
1 parent 5d987ae commit aa1a162

File tree

12 files changed

+183
-236
lines changed

12 files changed

+183
-236
lines changed

‎solution/0900-0999/0989.Add to Array-Form of Integer/README.md

+44-82
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,11 @@ tags:
7171

7272
<!-- solution:start -->
7373

74-
### 方法一
74+
### 方法一：模拟
75+
76+
我们可以从数组的最后一位开始，将数组的每一位与 $k$ 相加，然后将 $k$ 除以 $10$，并将余数作为当前位的值，将商作为进位。一直循环，直到数组遍历完并且 $k = 0$。最后将答案数组反转即可。
77+
78+
时间复杂度 $O(n)$，其中 $n$ 表示 $\textit{num}$ 的长度。忽略答案数组的空间消耗，空间复杂度 $O(1)$。
7579

7680
<!-- tabs:start -->
7781

@@ -80,13 +84,12 @@ tags:
8084
```python
8185
class Solution:
8286
def addToArrayForm(self, num: List[int], k: int) -> List[int]:
83-
i, carry = len(num) - 1, 0
8487
ans = []
85-
while i >= 0 or k or carry:
86-
carry += (0 if i < 0 else num[i]) + (k % 10)
87-
carry, v = divmod(carry, 10)
88-
ans.append(v)
89-
k //= 10
88+
i = len(num) - 1
89+
while i >= 0 or k:
90+
k += 0 if i < 0 else num[i]
91+
k, x = divmod(k, 10)
92+
ans.append(x)
9093
i -= 1
9194
return ans[::-1]
9295
```
@@ -96,14 +99,13 @@ class Solution:
9699
```java
97100
class Solution {
98101
public List<Integer> addToArrayForm(int[] num, int k) {
99-
int i = num.length - 1, carry = 0;
100-
LinkedList<Integer> ans = new LinkedList<>();
101-
while (i >= 0 || k > 0 || carry > 0) {
102-
carry += (i < 0 ? 0 : num[i--]) + k % 10;
103-
ans.addFirst(carry % 10);
104-
carry /= 10;
102+
List<Integer> ans = new ArrayList<>();
103+
for (int i = num.length - 1; i >= 0 || k > 0; --i) {
104+
k += (i >= 0 ? num[i] : 0);
105+
ans.add(k % 10);
105106
k /= 10;
106107
}
108+
Collections.reverse(ans);
107109
return ans;
108110
}
109111
}
@@ -115,15 +117,13 @@ class Solution {
115117
class Solution {
116118
public:
117119
vector<int> addToArrayForm(vector<int>& num, int k) {
118-
int i = num.size() - 1, carry = 0;
119120
vector<int> ans;
120-
for (; i >= 0 || k || carry; --i) {
121-
carry += (i < 0 ? 0 : num[i]) + k % 10;
122-
ans.push_back(carry % 10);
123-
carry /= 10;
121+
for (int i = num.size() - 1; i >= 0 || k > 0; --i) {
122+
k += (i >= 0 ? num[i] : 0);
123+
ans.push_back(k % 10);
124124
k /= 10;
125125
}
126-
reverse(ans.begin(), ans.end());
126+
ranges::reverse(ans);
127127
return ans;
128128
}
129129
};
@@ -132,92 +132,54 @@ public:
132132
#### Go
133133
134134
```go
135-
func addToArrayForm(num []int, k int) []int {
136-
i, carry := len(num)-1, 0
137-
ans := []int{}
138-
for ; i >= 0 || k > 0 || carry > 0; i-- {
135+
func addToArrayForm(num []int, k int) (ans []int) {
136+
for i := len(num) - 1; i >= 0 || k > 0; i-- {
139137
if i >= 0 {
140-
carry += num[i]
138+
k += num[i]
141139
}
142-
carry += k % 10
143-
ans = append(ans, carry%10)
144-
carry /= 10
140+
ans = append(ans, k%10)
145141
k /= 10
146142
}
147-
for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
148-
ans[i], ans[j] = ans[j], ans[i]
149-
}
150-
return ans
143+
slices.Reverse(ans)
144+
return
151145
}
152146
```
153147

154148
#### TypeScript
155149

156150
```ts
157151
function addToArrayForm(num: number[], k: number): number[] {
158-
let arr2 = [...String(k)].map(Number);
159-
let ans = [];
160-
let sum = 0;
161-
while (num.length || arr2.length || sum) {
162-
let a = num.pop() || 0,
163-
b = arr2.pop() || 0;
164-
sum += a + b;
165-
ans.unshift(sum % 10);
166-
sum = Math.floor(sum / 10);
152+
const ans: number[] = [];
153+
for (let i = num.length - 1; i >= 0 || k > 0; --i) {
154+
k += i >= 0 ? num[i] : 0;
155+
ans.push(k % 10);
156+
k = Math.floor(k / 10);
167157
}
168-
return ans;
158+
return ans.reverse();
169159
}
170160
```
171161

172162
#### Rust
173163

174164
```rust
175165
impl Solution {
176-
pub fn add_to_array_form(num: Vec<i32>, mut k: i32) -> Vec<i32> {
177-
let n = num.len();
178-
let mut res = vec![];
179-
let mut i = 0;
180-
let mut sum = 0;
181-
while i < n || sum != 0 || k != 0 {
182-
sum += num.get(n - i - 1).unwrap_or(&0);
183-
sum += k % 10;
184-
res.push(sum % 10);
185-
186-
i += 1;
166+
pub fn add_to_array_form(num: Vec<i32>, k: i32) -> Vec<i32> {
167+
let mut ans = Vec::new();
168+
let mut k = k;
169+
let mut i = num.len() as i32 - 1;
170+
171+
while i >= 0 || k > 0 {
172+
if i >= 0 {
173+
k += num[i as usize];
174+
}
175+
ans.push(k % 10);
187176
k /= 10;
188-
sum /= 10;
177+
i -= 1;
189178
}
190-
res.reverse();
191-
res
192-
}
193-
}
194-
```
195-
196-
<!-- tabs:end -->
197-
198-
<!-- solution:end -->
199179

200-
<!-- solution:start -->
201-
202-
### 方法二
203-
204-
<!-- tabs:start -->
205-
206-
#### TypeScript
207-
208-
```ts
209-
function addToArrayForm(num: number[], k: number): number[] {
210-
const n = num.length;
211-
const res = [];
212-
let sum = 0;
213-
for (let i = 0; i < n || sum !== 0 || k !== 0; i++) {
214-
sum += num[n - i - 1] ?? 0;
215-
sum += k % 10;
216-
res.push(sum % 10);
217-
k = Math.floor(k / 10);
218-
sum = Math.floor(sum / 10);
180+
ans.reverse();
181+
ans
219182
}
220-
return res.reverse();
221183
}
222184
```
223185

‎solution/0900-0999/0989.Add to Array-Form of Integer/README_EN.md

+44-82
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,11 @@ tags:
6666

6767
<!-- solution:start -->
6868

69-
### Solution 1
69+
### Solution 1: Simulation
70+
71+
We can start from the last digit of the array and add each digit of the array to $k$. Then, divide $k$ by $10$, and use the remainder as the current digit's value, with the quotient as the carry. Continue this process until the array is fully traversed and $k = 0$. Finally, reverse the answer array.
72+
73+
The time complexity is $O(n)$, where $n$ is the length of $\textit{num}$. Ignoring the space consumption of the answer array, the space complexity is $O(1)$.
7074

7175
<!-- tabs:start -->
7276

@@ -75,13 +79,12 @@ tags:
7579
```python
7680
class Solution:
7781
def addToArrayForm(self, num: List[int], k: int) -> List[int]:
78-
i, carry = len(num) - 1, 0
7982
ans = []
80-
while i >= 0 or k or carry:
81-
carry += (0 if i < 0 else num[i]) + (k % 10)
82-
carry, v = divmod(carry, 10)
83-
ans.append(v)
84-
k //= 10
83+
i = len(num) - 1
84+
while i >= 0 or k:
85+
k += 0 if i < 0 else num[i]
86+
k, x = divmod(k, 10)
87+
ans.append(x)
8588
i -= 1
8689
return ans[::-1]
8790
```
@@ -91,14 +94,13 @@ class Solution:
9194
```java
9295
class Solution {
9396
public List<Integer> addToArrayForm(int[] num, int k) {
94-
int i = num.length - 1, carry = 0;
95-
LinkedList<Integer> ans = new LinkedList<>();
96-
while (i >= 0 || k > 0 || carry > 0) {
97-
carry += (i < 0 ? 0 : num[i--]) + k % 10;
98-
ans.addFirst(carry % 10);
99-
carry /= 10;
97+
List<Integer> ans = new ArrayList<>();
98+
for (int i = num.length - 1; i >= 0 || k > 0; --i) {
99+
k += (i >= 0 ? num[i] : 0);
100+
ans.add(k % 10);
100101
k /= 10;
101102
}
103+
Collections.reverse(ans);
102104
return ans;
103105
}
104106
}
@@ -110,15 +112,13 @@ class Solution {
110112
class Solution {
111113
public:
112114
vector<int> addToArrayForm(vector<int>& num, int k) {
113-
int i = num.size() - 1, carry = 0;
114115
vector<int> ans;
115-
for (; i >= 0 || k || carry; --i) {
116-
carry += (i < 0 ? 0 : num[i]) + k % 10;
117-
ans.push_back(carry % 10);
118-
carry /= 10;
116+
for (int i = num.size() - 1; i >= 0 || k > 0; --i) {
117+
k += (i >= 0 ? num[i] : 0);
118+
ans.push_back(k % 10);
119119
k /= 10;
120120
}
121-
reverse(ans.begin(), ans.end());
121+
ranges::reverse(ans);
122122
return ans;
123123
}
124124
};
@@ -127,92 +127,54 @@ public:
127127
#### Go
128128
129129
```go
130-
func addToArrayForm(num []int, k int) []int {
131-
i, carry := len(num)-1, 0
132-
ans := []int{}
133-
for ; i >= 0 || k > 0 || carry > 0; i-- {
130+
func addToArrayForm(num []int, k int) (ans []int) {
131+
for i := len(num) - 1; i >= 0 || k > 0; i-- {
134132
if i >= 0 {
135-
carry += num[i]
133+
k += num[i]
136134
}
137-
carry += k % 10
138-
ans = append(ans, carry%10)
139-
carry /= 10
135+
ans = append(ans, k%10)
140136
k /= 10
141137
}
142-
for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
143-
ans[i], ans[j] = ans[j], ans[i]
144-
}
145-
return ans
138+
slices.Reverse(ans)
139+
return
146140
}
147141
```
148142

149143
#### TypeScript
150144

151145
```ts
152146
function addToArrayForm(num: number[], k: number): number[] {
153-
let arr2 = [...String(k)].map(Number);
154-
let ans = [];
155-
let sum = 0;
156-
while (num.length || arr2.length || sum) {
157-
let a = num.pop() || 0,
158-
b = arr2.pop() || 0;
159-
sum += a + b;
160-
ans.unshift(sum % 10);
161-
sum = Math.floor(sum / 10);
147+
const ans: number[] = [];
148+
for (let i = num.length - 1; i >= 0 || k > 0; --i) {
149+
k += i >= 0 ? num[i] : 0;
150+
ans.push(k % 10);
151+
k = Math.floor(k / 10);
162152
}
163-
return ans;
153+
return ans.reverse();
164154
}
165155
```
166156

167157
#### Rust
168158

169159
```rust
170160
impl Solution {
171-
pub fn add_to_array_form(num: Vec<i32>, mut k: i32) -> Vec<i32> {
172-
let n = num.len();
173-
let mut res = vec![];
174-
let mut i = 0;
175-
let mut sum = 0;
176-
while i < n || sum != 0 || k != 0 {
177-
sum += num.get(n - i - 1).unwrap_or(&0);
178-
sum += k % 10;
179-
res.push(sum % 10);
180-
181-
i += 1;
161+
pub fn add_to_array_form(num: Vec<i32>, k: i32) -> Vec<i32> {
162+
let mut ans = Vec::new();
163+
let mut k = k;
164+
let mut i = num.len() as i32 - 1;
165+
166+
while i >= 0 || k > 0 {
167+
if i >= 0 {
168+
k += num[i as usize];
169+
}
170+
ans.push(k % 10);
182171
k /= 10;
183-
sum /= 10;
172+
i -= 1;
184173
}
185-
res.reverse();
186-
res
187-
}
188-
}
189-
```
190-
191-
<!-- tabs:end -->
192-
193-
<!-- solution:end -->
194174

195-
<!-- solution:start -->
196-
197-
### Solution 2
198-
199-
<!-- tabs:start -->
200-
201-
#### TypeScript
202-
203-
```ts
204-
function addToArrayForm(num: number[], k: number): number[] {
205-
const n = num.length;
206-
const res = [];
207-
let sum = 0;
208-
for (let i = 0; i < n || sum !== 0 || k !== 0; i++) {
209-
sum += num[n - i - 1] ?? 0;
210-
sum += k % 10;
211-
res.push(sum % 10);
212-
k = Math.floor(k / 10);
213-
sum = Math.floor(sum / 10);
175+
ans.reverse();
176+
ans
214177
}
215-
return res.reverse();
216178
}
217179
```
218180

0 commit comments

Comments
 (0)