Regular expressions in R in R Programming - Step-by-Step Execution

Concept Flow - Regular expressions in R

Start with a string

↓

Define regex pattern

↓

Use regex function (e.g., grepl, gsub)

↓

Check match or replace

↓

If match found

→Return TRUE or replaced string

↓

If no match

→Return FALSE or original string

This flow shows how R uses a regex pattern to check or change parts of a string using functions like grepl or gsub.

Execution Sample

R Programming

text <- c("cat", "dog", "bird")
pattern <- "^c"
matches <- grepl(pattern, text)
print(matches)

This code checks which words in the list start with the letter 'c' and prints TRUE or FALSE for each.

Execution Table

Step	Variable	Value	Action	Output
1	text	["cat", "dog", "bird"]	Define vector of strings
2	pattern	"^c"	Define regex pattern to match strings starting with 'c'
3	matches	grepl(pattern, text)	Check each string if it starts with 'c'	[TRUE, FALSE, FALSE]
4	print(matches)		Print the logical vector	[TRUE, FALSE, FALSE]
5			End of execution	Execution stops after printing results

💡 All strings checked; grepl returns logical vector indicating matches

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
text	undefined	["cat", "dog", "bird"]	["cat", "dog", "bird"]	["cat", "dog", "bird"]	["cat", "dog", "bird"]
pattern	undefined	undefined	"^c"	"^c"	"^c"
matches	undefined	undefined	undefined	[TRUE, FALSE, FALSE]	[TRUE, FALSE, FALSE]

Key Moments - 3 Insights

Why does grepl return TRUE only for "cat"?

Because the pattern "^c" means 'start with c'. Only "cat" starts with 'c', so only its match is TRUE (see execution_table step 3).

What does the caret (^) symbol mean in the regex pattern?

It means 'start of string'. So the pattern "^c" matches strings that begin with the letter 'c' (see pattern definition in execution_table step 2).

Why is the output a logical vector and not the matched strings?

Because grepl returns TRUE or FALSE for each string to show if it matches. To get matched strings, functions like grep or regmatches are used (see execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'matches' after step 3?

A [TRUE, FALSE, FALSE]

B [FALSE, TRUE, FALSE]

C [TRUE, TRUE, TRUE]

D [FALSE, FALSE, FALSE]

💡 Hint

Check the 'matches' value in execution_table row with Step 3.

At which step is the regex pattern '^c' defined?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'pattern' variable assignment in execution_table.

If the pattern changed to 'd$', which string would grepl match?

A "cat"

B "dog"

C "bird"

D None

💡 Hint

The '$' means 'end of string'. Check which string ends with 'd' in the 'text' vector.

Concept Snapshot

Regular expressions in R use patterns to find or replace text.
Use functions like grepl() to check matches (returns TRUE/FALSE).
Patterns use symbols like ^ (start) and $ (end) to anchor matches.
Example: grepl("^c", c("cat", "dog")) returns TRUE for strings starting with 'c'.
Use gsub() to replace matched parts.
Regex helps search text efficiently in R.

Full Transcript

This visual execution shows how R uses regular expressions to find patterns in text. We start with a list of words and a regex pattern that looks for words starting with 'c'. Using grepl(), R checks each word and returns TRUE if it matches or FALSE if not. The caret symbol ^ means the start of the string. Only 'cat' starts with 'c', so only it returns TRUE. The output is a logical vector showing which words matched. This helps beginners see how regex patterns work step-by-step in R.

Practice

1. What does the grepl() function do in R when used with regular expressions?

easy

A. It checks if a pattern exists in a string and returns TRUE or FALSE.

B. It replaces all occurrences of a pattern in a string.

C. It extracts all matches of a pattern from a string.

D. It splits a string into parts based on a pattern.

Solution

1. Step 1: Understand the purpose of grepl()

   grepl() returns a logical value indicating if the pattern is found in the string.

2. Step 2: Compare with other functions

   Functions like gsub() replace text, and strsplit() splits strings, so they do not match grepl()'s behavior.

3. Final Answer:

   It checks if a pattern exists in a string and returns TRUE or FALSE. -> Option A

4. Quick Check:

   grepl() = logical check [OK]

Hint: Remember: grepl() returns TRUE/FALSE if pattern found [OK]

Common Mistakes:

• Confusing grepl() with gsub() which replaces text
• Thinking grepl() extracts matched text
• Assuming grepl() splits strings

2. Which of the following is the correct syntax to replace all occurrences of "cat" with "dog" in the string "cat and cat" using regular expressions in R?

easy

A. sub("cat", "dog", "cat and cat")

B. str_replace_all("cat and cat", "cat", "dog")

C. gsub("cat", "dog", "cat and cat")

D. replace("cat", "dog", "cat and cat")

Solution

1. Step 1: Identify function for replacing all occurrences

   gsub() replaces all matches, while sub() replaces only the first.

2. Step 2: Check syntax correctness

   gsub(pattern, replacement, string) is the correct order and usage in R.

3. Final Answer:

   gsub("cat", "dog", "cat and cat") -> Option C

4. Quick Check:

   Replace all = gsub() [OK]

Hint: Use gsub() to replace all matches, sub() only first [OK]

Common Mistakes:

• Using sub() when all occurrences need replacement
• Using non-existent replace() function in base R
• Confusing argument order in functions

3. What is the output of the following R code?

text <- c("apple", "banana", "apricot", "berry")
matches <- grepl("^a", text)
matches

medium

A. [FALSE, TRUE, FALSE, TRUE]

B. [FALSE, FALSE, FALSE, FALSE]

C. [TRUE, TRUE, TRUE, TRUE]

D. [TRUE, FALSE, TRUE, FALSE]

Solution

1. Step 1: Understand the pattern "^a"

   The caret (^) means the string must start with 'a'. So strings starting with 'a' match.

2. Step 2: Check each string in text

   "apple" and "apricot" start with 'a' (TRUE), "banana" and "berry" do not (FALSE).

3. Final Answer:

   [TRUE, FALSE, TRUE, FALSE] -> Option D

4. Quick Check:

   ^a matches start with 'a' = [TRUE, FALSE, TRUE, FALSE] [OK]

Hint: ^ means start of string; check which words start with 'a' [OK]

Common Mistakes:

• Ignoring ^ and matching 'a' anywhere
• Confusing TRUE/FALSE order in output
• Assuming grepl returns matched strings instead of logical

4. The following R code is intended to replace the first digit in a string with "#" but does not work as expected:

text <- "abc123"
result <- sub("[0-9]", "#", text)
print(result)

What is the problem and how to fix it?

medium

A. Pattern should be "\\d" instead of "[0-9]" for digits in R regex.

B. No problem; code works correctly and replaces first digit.

C. Use gsub() instead of sub() to replace all digits, not just first.

D. The replacement string "#" must be escaped as "\\#".

Solution

1. Step 1: Check the pattern and function

   [0-9] matches any digit; sub() replaces the first match only.

2. Step 2: Verify the output

   Replacing first digit '1' with '#' in "abc123" results in "abc#23", which is expected.

3. Final Answer:

   No problem; code works correctly and replaces first digit. -> Option B

4. Quick Check:

   sub() replaces first digit correctly [OK]

Hint: sub() replaces first match; [0-9] matches digits [OK]

Common Mistakes:

• Thinking [0-9] is invalid in R regex
• Confusing sub() with gsub() for all replacements
• Believing replacement '#' needs escaping

5. You have a vector of email addresses:

emails <- c("[e-mail]", "admin@sitecom", "[e-mail]")

Which regular expression pattern would correctly identify emails ending with ".com" using grepl()?

hard

A. "\\.com$"

B. ".com"

C. "com$"

D. "\\.com"

Solution

1. Step 1: Understand the pattern requirements

   We want to match emails ending exactly with ".com". The dot must be escaped as "\\." to match a literal dot, and "$" means end of string.

2. Step 2: Analyze each option

   "\\.com$" uses "\\.com$" which matches '.com' at the end. ".com" matches any character before 'com', not necessarily end. "com$" misses the dot. "\\.com" matches '.com' anywhere, not necessarily at end.

3. Final Answer:

   "\\.com$" -> Option A

4. Quick Check:

   Escape dot and use $ for end match [OK]

Hint: Escape dot with \\. and use $ to match string end [OK]

Common Mistakes:

• Not escaping dot, so matches any character
• Missing $ causing partial matches
• Confusing string end anchor with start anchor