5 JavaScript coding interview questions - Part 8

#javascript #algorithms #interview #career

Q1: Find the Intersection of Two Arrays.
Write a function that returns the common elements between two arrays.
Ans:

function arrayIntersection(arr1, arr2) {
  return arr1.filter(item => arr2.includes(item));
}

console.log(arrayIntersection([1, 2, 3, 4], [3, 4, 5, 6])); 
// Output: [3, 4]

🧠 Tip: Use Set for better performance with large datasets.

Q2: Capitalize the First Letter of Each Word.
Write a function that takes a sentence and capitalizes the first letter of each word.
Ans:

function capitalizeWords(sentence) {
  return sentence
    .split(" ")
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(" ");
}

console.log(capitalizeWords("hello world from javascript"));
// Output: "Hello World From Javascript"

Q3: Count the Frequency of Each Element in an Array
Write a function that counts how many times each element appears in an array.
Ans:

function countFrequency(arr) {
  return arr.reduce((acc, item) => {
    acc[item] = (acc[item] || 0) + 1;
    return acc;
  }, {});
}

console.log(countFrequency(["apple", "banana", "apple", "orange", "banana", "apple"]));
// Output: { apple: 3, banana: 2, orange: 1 }

Q4: Check if Two Strings Are Anagrams
Write a function to check whether two strings are anagrams of each other.
Ans:
Anagrams are words or phrases that can be rearranged to make an entirely different word or phrase.

function isAnagram(str1, str2) {
  const normalize = str => str.toLowerCase().split("").sort().join("");
  return normalize(str1) === normalize(str2);
}

console.log(isAnagram("listen", "silent")); // true
console.log(isAnagram("hello", "world"));   // false

💡 Explanation:
We normalize both strings by converting them to lowercase, sorting, and comparing.
If both sorted versions match — they’re anagrams!

Q5: Chunk an Array
Write a function that splits an array into chunks of a specified size.
Ans:

function chunkArray(arr, size) {
  let result = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3));
// Output: [[1, 2, 3], [4, 5, 6], [7]]

💡 Explanation:
This is the core part of the loop that allows the function to chunk the array efficiently. Let’s go step by step 👇
for (let i = 0; i < arr.length; i += size)

🧩 1. Normal for-loop structure
A typical for loop looks like this:
for (initialization; condition; increment) { // code to execute }
Here:

initialization — sets up a variable (like let i = 0)
condition — loop continues while this is true
increment — runs after each loop iteration (to move to the next step)

🧠 2. In this code:
for (let i = 0; i < arr.length; i += size)

let i = 0 → start from index 0
i < arr.length → keep looping until i reaches the end of the array
i += size → instead of increasing i by 1, we increase it by size That means each time, the loop jumps forward by size elements.

💡 3. Example to visualize
Suppose:

arr = [1, 2, 3, 4, 5, 6, 7]
size = 3

Here’s how the loop runs:

Iteration	`i` Value	Slice (`arr.slice(i, i + size)`)	Result
1	0	arr.slice(0, 3) → `[1, 2, 3]`	result = `[[1,2,3]]`
2	3	arr.slice(3, 6) → `[4, 5, 6]`	result = `[[1,2,3],[4,5,6]]`
3	6	arr.slice(6, 9) → `[7]`	result = `[[1,2,3],[4,5,6],[7]]`