Accessing parent methods in Ruby - Time & Space Complexity

Time Complexity: Accessing parent methods

O(n)

Understanding Time Complexity

When a child class calls a method from its parent class, it runs some code inherited from above. We want to see how the time it takes changes as the input grows.

How does calling a parent method affect the total work done?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Parent
  def process(items)
    items.each do |item|
      puts item * 2
    end
  end
end

class Child < Parent
  def process(items)
    super
  end
end

child = Child.new
child.process([1, 2, 3, 4, 5])

This code defines a parent class with a method that loops over a list and prints doubled values. The child class calls the parent's method using super.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping over each item in the list inside the parent method.
• How many times: Once for each item in the input array.

How Execution Grows With Input

As the list gets bigger, the method runs the loop more times, doing more work.

Input Size (n)	Approx. Operations
10	10 times printing doubled values
100	100 times printing doubled values
1000	1000 times printing doubled values

Pattern observation: The work grows directly with the number of items. Double the items, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of items in the list.

Common Mistake

[X] Wrong: "Calling super adds extra loops or doubles the work."

[OK] Correct: The child just calls the parent's method once. It does not repeat the loop multiple times, so the work stays proportional to the input size.

Interview Connect

Understanding how inherited methods run helps you explain code efficiency clearly. It shows you can think about how code layers affect performance, a useful skill in many coding tasks.

Self-Check

What if the child method added another loop over the items before calling super? How would the time complexity change?

Practice

1. In Ruby, how do you call a method from a parent class inside a child class method?

easy

A. Use parent.method_name

B. Call the parent method by its name directly

C. Use this.parent.method_name

D. Use super inside the child method

Solution

1. Step 1: Understand method inheritance in Ruby

   Child classes inherit methods from parent classes but to call the parent's version inside an overridden method, you use super.

2. Step 2: Identify the correct syntax for calling parent method

   Using super inside the child method calls the parent method with the same name.

3. Final Answer:

   Use super inside the child method -> Option D

4. Quick Check:

   Calling parent method = super [OK]

Hint: Use super to call parent method inside child [OK]

Common Mistakes:

• Trying to call parent method by name directly
• Using non-existent syntax like parent.method_name
• Confusing this with Ruby's self

2. Which of the following is the correct syntax to call a parent class method with arguments in Ruby?

easy

A. super arg1, arg2

B. super(arg1 arg2)

C. super[arg1, arg2]

D. super{arg1, arg2}

Solution

1. Step 1: Recall Ruby method call syntax

   In Ruby, method arguments are passed separated by commas without brackets unless parentheses are used.

2. Step 2: Identify correct super usage with arguments

   The correct way is super arg1, arg2 or super(arg1, arg2). super arg1, arg2 uses the correct syntax without parentheses.

3. Final Answer:

   super arg1, arg2 -> Option A

4. Quick Check:

   Pass args to super with commas [OK]

Hint: Pass arguments to super separated by commas [OK]

Common Mistakes:

• Using brackets [] or braces {} instead of parentheses or commas
• Omitting commas between arguments
• Using incorrect syntax like super(arg1 arg2)

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

class Parent
  def greet(name)
    "Hello, #{name} from Parent"
  end
end

class Child < Parent
  def greet(name)
    super(name) + " and Child"
  end
end

puts Child.new.greet("Alice")

medium

A. "Hello, Alice from Child"

B. "Hello, Alice from Parent and Child"

C. "Hello, Alice from Parent"

D. Error: wrong number of arguments

Solution

1. Step 1: Understand method overriding and super call

   The Child#greet method calls super(name), which calls Parent#greet(name) and returns "Hello, Alice from Parent".

2. Step 2: Concatenate the returned string

   The child method adds " and Child" to the parent's returned string, resulting in "Hello, Alice from Parent and Child".

3. Final Answer:

   "Hello, Alice from Parent and Child" -> Option B

4. Quick Check:

   super returns parent's string + child's addition [OK]

Hint: super returns parent's result; child adds more [OK]

Common Mistakes:

• Thinking super calls child's method again causing recursion
• Ignoring the concatenation after super call
• Assuming super without arguments forwards none

4. Identify the error in this Ruby code snippet:

class Parent
  def info
    "Parent info"
  end
end

class Child < Parent
  def info
    super()
    puts "Child info"
  end
end

Child.new.info

medium

A. super() returns value but is ignored; only child info prints

B. Runtime error: super() called without arguments

C. Syntax error: super() should not have parentheses

D. No error; outputs both parent and child info

Solution

1. Step 1: Analyze the super call with parentheses

   Calling super() calls the parent method with no arguments and returns "Parent info" but does not print it.

2. Step 2: Check what is printed

   The child method prints only "Child info" because the parent's return value is ignored.

3. Final Answer:

   super() returns value but is ignored; only child info prints -> Option A

4. Quick Check:

   super() returns but doesn't print [OK]

Hint: super() returns value; print it to see output [OK]

Common Mistakes:

• Assuming super() prints parent's return value automatically
• Thinking super() without args causes error
• Confusing syntax error with runtime behavior

5. Given this Ruby code, what will be the output?

class A
  def message
    "A"
  end
end

class B < A
  def message
    "B" + super
  end
end

class C < B
  def message
    super + "C"
  end
end

puts C.new.message

hard

A. "ABC"

B. "BCA"

C. "BAC"

D. "CAB"

Solution

1. Step 1: Trace method calls from C to A

   C#message calls super which is B#message. B#message returns "B" + super which calls A#message returning "A".

2. Step 2: Combine returned strings step-by-step

   B#message returns "B" + "A" = "BA". Then C#message returns "BA" + "C" = "BAC".

3. Final Answer:

   "BAC" -> Option C

4. Quick Check:

   super chains add strings in order [OK]

Hint: super calls chain up; combine results in call order [OK]

Common Mistakes:

• Mixing order of concatenation
• Assuming super calls only immediate parent
• Ignoring that super returns parent's result