Forem: Viren B

JavaScript.info - Constructor, operator "new"

Thank you for reading!

Solving "Make a Person" / freeCodeCamp Algorithm Challenges

Viren B — Thu, 06 Aug 2020 17:18:29 +0000

** Post can also be found on virenb.cc **

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Make a Person'.

Starter Code

var Person = function(firstAndLast) {
  // Only change code below this line
  // Complete the method below and implement the others similarly
  this.getFullName = function() {
    return "";
  };
  return firstAndLast;
};

var bob = new Person('Bob Ross');
bob.getFullName();

Instructions

Fill in the object constructor with the following methods below:

getFirstName()
getLastName()
getFullName()
setFirstName(first)
setLastName(last)
setFullName(firstAndLast)

Run the tests to see the expected output for each method. The methods that take an argument must accept only one argument and it has to be a string. These methods must be the only available means of interacting with the object.

Test Cases

Object.keys(bob).length should return 6.
bob instanceof Person should return true.
bob.firstName should return undefined.
bob.lastName should return undefined.
bob.getFirstName() should return "Bob".
bob.getLastName() should return "Ross".
bob.getFullName() should return "Bob Ross".
bob.getFullName() should return "Haskell Ross" after bob.setFirstName("Haskell").
bob.getFullName() should return "Haskell Curry" after bob.setLastName("Curry").
bob.getFullName() should return "Haskell Curry" after bob.setFullName("Haskell Curry").
bob.getFirstName() should return "Haskell" after bob.setFullName("Haskell Curry").
bob.getLastName() should return "Curry" after bob.setFullName("Haskell Curry").

Our Approach

The instructions for this challenge are short and to the point.

We're working with a function expression, with an argument of firstAndLast.
It is an object constructor that we need to complete. The instructions mention methods which must be included in the object constructor.

This challenge is a little unique as we have to build out and complete an object constructor. freeCodeCamp provided a few lessons about object constructors from what I remember so it may be helpful to go back and look at them.

The instructions let us know which methods have to be created, so let's get down to it.

The argument for this constructor is firstAndLast, which will be a string of a first and last name, separated by a white space (according to our test cases). I think it will be handy to separate out the first and last name into their own variables as some methods require us to return either name. We can deconstruct the argument as seen below.

let [firstName, lastName] = firstAndLast.split(' ');
// We're splitting on the white space between the two names

var Person = function(firstAndLast) {
    let [firstName, lastName] = firstAndLast.split(' ');
    console.log(firstName, lastName)
};

Person('Bob World') // Bob, World

Okay, we won't need the console.log() in our solution but we're off to a good start.

Before we dive into approaching each method, I found this to be good documentation about constructor functions.

getFirstName()

This method, as it states, will return the first name. We have that in a variable already. So our code would look something like this:

this.getFirstName = function() {
  return firstName;
}

Our next method will be getLastName() will be the pretty much the same.

this.getLastName = function() {
  return lastName;
}

Let's skip over getFullName() for now. The reason is it will have to be updated if we run a 'set' method to change the name.

For setFirstName(), we'll have it take in an argument, and then update the firstName variable to the new one provided in this function.

this.setFirstName = function (first) {
  firstName = first;
  return firstName;
}

setLastName() will work very similarly.

this.setLastName = function (last) {
  lastName = last;
  return lastName;
}

The most challenging method is setFullName(). We will have to replace both variables with the new argument provided in this function. Like the argument of the constructor function, we assume (based off the test cases), it will be a string with a first and last name, separated by a white space.

this.setFullName = function (firstAndLast) {
  firstName = firstAndLast.split(' ')[0];
  lastName = firstAndLast.split(' ')[1];
  return `${firstName} ${lastName}`;
}

MDN: String.split()

We take the argument, split it at the white space, and then set each string into the firstName and lastName variables.

Returning to the last method we didnt cover, getFullName().

this.getFullName = function () {
    return `${firstName} ${lastName}`;
};

Our Solution

var Person = function(firstAndLast) {
  // Complete the method below and implement the others similarly

  let [firstName, lastName] = firstAndLast.split(' ');

  this.getFirstName = function() {
    return firstName;
  };

  this.getLastName = function() {
    return lastName;
  };

  this.getFullName = function() {
    return `${firstName} ${lastName}`;
  };

  this.setFirstName = function(first) {
    firstName = first;
    return firstName;
  };

  this.setLastName = function(last) {
    lastName = last;
    return lastName;
  }

  this.setFullName = function(firstAndLast) {
    firstName = firstAndLast.split(' ')[0];
    lastName = firstAndLast.split(' ')[1];
    return `${firstName} ${lastName}`;
  }

};

Links & Resources

'Make a Person' Challenge on fCC

MDN: The arguments object

Thank you for reading!

Solving "Arguments Optional" / freeCodeCamp Algorithm Challenges

Viren B — Wed, 05 Aug 2020 20:28:24 +0000

** Post can also be found on virenb.cc **

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Arguments Optional'.

Starter Code

function addTogether() {
  return false;
}

addTogether(2,3);

Instructions

Create a function that sums two arguments together. If only one argument is provided, then return a function that expects one argument and returns the sum.

For example, addTogether(2, 3) should return 5, and addTogether(2) should return a function.

Calling this returned function with a single argument will then return the sum:

var sumTwoAnd = addTogether(2);

sumTwoAnd(3) returns 5.

If either argument isn't a valid number, return undefined.

Test Cases

addTogether(2, 3) should return 5.
addTogether(23, 30) should return 53.
addTogether(5)(7) should return 12.
addTogether("http://bit.ly/IqT6zt") should return undefined.
addTogether(2, "3") should return undefined.
addTogether(2)([3]) should return undefined.

Our Approach

After reading the instructions, starter code, and test cases more than once, this is what we're working with:

We have at least one argument, a string or a number.
We need to return a number or an undefined.
We need to evaluate the argument(s). Either sum it if there is more than one number, return undefined, or return a function.

So diving straight into this...we've worked with the arguments object in a previous challenge. Looking at the test cases, we deal with different arguments (different types, etc.).

We can set the argument(s) into a variable or variables, depending on how many. We can use destructuring.

function addTogether() {
  let [arg1, arg2] = arguments;
  console.log(`${arg1}, ${arg2}`);
}

addTogether(2, 3) // 2, 3
addTogether(2)(3) // 2, undefined
addTogether("http://bit.ly/IqT6zt") // ttp://bit.ly/IqT6zt, undefined
addTogether(2)([3]) // 2, undefined

So we are setting an undefined variable as arg2. Reading back the instructions, we have to return a function if there is only one argument.

If only one argument is provided, then return a function that expects one argument and returns the sum.

Before writing that function, we should create a function to evaluate if the argument is a number. JavaScript has a built-in method to check this. It returns a true or false.

MDN: Number.isInteger()

We can add a function like the below into addTogether().

function isNum(num) {
  return Number.isInteger(num)
}

isNum(47) // true
isNum('47') // false

So we have our arguments variables and now a function to check if it is a number or not. From the instructions, if an argument is not a number, return undefined.

function addTogether() {
  let [arg1, arg2] = arguments;

  function isNum(num) {
    return Number.isInteger(num)
    }

  if (!isNum(arg1)) {
    return undefined;
  }

}

If we have two arguments which are both numbers, we can add them together. We can add that to an 'else if' statement.

function addTogether() {
  let [arg1, arg2] = arguments;

  function isNum(num) {
    return Number.isInteger(num)
    }

  if (!isNum(arg1)) {
    return undefined;
  }
   else if (isNum(arg1) && isNum(arg2)) {
    return arg1 + arg2;
  }

}

So if arg1 is not a number, we have it covered. If both arguments are numbers, we add them and have that case covered. If there is only one argument, what do we do?

If only one argument is provided, then return a function that expects one argument and returns the sum.

else if (!arg2) {
  // return a function
}

We have to return a function that expects one argument and returns the sum.

else if (!arg2) {
    return function(newArg) {
        // 
  }
}

We have newArg, we have to sum it with arg1. But first, we must check if its a number.

else if (!arg2) {
    return function(newArg) {
    if (isNum(newArg)) {
        return arg1 + newArg;
    }
  }
}

This if/else statement should be able to handle all of our test cases.

Our Solution

function addTogether() {
  let [arg1, arg2] = arguments;

  function isNum(num) {
    return Number.isInteger(num);
  }

  if (!isNum(arg1)) {
    return undefined;
  }
  else if (isNum(arg1) && isNum(arg2)) {
    return arg1 + arg2;
  }
  else if (!arg2) {
    return function(newArg) {
      if (isNum(newArg)) {
        return arg1 + newArg;
      }
    }
  }
}

Links & Resources

'Arguments Optional' Challenge on fCC

-Mozilla Developer Network

Thank you for reading!

Solving "Everything Be True" / freeCodeCamp Algorithm Challenges

Viren B — Tue, 04 Aug 2020 17:50:18 +0000

Post can also be found on virenb.cc

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Everything Be True'.

Starter Code

function truthCheck(collection, pre) {
  return pre;
}

truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex");

Instructions

Check if the predicate (second argument) is truthy on all elements of a collection (first argument).

In other words, you are given an array collection of objects. The predicate pre will be an object property and you need to return true if its value is truthy. Otherwise, return false.

In JavaScript, truthy values are values that translate to true when evaluated in a Boolean context.

Remember, you can access object properties through either dot notation or [] notation.

Test Cases (& Rules)

truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy", "sex": "male"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex") should return true.
truthCheck([{"user": "Tinky-Winky", "sex": "male"}, {"user": "Dipsy"}, {"user": "Laa-Laa", "sex": "female"}, {"user": "Po", "sex": "female"}], "sex") should return false.
truthCheck([{"user": "Tinky-Winky", "sex": "male", "age": 0}, {"user": "Dipsy", "sex": "male", "age": 3}, {"user": "Laa-Laa", "sex": "female", "age": 5}, {"user": "Po", "sex": "female", "age": 4}], "age") should return false.
truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true}, {"name": "FastForward", "onBoat": null}], "onBoat") should return false
truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastForward", "onBoat": true}], "onBoat") should return true
truthCheck([{"single": "yes"}], "single") should return true
truthCheck([{"single": ""}, {"single": "double"}], "single") should return false
truthCheck([{"single": "double"}, {"single": undefined}], "single") should return false
truthCheck([{"single": "double"}, {"single": NaN}], "single") should return false

Our Approach

After reading the instructions, starter code, and test cases more than once, this is what we're working with:

We have two arguments, collection, an array of objects and, pre, a string.
We need to return a boolean value, true or false.
We need to check each object's properties and check if the string, pre, exists in the object, and if the value is a truthy value.

So, looking at one of the test cases,

truthCheck([{"single": "double"}, {"single": NaN}], "single")
// false

should be false because the property "single" is in the objects but the second item is NaN, a falsy value.

Since collection is already in an array, we can use a for loop or map() to iterate over the items. The challenging part is we have objects within the array.

All of the built-in methods of an Object are listed here on MDN.

I've found Object.keys() to be very helpful but we want to check the value of the key as well so it may not be the best way to approach this challenge.

We can start by writing out our map().

let checkedArrr = collection.map(obj => {
  // more code
})

So we want to check that the property, which is the word from pre, exists in collection. Then we want to check that all the values are truthy.

In JavaScript, a truthy value is a value that is considered true when encountered in a Boolean context. All values are truthy unless they are defined as falsy (i.e., except for false, 0, -0, 0n, "", null, undefined, and NaN).

We will find a way to check the value but we'll first check if the property exists. Within the documentation, there is a method called hasOwnProperty(), which does exactly what it sounds like. It will return a true or false value.

MDN: Object.hasOwnProperty()

function truthCheck(collection, pre) {
    let checkedArr = collection.map(obj => {
    return obj.hasOwnProperty(pre);
  })
    return checkedArr
}

truthCheck([{"name": "Pete", "onBoat": true}, {"name": "Repeat", "onBoat": true, "alias": "Repete"}, {"name": "FastForward", "onBoat": true}], "onBoat")
// [ true, true, true ]

So we are half way there, we are able to check that the property 'onBoat' exists in every object in collection. We can see that every 'onBoat' property has a string value, so they are all truthy values. This should return true.

We have to find a way to access the value of the correct key in the object. We can do this with bracket notation.

const team = [{name: 'Leo Messi', number: 10}, {name: 'Harry Kane', number: 10}, {name: 'Luuk De Jong', number: 19}];

team.map(object => {
  return object['name']
})
// [ "Leo Messi", "Harry Kane", "Luuk De Jong" ]

So in our challenge, we've written the below code. We can add in obj[pre]:

function truthCheck(collection, pre) {
    let checkedArr = collection.map(obj => {
    return obj.hasOwnProperty(pre) && obj[pre]
  })
}

obj[pre] would just give us the value, we want to check if it is truthy or falsy. Step in Boolean. It is another built-in object which you can wrap around a value to check if it is a boolean.

MDN: Boolean

So to test out Boolean on our smaller array of objects example (we added a fourth member to our team):

const team = [{name: 'Leo Messi', number: 10}, {name: 'Harry Kane', number: 10}, {name: 'Luuk De Jong', number: 19}, {name: '', number: 45}];

team.map(object => {
  return Boolean(object['name'])
})
// [ true, true, true, false ]

The fourth item did not have a name, just an empty string, so it returned false. Back to our challenge, we can wrap Boolean around obj[pre].

function truthCheck(collection, pre) {
    let checkedArr = collection.map(obj => {
    return obj.hasOwnProperty(pre) && Boolean(obj[pre]);
  })
}

So we're now able to return an array of true or false values. This is progress but we have to return a single true or false. If one object's value is falsy, we have to return false. So since the above code was giving us an array of true and falses, we can check if even one false exists, we can return false.

MDN: Array.includes()

This method is a little new-er to me but it does the job we want here. We can run checkedArr.includes() to see if the array includes false. I think a ternary operator is a nice way to write this out.

return checkedArr.includes(false) ? false : true;

That is all!

Our Solution

function truthCheck(collection, pre) {
  let checkedArr = collection.map(obj => {
    return obj.hasOwnProperty(pre) && Boolean(obj[pre]);
  })

  return checkedArr.includes(false) ? false : true;
}

Links & Resources

'Everything Be True' Challenge on fCC

MDN: String.fromCharCode()

Thank you for reading!

Solving "Binary Agents" / freeCodeCamp Algorithm Challenges

Viren B — Mon, 03 Aug 2020 21:01:59 +0000

Post can also be found on virenb.cc

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Binary Agents'.

Starter Code

function binaryAgent(str) {
  return str;
}

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111");

Instructions

Return an English translated sentence of the passed binary string.

The binary string will be space separated.

Test Cases (& Rules)

binaryAgent("01000001 01110010 01100101 01101110 00100111 01110100 00100000 01100010 01101111 01101110 01100110 01101001 01110010 01100101 01110011 00100000 01100110 01110101 01101110 00100001 00111111") should return "Aren't bonfires fun!?"
binaryAgent("01001001 00100000 01101100 01101111 01110110 01100101 00100000 01000110 01110010 01100101 01100101 01000011 01101111 01100100 01100101 01000011 01100001 01101101 01110000 00100001") should return "I love FreeCodeCamp!"

Our Approach

After reading the instructions, starter code, and test cases more than once, this is what we're working with:

Our function takes in one argument, str, a string. It is a sentence of binary digits, 0's and 1's.
We must return a string.
We need to convert str to an English sentence.

To begin solving this challenge, let us look at the argument, str. The two test cases have str has long binary sentences. We know that binary strings can be translated to English letters and characters.

We can convert our str string to an array using split(' '). Split() with ' ' will separate the string at each whitespace.

String.split() on MDN

"01000001 01110010 01100101 01101110 00100111 01110100 00100000".split(' ')
// [ "01000001", "01110010", "01100101", "01101110", "00100111", "01110100", "00100000" ]

We now have an array of strings (binary values still). Having an array, we can evaluate each value and figure out how convert the value from binary to English characters. We can opt for a for loop or another method like map().

We can iterate through the array with map(), but how to translate each index? Looking at built-in String methods, one which could be of use is fromCharCode().

The static String.fromCharCode() method returns a string created from the specified sequence of UTF-16 code units.

This is useful but would not work yet since our strings are in binary. There is another method, parseInt(), to convert each binary string to decimal.

MDN: parseInt()

parseInt(str, radix)
// radix = 2

parseInt('01000001', 2)
// 65

String.fromCharCode(65)
// A

So we can combine these within our map() function.

str.split(' ') // Creates an array
     .map(b => String.fromCharCode(parseInt(b, 2))) // iterates through the array, converts binary to decimal then returns a character

Here is a little example:

str = "01001000 01001001 00100001";
str.split(' ') // [ "01001000", "01001001", "00100001" ]
str.map(b => String.fromCharCode(parseInt(b, 2)))
// 1. parseInt('01001000', 2) // 72
// 1a. String.fromCharCode(72) // H

// 2. parseInt('01001001', 2) // 73
// 2a. String.fromCharCode(73) // I

// 3. parseInt('00100001', 2) // 33
// 3a. String.fromCharCode(33) // !

The last step is to join back the array into a string.

And return! My solution is to chain everything instead of creating a variable.

Our Solution

function binaryAgent(str) {
  return str.split(' ')
            .map(b => String.fromCharCode(parseInt(b, 2)))
            .join('');
}

Links & Resources

'Binary Agents' Challenge on fCC

'Steamroller' Challenge on fCC

Thank you for reading!

Solving "Steamroller" / freeCodeCamp Algorithm Challenges

Viren B — Fri, 31 Jul 2020 11:32:44 +0000

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Steamroller'.

Starter Code

function steamrollArray(arr) {
  return arr;
}

steamrollArray([1, [2], [3, [[4]]]]);

Instructions

Flatten a nested array. You must account for varying levels of nesting.

Test Cases (& Rules)

steamrollArray([[["a"]], [["b"]]]) should return ["a", "b"].
steamrollArray([1, [2], [3, [[4]]]]) should return [1, 2, 3, 4].
steamrollArray([1, [], [3, [[4]]]]) should return [1, 3, 4].
steamrollArray([1, {}, [3, [[4]]]]) should return [1, {}, 3, 4].
Your solution should not use the Array.prototype.flat() or Array.prototype.flatMap() methods.

Our Approach

After reading the instructions, starter code, and test cases more than once, this is what we're working with:

Our function takes in one argument, arr, which is an array of subarrays (contains numbers, strings, objects).
We must return the array flattened (see test cases).
Must do this without methods such as flat() or flatMap().

Looking at all the test cases, we have some interesting cases like [[4]]] as an index in arr. We need to go visit each index and remove them from an array, if they are in one.

The first thing I will do is create an empty array, to hold our new flattened array.

let flattened = [];

As we have to visit each index of arr, I figured to use the method, map().

MDN: Array.map()

arr.map((val) => {
  // more code coming
})

What are we going to do at each index though? There is another array method, isArray(), to check if the value is an array or not. It will return true or false.

MDN: Array.isArray()

If the value in the index is not an array, we can add it into our new flattened array.

arr.map((val) => {
  if (!Array.isArray(val)) {
    flattened.push(val);
  }
  else {
    // see below
  }
})

That is not too complex. For our else statement, how are we handling the indexes which contain an array?

We can use the ... operator in the else statement on steamrollArray() so it will be called and flatten the array each loop. This is a recursive fashion (I believe).

arr.map((val) => {
  if (!Array.isArray(val)) {
    flattened.push(val);
  }
  else {
    flattened.push(...steamrollArray(val));
  }
})

If our arr is [[[1]], 2], our first val is [[1]]. It will not pass the if statement since it is in an array so it will be evaluated by the else statement. We're calling the same flattened.push but not on the val. We're pushing ...steamrollArray(val), which will run the function again but it flattens val with each execution. Once it is out of the subarray, it will be pushed into flattened.

Make sure to return flattened.

Our Solution

function steamrollArray(arr) {
  let flattened = [];

  arr.map(val => {
    if (!Array.isArray(val)) {
      flattened.push(val);
    }
    else {
      flattened.push(...steamrollArray(val));
    }
  })

  return flattened;
}

Links & Resources

'Drop it' Challenge on fCC

Thank you for reading!

Solving "Drop it" / freeCodeCamp Algorithm Challenges

Viren B — Fri, 31 Jul 2020 01:14:45 +0000

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Drop it'.

Starter Code

function dropElements(arr, func) {
  return arr;
}

dropElements([1, 2, 3], function(n) {return n < 3; });

Instructions

Given the array arr, iterate through and remove each element starting from the first element (the 0 index) until the function func returns true when the iterated element is passed through it.

Then return the rest of the array once the condition is satisfied, otherwise, arr should be returned as an empty array.

Test Cases

dropElements([1, 2, 3, 4], function(n) {return n >= 3;}) should return [3, 4].
dropElements([0, 1, 0, 1], function(n) {return n === 1;}) should return [1, 0, 1].
dropElements([1, 2, 3], function(n) {return n > 0;}) should return [1, 2, 3].
dropElements([1, 2, 3, 4], function(n) {return n > 5;}) should return [].
dropElements([1, 2, 3, 7, 4], function(n) {return n > 3;}) should return [7, 4].
dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;}) should return [3, 9, 2].

Our Approach

After reading the instructions, starter code, and test cases more than once, this is what we're working with:

Our function takes in two arguments, an array (arr), and a function (func). arr consists of numbers.
We must return an array.
We want to alter arr based on the constraints of func, then return arr.

I had to read the instructions a few times to get a better idea of what the challenge was actually asking for. We want to work with arr, and remove each index until we come across a truthy index. So let's explore one of the test cases first off:

dropElements([1, 2, 3, 4], function(n) {return n >= 3;}) // should return [3, 4]

So, based on the arguments, we want to evaluate arr with func and keep the values that are greater than or equal to 3. Seems some what straight forward. Let's look at the last test case provided though:

dropElements([1, 2, 3, 9, 2], function(n) {return n > 2;}) // should return [3, 9, 2].

We want values greater than two so why is [2] being returned? Have a read at the below instruction:

Then return the rest of the array once the condition is satisfied, otherwise, arr should be returned as an empty array.

So once we hit something truthy, we'll return all the following elements. This is a more clear example:

dropElements([8, 1, 2, 3], function(n) {return n > 3; });

// On arr[0], we have 8. 8 is greater than 3. Even though 1 and 2 are not greater than 3, arr[0] has already met the constraint from the function so we return the rest of the elements.

Alright, hopefully the instructions are making a little more sense now. Let's get into the code.

The first thing I will do is set a variable equal to arr's length so we know how many times to loop.

const arrLength = arr.length;

I think it is time for the for loop.

for (let i = 0; i < arrLength; i++) {}

// We'll start i at 0 since array's index begins at 0

The next thing we'll need is an if statement to see if each index meets the constraint provided in the second argument, func. func takes in one argument, n. We can use arr[0] as func's argument each loop to see if it will meet the constraint.

for (let i = 0; i < arrLength; i++) {
  if (!func(arr[0])) {
    // more code coming
  }
}

Above, I'm using arr[0] instead of arr[i] because of the code we will be putting inside the if statement. If func(arr[0]) is false, we will remove it, right? Enter the array method, shift(). pop() or push() are common but here we want to remove elements from the beginning of the array and that is what shift() does for us.

Array.shift() on MDN

for (let i = 0; i < arrLength; i++) {
  if (!func(arr[0])) {
    arr.shift();
  }
  else {
    return arr;
  }
}

So let's try this step by step with one of our test cases:

dropElements([1, 2, 3, 4], function(n) {return n >= 3;});

const arrLength = arr.length // 4
for (let i = 0; i < arrLength; i++) {
  if (!func(arr[0])) {
    arr.shift();
  }
  else {
    return arr;
  }
}

// Loop 1: arr[0] = 1; is not greater or equal to 3. shift() run
// Loop 2: [2,3,4]; arr[0] = 2; not greater or equal to 3. shift() run
// Loop 3: [3,4]; arr[0] = 3; 3 is greater than or equal. return arr

As always, return arr and that is it!

Our Solution

function dropElements(arr, func) {
  const arrLength = arr.length;
  for (let i = 0; i < arrLength; i++) {
    if (!func(arr[0])) {
      arr.shift();
    }
    else {
      return arr;
    }
  }
  return arr;
}

Links & Resources

'Smallest Common Multiple' Challenge on fCC

Thank you for reading!

Solving "Smallest Common Multiple" / freeCodeCamp Algorithm Challenges

Viren B — Wed, 29 Jul 2020 18:36:33 +0000

Also posted on virenb.cc

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Smallest Common Multiple'.

Starter Code

function smallestCommons(arr) {
  return arr;
}


smallestCommons([1,5]);

Instructions

Find the smallest common multiple of the provided parameters that can be evenly divided by both, as well as by all sequential numbers in the range between these parameters.

The range will be an array of two numbers that will not necessarily be in numerical order.

For example, if given 1 and 3, find the smallest common multiple of both 1 and 3 that is also evenly divisible by all numbers between 1 and 3. The answer here would be 6.

Test Cases

smallestCommons([1, 5]) should return a number.
smallestCommons([1, 5]) should return 60.
smallestCommons([5, 1]) should return 60.
smallestCommons([2, 10]) should return 2520.
smallestCommons([1, 13]) should return 360360.
smallestCommons([23, 18]) should return 6056820.

Our Approach

After reading the starter code, instructions, and test cases, this is what I summarized about this challenge -

We have one input, an array with two indexes, always positive numbers.
We must return a number.

We have another math based challenge, just like yesterday's. We'll look more at the formula of what is commonly referred to as Least Common Multiple (LCM).

From ThinkMath, a multiple (of a number) is any product of that number and an integer.

It is often useful to know what multiples two numbers have in common. One way is to list (some of) the multiples of each and look for a pattern. For example, to find the common (positive) multiples of 4 and 6, we might list:

Multiples of 4: 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, ...

Multiples of 6: 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, ...

The numbers 12, 24, 36, and 48 appear on both of these lists (and more would appear if the lists were longer). They are common multiples. The least common multiple is the smallest of these: 12. All the other common multiples are, themselves, multiples of the least common multiple.

Source: ThinkMath

We'll touch on the math and the challenging part in more detail soon.

I'll start off the challenge by using sort() on arr, to make sure the bigger number is the first index.

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

sort() on MDN

Next, I'll save each value into their own variable. We can do that by destructuring arr.

let arr = [100, 50];
let [high, low] = arr;
console.log(high);
// 100
console.log(low);
// 50

// Instead of 
let arr = [100, 50];
let high = arr[0];
let low = arr[1];

Destructuring on MDN

So it looks like we will use a for loop to check on the divisibility of these two numbers (and the sequence of numbers in between). Before I start the loop, I will declare one more variable:

let multiple = high;

I'm setting multiple to the larger variable, high.

For our for loop, it will run as long as low is smaller than high. See the below code -

for (let i = low; i < high; i++) {}

So, looking at our test cases, let's disect [5, 1]. Without any code, what are the multiples (the answer should be 60):

5: 1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70

1: 1, 2, 3, 4, 5

So 5 is the smallest common multiple but we want a number that is evenly divisible by all the numbers between 1 and 5. This is the real challenge. So just doing some math without code, we can study the above numbers and determine 60 is the first number that is divisble evenly by 1, 2, 3, 4, 5.

For example, if given 1 and 3, find the smallest common multiple of both 1 and 3 that is also evenly divisible by all numbers between 1 and 3. The answer here would be 6.

So in our for loop, we can first check if multiple is not divisible by low. If it is not, we will add the value of high to multiple, then reduce our i variable and keep looping.

if (multiple % 1 !== 0) {
  multiple += high;
  i = low - 1;
}

We can add an else if statement, if i equals high, we know we have found our answer. Let's see how this works step by step.

function smallestCommons(arr) {
    arr = arr.sort((a,b) => b - a);
    let [high, low] = arr;
    let multiple = high;

    for (let i = low; i < high; i++) {
        if (multiple % i !== 0) {
            multiple += high;
            i = low - 1;
        }
        else if (i == high) {
            return multiple;
        }
    return multiple
}

Starting the for loop,

i = 1, multiple = 3
- 3 / 1 = 0 reminder so we ignore the if statement (and also the else if)
i = 2, multiple = 3
- 3 /2 = 1 remainder, so we add high to multiple and also set i = low - 1;
- i = 0 but next loop we i++
i = 1, multiple = 6
- 6 / 1 remainder is 0 so we don't increment multiple
i = 2, multiple = 6
- 6 / 2 remainder is 0 so we don't increment multiple
next loop, with i++, i is no longer less than high so we exit the for loop

We return multiple

This may not be the most efficient solution!

Our Solution

function smallestCommons(arr) {
  arr = arr.sort((a,b) => b - a);
  let [high, low] = arr;
  let multiple = high;

  for (let i = low; i < high; i++) {
    if (multiple % i !== 0) {
      multiple += high;
      i = low - 1;
    }
    else if (i == high) {
      return multiple;
    }

    return multiple;
  }
}

Links & Resources

'Sum All Primes' Challenge on fCC

Thank you for reading!

Solving "Sum All Primes" / freeCodeCamp Algorithm Challenges

Viren B — Tue, 28 Jul 2020 20:08:56 +0000

Post can also be found on https://virenb.cc/fcc-029-sum-all-primes

Let's solve freeCodeCamp's intermediate algorithm scripting challenge, 'Sum All Primes'.

Starter Code

function sumPrimes(num) {
  return num;
}

sumPrimes(10);

Instructions

A prime number is a whole number greater than 1 with exactly two divisors: 1 and itself. For example, 2 is a prime number because it is only divisible by 1 and 2. In contrast, 4 is not prime since it is divisible by 1, 2 and 4.

Rewrite sumPrimes so it returns the sum of all prime numbers that are less than or equal to num.

Test Cases

sumPrimes(10) should return a number.
sumPrimes(10) should return 17.
sumPrimes(977) should return 73156.

Our Approach

The instructions for this challenge are short and to the point.

Our one input is num, an integer.
We must return an integer.
We need to do two things. Identify all the prime numbers within num and then add them up.

So, before we start, if we re-read the instructions, it provides us with a definition of what a prime number is.

A prime number is a whole number greater than 1 with exactly two divisors: 1 and itself. For example, 2 is a prime number because it is only divisible by 1 and 2. In contrast, 4 is not prime since it is divisible by 1, 2 and 4.

Some examples of prime numbers: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97

So, hopefully that gives a better idea on what a prime number is and how to find out if a number is prime.

For this challenge, I think it would be best if we broke it up into two parts. One part is to write code on figuring out if a number is prime. The second part would be to calculate the sum of all the prime numbers (within num).

Let's start with prime numbers. From the above description, a prime number is divisible only by itself and 1. While making our prime number checker function, we can start with an if statement. If the argument is less than or equal to one, we can return false as it will not be a prime number. Even though the test cases do not give us a number so small, I included it anyway.

function isPrime(n) {
  if (n <= 1) return false;
}

The modulo operator will be very useful as we can check the divisibility of each number. I'll opt to use a for loop to check how many divisors n will have.

We can start the checking with 2.

for (let i = 2; i <= (n/2); i++) {}

So, if our number is 11 (a prime number), it would run 4 times.

Inside the for loop, we can write an if statement checking if n is divisible by i. If it returns a remainder of 0, we know it is not a prime number. We can return false. Here is the updated code.

function isPrime(n) {
  if (n <= 1) return false;
  for (let i = 2; i <= (n/2); i++) {
    if (n % i === 0) {
      return false
    }
  }
}

We would determine n is divisible by more than just 1 and itself, so it wouldn't be a prime number. We would return false and exit the loop. If it is not divisble by i at all, we know it is a prime number. We can return a true.

function isPrime(n) {
  if (n <= 1) return false;
  for (let i = 2; i <= (n/2); i++) {
    if (n % i === 0) {
      return false
    }
  }
  return true;
}

Let us try it out with a small number, 5:

isPrime(5);

function isPrime(n) {
  if (n <= 1) return false;
  for (let i = 2; i <= (n/2); i++) {
    if (n % i === 0) {
      return false
    }
  }
  return true;
}

// n = 5
// First line, is not true, so keep it running
// First for loop, 5 % 2 !== 0 

// There is no second loop, because i = 3 and it is bigger than 5/2
// 5 is a prime number

Let's try with 9 now:

isPrime(9);

function isPrime(n) {
  if (n <= 1) return false;
  for (let i = 2; i <= (n/2); i++) {
    if (n % i === 0) {
      return false
    }
  }
  return true;
}

// n = 9
// First line, is not true, so keep it running
// First for loop, 9 % 2 !== 0 

// Second loop, i = 3, 3 <= (9/2) still true
// 9 % 3 === 0 is true so we return false
// 9 is not prime as it is divisible by 1, 3, 9

Hopefully that helped grasp the prime number part of the challenge. Now that we have a helper function to determine prime numbers, we can see how to sum the prime numbers of num.

So we'll be using another for loop. Before we start looping, I will declare a variable, sum, and set it to 0. This will be the number we return.

let sum = 0;

function sumPrimes(num) {
  let sum = 0;
    // For loop 
  return sum;
}

So we want to go through every number smaller than num, and check if its a prime number. If it is, we will add it into our new variable, sum.

for (let j = 1; j <= num; j++) {
  if (isPrime(j)) {
    sum += j;
  }
}

Having this helper function makes the this function a lot more cleaner. It evaluates each number, and will add it into the sum if it is prime.

function sumPrimes(num) {
  let sum = 0;
  for (let j = 1; j <= num; j++) {
    if (isPrime(j)) {
      sum += j;
    }
  }
  return sum;
}

Our Solution

function sumPrimes(num) {
  let sum = 0;
  for (let j = 1; j <= num; j++) {
    if (isPrime(j)) {
      sum += j;
    }
  }
  return sum;
}

function isPrime(n) {
  if (n <= 1) return false;
  for (let i = 2; i <= (n/2); i++) {
    if (n % i === 0) {
      return false;
    }
  }
  return true;
}

Links & Resources