DataCamp Exercise

It is time for DATA CAMP exercises!

Take your first steps with R. To test your knowledge up to know you can test yourself in the following exercises.

  • R makes use of the # sign to add comments, so that you and others can understand what the R code is about. Comments are not run as R code, so they will not influence your result. You will find the task written as comment.
  • Write directly in the script.R window on the left. The comments are telling you what to do.
  • When you are ready press Submit and every line of code is interpreted and executed by R and you get a message whether or not your code was correct.
  • The output of your R code is shown in the Console panel on the right.
  • Press Hint for tips.
  • Press Solution for a new tab showing the solution.
  • Be patient: this may take some time to load.
DataCamp Light | Standalone example

Simple calculation to start:

# no pec # Calculate 3 + 4 3 + 4 # Calculate 6 + 12 # Calculate 3 + 4 3 + 4 # Calculate 6 + 12 6 + 12 test_output_contains("18", incorrect_msg = "Make sure to add `6 + 12` on a new line. Do not start the line with a `#`, otherwise your R code is not executed!") success_msg("Awesome! See how the console shows the result of the R code you submitted? Now that you're familiar with the interface, let's get down to R business!")

Just add a line of R code that calculates the sum of 6 and 12, just like the example in the sample code!

Arithmetic calculations

In its most basic form, R can be used as a simple calculator with the following arithmetic operators:

  • Addition: +
  • Subtraction: -
  • Multiplication: *
  • Division: /
  • Exponentiation: ^
  • Modulo: %%

The last two might need some explaining:

The ^ operator raises the number to its left to the power of the number to its right: for example 3^2 is 9.

The modulo %% returns the remainder of the division of the number to the left by the number on its right, for example 5 %% 3 is 2.

Instructions:

  • Type 5^2 in the editor to calculate 2 to the power 5.
  • Type 28 %% 6 to calculate 28 modulo 6.
  • Submit the answer and have a look at the R output in the console.
# no pec # An addition example 5 + 5 # A subtraction example 5 - 5 # A multiplication example 3 * 5 # A division example 10 / 2 # Exponentiation (5²) # Modulo (28 modulo 6) # An addition 5 + 5 # A subtraction 5 - 5 # A multiplication 3 * 5 # A division 10 / 2 # Exponentiation (5²) 5 ^ 2 # Modulo (28 modulo 6) 28 %% 6 msg = "Do not remove the other arithmetic examples!" test_output_contains("5^2", incorrect_msg = "The exponentiation example is not correct. Write `5 ^ 2` on a new line.") test_output_contains("28 %% 6", incorrect_msg = "There seems to be an issue with the modulo example. Write `28 %% 6` on a new line.") success_msg("Great! Head over to the next exercise.")

Another example of the modulo operator: 9 %% 2 equals 1.

Assign variables part 1

A basic concept in (statistical) programming is called a variable.

A variable allows you to store a value (e.g. 4) or an object (e.g. a function description) in R. You can then later use this variable's name to easily access the value or the object that is stored within this variable. You can assign a value 4 to a variable with the command my_var <- 4.

Instructions:

  • Complete the code in the editor such that it assigns the value 42 to the variable x.
  • Print x.
  • Submit the answer.
# no pec # Assign the value 42 to x # Print out the value of the variable x # Assign the value 42 to x x <- 42 # Print out the value of the variable x x test_object("x", undefined_msg = "Make sure to define a variable `x`.", incorrect_msg = "Make sure that you assign the correct value to `x`.") success_msg("Good job! Have you noticed that R does not print the value of a variable to the console when you did the assignment? `x <- 42` did not generate any output, because R assumes that you will be needing this variable in the future. Otherwise you wouldn't have stored the value in a variable in the first place, right? Proceed to the next exercise!")

Look at how the value 4 was assigned to my_variable in the exercise's assignment. Do the exact same thing in the editor, but now assign 42 to the variable x.

Assign variables part 2

Suppose you have a fruit basket with five apples and you want to store the number of apples in a variable with the name my_apples.

Instructions:

  • Type the following code in the editor: my_apples <- 5. This will assign the value 5 to my_apples.
  • Print my_apples.
  • Submit the answer.
# no pec # Assign the value 5 to the variable my_apples # Print out the value of the variable my_apples # Assign the value 5 to the variable my_apples my_apples <- 5 # Print out the value of the variable my_apples my_apples test_object("my_apples", undefined_msg = "Please make sure to define a variable `my_apples`.", incorrect_msg = "Make sure that you assign the correct value to `my_apples`.") test_output_contains("my_apples", incorrect_msg = "Have you explicitly told R to print out the `my_apples` variable to the console?") success_msg("Great! Continue to the next exercise!")

Remember that if you want to assign a number or an object to a variable in R, you can make use of the assignment operator <-. Alternatively, you can use =, but <- is widely preferred in the R community.

Assign variables part 3

Every tasty fruit basket needs oranges, so you decide to add six oranges. Your reflex is to immediately create the variable my_oranges and assign the value 6 to it. Next, you want to calculate how many pieces of fruit you have in total. Since you have given meaningful names to these values, you can now code this in a clear way: my_apples + my_oranges.

Instructions:

  • Assign to my_oranges the value 6.
  • Add the variables my_apples and my_oranges and have R simply print the result.
  • Assign the result of adding my_apples and my_oranges to a new variable my_fruit.
# no pec # Assign a value to the variables my_apples and my_oranges my_apples <- 5 # Add these two variables together # Create the variable my_fruit # Assign a value to the variables my_apples and my_oranges my_apples <- 5 my_oranges <- 6 # Add these two variables together my_apples + my_oranges # Create the variable my_fruit my_fruit <- my_apples + my_oranges test_object("my_apples", incorrect_msg = "Keep the line that assigns 5 to `my_apples`.") test_object("my_oranges", incorrect_msg = "Keep the line that assigns 6 to `my_oranges`.") test_output_contains("my_apples + my_oranges", incorrect_msg = "Make sure to print out the result of adding `my_apples` and `my_oranges`. The code example in the description already gives away the answer to this instruction!") msg <- "Have you used `my_fruit <- my_apples + my_oranges` to create the `my_fruit` variable?" test_object("my_fruit", undefined_msg = msg, incorrect_msg = msg) success_msg("Nice one! The great advantage of doing calculations with variables is reusability. If you just change `my_apples` to equal 12 instead of 5 and rerun the script, `my_fruit` will automatically update as well. Continue to the next exercise.")

my_fruit is just the sum of my_apples and my_oranges. You can use the + operator to sum the two and <- to assign that value to the variable my_fruit.

Apples and oranges

Common knowledge tells you not to add apples and oranges.
The my_apples and my_oranges variables both contained a number in the previous exercise. The + operator works with numeric variables in R. If you really tried to add "apples" and "oranges", and assigned a text value to the variable my_oranges (see the editor), you would be trying to assign the addition of a numeric and a character variable to the variable my_fruit. This is not possible.

Instructions:

  • Submit the answer and read the error message. Make sure to understand why this did not work.
  • Adjust the code so that R knows you have 6 oranges and thus a fruit basket with 11 pieces of fruit.
# no pec # Assign a value to the variable my_apples my_apples <- 5 # Fix the assignment of my_oranges my_oranges <- "six" # Create the variable my_fruit and print it out my_fruit <- my_apples + my_oranges my_fruit # Assign a value to the variable my_apples my_apples <- 5 # Fix the assignment of my_oranges my_oranges <- 6 # Create the variable my_fruit and print it out my_fruit <- my_apples + my_oranges my_fruit test_error(incorrect_msg = "You can do this by setting the `my_oranges` variable to a numeric value, not a string!") test_object("my_apples", incorrect_msg = "Make sure that `my_apples` still contains `5`.") test_object("my_oranges", incorrect_msg = "Make sure that `my_oranges` is equal to `6`.") test_object("my_fruit", incorrect_msg = "The value of `my_fruit` is not correct. It should be 11, the sum of `my_apples` and `my_oranges`.") test_output_contains("my_fruit", incorrect_msg = "Don't remove the line that prints out `my_fruit`.") success_msg("Awesome, keep up the good work! Continue to the next exercise.")

You have to assign the numeric value 6 to the my_oranges variable instead of the character value "six". Note how the quotation marks are used to indicate that "six" is a character.

Basic data types in R

R works with numerous data types. Some of the most basic types to get started are:

  • Decimal values like 4.5 are called numerics.
  • Whole numbers like 4 are called integers. Integers are also numerics.
  • The Boolean values TRUE or FALSE are called logical.
  • Text (or string) values are called characters.
    Note how the quotation marks in the editor indicate that "Apple" is a string just like "five".

Instructions:

Change the value of the following variables:
  • my_numeric to 42.
  • my_character to "universe". Note that the quotation marks indicate that "universe" is a character.
  • my_logical to FALSE.

Note that R is case sensitive!

# no pec # Change my_numeric to be 42 my_numeric <- 42.5 # Change my_character to be "universe" my_character <- "some text" # Change my_logical to be FALSE my_logical <- TRUE # Change my_numeric to be 42 my_numeric <- 42 # Change my_character to be "universe" my_character <- "universe" # Change my_logical to be FALSE my_logical <- FALSE test_object("my_numeric", incorrect_msg = "Have you correctly changed the declaration of `my_numeric` so it contains the value 42?") test_object("my_character", incorrect_msg = "Have you correctly changed `my_character` to `\"universe\"`? Don't forget the quotes!") test_object("my_logical", incorrect_msg = "Have you correctly changed `my_logical` to `FALSE`? All letters of `FALSE` should be capitalized!") success_msg("Great work! Continue to the next exercise.")

Replace the values in the editor with the values that are provided in the exercise. For example: my_numeric <- 42 assigns the value 42 to the variable my_numeric.

What's that data type?

Do you remember that when you added 5 + "six", you got an error due to a mismatch in data types? You can avoid such situations by checking the data type of a variable beforehand. You can do this with the class() function, as the code in the editor shows.

Instructions:

  • Complete the code in the editor and also print out the classes of my_character and my_logical.
# no pec # Declare variables of different types my_numeric <- 42 my_character <- "universe" my_logical <- FALSE # Check class of my_numeric class(my_numeric) # Check class of my_character # Check class of my_logical # Declare variables of different types: my_numeric <- 42 my_character <- "universe" my_logical <- FALSE # Check class of my_numeric class(my_numeric) # Check class of my_character class(my_character) # Check class of my_logical class(my_logical) msg <- "Do not change the declaration of the variables!" lapply(c("my_numeric", "my_character", "my_logical"), test_object, undefined_msg = msg, incorrect_msg = msg) patt <- "Have you included `class(%1$s)` to print out the data type of `%1$s`?" test_output_contains("class(my_numeric)", incorrect_msg = "Do not remove the code that prints out the type of `my_numeric`.") test_output_contains("class(my_character)", incorrect_msg = sprintf(patt, "my_character")) test_output_contains("class(my_logical)", incorrect_msg = sprintf(patt, "my_logical")) success_msg("Congratulations! This was the last exercise for this chapter. Head over to the next chapter to get immersed in the world of vectors!")

The code that prints the data type of my_numeric is already included; do a similar things for my_character and my_logical.

Congratulations! This was the last exercise for this chapter.

Updated: