feat: implement leetcode 0001

Author: JCPedroza

src/leet-code/0001-two-sum/README.md

@@ -0,0 +1,67 @@
+# Two Sum
+
+Given an array of integers `nums` and an integer `target`, return the two
+indexes of the numbers that add up to `target`.
+
+* Assume that `nums` contains at most one solution.
+* Can't use the same element twice.
+* Answer must be in ascending order.
+* Throw an error if `nums` has no solution for `target`.
+
+## Function Signature
+
+```typescript
+function twoSum(nums: number[], target: number): [number, number]
+```
+
+## Expected Behavior
+
+```
+In: [3, 2], 5
+Out: [0, 1]
+
+In: [4, -7, 9, 2], 11
+Out: [2, 3]
+
+In: [4, -7, 9, 2, -5], -12
+Out: [1, 4]
+
+In: [3, 2], -10
+Out: Throw error
+
+In: [9], 9
+Out: Throw error
+
+In: [], 0
+Out: Throw error
+```
+
+## Optimization
+
+Consider:
+
+```
+nums[x] + nums[y] = target
+target - nums[x] = nums[y]
+```
+
+Two nested iterations are needed to find all `nums[x] + nums[y]`. This results
+in cuadratic time complexity `O(n^2)`.
+
+In one single iteration we can calculate `target - nums[x]` for all `x` and
+perform a fast lookup (like the ones you can perform using a hash map) to
+check if we have already seen one of the results.
+
+This avoids nested iterations, resulting in linear time complexity `O(n)`. By
+having the results as map keys, the `has()` and `get()` operations cost linear
+time.
+
+The trade-off is that we need a place to store the results, so space complexity
+goes from constant `O(1)` to linear `O(n)`.
+
+## Complexity Analysis
+
+| solution      | time   | space |
+| ------------- | ------ | ----- |
+| nested loops  | O(n^2) | O(1)  |
+| hash map      | O(n)   | O(n)  |

src/leet-code/0001-two-sum/two-sum-map-for.js

@@ -0,0 +1,31 @@
+/**
+ * Finds the two indexes of the two numbers that add up to 'target'. Assumes
+ * that there is exactly one solution. Uses a hash map to iterate only once, and
+ * one for loop.
+ *
+ * Time complexity: O(n)
+ * Space complexity: O(n) (space used by the hash map)
+ *
+ * @throws {Error} Array must contain a solution.
+ * @param {number[]} nums Numeric array to be searched.
+ * @param {number} target Target sum to search for.
+ * @returns {[number, number]} Indexes of the two numbers that add up to
+ * 'target'.
+ */
+const twoSum = (nums, target) => {
+  /** @type {Map<number, number>} */
+  const difIdxMap = new Map()
+
+  for (let idx = 0; idx < nums.length; idx++) {
+    const dif = target - nums[idx]
+    if (difIdxMap.has(dif)) return [difIdxMap.get(dif) ?? -1, idx]
+    else difIdxMap.set(nums[idx], idx)
+  }
+
+  throw new Error(`Array [${nums}] has no solution for ${target}`)
+}
+
+module.exports = {
+  fun: twoSum,
+  id: 'hash-map for-loop'
+}

src/leet-code/0001-two-sum/two-sum-map-tail.js

@@ -0,0 +1,42 @@
+/**
+ * Finds the two indexes of the two numbers that add up to 'target'. Assumes
+ * that there is exactly one solution. Uses a hash map to iterate only once,
+ * and tail recursion.
+ *
+ * Time complexity: O(n)
+ * Space complexity: O(n) (space used by the hash map)
+ *
+ * @throws {Error} Array must contain a solution.
+ * @param {number[]} nums Numeric array to be searched.
+ * @param {number} target Target sum to search for.
+ * @returns {[number, number]} Indexes of the two numbers that add up to
+ * 'target'.
+ */
+const twoSum = (nums, target) => {
+  /**
+   * Helper recursive function.
+   *
+   * @param {number} idx Current index.
+   * @param {Map<number, number>} difIdxMap Map of differences - indexes.
+   * @returns {[number, number]}
+   */
+  const twoSumRecur = (idx, difIdxMap) => {
+    if (idx >= nums.length) {
+      throw new Error(`Array [${nums}] has no solution for ${target}`)
+    }
+
+    const dif = target - nums[idx]
+    if (difIdxMap.has(dif)) {
+      return [difIdxMap.get(dif) ?? -1, idx]
+    }
+
+    return twoSumRecur(idx + 1, difIdxMap.set(nums[idx], idx))
+  }
+
+  return twoSumRecur(0, new Map())
+}
+
+module.exports = {
+  fun: twoSum,
+  id: 'hash-map tail-recursion'
+}

src/leet-code/0001-two-sum/two-sum-naive.js

@@ -0,0 +1,29 @@
+/**
+ * Finds the two indexes of the two numbers that add up to 'target'. Assumes
+ * that there is exactly one solution. Uses a naive brute-force approach.
+ *
+ * Time complexity: O(n^2)
+ * Space complexity: O(1)
+ *
+ * @throws {Error} Array must contain a solution.
+ * @param {number[]} nums Numeric array to be searched.
+ * @param {number} target Target sum to search for.
+ * @returns {[number, number]} Indexes of the two numbers that add up to
+ * 'target'.
+ */
+const twoSum = (nums, target) => {
+  for (let pivotIdx = 0; pivotIdx < nums.length - 1; pivotIdx++) {
+    for (let idx = pivotIdx + 1; idx < nums.length; idx++) {
+      if (nums[pivotIdx] + nums[idx] === target) {
+        return [pivotIdx, idx]
+      }
+    }
+  }
+
+  throw new Error(`Array [${nums}] has no solution for ${target}`)
+}
+
+module.exports = {
+  fun: twoSum,
+  id: 'naive'
+}

src/leet-code/0001-two-sum/two-sum.repo.js

@@ -0,0 +1,11 @@
+const twoSumNaive = require('./two-sum-naive')
+const twoSumMapFor = require('./two-sum-map-for')
+const twoSumMapTail = require('./two-sum-map-tail')
+
+const solutions = [
+  twoSumNaive,
+  twoSumMapFor,
+  twoSumMapTail
+]
+
+module.exports = solutions

src/leet-code/0001-two-sum/two-sum.test.js

@@ -0,0 +1,52 @@
+const assert = require('node:assert/strict')
+const { describe, it } = require('node:test')
+
+const solutions = require('./two-sum.repo')
+
+for (const { fun, id } of solutions) {
+  describe(`Leetcode 0001 'Two Sum' solution ${id}`, () => {
+    it('Solves array of length 2', () => {
+      assert.deepEqual(
+        fun([3, 2], 5),
+        [0, 1]
+      )
+    })
+
+    it('Solves array of lengh 4', () => {
+      assert.deepEqual(
+        fun([4, -7, 9, 2], 11),
+        [2, 3]
+      )
+    })
+
+    it('Solves array of lengh 5', () => {
+      assert.deepEqual(
+        fun([4, -7, 9, 2, -5], -12),
+        [1, 4]
+      )
+    })
+
+    it('Solves for sume of the same values', () => {
+      assert.deepEqual(
+        fun([4, 8, -7, 8, 3], 16),
+        [1, 3]
+      )
+    })
+
+    it('Throws error if no solution is found in array of length 5', () => {
+      assert.throws(() => fun([3, 2, 1, 0, -1], -10), Error)
+    })
+
+    it('Throws error if no solution is found in array of length 2', () => {
+      assert.throws(() => fun([3, 2], 9), Error)
+    })
+
+    it('Throws error if no solution is found in array of length 1', () => {
+      assert.throws(() => fun([3], -6), Error)
+    })
+
+    it('Throws error if no solution is found in array of length 0', () => {
+      assert.throws(() => fun([], 7), Error)
+    })
+  })
+}

src/leet-code/0001-two-sum/two-sum.time.js

@@ -0,0 +1,19 @@
+const { timeAndReport } = require('../../../lib/time')
+
+const solutions = require('./two-sum.repo')
+
+const nums = [
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+  8, 7, 6, 5, 4, 3, 2, 1, 0, 2,
+  4, 6, 8, 1, 3, 5, 7, 9, 3, 6,
+  9, 4, 8, 9, 8, 6, 5, 3, 2, 1,
+  8, 6, 4, 2, 5, 1, 9, 5, 3, 8,
+  0, 4, 0, 8, 0, 6, 0, 4, 0, 3,
+  2, -9, 4, 5, 7, 8, -8, 7, 4, 6
+]
+
+const args = [nums, -17]
+const runs = 10_000
+const id = 'LeetCode 0001 - Two Sum'
+
+timeAndReport(solutions, args, runs, id)