🚀 From Brute Force to Optimal: Solving LeetCode Problems Step-by-Step (with JavaScript Examples)

When tackling coding problems, the smartest approach isn’t always the fastest—it’s knowing how to evolve your solution over time. Whether you're a beginner or brushing up for interviews, this post will walk you through 8 techniques, each one solving an example problem in progressively smarter ways.

---

🧱 Step 1: Brute Force with Loops

📌 Problem: Two Sum

Given an array nums and a target value, return the indices of two numbers such that they add up to the target.

🧠 Brute Force Solution

function twoSum(nums, target) {
  for (let i = 0; i < nums.length; i++) {
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[i] + nums[j] === target) {
        return [i, j];
      }
    }
  }
}

🔍 Analysis

• ✅ Easy to understand

• ❌ Time: O(n²) → slow for large arrays

---

🧮 Step 2: Hash Map Optimization

💡 Use hashing to store previously seen elements

function twoSum(nums, target) {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const diff = target - nums[i];
    if (map.has(diff)) return [map.get(diff), i];
    map.set(nums[i], i);
  }
}

🔍 Analysis

• ✅ Time reduced to O(n)

• ✅ More scalable

---

🔁 Step 3: Sliding Window

📌 Problem: Longest Substring Without Repeating Characters

🧠 Brute Force (Nested Loops)

function lengthOfLongestSubstring(s) {
  let max = 0;
  for (let i = 0; i < s.length; i++) {
    let set = new Set();
    for (let j = i; j < s.length; j++) {
      if (set.has(s[j])) break;
      set.add(s[j]);
    }
    max = Math.max(max, set.size);
  }
  return max;
}

🧠 Optimized with Sliding Window

function lengthOfLongestSubstring(s) {
  let set = new Set();
  let left = 0, maxLen = 0;

  for (let right = 0; right < s.length; right++) {
    while (set.has(s[right])) {
      set.delete(s[left]);
      left++;
    }
    set.add(s[right]);
    maxLen = Math.max(maxLen, right - left + 1);
  }
  return maxLen;
}

🔍 Analysis

• ❌ Brute force: O(n²)

• ✅ Sliding window: O(n)

---

📦 Step 4: Prefix Sum

📌 Problem: Subarray Sum Equals K

🧠 Optimized with Prefix Sum + Map

function subarraySum(nums, k) {
  const map = new Map();
  map.set(0, 1);
  let count = 0, sum = 0;

  for (const num of nums) {
    sum += num;
    if (map.has(sum - k)) count += map.get(sum - k);
    map.set(sum, (map.get(sum) || 0) + 1);
  }
  return count;
}

🔍 Analysis

• ✅ Handles multiple subarrays

• ✅ Time: O(n)

• ✅ Space: O(n)

---

🔍 Step 5: Sorting + Binary Search

📌 Problem: Find Insert Position

🧠 Binary Search

function searchInsert(nums, target) {
  let left = 0, right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (nums[mid] === target) return mid;
    else if (nums[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return left;
}

🔍 Analysis

• ✅ Efficient for sorted arrays

• ✅ Time: O(log n)

---

🧭 Step 6: Heap / Greedy

📌 Problem: Top K Frequent Elements

🧠 Using Map + Sort (Greedy-style)

function topKFrequent(nums, k) {
  const count = new Map();
  for (const num of nums) {
    count.set(num, (count.get(num) || 0) + 1);
  }
  const sorted = [...count.entries()].sort((a, b) => b[1] - a[1]);
  return sorted.slice(0, k).map(([num]) => num);
}

🔍 Analysis

• ✅ Time: O(n log n)

• 🛠️ Can optimize with heap for O(n log k)

---

🧵 Step 7: Backtracking

📌 Problem: Subsets

🧠 Recursive Backtracking

function subsets(nums) {
  const res = [];
  function backtrack(start, path) {
    res.push([...path]);
    for (let i = start; i < nums.length; i++) {
      path.push(nums[i]);
      backtrack(i + 1, path);
      path.pop();
    }
  }
  backtrack(0, []);
  return res;
}

🔍 Analysis

• ✅ Generates all combinations

• ❌ Time: O(2ⁿ)

---

🏗️ Step 8: Dynamic Programming

📌 Problem: Climbing Stairs

🧠 Bottom-Up DP

function climbStairs(n) {
  if (n <= 2) return n;
  let dp = [1, 1];
  for (let i = 2; i <= n; i++) {
    dp[i] = dp[i - 1] + dp[i - 2];
  }
  return dp[n];
}

🔍 Analysis

• ✅ Time: O(n)

• ✅ Space: O(n) (can optimize to O(1))

---

🔄 Final Recap Table

---

🧠 Conclusion

When approaching a problem:

1. Start with brute force to understand the core logic.

2. Climb the ladder—optimize with hash maps, two pointers, prefix sums, and beyond.

3. Always analyze complexity and think: Can I do better?

Whether you're prepping for interviews or improving daily, this technique ladder gives you a structured way to level up. 🚀