Basic Algorithm Scripting (ex. 1 to 16)

+ Finished Basic Algorithm Scripting module

Author: hgonzaga

06-basic-algorithm-scripting/01-convert-celsius-to-fahrenheit.js

@@ -0,0 +1,19 @@
+/*
+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) {
+    return celsius * (9/5) + 32;
+}
+
+console.log(convertToF(30));

06-basic-algorithm-scripting/02-reverse-a-string.js

@@ -0,0 +1,21 @@
+/*
+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.
+
+- reverseString("hello") should return a string.
+- reverseString("hello") should return the string olleh.
+- reverseString("Howdy") should return the string ydwoH.
+- reverseString("Greetings from Earth") should return the string htraE morf sgniteerG.
+*/
+function reverseString(str) {
+    let finalStr = "";
+    for (let i = str.length - 1; i >= 0; i--) {
+        finalStr += str[i];
+    }
+    return finalStr;
+}
+
+console.log(reverseString("hello"));
+console.log(reverseString("Greetings from Earth"));

06-basic-algorithm-scripting/03-factorialize-a-number.js

@@ -0,0 +1,39 @@
+/*
+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.
+
+- factorialize(5) should return a number.
+- factorialize(5) should return 120.
+- factorialize(10) should return 3628800.
+- factorialize(20) should return 2432902008176640000.
+- factorialize(0) should return 1.
+*/
+function factorialize(num) {
+    let total = 1;
+    while (num >= 1) {
+        total *= num;
+        num--;
+    }
+    return total;
+}
+
+console.log(factorialize(5));
+console.log(factorialize(10));
+console.log(factorialize(20));
+console.log(factorialize(0));
+
+
+function factorializeRecursive(num) {
+    if (num === 0) {
+        return 1;
+    }
+    return num * factorializeRecursive(num - 1);
+}
+console.log(factorializeRecursive(5));
+console.log(factorializeRecursive(10));
+console.log(factorializeRecursive(20));
+console.log(factorializeRecursive(0));

06-basic-algorithm-scripting/04-find-the-longest-word-in-a-string.js

@@ -0,0 +1,26 @@
+/*
+Find the Longest Word in a String
+Return the length of the longest word in the provided sentence.
+Your response should be a number.
+
+- findLongestWordLength("The quick brown fox jumped over the lazy dog") should return a number.
+- findLongestWordLength("The quick brown fox jumped over the lazy dog") should return 6.
+- findLongestWordLength("May the force be with you") should return 5.
+- findLongestWordLength("Google do a barrel roll") should return 6.
+- findLongestWordLength("What is the average airspeed velocity of an unladen swallow") should return 8.
+- findLongestWordLength("What if we try a super-long word such as otorhinolaryngology") should return 19.
+*/
+function findLongestWordLength(str) {
+    let strToArr = str.split(" ");
+    let longestLength = 0;
+    for (let str of strToArr) {
+        if (longestLength < str.length) {
+            longestLength = str.length;
+        }
+    }
+    return longestLength;
+}
+
+console.log(findLongestWordLength("The quick brown fox jumped over the lazy dog"));
+console.log(findLongestWordLength("What is the average airspeed velocity of an unladen swallow"));
+console.log(findLongestWordLength("What if we try a super-long word such as otorhinolaryngology"));

06-basic-algorithm-scripting/05-return-largest-numbers-in-arrays.js

@@ -0,0 +1,12 @@
+/*
+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].
+
+- largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]) should return an array.
+- largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]) should return [27, 5, 39, 1001].
+- largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]) should return [9, 35, 97, 1000000].
+- largestOfFour([[17, 23, 25, 12], [25, 7, 34, 48], [4, -10, 18, 21], [-72, -3, -17, -10]]) should return [25, 48, 21, -3].
+*/
+ 

06-basic-algorithm-scripting/06-confirm-the-ending.js

@@ -0,0 +1,24 @@
+/*
+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.
+
+- confirmEnding("Bastian", "n") should return true.
+- confirmEnding("Congratulation", "on") should return true.
+- confirmEnding("Connor", "n") should return false.
+- confirmEnding("Walking on water and developing software from a specification are easy if both are frozen", "specification") should return false.
+- confirmEnding("He has to give me a new name", "name") should return true.
+- confirmEnding("Open sesame", "same") should return true.
+- confirmEnding("Open sesame", "sage") should return false.
+- confirmEnding("Open sesame", "game") should return false.
+- confirmEnding("If you want to save our world, you must hurry. We dont know how much longer we can withstand the nothing", "mountain") should return false.
+- confirmEnding("Abstraction", "action") should return true.
+- Your code should not use the built-in method .endsWith() to solve the challenge.
+*/
+function confirmEnding(str, target) {
+    return str.substr(str.length - target.length) === target;
+}
+
+console.log(confirmEnding("Bastian", "n"));
+console.log(confirmEnding("Congratulation", "on"));

06-basic-algorithm-scripting/07-repeat-a-string-repeat-a-string.js

@@ -0,0 +1,26 @@
+/*
+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.
+
+- repeatStringNumTimes("*", 3) should return the string ***.
+- repeatStringNumTimes("abc", 3) should return the string abcabcabc.
+- repeatStringNumTimes("abc", 4) should return the string abcabcabcabc.
+- repeatStringNumTimes("abc", 1) should return the string abc.
+- repeatStringNumTimes("*", 8) should return the string ********.
+- repeatStringNumTimes("abc", -2) should return an empty string ("").
+- The built-in repeat() method should not be used.
+- repeatStringNumTimes("abc", 0) should return "".
+*/
+function repeatStringNumTimes(str, num) {
+    let finalStr = "";
+    while (num > 0 ) {
+        finalStr += str;
+        num--;
+    }
+    return finalStr;
+}
+
+console.log(repeatStringNumTimes("abc", 3));
+console.log(repeatStringNumTimes("*", 3));
+console.log(repeatStringNumTimes("abc", -2));

06-basic-algorithm-scripting/08-truncate-a-string.js

@@ -0,0 +1,22 @@
+/*
+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.
+
+- truncateString("A-tisket a-tasket A green and yellow basket", 8) should return the string A-tisket....
+- truncateString("Peter Piper picked a peck of pickled peppers", 11) should return the string Peter Piper....
+- truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length) should return the string A-tisket a-tasket A green and yellow basket.
+- truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2) should return the string A-tisket a-tasket A green and yellow basket.
+- truncateString("A-", 1) should return the string A....
+- truncateString("Absolutely Longer", 2) should return the string Ab....
+*/
+function truncateString(str, num) {
+    return num < str.length ? `${str.substring(0, num)}...` : str;
+}
+
+console.log(truncateString("A-tisket a-tasket A green and yellow basket", 8));
+console.log(truncateString("Peter Piper picked a peck of pickled peppers", 11));
+console.log(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length));
+console.log(truncateString("A-tisket a-tasket A green and yellow basket", "A-tisket a-tasket A green and yellow basket".length + 2));
+console.log(truncateString("A-", 1));
+console.log(truncateString("Absolutely Longer", 2));

06-basic-algorithm-scripting/09-finders-keepers.js

@@ -0,0 +1,19 @@
+/*
+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.
+
+- findElement([1, 3, 5, 8, 9, 10], function(num) { return num % 2 === 0; }) should return 8.
+- findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; }) should return undefined.
+*/
+function findElement(arr, func) {
+    for (let item of arr) {
+        if (func(item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+
+console.log(findElement([1, 2, 3, 4], num => num % 2 === 0));
+console.log(findElement([1, 3, 5, 9], function(num) { return num % 2 === 0; }));

06-basic-algorithm-scripting/10-boo-who.js

@@ -0,0 +1,32 @@
+/*
+Boo who:
+Check if a value is classified as a boolean primitive. Return true or false.
+Boolean primitives are true and false.
+
+- booWho(true) should return true.
+- booWho(false) should return true.
+- booWho([1, 2, 3]) should return false.
+- booWho([].slice) should return false.
+- booWho({ "a": 1 }) should return false.
+- booWho(1) should return false.
+- booWho(NaN) should return false.
+- booWho("a") should return false.
+- booWho("true") should return false.
+- booWho("false") should return false.
+*/
+function booWho(bool) {
+    return bool === true || bool === false;
+}
+
+console.log(booWho(null));
+console.log(booWho(true));
+console.log(booWho(false));
+console.log(booWho([1, 2, 3]));
+console.log(booWho([].slice));
+console.log(booWho({ "a": 1 }));
+console.log(booWho(1 ));
+console.log(booWho(NaN));
+console.log(booWho("a"));
+console.log(booWho("true"));
+console.log(booWho("false"));
+

06-basic-algorithm-scripting/11-title-case-a-sentence.js

@@ -0,0 +1,29 @@
+/*
+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.
+
+- titleCase("I'm a little tea pot") should return a string.
+- titleCase("I'm a little tea pot") should return the string I'm A Little Tea Pot.
+- titleCase("sHoRt AnD sToUt") should return the string Short And Stout.
+- titleCase("HERE IS MY HANDLE HERE IS MY SPOUT") should return the string Here Is My Handle Here Is My Spout.
+*/
+function titleCase(str) {
+    let finalStr = "";
+    const space_separator = " ";
+    let arr = str.split(space_separator);
+    for (let i = 0; i < arr.length; i++) {
+        const firstLetter = arr[i][0].toUpperCase();
+        const restOfWord = arr[i].substring(1, arr[i].length).toLowerCase();
+        finalStr += firstLetter + restOfWord;
+        if (i < arr.length - 1) {
+            finalStr += space_separator;
+        }
+    }
+    return finalStr;
+}
+
+console.log(titleCase("I'm a little tea pot"));
+console.log(titleCase("sHoRt AnD sToUt"));
+console.log(titleCase("HERE IS MY HANDLE HERE IS MY SPOUT"));

06-basic-algorithm-scripting/12-slice-and-splice.js

@@ -0,0 +1,24 @@
+/*
+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.
+
+- frankenSplice([1, 2, 3], [4, 5], 1) should return [4, 1, 2, 3, 5].
+- frankenSplice([1, 2], ["a", "b"], 1) should return ["a", 1, 2, "b"].
+- frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2) should return ["head", "shoulders", "claw", "tentacle", "knees", "toes"].
+- All elements from the first array should be added to the second array in their original order. frankenSplice([1, 2, 3, 4], [], 0) should return [1, 2, 3, 4].
+- The first array should remain the same after the function runs.
+- The second array should remain the same after the function runs.
+*/
+function frankenSplice(arr1, arr2, n) {
+    let arr = [...arr2];
+    arr.splice(n, 0, ...arr1)
+    return arr;
+}
+
+console.log(frankenSplice([1, 2, 3], [4, 5, 6], 1));
+console.log(frankenSplice([1, 2], ["a", "b"], 1));
+console.log(frankenSplice(["claw", "tentacle"], ["head", "shoulders", "knees", "toes"], 2));
+console.log(frankenSplice([1, 2, 3, 4], [], 0));

06-basic-algorithm-scripting/13-falsy-bouncer.js

@@ -0,0 +1,25 @@
+/*
+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.
+
+- bouncer([7, "ate", "", false, 9]) should return [7, "ate", 9].
+- bouncer(["a", "b", "c"]) should return ["a", "b", "c"].
+- bouncer([false, null, 0, NaN, undefined, ""]) should return [].
+- bouncer([null, NaN, 1, 2, undefined]) should return [1, 2].
+ */
+function bouncer(arr) {
+    const finalArray = [];
+    for (const item of arr) {
+        if (Boolean(item)) {
+            finalArray.push(item);
+        }
+    }
+    return finalArray;
+}
+
+console.log(bouncer([7, "ate", "", false, 9]));
+console.log(bouncer(["a", "b", "c"]));
+console.log(bouncer([false, null, 0, NaN, undefined, ""]));
+console.log(bouncer([null, NaN, 1, 2, undefined]));

06-basic-algorithm-scripting/14-where-do-i-belong.js

@@ -0,0 +1,43 @@
+/*
+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).
+
+- getIndexToIns([10, 20, 30, 40, 50], 35) should return 3.
+- getIndexToIns([10, 20, 30, 40, 50], 35) should return a number.
+- getIndexToIns([10, 20, 30, 40, 50], 30) should return 2.
+- getIndexToIns([10, 20, 30, 40, 50], 30) should return a number.
+- getIndexToIns([40, 60], 50) should return 1.
+- getIndexToIns([40, 60], 50) should return a number.
+- getIndexToIns([3, 10, 5], 3) should return 0.
+- getIndexToIns([3, 10, 5], 3) should return a number.
+- getIndexToIns([5, 3, 20, 3], 5) should return 2.
+- getIndexToIns([5, 3, 20, 3], 5) should return a number.
+- getIndexToIns([2, 20, 10], 19) should return 2.
+- getIndexToIns([2, 20, 10], 19) should return a number.
+- getIndexToIns([2, 5, 10], 15) should return 3.
+- getIndexToIns([2, 5, 10], 15) should return a number.
+- getIndexToIns([], 1) should return 0.
+- getIndexToIns([], 1) should return a number.
+ */
+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;
+}
+
+console.log(getIndexToIns([40, 60], 50));
+console.log(getIndexToIns([10, 20, 30, 40, 50], 35));
+console.log(getIndexToIns([10, 20, 30, 40, 50], 30));
+console.log(getIndexToIns([40, 60], 50));
+console.log(getIndexToIns([3, 10, 5], 3));
+console.log(getIndexToIns([5, 3, 20, 3], 5));
+console.log(getIndexToIns([2, 20, 10], 19));
+console.log(getIndexToIns([2, 5, 10], 15));
+console.log(getIndexToIns([], 1));