Regex literal syntax (/pattern/) in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a regex that matches the word 'cat'.

Ruby

pattern = /[1]/

Drag options to blanks, or click blank then click option'

Acat

Bdog

Cbat

Drat

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different word inside the slashes.

Forgetting the slashes around the pattern.

The regex literal /cat/ matches the exact string 'cat'.

2fill in blank

medium

Complete the code to check if the string 'hello' contains the letter 'e'.

Ruby

if 'hello' =~ /[1]/
  puts 'Found e'
end

Drag options to blanks, or click blank then click option'

Aa

Bo

Ci

De

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a letter not present in the string.

Using quotes inside the regex slashes.

The regex /e/ matches the letter 'e' in the string 'hello'.

3fill in blank

hard

Fix the error in the regex literal to match any digit.

Ruby

pattern = /[1]/

Drag options to blanks, or click blank then click option'

A[d]

Bd

C\d

D(d)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'd' without backslash matches the letter 'd', not digits.

Using square brackets or parentheses incorrectly.

The regex /\d/ matches any digit character. The backslash must be escaped in Ruby regex literals.

4fill in blank

hard

Fill both blanks to create a regex that matches a word starting with 'a' and ending with 'z'.

Ruby

pattern = /[1].*[2]/

Drag options to blanks, or click blank then click option'

A^a

Ba

Cz$

D$z

Attempts:

3 left

💡 Hint

Common Mistakes

Placing anchors in the wrong order.

Using '$z' instead of 'z$'.

The regex /^a.*z$/ matches strings starting with 'a' and ending with 'z'.

5fill in blank

hard

Fill all three blanks to create a regex that matches a string with exactly three digits.

Ruby

pattern = /^[1][2][3]$/

Drag options to blanks, or click blank then click option'

A\d

B[0-9]

C\w

D\s

Attempts:

3 left

💡 Hint

Common Mistakes

Using \w which matches letters and digits.

Using \s which matches whitespace.

The regex /^\d\d\d$/ matches exactly three digits from start to end.

Practice

1. What is the correct way to write a regex literal in Ruby to match the word cat?

easy

A. regex('cat')

B. "cat"

C. 'cat'

D. /cat/

Solution

1. Step 1: Understand regex literal syntax

   In Ruby, regex literals are written between slashes, like /pattern/.

2. Step 2: Identify the correct pattern for 'cat'

   The pattern to match the word 'cat' is simply /cat/.

3. Final Answer:

   /cat/ -> Option D

4. Quick Check:

   Regex literal = /pattern/ [OK]

Hint: Regex literals always use slashes /pattern/ in Ruby [OK]

Common Mistakes:

• Using quotes instead of slashes
• Calling a non-existent regex() function
• Confusing string and regex syntax

2. Which of the following is the correct regex literal to match the word Dog case-insensitively in Ruby?

easy

A. /Dog/m

B. /Dog/g

C. /Dog/i

D. /Dog/

Solution

1. Step 1: Identify the case-insensitive option

   In Ruby regex, the i option after the slashes makes matching case-insensitive.

2. Step 2: Check the options given

   Only /Dog/i uses the correct i flag for case-insensitive matching.

3. Final Answer:

   /Dog/i -> Option C

4. Quick Check:

   Case-insensitive flag = i [OK]

Hint: Use /pattern/i for case-insensitive regex in Ruby [OK]

Common Mistakes:

• Using g or m flags which mean different things
• Omitting the i flag for case-insensitivity
• Placing flags inside the slashes

3. What will be the output of this Ruby code?

text = "Hello World"
match = text =~ /world/i
puts match

medium

A. nil

B. 6

C. 0

D. Error

Solution

1. Step 1: Understand the =~ operator with regex

   The operator =~ returns the index of the first match or nil if no match.

2. Step 2: Analyze the regex and string

   The regex /world/i matches 'World' ignoring case. In "Hello World", 'World' starts at index 6 (0-based).

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Case-insensitive match index = 6 [OK]

Hint: =~ returns match start index or nil if no match [OK]

Common Mistakes:

• Ignoring case-insensitive flag i
• Thinking output is true/false instead of index
• Assuming match starts at 0 always

4. Identify the error in this Ruby regex literal:

pattern = /hello/i/

medium

A. Extra slash at the end causes syntax error

B. Missing quotes around pattern

C. Missing i flag for case-insensitivity

D. Regex literals cannot have flags

Solution

1. Step 1: Check regex literal syntax

   A regex literal starts and ends with a single slash. Here, there is an extra slash at the end.

2. Step 2: Identify the syntax error

   The extra slash after /hello/i is invalid and causes a syntax error.

3. Final Answer:

   Extra slash at the end causes syntax error -> Option A

4. Quick Check:

   Regex literal must start and end with one slash pair [OK]

Hint: Regex literals have exactly two slashes, no extras [OK]

Common Mistakes:

• Adding extra slash after regex
• Confusing regex with string quotes
• Thinking flags go inside slashes

5. You want to find all words starting with a or A in a string using a regex literal. Which regex literal correctly matches this requirement?

hard

A. /\b[a]\w*/i

B. /\b[A]\w*/

C. /\b[a]\w*/

D. /\b[a-z]\w*/i

Solution

1. Step 1: Understand the requirement

   We want words starting with 'a' or 'A'. Using case-insensitive flag i simplifies matching both.

2. Step 2: Analyze options

   /\b[a]\w*/i uses /\b[a]\w*/i which matches word boundary, then 'a' (case-insensitive), then zero or more word chars. This matches words starting with 'a' or 'A'.

3. Final Answer:

   /\b[a]\w*/i -> Option A

4. Quick Check:

   Use i flag to match both 'a' and 'A' easily [OK]

Hint: Use /pattern/i to match letters ignoring case [OK]

Common Mistakes:

• Listing both 'a' and 'A' inside brackets without i flag
• Using wrong character classes
• Missing word boundary \b