DEV Community: Kenny

Grade Summary

Kenny — Mon, 11 May 2020 04:36:41 +0000

Hi everyone!, I hope everyone is doing well during these troubling times! I ran into a particular problem, I thought would be fun to tackle and break down called Grade Summary. This function takes in a report(That happens to be a really long string) and what it returns is the average over every student including the total average of every student within an object. So lets get started with our IOCE.

Our input will be a string that will look like(not too sure why it would be input like this...):

'Jon 41 43 15 5 56\nJeremy 15 11 10 15 16\nJesse 19 17 20 19 18'

Our Output will be object where the keys are the student names and values their average. The object should also have a key named all assigned to the students' overall average, that should hopefully look similar to this.

{
    all: 15.9,
    Jon: 15.8,
    Jeremy: 13.4,
    Jesse: 18.6
}

Our Constraints will be that any calculations done, should be rounded to the tenth of a point.
Lastly there are no Edge Cases.

Since we know that our input is a string, and the output is an object with all of the student's average grade, we can declare and initialize a finalAverage object
and lets split by its line break(\n) from the string that was being inputted.
We're also going to need to a total average variable that we're going to use to keep track of the averages of the students.

const generateGradeSummary = (report) => {
  let finalAverage = {all: 0};
  let totalAverage = 0;
  let grades = report.split('\n');
};

Our currently grade will currently look like this:

[
    'Jon 41 43 15 5 56',
    'Jeremy 15 11 10 15 16',
    'Jesse 19 17 20 19 18'
]

Now that its in a form of an array we need to somehow separate the name from the string of numbers within the array. What we'd have to do to accomplish this, is to iterate through the array and split it once more by every empty space. Afterwards we're going to grab the average of each student by mapping the array from its second index and reducing the values into a single value and divide it by the number of scores that one particular student has.

The next step is to add all of our averages from each student and store them into our totalAverage variable in which we'll use to replace our all key with the correct value of the total average.

Our Final solution should look something similar to this:

const generateGradeSummary = (report) => {
  // create an finalObject, as the final output
    let finalAverage = {all: 0};
  let totalAverage = 0;
  // split the input by every line break  
  let grades = report.split('\n');
  // iterate through the grades
  grades.forEach(grade => {
    // split the array by every empty space 
    student = grade.split(' ');
    // to get the average of the students
    // map the student array starting from its seconds index
    // Convert string into number values and reduce to add them together, divided by the length of the student array
    let average = student.slice(1).map(i => Number(i)).reduce((a, b) => a + b, 0) / (student.length - 1);
    // add the students into the finalAverage object as the student's name as the key with the value of their average
    finalAverage[student[0]] = average;
  });
  // grab each key value and add them together and store into totalAverage
  for (let key in finalAverage) {
    totalAverage += finalAverage[key];
  }
  // change the all ley values into the totalAverage that was stored and divid by the number of keys
  // once done, round the value by tenths using toFixed(1);
  finalAverage.all = Number((totalAverage / (Object.keys(finalAverage).length - 1)).toFixed(1));
  // return the final output
  return finalAverage;
};

Thank you for the time to view over this post, and I hope it helps those that my have trouble if they've ever come across this problem, Thank you!
I hope everyone is staying safe until this annoying pandemic is over.

ASyncMap

Kenny — Mon, 06 Apr 2020 07:27:29 +0000

Hi everyone, Today we're going to be working on the toy problem, asyncMap!
This toy problem function has two parameters, an array of asynchronous functions which are (tasks) and a callback. Each of the tasks takes a separate callback and invokes that callback when complete. And the callback being passed into asyncMap is then performed on the results of the callbacks of the tasks. The order of the tasks should be the same as the results

For Example:

asyncMap([
function(cb){
  setTimeout(function(){
    cb('one');
  }, 200);
},
function(cb){
  setTimeout(function(){
    cb('two');
  }, 100);
}
],

function(results){
  // the results array will equal ['one','two'] even though
  // the second function had a shorter timeout.
  console.log(results); // ['one', 'two']
});

Lets break down, this function first we'll need an results array to become our final product to call our callback on, and we'll create a count variable to keep track of our order of tasks by doing so our current function should look like this:

const asyncMap = (tasks, callback) => {
  // create an arr
const results = [];
  // create a count variable to be incremented
  // to keep track our tasks
  let count = 0;
};

Next, we're going to want to iterate through our tasks that are being inputted into our function and each task that is being inputted will become an function that will be that initialized into our results array at each index. As we're doing so, we're going to want to increase our count variable as well for our conditional next.

tasks.forEach((task, i) => {
    // as we're iterating through each task, we'll 
    task(function(result){
      // initialize each result in the results array 
      results[i] = result;
      // increase the count variable for every result in the results array
      count++;
      // create a condition to check if the count is the same
      // as the tasks that are being inputed
      if(count === tasks.length){
        // if so call the callback onto the results array
        // results array should be filled with tasks

in our conditional, we're going to want to check the count is the exact same length as the task that are inputted. and if the conditional passes, we can simply just call our callback onto our results array.

Our final result for the toy problem should look like this:

const asyncMap = (tasks, callback) => {
  // create an arr
const results = [];
  // create a count variable to be incremented
  // to keep track of our tasks
  let count = 0;
  // iterate through the tasks, with the element and index
  tasks.forEach((task, i) => {
    // as we're iterating through each task, we'll 
    task(function(result){
      // initialize each result in the results array 
      results[i] = result;
      // increase the count variable for every result in the results array
      count++;
      // create a condition to check if the count is the same
      // as the tasks that are being inputted
      if(count === tasks.length){
        // if so call the callback onto the results array
        // results array should be filled with tasks
        callback(results);
      }
    });
  });
};

And once you're comfortable with promises we can instead use:

const asyncMap = (tasks, callback) => {
  return Promise.all(tasks.map((task) => new Promise(task))).then(values => callback(values));
};

Thank you for taking the time looking over this blog post! This problem was fun to solve out. I hope it helps those who had troubles with this problem!
Til next time Thank you!

Character Frequency

Kenny — Mon, 30 Mar 2020 06:52:21 +0000

Hi everyone Today, we're going to go over the Character Frequency Toy Problem!
This toy problem's input will be string and output an array of arrays that is sorted in descending order by frequency and then by ascending order by character for example:

characterFrequency('mississippi');
// =>
// [
//   ['i', 4],
//   ['s', 4],
//   ['p', 2],
//   ['m', 1],
// ]

To begin we know our

Input: String

Output: An array of arrays Where the subarrays' first element is the character and second is a number of how many times it had appeared in the provided string.

So lets break down the problem a little bit We know our output should be an array of arrays, so lets create an array variable, followed by an empty object, that will be our letter counter. When we're iterating through the string to see how many character out string has and next we're going to add them into our object as we're adding them into our string we're going to give each character a number value of how many occurrences the character appears

Our current output should look like this so far:

{ m: 1, 
  i: 5,
  s: 2, 
  p: 4 }

const characterFrequency = (string) => {
  let result = [];
// create an object to keep store the value as key value pairs
  let letterCount = {};
 // loop through string
  for (let i = 0; i < string.length; i++) {
    // if the letter only appears once keep its count at one
      //else increment the count
    !letterCount[string[i]] ? letterCount[string[i]] = 1 : letterCount[string[i]]++;    
  }

Next we're going to initialize a new variable grab the keys of our letter count object using Object.Keys now that now new variable is an array we could sort it accordingly

Afterwards we'll iterate one last time for our inner array
within our loop we'll create another array variable representing our inner array we're going to add the character in the first index of our inner array and the number in the second index of inner array and push the last part of our inner array into our final result array.

 for (let j = 0; j < arrayMaker.length; j++) {
    let innerArray = [];
    // letters added to innerArray
    innerArray[0] = arrayMaker[j];
    // numbers added to innerArray
    innerArray[1] = letterCount[arrayMaker[j]];
    result.push(innerArray);
  }

Our final solution should look at little something like this:

const characterFrequency = (string) => {
  let result = [];
  // create an object to keep store the value as key value pairs
  let letterCount = {};
  // loop through string
  for (let i = 0; i < string.length; i++) {
    // if the letter only appears once keep its count at one
    if (!letterCount[string[i]]) {
      letterCount[string[i]] = 1;
    } else {
      //else increment the count
      letterCount[string[i]]++;
    }
  }
  // turn the object into an array
  let arrayMaker = Object.keys(letterCount);
  // console.log(arrayMaker);
  // sort the array
  arrayMaker.sort(function(a, b) {
    if (letterCount[b] === letterCount[a]) {
      if (a > b) {
        return 1;
      } else if (a < b) {
        return -1;
      } else {
        return 0;
      }
    }
    return letterCount[b] - letterCount[a];
  });
  // loop through the sorted array
  for (let j = 0; j < arrayMaker.length; j++) {
    let innerArray = [];
    // letters added to innerArray
    innerArray[0] = arrayMaker[j];
    // numbers added to innerArray
    innerArray[1] = letterCount[arrayMaker[j]];
    result.push(innerArray);
  }
  // console.log(result);
  return result;

};

Thank you for taking the time looking over this blog post! This problem was fun to solve out. I hope it helps those who had troubles with this problem!
Til next time Thank you!

ArrayCeption

Kenny — Mon, 23 Mar 2020 05:34:33 +0000

Hello Everyone!
We're going to work on the toy problem called ArrayCeption! Dealing with an array with an array with an array of arbitrarily nested arrays and have it return the deepest level that contains a non-array value. Essentially we're just getting the deepest level of an array with nested arrays.

To start lets break the problem down a little bit!

Input: Array

Output: A Number of how deep the array is

Since the output is a number we can a counter system for if every array we traverse into is an array we can increase that counter.

const getDeepestLevel = (array) => {
  // This function wants to know how deep an array with an arbitrarily nested arrays
  // Input: an Array
  // Output: a number that tells us how deep the array is
  // Lets create a counter variable to keep track of how deep the nested array is
  let counter = 0;
};

Now that we have our counter, next we can create an recursive function that'll do the work for us.
This function will take the array and the depth of the array.
What this function should do is to iterate through the array and check if there are any array within the array and iterate through that array that while increasing the depth level.
Once we've hit to the point where the iterated array is no longer an array we'll set the counter variable that we have in the outer scope to the to the amount of times we've iterated through that array.

  function check(array, level){
    // Iterate through the array given
    array.forEach(element => {
      // check if the element being iterated is an array
        if (Array.isArray(element)){
        // recurse the element with and increase the level by 1
        check(element, level + 1);
        // once the iterated array is no longer an array
      } else if (!Array.isArray(element)) {
        // initialize the counter as the level where it last stop its iteration
        counter = Math.max(counter, level + 1);
      } else {
        return;
      }
    });
  }

Once we've finished making our function we can just simply call the function we've created with array and the depth level.
Since we want to know the initial depth we can just start at 0

Our final function solution should look something similar to this:

const getDeepestLevel = (array) => {
  // This function wants to know how deep an array with an arbitrarily nested arrays
  // Input: an Array
  // Output: a number that tells us how deep the array is
  // Lets create a counter variable to keep track of how deep the nested array is
  let counter = 0;
  // create a recursive function that'll take the array and set a depth level
  function check(array, level){
    // Iterate through the array given
    array.forEach(element => {
      // check if the element being iterated is an array
        if (Array.isArray(element)){
        // recurse the element with and increase the level by 1
        check(element, level + 1);
        // once the iterated array is no longer an array
      } else if (!Array.isArray(element)) {
        // initialize the counter as the level where it last stop its iteration
        counter = Math.max(counter, level + 1);
      } else {
        return;
      }
    });
  }
  // recall the function with the given array with the depth level of 0
  check(array, 0);
  // return the counter
  return counter;
};

Thank you for taking the time to view over this post, I hope this helps for those who had troubles with this toy problem.
Til next time!

RockPaperScissors

Kenny — Mon, 16 Mar 2020 06:04:09 +0000

Hello everyone!
Today we're going to working on a toy problem called rockPaperScissors, This toy problem was a lot of fun to work on! The objective of this problem is to generate as many combinations possible by the number of rounds is given. So if the user wanted to input of 2 rounds, this function should give all possible outcome of rock paper scissors

const rockPaperScissors = (rounds) => {
}

To start lets try to break the problem down a little bit

Input: Number

Output: Array of possible outcomes of rock paper scissors

const rockPaperScissors = (rounds) => {
  // This function wants a all possible outcome of rock paper scissors depending on the rounds that is being inputed(number)
  // Input: Number of Rounds
  // Output: possible outcome stored in an array
  // Lets create an outcome array to be receiving the possible outcome and return as final result
  let outcome = [];
  // create an array storage containing respective rock, paper, scissors to be iterated through.
  let rps = ['rock', 'paper', 'scissors'];
};

With the first thought, couldn't we just use a for-loop and keep pushing the results into the array to solve the problem? Well it is possible to use a for-loop way, but it'll become tedious and redundant dealing with nested for-loops, but my recommendation would be to use a recursive helper function within the function and calling it in the function.

Alright we're going to create a recursive function within our function that will go access our rock paper scissors array and add them into our output.

const roundChoices = function(round, roundNumber) {
    //iterate through the rock paper scissors array to give possible options
    rps.forEach((options) => {
      // put those options in our round array
      round.push(options);
      // using Ternary to check if the roundNumber is equal to the rounds being inputed.
      roundNumber === rounds ?
      // if so pushed the store the round results into or outcome
      // if not recursively call function with the roundNumber plue 1
      outcome.push(round.slice()) : roundChoices(round, roundNumber + 1);
      // pop off the round result;
      round.pop();
    });
   };

In the code above we're going to iterate through our rock paper scissors array and put the options into our array param and check to see if the roundNumber param is equal to the initial rounds param of our given function. If so we would complete the function by adding all of the results into our outcome array. If not it'll recall it's self with the round Number incremented

Our final solution should be:

const rockPaperScissors = (rounds) => {
  // This function wants a all possible outcome of rock paper scissors depending on the rounds that is being inputed(number)
  // Input: Number of Rounds
  // Output: possible outcome stored in an array
  // Lets create an outcome array to be receiving the possible outcome and return as final result
  let outcome = [];
  // create an array storage containing respective rock, paper, scissors to be iterated through.
  let rps = ['rock', 'paper', 'scissors'];
  // create a recursive helper function that will take the 
  const roundChoices = function(round, roundNumber) {
    //iterate through the rock paper scissors array to give possible options
    rps.forEach((options) => {
      // put those options in our round array
      round.push(options);
      // using Ternary to check if the roundNumber is equal to the rounds being inputed.
      roundNumber === rounds ?
      // if so pushed the store the round results into or outcome
      // if not recursively call function with the roundNumber plus 1
      outcome.push(round.slice()) : roundChoices(round, roundNumber + 1);
      // pop off the round result;
      round.pop();
    });
   };
   // call helper function
  roundChoices([], 1);
  // return the outcome
  return(outcome);
};

Thank you for taking the time to viewing over this blog.
A good little take away is making a little recursive helper function to do all the work for you instead of having to brute-force nested loops!

Stacks

Kenny — Mon, 10 Feb 2020 06:07:32 +0000

Hi everyone! This is the end of week 05 of the boot camp. We've brushing up on mySql and also learning about MongoDB. Things are slowly clicking together for me at this point. Before I was just lost, on where to start, but now I feel a bit more comfortable with full-stack development. For this week We're gonna go over with Queues and stacks. This week were given a problem a break down on stakes and queues.

In stacks we can think of it like a stack of plates in a sink. Typically if we were to wash plates in the sink, normally we'd clean the plate that was stacked on top of the stack instead of the first plate on the bottom of stack. That is an example of last in, first out; for short (LIFO). Unless you prefer to wash the first plate at the bottom of the stack, then you're my kind of person! Stacks has two principal operations that are essentially array methods

Push: that adds elements at the end of the collection.
Pop: removes the last element of the item at the end of the collection.

In this problem we have to create a stack with pseudo-classical instantiation with the push pop methods, and avoid using native array methods/properties.

With doing so We can start by simply creating a Stack function, and within the function we can initialize storage to be an empty object and a size variable that indicate the size of the stack that'll soon to be used.

const Stack = function() {
 this.storage = {};
 this.size = 0;

Now that we have our stack storage we can give it the functions of push and pop.
Since our storage is an object, we can use bracket notation to manipulate the object.

Stack.prototype.push = function(value) {
 this.storage[this.size] = value;
 this.size++;

Since we're going to add elements into the object we're going to increase the size of the stack storage for a later function

Next we're going to make a pop function for the stack, in which we're going to test the size of the storage, and if there nothing in the stack, we can just return, otherwise we'll start by initialize a popped variable to store the storage element, and delete the actual storage element. Since we're popping an element out of the storage we'd have to decrease the size of our size counter and simply return the popped variable.

Stack.prototype.pop = function() {
  if (this._size === 0) {
    return 'This stack is Empty';
  }
  let popped = this._storage[this._size - 1];
  delete this._storage[this._size - 1];
  this._size--;
  return popped;
};

Lastly we can also add size function for the stack aswell to tell us how many elements that are in the stack.

Stack.prototype.size = function() {
  return this.size;

All we had to do is just return the size counter that we've implementing in our stack constructor!

In conclusion stacks are relatively simple when it comes to adding and removing data, a little take away is that stacks are Last in, First Out (LIFO)
Thank you for taking the time to skim over my little post

Spiral traversing a matrix

Kenny — Mon, 03 Feb 2020 06:42:11 +0000

Hello readers!

This is week 4 of bootcamp and we're currently learning a little bit of the back-end side of development, and also a bit of databases like mySQL and its slowly breaking me inside and if there's a way to get a better understanding of mySQL please send help! Its been a rough month, but we're here with another toy-problem with spiral traversal! to get a grasp of the concept, our input is a matrix which is a two-dimensional array and our output is a single array.

A matrix would normally look like this:

let matrix = [
  [ 1, 2, 3],
  [ 4, 5, 6],
  [ 7, 8, 9]
];

Our output wants the elements from the matrix in a toilet-flush like formation.
so our output should look something like:

[1, 2, 3, 6, 9, 8, 7, 4, 5];

Lets jump right into it! and try to break it down!
There are many ways to solve this particular toy problem, but for this one I used a function that'll iterate through the matrix in a spiraling motion.

Lets Begin!
Since our output will be an array, its common to say we can make our output variable an empty array soon to be filled with elements! And since we're creating a recursive function within the function we can also input that as well!

function spiralTraversal(matrix) {
  let output = [];
  let spiral = function(matrix) {
 };

In the function we're going start by shifting the matrix and concatting it into the output afterwards we can start our conditionals statement. For this conditional we just want to check if there's anything left in our matrix and if there's nothing left we can just simply return it.

let spiral = function(matrix) {
  output = output.concat(matrix.shift());
  if(!matrix.length){
   return;
  }
 };

Now within the function we can start the looping process, or iterating process.
Lets create a simple loop to go forward in the matrix. Having i start from 0 and the stopping condition when that i hits the matrix's maximum length. Afterwards we're going to pop the matrix at the i index and concatting it to output.

}
    for (let i = 0; i < matrix.length - 1; i++) {
      output = output.concat(matrix[i].pop());
    }

if we console.log the output we should get [1, 2, 3, 6]

Now we're gonna go reverse the matrix and pop off each elements in the matrix and concat it our output. Next we're going to check if the matrix's elements are undefined, in order to access a matrix, we'd have to test the matrix[0][0].

    output = output.concat(matrix.pop().reverse());
     if (matrix[0][0] === undefined) {
      return;
    }

Our final step to the spiral function is to create a decrementing loop, starting from the length of the matrix. Afterwards we lastly shift the matrix at the iterated index and also concat it to our output.

for (let j = matrix.length- 1; j >= 0; j--) {
      output = output.concat(matrix[j].shift());
    }

Now that we've finish the functionality part of the function lastly outside of the loop we can just simply recursively call the function inside of itself. Since we've finally finshed the function we can call it once more in our overall function and return our output.

Thank you for taking the time to read over my post, Please let me know other ways to spiral traverse a matrix I'd love to know other ways!

Deep Equal

Kenny — Mon, 27 Jan 2020 07:49:27 +0000

Hi Everyone, This is week 3 of our bootcamp and we're presented with a few more toy problems! This weeks toy problem to took me a while to figure out, until I ran into the into a rather cheeky way of solving it, but unfortunately the constraint was NOT to use JSON.Stringify. We're going to break down the Deep Equal toy problem.

Lets get started!

const deepEquals = (obj1, obj2) => {
};

This toy problem takes in two objects and its output a boolean that determines if the two objects are deeply equivalent, which means they're both the same or not.

From here within the function we can declare a boolean variable which will be our final returned product:

const deepEquals = (obj1, obj2) => {
   let boolResult = true;
};

Our boolResult will be true for now, until we do a little bit more testing we can set it accordingly.

Next lets get the keys of both obj1 and obj2!
instead of proceeding with a for in loop we can just use Object.keys on them and store them into variables!

 const deepEquals = (obj1, obj2) => {
   let boolResult = true;
   let ob1 = Object.keys(obj1);
   let ob2 = Object.keys(obj2);
};

Now that we have both of the object's keys store in their respective variables we have one more variable to declare!
Next we're going to store a ternary into a variable to that'll test the which object key to iterate through.
The following ternary variable will test the length of object 1's keys if it is greater than or equal to object 2's keys.

 const deepEquals = (obj1, obj2) => {
   let boolResult = true;
   let ob1 = Object.keys(obj1);
   let ob2 = Object.keys(obj2);
   let objKeys = ob1.length >= ob2.length ? ob1 : ob2;

With the the last variable in play we can start the testing process!
We can start iterating through the objKeys that can be either object 1 or 2's keys. By calling forEach on the objKeys we can get the current key of the object.
Afterwards in our forEach we will test the type of both objects with its current key to equal to object. Next to be chained with its NOT recursive call

  objKeys.forEach((currentKey) => {
    if(typeof obj1[currentKey] === 'object' && typeof obj2[currentKey] === 'object'){
      if(!deepEquals(obj1[currentKey], obj2[currentKey])){
        boolResult = false;
      }

If the objects current key did not equal we'll re-initialize our boolResult to false, That will be later to be returned, We're almost done we've got an else statement to set to just test if the objects current key does NOT equal to each other and also re-initialize our boolResult to be false.

lastly we can finally return our boolResult that can be either true or false.
Our final should look something similar to this:

const deepEquals = (obj1, obj2) => {
  let boolResult = true;
    let ob1 = Object.keys(obj1);
    let ob2 = Object.keys(obj2);
    let objKeys = ob1.length >= ob2.length ? ob1 : ob2;
  objKeys.forEach((currentKey) => {
    if(typeof obj1[currentKey] === 'object' && typeof obj2[currentKey] === 'object'){
      if(!deepEquals(obj1[currentKey], obj2[currentKey])){
        boolResult = false;
      }
    } else {
     if(obj1[currentKey] !== obj2[currentKey]){
       boolResult = false;
     } 
    }
  });
  return boolResult;

If there's a much simpler way to solve this toy problem, besides using JSON.Stringify I'd love to learn a different approach on how to tackle varies toy problems!

Thank you for taking the time in having a look at my post! til next time!

Coding BootCamp & [Hint for largestProductOfThree]

Kenny — Mon, 20 Jan 2020 03:06:44 +0000

Hello, my name is Kenny, this will be my first very post of a blog! I'm currently immersed in a coding boot-camp, so I'll be using this platform to be blogging about my experiences in the boot-camp and my required blogging assignments here!

The program has been really great, the instructors at Operation Spark are here to help you improve in coding and in yourself. Instructors here gives constructive feedback that are not meant to offend but to help students improve and let them know on what areas to to work on. The program here ultimately teaches students JavaScript and autonomy. Autonomy I've learned is becoming much more self-sufficient and continuing to learn coding even after finishing class for the day.

This is the end week 2 of my immersion course, and so far we've gone through numerous exercises and sprints, and Dang were they difficult. This week we were introduced toy-problems, That got my brain juices flowing into over-drive. These problems can have a really simple solution or a very complicated solution depending on ones thought process. But it really helps on learning varies ways on solving a problem, such as breaking down a problem and take it in manageable pieces.
One problem we've been tasked to work on was a toy-problem:

"largestProductofThree"

A few thing that the boot camp has taught me was to get a GRASP of what the function should do, just to get a better understanding of how it operates.
Afterwards we can plan accordingly on how we would solve this problem.
This problem takes in an array of numbers and spits back out the highest number possible out of three of the highest possible numbers.

const largestProductOfThree = (array) => {
};

Since we know it takes an array, we could sort the array using .sort(). that way the numbers in the array will be in order from least to greatest.

array.sort((a, b) => a - b);

from here we could actually set the code above into a variable, so that way it wouldn't look as confusing in trying to solve the rest on the problem.

So lets initialize a variable of our sorted array.

let sorted = array.sort((a, b) => a - b);

Now that we have our sorted array in a variable we know what we're working on.
since this function wants the highest number possible in an array of numbers, and our array is sorted from least to greatest, we can just multiply the last three indexes of our sorted array.

let greatThree = 
   sorted[sorted.length - 1] * sorted[sorted.length - 2] * sorted[sorted.length - 3];

This way greatThree will always equal to the highest three multiple numbers in the sorted array.
Now our code should look something like this:

const largestProductOfThree = (array) => {
     let sorted = array.sort((a, b => a - b);
     let greatThree = 
   sorted[sorted.length - 1] * sorted[sorted.length - 2] * sorted[sorted.length - 3];
};

Now that is not it for this problem, it ALSO wants us to incorporate if the numbers in the array are negative as well.
I won't spoil the rest of the solution for us, hoping you could figure out the rest for yourself. I wish you best of luck!

I'll be doing doing a weekly blog post on my progress within the bootcamp with a little hint of another problem I happen to stubble upon.
Thank you for taking the time to skim over this!

Like & Follow on my Progress!