Simply Code!

Common Programming Problem-Solving Techniques and Patterns in JavaScript

Vineeth J Nair's photo
Vineeth J Nair
·

4 min read

In the world of programming, solving problems efficiently is a critical skill. JavaScript, being a versatile language, offers multiple ways to tackle challenges. This blog explores some common problem-solving techniques and patterns in JavaScript, equipping you to write clean, efficient, and maintainable code.

1. Divide and Conquer

The Divide and Conquer technique involves breaking down a problem into smaller subproblems, solving each one independently, and then combining the solutions. This approach is particularly effective for problems like sorting and searching.

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left <= right) {
    const mid = Math.floor((left + right) / 2);

    if (arr[mid] === target) return mid;
    if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }

  return -1;
}

const numbers = [1, 3, 5, 7, 9, 11];
console.log(binarySearch(numbers, 7)); // Output: 3

2. Two Pointers Technique

This technique uses two pointers to iterate through a data structure, often from opposite ends. It’s ideal for problems involving pairs, subarrays, or sequences.

Example: Finding a Pair with a Target Sum

function twoSum(arr, target) {
  let left = 0;
  let right = arr.length - 1;

  while (left < right) {
    const sum = arr[left] + arr[right];

    if (sum === target) return [arr[left], arr[right]];
    if (sum < target) left++;
    else right--;
  }

  return null;
}

const nums = [1, 2, 3, 4, 6];
console.log(twoSum(nums, 7)); // Output: [1, 6]

3. Sliding Window

The Sliding Window technique is used for problems involving subarrays or substrings. It involves maintaining a window that slides through the array, updating the result as needed.

Example: Maximum Sum Subarray of Size K

function maxSubarraySum(arr, k) {
  let maxSum = 0;
  let currentSum = 0;

  for (let i = 0; i < k; i++) {
    currentSum += arr[i];
  }

  maxSum = currentSum;

  for (let i = k; i < arr.length; i++) {
    currentSum += arr[i] - arr[i - k];
    maxSum = Math.max(maxSum, currentSum);
  }

  return maxSum;
}

const data = [2, 1, 5, 1, 3, 2];
console.log(maxSubarraySum(data, 3)); // Output: 9

4. Dynamic Programming (DP)

Dynamic Programming is used to solve problems with overlapping subproblems by storing the results of solved subproblems. It’s commonly used in optimization problems.

Example: Fibonacci Sequence (Memoization)

function fibonacci(n, memo = {}) {
  if (n <= 1) return n;
  if (n in memo) return memo[n];

  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
}

console.log(fibonacci(10)); // Output: 55

5. Greedy Algorithm

A Greedy Algorithm makes the best possible choice at each step. It’s effective for problems where local optimization leads to a global solution.

Example: Coin Change Problem

function minCoins(coins, amount) {
  coins.sort((a, b) => b - a);
  let count = 0;

  for (let coin of coins) {
    while (amount >= coin) {
      amount -= coin;
      count++;
    }
  }

  return amount === 0 ? count : -1;
}

console.log(minCoins([1, 2, 5], 11)); // Output: 3 (5 + 5 + 1)

6. Backtracking

Backtracking involves exploring all possible solutions and backtracking when a solution is not feasible. It’s useful for constraint satisfaction problems.

Example: Generating All Subsets

function subsets(nums) {
  const result = [];

  function backtrack(start, path) {
    result.push([...path]);

    for (let i = start; i < nums.length; i++) {
      path.push(nums[i]);
      backtrack(i + 1, path);
      path.pop();
    }
  }

  backtrack(0, []);
  return result;
}

console.log(subsets([1, 2, 3]));
// Output: [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

7. Hashing

Hashing is a technique that uses a hash table for efficient lookups. It’s ideal for problems involving frequency counts or quick data retrieval.

Example: Finding the First Non-Repeating Character

function firstNonRepeatingChar(str) {
  const charCount = {};

  for (let char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }

  for (let char of str) {
    if (charCount[char] === 1) return char;
  }

  return null;
}

console.log(firstNonRepeatingChar('swiss')); // Output: 'w'

Conclusion

Understanding these problem-solving techniques and patterns in JavaScript will significantly enhance your ability to tackle coding challenges effectively. By mastering these approaches, you can write better code, optimize solutions, and ace programming interviews. Start practicing these patterns to build a strong foundation in problem-solving.

Happy Coding!

Programming Tips