Suggested Solutions

Hopefully you’ve tried out the exercises before you’re reading this far. No cheating!

Remember, each suggested solution is just one of a bunch of different ways to approach the problems. They’re not “the right answer,” but they do illustrate a reasonable way to approach each exercise.

The most important benefit you can get from reading these suggested solutions is to compare them to your code and analyze why we each made similar or different choices. Don’t get into too much bikeshedding; try to stay focused on the main topic rather than the small details.

Suggested: Buckets of Marbles

The Buckets of Marbles Exercise can be solved like this:

  1. // RED(1)
  2. const howMany = 100;
  4. // Sieve of Eratosthenes
  5. function findPrimes(howMany) {
  6.     // BLUE(2)
  7.     var sieve = Array(howMany).fill(true);
  8.     var max = Math.sqrt(howMany);
  10.     for (let i = 2; i < max; i++) {
  11.         // GREEN(3)
  12.         if (sieve[i]) {
  13.             // ORANGE(4)
  14.             let j = Math.pow(i,2);
  15.             for (let k = j; k < howMany; k += i) {
  16.                 // PURPLE(5)
  17.                 sieve[k] = false;
  18.             }
  19.         }
  20.     }
  22.     return sieve
  23.         .map(function getPrime(flag,prime){
  24.             // PINK(6)
  25.             if (flag) return prime;
  26.             return flag;
  27.         })
  28.         .filter(function onlyPrimes(v){
  29.             // YELLOW(7)
  30.             return !!v;
  31.         })
  32.         .slice(1);
  33. }
  35. findPrimes(howMany);
  36. // [
  37. //    2, 3, 5, 7, 11, 13, 17,
  38. //    19, 23, 29, 31, 37, 41,
  39. //    43, 47, 53, 59, 61, 67,
  40. //    71, 73, 79, 83, 89, 97
  41. // ]

Suggested: Closure (PART 1)

The Closure Exercise (PART 1) for isPrime(..) and factorize(..), can be solved like this:

  1. var isPrime = (function isPrime(v){
  2.     var primes = {};
  4.     return function isPrime(v) {
  5.         if (v in primes) {
  6.             return primes[v];
  7.         }
  8.         if (v <= 3) {
  9.             return (primes[v] = v > 1);
  10.         }
  11.         if (v % 2 == 0 || v % 3 == 0) {
  12.             return (primes[v] = false);
  13.         }
  14.         let vSqrt = Math.sqrt(v);
  15.         for (let i = 5; i <= vSqrt; i += 6) {
  16.             if (v % i == 0 || v % (i + 2) == 0) {
  17.                 return (primes[v] = false);
  18.             }
  19.         }
  20.         return (primes[v] = true);
  21.     };
  22. })();
  24. var factorize = (function factorize(v){
  25.     var factors = {};
  27.     return function findFactors(v) {
  28.         if (v in factors) {
  29.             return factors[v];
  30.         }
  31.         if (!isPrime(v)) {
  32.             let i = Math.floor(Math.sqrt(v));
  33.             while (v % i != 0) {
  34.                 i--;
  35.             }
  36.             return (factors[v] = [
  37.                 ...findFactors(i),
  38.                 ...findFactors(v / i)
  39.             ]);
  40.         }
  41.         return (factors[v] = [v]);
  42.     };
  43. })();

The general steps I used for each utility:

  1. Wrap an IIFE to define the scope for the cache variable to reside.

  2. In the underlying call, first check the cache, and if a result is already known, return.

  3. At each place where a return was happening originally, assign to the cache and just return the results of that assignment operation—this is a space savings trick mostly just for brevity in the book.

I also renamed the inner function from factorize(..) to findFactors(..). That’s not technically necessary, but it helps it make clearer which function the recursive calls invoke.

Suggested: Closure (PART 2)

The Closure Exercise (PART 2) toggle(..) can be solved like this:

  1. function toggle(...vals) {
  2.     var unset = {};
  3.     var cur = unset;
  5.     return function next(){
  6.         // save previous value back at
  7.         // the end of the list
  8.         if (cur != unset) {
  9.             vals.push(cur);
  10.         }
  11.         cur = vals.shift();
  12.         return cur;
  13.     };
  14. }
  16. var hello = toggle("hello");
  17. var onOff = toggle("on","off");
  18. var speed = toggle("slow","medium","fast");
  20. hello();      // "hello"
  21. hello();      // "hello"
  23. onOff();      // "on"
  24. onOff();      // "off"
  25. onOff();      // "on"
  27. speed();      // "slow"
  28. speed();      // "medium"
  29. speed();      // "fast"
  30. speed();      // "slow"

Suggested: Closure (PART 3)

The Closure Exercise (PART 3) calculator() can be solved like this:

  1. // from earlier:
  2. //
  3. // function useCalc(..) { .. }
  4. // function formatTotal(..) { .. }
  6. function calculator() {
  7.     var currentTotal = 0;
  8.     var currentVal = "";
  9.     var currentOper = "=";
  11.     return pressKey;
  13.     // ********************
  15.     function pressKey(key){
  16.         // number key?
  17.         if (/\d/.test(key)) {
  18.             currentVal += key;
  19.             return key;
  20.         }
  21.         // operator key?
  22.         else if (/[+*/-]/.test(key)) {
  23.             // multiple operations in a series?
  24.             if (
  25.                 currentOper != "=" &&
  26.                 currentVal != ""
  27.             ) {
  28.                 // implied '=' keypress
  29.                 pressKey("=");
  30.             }
  31.             else if (currentVal != "") {
  32.                 currentTotal = Number(currentVal);
  33.             }
  34.             currentOper = key;
  35.             currentVal = "";
  36.             return key;
  37.         }
  38.         // = key?
  39.         else if (
  40.             key == "=" &&
  41.             currentOper != "="
  42.         ) {
  43.             currentTotal = op(
  44.                 currentTotal,
  45.                 currentOper,
  46.                 Number(currentVal)
  47.             );
  48.             currentOper = "=";
  49.             currentVal = "";
  50.             return formatTotal(currentTotal);
  51.         }
  52.         return "";
  53.     };
  55.     function op(val1,oper,val2) {
  56.         var ops = {
  57.             // NOTE: using arrow functions
  58.             // only for brevity in the book
  59.             "+": (v1,v2) => v1 + v2,
  60.             "-": (v1,v2) => v1 - v2,
  61.             "*": (v1,v2) => v1 * v2,
  62.             "/": (v1,v2) => v1 / v2
  63.         };
  64.         return ops[oper](val1,val2);
  65.     }
  66. }
  68. var calc = calculator();
  70. useCalc(calc,"4+3=");           // 4+3=7
  71. useCalc(calc,"+9=");            // +9=16
  72. useCalc(calc,"*8=");            // *5=128
  73. useCalc(calc,"7*2*3=");         // 7*2*3=42
  74. useCalc(calc,"1/0=");           // 1/0=ERR
  75. useCalc(calc,"+3=");            // +3=ERR
  76. useCalc(calc,"51=");            // 51
NOTE:
Remember: this exercise is about closure. Don’t focus too much on the actual mechanics of a calculator, but rather on whether you are properly remembering the calculator state across function calls.

Suggested: Modules

The Modules Exercise calculator() can be solved like this:

  1. // from earlier:
  2. //
  3. // function useCalc(..) { .. }
  4. // function formatTotal(..) { .. }
  6. function calculator() {
  7.     var currentTotal = 0;
  8.     var currentVal = "";
  9.     var currentOper = "=";
  11.     var publicAPI = {
  12.         number,
  13.         eq,
  14.         plus() { return operator("+"); },
  15.         minus() { return operator("-"); },
  16.         mult() { return operator("*"); },
  17.         div() { return operator("/"); }
  18.     };
  20.     return publicAPI;
  22.     // ********************
  24.     function number(key) {
  25.         // number key?
  26.         if (/\d/.test(key)) {
  27.             currentVal += key;
  28.             return key;
  29.         }
  30.     }
  32.     function eq() {
  33.         // = key?
  34.         if (currentOper != "=") {
  35.             currentTotal = op(
  36.                 currentTotal,
  37.                 currentOper,
  38.                 Number(currentVal)
  39.             );
  40.             currentOper = "=";
  41.             currentVal = "";
  42.             return formatTotal(currentTotal);
  43.         }
  44.         return "";
  45.     }
  47.     function operator(key) {
  48.         // multiple operations in a series?
  49.         if (
  50.             currentOper != "=" &&
  51.             currentVal != ""
  52.         ) {
  53.             // implied '=' keypress
  54.             eq();
  55.         }
  56.         else if (currentVal != "") {
  57.             currentTotal = Number(currentVal);
  58.         }
  59.         currentOper = key;
  60.         currentVal = "";
  61.         return key;
  62.     }
  64.     function op(val1,oper,val2) {
  65.         var ops = {
  66.             // NOTE: using arrow functions
  67.             // only for brevity in the book
  68.             "+": (v1,v2) => v1 + v2,
  69.             "-": (v1,v2) => v1 - v2,
  70.             "*": (v1,v2) => v1 * v2,
  71.             "/": (v1,v2) => v1 / v2
  72.         };
  73.         return ops[oper](val1,val2);
  74.     }
  75. }
  77. var calc = calculator();
  79. useCalc(calc,"4+3=");           // 4+3=7
  80. useCalc(calc,"+9=");            // +9=16
  81. useCalc(calc,"*8=");            // *5=128
  82. useCalc(calc,"7*2*3=");         // 7*2*3=42
  83. useCalc(calc,"1/0=");           // 1/0=ERR
  84. useCalc(calc,"+3=");            // +3=ERR
  85. useCalc(calc,"51=");            // 51

That’s it for this book, congratulations on your achievement! When you’re ready, move on to Book 3, Objects & Classes.

[^MathJSisPrime]: Math.js: isPrime(..), https://github.com/josdejong/mathjs/blob/develop/src/function/utils/isPrime.js, 3 March 2020.