stringr Exercises in R: 28 Practice Problems with Solutions

Explanation: str_length() counts Unicode characters, not bytes, which matters for accented or emoji input where nchar() can mislead with multibyte encodings. The return is always a plain integer vector the same length as the input, with NA preserved for missing entries. Prefer it over nchar() in any pipeline that may see non-ASCII data.

Explanation: str_sub() accepts negative positions so str_sub(fruit, -3, -1) would give the last three letters instead, which substr() cannot do without arithmetic. The function is also assignable: str_sub(x, 1, 3) <- "XYZ" overwrites the first three characters in place. Vectorised over both the string and the position arguments.

Explanation: str_pad() only grows strings, it never truncates, which is why GOOGL stays at length 5 untouched. The side argument accepts "left", "right" or "both" for centring, and pad can be any single character. For situations where you want truncation too, chain with str_trunc(), or use formatC() for sprintf-style numeric padding.

Explanation: str_squish() collapses every internal run of whitespace down to a single space and also trims leading and trailing whitespace in one step, doing what str_trim() plus a str_replace_all("\\s+", " ") would have taken two calls. str_to_title() uppercases the first letter of each word and lowercases the rest, which is exactly what name normalisation needs. For locale-sensitive casing (Turkish dotted-i, German eszett) pass locale = "tr" or similar.

Explanation: str_detect() returns a logical the same length as the input so it slots straight into filter() calls or base subsetting. The pattern is a regular expression by default, but plain literals like "ap" still work because they happen to be valid regex. Use fixed("ap") if you want to disable the regex engine for speed or to avoid metacharacter surprises on user input.

Explanation: str_subset(x, pat) is shorthand for x[str_detect(x, pat)] and reads more cleanly in a pipeline. The dollar sign $ anchors the pattern to the end of the string, which is why "thing" matches but "things" would not. Pair with ^ for start-of-string anchors and \\b for word boundaries when you cannot assume the target is the whole string.

Explanation: str_starts() and str_ends() are anchored detect helpers, equivalent to str_detect(x, "^pat") and str_detect(x, "pat$"). The dot in .com is escaped to \\.com so it matches a literal period rather than any character. Splitting the test into two named conditions reads better in code review than one long regex like "^https.*\\.com$".

Explanation: str_count() returns the number of non-overlapping matches per input string, perfect for tallying character classes. The bracketed set [aeiouAEIOU] is a regex character class, where every character inside is an alternative. You could also write the case-insensitive version as regex("[aeiou]", ignore_case = TRUE) if you want the casing toggled outside the pattern itself.

Explanation: str_which() is the index-returning sibling of str_detect(), equivalent to which(str_detect(x, pat)). Index vectors are useful when you need to align two parallel vectors, write back into a subset of a column or pass to slice(). The caret ^ anchors the regex at the start, so "blackberry" matches but a hypothetical "oblique fruit" would not.

Explanation: str_extract() returns the first match per string and NA when nothing matches, which is exactly what you want for joining downstream (the NA row drops on an inner join). \\d+ means "one or more digits" and is shorter than [0-9]+ but identical under default ASCII matching. To convert to integers in a single pipeline, chain as.integer() after the extract.

Explanation: Because the count of hashtags differs per tweet, str_extract_all() returns a list with one vector per input, which unlist() flattens for de-duplication. The pattern #\\w+ reads as "a literal hash followed by one or more word characters", where \\w is the regex shorthand for [A-Za-z0-9_]. If you want to keep the per-tweet structure instead, leave the list and pass it directly to purrr::map().

Explanation: str_match() differs from str_extract() by returning a matrix where column 1 is the whole match and subsequent columns are the parenthesised capture groups. The pattern uses [^,]+ (one or more non-comma characters) to grab the last name, then \\s+ to consume the comma-space separator, then .+ to take everything else. For a wider table with many capture groups consider tidyr::separate_wider_regex() which builds the tibble directly.

Explanation: The regex [0-9,]+(?:\\.[0-9]+)? matches one or more digits and commas, then an optional non-capturing group (?:...) for the decimal part. The non-capturing form is important because we just need a single string back from str_extract(), not a tidy matrix of pieces. The comma removal happens after extraction since R's as.numeric() does not understand thousands separators, and NA propagates through the cast for the no-amount row.

Explanation: (?<=@) is a positive lookbehind that requires an @ immediately before the match position but does not include the @ in the returned text. Then [^@]+$ consumes everything that is not another @ up to the end of the string, which is robust to weird local-parts. If you cannot rely on a regex engine with lookbehinds (some older versions), a str_match() with a capture group is a portable alternative.

Explanation: str_replace() only touches the first match per input string, leaving later occurrences alone. For non-compound names with zero spaces the function is a no-op, and the original value is returned unchanged. Use str_replace_all() when you need every occurrence rewritten, which is the much more common need in practice.

Explanation: str_replace_all() is the global-replace cousin of str_replace() and walks every non-overlapping match in each string. The pattern \\d matches one digit at a time so the dollar amount 50 becomes XX rather than a single X, which is what compliance usually wants. If you needed to mask whole numeric runs with one X regardless of length, use \\d+ instead.

Explanation: str_remove_all(x, pat) is shorthand for str_replace_all(x, pat, ""), which is the common cleaning idiom worth keeping in your fingers. [[:punct:]] is a POSIX character class that catches the full punctuation set in a locale-aware way, including apostrophes, colons and brackets without you having to list every glyph. Note headline 1 becomes "ratecut" not "rate cut" because the hyphen is removed, not replaced with a space, so add a space replacement step if word boundaries matter.

Explanation: Backreferences \\1, \\2, \\3 in the replacement string refer to the first, second and third parenthesised groups in the pattern, letting you reorder pieces without writing R-level string concatenation. Anchoring with ^...$ rejects partial-match input that would silently produce a half-rewritten string. For genuine date arithmetic prefer lubridate::dmy() since it understands more formats and returns proper Date objects, but for pure-string reshaping the regex approach is fastest.

Explanation: When the pattern argument is a named character vector, str_replace_all() runs every name as a regex against every input and replaces with the corresponding value, which is a tiny built-in lookup engine. Anchoring each key with ^...$ prevents "en" from matching inside "enabled" or other longer strings. For a much larger or non-regex lookup, dplyr::recode() or a left_join() on a translation table scales better.

Explanation: Without simplify = TRUE you get a list with one character vector per input, which is right when row lengths vary but awkward when they are uniform. simplify = TRUE returns a matrix padded with "" if some rows happen to be shorter than the longest. For a tidy-tibble alternative, use tidyr::separate_wider_delim() so each column gets a name immediately.

Explanation: str_c() with collapse = ", " reduces a vector of length n to a single string of length 1, useful for building human-readable summaries. The trick is splitting off the last element so you can prepend the Oxford comma plus "and " before joining the head and tail. For very long lists, consider knitr::combine_words() which handles this idiom natively.

Explanation: str_glue_data() resolves {name} against the column names of the data frame, which is cleaner than paste0() with many $column references. The output is a glue vector that prints without quotes and converts to a regular character vector with as.character() if a downstream function complains. For Markdown or Quarto templating use glue::glue_collapse() to join the resulting vector with bullet points.

Explanation: str_squish() runs first because trimming and collapsing internal whitespace makes the casing transform and the comma split predictable. str_split(x, ",\\s*") splits on a comma optionally followed by whitespace, which is more forgiving than "," alone. Because the inputs had different tag counts you get a list back, which is the right shape for tidyr::unnest_longer() if this is part of a tidy-data pipeline.

Explanation: separate_wider_delim() is the modern tidyr replacement for the deprecated separate() and is built on stringr-style splitting. The names argument creates typed columns directly, and if any row has the wrong number of pieces you get an informative error rather than silent truncation. For variable-width pieces (no fixed column count) use separate_longer_delim() to get extra rows instead.

Explanation: The pattern explicitly anchors ^...$ so partial matches are rejected, important for any validation use case where you do not want "hello alice@example.com world" to pass. The local-part class allows the realistic set including +, . and %, the domain class allows hyphens and dots, and the {2,10} quantifier on the TLD rejects the suspiciously long fake .toolongdomainname. Full RFC 5322 conformance is famously hard; a conservative regex like this catches >99% of typos in practice without false-flagging legitimate addresses.

Explanation: str_match() returns one row per input with one column per capture group plus a column 1 holding the whole match, perfect for parsing structured log lines. The square brackets around the level need escaping \\[ and \\] because they are character-class metacharacters in regex. For larger workflows look at tidyr::separate_wider_regex() which builds the tibble directly without the intermediate matrix.

Explanation: Lowercasing first means the character class [^a-z0-9] does not have to enumerate uppercase too, which keeps the regex compact. The + quantifier on the negated class collapses runs of punctuation and whitespace into a single hyphen, so "1.5.0!" becomes "1-5-0". The final ^-|-$ strip handles inputs that begin or end with punctuation, which is otherwise easy to forget and ugly when you see /posts/-intro- in a URL bar.

Explanation: The pattern uses [^/]+ for the host (everything up to the first slash) and an optional (/.*)? for the path so URLs that omit the trailing slash do not produce NA. The if_else() step fills missing paths with "/", the convention every well-behaved web server uses. For production URL parsing, prefer urltools::url_parse() which understands ports, query strings and fragments, but for one-off cleanup the regex is faster to read.