Predicate methods (ending with ?) in Ruby - Mini Project: Build & Apply

Using Predicate Methods Ending with ? in Ruby

📖 Scenario: You are building a simple program to check properties of numbers in a list. You want to find out which numbers are even and which are odd using Ruby's predicate methods.

🎯 Goal: Create a Ruby program that uses predicate methods ending with ? to check if numbers are even or odd, and then prints the results.

📋 What You'll Learn

Create an array called numbers with the exact values: 2, 5, 8, 11, 14

Create a variable called threshold and set it to 10

Use a for loop with variable num to iterate over numbers and inside the loop use the predicate method even? to check if num is even

Inside the loop, also check if num is greater than threshold

Print the number and whether it is even and if it is greater than the threshold in the format: "2 is even and less than or equal to 10" or "11 is odd and greater than 10"

💡 Why This Matters

🌍 Real World

Checking conditions like even or odd numbers is common in programs that handle data filtering, validation, or decision making.

💼 Career

Understanding predicate methods helps you write clear and readable code, which is important for software development jobs that require condition checks and logic.

1

Create the numbers array

Create an array called numbers with these exact values: 2, 5, 8, 11, 14

Ruby

# Create an array called numbers with 2, 5, 8, 11, 14
# Your code here

Hint

Use square brackets [] to create an array and separate numbers with commas.

2

Set the threshold variable

Create a variable called threshold and set it to 10

Ruby

numbers = [2, 5, 8, 11, 14]
# Create a variable called threshold and set it to 10
# Your code here

Hint

Use = to assign the value 10 to the variable threshold.

3

Use a for loop and predicate methods

Use a for loop with variable num to iterate over numbers. Inside the loop, use the predicate method even? on num to check if it is even. Also check if num is greater than threshold.

Ruby

numbers = [2, 5, 8, 11, 14]
threshold = 10
# Use a for loop with num to iterate over numbers
# Inside the loop, use num.even? and compare num with threshold
# Your code here

Hint

Use for num in numbers to loop. Use num.even? to check evenness and num > threshold to compare.

4

Print the results

Inside the for loop, print the number and whether it is even or odd, and if it is greater than the threshold or not. Use this exact format: "2 is even and less than or equal to 10" or "11 is odd and greater than 10"

Ruby

numbers = [2, 5, 8, 11, 14]
threshold = 10
for num in numbers
  is_even = num.even?
  is_greater = num > threshold
  # Print the result in the required format
  # Your code here
end

Hint

Use puts with string interpolation and the ternary operator ? : to print the message.

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