Skip to content

Commit 387b96a

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.2181
No.2181.Merge Nodes in Between Zeros
1 parent 8d1c046 commit 387b96a

File tree

5 files changed

+268
-80
lines changed

5 files changed

+268
-80
lines changed

‎solution/2100-2199/2181.Merge Nodes in Between Zeros/README.md

+101-35
Original file line numberDiff line numberDiff line change
@@ -116,41 +116,6 @@ class Solution {
116116
}
117117
```
118118

119-
### **TypeScript**
120-
121-
```ts
122-
/**
123-
* Definition for singly-linked list.
124-
* class ListNode {
125-
* val: number
126-
* next: ListNode | null
127-
* constructor(val?: number, next?: ListNode | null) {
128-
* this.val = (val===undefined ? 0 : val)
129-
* this.next = (next===undefined ? null : next)
130-
* }
131-
* }
132-
*/
133-
134-
function mergeNodes(head: ListNode | null): ListNode | null {
135-
let dummy = new ListNode(-1);
136-
let p = dummy;
137-
let sum = 0;
138-
head = head.next;
139-
while (head != null) {
140-
let cur = head.val;
141-
if (cur) {
142-
sum += cur;
143-
} else {
144-
p.next = new ListNode(sum);
145-
p = p.next;
146-
sum = 0;
147-
}
148-
head = head.next;
149-
}
150-
return dummy.next;
151-
}
152-
```
153-
154119
### **C++**
155120

156121
```cpp
@@ -211,6 +176,107 @@ func mergeNodes(head *ListNode) *ListNode {
211176
}
212177
```
213178

179+
### **TypeScript**
180+
181+
```ts
182+
/**
183+
* Definition for singly-linked list.
184+
* class ListNode {
185+
* val: number
186+
* next: ListNode | null
187+
* constructor(val?: number, next?: ListNode | null) {
188+
* this.val = (val===undefined ? 0 : val)
189+
* this.next = (next===undefined ? null : next)
190+
* }
191+
* }
192+
*/
193+
194+
function mergeNodes(head: ListNode | null): ListNode | null {
195+
const dummy = new ListNode();
196+
let cur = dummy;
197+
let sum = 0;
198+
while (head) {
199+
if (head.val === 0 && sum !== 0) {
200+
cur.next = new ListNode(sum);
201+
cur = cur.next;
202+
sum = 0;
203+
}
204+
sum += head.val;
205+
head = head.next;
206+
}
207+
return dummy.next;
208+
}
209+
```
210+
211+
### **Rust**
212+
213+
```rust
214+
// Definition for singly-linked list.
215+
// #[derive(PartialEq, Eq, Clone, Debug)]
216+
// pub struct ListNode {
217+
// pub val: i32,
218+
// pub next: Option<Box<ListNode>>
219+
// }
220+
//
221+
// impl ListNode {
222+
// #[inline]
223+
// fn new(val: i32) -> Self {
224+
// ListNode {
225+
// next: None,
226+
// val
227+
// }
228+
// }
229+
// }
230+
impl Solution {
231+
pub fn merge_nodes(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
232+
let mut dummy = Box::new(ListNode::new(-1));
233+
let mut cur = &mut dummy;
234+
let mut sum = 0;
235+
while let Some(node) = head {
236+
if node.val == 0 && sum != 0 {
237+
cur.next = Some(Box::new(ListNode::new(sum)));
238+
cur = cur.as_mut().next.as_mut().unwrap();
239+
sum = 0;
240+
}
241+
sum += node.val;
242+
head = node.next;
243+
}
244+
dummy.next.take()
245+
}
246+
}
247+
```
248+
249+
### **C**
250+
251+
```c
252+
/**
253+
* Definition for singly-linked list.
254+
* struct ListNode {
255+
* int val;
256+
* struct ListNode *next;
257+
* };
258+
*/
259+
260+
261+
struct ListNode *mergeNodes(struct ListNode *head) {
262+
struct ListNode dummy;
263+
struct ListNode *cur = &dummy;
264+
int sum = 0;
265+
while (head) {
266+
if (head->val == 0 && sum != 0) {
267+
cur->next = malloc(sizeof(struct ListNode));
268+
cur->next->val = sum;
269+
cur->next->next = NULL;
270+
cur = cur->next;
271+
sum = 0;
272+
}
273+
sum += head->val;
274+
head = head->next;
275+
}
276+
return dummy.next;
277+
}
278+
```
279+
214280
### **...**
215281
216282
```

‎solution/2100-2199/2181.Merge Nodes in Between Zeros/README_EN.md

+101-35
Original file line numberDiff line numberDiff line change
@@ -104,41 +104,6 @@ class Solution {
104104
}
105105
```
106106

107-
### **TypeScript**
108-
109-
```ts
110-
/**
111-
* Definition for singly-linked list.
112-
* class ListNode {
113-
* val: number
114-
* next: ListNode | null
115-
* constructor(val?: number, next?: ListNode | null) {
116-
* this.val = (val===undefined ? 0 : val)
117-
* this.next = (next===undefined ? null : next)
118-
* }
119-
* }
120-
*/
121-
122-
function mergeNodes(head: ListNode | null): ListNode | null {
123-
let dummy = new ListNode(-1);
124-
let p = dummy;
125-
let sum = 0;
126-
head = head.next;
127-
while (head != null) {
128-
let cur = head.val;
129-
if (cur) {
130-
sum += cur;
131-
} else {
132-
p.next = new ListNode(sum);
133-
p = p.next;
134-
sum = 0;
135-
}
136-
head = head.next;
137-
}
138-
return dummy.next;
139-
}
140-
```
141-
142107
### **C++**
143108

144109
```cpp
@@ -199,6 +164,107 @@ func mergeNodes(head *ListNode) *ListNode {
199164
}
200165
```
201166

167+
### **TypeScript**
168+
169+
```ts
170+
/**
171+
* Definition for singly-linked list.
172+
* class ListNode {
173+
* val: number
174+
* next: ListNode | null
175+
* constructor(val?: number, next?: ListNode | null) {
176+
* this.val = (val===undefined ? 0 : val)
177+
* this.next = (next===undefined ? null : next)
178+
* }
179+
* }
180+
*/
181+
182+
function mergeNodes(head: ListNode | null): ListNode | null {
183+
const dummy = new ListNode();
184+
let cur = dummy;
185+
let sum = 0;
186+
while (head) {
187+
if (head.val === 0 && sum !== 0) {
188+
cur.next = new ListNode(sum);
189+
cur = cur.next;
190+
sum = 0;
191+
}
192+
sum += head.val;
193+
head = head.next;
194+
}
195+
return dummy.next;
196+
}
197+
```
198+
199+
### **Rust**
200+
201+
```rust
202+
// Definition for singly-linked list.
203+
// #[derive(PartialEq, Eq, Clone, Debug)]
204+
// pub struct ListNode {
205+
// pub val: i32,
206+
// pub next: Option<Box<ListNode>>
207+
// }
208+
//
209+
// impl ListNode {
210+
// #[inline]
211+
// fn new(val: i32) -> Self {
212+
// ListNode {
213+
// next: None,
214+
// val
215+
// }
216+
// }
217+
// }
218+
impl Solution {
219+
pub fn merge_nodes(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
220+
let mut dummy = Box::new(ListNode::new(-1));
221+
let mut cur = &mut dummy;
222+
let mut sum = 0;
223+
while let Some(node) = head {
224+
if node.val == 0 && sum != 0 {
225+
cur.next = Some(Box::new(ListNode::new(sum)));
226+
cur = cur.as_mut().next.as_mut().unwrap();
227+
sum = 0;
228+
}
229+
sum += node.val;
230+
head = node.next;
231+
}
232+
dummy.next.take()
233+
}
234+
}
235+
```
236+
237+
### **C**
238+
239+
```c
240+
/**
241+
* Definition for singly-linked list.
242+
* struct ListNode {
243+
* int val;
244+
* struct ListNode *next;
245+
* };
246+
*/
247+
248+
249+
struct ListNode *mergeNodes(struct ListNode *head) {
250+
struct ListNode dummy;
251+
struct ListNode *cur = &dummy;
252+
int sum = 0;
253+
while (head) {
254+
if (head->val == 0 && sum != 0) {
255+
cur->next = malloc(sizeof(struct ListNode));
256+
cur->next->val = sum;
257+
cur->next->next = NULL;
258+
cur = cur->next;
259+
sum = 0;
260+
}
261+
sum += head->val;
262+
head = head->next;
263+
}
264+
return dummy.next;
265+
}
266+
```
267+
202268
### **...**
203269
204270
```

‎solution/2100-2199/2181.Merge Nodes in Between Zeros/Solution.c

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* struct ListNode *next;
6+
* };
7+
*/
8+
9+
10+
struct ListNode *mergeNodes(struct ListNode *head) {
11+
struct ListNode dummy;
12+
struct ListNode *cur = &dummy;
13+
int sum = 0;
14+
while (head) {
15+
if (head->val == 0 && sum != 0) {
16+
cur->next = malloc(sizeof(struct ListNode));
17+
cur->next->val = sum;
18+
cur->next->next = NULL;
19+
cur = cur->next;
20+
sum = 0;
21+
}
22+
sum += head->val;
23+
head = head->next;
24+
}
25+
return dummy.next;
26+
}

‎solution/2100-2199/2181.Merge Nodes in Between Zeros/Solution.rs

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
// Definition for singly-linked list.
2+
// #[derive(PartialEq, Eq, Clone, Debug)]
3+
// pub struct ListNode {
4+
// pub val: i32,
5+
// pub next: Option<Box<ListNode>>
6+
// }
7+
//
8+
// impl ListNode {
9+
// #[inline]
10+
// fn new(val: i32) -> Self {
11+
// ListNode {
12+
// next: None,
13+
// val
14+
// }
15+
// }
16+
// }
17+
impl Solution {
18+
pub fn merge_nodes(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
19+
let mut dummy = Box::new(ListNode::new(-1));
20+
let mut cur = &mut dummy;
21+
let mut sum = 0;
22+
while let Some(node) = head {
23+
if node.val == 0 && sum != 0 {
24+
cur.next = Some(Box::new(ListNode::new(sum)));
25+
cur = cur.as_mut().next.as_mut().unwrap();
26+
sum = 0;
27+
}
28+
sum += node.val;
29+
head = node.next;
30+
}
31+
dummy.next.take()
32+
}
33+
}

‎solution/2100-2199/2181.Merge Nodes in Between Zeros/Solution.ts

+7-10
Original file line numberDiff line numberDiff line change
@@ -11,19 +11,16 @@
1111
*/
1212

1313
function mergeNodes(head: ListNode | null): ListNode | null {
14-
let dummy = new ListNode(-1);
15-
let p = dummy;
14+
const dummy = new ListNode();
15+
let cur = dummy;
1616
let sum = 0;
17-
head = head.next;
18-
while (head != null) {
19-
let cur = head.val;
20-
if (cur) {
21-
sum += cur;
22-
} else {
23-
p.next = new ListNode(sum);
24-
p = p.next;
17+
while (head) {
18+
if (head.val === 0 && sum !== 0) {
19+
cur.next = new ListNode(sum);
20+
cur = cur.next;
2521
sum = 0;
2622
}
23+
sum += head.val;
2724
head = head.next;
2825
}
2926
return dummy.next;

0 commit comments

Comments
 (0)