Why regex is powerful in Ruby - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby regex code?

Look at this Ruby code using regex. What will it print?

Ruby

text = "Hello Ruby 2024!"
match = text.match(/Ruby (\d{4})/)
puts match[1]

A 2024

B Ruby 2024

C Hello

D nil

💡 Hint

Remember, parentheses in regex capture groups. What does match[1] return?

The regex /Ruby (\d{4})/ looks for 'Ruby ' followed by exactly 4 digits. The parentheses capture those digits. match[1] returns the first captured group, which is '2024'.

🧠 Conceptual

intermediate

Why is regex powerful in Ruby for text processing?

Choose the best reason why regex is powerful in Ruby.

A Ruby requires external libraries to use regex.

B Regex in Ruby only works with strings longer than 10 characters.

C Ruby integrates regex directly into its syntax with easy methods like <code>=~</code> and <code>match</code>.

D Ruby does not support regex backreferences.

💡 Hint

Think about how Ruby lets you use regex without extra setup.

Ruby has built-in regex support with special syntax and methods, making it easy and powerful for text matching and extraction.

🔧 Debug

advanced

What error does this Ruby regex code raise?

Find the error when running this Ruby code:

Ruby

pattern = /\d{3}-\d{2}-\d{4}/
text = "My number is 123-45-6789"
match = text.match(pattern)
puts match[5]

A SyntaxError

B IndexError

C TypeError

D NoMethodError

💡 Hint

Check what match[5] means if the regex has fewer capture groups.

The regex has no capture groups, so match[5] tries to access a non-existent group index, causing an IndexError.

📝 Syntax

advanced

Which option correctly uses regex to find all words starting with 'a' in Ruby?

Choose the Ruby code that correctly finds all words starting with 'a' in a string.

A text.scan(/\w*a\b/)

B text.scan(/a\w*\b/)

C text.scan(/\b\w*a/)

D text.scan(/\ba\w*/)

💡 Hint

Remember, \b means word boundary and \w* means zero or more word characters.

Option D matches a word boundary, then 'a', then zero or more word characters, correctly capturing words starting with 'a'.

🚀 Application

expert

What is the value of 'result' after running this Ruby code?

This Ruby code uses regex with named capture groups. What is the value of result?

Ruby

text = "User: alice, ID: 42"
pattern = /User: (?<name>\w+), ID: (?<id>\d+)/
match = text.match(pattern)
result = {user: match[:name], id: match[:id].to_i}

A {user: "alice", id: 42}

B {:user=>"alice", :id=>42}

C {user: "alice", id: "42"}

D {"user"=>"alice", "id"=>42}

💡 Hint

Look at how the hash keys and values are created and the use of to_i.

The code creates a Ruby hash with symbol keys :user and :id. The id value is converted to an integer with to_i. So the result is {user: "alice", id: 42}.

Practice

1. Why is regex considered powerful in Ruby?

easy

A. It cannot be combined with other Ruby methods.

B. It only works with numbers, not text.

C. It requires complex syntax to use.

D. It can quickly find and manipulate text patterns.

Solution

1. Step 1: Understand regex purpose in Ruby

   Regex is used to find patterns in text efficiently.

2. Step 2: Recognize Ruby's regex flexibility

   Ruby allows easy pattern matching and text manipulation using regex.

3. Final Answer:

   It can quickly find and manipulate text patterns. -> Option D

4. Quick Check:

   Regex power = quick text pattern handling [OK]

Hint: Regex helps find text patterns fast in Ruby [OK]

Common Mistakes:

• Thinking regex only works with numbers
• Believing regex syntax is always complex
• Assuming regex can't be combined with Ruby methods

2. Which of the following is the correct way to write a regex literal in Ruby?

easy

A. /pattern/

B. 'pattern'

C. {pattern}

D. (pattern)

Solution

1. Step 1: Identify Ruby regex syntax

   Ruby uses slashes / / to define regex literals.

2. Step 2: Compare options

   Only /pattern/ matches Ruby regex literal syntax.

3. Final Answer:

   /pattern/ -> Option A

4. Quick Check:

   Regex literal = /pattern/ [OK]

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

Common Mistakes:

• Using quotes instead of slashes
• Using braces or parentheses for regex
• Confusing regex with string syntax

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

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

medium

A. hello

B. 123

C. nil

D. error

Solution

1. Step 1: Understand the regex /\d+/

   This regex matches one or more digits in the string.

2. Step 2: Apply regex to text "hello123"

   The digits "123" match the pattern and are captured.

3. Final Answer:

   123 -> Option B

4. Quick Check:

   Digits found = 123 [OK]

Hint: \d+ matches digits; here it finds '123' [OK]

Common Mistakes:

• Expecting 'hello' as output
• Thinking match returns nil if partial match exists
• Confusing match object with string

4. Find the error in this Ruby code using regex:

text = "abc123"
if text =~ /\d+/
  puts "Digits found"
else
  puts "No digits"
end

medium

A. The regex syntax is incorrect

B. The =~ operator is used wrongly

C. No error; code works as expected

D. Missing parentheses in if condition

Solution

1. Step 1: Check regex syntax

   The regex /\d+/ correctly matches digits.

2. Step 2: Verify use of =~ operator

   The =~ operator checks if regex matches the string; usage is correct.

3. Final Answer:

   No error; code works as expected -> Option C

4. Quick Check:

   Regex and operator usage = correct [OK]

Hint: =~ checks regex match; no parentheses needed [OK]

Common Mistakes:

• Thinking =~ is invalid operator
• Expecting parentheses required in if
• Assuming regex syntax is wrong

5. How can you use regex in Ruby to replace all vowels in a string with '*'?

hard

A. string.gsub(/[aeiou]/i, '*')

B. string.replace(/[aeiou]/, '*')

C. string.sub(/[aeiou]/, '*')

D. string.match(/[aeiou]/).replace('*')

Solution

1. Step 1: Identify method to replace all matches

   gsub replaces all occurrences matching regex in the string.

2. Step 2: Use regex for vowels with case-insensitive flag

   /[aeiou]/i matches all vowels regardless of case.

3. Step 3: Combine to replace vowels with '*'

   string.gsub(/[aeiou]/i, '*') replaces all vowels with '*'.

4. Final Answer:

   string.gsub(/[aeiou]/i, '*') -> Option A

5. Quick Check:

   Replace vowels = gsub with /[aeiou]/i [OK]

Hint: Use gsub with /[aeiou]/i to replace all vowels [OK]

Common Mistakes:

• Using sub replaces only first match
• Using replace method incorrectly
• Trying to call replace on match object