Match method and MatchData in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Match method with capture groups

What is the output of this Ruby code?

Ruby

result = /Hello (\w+)/.match("Hello World")
puts result[1]

A nil

B Hello

C World

D Error

💡 Hint

Remember that the first capture group is accessed with index 1.

The regex captures the word after 'Hello '. The match method returns a MatchData object. Accessing result[1] returns the first captured group, which is 'World'.

❓ Predict Output

intermediate

MatchData object methods

What does this Ruby code print?

Ruby

m = /(\d+)-(\d+)/.match("123-456")
puts m.begin(1)

A 0

B 4

C 3

D Error

💡 Hint

begin(n) returns the start index of the nth capture group.

The first capture group (\d+) matches '123' starting at index 0. The second capture group matches '456' starting at index 4. So m.begin(1) returns 0, m.begin(2) returns 4. The code prints 0.

❓ Predict Output

advanced

Using MatchData to extract named captures

What is the output of this Ruby code?

Ruby

pattern = /(?<area>\d{3})-(?<number>\d{4})/
match = pattern.match("555-1234")
puts match[:area]

A 1234

B 555

C area

D nil

💡 Hint

Named captures can be accessed with symbols.

The regex defines named groups 'area' and 'number'. Accessing match[:area] returns the string matched by the 'area' group, which is '555'.

❓ Predict Output

advanced

Match method returns nil when no match

What is the output of this Ruby code?

Ruby

result = /cat/.match("dog")
puts result.nil?

A true

B nil

C false

D Error

💡 Hint

If the pattern does not match, match returns nil.

The string 'dog' does not contain 'cat', so match returns nil. puts result.nil? prints true.

🧠 Conceptual

expert

Understanding MatchData captures and indexing

Given the Ruby code below, what is the value of match[0], match[1], and match[2] respectively?

Ruby

match = /(\w+)-(\d+)/.match("code-123")

A "code", "code-123", "123"

B "code", "-", "123"

C "code-123", "-", "123"

D "code-123", "code", "123"

💡 Hint

match[0] is the entire matched string; match[1] and match[2] are capture groups.

match[0] returns the full matched string 'code-123'. match[1] returns the first capture group '\w+' which is 'code'. match[2] returns the second capture group '\d+' which is '123'.

Practice

1. What does the Ruby match method return when it finds a pattern in a string?

easy

A. A MatchData object containing details of the match

B. The matched substring as a string

C. An array of all matched substrings

D. A boolean value true

Solution

1. Step 1: Understand the purpose of match

   The match method searches a string for a pattern and returns information about the match.

2. Step 2: Identify the return type when a match is found

   It returns a MatchData object, which holds details like matched text and position.

3. Final Answer:

   A MatchData object containing details of the match -> Option A

4. Quick Check:

   match returns MatchData [OK]

Hint: Remember: match returns MatchData, not just string [OK]

Common Mistakes:

• Thinking it returns just the matched string
• Assuming it returns an array of matches
• Believing it returns true/false

2. Which of the following is the correct syntax to use the match method on a string str to find the pattern /abc/?

easy

A. /abc/.match(str)

B. match(str, /abc/)

C. str.match(/abc/)

D. str.match = /abc/

Solution

1. Step 1: Recall the method call format

   The match method is called on a string object with a regex pattern as argument.

2. Step 2: Check each option's syntax

   str.match(/abc/) correctly calls str.match(/abc/). match(str, /abc/) is invalid syntax. /abc/.match(str) reverses receiver and argument. str.match = /abc/ tries assignment, which is wrong.

3. Final Answer:

   str.match(/abc/) -> Option C

4. Quick Check:

   Correct method call = str.match(/abc/) [OK]

Hint: Call match on string with regex inside parentheses [OK]

Common Mistakes:

• Using match as a standalone function
• Swapping receiver and argument
• Trying to assign with =

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

result = "hello123".match(/\d+/)
puts result[0]

medium

A. 123

B. hello

C. nil

D. An error is raised

Solution

1. Step 1: Understand the regex pattern

   The pattern /\d+/ matches one or more digits in the string.

2. Step 2: Analyze the match and output

   In "hello123", digits "123" match. result[0] accesses the matched substring "123".

3. Final Answer:

   123 -> Option A

4. Quick Check:

   Digits matched = "123" [OK]

Hint: Access matched text with result[0] after match [OK]

Common Mistakes:

• Expecting the whole string as output
• Confusing nil with empty string
• Not using index 0 to get matched text

4. Consider this Ruby code snippet:

text = "abc"
match = text.match(/d/)
puts match[0]

What is the problem here?

medium

A. The regex pattern is invalid

B. Trying to access match[0] when match is nil

C. The string text is empty

D. The match method does not exist for strings

Solution

1. Step 1: Check the regex pattern and string

   The pattern /d/ looks for 'd' in "abc", which is not present, so match returns nil.

2. Step 2: Identify the error cause

   Trying to do match[0] when match is nil causes a NoMethodError.

3. Final Answer:

   Trying to access match[0] when match is nil -> Option B

4. Quick Check:

   Accessing [0] on nil causes error [OK]

Hint: Check if match is nil before accessing [OK]

Common Mistakes:

• Assuming pattern is invalid
• Ignoring that match can be nil
• Thinking match method is missing

5. You want to extract the first word starting with a capital letter from the string "today is a Sunny day" using match. Which code correctly does this and prints the matched word?

hard

A. puts "today is a Sunny day".match(/[A-Z]+/)[0]

B. puts "today is a Sunny day".match(/[a-z]\w*/)[0]

C. puts "today is a Sunny day".match(/\b\w+/)[0]

D. puts "today is a Sunny day".match(/[A-Z]\w*/)[0]

Solution

1. Step 1: Understand the regex requirements

   We want the first word starting with a capital letter. Pattern /[A-Z]\w*/ matches a capital letter followed by zero or more word characters.

2. Step 2: Analyze each option

   puts "today is a Sunny day".match(/[A-Z]\w*/)[0] matches correctly and returns the first capitalized word "Sunny". puts "today is a Sunny day".match(/[a-z]\w*/)[0] matches lowercase start, first is "today", wrong. puts "today is a Sunny day".match(/\b\w+/)[0] matches any word, first is "today", not capitalized. puts "today is a Sunny day".match(/[A-Z]+/)[0] matches only consecutive capital letters, first is "S", not full word.

3. Final Answer:

   puts "today is a Sunny day".match(/[A-Z]\w*/)[0] -> Option D

4. Quick Check:

   Capitalized word match = puts "today is a Sunny day".match(/[A-Z]\w*/)[0] [OK]

Hint: Use regex starting with [A-Z] and access [0] from match [OK]

Common Mistakes:

• Using lowercase letter class instead of uppercase
• Matching only letters without full word
• Not accessing matched text with [0]