Improve solution for Add two numbers: Make it a one pass solution, rather than ~ 4 passes

Author: lon-io

add_two_numbers.go

@@ -2,94 +2,80 @@ package main
 
 import (
     "fmt"
-    "strconv"
-    "strings"
 )
 
 type ListNode struct {
 	Val int
 	Next *ListNode
 }
 
-func walk (l *ListNode, a *string) {
-    v := l.Val
-    *a =  *a + fmt.Sprintf("%d", v)
-
-    if l.Next != nil {
-        walk(l.Next, a)
-    }
-}
-
-func extendLinkedList(ln *ListNode, acc []string, ci int) {
-    cmp := len(acc) - ci - 1
-    iSum, _ := strconv.ParseInt(acc[cmp], 10, 32)
-    ln.Val = int(iSum)
-
-    if cmp != 0 {
-        next := ListNode{}
-        ln.Next = &next
-        extendLinkedList(ln.Next, acc, ci + 1)
-    }
-}
-
 func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
-    acc1 := ""
-    acc2 := ""
+	resNode := &ListNode{}
+	curResNode := resNode
+	curNode1 := l1
+	curNode2 := l2
+	carry := 0
 
-    walk(l1, &acc1)
-    walk(l2, &acc2)
+	for {
+		var d1, d2 int
+		if curNode1 != nil {
+			d1 = curNode1.Val
+			curNode1 = curNode1.Next
+		}
 
-    lng := acc1
-    srt := acc2
-    if len(acc1) < len(acc2) {
-        lng = acc2
-        srt = acc1
-    }
+		if curNode2 != nil {
+			d2 = curNode2.Val
+			curNode2 = curNode2.Next
+		}
 
-    sumStr := ""
-    carry := 0
-    for i := 0; i <= len(lng); i ++ {
-        if i == len(lng) {
-            if carry > 0 {
-                sumStr = fmt.Sprintf("%d", carry) + sumStr
-            }
-        } else {
-            var vs, vl string
-
-            if i < len(srt)  {
-                vs = string(srt[i])
-            }
-
-            vl = string(lng[i])
-            ds, _ := strconv.Atoi(vs)
-            dl, _ := strconv.Atoi(vl)
-
-            sI := ds + dl + carry
-            carry = sI / 10
-            sI = sI % 10
-
-            fmt.Printf("\n Index: %d ::: short %d + long %d ==> %d;; carry: %d", i, ds, dl, sI, carry)
-            sumStr = fmt.Sprintf("%d", sI) + sumStr
-        }
-    }
+		dSum := d1 + d2 + carry
+		carry = dSum / 10
+		dSum = dSum % 10
 
-    fmt.Printf("\n FINAL SUM::: %s", sumStr)
-    sumSl := strings.Split(sumStr, "")
+		fmt.Printf("\nNode1 %d + Node2 %d ==> %d;; carry: %d", d1, d2, dSum, carry)
 
-    lnSum := ListNode{}
-    extendLinkedList(&lnSum, sumSl, 0)
+		curResNode.Val = dSum
 
-    return &lnSum
+		if curNode1 == nil && curNode2 == nil {
+            if carry > 0 {
+				carryNode := ListNode{
+					Val: carry,
+					Next: nil,
+				}
+				curResNode.Next = &carryNode
+			}
+
+			break
+		}
+
+		nextNode := ListNode{}
+		curResNode.Next = &nextNode
+		curResNode = curResNode.Next
+	}
+
+    return resNode
 }
 
-func extendTestCaseLinkedList(ln *ListNode, acc []int, ci int) {
+// populateLinkedList: Helper function to build LinkedList for testCases
+func populateLinkedList(ln *ListNode, acc []int, ci int) {
     iSum := acc[ci]
     ln.Val = int(iSum)
 
     if ci < len(acc) - 1 {
         next := ListNode{}
         ln.Next = &next
-        extendTestCaseLinkedList(ln.Next, acc, ci + 1)
+        populateLinkedList(ln.Next, acc, ci + 1)
+    }
+}
+
+// walk: Helper function to walk a Linkedlist and populate build a
+// string representation for it
+func walk (l *ListNode, a *string) {
+    v := l.Val
+    *a =  *a + fmt.Sprintf("%d", v)
+
+    if l.Next != nil {
+        walk(l.Next, a)
     }
 }
 
@@ -99,8 +85,12 @@ func main() {
 	test2 := []int{5,6,4}
 
 	var listNode1, listNode2 ListNode
-	extendTestCaseLinkedList(&listNode1, test1, 0)
-	extendTestCaseLinkedList(&listNode2, test2, 0)
+	populateLinkedList(&listNode1, test1, 0)
+	populateLinkedList(&listNode2, test2, 0)
+
+	resNode := addTwoNumbers(&listNode1, &listNode2)
+	resStr := ""
+	walk(resNode, &resStr)
 
-	addTwoNumbers(&listNode1, &listNode2)
+	fmt.Printf("\nRESULT::: %s \n", resStr)
 }