R Vectors Exercises: 18 Hands-On Problems with Worked Solutions

Explanation: c(1, 2, ...) and seq() produce double-precision vectors because the literals 1, 2, ... are doubles by default. The : operator and seq_len() produce integer vectors. The values print identically but identical() checks storage type as well as numerical equality, which is why the cross-type comparison returns FALSE. Use L suffixes (1L:10L) or as.integer() when you need integer storage.

Explanation: R coerces along the hierarchy logical < integer < double < character. c() picks the most general type present, so a single character literal forces everything to character and a single double demotes integers. The trap is c(1, "2", 3): the middle string silently turns numeric values into the strings "1" and "3", which then fail arithmetic downstream. Validate input types with is.numeric() before doing math on untrusted vectors.

Explanation: length(), head(), and tail() are the three cheapest checks you can run on an unknown vector. Together they confirm "right size, right start, right end" in three lines. head() and tail() default to six elements, so pass n = 3 (or just 3) when you want a tighter peek. For data frames the same trio works because length() returns the column count and head()/tail() slice rows.

Explanation: A vector of indices inside [ ] returns elements in the order requested, so prices[c(1, 5, 10)] is positional and prices[c(10, 5, 1)] reverses the order. The : shortcut builds a contiguous integer vector, making prices[11:15] the idiomatic way to pull a window. For overlapping or repeated picks (e.g., prices[c(1, 1, 2)]) the values repeat in the output: this is how c() with index vectors differs from set membership.

Explanation: Negative indexing means "exclude these positions". prices[-1] drops the first element, prices[-c(n-1, n)] drops the last two. head(x, -k) and tail(x, -k) accept negative counts as a cleaner idiom for trimming. Both produce the same result, but the head(prices, -2) form is more readable in pipelines and harder to off-by-one. Mixing positive and negative indices in the same call is an error: pick one or the other.

Explanation: & and | are element-wise, returning a logical vector the same length as their inputs. && and || collapse to a single TRUE/FALSE and only look at the first element of each side: using them inside [ ] silently filters by one comparison and drops the rest. The condition x > 30 & x < 75 is far cleaner than between(x, 30, 75) (which is dplyr) when you only need base R, and it's compiler-friendly because both comparisons short-circuit on FALSE.

Explanation: which() converts a logical vector to the integer positions where it is TRUE. Negating with ! flips the mask before passing in, so which(!results) gives the failing positions. For the count, sum() on a logical coerces TRUE to 1 and FALSE to 0, so sum(!results) counts failures without an explicit loop. This logical-to-position trick is the foundation of dplyr's slice() and filter() semantics.

Explanation: Character indexing on named vectors is one of R's most elegant features: pop["India"] works like a dictionary lookup, and the result preserves the name in the output. names(pop)[pop > 300] shows the pattern for "give me the labels of the matching values": apply the logical to names(), not to pop itself. The alternative pop[pop > 300] returns values with their names attached, which is useful when you want both.

Explanation: Backticks around SKU-A are required because the hyphen would otherwise be parsed as minus. The basket lookup is the canonical use case for named vectors: instead of an if/else cascade or a match() call, you index by the keys directly and the values come back in the requested order. For thousands of lookups, named vectors are faster than data frames because there's no row-search overhead.

Explanation: sort() works on the values and carries the names along, which is exactly what you want for the descending case. To sort by name instead, use order(names(pop)) to get the permutation and index back in. order() is the more general tool because it returns positions (so you can apply the same permutation to a parallel vector). For ties or mixed-type sorts, pass multiple vectors to order(): it breaks ties on the second argument.

Explanation: Every arithmetic operator (-, *, /, ^) is vectorised, so the scalar 32 is recycled across all eight elements automatically. There is no need for sapply() or a for loop. The compiled C code under the hood runs orders of magnitude faster than a manual loop in R. The same pattern handles columns in a data frame because columns are just vectors: mtcars$mpg * 1.609 converts MPG to kilometres-per-litre across all rows in one expression.

Explanation: R recycles the shorter vector to match the longer one. When the longer length is an exact multiple of the shorter (e.g., 6 and 3), there is no warning, which silently masks bugs. When it is not a multiple, R still does the operation but warns you. Position 4 holds a[4] + b[1] = 4 + 5 = 9 because b wraps back to its first element. Always treat recycling warnings as errors: in production code, wrap risky arithmetic in if (length(a) != length(b)) stop(...) so a typo cannot quietly corrupt a result.

Explanation: cumsum() is the vectorised running total: it returns a vector the same length as its input. Adding the scalar 1000 shifts every element up by the opening balance, again thanks to recycling. diff() returns first differences, which is one element shorter than its input, so to recover the daily P&L we prepend the opening balance to the running series before calling diff(). These two operators together cover ~80% of time-series feature engineering in base R.

Explanation: NA propagation is contagious: any arithmetic that touches an NA returns NA unless the function explicitly knows to skip them. Most aggregators in base R (mean, sum, sd, min, max, median, var) accept na.rm = TRUE for that purpose. Silent NAs are the single most common reason a downstream model errors out with "input contains missing values", so the safer default in pipelines is to either drop them upstream or impute, not to silently na.rm.

Explanation: Two facts catch most beginners: is.na(NaN) is TRUE because NaN counts as a flavour of missing, and is.null(NA) is FALSE because NA is a value but NULL is the absence of a value. Tests applied to NULL return zero-length logicals because NULL has length zero. is.finite(Inf) is FALSE, which matters for ratio calculations where a denominator can hit zero. The defensive pattern is x[is.finite(x)] to keep only "real" numbers before averaging.

Explanation: LOCF is the simplest imputation method and the only one that respects time order without lookahead. The single-pass loop works because by the time we hit position i, position i - 1 has already been filled (if it was NA, the previous iteration set it). The base-R vectorised trick uses cummax on a position index: ex_5_3 <- sensor[cummax((!is.na(sensor)) * seq_along(sensor))]. LOCF assumes the underlying signal is roughly piecewise-constant; for trending data, linear interpolation via approx() is usually better.

Explanation: The z-score (x - mean(x)) / sd(x) is the workhorse of distance-based outlier detection. Because mean and sd themselves are pulled up by the outliers, a single extreme value (here 245.0) inflates the standard deviation and can mask other outliers. The robust alternative is the modified z-score using median() and mad(): (x - median(x)) / mad(x). For very small samples (n < 30) or skewed distributions, prefer the IQR rule (Q1 - 1.5 * IQR and Q3 + 1.5 * IQR) over either z-score.

Explanation: cut() is the canonical way to turn a continuous numeric vector into an ordered factor with labeled bins. Using -Inf and Inf as the outer breakpoints catches anything below the lowest cut or above the highest, so you never accidentally produce NAs. The right = FALSE flag makes intervals left-closed and right-open [a, b), which matches how most product specs are written ("250 to 800 means at least 250 and below 800"). table() on a factor returns counts in factor-level order rather than alphabetical, preserving the low / mid / high reading direction.