Predicate methods (ending with ?) in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using a predicate method?

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

Ruby

def even_or_odd?(num)
  num.even?
end

puts even_or_odd?(7)

A 7

B true

C false

D nil

💡 Hint

Remember, the method checks if the number is even.

The method calls num.even? which returns true if num is even, false otherwise. Since 7 is odd, it returns false.

❓ Predict Output

intermediate

What does this predicate method return?

What will be the output of this Ruby code?

Ruby

class String
  def has_vowels?
    !!(self =~ /[aeiou]/i)
  end
end

puts "sky".has_vowels?

A true

B false

C nil

D 0

💡 Hint

Check if the string contains any vowels.

The method returns true if the string contains vowels, false otherwise. "sky" has no vowels, so it returns false.

🔧 Debug

advanced

Why does this predicate method raise an error?

This Ruby code raises an error. What is the cause?

Ruby

def positive?(num)
  num > 0 ? true : false
end

puts positive?(nil)

A NoMethodError because nil can't be compared with >

B SyntaxError due to missing colon in ternary

C Returns false because nil is not positive

D Returns true because nil is treated as zero

💡 Hint

Think about what happens when you compare nil with a number.

The expression num > 0 fails because nil does not support comparison with >, causing a NoMethodError.

🧠 Conceptual

advanced

What is the purpose of predicate methods ending with '?' in Ruby?

Why do Ruby methods often end with a question mark '?'? Choose the best explanation.

A They indicate the method modifies the object

B They are used only for methods that ask user input

C They are private methods by convention

D They always return a boolean value indicating true or false

💡 Hint

Think about what the '?' symbol suggests in English.

In Ruby, methods ending with '?' are predicate methods that return true or false, indicating a yes/no question about the object.

❓ Predict Output

expert

What is the output of this complex predicate method?

Analyze the code and determine what it prints.

Ruby

class Array
  def all_even?
    all?(&:even?)
  end
end

arr = [2, 4, 6, 7]
puts arr.all_even?

A false

B NoMethodError

C nil

D true

💡 Hint

Check if every element in the array is even.

The method all_even? returns true only if all elements are even. Since 7 is odd, it returns false.

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