Practice Activity 2: Modernizing the Process

Today you will be creating and manipulating vectors, lists, and data frames to uncover a top secret message using the tidyverse. First thing is to include the package in a setup chunk above!

This task is complex. It requires many different types of abilities. Everyone will be good at some of these abilities but nobody will be good at all of them. In order to solve this puzzle, you will need to use the skills of each member of your group.

Groupwork Protocols

During the Practice Activity, you and your partner will alternate between two roles—Developer and Coder.

When you are the Developer, you will type into the Quarto document in RStudio. However, you do not type your own ideas. Instead, you type what the Coder tells you to type. You are permitted to ask the Coder clarifying questions, and, if both of you have a question, you are permitted to ask the professor. You are expected to run the code provided by the Coder and, if necessary, to work with the Coder to debug the code. Once the code runs, you are expected to collaborate with the Coder to write code comments that describe the actions taken by your code.

When you are the Coder, you are responsible for reading the instructions / prompts and directing the Developer what to type in the Quarto document. You are responsible for managing the resources your group has available to you (e.g., cheatsheet, textbook). If necessary, you should work with the Developer to debug the code you specified. Once the code runs, you are expected to collaborate with the Developer to write code comments that describe the actions taken by your code.

Group Norms

Remember, your group is expected to adhere to the following norms:

1. Think and work together. Do not divide the work.
2. You are smarter together.
3. No cross-talk with other groups.

Part Zero: Accessing the Practice Activity

To access the activity and get it ready to share:

1. Log into your CSUMB R Server Account.
   
2. Choose one partner (with the closest upcoming birthday) to create an R Project called “pa-1-intro-quarto”.
   
3. Upload the pa1-base-r.qmd into the project folder.
   
4. Share the project with the other partner, go to File > Share Project > Type partner’s username > Click Add

For each code chunk, add a #| label: and a #comment describing what the code chunk is doing. Be sure to check that all spacing is appropriate as well!

Part One: Setup

Each of the following R chunks will cause an error and / or do the desired task incorrectly. Find the mistake, and correct it to complete the intended action.

1. Create vectors containing the upper case letters, lower case letters, and some punctuation marks. add a label that indicate this code chunk creates the vectors of letters and punctuation.

lower_case <- c("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
                "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z")

upper_case <- c("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
                "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z")

punctuation <- c(".", ",", "!", "?", "'", '"', "(", ")", " ", "-", ";", ":")

Using the above, we can complete the following 5 steps within a few lines of code using the tidyverse.

2. Make one long vector containing all the symbols.
3. Turn the my_symbols vector into a data frame, with one column named “symbol”.
4. Find the total number of symbols we have in our data frame.
5. Create a new variable in your dataframe that assigns a number to each symbol.

# add comment here

my_symbols <- tibble(symbols = c(lower_case, 
                                 upper_case, 
                                 punctuation)) |> 
              mutate(num = row_number()) 

Part Two: Decoding the secret message.

This chunk will load up the encoded secret message as a vector:

#extracts the code from a dropbox file and pulls out generic first vector X1
library(readr)
top_secret <- read_csv("https://www.dropbox.com/s/k72h1zewk4gtqep/PA_Secret_Code?dl=1", 
                       col_names = FALSE)$X1

By altering this top secret set of numbers, you will be able to create a message. Write your own code to complete the steps, in the order given below, but replace all of this mess with the tidyverse code below.

6. Add 14 to every number.
7. Multiply every number by 18, then subtract 257.
8. Use the exp() function to exponentiate every number.
9. Square every number.

#add comment here
#there are several ways to do this, the way below doesn't overwrite any column so you "don't lose work"

code_break <- top_secret |> 
  as_tibble() |> 
  mutate(step6 = top_secret + 14,
         step7 = step6*18 - 257,
         step8 = exp(step7),
         step9 = step8^2)

head(code_break) #see the first few lines here

Checkpoint: Headquarters has informed you that at this stage of decoding, there should be 352 numbers in the secret message that are below 17. Write the code to verify that this is true for your top_secret object!

Hint: This is what is called a “relational” comparison, where you compare an object to a number and R will give you a vector of TRUEs and FALSEs based on whether the comparison is / is not met. You can then use these TRUEs and FALSEs as numbers, since TRUE = 1 and FALSE = 0 in R land.

#add comment here

code_break |> 
  summarize(total = sum(step9 < 17))

Next, carry out the following steps:

10. Turn your vector of numbers into a matrix with 5 columns.

#add comment here
code_matrix <- code_break |> 
  pull(step9) |> 
  matrix(ncol = 5) |> 
  as_tibble(column_name = TRUE) |> 
  mutate(id = row_number())

11. Separately from your top secret numbers, create a vector of all the even numbers between 1 and 382. Name it “evens”. That is, “evens” should contain 2, 4, 6, 8 …, 382.

#add comment here
evens <- seq(from = 2, to = 382, by = 2)

12. Subtract the “evens” vector from the first column of your secret message matrix.
13. Subtract 100 from all numbers 18-24th rows of the 3rd column.
14. Multiply all numbers in the 4th and 5th column by 2.
15. Turn your matrix back into a vector.

#add comment here
code_vector <- code_matrix |> 
  mutate(V1 = V1 - evens) |> 
  mutate(V3 = if_else(id %in% 18:24, V3 - 100, V3)) |> 
  mutate(V4 = V4*2, 
         V5 = V5*2) |> 
  select(-id) |> 
  pivot_longer(V1:V5, names_to = "column", values_to = "code") |> 
  arrange(column) |> 
  mutate(id = row_number())

Checkpoint: Headquarters has informed you that at this stage of decoding, all numbers in indices 500 and beyond are below 100. Write the code to verify that this is true for your top_secret object!

Hint: Use a relational comparison similar to what you used in the last checkpoint, but here you will need to subset values from your vector!

#code to verify that indices 500 and beyond have values **below** 100
code_vector |> 
  summarize(beyond = sum(if_else(id %in% 500:max(id) >= 100, TRUE, FALSE))) 

16. Take the square root of all numbers in indices 38 to 465.
17. Use the round() function to round all numbers to the nearest whole number.
18. Replace all instances of the number 39 with 20. Hint: Step 18 requires another relational comparison, but this time it is equality. Equality in R is checked with a double equal sign rather than a single equal sign

#add comment here
code_vector_update <- code_vector |> 
  mutate(code = if_else(id %in% 38:465, sqrt(code), code)) |> 
  mutate(code = round(code, digits = 0)) |> 
  mutate(code = if_else(code == 39, 20, code))

Checkpoint: Headquarters has informed you that your final message should have 344 even numbers.

Hint: Checking for divisibility is an interesting operation that isn’t done much in R. Modulus is the operation you are interested in, where you are checking for whether the numbers are divisible by 2, with no remainder. See what you can find about modulus in R!

# Code to verify how many even numbers are in your top_secret vector

code_vector_update |> 
  summarize(even = sum(code %% 2 == 0))

Part 3: The secret message!

Use your final vector of numbers as indices for my_symbols to discover the final message, by running the following code:

# add comment here
code_vector_update |> 
  left_join(my_symbols, by = c("code" = "num")) |> 
  pull(symbols) |> 
  stringr::str_c(collapse = "")

Google the first line of this message, if you do not recognize it, to see what poem it is.