Algorithm

1. Convert Celsius to Fahrenheit

The algorithm to convert from Celsius to Fahrenheit is the temperature in Celsius times 9/5, plus 32.

You are given a variable celsius representing a temperature in Celsius. Use the variable fahrenheit already defined and assign it the Fahrenheit temperature equivalent to the given Celsius temperature. Use the algorithm mentioned above to help convert the Celsius temperature to Fahrenheit.

convertToF(0) should return a number

convertToF(-30) should return a value of -22

convertToF(-10) should return a value of 14

convertToF(0) should return a value of 32

convertToF(20) should return a value of 68

convertToF(30) should return a value of 86

 
    function convertToF(celsius) {
      let fahrenheit = celsius * (9 / 5) + 32;
      return fahrenheit;
    }

    // Change the inputs below to test your code
    convertToF(30);
 

Note: Learn Maths from here

Click 1

2. Reverse a String

Reverse the provided string.

You may need to turn the string into an array before you can reverse it.

Your result must be a string.

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

ANOTHER 1

 
    function reverseString(str) {
    let reversedStr = "";
    for (let i = str.length - 1; i >= 0; i--) {
        reversedStr += str[i];
    }
    return reversedStr;
    }
    reverseString("hello");
 

3. Factorialize a Number

Return the factorial of the provided integer.

If the integer is represented with the letter n, a factorial is the product of all positive integers less than or equal to n.

Factorials are often represented with the shorthand notation n!

For example: 5! = 1 * 2 * 3 * 4 * 5 = 120

Only integers greater than or equal to zero will be supplied to the function.

 
  function factorialize(num) {
    let product = 1;
    for (let i = 2; i <= num; i++) {
      product *= i;
    }
    return product;
  }

  factorialize(5);
 

or

 
  function factorialize(num) {
    if (num === 0) {
      return 1;
    }
    return num * factorialize(num - 1);
  }

  factorialize(5);
 

or

 
  function factorialize(num, factorial = 1) {
    if (num === 0) {
      return factorial;
    } else {
      return factorialize(num - 1, factorial * num);
    }
  }

  factorialize(5);
 

or

 
  function factorialize(num) {
    return num < 0 ? 1 :
      new Array(num)
        .fill(undefined)
        .reduce((product, _, index) => product * (index + 1), 1);
  }
  factorialize(5);
 

4. Find the Longest Word in a String

Return the length of the longest word in the provided sentence.

Your response should be a number.

 
  function findLongestWordLength(str) {
    let words = str.split(' ');
    let maxLength = 0;

    for (let i = 0; i < words.length; i++) {
      if (words[i].length > maxLength) {
        maxLength = words[i].length;
      }
    }

    return maxLength;
  }
 

or

 
  function findLongestWordLength(s) {
    return s.split(' ')
      .reduce(function(longest, word) {
        return Math.max(longest, word.length)
      }, 0);
  }
 

or

 
  function findLongestWordLength(str) {
    return Math.max(...str.split(" ").map(word => word.length));
  }
 

or

 
    function findLongestWordLength(str) {
      // split the string into individual words
      const words = str.split(" ");

      // words only has 1 element left that is the longest element
      if (words.length == 1) {
        return words[0].length;
      }

      // if words has multiple elements, remove the first element
      // and recursively call the function
      return Math.max(
        words[0].length,
        findLongestWordLength(words.slice(1).join(" "))
      );
    }

    findLongestWordLength("The quick brown fox jumped over 
                            the lazy dog");
 

5. Return Largest Numbers in Arrays

Return an array consisting of the largest number from each provided sub-array. For simplicity, the provided array will contain exactly 4 sub-arrays.

Remember, you can iterate through an array with a simple for loop, and access each member with array syntax arr[i].

  function largestOfFour(arr) {
    return arr;
  }

  largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26],  
 [32, 35, 37, 39], [1000, 1001, 857, 1]]);
 

  function largestOfFour(arr) {
    let results = [];
    for (let i = 0; i < arr.length; i++) {
      let largestNumber = arr[i][0];
      for (let j = 1; j < arr[i].length; j++) {
        if (arr[i][j] > largestNumber) {
          largestNumber = arr[i][j];
        }
      }
      results[i] = largestNumber;
    }

    return results;
  }

or

  function largestOfFour(arr) {
    return arr.map(function(group) {
      return group.reduce(function(prev, current) {
        return current > prev ? current : prev;
      });
    });
  }

or

  function largestOfFour(arr) {
    return arr.map(Function.apply.bind(Math.max, null));
  }

or

 function largestOfFour(arr, finalArr = []) {
    return !arr.length
      ? finalArr
      : largestOfFour(arr.slice(1), finalArr.concat(Math.max(...arr[0])))
  }

6. Confirm the Ending

Check if a string (first argument, str) ends with the given target string (second argument, target).

This challenge can be solved with the .endsWith() method, which was introduced in ES2015. But for the purpose of this challenge, we would like you to use one of the JavaScript substring methods instead.

 
  function confirmEnding(str, target) {
    // "Never give up and good luck will find you."
    // -- Falcor

    return str.slice(str.length - target.length) === target;
  }

  confirmEnding("He has to give me a new name", "name");
 

or

  function confirmEnding(str, target) {
    // "Never give up and good luck will find you."
    // -- Falcor

    let re = new RegExp(target + "$", "i");

    return re.test(str);
  }

  console.log(confirmEnding("Bastian", "n"));

or

  function confirmEnding(str, target) {
    return str.slice(-target.length) === target
  }

  confirmEnding("Bastian", "n");

7. Repeat a String Repeat a String

Repeat a given string str (first argument) for num times (second argument). Return an empty string if num is not a positive number. For the purpose of this challenge, do not use the built-in .repeat() method.

  function repeatStringNumTimes(str, num) {
    let accumulatedStr = "";

    for (let i = 0; i < num; i++) {
      accumulatedStr += str;
    }

    return accumulatedStr;
  }

or

  function repeatStringNumTimes(str, num) {
    if (num < 1) {
      return "";
    } else {
      return str + repeatStringNumTimes(str, num - 1);
    }
  }

or

  function repeatStringNumTimes(str, num) {
    return num > 0 ? str + repeatStringNumTimes(str, num - 1) : '';
  }

8. Truncate a String

Truncate a string (first argument) if it is longer than the given maximum string length (second argument). Return the truncated string with a ... ending.

  function truncateString(str, num) {
    // Clear out that junk in your trunk
    if (str.length > num) {
      return str.slice(0, num) + "...";
    } else {
      return str;
    }
  }

or

  function truncateString(str, num) {
    return str.length > num ? str.slice(0, num) + "..." : str;
  }

9. Finders Keepers

Create a function that looks through an array arr and returns the first element in it that passes a 'truth test'. This means that given an element x, the 'truth test' is passed if func(x) is true. If no element passes the test, return undefined.

  function findElement(arr, func) {
    let num = 0;

    for (let i = 0; i < arr.length; i++) {
      num = arr[i];
      if (func(num)) {
        return num;
      }
    }

    return undefined;
  }

or

  function findElement(arr, func) {
    return arr.find(func);
  } 

or

  function findElement(arr, func) {
    return arr[arr.map(func).indexOf(true)];
  }

or

  function findElement(arr, func) {
    return arr.length && !func(arr[0]) 
      ? findElement(arr.slice(1), func)
      : arr[0];
  }

10. Boo who

Check if a value is classified as a boolean primitive. Return true or false.

Boolean primitives are true and false.

Hint 1

You will need to check for the type of the parameter to see if it is a boolean.

Hint 2

To check for the type of a parameter, you can use typeof.

Hint 3

Since you must return true or false you can use if statements or just have it return the boolean used for the if statement.

  function booWho(bool) {
    return typeof bool === "boolean";
  }

  // test here
  booWho(null);

12. Title Case a Sentence

Return the provided string with the first letter of each word capitalized. Make sure the rest of the word is in lower case.

For the purpose of this exercise, you should also capitalize connecting words like the and of.

Hint 1

You chould start by splitting the string into an array of words.

Hint 2

You should make the word lowercase and make the first letter uppercase.

Hint 3

You will need to create a new string with pieces of the updated words.

  function titleCase(str) {
    const newTitle = str.split(" ");
    const updatedTitle = [];
    for (let st in newTitle) {
      updatedTitle[st] = newTitle[st][0].toUpperCase() + newTitle[st].slice(1).toLowerCase();
    }
    return updatedTitle.join(" ");
  }

or

  function titleCase(str) {
    return str
      .toLowerCase()
      .split(" ")
      .map(val => val.replace(val.charAt(0), val.charAt(0).toUpperCase()))
      .join(" ");
  }

  titleCase("I'm a little tea pot");

or

  function titleCase(str) {
    return str
      .toLowerCase()
      .replace(/(^|\s)\S/g, L => L.toUpperCase());
  }

13. Slice and Splice

You are given two arrays and an index.

Copy each element of the first array into the second array, in order.

Begin inserting elements at index n of the second array.

Return the resulting array. The input arrays should remain the same after the function runs.

  function frankenSplice(arr1, arr2, n) {
    // It's alive. It's alive!
    let localArray = arr2.slice();
    for (let i = 0; i < arr1.length; i++) {
      localArray.splice(n, 0, arr1[i]);
      n++;
    }
    return localArray;
  }

or

  function frankenSplice(arr1, arr2, n) {
    // It's alive. It's alive!
    let localArr = arr2.slice();
    localArr.splice(n, 0, ...arr1);
    return localArr;
  }

14. Falsy Bouncer

Remove all falsy values from an array.

Falsy values in JavaScript are false, null, 0, "", undefined, and NaN.

Hint: Try converting each value to a Boolean.

  function bouncer(arr) {
    let newArray = [];
    for (let i = 0; i < arr.length; i++) {
      if (arr[i]) newArray.push(arr[i]);
    }
    return newArray;
  }

or

  function bouncer(arr) {
    return arr.filter(Boolean);
  }

15. Where do I Belong

Return the lowest index at which a value (second argument) should be inserted into an array (first argument) once it has been sorted. The returned value should be a number.

For example, getIndexToIns([1,2,3,4], 1.5) should return 1 because it is greater than 1 (index 0), but less than 2 (index 1).

Likewise, getIndexToIns([20,3,5], 19) should return 2 because once the array has been sorted it will look like [3,5,20] and 19 is less than 20 (index 2) and greater than 5 (index 1).

  function getIndexToIns(arr, num) {
    arr.sort((a, b) => a - b);

    for (let i = 0; i < arr.length; i++) {
      if (arr[i] >= num)
        return i;
    }

    return arr.length;
  }

or

  function getIndexToIns(arr, num) {
    return arr.filter(val => num > val).length;
  }

or

  function getIndexToIns(arr, num) {
    // sort and find right index
    let index = arr
      .sort((curr, next) => curr - next)
      .findIndex(currNum => num <= currNum);
    // Returns index or total length of arr
    return index === -1 ? arr.length : index;
  }

  getIndexToIns([40, 60], 500);

or

  function getIndexToIns(arr, num) {
    return arr
      .concat(num)
      .sort((a, b) => a - b)
      .indexOf(num);
  }

  getIndexToIns([1, 3, 4], 2);

16. Mutations

Return true if the string in the first element of the array contains all of the letters of the string in the second element of the array.

For example, ["hello", "Hello"], should return true because all of the letters in the second string are present in the first, ignoring case.

The arguments ["hello", "hey"] should return false because the string hello does not contain a y.

Lastly, ["Alien", "line"], should return true because all of the letters in line are present in Alien.

  function mutation(arr) {
    let test = arr[1].toLowerCase();
    let target = arr[0].toLowerCase();
    for (let i = 0; i < test.length; i++) {
      if (target.indexOf(test[i]) < 0) return false;
    }
    return true;
  }

`or`

  function mutation(arr) {
    return arr[1]
      .toLowerCase()
      .split("")
      .every(function(letter) {
        return arr[0].toLowerCase().indexOf(letter) !== -1;
      });
  }

`or`

  function mutation([ target, test ], i = 0) {
    target = target.toLowerCase();
    test = test.toLowerCase();
    return i >= test.length
      ? true
      : !target.includes(test[i])
        ? false
        : mutation([ target, test ], i + 1);
  }

17.

Chunky Monkey

Write a function that splits an array (first argument) into groups the length of size (second argument) and returns them as a two-dimensional array.

  function chunkArrayInGroups(arr, size) {
    let temp = [];
    let result = [];

    for (let a = 0; a < arr.length; a++) {
      if (a % size !== size - 1) temp.push(arr[a]);
      else {
        temp.push(arr[a]);
        result.push(temp);
        temp = [];
      }
    }

    if (temp.length !== 0) result.push(temp);
    return result;
  }

  function chunkArrayInGroups(arr, size) {
    // Break it up.
    let newArr = [];
    for (let i = 0; i < arr.length; i += size) {
      newArr.push(arr.slice(i, i + size));
    }
    return newArr;
  }

or

  function chunkArrayInGroups(arr, size) {
    // Break it up.
    let newArr = [];
    let i = 0;

    while (i < arr.length) {
      newArr.push(arr.slice(i, i + size));
      i += size;
    }
    return newArr;
  }
  chunkArrayInGroups(["a", "b", "c", "d"], 2);

or

  function chunkArrayInGroups(arr, size) {
    let newArr = [];
    while (arr.length > 0) {
      newArr.push(arr.splice(0, size));
    }
    return newArr;
  }

or

  function chunkArrayInGroups(arr, size) {
    if (arr.length <= size) {
      return [arr];
    } else {
      return [arr.slice(0, size)].concat(
        chunkArrayInGroups(arr.slice(size), size)
      );
    }
  }

Basic Algorithm JS by Fcc

Algorithm

1.

Convert Celsius to Fahrenheit