From 745bfcac95a9bed2b8e2790bb756e53bb5d6fcde Mon Sep 17 00:00:00 2001
From: rizzOn <rezonphilip@gmail.com>
Date: Thu, 4 Jun 2026 01:05:36 +0530
Subject: [PATCH] day1 : of trying to riz up gophy kutty

---
 .DS_Store                           | Bin 0 -> 6148 bytes
 carry_aware_linked_list_addition.go |  73 ++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 .DS_Store
 create mode 100644 carry_aware_linked_list_addition.go

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ae3f0d8c7f2287e8fd20a0539b65f878b2d3f0a8
GIT binary patch
literal 6148
zcmeHLy-ve05I&b6MPjL#7%j0^>KlYA49p#iL}*hLM2agYLQF(F3NHW~3p=mETfq0(
zZq<~`2%)>m{?7MfU%#lfQxP$PyRt9R6_FH;XsEOZ&8@CZ4BiDA&QZ<!!-<<OS|<6c
zCf1%vPiAr{%VzzLqfOu3<@vaBW7yK-{pt1e^W&)LFW3H;xBchQmVa@v!Hp@9Du*(W
zbGgCiLC&Dv`_UA7g=((lN~TiA(XA|fObH7rMRSN?-R`7vlUNxa;{dJq<%Nr=C<DrX
zGN24716vH>%%-G!0ku~KlmTU6%>efYi$=^M)&c$2fv$rg{Rxo*otIFejhIEO1HuC_
zAr%->O?<^LAsu!b<Fbf#z>qG+uZ(%(%Bz<b<5!2>`fxE>K<$+QWuVExP8fE1{vYEf
z)B2L%Owo}tpbY#o227F<bN+1<&(<Gbk7un#E6^y6tEoVsH!cAfa34AF&fvGy5tl`*
V19BGHeL7Gt0-g}<l!0Gh;2VTJL974(

literal 0
HcmV?d00001

diff --git a/carry_aware_linked_list_addition.go b/carry_aware_linked_list_addition.go
new file mode 100644
index 0000000..77272e5
--- /dev/null
+++ b/carry_aware_linked_list_addition.go
@@ -0,0 +1,73 @@
+package gopherriz
+
+// 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.
+
+// our solution
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	return recursiveAddWithCarry(l1, l2, 0)
+}
+
+func recursiveAddWithCarry(l1 *ListNode, l2 *ListNode, carryValue int) *ListNode {
+	if l1 == nil && l2 == nil && carryValue == 0 {
+		return nil
+	}
+	nodeVal := (getNodeVal(l1) + getNodeVal(l2) + carryValue) % 10
+	carryVal := (getNodeVal(l1) + getNodeVal(l2) + carryValue) / 10
+	l1NextNode := getNextNode(l1)
+	l2NextNode := getNextNode(l2)
+
+	return &ListNode{
+		Val:  nodeVal,
+		Next: recursiveAddWithCarry(l1NextNode, l2NextNode, carryVal),
+	}
+}
+func getNextNode(node *ListNode) *ListNode {
+	if node == nil {
+		return nil
+	}
+	return node.Next
+}
+
+func getNodeVal(node *ListNode) int {
+	if node == nil {
+		return 0
+	}
+	return node.Val
+}
+
+// another more efficient way to approach this
+func addTwoNumbersOne(l1 *ListNode, l2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+	temp := dummy
+	carry := 0
+
+	for l1 != nil || l2 != nil || carry != 0 {
+		val1 := 0
+		if l1 != nil {
+			val1 = l1.Val
+			l1 = l1.Next
+		}
+
+		val2 := 0
+		if l2 != nil {
+			val2 = l2.Val
+			l2 = l2.Next
+		}
+
+		sum := val1 + val2 + carry
+		carry = sum / 10
+		temp.Next = &ListNode{Val: sum % 10}
+		temp = temp.Next
+	}
+
+	return dummy.Next
+}