Module methods in Ruby - Time & Space Complexity

Time Complexity: Module methods

O(n)

Understanding Time Complexity

We want to understand how long it takes to run code that uses module methods in Ruby.

Specifically, we ask: how does the time to run change as the input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

module MathHelpers
  def self.square_all(numbers)
    numbers.map { |n| n * n }
  end
end

n = 10
arr = (1..n).to_a
result = MathHelpers.square_all(arr)

This code defines a module method that squares each number in an array.

Identify Repeating Operations

• Primary operation: The method uses map to go through each number once.
• How many times: It runs once for each number in the input array.

How Execution Grows With Input

As the input array gets bigger, the method does more work, one step per number.

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

Pattern observation: The work grows directly with the number of items; doubling items doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the input size.

Common Mistake

[X] Wrong: "Module methods make the code run instantly, no matter the input size."

[OK] Correct: Module methods are just like regular methods; if they process each item, time grows with input size.

Interview Connect

Understanding how module methods handle input size helps you explain code efficiency clearly and confidently.

Self-Check

What if the method used nested loops inside the module method? How would the time complexity change?

Practice

1. What is the correct way to define a method inside a Ruby module so it can be called directly on the module?

easy

A. Define the method outside the module

B. Define the method without self inside the module

C. Define the method with self.method_name inside the module

D. Define the method with def module.method_name inside the module

Solution

1. Step 1: Understand module method definition

   In Ruby, to make a method callable directly on a module, you define it with self.method_name inside the module.

2. Step 2: Compare options

   Define the method with self.method_name inside the module uses self.method_name, which is correct. Other options either omit self or use invalid syntax.

3. Final Answer:

   Define the method with self.method_name inside the module -> Option C

4. Quick Check:

   Module methods use self.method_name = A [OK]

Hint: Use self.method_name to define module methods [OK]

Common Mistakes:

• Forgetting to add self before method name
• Defining methods outside the module
• Using invalid syntax like def module.method_name

2. Which of the following is the correct syntax to call a module method named greet defined in module Welcome?

easy

A. Welcome#greet

B. greet.Welcome

C. Welcome.new.greet

D. Welcome.greet

Solution

1. Step 1: Recall how to call module methods

   Module methods are called using dot notation: ModuleName.method_name.

2. Step 2: Check options

   Welcome.greet is the correct syntax using dot notation. Welcome#greet incorrectly uses #. greet.Welcome reverses the order. Welcome.new.greet confuses it with an instance method call.

3. Final Answer:

   Welcome.greet -> Option D

4. Quick Check:

   Call module methods with dot = D [OK]

Hint: Call module methods with ModuleName.method_name [OK]

Common Mistakes:

• Using # instead of . to call module methods
• Trying to call method with invalid syntax
• Confusing instance and module method calls

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

module MathTools
  def self.square(x)
    x * x
  end
end

puts MathTools.square(4)

medium

A. 16

B. square

C. Error: undefined method

D. 4

Solution

1. Step 1: Understand the method definition

   The method square is defined as a module method using self.square. It returns the square of the input.

2. Step 2: Calculate the output

   Calling MathTools.square(4) returns 4 * 4 = 16, which is printed.

3. Final Answer:

   16 -> Option A

4. Quick Check:

   4 squared = 16 [OK]

Hint: Multiply input by itself in module method [OK]

Common Mistakes:

• Forgetting self and causing undefined method error
• Confusing output with input
• Expecting method name as output

4. Identify the error in this Ruby module method code:

module Greetings
  def greet
    "Hello!"
  end
end

puts Greetings.greet

medium

A. Method greet is not defined as a module method

B. Module name is incorrect

C. Missing parentheses in method call

D. Syntax error in method body

Solution

1. Step 1: Check method definition inside module

   The method greet is defined without self., so it is an instance method, not a module method.

2. Step 2: Understand method call

   Calling Greetings.greet tries to call a module method, but none exists, causing an error.

3. Final Answer:

   Method greet is not defined as a module method -> Option A

4. Quick Check:

   Missing self. means no module method [OK]

Hint: Add self. to define module methods [OK]

Common Mistakes:

• Defining instance methods instead of module methods
• Calling module method without defining it
• Assuming parentheses are required in method call

5. Given the module below, how can you add a module method double that returns twice the input number?

module Calculator
  # Add your method here
end

hard

A. def double(x)
x + x
end

B. def self.double(x)
x * 2
end

C. def Calculator.double(x)
x * 2
end

D. def self.double
x * 2
end

Solution

1. Step 1: Define a module method with self

   To create a module method, define it with self.method_name inside the module.

2. Step 2: Write method to return twice the input

   The method should take one argument x and return x * 2.

3. Final Answer:

   def self.double(x) x * 2 end -> Option B

4. Quick Check:

   Module method with self and correct logic = A [OK]

Hint: Use def self.method(args) for module methods [OK]

Common Mistakes:

• Omitting self and creating instance method
• Missing method argument
• Defining method outside module