Capture groups in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to capture the word 'cat' from the string.

Ruby

text = "The cat sat on the mat."
match = text.match(/[1]/)
puts match[0]

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

Adog

Bcat

Cmat

Dsat

Attempts:

3 left

💡 Hint

Common Mistakes

Using a word not present in the string.

Forgetting to put the pattern inside slashes.

The regular expression /cat/ matches the substring 'cat' in the text.

2fill in blank

medium

Complete the code to capture the first word using a capture group.

Ruby

text = "Hello world"
match = text.match(/(\w+)[1]/)
puts match[1]

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

A\s

B\d

C\W

D\S

Attempts:

3 left

💡 Hint

Common Mistakes

Using \d which matches digits instead of whitespace.

Using \W which matches non-word characters.

The pattern /(\w+)\s/ captures one or more word characters followed by a whitespace.

3fill in blank

hard

Fix the error in the code to correctly capture the domain from the email.

Ruby

email = "[e-mail]"
domain = email.match(/@(\w+[1]\w+)/)[1]
puts domain

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

A\d

B\s

C\W

D\.

Attempts:

3 left

💡 Hint

Common Mistakes

Not escaping the dot, causing it to match any character.

Using \s which matches whitespace instead of a dot.

The pattern /@(\w+\.\w+)/ captures the domain part after '@', including the dot.

4fill in blank

hard

Fill both blanks to capture the area code and the phone number separately.

Ruby

phone = "[phone]"
match = phone.match(/\(([1])\) ([2])-\d{4}/)
puts match[1]
puts match[2]

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

A\d{3}

B\w+

D\s

Attempts:

3 left

💡 Hint

Common Mistakes

Using \w+ which matches letters and digits, not just digits.

Forgetting to match the space between parts.

The pattern captures three digits inside parentheses as the area code and three digits after the space as the phone number part.

5fill in blank

hard

Fill all three blanks to create a hash with keys as captured words and values as their lengths.

Ruby

text = "red blue green"
result = text.scan(/(\w+) (\w+) (\w+)/).map do |[1], [2], [3]|
  { [1] => [1].length, [2] => [2].length, [3] => [3].length }
end
puts result

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

Aa

Bb

Cc

Dx

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same variable name for all three captures.

Not matching the block parameters with the capture groups.

The block variables a, b, c capture the three words, which are then used as keys with their lengths as values.

Practice

1. What does a capture group do in a Ruby regular expression like /(\d{3})-(\d{2})/?

easy

A. It repeats the pattern multiple times.

B. It saves parts of the matched text for later use.

C. It matches only digits without saving.

D. It ignores the matched text.

Solution

1. Step 1: Understand capture groups in regex

   Capture groups are parts of a pattern enclosed in parentheses that save matched text.

2. Step 2: Analyze the example pattern

   The pattern /(\d{3})-(\d{2})/ has two capture groups for three digits and two digits separated by a dash.

3. Final Answer:

   It saves parts of the matched text for later use. -> Option B

4. Quick Check:

   Capture groups = save matched parts [OK]

Hint: Parentheses in regex save matched text as groups [OK]

Common Mistakes:

• Thinking capture groups repeat patterns
• Confusing capture groups with non-capturing groups
• Believing capture groups ignore matched text

2. Which of the following is the correct syntax to create a capture group in a Ruby regex?

easy

A. /(abc)/

B. /[abc]/

C. /{abc}/

D. /abc/

Solution

1. Step 1: Identify capture group syntax

   Capture groups in Ruby regex are created by enclosing the pattern in parentheses ().

2. Step 2: Compare options

   /(abc)/ uses parentheses correctly. /[abc]/ uses square brackets which match any one character. /{abc}/ uses curly braces which are quantifiers. /abc/ has no capture group.

3. Final Answer:

   /(abc)/ -> Option A

4. Quick Check:

   Parentheses = capture group [OK]

Hint: Use parentheses () for capture groups in regex [OK]

Common Mistakes:

• Using square brackets [] instead of parentheses
• Using curly braces {} incorrectly
• Forgetting parentheses for capture groups

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

text = "Order 123-45"
match = text.match(/(\d{3})-(\d{2})/)
[match[0], match[1], match[2]]

medium

A. ["123-45", "45", "123"]

B. ["12345", "123", "45"]

C. ["Order 123-45", "123", "45"]

D. ["123-45", "123", "45"]

Solution

1. Step 1: Understand match and capture groups

   The match method returns a MatchData object. match[0] is the full matched string, match[1] and match[2] are the first and second capture groups.

2. Step 2: Apply to given string and pattern

   The pattern matches "123-45" in the text. The first group captures "123", the second "45".

3. Final Answer:

   ["123-45", "123", "45"] -> Option D

4. Quick Check:

   Full match + groups = ["123-45", "123", "45"] [OK]

Hint: match[0] full, match[1..] capture groups [OK]

Common Mistakes:

• Confusing full match with capture groups
• Swapping capture group order
• Ignoring the dash in the match

4. What is wrong with this Ruby code snippet?

text = "abc123"
match = text.match(/(\d{3})/)
puts match[1]

medium

A. It prints "123" correctly.

B. It raises an error because there is no match.

C. It prints nil without error.

D. It raises a syntax error.

Solution

1. Step 1: Check the regex and string

   The regex /(\d{3})/ looks for exactly three digits. The string "abc123" contains "123" which matches.

2. Step 2: Understand match and output

   The match object captures "123" in group 1. puts match[1] prints "123".

3. Final Answer:

   It prints "123" correctly. -> Option A

4. Quick Check:

   Digits found and printed = "123" [OK]

Hint: Check if regex matches before accessing groups [OK]

Common Mistakes:

• Assuming no match causes error
• Expecting nil instead of matched string
• Confusing syntax error with runtime error

5. Given a string of dates like "2023-04-01, 2024-12-31", which Ruby code correctly extracts all year parts using capture groups?

hard

A. dates.scan(/\d{4}-\d{2}-\d{2}/)

B. dates.match(/(\d{4})-\d{2}-\d{2}/)

C. dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten

D. dates.match(/\d{4}/)

Solution

1. Step 1: Understand the goal and methods

   We want all years from multiple dates. scan finds all matches, match finds only first.

2. Step 2: Analyze each option

   dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten uses scan with a capture group for year, returning all years as array. dates.match(/(\d{4})-\d{2}-\d{2}/) uses match which returns only first match. dates.scan(/\d{4}-\d{2}-\d{2}/) uses scan but no capture group, returns full dates. dates.match(/\d{4}/) uses match without capture group, only first year.

3. Final Answer:

   dates.scan(/(\d{4})-\d{2}-\d{2}/).flatten -> Option C

4. Quick Check:

   scan + capture group = all years [OK]

Hint: Use scan with capture groups to get all matches [OK]

Common Mistakes:

• Using match instead of scan for multiple matches
• Not using capture groups to extract parts
• Forgetting to flatten nested arrays from scan