updated readme file and added jest test enviroment

Author: soumsps

2020/01_January/LC1_TwoSum/index.js

@@ -0,0 +1,28 @@
+// Given an array of integers, return an array of indices of the two numbers
+// that add up to the target.
+// You may assume that each input would have exactly one solution, and
+// you may not use the same element twice.
+// --- Examples
+// twoSum([2,7,11,15], 9) --> [0,1]
+// twoSum([3,2,4], 9) --> [1,2]
+
+function twoSum(arr, target) {
+  let numsVisited = {};
+  let res = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    const num = arr[i];
+    const complement = target - num;
+
+    if (numsVisited[complement] !== undefined) {
+      res.push(i);
+      res.push(numsVisited[complement]);
+    }
+
+    numsVisited[num] = i;
+  }
+
+  return res;
+}
+
+module.exports = twoSum;

2020/01_January/LC1_TwoSum/test.js

@@ -0,0 +1,12 @@
+const twoSum = require('./index');
+
+test('twoSum([2,7,11,15], 9) returns [0,1]', () => {
+  expect(twoSum([2, 7, 11, 15], 9).sort((a, b) => (a < b ? -1 : 1))).toEqual([
+    0,
+    1
+  ]);
+});
+
+test('twoSum([3, 2, 4], 6) returns [1,2]', () => {
+  expect(twoSum([3, 2, 4], 6).sort((a, b) => (a < b ? -1 : 1))).toEqual([1, 2]);
+});

2020/01_January/LC2_addTwoNumbers/index.js

@@ -0,0 +1,18 @@
+// 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.
+// --- Example
+// Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+// Output: 7 -> 0 -> 8
+// Explanation: 342 + 465 = 807.
+
+class ListNode {
+  constructor(val, next = null) {
+    this.val = val;
+    this.next = next;
+  }
+}
+
+function addTwoNumbers(l1, l2) {}
+
+module.exports = addTwoNumbers;

2020/01_January/LC2_addTwoNumbers/test.js

@@ -0,0 +1,86 @@
+const addTwoNumbers = require('./index');
+
+class ListNode {
+  constructor(val, next = null) {
+    this.val = val;
+    this.next = next;
+  }
+}
+
+const convertLLToArr = ll => {
+  let arr = [];
+  while (ll) {
+    arr.push(ll.val);
+    ll = ll.next;
+  }
+  return arr;
+};
+
+const convertIntToLL = int => {
+  let list = null;
+  int.split('').forEach(digit => {
+    const head = new ListNode(Number(digit), list);
+    list = head;
+  });
+  return list;
+};
+
+test('(2 -> 4 -> 3) + (5 -> 6 -> 4) = (7 -> 0 -> 8)', () => {
+  // 342
+  const l1 = new ListNode(2);
+  l1.next = new ListNode(4);
+  l1.next.next = new ListNode(3);
+
+  // 465
+  const l2 = new ListNode(5);
+  l2.next = new ListNode(6);
+  l2.next.next = new ListNode(4);
+
+  // 342 + 465 = 807
+  expect(convertLLToArr(addTwoNumbers(l1, l2))).toEqual([7, 0, 8]);
+});
+
+test('(9) + (6) = (5 -> 1)', () => {
+  // 342
+  const l1 = new ListNode(9);
+
+  // 465
+  const l2 = new ListNode(6);
+
+  // 342 + 465 = 807
+  expect(convertLLToArr(addTwoNumbers(l1, l2))).toEqual([5, 1]);
+});
+
+test('works for 10000000000000000000000001 + 465', () => {
+  const l1 = convertIntToLL('10000000000000000000000001');
+  const l2 = convertIntToLL('465');
+
+  expect(convertLLToArr(addTwoNumbers(l1, l2))).toEqual([
+    6,
+    6,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+});