Match operator (=~) in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the string contains the word 'cat'.

Ruby

result = 'concatenate' =~ /[1]/
puts result

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

Acat

Bdog

Cbat

Drat

Attempts:

3 left

💡 Hint

Common Mistakes

Using a word not present in the string, which returns nil.

The match operator =~ returns the index of the match or nil if no match. Here, 'cat' is found in 'concatenate' starting at index 3.

2fill in blank

medium

Complete the code to check if the string starts with a digit.

Ruby

result = '7eleven' =~ /^[1]/
puts result

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

Aa

B\d

Cz

D7

Attempts:

3 left

💡 Hint

Common Mistakes

Using a literal character instead of a digit pattern.

The regular expression ^\d matches a digit at the start of the string. The match operator returns 0 because the digit '7' is at index 0.

3fill in blank

hard

Fix the error in the code to correctly check if 'hello123' contains digits.

Ruby

result = 'hello123' =~ /[1]/
puts result

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

A[0-9a-z]

B[a-z]

C\d+

D123

Attempts:

3 left

💡 Hint

Common Mistakes

Using a pattern that matches letters instead of digits.

The pattern \d+ matches one or more digits anywhere in the string. The match operator returns the index where digits start.

4fill in blank

hard

Fill both blanks to create a hash with words as keys and their lengths as values, only for words longer than 4 characters.

Ruby

lengths = Hash[words.select { |word| word.length > 4 }.map { |word| [[1], [2]] }]

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

Aword

Bword.length

Cword.size

Dlen(word)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Python's len() function instead of Ruby's length method.

word is used as the key and word.length as the value. The condition filters words longer than 4 characters using select and map with Hash[].

5fill in blank

hard

Fill all three blanks to create a hash with uppercase words as keys, their lengths as values, only if length is greater than 3.

Ruby

result = Hash[words.select { |word| word.[3] > 3 }.map { |word| [[1], [2]] }]

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

Aword.upcase

Bword.length

Clength

Dword.size

Attempts:

3 left

💡 Hint

Common Mistakes

Using Python's len() or incorrect method names.

The keys are uppercase words using word.upcase. Values are word lengths using word.length. The condition uses word.size to check length greater than 3 using Hash[] with select and map.

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