If you're looking for a job in software development, then you need to be able to solve the coding challenges listed below.

These problems are commonly asked in interview questions. Knowing how to solve them gives you some advantage over your competitors!

Let's dive in.

# 1. Fizz Buzz

**Problem:**  

Write a program that prints the numbers from 1 to 100. But for multiples of 3, print "Fizz" instead of the number, and for multiples of 5, print "Buzz". For numbers that are multiples of both 3 and 5, print "FizzBuzz".

**Solution:**

```js
const myFunction = () => {
  for (let i = 0; i < 100; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log("FizzBuzz");
    } else if (i % 3 === 0) {
      console.log("Fizz");
    } else if (i % 5 === 0) {
      console.log("Buzz");
    } else {
      console.log(i);
    }
  }
};

myFunction();
```

In the above solution, we used a simple `for loop` to count numbers from `1-100`. Then, an `if else` conditional statement to check if the number meets the desired criteria from the problem.

*Note:*
To run the above script, you must have an installed nodejs runtime environment in your system. Then simply type `node` plus the name of your script like so: `node script.js`.

# 2. Palindrome

*What is a palindrome?*  

A palindrome is a word or phrase that reads the same forward and backward, such as *racecar*, *radar* or *kayak*.

**Problem:**

Check if a given string is a palindrome.  

**Solution:**

```js
const myFunction = (input) => {
  // reverse the string
  let reverse_input = "";
  for (let i = input.length - 1; i >= 0; i--) {
    reverse_input += input[i];
  }
  // check if the input string and the reversed string is equal
  if (input === reverse_input) {
    console.log("A palindrome!");
  } else {
    console.log("Not a palindrome!");
  }
};

// to use prompt function, run this script in the browser
// you can do so by attaching this script to an html file
let input_string = prompt("Enter a string: ");
myFunction(input_string);
```

The `prompt` function in the above code can only be executed in the browser or else you'll encounter an error. Therefore, to run this script, you must reference it to an `html` file like so: `    <script src="script.js"></script>`.

In the above code, we use `prompt` to accept a string input from the user. Then, we call a function to check if the input string is a palindrom or not.

The first step of the function reverses the input string. This is done by using a `for loop` to iterate from the last letter of a string to the first letter.

Then, we assign it to a new variable, `reverse_input`. We then check if `reverse_input` is equal to the input string by using an `if else` conditional statement. *Beautiful, isn'it?* 😅

# 3. Anagram

*Fun fact:* When you search the word `anagram` in google, it somehow suggest you a phrase, `nag a ram`. This is a lighthearted feature from google to show you how an `anagram` works. 😉

**Problem:**

Write a program to check if a given string is an anagram of another string.

**Solution:**

```js
const myFunction = (string_one, string_two) => {
  let sorted_one = string_one.split("").sort().join("");
  let sorted_two = string_two.split("").sort().join("");

  if (sorted_one === sorted_two) {
    console.log("An anagram!");
  } else {
    console.log("Not an anagram!");
  }
};

let input_string_one = prompt("Enter the first string: ");
let input_string_two = prompt("Enter the second string: ");

myFunction(input_string_one, input_string_two);
```

Note that the solution above only works for one word anagram. It will not work on an anagram that includes phrases.

First, we use the `prompt` function in the browser to accept user inputs. Then we call the function to check if the two input string are anagrams of each other.

We use the built-in function from JavaScript,`split("")`, to convert the string into an array of substrings. For instance, the word `great` will become `['g', 'r', 'e', 'a', 't']`.

Then, using the function `sort()`, we arrange the letters in alphabetical order, like so: `['a', 'e', 'g', 'r', 't']`.

Finally, the `join("")` function will convert the array back to a string, like so: `aegrt`.

Then, to check if it is an anagram or not, we use an `if else` statement to check their equality.

# 4. Count Vowels

The vowels in the alphabet are `a, e, i, o, u`.

**Problem:**

Create a program to print the number of vowels in an input string.

**Solution:**

```js
const myFunction = (input) => {
  let vowelCount = 0;
  for (let char of input) {
    if ("aieou".includes(char)) vowelCount++;
  }
  console.log(vowelCount);
};

let input_string = prompt("Enter a string: ");

myFunction(input_string);
```

Again, we use the `prompt` function to accept user input.

Then, we call the function to count the number of vowels in the input string.

The variable `vowelCount`, will store the number of vowels, `'a', 'i', 'e', 'o', 'u'`, that is present in the input string.

We use the `for of` loop to iterate on each character in the input string.

The built-in `inlcudes()` function will check if each character in the input string is present in the string of vowels, `aieou`.

For every vowel detected, `vowelCount` will increment.

Finally, we display the final result to the console.

Note that in JavaScript, you must first initialize or define the function before calling it or else you'll get a reference error, like so:

```js
Uncaught ReferenceError: Cannot access 'myFunction' before initialization
```

# 5. Title Case

A title case is simply a phrase or group of words where the first letter of each word begins in capital letters. 

For example, `The Rise Of The Great Developer`.

**Problem:**

Write a JavaScript function to convert a string to title case (capitalize the first letter in each word).

**Solution:**

```js
const myFunction = (input) => {
  // Create a new variable to store an array
  // Convert the input string to lower case
  // And then split it into an array of substring
  let new_arr = input.toLowerCase().split(" ");
  // Using a for loop to iterate in each substring
  // Then, using toUpperCase() function to convert the first letter to upper case
  // And, the slice() function to get the remaining letters from the substring
  // Finally, assign the result to the new array.
  for (let i = 0; i < new_arr.length; i++) {
    new_arr[i] = new_arr[i][0].toUpperCase() + new_arr[i].slice(1);
  }
  // Return back the array of substring into a string using join() function
  return new_arr.join(" ");
};
// Ask for user input
let input_string = prompt("Enter a string: ");
// Call the function to convert a string to title case
let result = myFunction(input_string);
// Display the result to the console
console.log(result);
```

As usual, we ask for a string input from the user using `prompt()` function.

Then we call the function to transform the input string into title case.

Inside the title case function, we start by converting the input string into lower case using `toLowerCase()` and then `split(" ")` function to split it into an array of subtrings.

We use a `for loop` to iterate in each substring. Then, using `toUpperCase()` function to convert the first letter to upper case.

And, the `slice()` function to get the remaining letters from the substring
 
Finally, assign the result to the new array.

This function will convert back the array of substring into a string using `join()` function.

We then print the result into the console in the `console.log(result)`.

# 6. Even or Odd

An even number is any number that is divisible by 2, or else it's an odd number.

**Problem:**

Create a function that will take an integer as an argument and returns `Even` for even numbers and `Odd` for odd numbers.

**Solution:**

```js
const myFunction = input => {
  if (input % 2 === 0) {
    return "Even";
  } else {
    return "Odd";
  }
};
// Ask for user input
let input_integer = prompt("Enter a number: ");
// Call the function to check for even or odd
let result = myFunction(input_integer);
// Display the result to the console
console.log(result);
```
Checking for even or odd number is fairly easy. To check if the number is `Even`, we use a modulo `%` operator to check if the remainder is equal to `0` when the input integer is divided by `2`. Else, the integer is an  `Odd` number.

# 7. Reverse String

Given the string `"I am a good developer"`, the reverse of it will be 
`"repoleved doog a ma I"`.

**Problem:**

Write a program to reverse an input string and then print it to the console.

**Solution:**

```js
const myFunction = (input) => {
  // reverse the string
  let reverse_input = "";
  for (let i = input.length - 1; i >= 0; i--) {
    reverse_input += input[i];
  }
  return reverse_input;
};
// Ask for user input
let input_string = prompt("Enter a string: ");
// Call the function to reverse the string
let result = myFunction(input_string);
// Display the result to the console
console.log(result);
```
Ask the user the string input using `prompt()` function. Then, we call the `myFunction` to convert the input string to its reverse order.

Inside the function, we use a `for loop` to iterate from the last letter of the string to the first letter.

We then assign each letter in reverse to a new variable, `reverse_input`.

This function will then return a string but in reverse order. Finally, we print the result to the console.

# 8. Factorial Calculation

The factorial of a positive integer is the product of all positive integers less than or equal to that number. 

For example, the factorial of 8 is, `40320`.

**Problem:**

Create a program to calculate the factorial of a positive integer.

**Solution:**

```js
const myFunction = (input) => {
  if (input == 0) {
    return 1;
  } else {
    return input * myFunction(input - 1);
  }
};
// Ask for user input
let input_number = prompt("Enter a number: ");
// Call the function to calculate the factorial
let result = myFunction(input_number);
// Display the result to the console
console.log(result);
```

We used a `recursive function` to calculate the factorial of the positive number. A recursive function is where you call the function itself inside the function. 😵

# 9. Fibonacci Sequence

The fibonacci sequence follows the rule that each number is equal to the sum of the preceding two numbers. 

For instance, `0 1 1 2 3 5 8 13 21`...is a fibonacci sequence with 9 terms.

**Problem:**

Implement a JavaScript program that can generate the Fibonacci sequence up to the number of terms entered by the user.

**Solution:**

```js
const myFunction = (input) => {
  let fibo_arr = [0, 1];
  for (let i = 2; i < input; i++) {
    fibo_arr.push(fibo_arr[i - 2] + fibo_arr[i - 1]);
  }
  return fibo_arr;
};
// Ask for user input
let input_number = prompt("Enter a number: ");
// Call the function to generate the fibonacci sequence
let result = myFunction(input_number);
// Display the result to the console
console.log(result);
```

In our solution, we started by initializing an array, `fibo_arr`, that will contain the fibonacci sequence. 

Then, we perform a `for loop` operation to calculate the sum of the preceding numbers up to the number of terms specified by the user. 

Finally, we return the array of fibonacci sequence from the function.

# 10. Find the largest number in an array

Consider the array, `[ 2, 18, 42, 69, 11]`. The largest number in the array is `69`.

**Problem**

Given an array of numbers, find the largest number in the array.

**Solution**

```js
const myFunction = (input) => {
  // Sort the array in increasing order
  input.sort();
  // Return the last element in the array
  return input[input.length - 1];
};

// Ask for user input
let user_input = prompt("Enter an array: ");
// convert user input to an array
let new_array = user_input.split(" ");
// Call the function to find the largest number in the array
let result = myFunction(new_array);
// Display the result to the console
console.log(result);
```

First, we convert the output of `prompt()` into an array using the `split()` function. 

Inside the function, we used the `sort()` method to sort the array in increasing order. 

Finally, we return the last element of the array, which is the largest number.

# 11. Check for Prime Number

A prime number in math is a natural number greater than 1 and is not a product of two smaller natural numbers. 

For instance, `7` is a prime number because the only way of calculating it as a product are `1 x 7` and `7 x 1`.

**Problem:**

Write a program to check if a number is a prime.

**Solution:**

```js
const myFunction = (input) => {
  if (input <= 1) return false;
  for (let i = 2; Math.sqrt(input) >= i; i++) {
    if (input % i === 0) return false;
  }
  return true;
};

// Ask for user input
let user_input = prompt("Enter a number: ");
// Call the function to check for prime number
let result = myFunction(user_input);
// Display the result to the console
console.log(result);
```

The number 0 and 1 are not prime numbers so we start by making a condition on those two numbers. 

We use a loop to iterate from 2 to the square root of the input number. This is because if the input number is not a prime, it must have a divisor less than or equal to its square root.

Within the loop, we use an `if` condition to check if the input is divisible by the current value of `i`. If it's divisible, then the input is not a prime number.

Finally, if the loop is completed without finding any divisor for the input number, we return `true` to suggest that the number is indeed a prime number.

# 12. Sum of all the numbers in an array

Given an array, `[ 1, 2, 3, 4]`; the sum of it will be `10`.

**Problem:**

Create a program to calculate the sum of all the numbers in an array.

**Solution:**

```js
const myFunction = (input) => {
  let sum = 0;
  for (let i = 0; i < input.length; i++) {
    sum += input[i];
  }
  return sum;
};

// Ask for user input
let user_input = prompt("Enter an array: ");
// Convert user input to an array
let new_arr = user_input.split(" ");
// Convert the string element to an integer
let int_arr = new_arr.map((element) => parseInt(element));
// Call the function to calculate sum of the array
let result = myFunction(int_arr);
// Display the result to the console
console.log(result);
```

Note that the output of the `prompt()` function is a string so we need to convert it to an array using `split()`.

However, the elements of the array are still `string`, so we need  to convert each element to an `integer` using `parseInt()` to perform addition. The `map()` function is used to iterate in each element of the array.

Inside the function, we simply used a `for loop`, to iterate and then perform an addition in each element of the array.

Finally, we return the sum. 🍻

# Conclusion

The solution to each problem can be presented in so many ways. You can opt to try these solutions or come up with your own way to solve these coding challenges.

If you have any questions or clarification, feel free to leave a comment below. Cheers!