BER Oct 2018 - Feli and Katrin - Done

starter-code/src/array-functions.js

@@ -1,33 +1,20 @@
-var ArrayFunctions = function (){}
+class ArrayFunctions {
+  constructor() {
 
-// 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(" --- ");
-};
-
-// 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;
-  });
-};
-
-// 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)));
-  });
+  }
+  printSpecial(arr) {
+    return arr.join(" --- ");
+  }
+  doubleArray(arr) {
+    return arr.map((number) => {
+      return number * 2;
+    });
+  }
+  superPower(arr) {
+    return arr.reduce((sum, number, index) => {
+      return sum + (number * (Math.pow(10, index)));
+    });
+  }
 }
 
 module.exports = ArrayFunctions;

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 bubbleSort = array => {
+    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,18 +1,18 @@
-function mergeSort(array) {
-  if(array.length < 2) { return array }
+const 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 = [];
+const sortHalves = (left, right) => {
+  const array = [];
 
-  while(left.length && right.length) {
-    if(left[0] < right[0]) {
+  while (left.length && right.length) {
+    if (left[0] < right[0]) {
       array.push(left.shift());
     } else {
       array.push(right.shift());
@@ -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,57 @@
-var LetterSequence = function(){}
-
-LetterSequence.prototype.createSequence = function(sequence){
-  var characters      = sequence.split("");
-  var containerString = "";
-  var repeatCount     = 1;
-
-  for (var i = 0; i < characters.length; i++){
-    var currentChar = characters[i];
-    var prevChar    = characters[i - 1];
-    var nextChar    = characters[i + 1];
-
-    if (currentChar === prevChar){
-      repeatCount++
+class LetterSequence {
+
+  createSequence(sequence) {
+    let characters = sequence.split("");
+    let containerString = "";
+    let repeatCount = 1;
+
+    for (let i = 0; i < characters.length; i++) {
+      let [prevChar, currentChar, nextChar] = [
+        characters[i - 1],
+        characters[i],
+        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) {
+        const repeats = repeatCount > 1 ? String(repeatCount) : ""
+        containerString += (repeats + currentChar)
+        repeatCount = 1;
+      }
     }
 
-    // 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;
-    }
+    return containerString;
   }
 
-  return containerString;
-}
-
-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]
+  decodeSequence(sequence) {
+    let containerString = "";
+    let characters = sequence.split("");
+
+    for (let i = 0; i < characters.length; i++) {
+      const current = characters[i];
+      const 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
+        // const letters = this._repeat(current, nextChar);
+        let letters = nextChar.repeat(current)
+        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;
-}
-
-// Maybe there's a function to do this in ES6...?
-
-LetterSequence.prototype._repeat = function(count, character){
-  var characters = "";
-
-  if (count <= 1){
-    count = 1
+    return containerString;
   }
-
-  for (var i = 0; i < count; i++){
-    characters += character;
-  }
-
-  return characters;
 }
 
+
 module.exports = LetterSequence;