Skip to content

Commit 5d0a56f

Browse files
YangFongYangFong
committed
feat: add solutions to lcci problem: No.02.05
No.02.05.Sum Lists
1 parent 383f9dc commit 5d0a56f

File tree

4 files changed

+259
-0
lines changed

4 files changed

+259
-0
lines changed

‎lcci/02.05.Sum Lists/README.md

+90
Original file line numberDiff line numberDiff line change
@@ -185,6 +185,96 @@ func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
185185
}
186186
```
187187

188+
### **TypeScript**
189+
190+
```ts
191+
/**
192+
* Definition for singly-linked list.
193+
* class ListNode {
194+
* val: number
195+
* next: ListNode | null
196+
* constructor(val?: number, next?: ListNode | null) {
197+
* this.val = (val===undefined ? 0 : val)
198+
* this.next = (next===undefined ? null : next)
199+
* }
200+
* }
201+
*/
202+
203+
function addTwoNumbers(
204+
l1: ListNode | null,
205+
l2: ListNode | null,
206+
): ListNode | null {
207+
if (l1 == null || l2 == null) {
208+
return l1 && l2;
209+
}
210+
const dummy = new ListNode(0);
211+
let cur = dummy;
212+
while (l1 != null || l2 != null) {
213+
let val = 0;
214+
if (l1 != null) {
215+
val += l1.val;
216+
l1 = l1.next;
217+
}
218+
if (l2 != null) {
219+
val += l2.val;
220+
l2 = l2.next;
221+
}
222+
if (cur.val >= 10) {
223+
cur.val %= 10;
224+
val++;
225+
}
226+
cur.next = new ListNode(val);
227+
cur = cur.next;
228+
}
229+
if (cur.val >= 10) {
230+
cur.val %= 10;
231+
cur.next = new ListNode(1);
232+
}
233+
return dummy.next;
234+
}
235+
```
236+
237+
238+
### **Rust**
239+
240+
```rust
241+
impl Solution {
242+
pub fn add_two_numbers(
243+
mut l1: Option<Box<ListNode>>,
244+
mut l2: Option<Box<ListNode>>,
245+
) -> Option<Box<ListNode>> {
246+
let mut dummy = Some(Box::new(ListNode::new(0)));
247+
let mut cur = dummy.as_mut();
248+
while l1.is_some() || l2.is_some() {
249+
let mut val = 0;
250+
if let Some(node) = l1 {
251+
val += node.val;
252+
l1 = node.next;
253+
}
254+
if let Some(node) = l2 {
255+
val += node.val;
256+
l2 = node.next;
257+
}
258+
if let Some(node) = cur {
259+
if node.val >= 10 {
260+
val += 1;
261+
node.val %= 10;
262+
}
263+
node.next = Some(Box::new(ListNode::new(val)));
264+
cur = node.next.as_mut();
265+
}
266+
}
267+
if let Some(node) = cur {
268+
if node.val >= 10 {
269+
node.val %= 10;
270+
node.next = Some(Box::new(ListNode::new(1)));
271+
}
272+
}
273+
dummy.unwrap().next
274+
}
275+
}
276+
```
277+
188278
### **...**
189279

190280
```

‎lcci/02.05.Sum Lists/README_EN.md

+90
Original file line numberDiff line numberDiff line change
@@ -180,6 +180,96 @@ func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
180180
}
181181
```
182182

183+
### **TypeScript**
184+
185+
```ts
186+
/**
187+
* Definition for singly-linked list.
188+
* class ListNode {
189+
* val: number
190+
* next: ListNode | null
191+
* constructor(val?: number, next?: ListNode | null) {
192+
* this.val = (val===undefined ? 0 : val)
193+
* this.next = (next===undefined ? null : next)
194+
* }
195+
* }
196+
*/
197+
198+
function addTwoNumbers(
199+
l1: ListNode | null,
200+
l2: ListNode | null,
201+
): ListNode | null {
202+
if (l1 == null || l2 == null) {
203+
return l1 && l2;
204+
}
205+
const dummy = new ListNode(0);
206+
let cur = dummy;
207+
while (l1 != null || l2 != null) {
208+
let val = 0;
209+
if (l1 != null) {
210+
val += l1.val;
211+
l1 = l1.next;
212+
}
213+
if (l2 != null) {
214+
val += l2.val;
215+
l2 = l2.next;
216+
}
217+
if (cur.val >= 10) {
218+
cur.val %= 10;
219+
val++;
220+
}
221+
cur.next = new ListNode(val);
222+
cur = cur.next;
223+
}
224+
if (cur.val >= 10) {
225+
cur.val %= 10;
226+
cur.next = new ListNode(1);
227+
}
228+
return dummy.next;
229+
}
230+
```
231+
232+
233+
### **Rust**
234+
235+
```rust
236+
impl Solution {
237+
pub fn add_two_numbers(
238+
mut l1: Option<Box<ListNode>>,
239+
mut l2: Option<Box<ListNode>>,
240+
) -> Option<Box<ListNode>> {
241+
let mut dummy = Some(Box::new(ListNode::new(0)));
242+
let mut cur = dummy.as_mut();
243+
while l1.is_some() || l2.is_some() {
244+
let mut val = 0;
245+
if let Some(node) = l1 {
246+
val += node.val;
247+
l1 = node.next;
248+
}
249+
if let Some(node) = l2 {
250+
val += node.val;
251+
l2 = node.next;
252+
}
253+
if let Some(node) = cur {
254+
if node.val >= 10 {
255+
val += 1;
256+
node.val %= 10;
257+
}
258+
node.next = Some(Box::new(ListNode::new(val)));
259+
cur = node.next.as_mut();
260+
}
261+
}
262+
if let Some(node) = cur {
263+
if node.val >= 10 {
264+
node.val %= 10;
265+
node.next = Some(Box::new(ListNode::new(1)));
266+
}
267+
}
268+
dummy.unwrap().next
269+
}
270+
}
271+
```
272+
183273
### **...**
184274

185275
```

‎lcci/02.05.Sum Lists/Solution.rs

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
impl Solution {
2+
pub fn add_two_numbers(
3+
mut l1: Option<Box<ListNode>>,
4+
mut l2: Option<Box<ListNode>>,
5+
) -> Option<Box<ListNode>> {
6+
let mut dummy = Some(Box::new(ListNode::new(0)));
7+
let mut cur = dummy.as_mut();
8+
while l1.is_some() || l2.is_some() {
9+
let mut val = 0;
10+
if let Some(node) = l1 {
11+
val += node.val;
12+
l1 = node.next;
13+
}
14+
if let Some(node) = l2 {
15+
val += node.val;
16+
l2 = node.next;
17+
}
18+
if let Some(node) = cur {
19+
if node.val >= 10 {
20+
val += 1;
21+
node.val %= 10;
22+
}
23+
node.next = Some(Box::new(ListNode::new(val)));
24+
cur = node.next.as_mut();
25+
}
26+
}
27+
if let Some(node) = cur {
28+
if node.val >= 10 {
29+
node.val %= 10;
30+
node.next = Some(Box::new(ListNode::new(1)));
31+
}
32+
}
33+
dummy.unwrap().next
34+
}
35+
}

‎lcci/02.05.Sum Lists/Solution.ts

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* class ListNode {
4+
* val: number
5+
* next: ListNode | null
6+
* constructor(val?: number, next?: ListNode | null) {
7+
* this.val = (val===undefined ? 0 : val)
8+
* this.next = (next===undefined ? null : next)
9+
* }
10+
* }
11+
*/
12+
13+
function addTwoNumbers(
14+
l1: ListNode | null,
15+
l2: ListNode | null,
16+
): ListNode | null {
17+
if (l1 == null || l2 == null) {
18+
return l1 && l2;
19+
}
20+
const dummy = new ListNode(0);
21+
let cur = dummy;
22+
while (l1 != null || l2 != null) {
23+
let val = 0;
24+
if (l1 != null) {
25+
val += l1.val;
26+
l1 = l1.next;
27+
}
28+
if (l2 != null) {
29+
val += l2.val;
30+
l2 = l2.next;
31+
}
32+
if (cur.val >= 10) {
33+
cur.val %= 10;
34+
val++;
35+
}
36+
cur.next = new ListNode(val);
37+
cur = cur.next;
38+
}
39+
if (cur.val >= 10) {
40+
cur.val %= 10;
41+
cur.next = new ListNode(1);
42+
}
43+
return dummy.next;
44+
}

0 commit comments

Comments
 (0)