R Programming Interview Questions

lapply is defined to return a list of the same length as X. Each element of the result is the return value of FUN applied to the corresponding element of X, and no simplification is performed. This is what distinguishes it from sapply, which attempts to simplify the result to a vector or matrix.

purrr::map() returns a list, but purrr::map_dbl() is a type-stable variant that always returns a numeric (double) vector of the same length as .x. The _dbl suffix signals the return type, and the function will error if .f produces non-numeric output for any element. This type-stability is the main reason to prefer map_dbl over sapply.

The 'l' in lapply stands for 'list'. lapply() iterates over a list (or an object coerced to a list), applies a function to each element, and always collects the results into a list — even when every result is a scalar. No simplification of the output structure is performed.

sapply() is a wrapper around lapply() that by default attempts to simplify the output: if each result is a scalar, it returns a vector; if each result is a vector of equal length, it returns a matrix. When simplification is not possible it falls back to a list, just like lapply(). The other options describe apply(), mclapply(), or fabricated restrictions.

sapply() applies sum() to each element of the list: sum(1:3) = 6 and sum(4:6) = 15. Because each result is a scalar of the same type, sapply() simplifies the output into a numeric vector c(6, 15). If lapply() were used instead, the result would be the list list(6, 15).

Line 2 uses <- (the assignment operator) instead of == (the equality comparison operator). x <- 5 assigns the value 5 to x and evaluates to 5, which is truthy in R, so the if condition is always TRUE no matter what x was before. Changing <- to == makes the code compare x to 5 as intended.

Line 6 uses a standalone if instead of else if. When n > 0, the first block sets result to "positive", but execution then falls through to the second independent if (n < 0) test. That test is FALSE, so the else branch overwrites result to "zero". Using else if on line 6 makes the three branches mutually exclusive, so classify(7) correctly returns "positive".

R's sapply first evaluates its arguments, producing the vector 1:3 as X. It then passes X and the function to lapply, which iterates over the vector and applies the function to each element, storing each return value in a list. Finally, sapply calls simplify2array on that list; because every element is a length-1 numeric, simplify2array produces the atomic numeric vector c(1, 4, 9).

sapply operates on a one-dimensional structure — an atomic vector or list. apply is designed for matrices and arrays: the second call passes a 2-D matrix (2 rows × 3 columns), and the third call passes a 3-D array (2 × 3 × 4). The dimensionality strictly increases: 1-D → 2-D → 3-D.

Line 2 correctly computes the sum x + y and stores it in result. However, line 3 returns x instead of result, so the function always returns its first argument rather than the sum. The fix is to change return(x) to return(result).

Each input element is summed: sum(1:2) = 3 and sum(3:5) = 8. Because every result is a length-1 scalar, sapply's default simplify = TRUE collapses the list into an unnamed numeric vector of length 2: c(3, 8). If the lengths differed sapply could fall back to a matrix or list.

purrr's map family shares the same iteration logic; the suffix determines the output type. map() is type-stable and always returns a list. map_dbl() is a typed variant that simplifies each result to a double and returns an atomic double vector of the same length as the input, raising an error if any element cannot be coerced to double.

Map is essentially a wrapper around mapply with SIMPLIFY set to FALSE. This means Map never simplifies — it consistently returns a list of the same length as the longest input. mapply, by contrast, has SIMPLIFY = TRUE by default and will collapse results into an atomic vector or matrix when the shapes allow it, making its return type less predictable.

R's next keyword is analogous to continue in many other languages: it halts the current iteration and moves to the next one. break terminates the loop altogether, regardless of the loop condition or remaining iterations.

R's parser reads input line by line. When the closing brace of an if block ends a line with no else following it, the parser treats the if statement as finished. A standalone else on the next line is then unexpected, causing a syntax error. Placing else on the same line as the closing brace tells the parser the statement continues.

For character-mode switch(), R compares EXPR against the names of the trailing arguments. The value bound to the first matching name is returned. If none of the names match and no unnamed default argument is supplied, switch() returns NULL. If an unnamed trailing argument is present, that default value is returned instead.

lapply always returns a list — its name stands for 'list apply' and the return type is guaranteed regardless of input or result shape (the first statement is true). sapply is a user-friendly wrapper that calls lapply and then attempts to simplify the list to a vector or matrix via simplify2array; when simplification fails it falls back to a list, so the claim that sapply always returns a vector is false and the claim that sapply is a wrapper around lapply that attempts to simplify the result to a vector or matrix when possible is true. Data frames in R are lists under the hood (each column is a list element), so lapply on a data frame iterates over columns (the last statement is true).

apply with MARGIN = 1 iterates over rows. Row 1 is 1+3+5 = 9, row 2 is 2+4+6 = 12, so the result is a named vector of length 2 (the statement that apply(m, 1, sum) returns a named numeric vector of length 2 is true, the statement that it returns a named numeric vector of length 3 is false). apply with MARGIN = 2 iterates over columns: 1+2 = 3, 3+4 = 7, 5+6 = 11, giving a named vector of length 3 (the statement that apply(m, 2, sum) returns a named numeric vector of length 3 is true). Since one returns length 2 and the other length 3, they are different lengths (the statement that they return different length vectors is true).

matrix(1:12, nrow=3, byrow=TRUE) fills row-wise producing rows (1,2,3,4), (5,6,7,8), (9,10,11,12). apply(mat, 1, ...) iterates over rows (MARGIN=1). For each row it computes the sum of squares: row 1 → 1+4+9+16=30; row 2 → 25+36+49+64=174; row 3 → 81+100+121+144=446. The result is a named (by row index) numeric vector printed as 30 174 446.

These flashcards target senior-level understanding of the R apply/purrr ecosystem: type-safety guarantees of vapply vs sapply, the strict-return contract of typed map_* functions versus sapply's silent coercion, and knowledge of purrr API evolution (invoke_map deprecation in favor of exec()-based patterns such as map2(.f_list, .args_list, ~ rlang::exec(.x, !!!.y))).

These flashcards test senior-level knowledge: the precise relationship between mapply/Map via SIMPLIFY, the side-effect design contract of purrr::walk versus map, and the internal simplify2array mechanism that governs sapply's often-surprising output shapes including the higher argument's effect on array dimensionality.

The first if evaluates check("A", FALSE), which appends "A" to log (via <<- into the enclosing f scope) and returns FALSE. Because && is short-circuit, check("B", TRUE) is never evaluated, so "B" is never appended. The overall condition is FALSE, so "X" is not appended. At this point log is c("A").

The second if evaluates check("C", TRUE), which appends "C" to log and returns TRUE. Because || is short-circuit and the left operand is already TRUE, check("D", FALSE) is never evaluated, so "D" is never appended. The condition is TRUE, so "Y" is appended. Now log is c("A", "C", "Y").

paste(log, collapse = "") yields the string "ACY", and cat prints it without quotes or a trailing newline.

A data frame is internally a list of columns, so lapply and sapply iterate over columns directly, preserving each column's original type. lapply(df, class) returns list(x = "integer", y = "character") (the first statement is true), and sapply(df, class) simplifies this to the named character vector c(x = "integer", y = "character") (the second statement is true). vapply(df, class, character(1)) does the same as sapply here but enforces that each result is a single character value, returning the identical named vector (the fourth statement is true). The third statement is false: apply first coerces the data frame to a matrix via as.matrix; because the columns have mixed types (integer and character), every element becomes character, so apply(df, 2, class) returns c(x = "character", y = "character"), not c(x = "integer", y = "character"). The fifth statement is false: apply(df, 1, class) iterates over 3 rows (not 2), each of which is a character vector in the coerced matrix, so it returns a character vector of length 3.

sapply is a wrapper: it calls lapply, then—if simplify is not FALSE and the result is non-empty—passes the result to simplify2array(answer, higher = (simplify == "array")). For 1:3, lapply produces list(NULL, NULL, NULL). Every element has length 0. simplify2array cannot build a vector or array from zero-length elements, so it returns list(). Hence sapply(1:3, function(x) NULL) evaluates to list(), not NULL or c(). The statement is TRUE.

When h() calls stop("boom"), the error begins stack unwinding. Before the error propagates, each function's on.exit expressions fire from the innermost frame outward. Inside h, two on.exit calls were made with add = TRUE and the default after = FALSE; this means the second expression (cat("H2 ")) is prepended before the first (cat("H ")), so they fire in the order H2 then H. Next, g's on.exit fires (G). The error then reaches the tryCatch in f, which catches it and runs the error handler (E). Because the error was caught, f continues normally and executes cat("D ") (D). When f returns normally, its on.exit fires (F). The full concatenated output is H2 H G E D F .