Add the .js files

Author: mdaz78

caesarsCipher.js

@@ -0,0 +1,34 @@
+// One of the simplest and most widely known ciphers is a Caesar cipher, also known as a shift cipher. In a shift cipher the meanings of the letters are shifted by some set amount.
+//
+// A common modern use is the ROT13 cipher, where the values of the letters are shifted by 13 places. Thus 'A' ↔ 'N', 'B' ↔ 'O' and so on.
+//
+// Write a function which takes a ROT13 encoded string as input and returns a decoded string.
+//
+// All letters will be uppercase. Do not transform any non-alphabetic character (i.e. spaces, punctuation), but do pass them on.
+
+function rot13(str) {
+    var strLength = str.length;
+    var count = 0;
+    var result = "";
+    var check;
+
+    while(count < strLength) {
+        check = 0;
+        if (str.charCodeAt(count) < 65 || str.charCodeAt(count) > 90) {
+            result = result.concat(str[count]);
+        } else {
+            check = str.charCodeAt(count) + 13;
+            if (check > 90) {
+                check = str.charCodeAt(count) - 13;
+                result = result.concat(String.fromCharCode(check));
+            } else {
+                result = result.concat(String.fromCharCode(check));
+            }
+        }
+        count++;
+    }
+
+    return result;
+}
+
+console.log(rot13("SERR PBQR PNZC")); // "FREE CODE CAMP"

checkPalindromes.js

@@ -0,0 +1,29 @@
+// Return true if the given string is a palindrome. Otherwise, return false.
+//
+// A palindrome is a word or sentence that's spelled the same way both forward and backward, ignoring punctuation, case, and spacing.
+//
+// Note
+// You'll need to remove all non-alphanumeric characters (punctuation, spaces and symbols) and turn everything lower case in order to check for palindromes.
+//
+// We'll pass strings with varying formats, such as "racecar", "RaceCar", and "race CAR" among others.
+//
+// We'll also pass strings with special symbols, such as "2A3*3a2", "2A3 3a2", and "2_A3*3#A2".
+
+
+function palindrome(str) {
+    str = str.toLowerCase();
+    str = str.replace(/[^a-z0-9]/g, '');
+    var strArr = str.split('');
+    var lenOfStrArr = strArr.length;
+
+    for (var i = 0, j = lenOfStrArr - 1; i < lenOfStrArr / 2; i++, j--) {
+        if (strArr[i] != strArr[j]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+
+console.log(palindrome(" eye"));

chunkyMonkey.js

@@ -0,0 +1,16 @@
+// 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) {
+    var counter = 0;
+    var resultArr = [];
+
+    while (counter < arr.length) {
+        resultArr.push(arr.slice(counter, counter += size));
+    }
+
+    return resultArr;
+}
+
+console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2));

confirmTheEnding.js

@@ -0,0 +1,20 @@
+// 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) {
+    var lenOfTarget = target.length;
+    var strEnding = str.slice(-lenOfTarget);
+    var targetArr = target.split('');
+    var strEndingArr = strEnding.split('');
+
+    for(var i = 0; i < lenOfTarget; i++) {
+        if (strEndingArr[i] != targetArr[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+console.log(confirmEnding("Bastian", "an"));

factorializeANumber.js

@@ -0,0 +1,16 @@
+// 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
+
+function factorialize(num) {
+    if (num === 0) {
+        return 1;
+    }
+    return factorialize(num - 1) * num;
+}
+
+console.log(factorialize(5));

falsyBounce.js

@@ -0,0 +1,10 @@
+// Remove all falsy values from an array.
+//
+// Falsy values in JavaScript are false, null, 0, "", undefined, and NaN.
+//
+
+function bouncer(arr) {
+    return arr.filter(Boolean);
+}
+
+console.log(bouncer([7, "ate", "", false, NaN, , "false", 9]));

findTheLongestWordInAString.js

@@ -0,0 +1,21 @@
+// Return the length of the longest word in the provided sentence.
+//
+// Your response should be a number.
+
+
+function findLongestWord(str) {
+    var strArr = str.split(' ');
+    var lenOfStrArr = strArr.length;
+    var max = 0;
+
+    for (var i = 0; i < lenOfStrArr; i++) {
+        if(strArr[i].length > max) {
+            max = strArr[i].length;
+
+        }
+    }
+
+    return max;
+}
+
+console.log(findLongestWord("The quick brown fox jumped over the lazy dog"));

mutations.js

@@ -0,0 +1,39 @@
+// 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) {
+    var input = arr[0].toLowerCase();
+    var check = arr[1].toLowerCase();
+
+    var inputArr = input.split('');
+    var checkArr = check.split('');
+
+    var validate = true;
+
+    for (var i = 0; i < checkArr.length; i++) {
+        validate = false;
+        for (var j = 0; j < inputArr.length; j++) {
+            if(checkArr[i] == inputArr[j]) {
+                validate = true;
+                break;
+            } else {
+                validate = false;
+            }
+        }
+
+        if (!validate) {
+            return false;
+        }
+    }
+
+    return true;
+
+}
+
+console.log(mutation(["hello", "hel"]));

repeatAString.js

@@ -0,0 +1,14 @@
+// Repeat a given string (first argument) num times (second argument). Return an empty string if num is not a positive number.
+
+
+function repeatStringNumTimes(str, num) {
+    var resultArr = [];
+
+    for (var i = 0; i < num; i++) {
+        resultArr.push(str);
+    }
+    return resultArr.join("");
+
+}
+
+console.log(repeatStringNumTimes("abc", 3));

returnLargestNumbersInArray.js

@@ -0,0 +1,23 @@
+// 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) {
+    var max;
+    var resultArr = [];
+
+    for (var outerArr = 0; outerArr < arr.length; outerArr++) {
+        max = 0;
+        for (var innerArr = 0; innerArr < arr[outerArr].length; innerArr++) {
+            if (arr[outerArr][innerArr] > max) {
+                max = arr[outerArr][innerArr];
+            }
+        }
+        resultArr.push(max);
+    }
+    return resultArr;
+}
+
+console.log(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]));

reverseAString.js

@@ -0,0 +1,8 @@
+function reverseString(str) {
+    var strArr = str.split('');
+    strArr.reverse();
+    var result = strArr.join('');
+    return result;
+}
+
+console.log(reverseString("hello"));

seekAndDestroy.js

@@ -0,0 +1,33 @@
+// You will be provided with an initial array (the first argument in the destroyer function), followed by one or more arguments. Remove all elements from the initial array that are of the same value as these arguments.
+function destroyer(arr) {
+    var initialArr = arguments[0];
+    var argsLength = arguments.length;
+
+    var checkArr = [];
+
+    var counter = 1;
+    while(counter < argsLength) {
+        checkArr.push(arguments[counter]);
+        counter++;
+    }
+
+    function remove(val) {
+        var i = 0;
+        var valid = true;
+        while(i < checkArr.length) {
+            if (val !== checkArr[i]) {
+                valid = true;
+            } else {
+                return false;
+            }
+            i++;
+        }
+        return valid;
+    }
+
+    var result = initialArr.filter(remove);
+    return result;
+
+}
+
+console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

slasherFlick.js

@@ -0,0 +1,22 @@
+// Return the remaining elements of an array after chopping off n elements from the head.
+//
+// The head means the beginning of the array, or the zeroth index.
+
+
+function slasher(arr, howMany) {
+    var resultArr = [];
+    var counter = 0;
+
+    while (counter < arr.length) {
+        if(counter < howMany) {
+            counter++;
+        } else {
+            resultArr.push(arr[counter]);
+            counter++;
+        }
+    }
+
+    return resultArr;
+}
+
+console.log(slasher([1, 2, 3], 4));

titleCaseASentence.js

@@ -0,0 +1,19 @@
+// 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".
+
+
+function titleCase(str) {
+    str = str.toLowerCase();
+    var strArr = str.split(" ");
+    var lenOfStrArr = strArr.length;
+    var resultArr = [];
+
+    for(var i = 0; i < lenOfStrArr; i++) {
+        resultArr[i] = strArr[i][0].toUpperCase() + strArr[i].slice(1);
+    }
+
+    return result = resultArr.join(" ");
+}
+
+console.log(titleCase("I'm a little tea pot"));

truncateAString.js

@@ -0,0 +1,19 @@
+// Truncate a string (first argument) if it is longer than the given maximum string length (second argument). Return the truncated string with a ... ending.
+//
+// Note that inserting the three dots to the end will add to the string length.
+//
+// However, if the given maximum string length num is less than or equal to 3, then the addition of the three dots does not add to the string length in determining the truncated string.
+
+
+
+function truncateString(str, num) {
+    if (num < str.length && num > 3) {
+        return str.slice(0, num - 3) + "...";
+    } else if (num >= str.length && num > 3) {
+        return str;
+    } else {
+        return str.slice(0, num) + "...";
+    }
+}
+
+console.log(truncateString("Absolutely Longer", 2));

whereDoIBelong.js

@@ -0,0 +1,26 @@
+// 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) {
+
+    // sort arr in ascending order
+    arr.sort(function(a, b) {
+        return a - b;
+    });
+
+    var counter = 0;
+    while (counter < arr.length) {
+        if (num > arr[counter]) {
+            counter++;
+        } else {
+            return counter;
+        }
+    }
+    return arr.length;
+}
+
+console.log(getIndexToIns([10, 20, 30, 40, 50], 35)); // 3