Class.new for dynamic class creation in Ruby - Time & Space Complexity

Time Complexity: Class.new for dynamic class creation

O(n)

Understanding Time Complexity

When we create classes dynamically using Class.new, it is important to understand how the time to create these classes grows as we create more of them.

We want to know how the time needed changes when we make many classes this way.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

classes = []
10.times do
  klass = Class.new do
    def greet
      "Hello"
    end
  end
  classes << klass
end
    

This code creates 10 new classes dynamically, each with a simple method, and stores them in an array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating a new class with Class.new inside a loop.
• How many times: The loop runs 10 times, so the class creation happens 10 times.

How Execution Grows With Input

Each time we add one more class creation, the total time increases by roughly the same amount.

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

Pattern observation: The time grows steadily and directly with the number of classes created.

Final Time Complexity

Time Complexity: O(n)

This means if you create twice as many classes, it will take about twice as long.

Common Mistake

[X] Wrong: "Creating classes dynamically is instant and does not depend on how many we make."

[OK] Correct: Each class creation takes some time, so making more classes adds up and takes longer overall.

Interview Connect

Understanding how dynamic class creation scales helps you reason about code that builds things on the fly, a useful skill in many programming tasks.

Self-Check

"What if we added methods inside the class dynamically for each class? How would the time complexity change?"

Practice

1. What does Class.new do in Ruby?

easy

A. Defines a method inside a class

B. Deletes an existing class

C. Creates a new instance of a class

D. Creates a new class dynamically at runtime

Solution

1. Step 1: Understand the purpose of Class.new

   Class.new is used to create a new class dynamically while the program runs, without writing a full class definition.

2. Step 2: Differentiate from other options

   It does not delete classes, create instances, or define methods alone. It creates a new class object.

3. Final Answer:

   Creates a new class dynamically at runtime -> Option D

4. Quick Check:

   Class.new = dynamic class creation [OK]

Hint: Class.new always creates a new class object [OK]

Common Mistakes:

• Confusing class creation with instance creation
• Thinking it deletes or modifies existing classes
• Assuming it only defines methods

2. Which of the following is the correct syntax to create a new class with Class.new and add a method greet that returns "Hello"?

easy

A. MyClass = Class.new do def greet return "Hello" end end

B. MyClass = Class.new { greet() = "Hello" }

C. MyClass = Class.new { def greet; "Hello"; end }

D. MyClass = Class.new { def greet() puts "Hello" }

Solution

1. Step 1: Check correct block syntax for Class.new

   The block can be given with curly braces or do-end. Inside, method definitions use def method_name; ...; end.

2. Step 2: Validate method definition and return value

   MyClass = Class.new { def greet; "Hello"; end } correctly defines greet returning "Hello". MyClass = Class.new do def greet return "Hello" end end is correct syntax but missing the 'end' for the block in MyClass = Class.new do def greet return "Hello" end end, so MyClass = Class.new do def greet return "Hello" end end is invalid as given. MyClass = Class.new { greet() = "Hello" } uses invalid method syntax. MyClass = Class.new { def greet() puts "Hello" } uses puts which prints but does not return the string.

3. Final Answer:

   MyClass = Class.new { def greet; "Hello"; end } -> Option C

4. Quick Check:

   Correct method syntax inside Class.new block = MyClass = Class.new { def greet; "Hello"; end } [OK]

Hint: Use def inside Class.new block with proper syntax [OK]

Common Mistakes:

• Using puts instead of returning a string
• Incorrect block syntax for Class.new
• Invalid method definition syntax

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

MyClass = Class.new do
  def greet
    "Hi"
  end
end

obj = MyClass.new
puts obj.greet

medium

A. Hi

B. Hello

C. Error: undefined method greet

D. nil

Solution

1. Step 1: Understand class creation and method definition

   The code creates a new class with a method greet returning "Hi".

2. Step 2: Create instance and call method

   Creating an instance obj and calling obj.greet returns "Hi" which is printed.

3. Final Answer:

   Hi -> Option A

4. Quick Check:

   Method greet returns "Hi" [OK]

Hint: Method returns string; puts prints it [OK]

Common Mistakes:

• Expecting 'Hello' instead of 'Hi'
• Thinking method is undefined
• Confusing return value with nil

4. Identify the error in this code snippet:

MyClass = Class.new {
  def greet
    "Hello"
  end
end

obj = MyClass.new
puts obj.greet

medium

A. Using curly braces instead of do-end for multi-line block

B. Missing parentheses in method definition

C. Cannot call new on Class.new result

D. Method greet should use puts instead of return

Solution

1. Step 1: Check block syntax for Class.new

   Curly braces are for single-line blocks. Multi-line blocks should use do-end syntax.

2. Step 2: Confirm other parts are correct

   Method definition syntax is valid, calling new is valid, and returning string is correct.

3. Final Answer:

   Using curly braces instead of do-end for multi-line block -> Option A

4. Quick Check:

   Multi-line block needs do-end [OK]

Hint: Use do-end for multi-line Class.new blocks [OK]

Common Mistakes:

• Using curly braces for multi-line blocks
• Thinking method needs parentheses
• Confusing method return with puts

5. You want to create a dynamic class with Class.new that has an initializer accepting a name and a method greet returning "Hello, <name>". Which code correctly implements this?

hard

A. Person = Class.new {
def initialize(name)
@name = name
end
def greet
"Hello, " + name
end
}

B. Person = Class.new do
def initialize(name)
@name = name
end
def greet
"Hello, #{@name}"
end
end

C. Person = Class.new do
def initialize(name)
name = @name
end
def greet
"Hello, " + @name
end
end

D. Person = Class.new do
def initialize(name)
@name = name
end
def greet
puts "Hello, #{@name}"
end
end

Solution

1. Step 1: Check initializer assigns instance variable

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end correctly assigns @name = name in initialize. Person = Class.new do def initialize(name) name = @name end def greet "Hello, " + @name end end reverses assignment incorrectly. Person = Class.new { def initialize(name) @name = name end def greet "Hello, " + name end } uses wrong block syntax. Person = Class.new do def initialize(name) @name = name end def greet puts "Hello, #{@name}" end end uses puts in greet which prints but does not return the string.

2. Step 2: Check greet method returns correct string

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end returns the string with interpolation. Person = Class.new { def initialize(name) @name = name end def greet "Hello, " + name end } uses undefined variable name. Person = Class.new do def initialize(name) @name = name end def greet puts "Hello, #{@name}" end end prints instead of returning.

3. Final Answer:

   Person = Class.new do def initialize(name) @name = name end def greet "Hello, #{@name}" end end -> Option B

4. Quick Check:

   Correct initializer and return string in greet [OK]

Hint: Assign @name in initialize; return string in greet [OK]

Common Mistakes:

• Reversing assignment in initialize
• Using puts instead of returning string
• Wrong block syntax with curly braces