Add two numbers

Author: volodimyr

2.add_two_numbers/add.go

@@ -0,0 +1,102 @@
+// 2. Add two numbers
+// Topics: 'Math', 'Recursion', 'Linked List'
+// Level: 'Medium'
+
+// You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+// You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+// Example 1:
+
+// Input: l1 = [2,4,3], l2 = [5,6,4]
+// Output: [7,0,8]
+// Explanation: 342 + 465 = 807.
+
+// Example 2:
+
+// Input: l1 = [0], l2 = [0]
+// Output: [0]
+
+// Example 3:
+
+// Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+// Output: [8,9,9,9,0,0,0,1]
+
+// Constraints:
+
+//     The number of nodes in each linked list is in the range [1, 100].
+//     0 <= Node.val <= 9
+//     It is guaranteed that the list represents a number that does not have leading zeros.
+
+package addtwonumbers
+
+// memory O(n) extra
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+	current := dummy
+	carry := 0
+
+	for l1 != nil || l2 != nil || carry > 0 {
+		sum := carry
+		if l1 != nil {
+			sum += l1.Val
+			l1 = l1.Next
+		}
+		if l2 != nil {
+			sum += l2.Val
+			l2 = l2.Next
+		}
+		carry = sum / 10
+		current.Next = &ListNode{Val: sum % 10}
+		current = current.Next
+	}
+
+	return dummy.Next
+}
+
+// memory O(1) extra
+// func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+// 	cur1 := l1
+// 	prev := cur1
+// 	cur2 := l2
+// 	var carry int
+// 	for {
+// 		sum := carry
+// 		if cur1 == nil && cur2 == nil {
+// 			if carry != 0 {
+// 				prev.Next = &ListNode{Val: carry}
+// 			}
+// 			break
+// 		}
+// 		if cur1 != nil {
+// 			sum += cur1.Val
+// 		}
+// 		if cur2 != nil {
+// 			sum += cur2.Val
+// 		}
+
+// 		if cur1 != nil {
+// 			cur1.Val = sum % 10
+// 		} else {
+// 			cur2.Val = sum % 10
+// 			prev.Next = cur2
+// 			prev = prev.Next
+// 		}
+
+// 		if cur1 != nil {
+// 			prev = cur1
+// 			cur1 = cur1.Next
+// 		}
+// 		if cur2 != nil {
+// 			cur2 = cur2.Next
+// 		}
+// 		carry = sum / 10
+// 	}
+
+// 	return l1
+// }
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}

2.add_two_numbers/add_test.go

@@ -0,0 +1,112 @@
+package addtwonumbers
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestAddTwoNumbers(t *testing.T) {
+	tests := []struct {
+		name string
+		l1   *ListNode
+		l2   *ListNode
+		want *ListNode
+	}{
+		{
+			name: "example 1: 342 + 465 = 807",
+			l1:   createList([]int{2, 4, 3}),
+			l2:   createList([]int{5, 6, 4}),
+			want: createList([]int{7, 0, 8}),
+		},
+		{
+			name: "example 2: 0 + 0 = 0",
+			l1:   createList([]int{0}),
+			l2:   createList([]int{0}),
+			want: createList([]int{0}),
+		},
+		{
+			name: "example 3: 9999999 + 9999 = 10009998",
+			l1:   createList([]int{9, 9, 9, 9, 9, 9, 9}),
+			l2:   createList([]int{9, 9, 9, 9}),
+			want: createList([]int{8, 9, 9, 9, 0, 0, 0, 1}),
+		},
+		{
+			name: "different lengths: 123 + 4567 = 4690",
+			l1:   createList([]int{3, 2, 1}),
+			l2:   createList([]int{7, 6, 5, 4}),
+			want: createList([]int{0, 9, 6, 4}),
+		},
+		{
+			name: "carry propagation: 99 + 1 = 100",
+			l1:   createList([]int{9, 9}),
+			l2:   createList([]int{1}),
+			want: createList([]int{0, 0, 1}),
+		},
+		{
+			name: "single digit with carry: 5 + 5 = 10",
+			l1:   createList([]int{5}),
+			l2:   createList([]int{5}),
+			want: createList([]int{0, 1}),
+		},
+		{
+			name: "no carry: 1 + 2 = 3",
+			l1:   createList([]int{1}),
+			l2:   createList([]int{2}),
+			want: createList([]int{3}),
+		},
+		{
+			name: "l1 longer: 12345 + 67 = 12412",
+			l1:   createList([]int{5, 4, 3, 2, 1}),
+			l2:   createList([]int{7, 6}),
+			want: createList([]int{2, 1, 4, 2, 1}),
+		},
+		{
+			name: "l2 longer: 12 + 3456 = 3468",
+			l1:   createList([]int{2, 1}),
+			l2:   createList([]int{6, 5, 4, 3}),
+			want: createList([]int{8, 6, 4, 3}),
+		},
+		{
+			name: "multiple carries: 999 + 999 = 1998",
+			l1:   createList([]int{9, 9, 9}),
+			l2:   createList([]int{9, 9, 9}),
+			want: createList([]int{8, 9, 9, 1}),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := addTwoNumbers(tt.l1, tt.l2)
+			if !equalLists(got, tt.want) {
+				t.Errorf("addTwoNumbers() = %v, want %v", listToSlice(got), listToSlice(tt.want))
+			}
+		})
+	}
+}
+
+func createList(vals []int) *ListNode {
+	if len(vals) == 0 {
+		return nil
+	}
+	head := &ListNode{Val: vals[0]}
+	current := head
+	for i := 1; i < len(vals); i++ {
+		current.Next = &ListNode{Val: vals[i]}
+		current = current.Next
+	}
+	return head
+}
+
+func listToSlice(head *ListNode) []int {
+	var result []int
+	current := head
+	for current != nil {
+		result = append(result, current.Val)
+		current = current.Next
+	}
+	return result
+}
+
+func equalLists(l1, l2 *ListNode) bool {
+	return reflect.DeepEqual(listToSlice(l1), listToSlice(l2))
+}