Back to Google Data Analytics Certificate (GDA)

Data Analysis with R Programming

Master R programming language fundamentals including data manipulation, visualization, and documentation with RStudio.

Explores the R programming language and RStudio environment for data analysis. Covers fundamental programming concepts including functions, variables, data types, pipes, and vectors. Introduces R packages like the Tidyverse for data manipulation. Covers dataframes, generating visualizations, aesthetics and annotations, and R Markdown for documenting R programming and creating reports.
5 minutes 5 Questions

R Programming is a powerful tool for data analysis that is extensively covered in the Google Data Analytics Certificate program. R is an open-source programming language specifically designed for statistical computing and data visualization, making it ideal for analysts working with large datasets.…

Concepts covered: Benefits of R programming, R vs. other programming languages, RStudio environment, R console and scripts, Variables in R, Data types in R, Vectors in R, Lists and data structures in R, Functions in R, Writing custom functions, Pipes in R (magrittr, native), Conditional statements in R, Loops in R, R packages overview, Installing and loading packages, Tidyverse package ecosystem, dplyr for data manipulation, tidyr for data tidying, readr for data import, Data frames in R, Creating and manipulating data frames, Filtering and selecting data in R, Mutating and transforming data, Grouping and summarizing data, Accessing and importing data in R, Cleaning data in R, Handling missing values in R, ggplot2 for visualization, Creating plots with ggplot2, Aesthetics in ggplot2, Annotations in R visualizations, Customizing R plots, R Markdown basics, Creating reports with R Markdown, Code documentation in R

Test mode:
Start practice test
GDA - Data Analysis with R Programming Example Questions

Test your knowledge of Data Analysis with R Programming

Question 1

What is the purpose of the lag() and lead() functions in dplyr when performing data cleaning operations?

Correct Answer: They access previous or subsequent row values within a column to enable comparisons or calculations across rows

The lag() and lead() functions in dplyr are window functions designed to access values from previous or subsequent rows within the same column.

The lag() function retrieves the value from a preceding row (by default, one row back), while the lead() function retrieves the value from a following row (by default, one row ahead). This functionality is extremely useful in data cleaning and analysis when you need to:

  • Calculate differences between consecutive values (e.g., day-over-day changes)
  • Identify patterns or trends across sequential observations
  • Compare current values with previous or next values
  • Detect anomalies by comparing adjacent records

For example, if you have sales data, you could use lag(sales) to access yesterday's sales value and calculate the daily change.

The other options are incorrect:

  • Rearranging row order is accomplished by the arrange() function, not lag() or lead(). These functions don't change the order of data.

  • Shifting columns horizontally is not what these functions do. They work within a single column to reference values from different rows, not to move entire columns.

  • Creating time delays in processing pipelines is a misunderstanding of these functions. They are not related to processing timing or synchronization - they simply provide access to offset row values within the data itself.

Question 2

Which of the following best describes how R's memory-efficient handling of missing values (NA) benefits data analysts during exploratory data analysis?

Correct Answer: R propagates NA values through calculations predictably, allowing analysts to identify data quality issues while preserving dataset structure

The correct answer states that R propagates NA values through calculations predictably, allowing analysts to identify data quality issues while preserving dataset structure. This is accurate because R's handling of NA (Not Available) values is designed to be consistent and predictable - when you perform calculations involving NA values, the result is typically NA (unless you explicitly handle it with functions like na.rm=TRUE). This behavior is beneficial during exploratory data analysis because:

  1. It alerts analysts to the presence of missing data rather than silently ignoring it
  2. It preserves the integrity and structure of the original dataset
  3. It allows analysts to make informed decisions about how to handle missing values

The other answers are incorrect:

  • The answer about R automatically converting NA values to zero is false and would be dangerous behavior. Automatically replacing missing values with zero would produce misleading statistical results and hide data quality issues.

  • The answer about R storing NA values in a separate memory partition is technically incorrect. R does not use separate memory partitions for NA values; NA is simply a special logical constant that represents missing values within the same data structures.

  • The answer about R assigning unique identifiers to each NA value based on its original data source is false. NA values in R are not tracked with unique identifiers or source information. All NA values are treated the same way regardless of their origin.

Question 3

A credit risk analyst at a bank is building a customer segmentation model using a dataframe 'loan_applications' with columns: app_id, credit_score, annual_income, debt_ratio, loan_amount, employment_years, and approval_status. The analyst needs to create a training dataset by first selecting applications where credit_score is below 650 OR debt_ratio exceeds 0.45, then from that result, keep only rows where loan_amount is greater than $25,000 AND employment_years is at least 2. The final output should contain app_id, credit_score, debt_ratio, and loan_amount columns arranged by credit_score in ascending order. Which dplyr pipeline correctly implements this two-stage filtering approach with proper logical operator precedence?

Correct Answer: loan_applications %>% filter(credit_score < 650 | debt_ratio > 0.45) %>% filter(loan_amount > 25000, employment_years >= 2) %>% select(app_id, credit_score, debt_ratio, loan_amount) %>% arrange(credit_score)

The correct answer uses a two-stage filtering approach with separate filter() functions, which precisely matches the requirements.

Let's break down why this is correct:

  1. The first filter() applies the initial condition: credit_score < 650 OR debt_ratio > 0.45. This selects high-risk applications based on either poor credit or high debt ratio.

  2. The second filter() then applies the additional conditions: loan_amount > 25000 AND employment_years >= 2. Using a comma between conditions in filter() is equivalent to using AND (&), so this correctly requires BOTH conditions to be true.

  3. The select() function then picks the required columns: app_id, credit_score, debt_ratio, and loan_amount.

  4. Finally, arrange(credit_score) sorts by credit_score in ascending order (the default).

The second option is incorrect because it combines all conditions in one filter without proper parentheses. Due to operator precedence in R, AND (&) is evaluated before OR (|), so the expression would be interpreted as: credit_score < 650 OR (debt_ratio > 0.45 AND loan_amount > 25000 AND employment_years >= 2), which doesn't match the two-stage filtering requirement.

The third option is incorrect because it uses OR (|) between loan_amount > 25000 and employment_years >= 2, but the requirement states both conditions must be met (AND logic).

The fourth option has two problems: First, it performs select() before the second filter(), which removes the employment_years column needed for filtering. Second, it uses arrange(desc(credit_score)) for descending order, but the requirement asks for ascending order.

More Data Analysis with R Programming questions
1047 questions (total)
Start 100 question test