R Basics Exercises: 18 Practice Problems with Solutions

Explanation: %/% returns the integer quotient (floor of x / y) and %% returns the remainder. The single-call form c(name = value, ...) builds a named vector in one pass, which is cleaner than calling names() afterward. A common mistake is to assume x / y already truncates to an integer; in R the / operator always returns a double (here 3.4), so when you need a clean quotient you must reach for %/%.

Explanation: Atomic vectors in R hold one type, so c() walks a coercion ladder: logical -> integer -> double -> character. The presence of a single string forces every element into character, which is why 1L becomes "1" and TRUE becomes "TRUE". The painful version of this bug appears when a stray text value lands in a CSV column and quietly turns your numeric series into strings, breaking later arithmetic. Always check typeof() after reading data you do not control.

Explanation: typeof() reports the underlying storage (integer vs double), class() reports the S3 class that method dispatch uses, and mode() is a coarser older grouping. For most modern code you want typeof() for storage questions and class() for dispatch questions. mode() is rarely the right answer; it exists for back-compatibility with S, and lumps integer and double together as "numeric", which can mask the very distinction you are trying to debug.

Explanation: Both forms produce the same printed values, but identical() returns FALSE because seq(50, 1, by = -1) is a double while 1:50 is an integer, and rev() preserves type. If you need them to compare equal, use seq.int(50, 1, by = -1L) for the explicit integer form, or coerce one side with as.integer(). This is the same coercion trap as Exercise 1.2 in a different costume: equality in R cares about storage type, not just printed digits.

Explanation: R recycles the shorter operand to the length of the longer one, position by position. When 6 / 2 == 3 cleanly, no warning. When 6 / 4 == 1.5, R still completes the operation (recycling c(10, 20, 30, 40, 10, 20)) but warns you that the recycling was not exact. Catching the warning with withCallingHandlers() plus muffleWarning lets you inspect it without aborting; tryCatch() would have stopped the expression. The recycling rule is the single biggest source of silent vector bugs in R, so when you see "not a multiple" treat it as an error to fix.

Explanation: Every arithmetic operator in R is vectorized, so subtraction broadcasts the scalar mean(mtcars$mpg) across the whole column and division broadcasts the scalar sd(...) the same way. There is no need to walk indices one at a time. The mean of the result is exactly 0 in theory and a tiny float artifact (7e-17) in practice; this floating-point residue is harmless and is why you should compare floats with all.equal(), not ==. The base helper scale(x)[, 1] does the same calculation if you want a one-shot version.

Explanation: which() converts a logical vector to the integer positions of its TRUE entries, which is exactly what you need when downstream code (a plotting helper, a row-removal step, a join key) expects indices rather than a boolean mask. Note that which() silently drops NA from its input, unlike a raw boolean subset where NA indices would expand the result. Use the vectorized & here, not the short-circuiting &&, which only looks at the first element of each side and will give you the wrong answer for vectors longer than 1.

Explanation: & is vectorized and returns one logical per position; && only inspects the first element of each side and returns a single scalar, which is exactly what you want inside if (...) and almost never what you want for filtering. Since R 4.3, && and || on length-greater-than-1 vectors throw an error rather than the historical silent behaviour, but in plenty of installed packages and stack-overflow snippets you will still see the old form. The rule of thumb: use & and | for data, && and || only inside scalar control flow.

Explanation: any() can return TRUE even with NA in the input as soon as it finds at least one confirmed TRUE, because no unknown value can change the answer. all() cannot return TRUE while an NA is unresolved because that unknown might be FALSE, so it returns NA by default. Passing na.rm = TRUE drops the NA before evaluating. The lesson: never trust an unparameterized all() on data that might have missing values; the silent NA propagation can disguise a "passes all checks" signal as merely "unknown".

Explanation: R is 1-indexed, and positive integers pick positions while negative integers drop them. You cannot mix positive and negative indices in a single bracket: v[c(1, -2)] is an error. Using length(v) instead of hardcoding 6 is a habit worth forming early; the day someone changes the vector to length 7, v[c(1, 6)] quietly produces the wrong answer while v[c(1, length(v))] keeps working.

Explanation: A logical mask is more robust than positional indexing because it keeps tracking the right rows even after sorts and joins reshuffle the table. Putting the mask in keep first lets you reuse it (for an apply() count, a print of dropped rows, an audit log) without recomputing. The condition for cyl uses == because we want exact membership; cyl <= 4 would also include any imaginary 1, 2, 3-cylinder rows, which the data does not have but a hand-typed filter should still reject deliberately.

Explanation: [ preserves the container: subsetting a list with single bracket always returns a (shorter) list, even when you ask for exactly one element. [[ extracts the contents of a single slot, so a list of one character vector becomes the bare character vector itself. The third common form, $, is equivalent to [[ for named lists but does not work with computed names. The rule of thumb: use [[ when you want the value inside a slot; use [ only when you really want to keep the wrapping list. Misuse here is the single most common cause of "why is my data a list?" debugging sessions.

Explanation: paste0() is paste(..., sep = ""); using it directly avoids the constant ceremony of passing sep = "" to glue tokens together without spaces. Notice the vectorization: quarter is length 4 and the scalars get recycled, so a single call produces all four filenames. For more complex templates with named placeholders, sprintf("report_%dQ%d.csv", year, quarter) or glue::glue("report_{year}Q{quarter}.csv") are more readable; for two or three tokens, paste0() wins on terseness.

Explanation: Both nchar() and substr() are vectorized over their main argument, so a single call handles all four words without an explicit loop. substr(s, start, stop) is end-inclusive (positions 1 through 3 give three characters), unlike Python's s[0:3] slicing. For strings shorter than stop, substr() silently returns whatever exists rather than padding or erroring, which is a behaviour you should remember when validating fixed-width inputs. Setting stringsAsFactors = FALSE is a safety habit on R versions before 4.0; the default flipped in 4.0 but explicit beats implicit.

Explanation: Passing levels = ... overrides the default alphabetical ordering, which would otherwise put "high" before "low" and break any model or plot that respects factor order. ordered = TRUE turns the factor into an ordered factor (class c("ordered", "factor")), so comparison operators like < work correctly. Subsetting a factor preserves all original levels even when no observations use them, which is why categorical models can mysteriously refuse to converge after filtering. droplevels() removes the orphans and is the right cleanup step after any filter that narrows a factor column.

Explanation: A default value (digits = 2) makes the function pleasant to call without arguments yet still tunable when needed. Naming the elements at construction time (via c(name = value)) is cheaper and more readable than building the vector first and adding names() afterward. Two real-world refinements you would add next: an na.rm argument that you pass through to mean, sd, min, and max, and a guard if (!is.numeric(x)) stop("x must be numeric") so the function fails fast on bad inputs instead of cascading cryptic warnings.

Explanation: if (cond) ... else ... is scalar control flow: it expects a length-1 logical and warns or errors otherwise. ifelse(test, yes, no) is vectorized and walks elementwise, which is why it just works on the full column. The loop version is correct but slower and noisier; for simple two-branch labels, prefer ifelse(). For more than two branches, reach for dplyr::case_when() or a lookup-table join, both of which scale to many conditions far more readably than nested ifelse() calls.

Explanation: The two key mistakes a beginner makes in a stateful loop are growing the output with c(out, value) (which reallocates on every iteration and turns a fast O(n) job into O(n^2)) and iterating with 1:length(x) (which silently iterates 1:0 = c(1, 0) when x is empty). Preallocating out and using seq_along(x)[-1] avoids both traps. For genuinely stateful work like exponentially weighted averages or sequential simulations, an explicit loop is fine; for plain cumulative reductions, cumsum(), cumprod(), or Reduce() are clearer and faster.