Refactoring Process

starter-code/src/array-functions.js

@@ -1,33 +1,52 @@
-var ArrayFunctions = function (){}
+class ArrayFunctions {
+  constructor(){
+    this.array = [];
+
+  }
+  printSpecial(array) {
+    return array.join(" --- ");
+  };
+
+  doubleArray(array){
+    return array.map((number)=>{
+      return number * 2;
+    });
+  };
+
+  superPower(array){
+    return array.reduce((sum, number, index)=>{
+      return sum + (number * (Math.pow(10, index)));
+    });
+  }
+}
+module.exports = ArrayFunctions;
 
 // 1) Define a function that takes an array with numbers and prints all the elements of the array, separated by " --- "
 // ArrayFunctions.printSpecial([12, 33, 144, 122])
 // 12 -- 33 -- 144 -- 122
 
-ArrayFunctions.prototype.printSpecial = function (array) {
-  return array.join(" --- ");
-};
+// ArrayFunctions.prototype.printSpecial = function (array) {
+//   return array.join(" --- ");
+// };
 
 // 2) Define a function that takes an array with numbers and returns another array where each element contains double each element in the array
 // ArrayFunctions.doubleMyArray([10, 20, 35, 12])
 // [20, 40, 70, 24]
 
-ArrayFunctions.prototype.doubleArray = function(array){
-  return array.map(function(number){
-    return number * 2;
-  });
-};
+// ArrayFunctions.prototype.doubleArray = function(array){
+//   return array.map(function(number){
+//     return number * 2;
+//   });
+// };
 
 // 3) Define a function that takes an array with numbers and returns the result of multiplying each element by ten to the power of the position it's in:
 // ArrayFunctions.superPower([1,2,3,4,5])
 // 54321
 // explanation: (1 x 10^0) + (2 x 10^1) + (3 x 10^2) + (4 x 10^3) + (5 x 10^4)
 // explanation: (1)        + (20)       + (300)      + (4000)     + (50000)
 
-ArrayFunctions.prototype.superPower = function(array){
-  return array.reduce(function(sum, number, index){
-    return sum + (number * (Math.pow(10, index)));
-  });
-}
-
-module.exports = ArrayFunctions;
+// ArrayFunctions.prototype.superPower = function(array){
+//   return array.reduce(function(sum, number, index){
+//     return sum + (number * (Math.pow(10, index)));
+//   });
+// }

starter-code/src/bubble-sort.js

@@ -1,12 +1,12 @@
 function bubbleSort(array) {
-    var length = array.length;
-    for (var i = (length - 1); i > 0; i--) {
+    const length = array.length;
+    for (let i = (length - 1); i > 0; i--) {
         // Number of passes
-        for (var j = (length - i); j > 0; j--) {
+        for (let j = (length - i); j > 0; j--) {
             // Compare the adjacent positions
             if (array[j] < array[j - 1]) {
                 // Swap the numbers
-                var tmp = array[j];
+                let tmp = array[j];
                 array[j] = array[j - 1];
                 array[j - 1] = tmp;
             }

starter-code/src/merge-sort.js

@@ -1,15 +1,15 @@
 function mergeSort(array) {
   if(array.length < 2) { return array }
 
-  var middle  = Math.floor(array.length / 2);
-  var left    = array.slice(0, middle);
-  var right   = array.slice(middle);
+  const middle  = Math.floor(array.length / 2);
+  const left    = array.slice(0, middle);
+  const right   = array.slice(middle);
 
   return sortHalves(mergeSort(left), mergeSort(right));
 }
 
 function sortHalves(left, right) {
-  var array = [];
+  let array = [];
 
   while(left.length && right.length) {
     if(left[0] < right[0]) {
@@ -21,7 +21,8 @@ function sortHalves(left, right) {
   // array.slice() with no arguments is a trick to make a copy of the array
   // .concat is to smash all of the arrays together
   // ...maybe there's an ES6 way to do this?
-  return array.concat(left.slice()).concat(right.slice());
+  // return array.concat(left.slice()).concat(right.slice());
+  return [...array, ...left, ...right];
 }
 
 module.exports = mergeSort;

starter-code/src/sequencer.js

@@ -1,68 +1,133 @@
-var LetterSequence = function(){}
+class LetterSequence {
+  constructor (){}
 
-LetterSequence.prototype.createSequence = function(sequence){
-  var characters      = sequence.split("");
-  var containerString = "";
-  var repeatCount     = 1;
+  createSequence (sequence) {
+    let characters      =  [...sequence];
+    let containerString = "";
+    let repeatCount     = 1;
 
-  for (var i = 0; i < characters.length; i++){
-    var currentChar = characters[i];
-    var prevChar    = characters[i - 1];
-    var nextChar    = characters[i + 1];
+    for (let i = 0; i < characters.length; i++){
+      let currentChar = characters[i];
+      let prevChar    = characters[i - 1];
+      let nextChar    = characters[i + 1];
 
-    if (currentChar === prevChar){
-      repeatCount++
+      if (currentChar === prevChar){
+        repeatCount++
+      }
+      if (currentChar !== nextChar && repeatCount >= 1){
+        let repeats = repeatCount > 1 ? String(repeatCount) : ""
+        containerString += (repeats + currentChar)
+        repeatCount = 1;
+      }
     }
+    return containerString;
+  }
+
+  decodeSequence (sequence){
+    let containerString = "";
+    let characters      =  [...sequence];
 
-    // If the sequence is broken, and the repeat count is greater than 1
-    // add the letter and the repeat count to the return string
-    if (currentChar !== nextChar && repeatCount >= 1){
-      var repeats = repeatCount > 1 ? String(repeatCount) : ""
-      containerString += (repeats + currentChar)
-      repeatCount = 1;
+    for (let i = 0; i < characters.length; i++){
+      let current         = characters[i];
+      let nextChar        = characters[i + 1];
+
+      // If the current character is not a number, then there must be a letter after it
+      if (!isNaN(characters[i])){
+        // So repeat it n times, and add it to our return value
+        let letters = this._repeat(current, nextChar);
+        containerString += letters;
+      // If the current character is a letter, and the last character is a letter, then
+      // it must be a lone letter
+      } else if (isNaN(characters[i]) && isNaN(characters[i - 1])){
+        containerString += characters[i]
+      }
     }
+    return containerString;
   }
 
-  return containerString;
-}
+  _repeat(count, character){
+    let characters = "";
 
-LetterSequence.prototype.decodeSequence = function(sequence){
-  var containerString = "";
-  var characters      = sequence.split("");
-
-  for (var i = 0; i < characters.length; i++){
-    var current         = characters[i];
-    var nextChar        = characters[i + 1];
-
-    // If the current character is not a number, then there must be a letter after it
-    if (!isNaN(characters[i])){
-      // So repeat it n times, and add it to our return value
-      var letters = this._repeat(current, nextChar);
-      containerString += letters;
-    // If the current character is a letter, and the last character is a letter, then
-    // it must be a lone letter
-    } else if (isNaN(characters[i]) && isNaN(characters[i - 1])){
-      containerString += characters[i]
+    if (count <= 1){
+      count = 1
+    }
+
+    for (let i = 0; i < count; i++){
+      characters += character;
     }
-  }
 
-  return containerString;
+    return characters;
+  }
 }
+  module.exports = LetterSequence;
 
-// Maybe there's a function to do this in ES6...?
 
-LetterSequence.prototype._repeat = function(count, character){
-  var characters = "";
 
-  if (count <= 1){
-    count = 1
-  }
+// let LetterSequence = function(){}
 
-  for (var i = 0; i < count; i++){
-    characters += character;
-  }
+// LetterSequence.prototype.createSequence = function(sequence){
+//   let characters      = sequence.split("");
+//   let containerString = "";
+//   let repeatCount     = 1;
+//
+//   for (let i = 0; i < characters.length; i++){
+//     let currentChar = characters[i];
+//     let prevChar    = characters[i - 1];
+//     let nextChar    = characters[i + 1];
+//
+//     if (currentChar === prevChar){
+//       repeatCount++
+//     }
+//
+//     // If the sequence is broken, and the repeat count is greater than 1
+//     // add the letter and the repeat count to the return string
+//     if (currentChar !== nextChar && repeatCount >= 1){
+//       let repeats = repeatCount > 1 ? String(repeatCount) : ""
+//       containerString += (repeats + currentChar)
+//       repeatCount = 1;
+//     }
+//   }
+//
+//   return containerString;
+// }
+//
+// LetterSequence.prototype.decodeSequence = function(sequence){
+//   let containerString = "";
+//   let characters      = sequence.split("");
+//
+//   for (let i = 0; i < characters.length; i++){
+//     let current         = characters[i];
+//     let nextChar        = characters[i + 1];
+//
+//     // If the current character is not a number, then there must be a letter after it
+//     if (!isNaN(characters[i])){
+//       // So repeat it n times, and add it to our return value
+//       let letters = this._repeat(current, nextChar);
+//       containerString += letters;
+//     // If the current character is a letter, and the last character is a letter, then
+//     // it must be a lone letter
+//     } else if (isNaN(characters[i]) && isNaN(characters[i - 1])){
+//       containerString += characters[i]
+//     }
+//   }
+//
+//   return containerString;
+// }
 
-  return characters;
-}
+// Maybe there's a function to do this in ES6...?
 
-module.exports = LetterSequence;
+// LetterSequence.prototype._repeat = function(count, character){
+//   let characters = "";
+//
+//   if (count <= 1){
+//     count = 1
+//   }
+//
+//   for (let i = 0; i < count; i++){
+//     characters += character;
+//   }
+//
+//   return characters;
+// }
+//
+// module.exports = LetterSequence;