Proc creation and call in Ruby - Time & Space Complexity

Time Complexity: Proc creation and call

O(n)

Understanding Time Complexity

We want to understand how the time it takes to create and call a Proc changes as we do it more times.

How does the number of Proc creations and calls affect the total work done?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

procs = []
10.times do |i|
  procs << Proc.new { i * 2 }
end

procs.each do |p|
  p.call
end
    

This code creates 10 Procs that double a number, then calls each Proc once.

Identify Repeating Operations

Look at what repeats in the code.

• Primary operation: Creating Procs inside a loop and calling each Proc.
• How many times: Each happens 10 times, once per item.

How Execution Grows With Input

As the number of Procs grows, the work grows too.

Input Size (n)	Approx. Operations
10	About 20 (10 creations + 10 calls)
100	About 200 (100 creations + 100 calls)
1000	About 2000 (1000 creations + 1000 calls)

Pattern observation: The total work grows directly with the number of Procs created and called.

Final Time Complexity

Time Complexity: O(n)

This means if you double the number of Procs, the total time roughly doubles too.

Common Mistake

[X] Wrong: "Creating a Proc once means calling it many times is free or very fast."

[OK] Correct: Each call still takes time, so calling many times adds up and affects total time.

Interview Connect

Understanding how repeated creation and calls affect time helps you reason about code efficiency and resource use in real projects.

Self-Check

"What if we created one Proc and called it multiple times instead of creating many Procs? How would the time complexity change?"

Practice

1. What does a Proc in Ruby do?

easy

A. Stores a block of code to run later

B. Creates a new variable

C. Defines a class

D. Starts a loop

Solution

1. Step 1: Understand what a Proc is and match description

   A Proc is a way to save some code to run later, like a recipe you keep for cooking. Only Stores a block of code to run later describes storing code to run later, which matches what a Proc does.

2. Final Answer:

   Stores a block of code to run later -> Option A

3. Quick Check:

   Proc = stored code block [OK]

Hint: Proc saves code to run later, like a saved recipe [OK]

Common Mistakes:

• Thinking Proc creates variables
• Confusing Proc with class definition
• Assuming Proc starts loops automatically

2. Which of the following is the correct way to create a Proc in Ruby?

easy

A. my_proc = Proc.new { |x| x * 2 }

B. my_proc = new Proc { |x| x * 2 }

C. my_proc = Proc.create { |x| x * 2 }

D. my_proc = Proc.call { |x| x * 2 }

Solution

1. Step 1: Recall Proc creation syntax and check options

   In Ruby, you create a Proc using Proc.new or proc with a block. Only my_proc = Proc.new { |x| x * 2 } uses the correct syntax Proc.new { |x| x * 2 }. Others use invalid methods like new Proc, Proc.create, or Proc.call.

2. Final Answer:

   my_proc = Proc.new { |x| x * 2 } -> Option A

3. Quick Check:

   Proc.new + block = correct Proc creation [OK]

Hint: Use Proc.new or proc with a block to create a Proc [OK]

Common Mistakes:

• Using 'new Proc' instead of 'Proc.new'
• Trying to call Proc.create or Proc.call to create
• Missing the block braces {}

3. What is the output of this Ruby code?

my_proc = proc { |x| x + 3 }
puts my_proc.call(4)

medium

A. 4

B. Error

C. 3

D. 7

Solution

1. Step 1: Trace the Proc definition and execution

   The Proc adds 3 to the input number: x + 3. Calling my_proc.call(4) computes 4 + 3 = 7.

2. Final Answer:

   7 -> Option D

3. Quick Check:

   4 + 3 = 7 [OK]

Hint: Proc.call runs code with given argument [OK]

Common Mistakes:

• Confusing Proc.call with Proc.new
• Forgetting to pass argument to call
• Expecting output without call

4. Identify the error in this code snippet:

my_proc = Proc.new { |x| x * 2 }
puts my_proc.call

medium

A. Proc.new syntax is incorrect

B. Missing argument when calling the Proc

C. Cannot call Proc with call method

D. Block should not have parameters

Solution

1. Step 1: Analyze Proc definition and call for errors

   The Proc expects one argument x to multiply by 2. The call is made without any argument, which causes an error because x is missing.

2. Final Answer:

   Missing argument when calling the Proc -> Option B

3. Quick Check:

   Proc needs argument when called [OK]

Hint: Always pass required arguments when calling a Proc [OK]

Common Mistakes:

• Calling Proc without required arguments
• Thinking Proc.new syntax is wrong
• Believing call method is invalid

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

def create_proc
  Proc.new { |x| x.nil? ? 'No value' : x * 10 }
end

my_proc = create_proc
puts my_proc.call(nil)
puts my_proc.call(5)

hard

A. nil\n50

B. Error\n50

C. No value\n50

D. No value\n5

Solution

1. Step 1: Analyze the Proc logic and trace both calls

   The Proc checks if x is nil; if yes, returns 'No value', else returns x * 10. Calling with nil returns 'No value'. Calling with 5 returns 5 * 10 = 50.

2. Final Answer:

   No value\n50 -> Option C

3. Quick Check:

   nil -> 'No value', 5 -> 50 [OK]

Hint: Proc can handle nil with conditional inside block [OK]

Common Mistakes:

• Expecting error when passing nil
• Forgetting ternary condition inside Proc
• Assuming multiplication by 10 applies to nil