From 145e0dda3c2dbf95a6eb87640e4f392838a31baa Mon Sep 17 00:00:00 2001
From: Atsutoshi-Honda <haniyasusin@gmail.com>
Date: Sat, 9 May 2026 18:05:31 +0900
Subject: [PATCH] init

---
 2. Add Two Numbers/memo.md | 121 +++++++++++++++++++++++++++++++++++++
 1 file changed, 121 insertions(+)
 create mode 100644 2. Add Two Numbers/memo.md

diff --git a/2. Add Two Numbers/memo.md b/2. Add Two Numbers/memo.md
new file mode 100644
index 0000000..16b83c8
--- /dev/null
+++ b/2. Add Two Numbers/memo.md	
@@ -0,0 +1,121 @@
+## step1:
+まずl1, l2のheadからポインタを順番に線形探索していって、各ノードでvalを足してもし繰り上げがあればそれを次のノード同士での足し算で利用すれば実装できそうだと感じた。なので答えをanswer_headとしてrunnerにl1とl2の各ノードの足した結果を新しいノードとして順次生成してもらってそれを答えとする方針でいく。
+### code
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        carry_up = 0
+        answer_head = ListNode()
+        runner = answer_head
+        while l1 or l2 or carry_up > 0:
+            val_sum = 0
+            if l1:
+                val_sum += l1.val
+                l1 = l1.next
+            if l2:
+                val_sum += l2.val
+                l2 = l2.next
+            val_sum += carry_up
+
+            runner.val = val_sum % 10
+            carry_up = val_sum // 10
+            if l1 or l2 or carry_up > 0:
+                runner.next = ListNode()
+                runner = runner.next
+        
+        return answer_head
+```
+これでacceptされた。空間計算量がO(n)かかり、l1やl2のメモリをそのまま活用する方法もあったと思うが分かりやすさを考えると別にこれでもいい気がする。
+他の方のコードを読んでみる。
+
+https://github.com/fhiyo/leetcode/pull/5/changes/f2e20f4d25a90b2fd41c44fc33005a620646d0fd
+```cpp
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        ListNode dummy_head = ListNode(-1);
+        ListNode* node = &dummy_head;
+        int carry = 0;
+        while (l1 || l2 || carry) {
+            const int total = getValOrDefault(l1, 0) + getValOrDefault(l2, 0) + carry;
+            carry = total / 10;
+            node->next = new ListNode(total % 10); // digit
+            node = node->next;
+            l1 = getNextIfExists(l1);
+            l2 = getNextIfExists(l2);
+        }
+        return dummy_head.next;
+    }
+
+private:
+    static int getValOrDefault(const ListNode* const node, const int default_value) {
+        if (!node) return default_value;
+        return node->val;
+    }
+
+    static ListNode* getNextIfExists(const ListNode* const node) {
+        if (!node) return nullptr;
+        return node->next;
+    }
+};
+```
+だいたい一緒だった。自分のコードではrunnerにそのまま新しいNodeを代入し、while文の最後でrunner.nextにてNoneで終わるかNodeを作るかを判断していた。この方はdummy_headを使っていて、先頭のnode.nextに足し算結果のノードを代入しているので最後にnode.nextにNoneを入れるか次のノードを入れるか判断する必要がない。ただ個人的には自分の方の回答の方が納得するので自分の方ので行こうと思う。
+
+## step2:
+### code
+```python
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        carry_up = 0
+        answer_head = ListNode()
+        runner = answer_head
+        while l1 or l2 or carry_up > 0:
+            val_sum = 0
+            if l1:
+                val_sum += l1.val
+                l1 = l1.next
+            if l2:
+                val_sum += l2.val
+                l2 = l2.next
+            val_sum += carry_up
+
+            runner.val = val_sum % 10
+            carry_up = val_sum // 10
+            if l1 or l2 or carry_up > 0:
+                runner.next = ListNode()
+                runner = runner.next
+        
+        return answer_head
+```
+
+## step3:
+### code
+```python
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        carry_up = 0
+        answer_head = ListNode()
+        runner = answer_head
+        while l1 or l2 or carry_up > 0:
+            val_sum = 0
+            if l1:
+                val_sum += l1.val
+                l1 = l1.next
+            if l2:
+                val_sum += l2.val
+                l2 = l2.next
+            val_sum += carry_up
+
+            runner.val = val_sum % 10
+            carry_up = val_sum // 10
+            if l1 or l2 or carry_up > 0:
+                runner.next = ListNode()
+                runner = runner.next
+        
+        return answer_head
+```
\ No newline at end of file