Merge pull request AlgorithmCrackers#35 from AlgorithmCrackers/add-two-numbers

Add two numbers

Author: santhoshvai

02_LinkedLists/LoopInList/README.md

@@ -27,6 +27,6 @@ bool hasLoop(struct node *head)
 
 > The entry node is the first node in the loop from head of list. For instance, the entry node of loop in the list of Figure 1 is the node with value 3.
 
-#### [LeetCode Solution](https://leetcode.com/problems/linked-list-cycle/)
+#### [LeetCode link](https://leetcode.com/problems/linked-list-cycle/)
 
 #### [Detailed discussion](http://k2code.blogspot.in/2010/04/how-would-you-detect-loop-in-linked.html)

02_LinkedLists/README.md

@@ -7,15 +7,7 @@
      * Input: the node `c` from the linked list `a->b->c->d->e`
      * Result: nothing is returned, but the new linked list looks like `a->b->d->e`
 4. Write code to partition a linked list around a value `x`, such that all nodes less than `x` come before all nodes greater than or equal to `x`.
-5. You have two numbers represented by a linked list, where each node contains a single digit. The digits are stored in reverse order, such that the 1's digit is at the head of the list. Write a function that adds the two numbers and returns the sum as a linked list.
-   * EXAMPLE
-     * Input: (7->1->6) + (5->9->2). That is, 617 + 295.
-     * Output: 2->1->9. That is, 912.
-   * FOLLOW UP
-     * Suppose the digits are stored in forward order. Repeat the above problem.
-     * Example
-       * Input: (6->1->7) + (2->9->5). That is, 617 + 295.
-       * Output: 9->1->2. That is, 912.
+5. 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 contain a single digit. Add the two numbers and return it as a linked list.**[add-two-numbers](add-two-numbers)**
 6. Given a circular linked list, implement an algorithm which returns node at the beginning of the loop.**[LoopInList](LoopInList)**
    * DEFINITION
      * Circular linked list: A (corrupt) linked list in which a node’s next pointer  points to an earlier node, so as to make a loop in the linked list.

02_LinkedLists/add-two-numbers/README.md

@@ -0,0 +1,23 @@
+# Add Two Numbers
+
+`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 contain a single digit. Add the two numbers and return it as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+## Example:
+
+```
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+Explanation: 342 + 465 = 807.
+```
+
+## Complexity Analysis:
+
+- **Time complexity** : `O(max(m, n))`. Assume that `m` and `n` are lengths of the two input linked-lists respectively. We traverse the linked-list with the maximum length once.
+
+- **Space complexity** : `O(max(m, n))`. The length of the new list is the maximum length of the two lists + 1 (for the carry over).
+
+#### [LeetCode link](https://leetcode.com/problems/add-two-numbers/)

02_LinkedLists/add-two-numbers/solution.js

@@ -0,0 +1,47 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  let current = new ListNode(-1)
+  const ptrToFake = current
+  // variable to store the carry over after addition (either 1 or  0)
+  let carry = 0
+  while(l1 || l2) {
+      const a = l1 ? l1.val : 0
+      const b = l2 ? l2.val : 0
+      // actual summing
+      sum = carry + a + b
+      // find the carry over
+      carry = sum > 9 ? 1 : 0
+      // the mod to 10 is the required number to store in the node
+      // example: 9 + 8 = 17, here 7 will be in the node, 1 goes to carry over
+      const node = new ListNode(sum % 10)
+      // add to the resulting linked list
+      current.next = node
+      // iterate to the next nodes
+      current = node
+      if (l1) {
+          l1 = l1.next
+      }
+      if (l2) {
+          l2 = l2.next
+      }
+  }
+
+  // finally, check if the carry was left over.. this means we need an extra 1
+  if (carry) {
+      const node = new ListNode(1)
+      current.next = node
+  }
+
+  return ptrToFake.next
+};