R String Exercises: 18 stringr Practice Problems Solved

Explanation: str_detect() returns a logical vector that plugs directly into filter(). Wrapping the pattern in regex(..., ignore_case = TRUE) makes the match case-insensitive without altering the original text. A common mistake is text == "great", which checks for an exact match rather than a substring match.

Explanation: str_count() returns one integer per input string, unlike str_detect(), which returns one TRUE/FALSE. Wrapping with regex() controls case sensitivity. To rank by aggressive copy, pipe into arrange(desc(free_count)). Note that str_count() counts non-overlapping matches, so "aaaa" matched against "aa" returns 2, not 3.

Explanation: The caret ^ anchors the match to the start of the string, while \\d matches any single digit. Without ^, the regex would match any digit anywhere in the string, returning ALPHA-12 and BETA-99 too. The double backslash is needed because R parses \\d as a literal \d before the regex engine sees it.

Explanation: str_extract() returns the FIRST match per string as a character vector, or NA when none is found. \\d{4} matches exactly four consecutive digits. If filenames could contain other four-digit numbers (an order id, for example), tighten the pattern with surrounding underscores: (?<=_)\\d{4}(?=_). Convert to integer with as.integer() if you need numeric years.

Explanation: str_extract_all() returns a list (one element per input) where each entry is every match found, or character(0) for strings with none. #\\w+ matches a literal # followed by one or more word characters (letters, digits, underscore). Use str_extract() for one match per string; switch to _all when a string can hold many. Flatten with unlist() to get one long vector.

Explanation: str_match() returns a matrix: column 1 is the full match, columns 2 onward are each capture group in order. Parentheses around \\d{3} create capture groups, while the outer \\( and \\) escape the literal parentheses of the input. Coerce to a tibble with as_tibble(ex_2_3[, -1], .name_repair = ~ c("area", "exchange", "line")) for downstream joins.

Explanation: A backreference \\1 in the replacement string refers to the first capture group, which is the last four digits here. Anchoring with ^ and $ ensures the pattern only matches a complete card number, not a 16-digit substring embedded in something else. str_replace() is enough since each input has exactly one card; switch to str_replace_all() for multi-card strings.

Explanation: [- ]? matches an optional hyphen or space between i and phone, covering all four variants in one pattern. The regex(..., ignore_case = TRUE) wrapper means we do not need separate alternatives for uppercase I. Always prefer one tight regex over a chain of str_replace_all() calls: it is faster and easier to maintain.

Explanation: \\B is a non-word-boundary, preventing a comma at position 0. The lookahead (?=(\\d{3})+(?!\\d)) matches positions followed by groups of three digits, ending where no more digits remain. Numbers under 1000 stay untouched because no qualifying position exists. For locale-aware formatting on actual numerics, formatC(x, big.mark = ",", format = "d") is simpler.

Explanation: str_split_fixed() returns a rectangular matrix with n columns, padding short rows with "". Compare with str_split(), which returns a list of variable-length vectors and is awkward to bind into a frame. For names with middle parts ("Ada Augusta King Lovelace"), n = 2 keeps the first token and bundles the rest into column 2. To get a tibble, wrap with as_tibble(.name_repair = ~ c("first", "last")).

Explanation: str_pad() is the idiomatic way to widen short strings with a fill character. side = "left" pads on the left, which is correct for zero-prefixed identifiers. Inputs that already meet or exceed width are returned unchanged. A common alternative is sprintf("%05d", zips), but str_pad() is more readable and composes cleanly inside a dplyr pipeline.

Explanation: Two capture groups bind the first token and everything after the first space, then the replacement swaps them. Using (.+) for the second group keeps multi-part surnames intact ("Le Guin", "Van Dijk"). The alternative str_split() plus paste() works too but operates on a list, while the regex approach stays vectorised and faster.

Explanation: ^ and $ force the entire input to match, not just a substring, so 1234 fails because it is only four digits long. The group (-\\d{4})? makes the four-digit extension optional, accepting both plain ZIP and ZIP+4. Without anchors, 1234 would match the first four digits of any longer string and return TRUE incorrectly.

Explanation: \\b is a word boundary, ensuring the match starts and ends at a word edge so dinary does not match inside extraordinary. [A-Za-z]{7,} requires at least seven letters. To include words with digits or hyphens, switch to \\w{7,} or extend the character class. Call unlist() to get a single flat vector across all sentences.

Explanation: A lookbehind (?<=\\$) requires a $ immediately before the match, but the $ itself is not part of the captured text, so you get clean numerics. (?:...) is a non-capturing group used here so the decimal portion is optional without polluting capture results. Convert to numeric for totals with as.numeric(unlist(ex_5_3)).

Explanation: str_squish() trims outer whitespace AND collapses internal runs to single spaces, doing the job of str_trim() plus a replace in one step. str_to_title() capitalises the first letter of every space-separated token. Watch out for names like "o'brien", where you may want capitalisation after the apostrophe too; that requires a custom regex pass with str_replace_all().

Explanation: (.+?) is a lazy capture, stopping at the first ] so the timestamp does not bleed into the next field. (\\w+) captures the alphabetic level; ([\\w.]+) allows dotted service names like auth.service. Lines that fail the pattern give a row of NA, which makes upstream validation easy: filter is.na(timestamp) to surface malformed records.

Explanation: Replacing one or more non-alphanumerics with a single dash ([^a-z0-9]+) collapses spaces, punctuation, and multiple dashes in one pass. The final pass strips leading and trailing dashes that resulted from punctuation at the edges. For Unicode titles with accents, run stringi::stri_trans_general(x, "Latin-ASCII") before lowercasing so characters like é fold to e.