Match operator (=~) in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using =~?

Consider the following Ruby code snippet. What will it print?

Ruby

text = "hello world"
pattern = /world/
puts text =~ pattern

A nil

B true

C 6

D false

💡 Hint

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

The string "hello world" contains "world" starting at index 6, so text =~ /world/ returns 6.

❓ Predict Output

intermediate

What does this =~ expression return when no match?

What is the output of this Ruby code?

Ruby

text = "goodbye"
pattern = /hello/
puts text =~ pattern

A 0

B -1

C false

D nil

💡 Hint

If the pattern is not found, =~ returns nil.

Since "hello" is not in "goodbye", text =~ /hello/ returns nil.

🔧 Debug

advanced

Why does this =~ expression cause an error?

Look at this Ruby code. Why does it raise an error?

Ruby

text = nil
pattern = /test/
puts text =~ pattern

A NoMethodError because nil does not support =~

B SyntaxError due to missing quotes

C Returns nil because no match

D Returns false because nil is falsey

💡 Hint

Only strings or objects that implement =~ can use it.

Calling =~ on nil causes NoMethodError since nil does not have this method.

🧠 Conceptual

advanced

What is the value of 'index' after this code runs?

Given this Ruby code, what is the value of the variable index?

Ruby

index = "abracadabra" =~ /cad/

A 4

B nil

C 3

D 0

💡 Hint

Count characters starting at 0 to find where "cad" starts.

"abracadabra" has "cad" starting at index 4, so index is 4.

❓ Predict Output

expert

What is the output of this complex =~ usage?

What does this Ruby code print?

Ruby

text = "123abc456"
pattern = /\d{3}(?<letters>[a-z]{3})\d{3}/
match_pos = text =~ pattern
letters = $~[:letters]
puts "Position: #{match_pos}, Letters: #{letters}"

A Position: nil, Letters: abc

B Position: 0, Letters: abc

C Position: 0, Letters: nil

D Position: 3, Letters: abc

💡 Hint

The =~ operator sets the global match variable $~ with named captures.

The pattern matches starting at index 0. The named group 'letters' captures "abc". So output is "Position: 0, Letters: abc".

Practice

1. What does the Ruby operator =~ do when used like string =~ /pattern/?

easy

A. Splits the string into an array based on the pattern

B. Returns true if the pattern is found, false otherwise

C. Replaces the pattern in the string with another string

D. Returns the index where the pattern starts in the string or nil if not found

Solution

1. Step 1: Understand the operator's purpose

   The =~ operator checks if a regex pattern matches anywhere in the string.

2. Step 2: Know the return value

   It returns the index of the first match or nil if no match is found.

3. Final Answer:

   Returns the index where the pattern starts in the string or nil if not found -> Option D

4. Quick Check:

   =~ returns index or nil [OK]

Hint: Remember: =~ returns index or nil, not true/false [OK]

Common Mistakes:

• Thinking it returns true or false
• Confusing it with string replacement
• Assuming it splits the string

2. Which of the following is the correct syntax to check if the string "hello123" contains digits using the match operator?

easy

A. "hello123" =~ /\d+/

B. "hello123" =~ "\d+"

C. "hello123" =~ /\w+/

D. "hello123" =~ /[a-z]+/i

Solution

1. Step 1: Identify correct regex syntax

   The pattern to match digits is /\d+/, which is a regex literal in Ruby.

2. Step 2: Match operator requires regex, not string

   The =~ operator expects a regex on the right side, so /\d+/ is correct, not a string.

3. Final Answer:

   "hello123" =~ /\d+/ -> Option A

4. Quick Check:

   Regex literal with =~ is correct [OK]

Hint: Use slashes /pattern/ for regex with =~ operator [OK]

Common Mistakes:

• Using a string instead of regex on right side
• Confusing \d with \w for digits
• Missing regex delimiters

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

text = "OpenAI GPT-4"
index = text =~ /GPT/
puts index

medium

A. nil

B. 0

C. 7

D. SyntaxError

Solution

1. Step 1: Locate the pattern in the string

   The string is "OpenAI GPT-4". The substring "GPT" starts at index 7 (counting from 0).

2. Step 2: Understand what =~ returns

   The operator returns the index of the first match, so it returns 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Index of "GPT" in string = 7 [OK]

Hint: Count characters from zero to find match index [OK]

Common Mistakes:

• Counting from 1 instead of 0
• Expecting true/false instead of index
• Assuming nil if unsure

4. Identify the error in this Ruby code snippet:

str = "test123"
result = str =~ "\d+"
puts result

medium

A. Using a string instead of a regex pattern with =~

B. Missing parentheses around =~ operator

C. Incorrect variable name 'str'

D. Using puts instead of print

Solution

1. Step 1: Check the right side of =~ operator

   The code uses a string "\d+" instead of a regex literal /\d+/.

2. Step 2: Understand =~ expects regex

   The match operator requires a regex pattern, so using a string causes a TypeError or unexpected behavior.

3. Final Answer:

   Using a string instead of a regex pattern with =~ -> Option A

4. Quick Check:

   Right side of =~ must be regex [OK]

Hint: Always use /pattern/ regex, not strings, with =~ [OK]

Common Mistakes:

• Using strings instead of regex
• Thinking parentheses are needed
• Confusing puts with print

5. Given the array words = ["cat", "dog", "bird", "cow"], which code snippet uses the match operator to find the first word containing the letter 'i' and returns its index in the array?

hard

A. words.find { |w| w =~ /i/ }

B. words.find_index { |w| w =~ /i/ }

C. words.index { |w| w.include?('i') }

D. words.select { |w| w =~ /i/ }

Solution

1. Step 1: Understand the goal

   We want the index of the first word containing 'i'.

2. Step 2: Use find_index with match operator

   find_index returns the index of the first element where the block is true. Using w =~ /i/ returns index or nil, so truthy means match found.

3. Step 3: Check other options

   words.index { |w| w.include?('i') } uses include? which works but is not using the match operator. words.find { |w| w =~ /i/ } returns the word, not index. words.select { |w| w =~ /i/ } returns all matches, not index.

4. Final Answer:

   words.find_index { |w| w =~ /i/ } -> Option B

5. Quick Check:

   find_index with =~ returns correct index [OK]

Hint: Use find_index with =~ to get index of first match [OK]

Common Mistakes:

• Using find instead of find_index for index
• Using include? instead of =~
• Expecting select to return single index