Coding interview challenges
Tags: challenge, javascript, codingchallenge
Published: 2020-08-30 18:13:00

There is common interview process by asking you  to solve the challenges on online platform or on the whiteboard.  Here are 5 common interview questions for javaScript or front-end Junior Developer position.

###Tacke Code Challege
+ Put in the time to prepare
You should practice the code challenges online for algorithms and data structures as much as possible.  These are free and paid for practice interview skill [Pramp](https://www.pramp.com/dashboard#/m), 
 [interviewing.io](https://interviewing.io/), 
[GeeksforGeeks](https://www.geeksforgeeks.org/), [CodeSignal](https://codesignal.com/), [Skilled](https://www.skilledinc.com/app/home), [Interview Cake](https://www.interviewcake.com/), [HackerRank](https://www.hackerrank.com/), [freeCodeCamp](https://www.freecodecamp.org/news/). 

+ Practice thinking alound
Talking through your thought process in an interview while writing your solution.  This will help interview a chance to help you if you make a wrong answer. It's also showed your communication skills.

+ Understand the problem before starting to code
This is important because it will save your time to solve the wrong problem and you may come up with questions for the interviewer.

+ Pracice writing code hand
This helps you get familiar with the whiteboard challenge because it will not provide autocomplete, format, error warning, etc. Try to write from left to right on the whiteboard and leave space so you can fill in more details.


###Common Coding Javascript Challenges

###1 Palindrome
A [palindrome](https://www.sitepoint.com/5-common-coding-interview-challenges/) is a word, sentence, or another type of character sequence which reads the same backward as forward. For example, “racecar” and “Anna” are palindromes. “Table” and “John” aren’t palindromes, because they don’t read the same from left to right and from right to left.


You will be provided a string and return `true` or `false`.

```javascript
palindrome('racecar')  ===  true
palindrome('table')  ===  false
```
###Reasoning about the challenge
This challenge revolves around the idea of reversing a string. If the reversed string is the same as the original input string, then you have a palindrome and your function should return true or return false otherwise.

###[Solution 1](https://www.sitepoint.com/5-common-coding-interview-challenges/)
```javascript
const palindrome = str => {
  // turn the string to lowercase
  str = str.toLowerCase()
  // reverse input string and return the result of the
  // comparison
  return str === str.split('').reverse().join('')
}
```
###Solution 2
```javascript
function palindrom(inputString) {
  let str = ""
  //copy from the end to front of input string
  for(let i = inputString.length; i >=0; i--) 
      str += inputString.charAt(i)
  //return true if both strings are matched
  return str === inputString
}
```
###Solution 3
```javascript
function palindrome(str) {
 
  str = str.replace(/[\W_]/g, '').toLowerCase();
	for (var i = 0, len = str.length -1; i < len/2; i ++){
		if (str[i] !== str[len-i]){
			return false;
		}
	}
	return true;
 }
	
 palindrome("eye");
```

###2 FizzBuzz

###Understanding the challenge
The FizzBuzz challenge goes something like this. Write a function that does the following:

+ console logs the numbers from 1 to n, where n is the integer the function takes as its parameter
+ logs fizz instead of the number for multiples of 3
+ logs buzz instead of the number for multiples of 5
+ logs fizzbuzz for numbers that are multiples of both 3 and 5

```javascript
fizzBuzz(5)
// 1
// 2
// fizz
// 4
// buzz
```
###Reasoning about the challenge
One important point about FizzBuzz relates to how you can find multiples of a number in JavaScript. You do this using the `modulo or remainder operator`, `%`. This operator returns the remainder after a division between two numbers. A remainder of 0 indicates that the first number is a multiple of the second number

```javascript
12 % 3 //0
12 % 5 //2
```
###[Solution 1](https://www.sitepoint.com/5-common-coding-interview-challenges/)
```javascript
const fizzBuzz = num => {
  for(let i = 1; i <= num; i++) {
    // check if the number is a multiple of 3 and 5
    if(i % 3 === 0 && i % 5 === 0) {
      console.log('fizzbuzz')
    } // check if the number is a multiple of 3
      else if(i % 3 === 0) {
      console.log('fizz')
    } // check if the number is a multiple of 5
      else if(i % 5 === 0) {
      console.log('buzz')
    } else {
      console.log(i)
    }
  }
}
```
###Solution 2
```javascript
const fizzBuzz = num => {
  for (let i = 0; i < num; i++){
    let output = ""
    if (n % 3 == 0) output +="Fizz"
    if (n % 5 == 0) output +="Buzz"
    console.log(output)
  }
}
```

###3 Anagram
A word is an anagram of another word if both use the same letters in the same quantity, but arranged differently.

###Understanding the challenge
You can state this challenge in the following terms: write a function that checks if two provided strings are anagrams of each other; letter casing shouldn’t matter. Also, consider only characters, not spaces or punctuation

```javascript
anagram('finder', 'Friend')  // true
anagram('hi', 'hello') // false
```

We can use javascript object literal to calculate the number of letters of both strings.  The key is letter character and value is the number of times that letter appears in the given string. Converting string to lower case or upper case. removing any that isn't a character by using `regular expression`

###[Solution](https://www.sitepoint.com/5-common-coding-interview-challenges/)
```javascript
// helper function that builds the
// object to store the data
const buildCharObject = str => {
  const charObj = {}
  for(let char of str.replace(/[^\w]/g).toLowerCase()) {
    // if the object has already a key value pair
    // equal to the value being looped over,
    // increase the value by 1, otherwise add
    // the letter being looped over as key and 1 as its value
    charObj[char] = charObj[char] + 1 || 1
  }
  return charObj
}

// main function
const anagram = (strA, strB) => {
  // build the object that holds strA data
  const aCharObject = buildCharObject(strA)
  // build the object that holds strB data
  const bCharObject = buildCharObject(strB)

  // compare number of keys in the two objects
  // (anagrams must have the same number of letters)
  if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
    return false
  }
  // if both objects have the same number of keys
  // we can be sure that at least both strings
  // have the same number of characters
  // Now we can compare the two objects to see if both
  // have the same letters in the same amount
  for(let char in aCharObject) {
    if(aCharObject[char] !== bCharObject[char]) {
      return false
    }
  }
  // if both the above checks succeed,
  // you have an anagram: return true
  return true
}
```

###4 Find the Vowels
###Understanding the challenge

A function that takes a string as argument and returns the number of vowels contained in that string.

The vowels are “a”, “e”, “i”, “o”, “u”.
```javascript
findVowels('there') // 2
findVowels('why') // 0
```
###[Solution](https://www.sitepoint.com/5-common-coding-interview-challenges/)

```javascript
const findVowels = str => {
  let count = 0
  const vowels = ['a', 'e', 'i', 'o', 'u']
  for(let char of str.toLowerCase()) {
    if(vowels.includes(char)) {
      count++
    }
  }
  return count
}
```

###5 Fibonacci
This article couldn’t be complete without a discussion of the Fibonacci challenge, a classic question you’ll surely come across during a job interview or coding practice.

A Fibonacci sequence is an ordering of numbers where each number is the sum of the preceding two. For example, the first ten numbers of the Fibonacci sequence are: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34.

###Understanding the challenge
The Fibonacci challenge goes something like this: write a function that returns the nth entry in the Fibonacci sequence, where n is a number you pass in as argument to the function.

```javascript
fibonacci(3)  // --> 2
```

###[Solution 1](https://www.sitepoint.com/5-common-coding-interview-challenges/)
```javascript
const fibonacci = num => {
  // store the Fibonacci sequence you're going
  // to generate inside an array and
  // initialize the array with the first two
  // numbers of the sequence
  const result = [0, 1]

  for(let i = 2; i <= num; i++) {
    // push the sum of the two numbers
    // preceding the position of i in the result array
    // at the end of the result array
    const prevNum1 = result[i - 1]
    const prevNum2 = result[i - 2]
    result.push(prevNum1 + prevNum2)
  }
  // return the last value in the result array
  return result[num]
}
```
###[Solution 2](https://www.sitepoint.com/5-common-coding-interview-challenges/)
```javascript
const fibonacci = num => {
  // if num is either 0 or 1 return num
  if(num < 2) {
    return num
  }
  // recursion here
  return fibonacci(num - 1) + fibonacci(num - 2)
}
```

*References*
https://www.sitepoint.com/5-common-coding-interview-challenges/