Skip to content

Commit f76309e

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1441 (#4268)
No.1441.Build an Array With Stack Operations
1 parent f563c72 commit f76309e

File tree

9 files changed

+182
-157
lines changed

9 files changed

+182
-157
lines changed

‎solution/1400-1499/1441.Build an Array With Stack Operations/README.md

+61-54
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ tags:
4141
<pre>
4242
<strong>输入：</strong>target = [1,3], n = 3
4343
<strong>输出：</strong>["Push","Push","Pop","Push"]
44-
<strong>解释：
44+
<strong>解释：
4545
</strong>读取 1 并自动推入数组 -&gt; [1]
4646
读取 2 并自动推入数组，然后删除它 -&gt; [1]
4747
读取 3 并自动推入数组 -&gt; [1,3]
@@ -81,13 +81,17 @@ tags:
8181

8282
### 方法一：模拟
8383

84-
我们定义 $cur$ 表示当前已经从 `list` 中读取到的数字，初始时 $cur = 0$，用一个数组 $ans$ 存储答案。
84+
我们定义一个变量 $\textit{cur}$ 表示当前待读取的数字，初始时 $\textit{cur} = 1$，用一个数组 $\textit{ans}$ 存储答案。
8585

86-
遍历数组 `target`，对于每个数字 $v$，如果当前要从 `list` 读取的数字小于 $v$，那么我们应该执行 `Push` 和 `Pop` 操作，直到读取的数字等于 $v$，然后执行 `Push` 操作，这样就可以得到数字 $v$。
86+
接下来，我们遍历数组 $\textit{target}$ 中的每个数字 $x$：
8787

88-
遍历结束后，也就构建出了数组 `target`，返回 `ans` 即可。
88+
- 如果 $\textit{cur} < x$，我们将 $\textit{Push}$ 和 $\textit{Pop}$ 依次加入答案，直到 $\textit{cur} = x$；
89+
- 然后我们将 $\textit{Push}$ 加入答案，表示读取数字 $x$；
90+
- 接着，我们将 $\textit{cur}$ 加一，继续处理下一个数字。
8991

90-
时间复杂度 $O(n)$，其中 $n$ 为数组 `target` 的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
92+
遍历结束后，返回答案数组即可。
93+
94+
时间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{target}$ 的长度。忽略答案数组的空间消耗，空间复杂度 $O(1)$。
9195

9296
<!-- tabs:start -->
9397

@@ -96,13 +100,14 @@ tags:
96100
```python
97101
class Solution:
98102
def buildArray(self, target: List[int], n: int) -> List[str]:
99-
cur, ans = 0, []
100-
for v in target:
101-
cur += 1
102-
while cur < v:
103-
ans.extend(['Push', 'Pop'])
103+
ans = []
104+
cur = 1
105+
for x in target:
106+
while cur < x:
107+
ans.extend(["Push", "Pop"])
104108
cur += 1
105-
ans.append('Push')
109+
ans.append("Push")
110+
cur += 1
106111
return ans
107112
```
108113

@@ -111,14 +116,15 @@ class Solution:
111116
```java
112117
class Solution {
113118
public List<String> buildArray(int[] target, int n) {
114-
int cur = 0;
115119
List<String> ans = new ArrayList<>();
116-
for (int v : target) {
117-
while (++cur < v) {
118-
ans.add("Push");
119-
ans.add("Pop");
120+
int cur = 1;
121+
for (int x : target) {
122+
while (cur < x) {
123+
ans.addAll(List.of("Push", "Pop"));
124+
++cur;
120125
}
121126
ans.add("Push");
127+
++cur;
122128
}
123129
return ans;
124130
}
@@ -131,14 +137,16 @@ class Solution {
131137
class Solution {
132138
public:
133139
vector<string> buildArray(vector<int>& target, int n) {
134-
int cur = 0;
135140
vector<string> ans;
136-
for (int& v : target) {
137-
while (++cur < v) {
138-
ans.emplace_back("Push");
139-
ans.emplace_back("Pop");
141+
int cur = 1;
142+
for (int x : target) {
143+
while (cur < x) {
144+
ans.push_back("Push");
145+
ans.push_back("Pop");
146+
++cur;
140147
}
141-
ans.emplace_back("Push");
148+
ans.push_back("Push");
149+
++cur;
142150
}
143151
return ans;
144152
}
@@ -148,32 +156,33 @@ public:
148156
#### Go
149157
150158
```go
151-
func buildArray(target []int, n int) []string {
152-
cur := 0
153-
ans := []string{}
154-
for _, v := range target {
155-
for cur = cur + 1; cur < v; cur++ {
159+
func buildArray(target []int, n int) (ans []string) {
160+
cur := 1
161+
for _, x := range target {
162+
for ; cur < x; cur++ {
156163
ans = append(ans, "Push", "Pop")
157164
}
158165
ans = append(ans, "Push")
166+
cur++
159167
}
160-
return ans
168+
return
161169
}
162170
```
163171

164172
#### TypeScript
165173

166174
```ts
167175
function buildArray(target: number[], n: number): string[] {
168-
const res = [];
169-
let cur = 0;
170-
for (const num of target) {
171-
while (++cur < num) {
172-
res.push('Push', 'Pop');
176+
const ans: string[] = [];
177+
let cur: number = 1;
178+
for (const x of target) {
179+
for (; cur < x; ++cur) {
180+
ans.push('Push', 'Pop');
173181
}
174-
res.push('Push');
182+
ans.push('Push');
183+
++cur;
175184
}
176-
return res;
185+
return ans;
177186
}
178187
```
179188

@@ -182,18 +191,18 @@ function buildArray(target: number[], n: number): string[] {
182191
```rust
183192
impl Solution {
184193
pub fn build_array(target: Vec<i32>, n: i32) -> Vec<String> {
185-
let mut res = Vec::new();
194+
let mut ans = Vec::new();
186195
let mut cur = 1;
187-
for &num in target.iter() {
188-
while cur < num {
189-
res.push("Push");
190-
res.push("Pop");
196+
for &x in &target {
197+
while cur < x {
198+
ans.push("Push".to_string());
199+
ans.push("Pop".to_string());
191200
cur += 1;
192201
}
193-
res.push("Push");
202+
ans.push("Push".to_string());
194203
cur += 1;
195204
}
196-
res.into_iter().map(String::from).collect()
205+
ans
197206
}
198207
}
199208
```
@@ -205,21 +214,19 @@ impl Solution {
205214
* Note: The returned array must be malloced, assume caller calls free().
206215
*/
207216
char** buildArray(int* target, int targetSize, int n, int* returnSize) {
208-
char** res = (char**) malloc(sizeof(char*) * n * 2);
217+
char** ans = (char**) malloc(sizeof(char*) * (2 * n));
218+
*returnSize = 0;
209219
int cur = 1;
210-
int i = 0;
211-
for (int j = 0; j < targetSize; j++) {
212-
while (++cur < target[j]) {
213-
res[i] = (char*) malloc(sizeof(char) * 8);
214-
strcpy(res[i++], "Push");
215-
res[i] = (char*) malloc(sizeof(char) * 8);
216-
strcpy(res[i++], "Pop");
220+
for (int i = 0; i < targetSize; i++) {
221+
while (cur < target[i]) {
222+
ans[(*returnSize)++] = "Push";
223+
ans[(*returnSize)++] = "Pop";
224+
cur++;
217225
}
218-
res[i] = (char*) malloc(sizeof(char) * 8);
219-
strcpy(res[i++], "Push");
226+
ans[(*returnSize)++] = "Push";
227+
cur++;
220228
}
221-
*returnSize = i;
222-
return res;
229+
return ans;
223230
}
224231
```
225232

‎solution/1400-1499/1441.Build an Array With Stack Operations/README_EN.md

+65-50
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,19 @@ The answers that read integer 3 from the stream are not accepted.
9393

9494
<!-- solution:start -->
9595

96-
### Solution 1
96+
### Solution 1: Simulation
97+
98+
We define a variable $\textit{cur}$ to represent the current number to be read, initially set to $\textit{cur} = 1$, and use an array $\textit{ans}$ to store the answer.
99+
100+
Next, we iterate through each number $x$ in the array $\textit{target}$:
101+
102+
- If $\textit{cur} < x$, we add $\textit{Push}$ and $\textit{Pop}$ to the answer alternately until $\textit{cur} = x$;
103+
- Then we add $\textit{Push}$ to the answer, representing reading the number $x$;
104+
- After that, we increment $\textit{cur}$ and continue to process the next number.
105+
106+
After the iteration, we return the answer array.
107+
108+
The time complexity is $O(n)$, where $n$ is the length of the array $\textit{target}$. Ignoring the space consumption of the answer array, the space complexity is $O(1)$.
97109

98110
<!-- tabs:start -->
99111

@@ -102,13 +114,14 @@ The answers that read integer 3 from the stream are not accepted.
102114
```python
103115
class Solution:
104116
def buildArray(self, target: List[int], n: int) -> List[str]:
105-
cur, ans = 0, []
106-
for v in target:
107-
cur += 1
108-
while cur < v:
109-
ans.extend(['Push', 'Pop'])
117+
ans = []
118+
cur = 1
119+
for x in target:
120+
while cur < x:
121+
ans.extend(["Push", "Pop"])
110122
cur += 1
111-
ans.append('Push')
123+
ans.append("Push")
124+
cur += 1
112125
return ans
113126
```
114127

@@ -117,14 +130,15 @@ class Solution:
117130
```java
118131
class Solution {
119132
public List<String> buildArray(int[] target, int n) {
120-
int cur = 0;
121133
List<String> ans = new ArrayList<>();
122-
for (int v : target) {
123-
while (++cur < v) {
124-
ans.add("Push");
125-
ans.add("Pop");
134+
int cur = 1;
135+
for (int x : target) {
136+
while (cur < x) {
137+
ans.addAll(List.of("Push", "Pop"));
138+
++cur;
126139
}
127140
ans.add("Push");
141+
++cur;
128142
}
129143
return ans;
130144
}
@@ -137,14 +151,16 @@ class Solution {
137151
class Solution {
138152
public:
139153
vector<string> buildArray(vector<int>& target, int n) {
140-
int cur = 0;
141154
vector<string> ans;
142-
for (int& v : target) {
143-
while (++cur < v) {
144-
ans.emplace_back("Push");
145-
ans.emplace_back("Pop");
155+
int cur = 1;
156+
for (int x : target) {
157+
while (cur < x) {
158+
ans.push_back("Push");
159+
ans.push_back("Pop");
160+
++cur;
146161
}
147-
ans.emplace_back("Push");
162+
ans.push_back("Push");
163+
++cur;
148164
}
149165
return ans;
150166
}
@@ -154,32 +170,33 @@ public:
154170
#### Go
155171
156172
```go
157-
func buildArray(target []int, n int) []string {
158-
cur := 0
159-
ans := []string{}
160-
for _, v := range target {
161-
for cur = cur + 1; cur < v; cur++ {
173+
func buildArray(target []int, n int) (ans []string) {
174+
cur := 1
175+
for _, x := range target {
176+
for ; cur < x; cur++ {
162177
ans = append(ans, "Push", "Pop")
163178
}
164179
ans = append(ans, "Push")
180+
cur++
165181
}
166-
return ans
182+
return
167183
}
168184
```
169185

170186
#### TypeScript
171187

172188
```ts
173189
function buildArray(target: number[], n: number): string[] {
174-
const res = [];
175-
let cur = 0;
176-
for (const num of target) {
177-
while (++cur < num) {
178-
res.push('Push', 'Pop');
190+
const ans: string[] = [];
191+
let cur: number = 1;
192+
for (const x of target) {
193+
for (; cur < x; ++cur) {
194+
ans.push('Push', 'Pop');
179195
}
180-
res.push('Push');
196+
ans.push('Push');
197+
++cur;
181198
}
182-
return res;
199+
return ans;
183200
}
184201
```
185202

@@ -188,18 +205,18 @@ function buildArray(target: number[], n: number): string[] {
188205
```rust
189206
impl Solution {
190207
pub fn build_array(target: Vec<i32>, n: i32) -> Vec<String> {
191-
let mut res = Vec::new();
208+
let mut ans = Vec::new();
192209
let mut cur = 1;
193-
for &num in target.iter() {
194-
while cur < num {
195-
res.push("Push");
196-
res.push("Pop");
210+
for &x in &target {
211+
while cur < x {
212+
ans.push("Push".to_string());
213+
ans.push("Pop".to_string());
197214
cur += 1;
198215
}
199-
res.push("Push");
216+
ans.push("Push".to_string());
200217
cur += 1;
201218
}
202-
res.into_iter().map(String::from).collect()
219+
ans
203220
}
204221
}
205222
```
@@ -211,21 +228,19 @@ impl Solution {
211228
* Note: The returned array must be malloced, assume caller calls free().
212229
*/
213230
char** buildArray(int* target, int targetSize, int n, int* returnSize) {
214-
char** res = (char**) malloc(sizeof(char*) * n * 2);
231+
char** ans = (char**) malloc(sizeof(char*) * (2 * n));
232+
*returnSize = 0;
215233
int cur = 1;
216-
int i = 0;
217-
for (int j = 0; j < targetSize; j++) {
218-
while (++cur < target[j]) {
219-
res[i] = (char*) malloc(sizeof(char) * 8);
220-
strcpy(res[i++], "Push");
221-
res[i] = (char*) malloc(sizeof(char) * 8);
222-
strcpy(res[i++], "Pop");
234+
for (int i = 0; i < targetSize; i++) {
235+
while (cur < target[i]) {
236+
ans[(*returnSize)++] = "Push";
237+
ans[(*returnSize)++] = "Pop";
238+
cur++;
223239
}
224-
res[i] = (char*) malloc(sizeof(char) * 8);
225-
strcpy(res[i++], "Push");
240+
ans[(*returnSize)++] = "Push";
241+
cur++;
226242
}
227-
*returnSize = i;
228-
return res;
243+
return ans;
229244
}
230245
```
231246

0 commit comments

Comments
 (0)