Super keyword behavior in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of super with arguments in method override

What is the output of the following Ruby code?

Ruby

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

class Child < Parent
  def greet(name)
    super(name).upcase
  end
end

puts Child.new.greet("Alice")

A Error: wrong number of arguments

B Hello, Alice!

C hello, alice!

D HELLO, ALICE!

💡 Hint

Remember that super(name) calls the parent method with the same argument, then upcase converts the string to uppercase.

The Child class overrides greet and calls super(name) to invoke Parent#greet with the argument. The returned string is then converted to uppercase, resulting in 'HELLO, ALICE!'.

❓ Predict Output

intermediate

Effect of super without arguments in method override

What will this Ruby code print?

Ruby

class A
  def info(x)
    "Value: #{x}"
  end
end

class B < A
  def info(x)
    super + "!"
  end
end

puts B.new.info(5)

A Value: 5!

B Value: !

C Error: wrong number of arguments

D Value: 5

💡 Hint

Calling super without arguments passes the same arguments received by the method.

In Ruby, calling super without parentheses passes all arguments received by the method to the parent method. So super calls info(5), returning 'Value: 5', then adds '!'.

❓ Predict Output

advanced

super with block forwarding behavior

What is the output of this Ruby code?

Ruby

class Base
  def process
    yield if block_given?
  end
end

class Derived < Base
  def process
    super { puts "Inside block" }
  end
end

Derived.new.process

A No output

B Inside block

C Error: no block given

D Error: wrong number of arguments

💡 Hint

super forwards the block given to it, so the block inside super is executed.

Derived#process calls super with a block that prints 'Inside block'. Base#process yields to the block, so 'Inside block' is printed.

❓ Predict Output

advanced

super with no arguments and no block in method with parameters

What happens when this Ruby code runs?

Ruby

class Parent
  def calculate(a, b)
    a + b
  end
end

class Child < Parent
  def calculate(a, b)
    super * 2
  end
end

puts Child.new.calculate(3, 4)

A Error: wrong number of arguments

B 7

C 14

D Error: undefined method '*' for nil

💡 Hint

super without parentheses passes all arguments received by the method.

Child#calculate calls super without parentheses, so it forwards both arguments (3,4) to Parent#calculate, which returns 7. Then 7 * 2 = 14 is printed.

❓ Predict Output

expert

super in multiple inheritance levels with keyword arguments

What is the output of this Ruby code?

Ruby

class Alpha
  def info(x:, y:)
    "Alpha: x=#{x}, y=#{y}"
  end
end

class Beta < Alpha
  def info(x:, y:)
    super(x: x + 1, y: y + 1) + " -> Beta"
  end
end

class Gamma < Beta
  def info(x:, y:)
    super(x: x * 2, y: y * 2) + " -> Gamma"
  end
end

puts Gamma.new.info(x: 1, y: 2)

A Alpha: x=3, y=5 -> Beta -> Gamma

B Alpha: x=2, y=3 -> Beta -> Gamma

C Alpha: x=4, y=6 -> Beta -> Gamma

D Error: wrong number of arguments

💡 Hint

Each super call modifies the keyword arguments before passing them up the chain.

Gamma#info calls super with x=2, y=4 (1*2, 2*2). Beta#info receives x=2, y=4, calls super with x=3, y=5 (2+1, 4+1). Alpha#info receives x=3, y=5 and returns 'Alpha: x=3, y=5'. Then Beta appends ' -> Beta', Gamma appends ' -> Gamma'.

Practice

1. What does the super keyword do in Ruby?

easy

A. Creates a new instance of the parent class

B. Overrides the parent class's method permanently

C. Calls the parent class's method with the same name

D. Deletes the parent class's method

Solution

1. Step 1: Understand the role of super

   The super keyword is used inside a child class method to call the method with the same name from its parent class. It does not create, override, or delete methods but simply calls the parent method to reuse or extend its behavior.

2. Final Answer:

   Calls the parent class's method with the same name -> Option C

3. Quick Check:

   super calls parent method [OK]

Hint: Remember: super calls parent method with same name [OK]

Common Mistakes:

• Thinking super creates or deletes methods
• Confusing super with instance creation
• Assuming super overrides methods permanently

2. Which of the following is the correct syntax to call the parent method with no arguments using super?

easy

A. super()

B. super[]

C. super

D. super{}

Solution

1. Step 1: Understand super with parentheses

   Using super() calls the parent method explicitly with no arguments, ignoring any current method arguments. Only super() uses parentheses correctly to pass no arguments; other forms are invalid syntax.

2. Final Answer:

   super() -> Option A

3. Quick Check:

   super() means no arguments [OK]

Hint: Use parentheses to call parent with no args: super() [OK]

Common Mistakes:

• Using super without parentheses to mean no arguments
• Using brackets or braces instead of parentheses
• Confusing super() with super without parentheses

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 + " and Child"
  end
end

puts Child.new.greet("Alice")

medium

A. Hello, Alice from Parent and Child

B. Hello, Alice from Child

C. Hello, from Parent and Child

D. Error: wrong number of arguments

Solution

1. Step 1: Trace the method call in Child#greet

   The Child's greet method calls super without parentheses, so it passes the argument "Alice" to Parent#greet. Parent#greet returns "Hello, Alice from Parent". Child appends " and Child" to this string.

2. Final Answer:

   Hello, Alice from Parent and Child -> Option A

3. Quick Check:

   super passes args, output combines strings [OK]

Hint: super without () passes all args automatically [OK]

Common Mistakes:

• Assuming super passes no arguments by default
• Expecting an error due to argument mismatch
• Ignoring the appended string in Child method

4. Identify the error in this Ruby code:

class Parent
  def initialize(age)
    @age = age
  end
end

class Child < Parent
  def initialize
    super
    @name = "Child"
  end
end

Child.new

medium

A. NameError for @name variable

B. No error, code runs fine

C. SyntaxError due to missing parentheses

D. ArgumentError: wrong number of arguments for super

Solution

1. Step 1: Check Parent initialize method

   Parent's initialize requires one argument age. Child's initialize calls super without arguments, so it tries to call Parent's initialize with zero arguments, causing an ArgumentError.

2. Final Answer:

   ArgumentError: wrong number of arguments for super -> Option D

3. Quick Check:

   super must match parent args or use super() [OK]

Hint: super without args passes current args; mismatch causes error [OK]

Common Mistakes:

• Assuming super() passes parent's required args automatically
• Ignoring that Parent requires an argument
• Thinking missing parentheses cause syntax error here

5. Given this code, what will Child.new.greet output?

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

class Child < Parent
  def greet(name = nil)
    if name
      super(name.upcase)
    else
      super()
    end
  end
end

puts Child.new.greet
puts Child.new.greet("alice")

hard

A. Hello, from Parent
Hello, alice from Parent

B. Hello, Guest from Parent
Hello, ALICE from Parent

C. Hello, Guest from Parent
Hello, alice from Parent

D. Error due to wrong arguments in super calls

Solution

1. Step 1: Analyze Child#greet with no argument

   When called without argument, name is nil, so super() calls Parent#greet with no arguments, using default "Guest". When called with "alice", name.upcase is "ALICE" passed to super(name.upcase), so Parent#greet returns "Hello, ALICE from Parent".

2. Final Answer:

   Hello, Guest from Parent Hello, ALICE from Parent -> Option B

3. Quick Check:

   super() calls parent with defaults; super(args) passes modified args [OK]

Hint: Use super() for no args, super(args) to pass specific args [OK]

Common Mistakes:

• Assuming super() passes current args
• Ignoring default parameter in Parent#greet
• Not uppercasing the argument before passing