Top JavaScript Algorithms Coding

Here are ten common JavaScript algorithms that are frequently encountered in coding challenges.

Get Taner Özer’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Two Sum Problem:

• Description: Given an array of integers, return indices of the two numbers such that they add up to a specific target.

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

Reverse a String:

• Description: Reverse the characters of a string.

function reverseString(str) {
  return str.split('').reverse().join('');
}

Palindrome Check:

• Description: Check if a given string is a palindrome.

function isPalindrome(str) {
  const cleanedStr = str.replace(/[^A-Za-z0-9]/g, '').toLowerCase();
  return cleanedStr === cleanedStr.split('').reverse().join('');
}

Fibonacci Sequence:

• Description: Generate the n-th Fibonacci number.

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

Factorial Calculation:

• Description: Compute the factorial of a number.

function factorial(n) {
  if (n === 0) return 1;
  return n * factorial(n - 1);
}

Binary Search:

• Description: Implement binary search on a sorted array.

function binarySearch(arr, target) {
  let left = 0, 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;
}

Merge Sort:

• Description: Implement merge sort algorithm.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  return merge(left, right);
}
function merge(left, right) {
  const result = [];
  while (left.length && right.length) {
    if (left[0] < right[0]) result.push(left.shift());
    else result.push(right.shift());
  }
  return result.concat(left, right);
}

Check if Two Strings are Anagrams:

• Description: Given two strings, check if they are anagrams of each other.

function areAnagrams(str1, str2) {
  if (str1.length !== str2.length) return false;
  const sortedStr1 = str1.split('').sort().join('');
  const sortedStr2 = str2.split('').sort().join('');
  return sortedStr1 === sortedStr2;
}

Group Anagrams:

• Description: Given an array of strings, group the anagrams together.

function groupAnagrams(strs) {
  const map = new Map();
  for (let str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map.has(sortedStr)) {
      map.set(sortedStr, []);
    }
    map.get(sortedStr).push(str);
  }
  return Array.from(map.values());
}

Anagram Substring Search:

• Description: Given a text and a pattern, find all starting indices in the text where the pattern is an anagram of a substring.

function findAnagrams(s, p) {
  const result = [];
  const pCount = Array(26).fill(0);
  const sCount = Array(26).fill(0);
  const aCharCode = 'a'.charCodeAt(0);

  for (let char of p) {
    pCount[char.charCodeAt(0) - aCharCode]++;
  }

  for (let i = 0; i < s.length; i++) {
    sCount[s[i].charCodeAt(0) - aCharCode]++;
    if (i >= p.length) {
      sCount[s[i - p.length].charCodeAt(0) - aCharCode]--;
    }
    if (arraysEqual(sCount, pCount)) {
      result.push(i - p.length + 1);
    }
  }
  return result;
}

function arraysEqual(arr1, arr2) {
  for (let i = 0; i < arr1.length; i++) {
    if (arr1[i] !== arr2[i]) return false;
  }
  return true;
}

Max Character Count in a String (Most Frequent Character)

• This involves finding the character that appears most frequently in a string.

function maxCharCount(str) {
    const charMap = {};
    let maxChar = '';
    let maxCount = 0;

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

    for (let char in charMap) {
        if (charMap[char] > maxCount) {
            maxCount = charMap[char];
            maxChar = char;
        }
    }

    return maxChar;
}

Title case refers to capitalizing the first letter of each word in a string while converting all other letters to lowercase. Here’s a JavaScript function to convert a given string to title case:

function titleCase(str) {
    return str
        .toLowerCase()
        .split(' ')
        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
        .join(' ');
}

// Example usage:
const myString = "hello world! this is an example.";
const titleCasedString = titleCase(myString);
console.log(titleCasedString); // Outputs: "Hello World! This Is An Example."

Thank you for reading :)

dxtaner (Taner Özer)
https://medium.com/@dxtaner
Taner Özer | LinkedIn