Tony Kharioki

Posted on

# Js Interviews... and how to. (part 2)

Recap

Last week I dropped a write up on acing JS interviews and common questions you may encounter. You can find part 1 here.

As usual, if you happen to me up with better, more effective, or even other solutions to these challenges, remember to make a pull request on the github repo.

### Challenges continuation...

Once again, the solutions and explanation given in the challenges below, assume that you have a basic understanding of Javascript and especially data types. The challenges below focus on arrays and strings.

Challenge 7 - Longest Word

Return the longest word of a string. Given a sentence write a function that returns the longest word in the sentence. If multiple words, return an array of these words.

``````function longestWord(sen) {
//? SOLUTION 1 - Return a single longest word
// strip punctuation and create filtered array
const wordArr = sen.toLowerCase().match(/[a-z0-9]+/g);
// sort by length
const sorted = wordArr.sort((a, b) => b.length - a.length);
// return longest word
return sorted[0];

}
``````
``````function longestWord(sen) {
//? SOLUTION 2 - Return an array and include multiple words if they have the same length
const wordArr = sen.toLowerCase().match(/[a-z0-9]+/g);
const sorted = wordArr.sort((a, b) => b.length - a.length);
const longestWordArr = sorted.filter(
word => word.length === sorted[0].length
);
return longestWordArr;
}
``````
``````function longestWord(sen) {
//? SOLUTION 3 - Return an array if multiple and single string if only one
const wordArr = sen.toLowerCase().match(/[a-z0-9]+/g);
const sorted = wordArr.sort((a, b) => b.length - a.length);
const longestWordArr = sorted.filter(
word => word.length === sorted[0].length
);

if (longestWordArr.length > 1) {
return longestWordArr;
} else {
return longestWordArr[0];
}
}
``````

Challenge 8 - Chunking arrays

Given an array and a length of n, split the array into chunked arrays of length n.

``````function chunkArray(arr, len) {
//? SOLUTION 1 - using while loop
const chunkedArr = [];
// set index
let i = 0;

// loop while index is less than array lenngth
while (i < arr.length) {
// slice out from the index to the index + the chink length and push on to the chunked array
chunkedArr.push(arr.slice(i, i + len));
// Increment by chunk length
i += len;
}
// return chunked array
return chunkedArr;
}
``````

the second solution is quite a handful, and it may take a while to understand it

``````function chunkArray(arr, len) {
//? solution 2
// init an empty array
const chunkd = [];
// Loop through the arr
arr.forEach(val => {
// Get last element
const last = chunkd[chunkd.length - 1];
// Check if last and if last length is equal to the chunk len
if (!last || last.length === len) {
chunkd.push([val]);
} else {
last.push(val);
}
});

return chunkd;
}
``````

Challenge 9 - Flattening arrays

Given an array of arrays, flatten to a single array

``````function flattenArray(arrays) {
//? Solution 1 - using reduce
return arrays.reduce((a, b) => a.concat(b));
}
``````

solution 2, using apply method. (Fun fact: I actually learnt this recently. I am not sure I still understand it)

``````function flattenArray(arrays) {
//? Solution 2 - apply method
return [].concat.apply([], arrays);
}
``````

solution 3, using es2015's spread operator

``````function flattenArray(arrays) {
//? Solution 3 - spread operator
return [].concat(...arrays);
}
``````

Challenge 10 - Anagram

Given two string values, return true if anagram both are anagrams of each other.
According to Wikipedia, an anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once. e.g dormitory and dirty room, or elbow and below
This particular solution uses a helper function to compare both strings. We start by making a helper function...

``````// Helper function
function formatStr(str) {
return (
str
// remove all characters that are not word characters
.replace(/[^\w]/g, '')
// lowercase
.toLowerCase()
// extract each character to form an array
.split('')
// sort all characters
.sort()
// form a string again
.join('')
);
}
``````

then we compare both strings

``````function isAnagram(str1, str2) {
// using the formatStr helper function, compare both strings
return formatStr(str1) === formatStr(str2);
}
``````

Challenge 11 - Letter changes

Given a string, change every letter of the string to the one that follows it and capitalize the vowels. This solution uses regex to replace character codes and uppercase vowels

``````function letterChanges(str) {
// using regex
let newStr = str
// lowercase everything
.toLowerCase()
// replace characters
.replace(/[a-z]/gi, char => {
// if character is 'z' or 'Z' return 'a'
if (char === 'z' || char === 'Z') {
return 'a';
} else {
// every character has a character code, so we increse it by 1
return String.fromCharCode(char.charCodeAt() + 1);
}
});

// uppercase the vowels
newStr = newStr.replace(/a|e|i|o|u/gi, vowel => vowel.toUpperCase());

return newStr;
}
``````

Well this is getting quite long, let's continue in part 3. Coming soon.
Until then, have a great time.