Add JavaScript files and solutions

Author: wittenbrock

01-sum-all-numbers-in-a-range/main.js

@@ -0,0 +1,11 @@
+/* We'll pass you an array of two numbers. Return the sum of those two numbers plus the sum of all the numbers between them.
+
+The lowest number will not always come first. */
+
+let sumAll = arr => {
+  let sum = 0;
+  for (let i = Math.min(...arr); i <= Math.max(...arr); i++) {
+      result += i;
+  }
+  return sum;
+}

02-diff-two-arrays/main.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.
+
+Note: You can return the array with its elements in any order. */
+
+let diffArray = (arr1, arr2) => {
+  const master = [...arr1, ...arr2];
+  let finalArray = [];
+  let checker = (masterArray, array) => {
+      masterArray.forEach(elem => {
+          let includes = arr1.includes(elem);
+          if (!includes) {
+              finalArray.push(elem)
+          }
+      })
+  }
+  checker(master, arr1);
+  checker(master, arr2);
+  return finalArray;
+}

03-seek-and-destroy/main.js

@@ -0,0 +1,10 @@
+/* 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. */
+
+let destroyer = (...args) => {
+  const initArr = args[0];
+  const removeArr = args.slice(1,);
+  return initArr.filter(elem => !removeArr.includes(elem))
+}

04-wherefore-art-thou/main.js

@@ -0,0 +1,18 @@
+/* Make a function that looks through an array of objects (first argument) and returns an array of all objects that have matching name and value pairs (second argument). Each name and value pair of the source object has to be present in the object from the collection if it is to be included in the returned array.
+
+For example, if the first argument is [{ first: "Romeo", last: "Montague" }, { first: "Mercutio", last: null }, { first: "Tybalt", last: "Capulet" }], and the second argument is { last: "Capulet" }, then you must return the third object from the array (the first argument), because it contains the name and its value, that was passed on as the second argument. */
+
+let whatIsInAName = (collection, source) => {
+  const sourceKeys = Object.keys(source);
+  const sourceKey1 = sourceKeys[0];
+  const sourceVal1 = source[sourceKey1];
+  let sourceKey2;
+  let sourceVal2;
+  if (sourceKeys.length > 1) {
+      sourceKey2 = sourceKeys[1];
+      sourceVal2 = source[sourceKey2];
+      return collection.filter(obj => obj[sourceKey1] === sourceVal1 && obj[sourceKey2] === sourceVal2);
+  } else {
+      return collection.filter(obj => obj[sourceKey1] === sourceVal1);
+  }
+}

05-spinal-tap-case/main.js

@@ -0,0 +1,5 @@
+/* Convert a string to spinal case. Spinal case is all-lowercase-words-joined-by-dashes. */
+
+let spinalCase = str => {
+  return str.replace(/[\s_]/g, '-').replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}

06-pig-latin/main.js

@@ -0,0 +1,19 @@
+/* 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.
+
+Input strings are guaranteed to be English words in all lowercase. */
+
+let translatePigLatin = str => {
+  const consonantBlock = /(^[^a, e, i, o, u]+)(\w+)/g;
+  const vowels = /[a, e, i, o, u]/gi;
+  if (str.search(vowels) === -1) {
+      return str + 'ay';
+  } else if (!(str.search(consonantBlock) === -1)) {
+      return str.replace(consonantBlock , '$2$1ay');
+  } else {
+      return str + 'way';
+  }
+}

07-search-and-replace/main.js

@@ -0,0 +1,17 @@
+/* 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" */
+
+let myReplace = (str, before, after) => {
+  if (before[0] === before[0].toUpperCase()) {
+      after = after[0].toUpperCase() + after.substring(1);
+  }
+return str.replace(before, after);
+}

08-dna-pairing/main.js

@@ -0,0 +1,19 @@
+/* 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.
+
+For example, for the input GCG, return [["G", "C"], ["C","G"],["G", "C"]]
+
+The character and its pair are paired up in an array, and all the arrays are grouped into one encapsulating array. */
+
+let pairElement = str => {
+  const pairs = {
+    A: ["A", "T"],
+    T: ["T", "A"],
+    C: ["C", "G"],
+    G: ["G", "C"]
+  };
+  return [...str].map(elem => pairs[elem]);
+}

09-missing-letters/main.js

@@ -0,0 +1,17 @@
+/* Find the missing letter in the passed letter range and return it.
+
+If all letters are present in the range, return undefined. */
+
+let fearNotLetter = str => {
+  const alphabet = "abcdefghiklmnopqrstuvxyz";
+  const alphabetArray = alphabet.split('');
+  let sliceMachine = string => {
+      const beginning = alphabet.indexOf(string[0]);
+      const end = alphabet.indexOf(string[string.length - 1]);
+      return alphabet.slice(beginning, end + 1).split('');
+  }
+  let diffArray = (arr1, arr2) => {
+    return arr1.filter(item => !arr1.includes(item) || !arr2.includes(item))
+  }
+  let result = diffArray(sliceMachine(str), str);
+  return result[0];

10-sorted-union/main.js

@@ -0,0 +1,12 @@
+/* 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.
+
+Check the assertion tests for examples. */
+
+let uniteUnique = (...args) => {
+  const flatArr = args.flat(2);
+  return [...(new Set(flatArr))];
+}

11-convert-html-entities/main.js

@@ -0,0 +1,12 @@
+/* Convert the characters &, <, >, " (double quote), and ' (apostrophe), in a string to their corresponding HTML entities. */
+
+let convertHTML = str => {
+  const map = {
+      "&": `&amp;`,
+      "<": `&lt;`,
+      ">": `&gt;`,
+      "\"": `&quot;`,
+      "\'": `&apos;`
+  }
+  return [...str].map(letter => map[letter] || letter).join('');
+}

12-sum-all-odd-fibonacci-numbers/main.js

@@ -0,0 +1,19 @@
+/* Given a positive integer num, return the sum of all odd Fibonacci numbers that are less than or equal to num.
+
+The first two numbers in the Fibonacci sequence are 1 and 1. Every additional number in the sequence is the sum of the two previous numbers. The first six numbers of the Fibonacci sequence are 1, 1, 2, 3, 5 and 8.
+
+For example, sumFibs(10) should return 10 because all odd Fibonacci numbers less than or equal to 10 are 1, 1, 3, and 5. */
+
+let sumFibs = num => {
+  let a = 0;
+  let b = 1;
+  let result = [0, 1];
+  while(result[result.length - 1] < num) {
+      result.push(a+b);
+      a = result[result.length - 2];
+      b = result[result.length - 1];
+  }
+  return result
+      .filter(el => el <= num && el % 2 === 1)
+      .reduce((total, currentVal) => total += currentVal);
+}

13-sum-all-primes/main.js

@@ -0,0 +1,19 @@
+/* Sum all the prime numbers up to and including the provided number.
+
+A prime number is defined as a number greater than one and having only two divisors, one and itself. For example, 2 is a prime number because it's only divisible by one and two.
+
+The provided number may not be a prime. */
+
+let sumPrimes = num => {
+  let isPrime = value => {
+      for(var i = 2; i < value; i++) {
+          if(value % i === 0) {
+              return false;
+          }
+      }
+      return value > 1;
+  }
+  return Array.from({length: num + 1}, (v, i) => i)
+      .filter(isPrime)
+      .reduce((total, currentVal) => total += currentVal);
+}

14-smallest-common-multiple/main.js

@@ -0,0 +1,25 @@
+/* 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.
+
+The range will be an array of two numbers that will not necessarily be in numerical order.
+
+For example, if given 1 and 3, find the smallest common multiple of both 1 and 3 that is also evenly divisible by all numbers between 1 and 3. The answer here would be 6. */
+
+let smallestCommons = arr => {
+  let min = Math.min.apply(null, arr);
+  let max = Math.max.apply(null, arr);
+  let grandLCM;
+  for (let i=min; i<max; i++) {
+      if (i===min){
+          grandLCM = (i * (i+1))/gcd(i, i+1);
+      } else{
+          grandLCM = (grandLCM * (i+1))/gcd(grandLCM, i+1);
+      }
+  }
+  return grandLCM;
+  function gcd(x, y) {    // Implements The Euclidean Algorithm
+  if (y === 0)
+      return x;
+  else
+      return gcd(y, x%y);
+  }
+}

15-drop-it/main.js

@@ -0,0 +1,8 @@
+/* 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.
+
+Then return the rest of the array once the condition is satisfied, otherwise, arr should be returned as an empty array. */
+
+let dropElements = (arr, func) => {
+  let index = arr.findIndex(func);
+  return index === -1 ? [] : arr.slice(index);
+}

16-steamroller/main.js

@@ -0,0 +1,6 @@
+/* Flatten a nested array. You must account for varying levels of nesting. */
+
+let deepFlatten = arr => {
+  let flat = arr.flat();
+  return flat.some(Array.isArray) ? steamrollArray(flat) : flat;
+}

17-binary-agents/main.js

@@ -0,0 +1,10 @@
+/* Return an English translated sentence of the passed binary string.
+
+The binary string will be space separated. */
+
+let binaryAgent = str => {
+  return str
+      .split(" ")
+      .map(elem => String.fromCharCode(parseInt(elem, 2)))
+      .join("");
+}

18-everything-be-true/main.js

@@ -0,0 +1,28 @@
+/* 
+Check if the predicate (second argument) is truthy on all elements of a collection (first argument).
+
+In other words, you are given an array collection of objects. The predicate pre will be an object property and you need to return true if its value is truthy. Otherwise, return false.
+
+In JavaScript, truthy values are values that translate to true when evaluated in a Boolean context.
+
+Remember, you can access object properties through either dot notation or [] notation.
+*/
+
+let truthCheck = (collection, pre) => {
+  return collection.every(obj => {
+      switch (obj.hasOwnProperty(pre)) {
+          case obj[pre] === 0:
+          case obj[pre] === '':
+          case obj[pre] === undefined:
+          case obj[pre] === null:
+          case String(obj[pre]) === "NaN":
+              return false;
+          default:
+              return true;
+      }
+  })
+}
+let truthCheck = (collection, pre) => {
+return collection.every(el => el.hasOwnProperty(pre) && Boolean(el[pre]))
+}
+let truthCheck = (collection, pre) => collection.every(obj => obj[pre]);

19-arguments-optional/main.js

@@ -0,0 +1,36 @@
+/*
+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.
+
+Calling this returned function with a single argument will then return the sum:
+
+var sumTwoAnd = addTogether(2);
+
+sumTwoAnd(3) returns 5.
+
+If either argument isn't a valid number, return undefined.
+*/
+
+let addTogether = (...args) => {
+  let isNumber = elem => typeof elem === 'number' ? true : false;
+  if (args.length > 1) {
+      let num1 = args[0], num2 = args[1];
+      if (isNumber(num1) && isNumber(num2)) {
+          return num1 + num2;
+      } else {
+          return undefined
+      }
+  } else {
+      let num3 = args[0];
+      if (isNumber(num3)) {
+          return function(arg2) {
+              if (isNumber(arg2)) {
+                  return num3 + arg2;
+              }
+          }
+      } else {
+          undefined
+      }
+  }
+};

20-make-a-person/main.js

@@ -0,0 +1,34 @@
+/*
+Fill in the object constructor with the following methods below:
+
+getFirstName() getLastName() getFullName() setFirstName(first) setLastName(last) setFullName(firstAndLast)
+Run the tests to see the expected output for each method.
+
+The methods that take an argument must accept only one argument and it has to be a string.
+
+These methods must be the only available means of interacting with the object.
+*/
+
+let Person = function(firstAndLast) {
+  var fullName = firstAndLast;
+  this.getFirstName = function() {
+    return fullName.split(" ")[0];
+  };
+  this.getLastName = function() {
+    return fullName.split(" ")[1];
+  };
+  this.getFullName = function() {
+    return fullName;
+  };
+  this.setFirstName = function(name) {
+    fullName = name + " " + fullName.split(" ")[1];
+  };
+  this.setLastName = function(name) {
+    fullName = fullName.split(" ")[0] + " " + name;
+  };
+  this.setFullName = function(name) {
+    fullName = name;
+  };
+};
+let bob = new Person('Bob Ross');
+bob.getFullName();