In this article, we'll see how to make strings lowercase with the toLowerCase() method in Python.

What is a String?

A string is a data type that can contain many different characters. A string is written as a series of characters between single or double quotes.

const exampleString = 'I am a String!'
console.log(exampleString); // I am a String!

What is a Method?

A method is a function that you can use on a specific data type. Methods can either take or not take arguments.

How Does the toLowerCase() Method Work?

The toLowerCase() method is a string method that returns a new string that's completely lowercase. If the original string has uppercase letters, in the new string these will be lowercase. Any lowercase letter, or any character that is not a letter, is not affected.

console.log(exampleString.toLowerCase()); // i am a string!

console.log('FREECODECAMP'.toLowerCase()); // freecodecamp

What to Keep in Mind When Using the toLowerCase Method

The toLowerCase() method does a pretty straightforward thing: it creates a new string where all the uppercase letters are now lowercase. But there are a few things to keep in mind when using it. Let's take a look at them.

Strings are immutable

Strings are an immutable data type, which means they can't be changed. The original string will stay unchanged after you use the toLowerCase() method.

In the examples above, the toLowerCase() method has acted on the exampleString but never changed it. Checking the value of exampleString still shows the original value:

console.log(exampleString); // I am a string!

console.log(exampleString.toLowerCase()); // i am a string!

console.log(exampleString); // I am a string!

The toLowerCase() method returns a new string

This means that the toLowerCase() method returns a new string. You'll need to save it in a variable if you want to use it again in your code.

const newString = exampleString.toLowerCase()

console.log(newString); // i am a string!

Strings are case sensitive

Strings are case sensitive, so a lowercase string is different than an uppercase string.

console.log('freecodecamp' === 'FREECODECAMP'); // false

This is useful when thinking about what the toLowerCase() method could be useful for. In the example you will see how this feature makes the toLowerCase() method useful and necessary when building a script or program that deals with strings.

toLowerCase() Method Example – How to Check if the User Input Matches

Let's write a small app that asks the user a question, gets the input, and gives feedback about the user's answer.

There are various ways to do that: you could use this in a web app, getting the value from an input element with type="text". To keep it simple, in the example you will see the usage of the prompt JavaScript function.

The prompt function will display a browser message popup with an input field in which the user can write an answer:

const answer = prompt("What color is the sun?")
if (answer === "yellow") {
  alert("Correct!")
} else {
  alert("That is not the correct color!")
}

This code asks the user a question, "What color is the sun?", and waits for an answer. Then it checks if the answer is "yellow", and if it is it prints "Correct!" If it isn't, it prints "That is not the correct color!".

But there is an issue with this code.

Running this code, you will have this question asked in the popup:

If you answer "Yellow", it says "That is not the correct color!"

Why does this happen?

Remember that strings are case sensitive. The script is checking if the user input the string yellow – Yellow, with a capital "Y", is a different string.

You can easily fix this by using the toLowerCase() method, and doing this small change to the code:

const answer = prompt("What color is the sun?")
if (answer.toLowerCase() === "yellow") {
  alert("Correct!")
} else {
  alert("That is not the correct color!")
}

And now, if you try again...

What changed? Writing answer.toLowerCase() you make sure that the checked string is completely lowercase before comparing it with the correct answer string "yellow". In this way it doesn't matter if the user writes "YELLOW" or "yELLOW" or "yellow" – it is all converted to lowercase.

Thanks for reading! Now you know how to use the toLowerCase() method in JavaScript.

In the first half of this article you will learn all the methods that allow you to remove an element from an array without mutating the original array. In fact, this is what you will want to do most often. For example, if you don't want to mutate your React State. Or the array is used in other parts of your code, and mutating it would cause unexpected issues.

Always better to avoid mutations!

But, for completeness, the second half of the article will list methods to remove an item from an array in place. These methods do mutate the array itself.

Here you can find a handy summary of the article content, if you want to navigate to a section in particular.

• How to remove an element from an array without mutating the array
  • Remove the first element of an array with slice
  • Remove the last element of an array with slice
  • Remove an element at any position of an array with slice and concat
  • Remove an element of a certain value with filter
  • Remove an element from an array with a for loop and push
  • Remove the first element of an array with destructuring and the rest operator
• How to remove an element from an array while mutating the array
  • Remove the last element of an array with pop
  • Remove the first element of an array with shift
  • Remove an element at any index with splice
• Conclusion

How to remove an element from an array without mutating the array

If you have an input array, like as a function parameter, best practices dictate that you should not mutate the array. Instead you should create a new one.

There are a few methods you can use to remove a specific item from an array without mutating the array.

To avoid mutating the array, a new array will be created without the element you want to remove.

You could use methods like:

• Array.prototype.slice()
• Array.prototype.slice() together with Array.prototype.concat()
• Array.prototype.filter()
• A for loop and Array.prototype.push()

Let's see in detail how you could use each one of these to remove an element from an array without mutating the original one.

Remove the first element of an array with slice

If you want to remove the first element in an array, you can use Array.prototype.slice() on an array named arr like this: arr.slice(1).

Here is a complete example, in which you want to remove the first element from an array containing the first 6 letters of the alphabet.

// the starting array
const arrayOfLetters = ['a', 'b', 'c', 'd', 'e', 'f'];

// here the array is copied, without the first element
const copyWithoutFirstElement = arrayOfLetters.slice(1);

// arrayOfLetters is unchanged
console.log(arrayOfLetters) // ['a', 'b', 'c', 'd', 'e', 'f']

// and copyWithoutFirstElement contains the letters from b to f
console.log(copyWithoutFirstElement) // ['b', 'c', 'd', 'e', 'f']

The slice method can take a single number as argument, and in this case it copies from that index to the end of the array. So using arrayOfLetters.slice(1) will create a copy of the arrayOfLetters array that excludes the first element.

Remove the last element of an array with slice

If the element you want to remove is the last element of the array, you can use Array.prototype.slice() on an array named arr in this way: arr.slice(0, -1).

Here is a complete example using the same alphabet array from above, starting with an array of the first 6 alphabet letters.

const arrayOfLetters = ['a', 'b', 'c', 'd', 'e', 'f'];
const copyWithoutLastElement = arrayOfLetters.slice(0, -1);

// arrayOfLetters is unchanged
console.log(arrayOfLetters) // ['a', 'b', 'c', 'd', 'e', 'f']

console.log(copyWithoutLastElement) // ['a', 'b', 'c', 'd', 'e']

The slice method takes up to two parameters. The first index of slice indicates from which index to start the copy, and the second argument says up to which element to copy – but it's not inclusive.

slice accepts a negative index to count from the end. This means that writing -1 would mean the last index. So from 0 to -1 means to create a copy from index 0 up to (but not including) the last index. The end result is that the last element is not included in the copy.

Remove an element at any position of an array with slice and concat

If you want to create a copy that is missing an element at any index you can use Array.prototype.slice and Array.prototype.concat together in this way: arrayOfLetters.slice(0, n).concat(arrayOfLetters.slice(n+1)) where n is the index of the element you want to remove.

const arrayOfLetters = ['a', 'b', 'c', 'd', 'e', 'f'];

const halfBeforeTheUnwantedElement = arrayOfLetters.slice(0, 2)

const halfAfterTheUnwantedElement = arrayOfLetters(3);

const copyWithoutThirdElement = halfBeforeTheUnwantedElement.concat(halfAfterTheUnwantedElement);

// arrayOfLetters is unchanged
console.log(arrayOfLetters) // ['a', 'b', 'c', 'd', 'e', 'f']

console.log(copyWithoutFifthElement) // ['a', 'b', 'd', 'e', 'f']

This use of slice is a way to put together the two previous uses.

The first use of slice will create an array from the beginning to just before the element you want to remove.

The second use of slice creates an array from after the element you want to remove to the end of the array.

The two arrays are concatenated together with concat to form an array that is similar to the starting one, but without a particular element.

Remove an element of a certain value with filter

If you want to remove an element with a certain value, you can use Array.prototype.filter(). Let's take the same arrayOfLetters and create a copy without the d.

const arrayOfLetters = ['a', 'b', 'c', 'd', 'e', 'f'];

const arrayWithoutD = arrayOfLetters.filter(function (letter) {
    return letter !== 'd';
});

// arrayOfLetters is unchanged
console.log(arrayOfLetters); // ['a', 'b', 'c', 'd', 'e', 'f']

console.log(arrayWithoutD); // ['a', 'b', 'c', 'e', 'f']

filter takes a callback, and tests all the elements of the array with that callback. It keeps the elements for which the callback returns true (or a truthy value) and excludes the elements for which the callback returns false (or a falsy value).

In this case, the callback checks letter !== "d" so it returns false for the letter d and true for all others, resulting in an array that doesn't include the letter d.

The callback to filter is passed three arguments, in order: the element itself, the index of the element, and the whole array.

You can create more complex conditions than this example, as complex as you need.

Remove an element from an array with a for loop and push

A final method to remove an element from an array without mutating the original array is by using the push method.

With these simple steps:

1. Create an empty array
2. Loop through the original array
3. Push to the empty array the elements you want to keep

const arrayOfLetters = ['a', 'b', 'c', 'd', 'e', 'f'];

const arrayWithoutB = [];

for (let i = 0; i < arrayOfLetters.length; i++) {
    if (arrayOfLetters[i] !== 'b') {
        arrayWithoutH.push(arrayOfLetters[i]);
    }
}

// arrayOfLetters is unchanged
console.log(arrayOfLetters); // ['a', 'b', 'c', 'd', 'e', 'f']

console.log(arrayWithoutB); // ['a', 'c', 'd', 'e', 'f']

The condition of the if statement can check both the index (i) and the value of the element for more complex statements.

Remove the first element of an array with destructuring and the rest operator

Array destructuring and the rest operator are two concepts that are a bit confusing.

I suggest this article that covers how to destructure an array if you want to go deeper on this topic.

You can remove the first element using destructuring – let's say of an array named arr – and create a new array named newArr in this way: const [ , ...newarr] = arr;.

Now, let's see a practical example on how to use destructuring and the rest operator.

const arrayOfFruits = ['olive', 'apricot', 'cherry', 'peach', 'plum', 'mango'];

const [ , ...arrayOfCulinaryFruits] = arrayOfFruits;

// arrayOfFruits is unchanged
console.log(arrayOfFruits); // ['olive', 'apricot', 'cherry', 'peach', 'plum', 'mango']

console.log(arrayOfCulinaryFruits); // ['apricot', 'cherry', 'peach', 'plum', 'mango']

Putting a comma before the rest operator says to avoid the first element in the array, and all the others are copied in the arrayOfCulinaryFruits array.

How to remove an element from an array while mutating the array

In some cases it might be appropriate to mutate the original array. In these cases you can also use one of the following mutating methods.

• Array.prototype.pop()
• Array.prototype.shift()
• Array.prototype.splice()

Remove the last element of an array with pop

You can remove the last item of an array with Array.prototype.pop().

If you have an array named arr, it looks like arr.pop().

const arrayOfNumbers = [1, 2, 3, 4];

const previousLastElementOfTheArray = arrayOfNumbers.pop();

console.log(arrayOfNumbers); // [1, 2, 3]

console.log(previousLastElementOfTheArray); // 4

The pop method is used on the array, and it changes the array by removing the last item of the array.

The pop method also returns the removed element.

Remove the first element of an array with shift

The shift method can be used on an array to remove the first element of an array.

If you have an array named arr it can be used in this way: arr.shift().

const arrayOfNumbers = [1, 2, 3, 4];

const previousFirstElementOfTheArray = arrayOfNumbers.shift();

console.log(arrayOfNumbers); // [2, 3, 4]

console.log(previousFirstElementOfTheArray); // 1

The shift method removes the first item of the array.

It also returns the removed element.

Remove an element at any index with splice

You can remove the element at any index by using the splice method.

If you have an array named arr it can be used in this way to remove an element at any index: arr.splice(n, 1), with n being the index of the element to remove.

const arrayOfNumbers = [1, 2, 3, 4];

const previousSecondElementOfTheArray = arrayOfNumbers.splice(1, 1);

console.log(arrayOfNumbers); // [1, 3, 4]

console.log(previousSecondElementOfTheArray); // [2]

The splice method can accept many arguments.

To remove an element at any index, you need to give splice two arguments: the first argument is the index of the element to remove, the second argument is the number of elements to remove.

So, if you have an array named arr, in order to remove an element at index 4, the way to use the splice method would be: arr.splice(4, 1).

The splice method then returns an array containing the removed elements.

Conclusion

There are many different ways to do the same thing in JavaScript.

In this article you have learned nine different methods to remove an element from an array. Six of them do not mutate the original array, and three of them do.

You will probably use all of them at one point or an other, and maybe you will learn even more methods to do this same thing.

Have fun!

First, before diving into how it works in Excel, let's take a look at the math.

If you want to jump directly to the Excel part, and avoid the math part, please proceed to the section How to work with percentages in Excel.

What is the Formula for Calculating a Percentage?

Percentages from 0% to 100% are equivalent to decimal values from 0 to 1. That means you can convert from a percentage to a decimal number. Let's see how.

How to Convert from Decimal Number to Percentage

You can convert from a decimal number to a percentage in the following way:

• take the decimal number, (d),
• multiply it by (100),
• and then add the percentage (\%) symbol,

In short, if you want to get a percentage from a number (d) you can do this:

$$ ( d \cdot 100 ) \% $$

How to Convert from a Percentage to a Decimal Number

If you want to convert from a percentage to a number, you can:

• take the percentage (P\%),
• remove the percentage symbol, (P)
• then divide the number by (100): (\frac{P}{100})

In short, to convert a percentage (P\%) to a decimal number:

$$ \frac{P\xcancel{\%}}{100} $$

How to Calculate the Percentage of a Number

There are three cases in which you might want to calculate the percentage of a number:

• to add a percentage to the number (like for calculating how much you have to pay including VAT)
• to just get the percentage of the number
• to subtract a percentage from the number (like for a sale)

How to add a percentage to a number

Let's first use a specific case, and then let's generalise.

You went shopping, and the total you need to pay is $185 + VAT. Let's say VAT in this case is 17%.

So you would have to calculate 17% of $185 and then add it to $185.

$$ \$185 \cdot 17 \% + \$185 $$

You can make it a single operation if instead you multiply by ( 117 \% ).

$$ \$185 \cdot ( 100\% + 17\% ) = \$185 \cdot 117\% $$

If you have a simple calculator that doesn't have a percentage operator, you can convert the percentage to a decimal number as we discussed above. Here's what that would look like:

$$ \$185 \cdot 117\% = \$185 \cdot \frac{117 \xcancel{ \% }}{ 100 } = \$185 \cdot 1.17 $$

So, in general, if you want to add a percentage ( P \% ) to a number ( n ) you can do this:

$$ n \cdot ( 100\% + P\%) $$

Or if instead you have the percentage in the decimal number form ( d ) you can do this:

$$ n \cdot (1 + d) $$

How to calculate the percentage of a number

If you want to buy a house you need to pay a deposit on the house. Let's say that's 15% of the total value of the house.

If the house price is $200,000, how can you calculate it?

You can multiply the price by the percent number to get the percentage.

$$ \$200,000 \cdot 15 \% = \$30,000 $$

So if you want to know what's the percentage (P\%) or fraction (d) of a number (m), you can multiply that number by the percentage or fraction.

$$ m \cdot P\% \newline \, \\ m \cdot d $$

How to subtract a percentage from a number

This case is common for calculating the price of an item on sale. For example, if something has an original price of $999 and it is on sale for 20% less, you can calculate the the final price by figuring out what is 20% of $999. Well, it's $199.80, so then you just subtract that value from $999.

The final price of the item on sale is $799.20.

You can calculate it in a single step if you multiply the original price by ((100\% - 20\%)) or (80\%):

$$ \$999 \cdot (100\% - 20\%) = \$999 \cdot 80\% = \$779.20 $$

So the general formula to subtract a percentage (P\%) from a number (b) is:

$$ b \cdot (100\% - P\%) $$

Or in decimal form:

$$ b \cdot (1 - d) $$

How to Calculate the Percentage of a Number in Respect to Another Number

A cake weights 11 lbs, and you eat 3 pieces for a total of 21 oz. How can you know what percentage of cake have you eaten?

It's important to do calculations of this kind with everything in the same units. So, first, let's convert the weight of the cake to ounces.

$$ 11~\mathrm{lb} \cdot \frac{16~\mathrm{oz}}{\mathrm{lb}} = 176~\mathrm{oz} $$

Now it's possible to see the percentage of the cake you've eaten: you need to divide the part (in this case the 21 oz of cake you have eaten) by the whole (the 176 oz of the whole cake):

$$ \frac{11~\mathrm{oz}}{176~\mathrm{oz}} = 0.0625 $$

As seen in the paragraph on how to convert a decimal to a number, you can convert this to a percentage with ( 0.0625 \cdot 100 \% = 6.25\%).

In this example, you have eaten 6.25% of the whole cake.

How Do You Combine Two Percentages?

Let's say that some items in an online store are discounted at 20%, and then there is an offer for a 10% discount for everything in your cart at payment.

If you are getting a discount of 20% and then another 10% on top of that... how much is the discount?

It's not 30%, because the second discount is applied at a different time than the first discount.

A discount of 20% means you pay 80% ((100\% - 20\%)) of the original price, and a discount of 10% means you pay 90% ((100\% - 10\%))of the original price. Combining the two discounts means multiplying together the two percentages, like so:

$$ 80\% \cdot 90\% = 72\% $$

Or in decimal form:

$$ 0.80 \cdot 0.90 = 0.72 $$

So you pay 72% of the original price, or have a discount of 28%.

Why Are a Decimal and a Percentage Equivalent?

Percentage comes from "per cent", or "over one hundred". The percentage symbol represents the line fraction with 100 in the denominator.

$$ 0.20 = \frac{20}{100} = 20\% $$

The percentage is a simple way to describe how many hundredths of a whole something is.

How to Work with Percentages in Excel

Now it's time to start working with Excel. Let's start with a pretty important thing. How do you write percentages in Excel?

How to Write Percentages in Excel

In Excel you can write percentages in two ways:

• You can write a decimal number and then format the cell as a percentage from the format drop down menu or from the Percent Style button:

In the first image the Percent Style button is circled in red, and a decimal number is written in the cell. In the second image, the cell has been formatted as a percentage, and the number is converted to a percentage.

• You can write a percentage in the cell, and the cell will automatically take the percentage formatting:

In the first image you can see that the empty cell has the "General" formatting, in the second image you can see a percentage being written in the cell, and in the third image you can see that the cell has taken the percentage formatting.

The default format is for a whole percentage. You can change the number of decimal places shown with the "Increase Decimal" and "Decrease Decimal" buttons.

The two buttons "Increase Decimal" and "Decrease Decimal" circled in red.

Let's say you have a decimal form of 0.12345. Formatting it to a percentage will show ( 12\% ). You can use the buttons to show the decimal places.

In the first image, the value 12% appears in the cell K1. In the second image, after using the "Increase Decimal" button twice, the value 12.35% appears in the cell K1. In the third image, after using the button "Decrease Decimal" once, the value 12.3% appears in the cell K1.

How to Calculate the Percentage of a Number in Excel

In math, the percentage of a number is calculated by multiplying that number by the percentage: ( 87\% \cdot 824 = 716.88 ).

In Excel, let's say you have the number in cell A1 and the percentage in cell B1. To calculate the result, you can write in cell C1 =A1*B1:

In the first image you can see the formula to calculate the percentage of a number, and then its result in the second image.

How to Calculate the Percentage of a Number with Respect to Another in Excel

In math, you can calculate the percentage of a number with respect to another number by taking the ratio of the two numbers and then converting to a percentage.

If you want to know what percentage 75 is with respect to 142, you can do ( \frac{75}{142} = 0.528 = 52.8\% ).

Let's write 75 in cell G1, and 142 in cell H1. To get the percentage of 75 in respect of 142 you can write in cell I1 =G1/H1. The cell will have the result in decimal format, but you can format it to a percentage using the Percent Style button. Then you can adjust the number of decimal places with the Increase Decimal and Decrease Decimal buttons.

In the first image you can see the formula to do the calculation. In the second image it results in a decimal number. In the third image it has been converted to a percentage, and then in the fourth the number of digits after the decimal separator has been changed.

How to Calculate a Percentage of Multiple Percentages in Excel

Let's take the example used above.

An online store has a promotion on some items for 20% off. Then there is another promotion of 10% off for everything in the cart at the moment of payment.

The first discount means you pay 80% of the original price of the item. And then you pay 90% of what's in the cart.

How much is the discount?

You get the result by multiplying the two percentages. ( 90\% \cdot 80\%).

In Excel, if you have the first percentage in I2 and the second in J2, you can write =I2*J2 to calculate the result.

In the first image you can see the formula to calculate the percentage from multiple percentages, and then its result in the second image.

Conclusion

Percentages are a mathematical tool we use in every day life. In this tutorial, you have learned how they work mathematically, and how to use them in Excel.

I hope this article has been useful.

What is a callback in JavaScript?

A callback is a function passed as an argument of another function.

This means that the parent function is usually built to use any kind of function. But the callback function, on the other hand, is meant to be used in a specific case (or a restricted number of cases) in which the parent function is used.

How do you create a callback function in JavaScript?

You create a callback function just like any other function in JavaScript:

function callbackFunction () {

}

The difference between a callback function and any other function is how it's used.

A callback function is specifically built to be used as argument of another function.

function anyFunction(fun) {
    // ...
    fun(a, b, c);
    //...
}

anyFunction(callbackFunction);

So, to create a callbackFunction you need to know how the parent function uses the callback function, what arguments it passes in, and what order it passes them in.

What is an example of a callback function?

We'll now write our own callback function, as it's something you'll have to do many times. So, let's start!

A higher order function that's already integrated in the JavaScript language is the every method.

The every method is an array method, and uses a callback to check that all the elements in the array pass a certain test.

Looking at the documentation on the every method, you can see that the callback is passed three arguments: an element of the array, the index of that element, and the whole array.

So the callback function signature would be something like this:

function callbackFunction(element, index, array) {
    // do something
}

Callback functions can be as simple or as complex as you need them to be. To create an example, we need some context.

How to write a callback function in JavaScript

So, let's say you are working with arrays of strings. You need to check if the array contains only strings that are exactly three characters long, are uppercase, contain all different letters, and that they don't repeat inside the array.

This is a pretty complex case, but maybe you will eventually need to do something like this or of equal complexity, so it's all good practice.

You can tackle one condition at a time when you build a function with so many things to check.

The first condition is that the element is a string, so, let's add it:

function callbackFunction(element, index, array) {

    // check that element is a string
    const isNotString = typeof element !== "string";
    // if it's not, end function
    if (isNotString) {return;}

}

Next, the strings must be all uppercase, contain only letters, and be 3 characters long.

You could check these three conditions separately, or you can check them together with a regular expression that checks for exactly those three things.

Such a regular expression would look like this: /^[A-Z]{3}$/.

Let's see what the parts of this regular expression are:

• The characters ^ at the beginning and $ at the end are anchors. These say that the string must start and end in exactly that way. And if you use both, they restrict a string to contain only and exactly the pattern in the regular expression.
• [A-Z] is a character class that matches any character from A to Z, so all uppercase letters.
• {3} is a counter. This says that the previous thing must be matched exactly three consecutive times.

The regular expression explained above is the equivalent of this regular expression: /^[A-Z][A-Z][A-Z]$/.

In this case instead of the counter {3} we have written the class [A-Z] three times.

Let's add this to the code.

function callbackFunction(element, index, array) {

    // check that element is a string
    const isNotString = typeof element !== "string";
    // if it's not, end function
    if (isNotString) {
        return;
    }

    // check that string is 3 characters long and only uppercase letters
    const isItThreeUpperCaseLetters = /^[A-Z]{3}$/.test(element);
    // otherwise, end function
    if (!isItThreeUpperCaseLetters) {
        return;
    }

}

If you don't like regular expressions, you can read below how to do the same checks without using a regular expression.

Then, next, we need to check if the characters are all different.

There are three characters you can use: element[0] !== element[1] && element[0] !== element[2] && element[1] !== element[2].

But, you can also do this with a loop – a double loop actually.

// with the outer loop, you get j, the first index to compare
for (let j = 0; j++; j < element.length) {
    // with the inner loop you get k, the second index to compare
    for (let k = j+1; k++; k < element.length) {
        // you compare the element at index j with the element at index k
        if (element[j] === element[k]) {
            // if they are equal return to stop the function
            return;
        }
    }
}

The loop will work with any length, and you don't need to rewrite it for different situations.

Is it the exact same as writing the three comparisons? Let's follow the loop to check.

At first iteration we have that j=0, and k=1, so the first comparison is element[0] === element[1]. Then k increases, so it's j=0 and k=2, so that is element[0] === element[2].

At this point the inner loop stops, and the outer loop (the one with j) goes to the next iteration. This time j=1, and the inner loop starts at k=j+1 so at k=2 – the comparison here is element[1] === element[2].

The inner loop has finished looping, the outer loop goes from j=1 to j=2, the inner loop doesn't start as k = j+1 = 3 doesn't pass the k < element.length condition of the loop.

function callbackFunction(element, index, array) {


    // check that element is a string
    const isNotString = typeof element !== "string";
    // if it's not, end function
    if (isNotString) {
        return;
    }


    // check that string is 3 characters long and only uppercase letters
    const isItThreeUpperCaseLetters = /^[A-Z]{3}$/.test(element);
    // otherwise, end function
    if (!isItThreeUpperCaseLetters) {
        return;
    }


    // check if all characters are different
    const allDifferentCharacters = element[0] !== element[1] && element[0] !== element[2] && element[1] !== element[2];
    // if not, return to stop the function
    if (!allDifferentCharacters) {
        return;
    }



}

Then, the last thing we need to check is that the strings are not repeated inside the array.

We can use indexOf to check that the current one is the first appearance of element inside the array.

We would need to reference the array for this. And we have it – it's one of the arguments passed in to the callback, the array parameter.

If this is the first appearance of the string in the array, the output of indexOf will be the same as index.

If array.indexOf(element) === index is true, that means that element is present in the array for the first time at index. If it's false, an identical string is present earlier in the array.

Let's add this check to the function. And if the string has survived through all the checks, then the function can return true at the end.

function callbackFunction(element, index, array) {


    // check that element is a string
    const isNotString = typeof element !== "string";
    // if it's not, end function
    if (isNotString) {
        return;
    }


    // check that string is 3 characters long and only uppercase letters
    const isItThreeUpperCaseLetters = /^[A-Z]{3}$/.test(element);
    // otherwise, end function
    if (!isItThreeUpperCaseLetters) {
        return;
    }


    // check if all characters are different
    const allDifferentCharacters = element[0] !== element[1] && element[0] !== element[2] && element[1] !== element[2];
    // if not, return to stop the function
    if (!allDifferentCharacters) {
        return;
    }


    // check if it's the first appearence of element inside the array
    const isItFirstAppearence = array.indexOf(element) === index;
    // if not, return to stop the function
    if (!isItFirstAppearence) {
        return;
    }


    return true;
}

And if we didn't use a regular expression?

In the code above, to check three different things, we used a regular expression: /^[A-Z]{3}$/.

But if you don't want to work with regex, you can use the length property to check if a string is of exactly a certain length. In this case element.length === 3 to check that the string is exactly three characters long.

Next, the string must be all uppercase and contain only letters.

You can use charCodeAt for this. This method returns the ASCII code of a character, and knowing that uppercase letters have ASCII codes from 65 to 90, you can check that there are only uppercase letters.

There are three numbers to check: element.charCodeAt(0), element.charCodeAt(1), and element.charCodeAt(2). They all need to be between 65 and 90. It's only three characters, but we can still use a loop.

So, that would be as below:

for (let i = 0; i++; i < element.length) {
    // find the ASCII code of the character
    const code = element.charCodeAt(i);
    // check if it's outside of the range
    if (code < 65 || code > 90) {
        // if it is, return to stop the function
        return;
    }
}

Let's add this to the function:

function callbackFunction(element, index, array) {

    // check that element is a string
    const isNotString = typeof element !== "string";
    // if it's not, end function
    if (isNotString) {return;}

    // check that element has length string
    const hasLengthThree = element.length === 3;
    // if it has a different length, end function
    if (!hasLengthThree) {return;}

    // loop over the characters
    for (let i = 0; i++; i < element.length) {
        // find the ASCII code of the character
        const code = element.charCodeAt(i);
        // check if it's outside of the range
        if (code < 65 || code > 90) {
            // if it's outside the range, return and stop the function
            return;
        }
    } 
}

If you have come here from the link above, you can return there to continue reading how to finish the function, otherwise, please continue to the end.

How to use the example callback function

We have written the callback function. So how do you use it?

anArray.every(callbackFunction);

You can also use the every method inside a callback – maybe the callback to a filter method.

As a program becomes more complex, it's probably going to use proportionally more callback functions.

Why do we use callback functions in JavaScript?

Callback functions are a neat feature of JavaScript. It means we can have a general function that does something (like every that checks if every element in an array match a certain condition, filter, that removes the elements that don't match a certain condition, replace, a string method that accepts a callback to describe how to replace parts of a string, and so on) and a callback function to add specifics of that behaviour for the specific situation.

• filter in that situation will remove the elements specified by the callback.
• every will check that all the elements in that situation are as specified by the callback function.
• replace will replace parts of the string in the situation in which it is used as specified by the callback.

Higher order functions add a level of abstraction to the code. We don't know (and don't need to know), how every checks every element of the array and verifies that they all pass the tests specified by the callback. We only need to know that the method accepts a callback function for that.

Conclusion

Callbacks are functions that are passed as arguments of other functions. You have seen an example of how to create one, and some considerations on why they are useful.

Thank you for reading!

So if you were to have 3!, for example, you'd compute 3 x 2 x 1 (which = 6). Let's see how it works with some more examples.

Definition of a Factorial

The factorial of a number is the multiplication of all the numbers between 1 and the number itself. It is written like this: n!. So the factorial of 2 is 2! (= 1 × 2).

To calculate a factorial you need to know two things:

1. 0! = 1
2. n! = (n - 1)! × n

The factorial of 0 has value of 1, and the factorial of a number n is equal to the multiplication between the number n and the factorial of n-1.

For example, 5! is equal to 4! × 5.

Here the first few factorial values to give you an idea of how this works:

What is a Factorial Used For?

Practically speaking, a factorial is the number of different permutations you can have with n items: 3 items can be arranged in exactly 6 different ways (expressed as 3!).

For example, let's see all the arrangements you can have with the three items, A, B and C:

ABC
ACB
BAC
BCA
CAB
CBA

And in fact, 3! = 6.

How to Calculate the Factorial of 0

Looking at the factorial from this point of view, what's the factorial of 0?

Well, how many different ways can you arrange 0 elements?

There is exactly 1 way to arrange zero elements. And that's making a sequence of zero elements.

Factorial Use Cases

You typically use a factorial when you have a problem related to the number of possible arrangements. Let's look at some example problems.

Factorial example problem 1: the letters in the word "camper"

How many different ways can you arrange the letters of the word camper?

The word camper has 6 letters, so the number of possible arrangements is given by the factorial of 6: 6! = 6 × 5 × 4 × 3 × 2 × 1 = 720. That would have been a pretty big number of arrangements to find by hand, wouldn't it?

Factorial example problem 2: drawing colored balls from a bag

Let's say there are three balls in a bag – one green, one blue, and one yellow.

If you draw the three balls in sequence, what chance is there that you'll get the yellow first, the green one second, and the blue one last?

Maybe now you are wondering what chances have to do with factorials – well, in a moment you will see.

There are 6 possible sequences in which the balls can be drawn: 3! = 6.

There is a chance of 1 over the total number of possibilities to get the yellow-green-blue sequence, so that is 1/(3!) or 1/6 or 16.7% chance to get the desired outcome.

How to Calculate a Factorial Programmatically with JavaScript

There are two ways to calculate factorials programmatically in JavaScript:

How to calculate a factorial in JS with recursion

Let's get back to the two things to know when calculating a factorial – that is 0! = 1 and n! = (n - 1)! × n. We can use the first one to create the base case of the recursive function, because in that case we know the result already.

function factorial(n) {
  if (n === 0) {
      return 1;
  }
}

The second thing to know about how to calculate a factorial, n! = (n - 1)! × n, can be the recursive case.

function factorial(n) {
    if (n === 0) {
        return 1;
    } else {
        return factorial(n-1) * n;
    }
}

How to calculate a factorial with a JavaScript while loop

We said before that 0! = 1. So, to calculate the factorial of a number with a loop, we can initialize a variable to 1, and multiply the numbers from n to 1 by the variable inside the loop.

In this way, if the input is higher than 1, the output will easily be 1.

function factorial(n) {
    let result = 1;
    for (n > 1) {
        result *= n;
        n--;
    }
    return result;
}

Conclusion

The factorial is a pretty important operator to know if you are interested in statistics and probabilities.

In this article you have learned a how to calculate a factorial, a simple application, and you have seen how to calculate it using JavaScript.

Have fun with it!

There will come a time when you want to get a value by combining two or more different units. CSS has a function that you can use to make such calculations – calc(). And in this tutorial, you'll learn how it works.

There are other functions you can use with these relative units – like max, min and clamp – that, when confronted with different values, use the appropriate one. These are really useful in responsive layouts, and can be an alternative to using media queries.

If you learn to use them appropriately you can avoid the jumpy change of layout that can happen when resizing a window if you used media queries, and with less code!

How to Use the CSS calc() Function

The calc function takes a single parameter. This parameter can be an expression combining any length unit and the four mathematical operators +, -, /, *.

You can also use parenthesis to indicate an order of evaluation different than the standard precedence rules.

In the expression inside the calc() function you can use CSS variables, values obtained with [attr()](https://developer.mozilla.org/en-US/docs/Web/CSS/attr), and values from the functions max(), min() and clamp().

calc() allows you to calculate a value from complex parameters.

div {
    width: calc(100% - 2em);
}

Note: always leave a space on either side of the mathematical operators.

How to Use the CSS max() Function

The max function accepts a list of comma separated values and returns the biggest one. Each value can also be an expression (whatever you can use as an argument for the calc() function can be one of the arguments in this function, too).

The max function can be seen as a way to determine a minimum value for a certain thing.

A use case for this function is making a text responsive, while giving a minimum value to the dimension.

For example:

h1 {
    font-size: max(1rem, 10vh);
}

In this way, the text will be a tenth of the viewport height, unless the viewport height becomes too small. The text will always have a font-size of at least 1rem to ensure legibility.

How to Use the CSS min() Function

In the same way as the max function, min can take any number of arguments, including other max, min, or clamp functions, and give back the smallest value between them.

The min function can be seen as determining a maximum value.

For example, let's say that you are creating a form and you want it to be responsive while the screen width changes. You'll want to give it a maximum width to avoid that horizontally stretched look that can happen on the largest screens.

You could write something like this:

.form {
    width: min(600px, 90vw);
}

Your page will have a width equal to 90% of the viewport width, or 600px wide, whatever is smallest. So if the viewport width is larger than ~670px, the form will not stretch horizontally.

Example for min() and max():

You can see the code snippets at work in this pen. Try resizing the pen horizontally and vertically and see the form width and font size change responsively.

How to Use the CSS clamp() Function

The clamp function clamps a value between and upper and lower limit. It selects a value in a range with defined limits.

clamp takes three values. The first one will be the minimum value, the second one the preferred value, and the third one the maximum value.

The clamp function will give back the preferred value, unless it is smaller than the minimum value (in which case it will give back the minimum value) or if it is bigger than the maximum value, in which case it will give back the maximum value.

You can use clamp to have layout elements responsively resize within a range.

h1 {
    font-size: clamp(1rem, 10vw, 2rem);
}

div {
    padding: clamp(10px, 6vw, 50px);
    width: clamp(140px, 90vw, 600px);
}

Example of clamp Function:

See it in action in this pen! Resize the pen horizontally and see how the various elements change dimensions.

The MDN has more detailed info on all of these functions:

• calc
• max
• min
• clamp

And with this, you have seen an overview of these four marvelous functions. You have learned enough to start using them, so go out there and have fun!

In this guide you will learn about the CONCAT function and how to use it.

Concatenation just means to join two things together. And in Excel, you can use the CONCAT function to join data from multiple cells into one cell. Let's see how it works.

Syntax of the CONCAT function

The general syntax of the CONCAT function is:

=CONCAT(text1; [text2; ...])

Where the arguments are:

• text1 is a required argument that can be a string or an array of strings (like a range of cells).
• [text2, ...] identifies the optional arguments that follow. There can be up to 253 text arguments, and each one can also be a string or an array of strings (such as a range of cells).

How to use the CONCAT function in Excel

To use the CONCAT function, you will need to click on the cell in which you want the result to appear, and type =CONCAT( there.

After that you can click on the cells, or range of cells, you want to concatenate (or join) together – you will need to keep the Ctrl button pressed to add multiple arguments.

Like you can see in these screenshots, we are writing =CONCAT( in the cell D1 and then clicking on the cells A1 and B1 while keeping Ctrl pressed. After that, pressing Enter will give the result in the cell D1.

If you want to add text in between the different cells' content, for example a space, you can click on a cell, then type a semicolon and the text you want to add in between quotes, then another semicolon, and finally click on the next cell:

In this case you would write =CONCAT( in cell D1, then click on cell A1, type a semicolon, then type the space surrounded by strings, " ", followed by another semicolon, and finally click on cell B1. This will result in "Leonardo da Vinci" in cell D1.

Note: You can concatenate together up to 32,767 characters, which is the cell limit. If the resulting string is longer than 32,767 characters the function will output a #VALUE! error.

Examples

The official Microsoft documentation has three helpful examples of how to use the CONCAT function. Let's examine them.

CONCAT Example 1:

If you want to follow along, copy this table and paste its data in cell A1 of a new Excel sheet.

This function allows for whole column reference, so in the formula =CONCAT(B:B; C:C) you are concatenating the whole column B (B:B) followed by the whole column C (C:C), so the result is A'sa1a2a4a5a6a7B'sb1b2b4b5b6b7 – the empty cells do not contribute to the end result.

CONCAT Example 2:

To follow along, copy this table, and paste it in the A1 cell of an empty Excel sheet.

In this case, it is the cells in the range B2:C8 (the range highlighted in the picture) that are being concatenated together, and the formula in the A1 cell will result in a1b1a2b2a4b4a5b5a6b6a7b7. Also in this case the empty cells do not contribute to the result.

Note: The cells in a range are read row by row, so the cells are concatenated in the order: B2;C2;B3;C3;B4;C4;B5;C5;B6;C6;B7;C7;B8;C8 (with B8 and C8 being empty, so not contributing to the end result).

CONCAT Example 3

This example has various examples in it, all with the general theme of joining cells with other text. This example illustrates well how you can do a lot of things with the Concat function.

Let's take a look.

To follow along you can also copy this table in the A1 cell of an empty Excel sheet.

Stream population for brook trout species is 32/mile.

The first formula shown in this example joins together the text of three cells (A2, A3 and A4) with a few strings to form a longer sentence.

So, the result is given by the combination of the string "Stream population for " with the content of the cell A2, so "brook trout", which is then followed by a space (" "), the content of cell A3 ("species"), the string " is ", the content of cell A4 (32), and finally, the string "/mile.".

All together it results in the string "Stream population for brook trout species is 32/mile.".

(For the following screenshots I have hidden the rows of the formulas I have already talked about).

Andreas Hauser

In this example, the formula =CONCAT(B2; " "; C2) joins together the string from the cell B2, a space " " and the string from the cell C2, resulting in "Andreas Hauser".

Hauser, Andreas

From this example you can see that the order in which the cells are written in the CONCAT function arguments matter. The formula =CONCAT(C2; ", "; B2) joins together the strings from cell C2, a comma and a space ", " and from cell B2, resulting in "Hauser, Andreas".

The strings from cells C2 and B2 have been joined in a different order because they have been written in a different order in the arguments of the method.

Fourth & Pine

You can join together any kind of screen. See here where the formula =CONCAT(B3; " & "; C3) joins the string from cell B3 with the string from cell C3 putting in the middle of the two the string with a space, an ampersand and another space, " & " resulting in "Fourth & Pine".

Fourth & Pine (II)

This example shows an alternative method of concatenating strings: using the operator & you can write the list of strings you want to join separated by an ampersand (&). So =B3 & " & " & C3 gives the same result as =CONCAT(B3; " & "; C3).

Note: You can use the & operator only for single cells, it doesn't work for ranges.

And that's it! Now you know how to use the CONCAT function in Excel. Thanks for reading!

In this article, we'll see how to make strings lowercase with the lower() method in Python.

What is a string?

A string is a data type that can contain many different characters. A string is written as a series of characters between single or double quotes.

>>> example_string = 'I am a String!'
>>> example_string
'I am a String!'

What is a method?

A method is a function that can be used on a specific data type. Methods can take or not take arguments.

Sometimes you may wonder if a method exists. In Python you can see the whole list of string methods by using the dir() function with a string as argument, like so:

>>> dir(example_string)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Of these many string methods, in this article you will learn about the lower() method and how it works.

How does the lower() method work?

The lower() method is a string method that returns a new string, completely lowercase. If the original string has uppercase letters, in the new string these will be lowercase. Any lower case letter, or any character that is not a letter, is not affected.

>>> example_string.lower()
'i am a string!'

>>> 'FREECODECAMP'.lower()
'freecodecamp'

What to keep in mind when using the lower method

The lower() method does a pretty straightforward thing: it creates a new string were all the uppercase letters are now lowercase. But there are a few things to keep in mind when using it. Let's take a look at them.

Strings are immutable

Strings are an immutable data type, which means they can't be changed. The original string will stay unchanged after you use the lower() method.

In the examples above, the lower() method has acted on the example_string but never changed it. Checking the value of example_string still shows the original value.

>>> example_string
'I am a String!'

>>> example_string.lower()
'i am a string!'

>>> example_string
'I am a String!'

The lower() method returns a new string

The lower() returns a new string. You'll need to save it in a variable if you want to use it again in your code.

>>> new_string = example_string.lower()

>>> new_string
'i am a string!'

Strings are case sensitive

Strings are case sensitive, so a lowercase string is different than an uppercase string.

>>> 'freecodecamp' == 'FREECODECAMP'
False

This is useful when thinking about what the lower() method could be useful for. In the example you will see how this feature makes the lower() method useful and necessary when building a script or program that deals with strings.

lower() method example: how to check if the user input matches

Let's write a small script that asks the user a question and waits for input, and gives feedback about the user's answer.

answer = input("What color is the sun? ")
if answer == "yellow":
  print("Correct!")
else:
  print("That is not the correct color!")

This script asks the user a question, "What color is the sun?", and waits for an answer. Then it checks if the answer is "yellow", and if it is it prints "Correct!" If it isn't, it prints "That is not the correct color!".

But there is an issue with this script.

Running this script, you will have this question asked in the terminal:

$ python sun_color.py
What color is the sun?

If you answer "Yellow", it says:

$ python sun_color.py
What color is the sun? Yellow
That is not the correct color!

Why does this happen?

Remember that strings are case sensitive. The script is checking if the user input the string yellow – Yellow, with a capital "Y", is a different string.

You can easily fix this by using the lower() method, and doing this small change to the sun_color.py file:

answer = input("What color is the sun? ")
if answer.lower() == "yellow":
  print("Correct!")
else:
  print("That is not the correct color!")

And now, if you try again...

>>> python sun_color.py
What color is the sun? Yellow
Correct!

What changed? Writing answer.lower() you make sure that the checked string is completely lower case before comparing it with the correct answer string "yellow". In this way it doesn't matter if the user writes "YELLOW" or "yELLOW" or "yellow" – it is all converted to lowercase.

Thanks for reading! Now you know how to use the lower() method in JavaScript.

I have already written about SQL joins here and here, but let's take a moment to review how a join works first, and particularly the syntax specific to MySQL.

SQL Join Statement

Join is a statement that lets you put together two tables, matching rows that are related to each other, and keeping only the rows that can be matched, not keeping unpaired rows.

SELECT * FROM table1 
  INNER JOIN table2
  ON table1.id = table2.id;

The SELECT ... FROM statement indicates which is the first table, then the second table name is written just after the INNER JOIN keywords.

How the two tables should be joined is written in the ON statement. In this case the two tables are joined using the relationship table1.id = table2.id.

It is possible to use multiple join statements together to join more than one table at the same time.

SELECT *
  FROM table1
  INNER JOIN table2
  ON table1.id = table2.id
  INNER JOIN table3
  ON table2.id = table3.id;

To do that you add a second INNER JOIN statement and a second ON statement to indicate the third table and the second relationship.

Let's talk a moment about the relationships you can have between tables and why you might want to join three tables together.

Relationships Between Tables in SQL

When you have tables that are related to each other, their relationships could be one of various types.

one-to-many

In a one-to-many kind of relationship, one row of the first table can be related to multiple rows of the second table.

In a relational database this can be implemented with the second table having a first_table_id column that says to which row of the first table that row is related.

many-to-one

In a many-to-one kind of relationship, one row of the first table can be related to one single row of the second table, and one row of the second table can be related to multiple rows of the first table.

In a relational database this can be implemented with the first table having a second_table_id column that says to which row of the second table that row is related.

Many-to-one

many-to-many

In this case multiple rows are related to multiple rows.

Many-to-many

This kind of relationship can't be represent as is with SQL tables – you need to add a coupling table between the two tables so that only many-to-one and one-to-many relationships are present between tables.

Each row of the table in the middle represents one relationship between the rows of the left table and and the rows of the right table.

In practice in MySQL, that middle table will have a column for first_table_id and a column for second_table_id, with each combination being unique.

Joining SQL Tables in Practice

Let's imagine we have an organization's database, where we have a table with teams (their name, and other identifing info), and a table with projects (name, progress, and so on).

As a team can work on multiple projects, and a project can be worked on by multiple teams, there is also a third table that keeps track of team-project matches.

We can use a JOIN statement to put everything together when we need to view the info from the tables in a human readable way, like this:

SELECT
  teams.team_name AS team_name,
  projects.project_name AS project_name
FROM TABLE teams
INNER JOIN matches
  ON teams.id = matches.team_id
INNER JOIN matches
  ON matches.project_id = projects.id
ORDER BY teams.id;

We choose which columns to show from each table with a SELECT statement.

We specify how the rows of the tables are to be combined with an ON statement.

And we order the rows in the way we prefer with an ORDER BY statement.

The ON statements teams.id = matches.team_id and matches.projects_id = projects.id mean that the rows are combined using the rows of the matches table. Each row of the output table has the project name and the team name combined using the pairs of project id and team id in the matches table.

The output table will look like below.

There is no column directly from the matches table. The matches table is not shown in the output but it is used as instructions for how to combine the rows of the teams and projects tables.

Conclusion

The JOIN statement lets you join together one or more tables. It has to be used in conjunction with the ON statement to determine the relationship between the rows of a table and the rows of a different table.

In this article you have learned how to use the JOIN statement to join together three different tables.

According to the game's creator, Lynn Zheng,

Learn to Code RPG is an interactive visual novel game where you will teach yourself to code, make friends in the tech industry, and pursue your dream of becoming a developer. 🎯

If this is the first time you're hearing about this game, you can download it and play it first on your own.

And if you want to learn more about the game from Lynn herself, check out this introductory article.

Learn to Code RPG Story Milestones

These are the achievements that you get for sure by following the storyline.

3, 2, 1, Learn to Code! You'll get this achievement the first time you start working on the quizzes.

Got My First Interview! You get this achievement once your character goes through their first interview after completing the curriculum.

Got My First Offer! Once you receive your first job offer you get this achievement.

Gotta Crush Those Technical Interviews! Once you start preparing for the technical interviews you get this achievement.

Nailed the Curriculum! You unlock this achievement once you reach a CS Knowledge of 60 or more, enough to allow you to go to the next step.

Now Streaming: My Dream Dev Job You unlock this achievement once you accept an offer for a dev job.

Submitted My First Dev Job Application! When you submit your first job application, you get this achievement.

Learn to Code RPG Story Easter Eggs

You can unlock these special achievements mostly by making certain choices in the game, by employing some skill, or in some cases by pure chance.

Applied to CupcakeCPU Through a Recruiter: This achievement has the prerequisite of getting all the questions of the trivia quiz at the Hacker Space right. This will give you the opportunity to apply to CupcakeCPU.

Asked My Tech-Savvy Friends about Tech Buzzwords: Ask about one of the buzzwords you discovered by eavesdropping on people's conversations.

Barista Is My Undercover Identity for Collecting Buzzwords: You unlock this one during your first Barista shift.

Beat Up AI at Pong: beat the Pong AI to unlock this achievement.

Chill Beats to Code to: listen to music during one of your rest days.

Chill Beats to Smash Keyboard to: play the rythm game during one of your rest days.

Flunked All Quizzes in a Session: Get all questions in a session wrong.

Got Beaten Up by AI at Pong: lose at Pong.

Got a Nearly Perfect Score on ALL Music Tracks: Get above 95% for all tracks. See next achievements for details.

Got a Nearly Perfect Score on My Favorite Music Track: Get this achievement for reaching a score above 95%. For reference to reach 90% you need at least 3/4 of your scores to be perfects (100pt each) and 1/4 to be goods (60pt each).

Hanging Out at the Hacker Space: you get this achievement after hanging out at the Hacker Space for the first time.

I Might Get a Puppy Just So I Can Go to the Park: Go take a walk on one of your rest days.

Late-night Cookie Crunch: When confronted with all the certifications available in the freeCodeCamp curriculum, choose Quality Assurance and go grab a cookie.

Maxed Out ALL CS Knowledge Stats: Max out all of the CS Knowledge Stats.

Maxed Out One CS Knowledge Stat: Max out one of the CS Knowledge Stats.

Nailed All Quizzes in a Session: Get all quizzes in a session right.

Referred by a VIP Member: In the intro, after the disaster of an interview you are asked how you came across the opportunity. If you say you were referred by certain people, for example, me, you can get the achievement. (Fine, the complete list of names is Quincy, Lynn, Abbey, Estefania, Jessica, Oliver, Ilenia, Dionysia, Naomi, Yoko, Daniel, Beau.)

Rejected? Well, The First One Seldom Works Out: Be rejected by a job you applied to for the first time.

Rejected Again? I Thought Third Time Was the Charm: Be rejected by a job you applied to for the third time.

Set a New High Score in the Rhythm Game: available from the second time you play a song, just get a new high score!

Tech Buzzword Encyclopedia: collect all buzzwords at the coffee shop.

Tech Trivia Guru: Answer correctly to all questions in the Trivia quiz at the Hacker Space.

The Hacker Space Is My Second Home Now: Experience all events at Hacker Space.

This Job Needs Me to... ?: there are 6 achievements of this kind, related to job interviews. You could find job postings that have strange skill requirements, and finding those you unlock these achievements. The whole list of skill requirements is: Brew Coffee, Fix Fax Machines, Fuse Cables, Handle Angry Customers, Pacify Office Pets, and Retrieve Lost Passwords.

Travel in Time and SAVE the World: unlock one of the alternative endings (ones that are not getting a dev job) and then go back in time to continue playing.

You Can Never Be Too Careful with Prod: get a dev job, and once it's time to push your code to production, check your code again and again as many times as possible.

Quiz Question Easter Eggs

These are achievements that are unlocked by chance while you complete the quizzes. If you get one of the questions about freeCodeCamp right, you unlock one of these achievements.

• Contribute to Open Source with freeCodeCamp!
• Dr. DevDocs.io
• Hello, Earth to Code Radio!
• The Launch of freeCodeCamp
• The Mission of freeCodeCamp
• The Tech Stack of freeCodeCamp
• What inspired freeCodeCamp?
• freeCodeCamp Has a Chat Server? Fancy!
• freeCodeCamp Has a Forum? Neat!
• freeCodeCamp Has a Mascot? Cute!

Alternative Learn to Code RPG Endings

These are the achievements you unlock by playing the six different endings. There's one you can get to easily just by following the main storylines – but the others are all about chance. There is a small chance of the event that unlocks the ending happening in certain moments.

Cat Who Codes: this ending involves Mint the cat, during the night you could be woken up by the cat doing something...
Coding It Forward: during dinner you could have the chance to become a coding tutor, accept the offer to unlock this ending.
Dev Who Brought Down Prod on the First Day: get a dev job and play till the end to unlock this one.
Just Another Day at the Office: while going through job postings you could find one unrelated to coding, for an office job. Accept that job to unlock this ending.
Nature Lover at Heart: each day of forced rest there is a small chance that the character may come to the conclusion that learning to code is too much and decide to do something different...
Now serving 0xc0ffee: you could be offered a promotion at the Coffee Shop, accept it to unlock this ending.

Conclusion

This is the list of achievements for the release on December 22nd. I hope you can satisfy your completionist spirit with this guide. Have nice replays!

If you want to learn more about the game you can read the article Learn to Code RPG – A Visual Novel Video Game Where you Learn Computer Science Concepts from the game dev herself about the process of creating the game.

You may think that lambda functions are an intermediate or advanced feature, but here you will learn how you can easily start using them in your code.

In Python, functions are usually created like this:

def my_func(a):
  # function body

You declare them with the def keyword, give them a name, and then add the list of arguments surrounded by round parenthesis. There could be many lines of code, with as many statements and expressions as you need inside.

But sometimes you might need a function with only one expression inside, for example a function that doubles its argument:

def double(x):
  return x*2

This is a function that you can use, for example, with the map method.

def double(x):
  return x*2

my_list = [1, 2, 3, 4, 5, 6]
new_list = list(map(double, my_list))
print(new_list) # [2, 4, 6, 8, 10, 12]

This would be a good place to use a lambda function, as it can be created exactly where you need to use it. This means using fewer lines of code and and you can avoid creating a named function that is only used once (and then has to be stored in memory).

How to use lambda functions in Python

You use lambda functions when you need a small function for a short time – for example as an argument of a higher order function like [map](https://www.freecodecamp.org/news/python-map-function-how-to-map-a-list-in-python-3-0-with-example-code/) or filter.

The syntax of a lambda function is lambda args: expression. You first write the word lambda, then a single space, then a comma separated list of all the arguments, followed by a colon, and then the expression that is the body of the function.

Note that you can't give a name to lambda functions, as they are anonymous (without a name) by definition.

A lambda function can have as many arguments as you need to use, but the body must be one single expression.

Example 1

For example, you could write a lambda function that doubles its argument: lambda x: x*2, and use it with the map function to double all elements in a list:

my_list = [1, 2, 3, 4, 5, 6]
new_list = list(map(lambda x: x*2, my_list))
print(new_list) # [2, 4, 6, 8, 10, 12]

Notice the difference between this one and the function we wrote above with the double function. This one is more compact, and there is not an extra function occupying space in memory.

Example 2

Or you could write a lambda function that checks if a number is positive, like lambda x: x > 0, and use it with filter to create a list of only positive numbers.

my_list = [18, -3, 5, 0, -1, 12]
new_list = list(filter(lambda x: x > 0, my_list))
print(new_list) # [18, 5, 12]

The lambda function is defined where it is used, in this way there is not a named function in memory. If a function is used i only one place it makes sense to use a lambda function to avoid cluttering.

Example 3

You can also return a lambda function from a function.

If you ever need to create multiple functions that multiply numbers, for example doubling or tripling and so on, lambda can help.

Instead of creating multiple functions, you could create a function multiplyBy as below, and then call this function multiple times with different arguments to create the functions that double, triple, and so on.

def muliplyBy (n):
  return lambda x: x*n

double = multiplyBy(2)
triple = muliplyBy(3)
times10 = multiplyBy(10)

The lambda function takes the value n from the parent function, so that in double the value of n is 2, in triple it is 3 and in times10 it is 10. Now calling these functions with an argument will multiply that number.

double(6)
> 12
triple(5)
> 15
times10(12)
> 120

If you weren't using a lambda function here, you would need to define a different function inside multiplyBy, something like the below:

def muliplyBy (x):
  def temp (n):
    return x*n
  return temp

Using a lambda function uses half the lines and makes it more readable.

Conclusion

Lambda functions are a compact way to write functions if your function includes only one small expression. They are not usually something that beginner coders use, but here you have seen how you can easily use them at any level.

In this article, we'll learn how random number generators work.

How an Analogic Random Number Generator Works

The simplest form of a RNG is throwing dice or flipping coins.

Using a single die or coin means that each value has the same probability of occurring. Using multiple dice or coins instead will give a lower probability to the highest and lower values, and a higher probability to the middle values.

The oldest known tabletop game, the Royal Game of Ur, uses four 4-sided dice. Each die can give a value of 0 or 1 meaning that the value obtained by a single dice throw can go from 0 to 4.

All the possible combinations obtained by throwing 4 dice, each can give a value of 0 or 1

There are 16 possible combinations, of which one gives a value of 0, 4 gives a value of 1, 6 gives a value of 2, 4 gives a value of 3, and one gives a value of 4.

In this case there is a 1/16 or 6.25% chance of getting 0, 1/4 or 25% chance of getting 1, 3/8 or 37.5% chance of getting 2, 1/4 or 25% chance of getting 3 and 1/16 or 6.25% change of getting 4.

More complex games have manuals full of tables to determine something randomly.

Part of a table for random effects after drinking a potion. Here's the whole table.

Any game that uses dice has an analogic random number generator.

How Random Number Generators Work in Video Games

In video games, RNGs are much less noticeable and more complex, and players might not even be aware they exist. There are many ways you can generate a Random Number, but how do you actually use one?

Breaking it down into the simplest terms, using a RNG is not dissimilar from what you saw above with the dice throw used to determine an effect from a table. You just don't see the dice throw.

In a video game, you can use a RNG to determine what kind of loot might be dropped by a fallen enemy, or what you can find in a chest, or what kind of random encounter will await you, or even what the weather will be.

RNGs are used, for example, to live up open world games without the developers having to code every single section of forests and roads and deserts. Instead, developers code some possibilities and let chance determine what happens when the player reaches a certain point in the map.

Will you meet a bear, a wolf pack, or some bandits? The game does its version of rolling a die to determine that.

Let's see how to code a simple example of a Random Number Generator to better understand how they actually work.

How to Code a Random Number Generator

Most programming languages contain a random function. This function returns a random number, and what kind of random number depends on its implementation.

For example, in JavaScript, Math.random() returns a random number between 0 (included) and 1 (not included). In Python, randint from the random module returns a whole number in a range (Python has also a function that does the same as JavaScript's Math.random).

Let's consider a pretty common video game situation: we have an enemy that often drops a common item, but now and then drops something rare. This enemy may be, for example, a wolf that could drop a wolf pelt (common) or a wolf fang (rare).

How do you determine what is "rare"? That depends on you – it can be that 1 in 10 drops is a rare item, or that 1 in 100 drops is a rare item. A middle ground may be a chance of 1 in 25 for a rare items. And to complicate it a bit, there could be also a 1 in 10 chance of no item.

In this case you would need a function that returns a value between 0 and 1.

A chance of 1 in 25 is 4%, and a chance of 1 in 10 is 10%. In decimal form that would be 0.04 and 0.1, respectively.

In this case you can say that a number in the range from 0 to 0.04 gives the rare item, and a number in the range from 0.9 to 1 gives no item.

The percentage breakdown of the wolf drop

To avoid sticking to one language, let's first see how we can code this using pseudocode. This is not a real programming language – rather, it's a way to break down the code logic. It's like taking notes, as it's personal and will have varied syntax depending on the person writing it.

FUNCTION wolfDrop
  randomNumber = random(0,1)
  IF
    randomNumber < 0.04
    THEN
     -> wolf fang
  ELSE IF
    randomNumber < 0.9
    THEN
     -> wolf pelt
  ELSE
    -> empty
  END IF
END FUNCTION

Or a more verbose version:

Create a function called wolfDrop and inside it store a random number between 0 (included) and 1 (excluded) in the randomNumber variable. If randomNumber has a value less than 0.04 the drop will be a wolf fang, else if the randomNumber has a value less than 0.9 the drop will be a wolf pelt, and otherwise there will be no drop.

With the pseudocode ready, we can implement the code snippet in any language. Let's see, for example, how to code it in a few different languages:

function wolfDrop () {
  const randomNumber = Math.random();
  if (randomNumber < 0.04) {
    return "Wolf fang";
  } else if (randomNumber < 0.9) {
    return "Wolf pelt";
  } else {
    return;
  }
}

import random
def wolfDrop():
  randomNumber = random.random()
  if randomNumber < 0.04:
    return "Wolf fang"
  elif randomNumber < 0.9:
    return "Wolf pelt"
  else
    return

(defn wolf-drop []
  (let [random-number (rand)]
    (cond (< random-number 0.04) "Wolf fang"
          (< random-number 0.9) "Wolf pelt")))

func wolfDrop() string {
    randomNumber := rand.Float64()
    switch {
        case randomNumber < 0.04:
            return "Wolf fang"
        case randomNumber < 0.9:
            return "Wolf pelt"
        default:
            return ""
    }
}

fun wolfDrop(): String {
    val randomNumber = Random.nextFloat()
    when {
        randomNumber < 0.04 -> return "Wolf fang"
        randomNumber < 0.9 -> return "Wolf pelt"
        else -> return ""
    }
}

def wolf_pelt() do
  random_number = :rand.uniform()
  cond do
    random_number < 0.04 -> "Wolf fang"
    random_number < 0.9 -> "Wolf pelt"
    true -> nil
  end
end

string WolfPelt() {
  var random = new Random();
  double randomNumber = random.NextDouble();
  if (randomNumber < 0.04) return "Wolf fang";
  if (randomNumber < 0.9) return "Wolf pelt";
  return null;
}

extern crate rand;

fn wolf_drop() -> &'static str {
  let random_number: f64 = rand::random();
  if random_number < 0.04 {
    "Wolf fang"
  } else if random_number < 0.9 {
    "Wolf pelt"
  } else {
    ""
  }
}

#include <stdlib.h>
#include <string.h>
#include <time.h>

int wolf_drop(char *drop_item) {
  srand((unsigned) time(0));
  double random_number = 1.0 * rand() / RAND_MAX;
  if (random_number < 0.04) {
    strncpy(drop_item, "wolf fang\0", 10);
  } else if (random_number < 0.9) {
    strncpy(drop_item, "wolf pelt\0", 10);
  } else {
    strncpy(drop_item, "\0", 1);
  }
  return 0;
}

function wolfdrop()
    randomnumber = rand()
    if randomnumber < 0.04
        return "wolf fang"
    elseif randomnumber < 0.9
        return "wolf pelt"
    else
        return ""
    end
end

(Thanks to alpox for the code snippets in Clojure, Golang, Kotlin, Elixir and C#, and to Jeremy for the snippets in Rust, C, and Julia.)

Other examples of math.random

If you want to learn more about all this, you can read this article about the Math.random function in JavaScript and create a Dice Rolling Game.

You can also read this article on using the random walk algorithm and create a random dungeon map with JavaScript to experiment some more with RNGs.

Conclusion

Random Number Generators, or RNGs, are used in many games. In this article, you have learned how and why they are used, and you've seen an example implementation.

Next time you play a video game, will you be able to spot where a RNG may be used?

There are two possible ways to undo your last commit. We'll look at both of them in this article.

The revert command

The revert command will create a commit that reverts the changes of the commit being targeted. You can use it to revert the last commit like this:

git revert <commit to revert>

You can find the name of the commit you want to revert using [git log](https://www.freecodecamp.org/news/git-log-command/). The first commit that's described there is the last commit created. Then you can copy from there the alphanumerical name and use that in the revert command.

In this image, each circe represents a commit.

The reset command

You can also use the reset command to undo your last commit. But be careful – it will change the commit history, so you should use it rarely. It will move the HEAD, the working branch, to the indicated commit, and discard anything after:

git reset --soft HEAD~1

The --soft option means that you will not lose the uncommitted changes you may have.

In this image, each circle represents a commit.

If you want to reset to the last commit and also remove all unstaged changes, you can use the --hard option:

git reset --hard HEAD~1

This will undo the latest commit, but also any uncommitted changes.

In this image, each circle represents a commit.

Should You Use reset or revert in Git?

You should really only use reset if the commit being reset only exists locally. This command changes the commit history and it might overwrite history that remote team members depend on.

revert instead creates a new commit that undoes the changes, so if the commit to revert has already been pushed to a shared repository, it is best to use revert as it doesn't overwrite commit history.

Conclusion

You have learned two ways to undo the last commit and also when it's best to use one over the other.

Now if you notice that your last commit introduces a bug or should have not been committed you know how to fix that!

In this guide you will learn how to delete directories and files from the Linux command line.

The Linux rm Command

The rm (short for remove) command is pretty useful. Let's learn its syntax and look at a few examples to see it in action.

rm Command Syntax

The syntax is shown below, with args being any number of arguments (folders or files).

rm [options] args

Without options you can use it to delete files. But to delete directories you need to use the options for this command.

The options are as follows:

• -r, "recursive" – this option allows you to delete folders and recursively remove their content first
• -i, "interactive" – with this option, it will ask for confirmation each time before you delete something
• -f, "force" – it ignores non-existent files and overrides any confirmation prompt (essentially, it's the opposite of -i). It will not remove files from a directory if the directory is write-protected.
• -v, "verbose" – it prints what the command is doing on the terminal
• -d, "directory" – which allows you to delete a directory. It works only if the directory is empty.

Linux rm Command Example

Let's take a project_folder directory as an example. It has these files and folders inside:

Let's use this directory to show how the various options work.

You can add the option -v to all commands so that it will write down step by step what's going on.

So, let's start with the first option, -r. You just learned that this removes files and folders recursively. You can use it like this rm -r project_folder or also rm -rv project_folder as the verbose option.

It has deleted the project_folder directory and everything inside it, in the order shown.

Let's recreate the folder and try again.

What happens if you don't use the -r option and you try to delete the directory anyway? It will not allow it and will instead show an error:

To delete directories you can use the -d option, but if you try to use it in this case it will give an error as the folder is not empty.

The -i option make so that it asks about each action individually.

And you need to press y or n and then Enter after each query.

If you select y for all queries it will delete everything:

If instead you decide to not delete some files or folders, with n it will keep those files and continue with the rest:

The last option we haven't seen so far is -f, which will suppress errors.

For example writing as below you would be trying to delete two non existing files – there is not a rat.png file, and dog.pmg has a typo and it gives two errors. With the -f option, you will not see the errors.

Conclusion

The Linux command line is pretty useful if you're a developer. In this article, you have seen one of its possible commands, rm, that you can use to delete directories and files.

Enjoy this new tool in your arsenal!

To do this in SQL, you can use JOIN statements. The LEFT JOIN statement is one of the various JOIN statements available. When you use it to join two tables, it keeps all the rows of the first table (the left table), even if there is not a corresponding match on the second table.

You can use JOIN in a SELECT query to join two tables, table_1 and table_2, like this:

SELECT columns
FROM table_1
LEFT OUTER JOIN table_2
ON relation;

SELECT columns
FROM table_1
LEFT JOIN table_2
ON relation;

First you write which columns will be present in the joined table. You can specify to which table the column belongs by prefixing the table name to the column name. This is necessary if some columns have the same name (like table_1.column_1 and table_2.column_1) with SELECT <columns>.

Then you would write the name of the first table as FROM table_1.

After that you'd write the name of the second table as LEFT OUTER JOIN table_2 or LEFT JOIN table_2 (omitting the OUTER keyword).

And at the end you'd write the relation to use to match the rows, for example ON table_1.column_A = table_2.column_B. Often the relation is by id, but it can be with any column.

SQL LEFT JOIN Example

Let's say you have a book database in which you have two tables, one with books, the other with authors. To avoid repeating all the author info for each book, that info is in its own table, and the books have only the author_name column.

We can join these two tables based on the names of the authors. Using the books table as the left table, you can write the following code to join them:

SELECT books.title AS book_title, books.publ_year, books.author_name, authors.year_of_birth, authors.place_of_birth
   FROM books
   LEFT JOIN authors
   ON books.author_name = authors.name
;

Let's break it down.

In the first line, you choose which columns to show in the final table. It's also the place to decide if some columns will have a different name in the resulting table using AS like with books.title AS book_title.

The second line, FROM books, says which is the first table to consider, also called the left table.

Then the third line, LEFT JOIN authors, says which other table to consider.

ON books.author_name = authors.name says to match the tables using the rows books.author_name and authors.name.

After this query you would get the table as below, where the rows that didn't get info from the authors table just show NULL.

Note that the authors not present in the books table are not in this joined table. This is because, as I said before, only the unrelated rows from the left table (in this case books) are kept, not those from the right/second table.

A more complex LEFT JOIN example

Let's see another way you can use JOIN together with other SQL features to do some data analysis.

You might want to see how many books from each author are present in the database. You could use the below query to do so:

SELECT authors.name AS author_name,
    SUM(
      CASE
        WHEN books.title LIKE '%'
          THEN 1
        ELSE 0
      END
    ) as number_of_books
  FROM authors
  LEFT JOIN books
  ON books.author_name = authors.name
  GROUP BY authors.name
  ORDER BY number_of_books DESC
;

Code breakdown

Line 1: with SELECT you list the columns you want in the resulting table.

Line 2: SUM is an aggregation function used in conjunction with GROUP BY. The values of the rows that are grouped together are then summed.

Line 3-7: you use the CASE statement to get different results depending on a condition. In this case, a row is counted as 1 if it contains a book title, otherwise it is counted as 0. And here we use LIKE to check if the cell contains any characters (learn more in this article about Contains String).

Line 8: this gives a name of number_of_books to the column that is created for the SUM.

Line 9: the left/first table in this case is authors.

Line 10: the right/second table in this case is books.

Line 11: this joins the two tables using the author names.

Line 12: the rows are grouped by author name - all the rows with the same value in that column will be represented by a single row.

Line 13: we use order by to arrange in descending order using the number of books.

The query will give you the below table. Note that you see here only the authors that are present in the authors table. The authors mentioned in the books table without an entry in the authors table are not present here. This is an effect of the fact that the unrelated rows from the books table were not kept.

If the authors table is updated to include all the authors mentioned in the books table, like this:

Then the table from the query above would actually give the number of books for all authors.

Conclusion

In a Relational Database, data should be written only once, so we often end up with multiple tables related to each other. LEFT JOIN is a really useful ally when we need to analyse data and join information from different tables. Enjoy querying your database using this powerful tool.