R interview questions

What a strong answer covers

• Define an atomic vector as a homogeneous collection of elements of the same data type.
• Define a list as a heterogeneous collection that can store elements of different types, including other data structures.
• Provide a clear R code example for creating a numeric vector.
• Provide a clear R code example for creating a list containing different data types or structures.

Where people lose the point

• ×Confusing the homogeneity of vectors with the heterogeneity of lists.
• ×Incorrectly stating that vectors can hold elements of different types without coercion.
• ×Providing examples that don't clearly illustrate the core difference.

What a strong answer covers

• Explain that a data frame is a list of vectors of equal length, representing a tabular data structure.
• Demonstrate creating a data frame using `data.frame()` with named vectors as arguments.
• Mention key characteristics: columns are vectors, all columns must have the same number of rows, and columns can be of different data types.
• Discuss how to inspect a data frame (e.g., `str()`, `head()`, `dim()`).

Where people lose the point

• ×Attempting to create a data frame with columns of unequal length without handling.
• ×Not mentioning that columns can be of different types.
• ×Forgetting to name the columns when creating from scratch.

What a strong answer covers

• Demonstrate subsetting using positive integer indices (e.g., `x[c(2, 4)]`).
• Demonstrate subsetting using logical indexing (e.g., `x[x == 20 | x == 40]`).
• Briefly explain the advantages or use cases for each method (e.g., integer for known positions, logical for conditional selection).
• Mention that negative indices exclude elements, but are not suitable for this specific extraction.

Where people lose the point

• ×Using incorrect indexing (e.g., `x[2,4]` which is for matrices/data frames).
• ×Only providing one subsetting method when asked for different ones.
• ×Misunderstanding how logical vectors are recycled during subsetting.

What a strong answer covers

• Explain that `install.packages('packagename')` is used to download and install a package from CRAN (or other repositories) onto the local system.
• Explain that `library(packagename)` (or `require(packagename)`) is used to load an installed package into the current R session, making its functions available.
• Clarify that installation only needs to happen once per R version, while loading is required in every new R session where the package is used.
• Mention that `install.packages()` typically requires an internet connection, but `library()` does not.

Where people lose the point

• ×Confusing `install.packages()` with `library()` or vice-versa.
• ×Stating that a package needs to be installed in every session.
• ×Not understanding that `library()` makes functions available, while `install.packages()` puts the files on disk.

What a strong answer covers

• State that missing values are represented by `NA` (Not Available) in R.
• Explain that `NA` can exist for all atomic vector types (numeric, character, logical).
• Demonstrate how to check for `NA` values using `is.na()` on a vector.
• Show how to use `is.na()` in conjunction with `sum()` or `any()` to count or detect missing values in a vector or across a data frame.

Where people lose the point

• ×Confusing `NA` with `NULL` (which represents the absence of an object).
• ×Attempting to use `== NA` for checking missing values, which always returns `NA`.
• ×Not knowing how to apply `is.na()` to a data frame (e.g., `colSums(is.na(df))`).

What a strong answer covers

• Explain that `apply` family functions (e.g., `lapply`, `sapply`, `vapply`, `apply`) are generally preferred for iterating over lists, vectors, or margins of arrays/matrices.
• Highlight the benefits: conciseness, readability, and often better performance due to underlying C/Fortran implementations.
• Describe `lapply` for returning a list and `sapply` for attempting to simplify the output to a vector or matrix.
• Mention that `for` loops are still appropriate for tasks with side effects, complex control flow, or when the output structure is highly variable and not easily handled by `apply` functions.

Where people lose the point

• ×Incorrectly claiming `apply` functions are *always* faster than `for` loops in all scenarios.
• ×Not being able to differentiate between `lapply` and `sapply`'s return types.
• ×Failing to acknowledge any valid use cases for `for` loops.

What a strong answer covers

• Create a sample data frame suitable for the demonstration.
• Use `filter()` to subset rows based on a logical condition (e.g., `column > value`).
• Use `select()` to choose a subset of columns.
• Use `mutate()` to create a new column by transforming existing ones (e.g., `new_col = col1 + col2`).
• Correctly chain these operations using the pipe operator (`%>%` or `|>`).

Where people lose the point

• ×Incorrect `dplyr` verb usage or syntax (e.g., `filter(column == 'value')` vs `filter(column = 'value')`).
• ×Misunderstanding the order of operations in a pipeline.
• ×Not using the pipe operator, leading to nested or less readable code.

What a strong answer covers

• Define a `character` vector as a simple sequence of text strings.
• Define a `factor` as a vector used to store categorical data, where elements are stored as integers with associated labels (levels).
• Explain that factors are particularly useful for statistical modeling and plotting, as R treats them as nominal or ordinal variables.
• Provide scenarios for using `character` (e.g., free text, unique identifiers) and `factor` (e.g., gender, education level, experimental groups).

Where people lose the point

• ×Not understanding that factors have underlying integer representations.
• ×Failing to mention the importance of factors in statistical modeling.
• ×Incorrectly converting between character and factor, especially when dealing with numeric-like factors.

What a strong answer covers

• Explain that R uses lexical scoping, meaning that the environment where a function was *defined* determines where it looks for variables, not where it is *called*.
• Describe the search path for variables: first in the function's own environment, then its enclosing environment (where it was defined), and so on up to the global environment and loaded packages.
• Provide a simple code example demonstrating how a function accesses variables from its defining environment.
• Contrast lexical scoping with dynamic scoping (where variables are looked up in the calling environment), noting R does not use dynamic scoping by default.

Where people lose the point

• ×Confusing lexical scoping with dynamic scoping.
• ×Incorrectly stating that functions only see variables passed as arguments.
• ×Failing to explain the 'search path' or 'enclosing environment' concept.

What a strong answer covers

• Identify the three essential components: Data, Aesthetics (aes), and Geoms (geometric objects).
• Explain that **Data** is the data frame containing the variables to be plotted.
• Describe **Aesthetics (aes)** as the mapping of variables from the data to visual properties of the plot (e.g., x-position, y-position, color, size, shape).
• Define **Geoms (geometric objects)** as the visual representations of the data (e.g., `geom_point` for points, `geom_bar` for bars, `geom_line` for lines).
• Illustrate how these components are combined in a basic `ggplot2` call (e.g., `ggplot(data, aes(x, y)) + geom_point()`).

Where people lose the point

• ×Omitting one of the three core components.
• ×Confusing the role of aesthetics with geoms (e.g., saying `geom_point` defines the color directly, rather than `aes(color = variable)`).
• ×Not understanding that `ggplot()` initializes the plot with data and global aesthetics, while `geom_` functions add layers.

What a strong answer covers

• Explain that the coefficient for `x` represents the estimated change in the mean of `y` for a one-unit increase in `x`, assuming all other predictors are held constant (though not applicable in a simple linear regression).
• Mention that the sign of the coefficient indicates the direction of the relationship (positive for increasing `y` with `x`, negative for decreasing `y` with `x`).
• Discuss the importance of the p-value associated with the coefficient to determine its statistical significance (i.e., whether the observed relationship is likely due to chance).
• Briefly touch on the intercept's interpretation as the expected value of `y` when `x` is zero, if zero is a meaningful value for `x`.

Where people lose the point

• ×Confusing correlation with causation based solely on the coefficient.
• ×Ignoring the p-value and only focusing on the magnitude of the coefficient.
• ×Incorrectly interpreting the coefficient as a percentage change without appropriate transformations.

What a strong answer covers

• State that R generally uses 'pass-by-value' semantics, but with a 'copy-on-modify' optimization.
• Explain that when an argument is passed to a function, a copy of the object is not immediately made. Instead, the function receives a pointer to the original object.
• Clarify that a copy is only made if the function *modifies* the object. If the object is not modified, no copy is made, saving memory and time.
• Provide a clear R code example where a function modifies an argument, and show that the original object outside the function remains unchanged, demonstrating copy-on-modify behavior.

Where people lose the point

• ×Simply stating 'pass-by-value' without mentioning the copy-on-modify optimization.
• ×Providing an example where the argument is not modified, thus not demonstrating the 'copy' aspect.
• ×Confusing R's behavior with true pass-by-reference where the original object *would* be modified.

What a strong answer covers

• Define an environment as a collection of named objects (variables, functions) and a pointer to an enclosing environment.
• Explain that environments form a hierarchical structure, with the global environment at the top, and each function call creating a new execution environment.
• Describe how R uses environments for variable lookup: when a variable is referenced, R searches the current environment, then its enclosing environment, and so on up the search path until the variable is found or an error occurs.
• Relate environments to lexical scoping, emphasizing that a function's enclosing environment is determined by where it was *defined*, not where it is called.

Where people lose the point

• ×Confusing environments with simple lists or data frames.
• ×Misunderstanding the hierarchical nature of environments or the search path.
• ×Failing to connect environments directly to how R resolves variable names and implements lexical scoping.

What a strong answer covers

• Define Non-Standard Evaluation (NSE) as R's ability to capture and evaluate expressions in a non-standard way, often without explicit quoting, allowing functions to 'see' the names of variables directly from the calling environment.
• Provide examples of NSE in `dplyr` (e.g., `filter(df, x > 5)`) or `ggplot2` (e.g., `aes(x = variable)`), where variable names are used directly without quotes.
• Explain the benefits (more concise, readable code) and challenges (can be harder to program with, especially when writing functions that wrap NSE functions).
• Describe how the `rlang` package provides tools (e.g., `{{}}` for 'embrace', `enquo()`, `!!` for 'unquote') to explicitly quote, unquote, and programmatically work with expressions, making it easier to write functions that correctly interact with NSE.

Where people lose the point

• ×Not understanding that NSE involves capturing expressions rather than evaluating values immediately.
• ×Failing to provide concrete examples from `dplyr` or `ggplot2`.
• ×Not mentioning `rlang` or its role in managing NSE programmatically.

What a strong answer covers

• Define vectorization as performing operations on entire vectors or matrices at once, rather than element by element using explicit loops.
• Explain the primary benefits: improved performance (due to optimized C/Fortran code underlying vectorized operations), more concise and readable code, and reduced chance of off-by-one errors common in loops.
• Provide a clear R code example demonstrating a simple operation (e.g., adding two vectors, squaring elements) using both a `for` loop and a vectorized approach.
• Discuss how to measure the performance difference (e.g., using `system.time()` or `microbenchmark`).

Where people lose the point

• ×Not providing a concrete example that clearly shows the performance difference.
• ×Failing to explain *why* vectorized operations are faster (i.e., underlying compiled code).
• ×Only mentioning conciseness without also highlighting performance benefits.

What a strong answer covers

• Define 'wide' format: each row represents a single observational unit, and different measurements or variables for that unit are stored in separate columns.
• Define 'long' format: each row represents a single observation of a variable, with identifier columns and separate columns for 'key' (variable name) and 'value' (measurement).
• Explain the advantages of long format for `ggplot2` and many statistical models.
• Demonstrate converting a wide data frame to long format using `tidyr::pivot_longer()`, specifying `cols` to pivot, `names_to` for the new key column, and `values_to` for the new value column.

Where people lose the point

• ×Confusing wide and long definitions.
• ×Not understanding the purpose or benefits of converting between formats.
• ×Incorrectly using `pivot_longer()` arguments or choosing the wrong columns to pivot.