Subclass with < operator in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of subclass comparison with < operator

What is the output of this Ruby code?

Ruby

class Animal
  def <(other)
    self.class < other.class
  end
end

class Dog < Animal; end
class Cat < Animal; end

puts Dog.new < Cat.new

A false

B NoMethodError

C true

D ArgumentError

💡 Hint

Remember that Ruby's < operator can be used to compare classes by their inheritance hierarchy.

The < operator compares the classes of the instances using Ruby's built-in Class#< method, which returns true if the left class (self.class) is a subclass of the right class (other.class). Dog is not a subclass of Cat, so it returns false.

❓ Predict Output

intermediate

Subclass comparison with overridden < operator

What does this Ruby code print?

Ruby

class Vehicle
  def <(other)
    self.class < other.class
  end
end

class Car < Vehicle; end
class Truck < Vehicle; end

puts Car.new < Truck.new

A NoMethodError

B false

C TypeError

D true

💡 Hint

Check if Car is subclass of Truck or vice versa.

The < operator compares the classes. Car is not a subclass of Truck, so Car < Truck returns false.

🔧 Debug

advanced

Why does this subclass < operator code raise an error?

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

Ruby

class Fruit
  def <(other)
    self < other
  end
end

class Apple < Fruit; end
class Banana < Fruit; end

puts Apple.new < Banana.new

A NoMethodError because < is undefined

B ArgumentError because of wrong argument type

C SystemStackError due to infinite recursion

D SyntaxError due to missing end

💡 Hint

Look at the < method calling itself.

The < method calls self < other, which calls the same method again, causing infinite recursion and a SystemStackError.

❓ Predict Output

advanced

Output of subclass < operator with modules included

What is the output of this Ruby code?

Ruby

module ComparableModule
  def <(other)
    self.class < other.class
  end
end

class Parent; include ComparableModule; end
class Child < Parent; end
class Sibling < Parent; end

puts Child.new < Sibling.new

A true

B TypeError

C NoMethodError

D false

💡 Hint

Check the inheritance relationship between Child and Sibling.

Child and Sibling are siblings, neither is subclass of the other, so Child < Sibling returns false.

🧠 Conceptual

expert

Understanding < operator behavior in subclass comparison

In Ruby, when you define < operator in a superclass to compare classes of instances using self.class < other.class, what will be the result of comparing an instance of a subclass with an instance of its superclass using < ?

A true, because Class#< returns true if left is subclass of right

B false, because subclass is not less than superclass

C true, because subclass is always less than superclass

D false, because Class#< returns true only if left is superclass of right

💡 Hint

Recall how Class#< works in Ruby.

Class#< returns true if the left class is a subclass of the right class. So comparing subclass instance < superclass instance returns true.

Practice

1. In Ruby, what does the expression ChildClass < ParentClass check?

easy

A. If ChildClass and ParentClass are the same class

B. If ChildClass is an instance of ParentClass

C. If ChildClass is a subclass of ParentClass

D. If ParentClass is a subclass of ChildClass

Solution

1. Step 1: Understand the < operator for classes

   In Ruby, the < operator between classes checks inheritance, specifically if the left class is a subclass of the right class.

2. Step 2: Apply to ChildClass < ParentClass

   This expression returns true if ChildClass inherits from ParentClass, meaning ChildClass is a subclass.

3. Final Answer:

   If ChildClass is a subclass of ParentClass -> Option C

4. Quick Check:

   Subclass check = true if inheritance [OK]

Hint: Remember: < means 'is subclass of' in Ruby classes [OK]

Common Mistakes:

• Confusing subclass check with instance check
• Thinking < checks equality of classes
• Reversing the order of classes in the expression

2. Which of the following is the correct syntax to check if Dog is a subclass of Animal in Ruby?

easy

A. Dog < Animal

B. Dog.is_subclass_of?(Animal)

C. Dog.subclass_of? Animal

D. Dog < Animal()

Solution

1. Step 1: Recall Ruby subclass syntax

   Ruby uses the < operator between classes to check subclass relationships, like Dog < Animal.

2. Step 2: Evaluate options

   Methods like is_subclass_of? and subclass_of? do not exist on classes. Dog < Animal() has incorrect syntax with parentheses. Only Dog < Animal is valid Ruby syntax.

3. Final Answer:

   Dog < Animal -> Option A

4. Quick Check:

   Correct syntax uses < operator [OK]

Hint: Use < directly between classes, no method needed [OK]

Common Mistakes:

• Using methods that don't exist for subclass check
• Adding parentheses incorrectly
• Using instance methods instead of class operators

3. What is the output of this Ruby code?

class Vehicle; end
class Car < Vehicle; end
class Bike; end

puts Car < Vehicle
puts Bike < Vehicle

medium

A. false
false

B. true
false

C. true
true

D. false
true

Solution

1. Step 1: Analyze class inheritance

   Car inherits from Vehicle, so Car < Vehicle returns true. Bike does not inherit from Vehicle, so Bike < Vehicle returns false.

2. Step 2: Determine output of puts statements

   The first puts prints true, the second prints false, each on its own line.

3. Final Answer:

   true false -> Option B

4. Quick Check:

   Subclass true, unrelated false [OK]

Hint: Subclass < Parent = true; unrelated classes = false [OK]

Common Mistakes:

• Assuming unrelated classes return true
• Confusing instance and class comparisons
• Mixing up order of classes in < operator

4. Consider this Ruby code snippet:

class Fruit; end
class Apple < Fruit; end

puts Apple < fruit

What is the error and how to fix it?

medium

A. No error; output is true

B. SyntaxError: invalid syntax; fix by adding parentheses

C. TypeError: wrong argument type; fix by using instance instead of class

D. NameError: uninitialized constant 'fruit'; fix by capitalizing 'Fruit'

Solution

1. Step 1: Identify the error

   The code uses lowercase 'fruit' instead of 'Fruit'. Ruby constants (classes) must start with uppercase letters. This causes a NameError.

2. Step 2: Fix the error

   Change 'fruit' to 'Fruit' to reference the class correctly.

3. Final Answer:

   NameError: uninitialized constant 'fruit'; fix by capitalizing 'Fruit' -> Option D

4. Quick Check:

   Class names start uppercase [OK]

Hint: Class names always start with uppercase letter [OK]

Common Mistakes:

• Using lowercase for class names
• Confusing variables with class constants
• Trying to call < on instances instead of classes

5. You have these Ruby classes:

class Animal; end
class Mammal < Animal; end
class Dog < Mammal; end
class Fish < Animal; end

puts Dog < Animal
puts Fish < Mammal
puts Mammal < Dog

What is the output and why?

hard

A. true
false
false

B. true
true
false

C. false
false
true

D. true
false
true

Solution

1. Step 1: Evaluate Dog < Animal

   Dog inherits from Mammal, which inherits from Animal, so Dog is a subclass of Animal. Returns true.

2. Step 2: Evaluate Fish < Mammal

   Fish inherits directly from Animal, not Mammal. So Fish is not a subclass of Mammal. Returns false.

3. Step 3: Evaluate Mammal < Dog

   Mammal is a superclass of Dog, not a subclass. So this returns false.

4. Final Answer:

   true false false -> Option A

5. Quick Check:

   Subclass chain true, unrelated or reversed false [OK]

Hint: Subclass < superclass = true; reversed or unrelated = false [OK]

Common Mistakes:

• Assuming superclass < subclass returns true
• Ignoring multi-level inheritance
• Mixing up class hierarchy direction