storing

Storing my answers from this module 😃

Author: davigl

arguments-optional.js

@@ -0,0 +1,31 @@
+/*
+Create a function that sums two arguments together. 
+If only one argument is provided, then return a function that expects one argument and returns the sum.
+
+For example, addTogether(2, 3) should return 5, and addTogether(2) should return a function.
+*/
+
+function addTogether() {
+  const checkType = (number) => {
+    if (typeof(number) === "number") {
+      return true;
+    } else return false;
+  }
+
+  if (arguments.length > 1) {
+    let x = arguments[0];
+    let y = arguments[1];
+    
+    if (checkType(x) && checkType(y)) return (x + y);
+  } else if (arguments.length === 1) {
+    let z = arguments[0];
+
+    if (checkType(arguments[0])) {
+      return (arg2) => {
+     	  if (checkType(arg2)) return (z + arg2);
+      }
+    }    
+  }
+}
+
+console.log(addTogether(2)(3));

binary-agents.js

@@ -0,0 +1,20 @@
+/*
+Return an English translated sentence of the passed binary string.
+
+The binary string will be space separated.
+*/
+
+function binaryAgent(str) {
+  let splitted = str.split(" ");
+  let output = ""
+
+  for (let i = 0; i < splitted.length; i++) {
+    let number = parseInt(splitted[i], 2);
+
+    output += String.fromCharCode(number);
+  }
+
+  return output;
+}
+
+binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

convert-html-entities.js

@@ -0,0 +1,15 @@
+/*
+Convert the characters &, <, >, " (double quote), and ' (apostrophe), in a string to their corresponding HTML entities.
+*/
+
+function convertHTML(str) {
+  str = str.replace(/&/g, "&amp;")
+  str = str.replace(/</g, "&lt;")
+  str = str.replace(/>/g, "&gt;")
+  str = str.replace(/"/g, "&quot;")
+  str = str.replace(/'/g, "&apos;")
+
+  return str;
+}
+
+console.log(convertHTML("Hamburgers < Pizza < Tacos"));

diff-two-arrays.js

@@ -0,0 +1,19 @@
+/*
+Compare two arrays and return a new array with any items only found in one of the two given arrays, but not both. In other words, return the symmetric difference of the two arrays.
+*/
+
+const filterArray = (arr, arr2) => {
+  let newArray = arr.filter((value) => {
+    if (arr2.indexOf(value) < 0) return value;
+  });
+
+  return newArray;
+}
+
+function diffArray(arr1, arr2) {
+  var newArr = [...filterArray(arr2, arr1), ...filterArray(arr1, arr2)];
+
+  return newArr;
+}
+
+diffArray(["andesite", "grass", "dirt", "pink wool", "dead shrub"], ["diorite", "andesite", "grass", "dirt", "dead shrub"]);

dna-pairing.js

@@ -0,0 +1,36 @@
+/** 
+The DNA strand is missing the pairing element. Take each character, get its pair, and return the results as a 2d array.
+
+Base pairs are a pair of AT and CG. Match the missing element to the provided character.
+
+Return the provided character as the first element in each array.
+*/
+
+const search = (char, pairs) => {
+  switch (char) {
+      case "T":
+        pairs.push(["T", "A"]);
+        break;
+      case "A":
+        pairs.push(["A", "T"]);
+        break;
+      case "C":
+        pairs.push(["C", "G"]);
+        break;
+      case "G":
+        pairs.push(["G", "C"]);
+        break;
+  }
+}
+
+function pairElement(str) {
+  var pairs = [];
+
+  for (let i = 0; i < str.length; i++) {
+    search(str[i], pairs);
+  }
+
+  return pairs;
+}
+
+pairElement("GCG");

drop-it.js

@@ -0,0 +1,18 @@
+/*
+Given the array arr, iterate through and remove each element starting from the first element (the 0 index) until the function func returns true when the iterated element is passed through it.
+*/
+
+function dropElements(arr, func) {
+  let updatedArray = [];
+
+  for (let i = 0; i < arr.length; i++) {
+    if (func(arr[i])) {
+      updatedArray = arr.slice(i, arr.length);
+      break;
+    }
+  }
+
+  return updatedArray;
+}
+
+console.log(dropElements([1, 2, 3, 4], function(n) {return n >= 3; }));

everything-be-true.js

@@ -0,0 +1,13 @@
+/*
+Check if the predicate (second argument) is truthy on all elements of a collection (first argument).
+*/
+
+function truthCheck(collection, pre) {
+  for (let i = 0; i < collection.length; i++) {
+    if (!(collection[i][pre])) return false;
+  }
+
+  return true;
+}
+
+console.log(truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex"));

make-a-person.js

@@ -0,0 +1,38 @@
+/*
+Fill in the object constructor with the following methods below:
+
+getFirstName()
+getLastName()
+getFullName()
+setFirstName(first)
+setLastName(last)
+setFullName(firstAndLast)
+*/
+
+var Person = function(firstAndLast) {
+  this.getFirstName = () => {
+    let first = firstAndLast.split(" ")[0];
+
+    return first;
+  }
+  this.getLastName = () => {
+    let last = firstAndLast.split(" ")[1];
+
+    return last;
+  }
+  this.getFullName = () => {
+    return firstAndLast;
+  };
+  this.setFirstName = (name) => {
+    firstAndLast = firstAndLast.replace(this.getFirstName(), name);
+  };
+  this.setLastName = (name) => {
+    firstAndLast = firstAndLast.replace(this.getLastName(), name);
+  };
+  this.setFullName = (name) => {
+    firstAndLast = name;
+  };
+};
+
+var bob = new Person('Bob Ross');
+bob.getFullName();

map-the-debris.js

@@ -0,0 +1,24 @@
+/*
+Return a new array that transforms the elements' average altitude into their orbital periods (in seconds).
+
+The array will contain objects in the format {name: 'name', avgAlt: avgAlt}.
+*/
+
+function orbitalPeriod(arr) {
+  var GM = 398600.4418;
+  var earthRadius = 6367.4447;
+
+  for (let i = 0; i < arr.length; i++) {
+    let orbitalPeriodCalc = (2 * Math.PI) * Math.sqrt(
+      Math.pow(earthRadius + arr[i]['avgAlt'], 3) / GM
+    )
+
+    delete arr[i]['avgAlt'];
+
+    arr[i]['orbitalPeriod'] = Math.round(orbitalPeriodCalc);
+  }
+
+  return arr;
+}
+
+console.log(orbitalPeriod([{name : "sputnik", avgAlt : 35873.5553}]));

missing-letters.js

@@ -0,0 +1,18 @@
+/*
+Find the missing letter in the passed letter range and return it.
+
+If all letters are present in the range, return undefined.
+*/
+
+function fearNotLetter(str) {
+  for (let i = 0; i < str.length - 1; i++) {
+    let actualLetterCode = str.charCodeAt(i);
+    let nextLetterCode = str.charCodeAt(i + 1);
+
+    if ((actualLetterCode + 1) != nextLetterCode) {
+      return String.fromCharCode(actualLetterCode + 1);
+    }
+  }
+}
+
+console.log(fearNotLetter("abce"));

pig-latin.js

@@ -0,0 +1,36 @@
+/*
+Translate the provided string to pig latin.
+
+Pig Latin takes the first consonant (or consonant cluster) of an English word, moves it to the end of the word and suffixes an "ay".
+
+If a word begins with a vowel you just add "way" to the end.
+
+If a word does not contain a vowel, just add "ay" to the end.
+
+Input strings are guaranteed to be English words in all lowercase.
+*/
+
+function translatePigLatin(str) {
+  let startVowel = /^[aeiou]/i;
+  let globalVowels = /[aeiou]/gi;
+
+  if (startVowel.test(str)) {
+    str = str.concat("way");
+  } else if (globalVowels.test(str)) {
+    for (let i = 0; i < str.length - 1; i++) {
+      if (!(startVowel.test(str))) {
+        str = str.slice(1, str.length).concat(str.charAt(0));
+      } else {
+        break;
+      }
+    }
+
+    str = str.concat("ay");
+  } else {
+    str = str.concat("ay");
+  }
+
+  return str;
+}
+
+console.log(translatePigLatin("glove"));

search-and-replace.js

@@ -0,0 +1,27 @@
+/*
+Perform a search and replace on the sentence using the arguments provided and return the new sentence.
+
+First argument is the sentence to perform the search and replace on.
+
+Second argument is the word that you will be replacing (before).
+
+Third argument is what you will be replacing the second argument with (after).
+
+Note
+Preserve the case of the first character in the original word when you are replacing it. For example if you mean to replace the word "Book" with the word "dog", it should be replaced as "Dog"
+*/
+
+
+function myReplace(str, before, after) {
+  let regex = /^[A-Z]/
+
+  if (regex.test(before)) {
+    after = after.charAt(0).toUpperCase() + after.slice(1);
+  }
+
+  str = str.replace(before, after);
+
+  return str;
+}
+
+myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

seek-and-destroy.js

@@ -0,0 +1,26 @@
+/*
+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.
+
+Note
+You have to use the arguments object.
+*/
+
+const destroy = (arr, number) => {
+  arr = arr.filter(value => {
+    if (number !== value) return value;
+  });
+
+  return arr;
+}
+
+function destroyer(arr) {
+  let keys = Object.keys(arguments);
+
+  for (let i = 1; i < keys.length; i++) {
+    arr = destroy(arr, arguments[i]);
+  }
+
+  return arr;
+}
+
+destroyer([1, 2, 3, 1, 2, 3], 2, 3);

smallest-common-multiple.js

@@ -0,0 +1,24 @@
+/*
+Find the smallest common multiple of the provided parameters that can be evenly divided by both, as well as by all sequential numbers in the range between these parameters.
+*/
+
+function smallestCommons(arr) {
+  var range = [];
+  for (var i = Math.max(arr[0], arr[1]); i >= Math.min(arr[0], arr[1]); i--) {
+    range.push(i);
+  }
+
+  var lcm = range[0];
+  for (i = 1; i < range.length; i++) {
+    var GCD = gcd(lcm, range[i]);
+    lcm = (lcm * range[i]) / GCD;
+  }
+  return lcm;
+
+  function gcd(x, y) {
+    if (y === 0) return x;
+    else return gcd(y, x % y);
+  }
+}
+
+smallestCommons([1,5]);

sorted-union.js

@@ -0,0 +1,25 @@
+/*
+Write a function that takes two or more arrays and returns a new array of unique values in the order of the original provided arrays.
+
+In other words, all values present from all arrays should be included in their original order, but with no duplicates in the final array.
+
+The unique numbers should be sorted by their original order, but the final array should not be sorted in numerical order.
+*/
+
+function onlyUnique(value, index, self) { 
+    return self.indexOf(value) === index;
+}
+
+function uniteUnique(arr) {
+  let unique = []
+
+  for (let key in arguments) {
+    unique.push(...arguments[key]);
+  }
+  
+  unique = unique.filter(onlyUnique);
+
+  return unique;
+}
+
+console.log(uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1]));

spinal-tap-case.js

@@ -0,0 +1,14 @@
+/*
+Convert a string to spinal case. Spinal case is all-lowercase-words-joined-by-dashes.
+*/
+
+function spinalCase(str) {
+  var regex = /\s+|_+/g;
+
+  str = str.replace(/([a-z])([A-Z])/g, "$1 $2");
+  str = str.replace(regex, "-").toLowerCase();
+
+  return str;
+}
+
+console.log(spinalCase('This Is Spinal Tap'));