xiaokai1996
diff --git a/‎001. Add Two Numbers/README.md
Lines changed: 22 additions & 16 deletions b/‎001. Add Two Numbers/README.md
Lines changed: 22 additions & 16 deletions
diff --git a/‎001. Add Two Numbers/solution.py
Lines changed: 54 additions & 0 deletions b/‎001. Add Two Numbers/solution.py
Lines changed: 54 additions & 0 deletions
@@ -1,37 +1,43 @@
-这道题让我想起之前的 [Add Binary](../87. Add Binary). 思想几乎类似，难点在于**进位**。
+# 思路(C++)
 
-其次，这种关系到两个链表的问题，dummy 节点应该是必不可少的了。
+这道题让我想起之前的 [Add Binary](../66. Add Binary). 思想几乎类似，难点在于**进位**。
 
-以上两点，便是这道题的核心。私以为，本题难度应为 Easy.
+其次，这种关系到两个链表的问题，dummy 节点应该是必不可少的了。
+
+以上两点，便是这道题的核心。私以为，本题难度应为 Easy.
 
 -----
 
-具体说一下进位的事情。
+具体说一下进位的事情。
 
-STL 有一个专门的结构体叫做 `div_t`, 其包含两个成员，分别是 quot(quotient) 与 rem(remainder). 用来做什么，从命名上是否可以看出一点端倪呢？
+STL 有一个专门的结构体叫做 `div_t`, 其包含两个成员，分别是 quot(quotient) 与 rem(remainder). 用来做什么，从命名上是否可以看出一点端倪呢？
 
-举例说明.
+举例说明.
 
      38 / 5 == 7 remainder 3
 
-用 C++ 来描述，便是：
+用 C++ 来描述，便是：
 
      div_t result = div(38, 5);
      cout << result.quot << result.rem;
 
-前者为被除后的结果，后者为余数。
+前者为被除后的结果，后者为余数。
 
 -----
 
-与这道题的关系是？
+与这道题的关系是？
 
-本题的进位是基于十进制的，故两个节点相加之后的值，应判断是否超出了10，超出需要进位，留下的是余数。即，做了 div 操作后。sum.rem 是新链表的当前节点，sum.quot 是下一次加法运算的进位。
+本题的进位是基于十进制的，故两个节点相加之后的值，应判断是否超出了10，超出需要进位，留下的是余数。即，做了 div 操作后。sum.rem 是新链表的当前节点，sum.quot 是下一次加法运算的进位。
 
-有：
+有：
 
 ```cpp
-if (l1) { sum.quot += l1->val; l1 = l1->next; } // 进位 + l1
-if (l2) { sum.quot += l2->val; l2 = l2->next; } // 进位 + l1 + l2
-sum = div(sum.quot, 10); // 除 10 操作，得到新的 quot 与 rem.
-tail->next = new ListNode(sum.rem); // rem 为节点值, quot 留作下次迭代
-```
+if (l1) { sum.quot += l1->val; l1 = l1->next; } // 进位 + l1
+if (l2) { sum.quot += l2->val; l2 = l2->next; } // 进位 + l1 + l2
+sum = div(sum.quot, 10); // 除 10 操作，得到新的 quot 与 rem.
+tail->next = new ListNode(sum.rem); // rem 为节点值, quot 留作下次迭代
+```
+
+## Python
+
+STL 里的 `div` 方法对应 Python 里的 [`divmod`](https://docs.python.org/3/library/functions.html#divmod). 其等同于 (a // b, a % b). 其余的思路一致，不过 Python 里似乎不方便取地址直接修改内存，只好用傀儡节点的方法替代。
@@ -0,0 +1,54 @@
+#!python3
+
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+
+class Solution:
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        head = ListNode(0)
+        p = head
+        quot = 0
+        while l1 or l2 or quot != 0:
+            if l1:
+                quot += l1.val
+                l1 = l1.next
+            if l2:
+                quot += l2.val
+                l2 = l2.next
+            quot, rem = divmod(quot, 10)
+            p.next = ListNode(rem)
+            p = p.next
+
+        return head.next
+
+
+def co
A32A
mpareLinkedList(l1, l2):
+    while l1 or l2:
+        if not (l1 and l2) or l1.val != l2.val:
+            return False
+        l1 = l1.next
+        l2 = l2.next
+    return True
+
+
+if __name__ == "__main__":
+    l1 = ListNode(2)
+    l1.next = ListNode(4)
+    l1.next.next = ListNode(3)
+    l2 = ListNode(5)
+    l2.next = ListNode(6)
+    l2.next.next = ListNode(4)
+    lsum = ListNode(7)
+    lsum.next = ListNode(0)
+    lsum.next.next = ListNode(8)
+    print(compareLinkedList(Solution().addTwoNumbers(l1, l2), lsum))