Predicate methods (ending with ?) in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the number is even using a predicate method.

Ruby

number = 4
puts number.[1]

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

Apositive?

Bodd?

Ceven?

Dzero?

Attempts:

3 left

💡 Hint

Common Mistakes

Using odd? instead of even?

Forgetting the question mark at the end of the method

The even? method returns true if the number is even.

2fill in blank

medium

Complete the code to check if the string is empty using a predicate method.

Ruby

text = ""
puts text.[1]

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

Aempty?

Bblank?

Cnil?

Dzero?

Attempts:

3 left

💡 Hint

Common Mistakes

Using nil? which checks for nil, not empty string

Using blank? which is not a standard Ruby method

The empty? method returns true if the string has no characters.

3fill in blank

hard

Fix the error in the code to check if the array includes the number 5 using a predicate method.

Ruby

numbers = [1, 2, 3, 4, 5]
puts numbers.[1](5)

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

Ainclude

Bcontains?

Cincludes?

Dinclude?

Attempts:

3 left

💡 Hint

Common Mistakes

Using include without the question mark

Using non-existent methods like includes? or contains?

The correct predicate method to check if an array contains an element is include?.

4fill in blank

hard

Fill both blanks to create a hash with keys as words and values as booleans indicating if the word starts with 'a'.

Ruby

words = ["apple", "banana", "avocado"]
result = words.map { |word| [word, word.[1]('a') && word.[2]('a')] }.to_h
puts result

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

Astart_with?

Binclude?

Attempts:

3 left

💡 Hint

Common Mistakes

Using include? which checks anywhere in the string, not just the start

Mixing different methods in the two blanks

The start_with? method checks if a string begins with the given prefix.

5fill in blank

hard

Fill the blanks to filter an array of strings to only those that end with 'ing' and check if each is lowercase.

Ruby

words = ["running", "Jumping", "walking", "Talk"]
filtered = words.select { |word| word.[1]('ing') }
result = filtered.map { |word| word.[2] == word }
puts result

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

Aend_with?

Bdowncase

Cdowncase == word

Ddowncase?

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent method downcase?

Not comparing downcase result to the original word

end_with? checks if the string ends with 'ing'. Then word.downcase == word checks if the word is already lowercase.

Practice

1. What does a predicate method in Ruby always return?

easy

A. A string value

B. A boolean value (true or false)

C. An integer value

D. An array

Solution

1. Step 1: Understand predicate method purpose

   Predicate methods in Ruby are designed to answer yes/no questions about an object or data.

2. Step 2: Identify return type of predicate methods

   They always return true or false, which are boolean values.

3. Final Answer:

   A boolean value (true or false) -> Option B

4. Quick Check:

   Predicate methods return true/false [OK]

Hint: Predicate methods always answer yes/no questions [OK]

Common Mistakes:

• Thinking predicate methods return strings or numbers
• Confusing predicate methods with regular methods
• Ignoring the question mark at the end

2. Which of the following is the correct way to define a predicate method in Ruby?

easy

A. def valid?; true; end

B. def valid; true; end

C. def valid!; true; end

D. def valid: true; end

Solution

1. Step 1: Recognize predicate method naming

   Predicate methods must end with a question mark (?).

2. Step 2: Check method syntax

   def valid?; true; end defines a method named valid? correctly with def and end keywords.

3. Final Answer:

   def valid?; true; end -> Option A

4. Quick Check:

   Method name ends with ? and syntax is correct [OK]

Hint: Predicate methods end with ? and use def ... end [OK]

Common Mistakes:

• Omitting the question mark in method name
• Using invalid method name characters like ! or :
• Incorrect method definition syntax

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

def empty_string?(str)
  str.empty?
end

puts empty_string?("")
puts empty_string?("hello")

medium

A. false\ntrue

B. true\ntrue

C. true\nfalse

D. false\nfalse

Solution

1. Step 1: Understand the method behavior

   The method empty_string? calls str.empty? which returns true if str is an empty string.

2. Step 2: Evaluate the calls

   empty_string?("") returns true because "" is empty; empty_string?("hello") returns false because "hello" is not empty.

3. Final Answer:

   true\nfalse -> Option C

4. Quick Check:

   Empty string check returns true, non-empty returns false [OK]

Hint: empty? returns true only for empty strings [OK]

Common Mistakes:

• Assuming non-empty strings return true
• Confusing empty? with nil? method
• Ignoring the question mark in method names

4. Identify the error in this Ruby code:

def positive?(num)
  if num > 0
    true
  else
    false
  end
end

puts positive?("5")

medium

A. ArgumentError because "5" is a string, not a number

B. SyntaxError due to missing end

C. No error, outputs true

D. Returns nil instead of true/false

Solution

1. Step 1: Analyze method input and comparison

   The method compares num > 0, but "5" is a string, not a number.

2. Step 2: Understand Ruby type comparison

   Comparing string "5" with integer 0 causes an ArgumentError at runtime.

3. Final Answer:

   ArgumentError because "5" is a string, not a number -> Option A

4. Quick Check:

   Comparing string and integer causes ArgumentError [OK]

Hint: Check input types before numeric comparisons [OK]

Common Mistakes:

• Passing strings instead of numbers
• Assuming no error on mixed type comparisons
• Missing end keyword (not the case here)

5. You want to create a predicate method valid_name? that returns true only if a string is not empty and contains only letters. Which implementation is correct?

hard

A. def valid_name?(name)
name.nil? && name.match?(/[a-z]/)
end

B. def valid_name?(name)
name.empty? || name.match?(/\d+/)
end

C. def valid_name?(name)
name.length > 0 && name.include?(' ')
end

D. def valid_name?(name)
!name.empty? && name.match?(/^[a-zA-Z]+$/)
end

Solution

1. Step 1: Understand the requirements

   The method must return true only if the string is not empty and contains only letters.

2. Step 2: Evaluate each option

   def valid_name?(name) !name.empty? && name.match?(/^[a-zA-Z]+$/) end checks that name is not empty and matches only letters using regex /^[a-zA-Z]+$/. This meets the requirements.

3. Final Answer:

   def valid_name?(name) !name.empty? && name.match?(/^[a-zA-Z]+$/) end -> Option D

4. Quick Check:

   Not empty and only letters = valid_name? true [OK]

Hint: Use regex and empty? to validate strings in predicates [OK]

Common Mistakes:

• Using || instead of && for conditions
• Checking for digits instead of letters
• Ignoring empty string check