Solutions to FreeCodeCamp Challenges - http://j.mp/abhisekpFCCSolns

# FCC Solutions.md

Solutions to FreeCodeCamp Challenges

See http://www.freecodecamp.com/abhisekp

ShortUrl to Gist: http://j.mp/abhisekpFCCSolns

One Liner Solutions Only: http://j.mp/abhisekpFCCSolnsOneLiners

Solved using RegExp: http://bit.ly/abhisekpFCCRegExpSolns

01. Challenge - Meet Bonfire.js

function meetBonfire(argument) {
  // Good luck!
  console.log("you can read this function's argument in the developer tools", argument);

  return true;
}

meetBonfire("You can do this!");

01. Challenge - Validate US Telephone Numbers.js

function telephoneCheck(str) {
  // Good luck!
  // I'm feeling lucky today!
  return /^(1)?(((?:\s*\(\s*)(\d{3})(?:\s*\)\s*))|((\s*|-)\d{3}(\s*|-)))(\d{3})(\s*-?\s*)(\d{4})$/.test(str);
}

telephoneCheck("555-555-5555");

02. Challenge - Reverse a String.js

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

reverseString('hello');

03. Challenge - Factorialize a Number 1.js

function factorialize(num) {
  return (num < 2) ? 1 : (num * factorialize(num - 1));
}

factorialize(5);

03. Challenge - Factorialize a Number 2.js

function factorialize(num) {
  var fact = 1;
  while(num) { fact *= num--; }
  return fact;
}

factorialize(5);

03. Challenge - Roman Numeral Converter 1.js

var romanPair = {
  1: 'I',
  5: 'V',
  10: 'X',
  50: 'L',
  100: 'C',
  500: 'D',
  1000: 'M'
};

// all bases as number sorted in ascending order
var romanBases = Object.keys(romanPair).sort(function (a, b) {
  return a - b;
}).map(function (base) {
  return Number(base);
});
// console.log('romanBases:', romanBases);

var minRomanBase = Math.min.apply(null, romanBases);
var maxRomanBase = Math.max.apply(null, romanBases);

function convert(num) {
  // console.log('num:', num);

  if (num < minRomanBase || num > maxRomanBase) {
    if (num === 0) {
      return 'Zero (0) was discovered later by Aryabhata (Indian Mathematician).';
    }
    else if (num > maxRomanBase) {
      return 'Romans were too tired to extend their number system.'
    }
    return 'You should definitely consider using the modern decimal number system.';
  }

  if (romanPair[num]) {
    return romanPair[num];
  }

  var baseInset = 1,
    tempBase = 1;
  romanBases.forEach(function (base, i) {
    if (num > base) {
      // check if the base is either 1, 10, 100 or 1000
      if (Math.log10(base) % 1 === 0) {
        // find the baseInset value
        baseInset = base;
      }
      if (romanBases[i + 1] - num <= baseInset) {
        // assign the tempBase to the next romanBase
        tempBase = romanBases[i + 1];
      }
      else {
        // assign the tempBase to the current romanBase
        tempBase = base;
      }

    }
  });
  // console.log('baseInset:', baseInset);
  // console.log('tempBase:', tempBase);

  var diff = 0,
    romanNum;

  // if number is > a roman tempBase
  if (num > tempBase) {
    diff = num - tempBase;
    // console.log('diff:', diff);
    romanNum = convert(tempBase) + convert(diff);
  }
  else { // fixme
    diff = num - (tempBase - baseInset);
    // console.log('diff:', diff);
    romanNum = convert(baseInset) + convert(tempBase) + (diff ? convert(diff) : '');
  }

  return romanNum;
}

convert(36);

04. Challenge - Check for Palindromes 1.js

function palindrome(str) {
  str = str.toLowerCase().replace(/[\W_]/g, '');
  for(var i = 0, len = str.length - 1; i < len/2; i++) {
    if(str[i] !== str[len-i]) {
      return false;
    }
  }
  return true;
}

palindrome("eye");

04. Challenge - Check for Palindromes 2.js

function palindrome(str) {
  return (str = str.toLowerCase().replace(/\W|_/g, '')) === str.split('').reverse().join('');
}

palindrome("0_0 (: /-\\ :) 0-0");

04. Challenge - Where art thou 1.js

function where(collection, source) {
  // "What's in a name? that which we call a rose
  // By any other name would smell as sweet.”
  // -- by William Shakespeare, Romeo and Juliet
  var srcKeys = Object.keys(source);
  
  // filter the collection
  return collection.filter(function (obj) {
    // return a Boolean value for filter callback using reduce method
    return srcKeys.reduce(function (res, key) {
      // reduce to Boolean value to be returned by reduce method
      return obj.hasOwnProperty(key) && obj[key] === source[key];
    }, false);
  });
}

where([{ first: 'Romeo', last: 'Montague' }, { first: 'Mercutio', last: null }, { first: 'Tybalt', last: 'Capulet' }], { last: 'Capulet' });

04. Challenge - Where art thou 2.js

function where(collection, source) {
  // "What's in a name? that which we call a rose
  // By any other name would smell as sweet.”
  // -- by William Shakespeare, Romeo and Juliet
  var srcKeys = Object.keys(source);
  
  // filter the collection
  return collection.filter(function (obj) {
    for(var i = 0; i < srcKeys.length; i++) {
      // check if obj in collection doesn't have the key
      // or if it does have the key,
      // then check if the property value doesn't match the value in source
      if(!obj.hasOwnProperty(srcKeys[i]) || obj[srcKeys[i]] !== source[srcKeys[i]]) {
        return false;
      }
    }
    return true;
  });
}

where([{ first: 'Romeo', last: 'Montague' }, { first: 'Mercutio', last: null }, { first: 'Tybalt', last: 'Capulet' }], { last: 'Capulet' });

04. Challenge - Where art thou 3.js

function where(collection, source) {
  // "What's in a name? that which we call a rose
  // By any other name would smell as sweet.”
  // -- by William Shakespeare, Romeo and Juliet
  var srcKeys = Object.keys(source);

  // filter the collection
  return collection.filter(function (obj) {
    // return a Boolean value for `filter` method
    return srcKeys.every(function (key) {
      // reduce to Boolean value to be returned for `every` method
      return obj.hasOwnProperty(key) && obj[key] === source[key];
    });
  });
}

where([{ first: 'Romeo', last: 'Montague' }, { first: 'Mercutio', last: null }, { first: 'Tybalt', last: 'Capulet' }], { last: 'Capulet' });

05. Challenge - Find the Longest Word in a String 1.js

function findLongestWord(str) {
  var maxWordLength = 0,
      words = str.split(' ');
  for(var i = 0, len = words.length; i < len; i++) {
    if(words[i].length > maxWordLength) {
      maxWordLength = words[i].length;
    }
  }
  
  return maxWordLength;
}

findLongestWord('The quick brown fox jumped over the lazy dog');

05. Challenge - Find the Longest Word in a String 2.js

function findLongestWord(str) {
  var maxWordLength = 0,
      words = str.split(' ');
  maxWordLength = words.reduce(function(max, curr) {
    return curr.length > max ? curr.length : max;
  }, 0);
  
  return maxWordLength;
}

findLongestWord('The quick brown fox jumped over the lazy dog');

05. Challenge - Find the Longest Word in a String 4.js

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

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

05. Challenge - Search and Replace.js

function myReplace(str, before, after) {
  var replaced = after;

  function replacer(before, after) {
    return after.split('').map(function (afterCh, i) {
      var beforeCh = before[i];

      if (i >= before.length) {
        return afterCh;
      }

      if (beforeCh >= 'a' && beforeCh <= 'z') {
        return afterCh.toLowerCase();
      }
      else if (beforeCh >= 'A' && beforeCh <= 'Z') {
        return afterCh.toUpperCase();
      }

      return afterCh;
    }).join('');
  }

  replaced = str.replace(before, replacer(before, after));
  return replaced;
}

myReplace("A quick brown fox jumped over the lazy dog", "jumped", "leaped");

// https://repl.it/BRTQ/4

06. Challenge - Find the Longest Word in a String 3.js

function findLongestWord(str) {
  var maxWordLength = 0,
      words = str.split(' ');
  
  words.forEach(function(curr) {
    if(curr.length > maxWordLength) {
      maxWordLength = curr.length;
    }    
  });
  
  return maxWordLength;
}

findLongestWord('The quick brown fox jumped over the lazy dog');

06. Challenge - Title Case a Sentence 1.js

function titleCase(str) {
  str = str.toLowerCase();
  var words = str.split(' ');
  for(var i = 0, len = words.length; i < len; i++) {
    words[i] = words[i][0].toUpperCase() + words[i].substr(1);
  }
  str = words.join(' ');
  
  return str;
}

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

06. Challenge - Title Case a Sentence 2.js

function titleCase(str) {
  str = str.toLowerCase();
  var words = str.split(' ');
  str = words.map(function (word) {
    return word[0].toUpperCase() + word.substr(1);
  }).join(' ');
  
  return str;
}

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

06. Challenge - Title Case a Sentence 3.js

function titleCase(str) {
  return str.replace(/(\w)([\w']*)/g, function (match, $1, $2){
    return $1.toUpperCase() + $2.toLowerCase();
  });
}

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

06. Challenge - Title Case a Sentence 4.js

function titleCase(str) {
  return str.toLowerCase().replace(/(?: |^)[a-z]/g, (L) => L.toUpperCase());
}

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

07. Challenge - DNA Pairing 1.js

function find(array, cb) {
    /* ES6 Array.prototype.find available */
    if(typeof Array.prototype.find !== 'undefined') {
        return array.find(cb);
    }
    
    // console.log('ES6 Array.prototype.find Unavailable');
    for(var index = 0; index < array.length; index++) {
        var curr = array[index];
        var found = cb(curr, index, array);
        if(found) {
            var value = array[index];
            return value;
        }
    }
}

function nextInCircularArray(array, index) {
    // console.log('\nindex:', index);
    // console.log('Given Array:', array);
    var nextIndex = (index+1) % array.length;
    // console.log('nextIndex:', nextIndex);
    return array[nextIndex];
}

function pair(DNAstr) {
    function findPair(pairs, DNA) {
        return find(pairs, function (pair) {
            return pair.indexOf(DNA) !== -1;
        });
    }    

    var pairs = [
        ['A', 'T'],
        ['G', 'C']
    ];
    
    return [].map.call(DNAstr, function (DNA) {
        var pair = [DNA];
        console.log('DNA:', DNA);
        var foundPair = findPair(pairs, DNA);
        console.log('> foundPair:', foundPair);
        var otherDNA = nextInCircularArray(foundPair, foundPair.indexOf(DNA));
        console.log('> otherDNA:', otherDNA);
        pair.push(otherDNA);
        return pair;
    });
}

pair("ATCGA");

07. Challenge - DNA Pairing 2.js

function pair(str) {
  var pairs = {A:'T', T: 'A', C: 'G', G: 'C'};
  return [].map.call(str, function(dna){
    return [dna, pairs[dna]];
  });
}

pair("ATCGA");

07. Challenge - Return Largest Numbers in Arrays 1.js

function largestOfFour(arr) {
  // You can do this!  
  for(var i = 0; i < arr.length; i++) {
    var max = arr[i][0];
    for(var j = 1; j < arr.length; j++) {
      if(arr[i][j] > max) {
        max = arr[i][j];
      }      
    }
    arr[i] = max;
  }
  return arr;
}

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

07. Challenge - Return Largest Numbers in Arrays 2.js

function largestOfFour(arr) {
  // You can do this!
  // Yes, I can. :P
  return arr.map(Function.apply.bind(Math.max, null));
}

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

08. Challenge - Confirm the Ending 1.js

function end(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  // "I find my own luck!" -- AbhisekP.  
  
  return target === str.substr(str.length - target.length);
}

end('Bastian', 'n');

08. Challenge - Confirm the Ending 2.js

function end(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  // "I find my own luck!" -- AbhisekP.
  
  return new RegExp(target + '$').test(str);
}

end('Bastian', 'n');

08. Challenge - Confirm the Ending 3.js

function end(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  // "I find my own luck!" -- AbhisekP.
  return str.endsWith(target);
}

end('Bastian', 'n');

08. Challenge - Confirm the Ending 4.js

function end(str, target) {
  // "Never give up and good luck will find you."
  // -- Falcor
  // "I find my own luck!" -- AbhisekP.
  
  return str.lastIndexOf(target) === str.length - target.length;
}

end('Bastian', 'n');

08. Challenge - Missing letters.js

function fearNotLetter(str) {
  var startCode = str.charCodeAt(0);
  var endCode = str.charCodeAt(str.length-1);

  if(endCode - startCode + 1 === str.length) {
    return;
  }

  var missing = '';

  for(var codeIndex = startCode; codeIndex !== endCode; codeIndex++) {
    var currChar = String.fromCharCode(codeIndex);
    if(str.indexOf(currChar) === -1) {
      missing += currChar;
    }
  }


  return missing;
}

fearNotLetter("abce");

09. Challenge - Boo who.js

function boo(bool) {
  // What is the new fad diet for ghost developers? The Boolean.
  return typof bool === 'boolean';
}

boo(null);

09. Challenge - Repeat a string repeat a string 1.js

function repeat(str, num) {
  // repeat after me
  // am i in class 2 or something?
  var repeated = '';
  while(num-- > 0) {
    repeated += str;
  }
  return repeated;
}

repeat('abc', 3);

09. Challenge - Repeat a string repeat a string 2.js

function repeat(str, num) {
  // repeat after me
  // am i in class 2 or something?
  
  return num <= 0 ? '': str.repeat(num);
}

repeat('abc', 3);

10. Bonfire - Convert HTML Entities 2.js

function convert(str) {
    'use strict';

    var htmlEntities = {
        '\'': ''',
        '&': '&',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',

        get get() {
            return function (entity) {
                return this[entity];
            };
        },
        get toString() {
            return function () {
                return Object.keys(this).join('');
            }
        }
    };

    Object.defineProperties(htmlEntities, {
        get: {
            enumerable: false
        },
        toString: {
            enumerable: false
        }
    });

    var re = new RegExp('[' + htmlEntities + ']', 'g');
    return str.replace(re, function (entity) {
        return htmlEntities.get(entity);
    });
}

convert('Dolce & Gabbana');

10. Bonfire - Truncate a string 1.js

function truncate(str, num) {
  // Clear out that junk in your trunk
  // trunk is loaded

  if(str.length > num) {
      if(num <= 3) {
          return str.substr(0, num) + '...';
      }
      return str.substr(0, num-3) + '...';
  }
  return str;
}

truncate('A-tisket a-tasket A green and yellow basket', 11);

10. Bonfire - Truncate a string 2.js

function truncate(str, num) {
  // Clear out that junk in your trunk
  // trunk is loaded

  return str.length > num ? num <= 3 ? str.substr(0, num) + '...': str.substr(0, num-3) + '...' : str;
}

truncate('A-tisket a-tasket A green and yellow basket', 11);

10. Challenge - Convert HTML Entities 1.js

this.myNamespace = {};

(function (namespace, window, undefined) {
    var htmlEntities = {
        '\'': ''',
        '&': '&',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',

        get get() {
            return function (entity) {
                return this[entity];
            };
        },

        get toString() {
            return function () {
                return Object.keys(this).join('');
            };
        }
    };

    Object.defineProperties(htmlEntities, {
        get: {
            enumerable: false
        },
        toString: {
            enumerable: false
        }
    });

    namespace.htmlEntities = htmlEntities;
})(myNamespace, this);

function convert(str) {
    'use strict';

    var re = new RegExp('[' + myNamespace.htmlEntities + ']', 'g');
    return str.replace(re, myNamespace.htmlEntities.get.bind(myNamespace.htmlEntities));
}

convert('Dolce & Gabbana');

11. Bonfire - Chunky Monkey.js

function chunk(arr, size) {
  // Break it up
  // It's already broken :(
  arr = arr.slice();
  var arr2 = [];
  for(var i = 0, len = arr.length; i < len; i+=size) {
    arr2.push(arr.slice(0, size));
    arr = arr.slice(size);
  }
  return arr2;
}

chunk(['a', 'b', 'c', 'd'], 2);

12. Bonfire - Slasher Flick.js

function slasher(arr, howMany) {
  // it doesn't always pay to be first
  // well, now my head is chopped off >:(
  return arr.splice(0, howMany) && arr;
}

slasher([1, 2, 3], 2);

13. Bonfire - Sum All Odd Fibonacci Numbers 1.js

function sumFibs(num) {
    // Fibonacci is life. It's everywhere
    var sum = 0,
    last = 0,
    fib = 1;
    for(var curr = 1; fib <= num; fib = last + curr, last = curr, curr = fib) {
        if(fib % 2) {
            sum += fib;
        }
        // console.log(last, curr, fib);
    }
    return sum;
}

sumFibs(4);

13. Bonfire - Sum All Odd Fibonacci Numbers 2.js

function sumFibs(num) {
    // Fibonacci is life. It's everywhere
    var sum = 0,
        last = 0,
        curr = 1,
        fib = curr;
    
    while(fib <= num) {
        if(fib % 2) {
            sum += fib;
        }
        
        // console.log(last, curr, fib);
        
        fib = last + curr;
        last = curr;
        curr = fib;
    }
    
    return sum;
}

sumFibs(4);

14. Bonfire - Falsey Bouncer 1.js

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
  // I've a hammer fist.
  return arr.filter(Boolean);
}

bouncer([7, 'ate', '', false, 9]);

14. Bonfire - Falsey Bouncer 2.js

function bouncer(arr) {
  // Don't show a false ID to this bouncer.
  // I've a hammer fist.
  var filtered = [];
  for(var i = 0; i < arr.length; i++) {
    if(Boolean(arr[i])) {
      filtered.push(arr[i]);
    }
  }
  
  return filtered;
}

bouncer([7, 'ate', '', false, 9]);

15. Bonfire - Seek and Destroy 1.js

function destroyer(arr) {
  // Remove all the values
  // I don't like the emptiness :P
  
  var args = [].slice.call(arguments, 1);
  return arr.filter(function (el) {
    for(var i = 0; i < args.length; i++) {
      if(args[i] === el) {
        return false;
      }
    }
    
    return true;
  });
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

15. Bonfire - Seek and Destroy 2.js

function destroyer(arr) {
  // Remove all the values
  // I don't like the emptiness :P
  
  // grab the other args
  var args = [].slice.call(arguments, 1);
  
  // filter the given array
  return arr.filter(function (el) {
    // return a Boolean true if args elements doesn't match el
    return args.reduce(function (res, curr) {
        return res && curr !== el;
      }, true);
    });
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

15. Bonfire - Seek and Destroy 3.js

function destroyer(arr) {
  // Remove all the values
  // I don't like the emptiness :P
  
  // grab the other args
  var args = [].slice.call(arguments, 1);
  
  // filter the given array
  return arr.filter(function (el) {
    // return elements not in the args
    return args.indexOf(el) === -1;
  });
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

15. Bonfire - Seek and Destroy 4.js

function destroyer(arr, ...args) {
  return arr.filter((el) => !args.includes(el))
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

16. Bonfire - Finders Keepers.js

function find(arr, func) {
  // Find me if you can
  return arr.filter(func)[0];
}

find([1, 2, 3, 4], function(num){ return num % 2 === 0; });

16. Bonfire - Where do I belong.js

function where(arr, num) {
  // Find my place in this sorted array.
  // Why? Are you lost?

  return arr.reduce((pos, curr) => num <= curr ? pos : pos + 1, 0);
}

where([40, 60], 50);

17. Bonfire - Drop it 1.js

function drop(arr, func) {
  // Drop them elements.
  // They're not eggs!
  for(var i = 0; i < arr.length; i++) {
      if(func(arr[i])) {
          return arr.slice(i);
      }
  }
  return [];
}

drop([1, 2, 3], function(n) {return n < 3; });

17. Bonfire - Drop it 2.js

function drop(arr, func) {
  // Drop them elements.
  // They're not eggs!
  'use strict';
  for(let el of arr) {
      if(func(el)) {
          return arr.slice(arr.indexOf(el));
      }
  }
  return [];
}

drop([1, 2, 3], function(n) {return n < 3; });

18. Bonfire - Caesar's Cipher.js

function rot13(str) { // LBH QVQ VG!
  return str.replace(/[A-Z]/g, (L) => String.fromCharCode(65 + L.charCodeAt(0) % 26));
}

rot13("SERR PBQR PNZC");

Arguments Optional 1.js

function addTogether(a, b) {
  return typeof a === 'number' ?
    (arguments.length < 2 
       ? addTogether.bind(null, a) 
       : typeof b === 'number' ? a + b : undefined
    ) : undefined;
}

addTogether('2',3);
addTogether(0, 3);
addTogether(0, 0);
addTogether(0.5, 0.5);
addTogether(0.5, 2.5);
addTogether(-2.5, 0);
addTogether(0, '0');

Arguments Optional 2.js

function addTogether(a, b) {
  if (typeof a !== 'number') {
    return;
  }
  
  if (arguments.length < 2) {
    return addTogether.bind(null, a);
  }
  
  if (typeof b !== 'number') {
    return;
  }
  
  return a + b;
}

Binary Agents 1.js

function binaryAgent(str) {
  return str.replace(/\d+\s?/g, val => String.fromCodePoint(parseInt(val, 2)))
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")

Binary Agents 2.js

function binaryAgent(str) {
  return String.fromCodePoint.apply(
    null,
    str.split(' ').map(val => parseInt(val, 2))
  )
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111")

Diff Two Arrays.js

function diffArray(arr1, arr2) {
  // Same, same; but different.
  return arr1.filter(el => !arr2.includes(el))
  .concat(arr2.filter(el => !arr1.includes(el)));
}

diff([1, 2, 3, 5], [1, 2, 3, 4, 5]);

Everything Be True.js

function truthCheck(collection, pre) {
  // Is everyone being true?
  return collection.every(obj => obj[pre]);
}

truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

Exact Change.js

function checkCashRegister(price, cash, cid) {
  const currenciesVal = {
    'ONE HUNDRED': 100,
    TWENTY: 20,
    TEN: 10,
    FIVE: 5,
    ONE: 1,
    QUARTER: 0.25,
    DIME: 0.1,
    NICKEL: 0.05,
    PENNY: 0.01,
  }

  let remains = +(cash - price).toFixed(2)
  const total = +(cid.reduce((sum, cashes) => sum + cashes[1], 0)).toFixed(2)

  if (remains === total) {
    return 'Closed'
  }

  // Here is your change, ma'am.
  return cid.reverse()
    .reduce((returnVal, currCID, idx) => {
      const type = currCID[0] // currency type
      const val = currenciesVal[type] // currency value
      const avail = currCID[1] // currency available in drawer

      // amount to spend for this currency in drawer
      const usage = Math.floor(Math.min(avail, remains) / val) * val

      // remaining amount after deducing the used amount
      remains = +(remains - usage).toFixed(2)

      // if this is the last cash drawer and there are still change left
      if ((idx === cid.length - 1) && remains) {
        return 'Insufficient Funds'
      }

      // if currency used, then add it to value
      if (usage) {
        returnVal.push([type, usage])
      }

      return returnVal
    }, [])
}

console.log(
	checkCashRegister(19.50, 20.00, [
		["PENNY", 1.01],
		["NICKEL", 2.05],
		["DIME", 3.10],
		["QUARTER", 4.25],
		["ONE", 90.00],
		["FIVE", 55.00],
		["TEN", 20.00],
		["TWENTY", 60.00],
		["ONE HUNDRED", 100.00]
	])
)

Mutations 1.js

function mutation(arr) {
  // change is the only constant in universe
  
  return arr[1].toLowerCase().split('').every(letter => arr[0].toLowerCase().includes(letter));
}

mutation(['hello', 'hey']); // false
mutation(['hello', 'helloy']); // false
mutation(['hello', 'yellow']); // false

Mutations 2.js

function mutation(arr) {
  // change is the only constant in universe
  
  var test = arr[1].toLowerCase(),
      target = arr[0].toLowerCase();
  
  for(var i = 0; i < test.length; i++) {
    if(target.indexOf(test[i]) < 0) {
      return false;
    }
  }
  
  return true;
}

mutation(['hello', 'hey']);

Pig Latin.js

function translatePigLatin(str) {
  return /^[aeiou]/.test(str)
    ? str + 'way'
    : str.replace(/([^aeiou]+)(.+)/, '$2$1ay')
}

translatePigLatin("consonant")

Profile Lookup.js

function lookUpProfile(firstName, prop) {
  const foundContact = contacts.find(contact => contact.firstName === firstName)

  if (!foundContact) return "No such contact"

  return foundContact.hasOwnProperty(prop)
    ? foundContact[prop]
    : "No such property"
}

lookUpProfile("Akira", "likes")

Record Collection.js

function updateRecords(id, prop, value) {
  // store the collection with corresponding collection id
  const col = collection[id]
  
  // check if value is empty/blank
  if(value === '') {
    // delete the property entirely
    delete col[prop]
    return collection // exit the function
  }
  
  // check if prop is tracks
  if (prop === 'tracks') {
    // check if prop exists and push the value at the end  
    if (col[prop]) col[prop].push(value)
    // otherwise, assign a new array with value as 1st element
    else col[prop] = [value]
    return collection // exit the function
  } 
  
  // if code has reached till this point, means
  // value must not be blank
  // and prop must not be tracks
  // so assign the prop with the value
  col[prop] = value
  
  return collection // exit the function
}

Sorted Union.js

function uniteUnique(...arrs) {
  return [].concat(...arrs).filter(
  	(val, idx, currArr) => currArr.indexOf(val) === idx
  )
}

uniteUnique([1, 3, 2], [5, 2, 1, 4], [2, 1])

Spinal Tap Case 1.js

function spinalCase(str) {
  // "It's such a fine line between stupid, and clever."
  // --David St. Hubbins
  
  return str.replace(
    /[_\s](\w)|(?=[A-Z])/g,
    (s, w) => w ? '-'+w : '-'
  ).replace(/^-/, '').toLowerCase()
}

spinalCase('This Is Spinal Tap')

Spinal Tap Case 2.js

function spinalCase(str) {
  // "It's such a fine line between stupid, and clever."
  // --David St. Hubbins

  return str.split(/\s|_|(?=[A-Z])/).join('-').toLowerCase()
}

spinalCase('This Is Spinal Tap')

Steamroller.js

function steamrollArray (arr) { 
  return Array.isArray(arr) 
    ? [].concat.apply([], arr.map(steamrollArray)) 
    : arr
}

steamrollArray([1, [2], [3, [[4]]]])

Sum All Numbers in a Range.js

function sumAll([firstNum, lastNum]) {
  // Buckle up everything to one!
  // Using Arithmetic Progression summing formula
  // https://en.wikipedia.org/wiki/Arithmetic_progression#Sum
  return (Math.abs(lastNum - firstNum) + 1) * (firstNum + lastNum) / 2;
}

sumAll([10, 1]); // 55

Symmetric Difference.js

function sym(...arrays) {
  // Same, Same
  // But different
  
  return arrays.reduce((symDiff, arr) =>
    symDiff.concat(arr)
    .filter((val, idx, theArr) =>
      theArr.indexOf(val) === idx && !(symDiff.includes(val) && arr.includes(val))
    )
  )
}

sym([1, 2, 3], [5, 2, 1, 4]);