Comparable module usage in Ruby - Time & Space Complexity

Time Complexity: Comparable module usage

O(1)

Understanding Time Complexity

We want to understand how the time needed to compare objects grows when using the Comparable module in Ruby.

How does the number of comparisons change as we compare more or bigger objects?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Box
  include Comparable

  attr_reader :volume

  def initialize(volume)
    @volume = volume
  end

  def <=>(other)
    volume <=> other.volume
  end
end

box1 = Box.new(10)
box2 = Box.new(20)
puts box1 < box2

This code defines a Box class that can be compared by volume using the Comparable module.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Single comparison of two Box objects using the <=> method.
• How many times: Once per comparison call.

How Execution Grows With Input

Each comparison checks the volume values once, so the time per comparison is constant.

Input Size (n)	Approx. Operations
10	1 comparison
100	1 comparison
1000	1 comparison

Pattern observation: The time is constant regardless of input size.

Final Time Complexity

Time Complexity: O(1)

This means the time to perform one comparison is constant and does not grow with input size.

Common Mistake

[X] Wrong: "Using Comparable makes all comparisons instant regardless of input size."

[OK] Correct: Each comparison still takes time, so if you compare many objects, the total time adds up.

Interview Connect

Understanding how comparison operations scale helps you write efficient code when sorting or searching objects, a useful skill in many programming tasks.

Self-Check

"What if the <=> method compared multiple attributes instead of just one? How would the time complexity change?"