diff --git a/starter-code/src/array-functions.js b/starter-code/src/array-functions.js index ec99c6a..e517f49 100644 --- a/starter-code/src/array-functions.js +++ b/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; diff --git a/starter-code/src/bubble-sort.js b/starter-code/src/bubble-sort.js index fe84337..f9c52b1 100644 --- a/starter-code/src/bubble-sort.js +++ b/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; } diff --git a/starter-code/src/merge-sort.js b/starter-code/src/merge-sort.js index f6e4e70..125ce60 100644 --- a/starter-code/src/merge-sort.js +++ b/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; diff --git a/starter-code/src/sequencer.js b/starter-code/src/sequencer.js index 02284cc..293a1b6 100644 --- a/starter-code/src/sequencer.js +++ b/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;