feat: implement problem 4

Author: hoangtrietdev

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+.env

jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

src/problem4/index.test.ts

@@ -0,0 +1,32 @@
+import { sumToNWithLoop, sumToNWithFormula, sumToNWithRecursion, sumToNMemoRecursion } from "./index";
+
+describe("Sum to N functions", () => {
+  it("sumToNWithLoop should return correct sum", () => {
+    expect(sumToNWithLoop(5)).toBe(15);
+    expect(sumToNWithLoop(0)).toBe(0);
+  });
+
+  it("sumToNWithFormula should return correct sum", () => {
+    expect(sumToNWithFormula(5)).toBe(15);
+    expect(sumToNWithFormula(0)).toBe(0);
+  });
+
+  it("sumToNWithRecursion should return correct sum", () => {
+    expect(sumToNWithRecursion(5)).toBe(15);
+    expect(sumToNWithRecursion(0)).toBe(0);
+  });
+
+  it("sumToNMemoRecursion should return correct sum", () => {
+    expect(sumToNMemoRecursion(5)).toBe(15);
+    expect(sumToNMemoRecursion(0)).toBe(0);
+  });
+
+  it("should throw error if result exceeds Number.MAX_SAFE_INTEGER", () => {
+    // Find n such that (n * (n + 1)) / 2 > Number.MAX_SAFE_INTEGER
+    const unsafeN = Math.floor((Math.sqrt(8 * Number.MAX_SAFE_INTEGER + 1) - 1) / 2) + 1;
+    expect(() => sumToNWithLoop(unsafeN)).toThrow('Result exceeds Number.MAX_SAFE_INTEGER');
+    expect(() => sumToNWithFormula(unsafeN)).toThrow('Result exceeds Number.MAX_SAFE_INTEGER');
+    expect(() => sumToNWithRecursion(unsafeN)).toThrow('Result exceeds Number.MAX_SAFE_INTEGER');
+    expect(() => sumToNMemoRecursion(unsafeN)).toThrow('Result exceeds Number.MAX_SAFE_INTEGER');
+  });
+});

src/problem4/index.ts

@@ -0,0 +1,82 @@
+/**
+ * Iteratively computes the sum from 1 to n using a loop.
+ *
+ * Time Complexity: O(n) — Iterates through all numbers from 1 to n.
+ * Space Complexity: O(1) — Uses constant extra space for sum variable.
+ */
+export const sumToNWithLoop = (n: number): number => {
+  /** Check if sum will exceed Number.MAX_SAFE_INTEGER */
+  if (n > 0 && (n * (n + 1)) / 2 > Number.MAX_SAFE_INTEGER) {
+    throw new Error('Result exceeds Number.MAX_SAFE_INTEGER');
+  }
+  let sum = 0;
+  for (let i = 1; i <= n; i++) {
+    sum += i;
+  }
+  return sum;
+}
+
+
+/**
+ * Computes the sum from 1 to n using the mathematical formula.
+ *
+ * Time Complexity: O(1) — Direct calculation, no iteration.
+ * Space Complexity: O(1) — No extra space required.
+ *
+ * This is the most optimal approach for this problem.
+ */
+export const sumToNWithFormula = (n: number): number => {
+  /** Check if sum will exceed Number.MAX_SAFE_INTEGER */
+  if (n > 0 && (n * (n + 1)) / 2 > Number.MAX_SAFE_INTEGER) {
+    throw new Error('Result exceeds Number.MAX_SAFE_INTEGER');
+  }
+  return (n * (n + 1)) / 2;
+}
+
+
+/**
+ * Recursively computes the sum from 1 to n.
+ *
+ * Time Complexity: O(n) — Recursion depth is n.
+ * Space Complexity: O(n) — Call stack grows linearly with n.
+ *
+ * Not recommended for large n due to stack overflow risk.
+ */
+export const sumToNWithRecursion = (n: number): number => {
+  /** Check if sum will exceed Number.MAX_SAFE_INTEGER */
+  if (n > 0 && (n * (n + 1)) / 2 > Number.MAX_SAFE_INTEGER) {
+    throw new Error('Result exceeds Number.MAX_SAFE_INTEGER');
+  }
+  if (n === 0) {
+    return 0;
+  }
+  return n + sumToNWithRecursion(n - 1);
+}
+
+/**
+ * Memoized recursive computation of sum from 1 to n.
+ *
+ * Time Complexity: O(n) — Each value from 1 to n is computed once.
+ * Space Complexity: O(n) — Stores results for each n in memoization map and call stack.
+ *
+ * Memoization is used to avoid redundant calculations in recursion, improving efficiency.
+ * This technique is especially useful in problems with overlapping sub-problems.
+ */
+const memo = new Map<number, number>();
+
+export function sumToNMemoRecursion(n: number): number {
+  /** Check if sum will exceed Number.MAX_SAFE_INTEGER */
+  if (n > 0 && (n * (n + 1)) / 2 > Number.MAX_SAFE_INTEGER) {
+    throw new Error('Result exceeds Number.MAX_SAFE_INTEGER');
+  }
+  if (n <= 0) return 0;
+
+  if (memo.has(n)) {
+    return memo.get(n)!;
+  }
+
+  const result = n + sumToNMemoRecursion(n - 1);
+  memo.set(n, result);
+
+  return result;
+}

src/problem4/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};