Define_method for dynamic methods in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a method dynamically using define_method.

Ruby

class Greeter
  define_method(:[1]) do |name|
    "Hello, #{name}!"
  end
end

Drag options to blanks, or click blank then click option'

Agreet

Bsay_hello

Chello

Dwelcome

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of a symbol for the method name.

Choosing a method name that does not match the greeting context.

The method name to define dynamically is greet. Using define_method(:greet) creates a method called greet that takes a name and returns a greeting.

2fill in blank

medium

Complete the code to define a method dynamically that returns the square of a number.

Ruby

class Calculator
  define_method(:[1]) do |x|
    x * x
  end
end

Drag options to blanks, or click blank then click option'

Asquare

Bcube

Cdouble

Dmultiply

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing a method name that does not match the operation.

Using a method name that implies a different calculation.

The method name square matches the operation of returning the square of a number.

3fill in blank

hard

Fix the error in the code to define a method dynamically that returns a greeting with a given name.

Ruby

class Person
  define_method([1]) do |name|
    "Hi, #{name}!"
  end
end

Drag options to blanks, or click blank then click option'

A"greet"

B:greet

Cgreet

D'greet'

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around the method name instead of a symbol.

Using a bare word without colon which is undefined.

The method name must be a symbol, so :greet is correct. Using strings or bare words causes errors.

4fill in blank

hard

Fill both blanks to define dynamic methods for addition and subtraction.

Ruby

class MathOps
  define_method(:[1]) do |a, b|
    a + b
  end

  define_method(:[2]) do |a, b|
    a - b
  end
end

Drag options to blanks, or click blank then click option'

Aadd

Bsubtract

Cmultiply

Ddivide

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing method names with operations they don't perform.

Using method names for multiplication or division instead.

The first method is named add for addition, and the second is subtract for subtraction.

5fill in blank

hard

Fill all three blanks to define dynamic methods for multiplication, division, and modulus.

Ruby

class AdvancedMath
  define_method(:[1]) do |a, b|
    a * b
  end

  define_method(:[2]) do |a, b|
    a / b
  end

  define_method(:[3]) do |a, b|
    a % b
  end
end

Drag options to blanks, or click blank then click option'

Amultiply

Bdivide

Cmodulus

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names that don't match the operation.

Confusing modulus with division or multiplication.

The methods are named multiply, divide, and modulus matching their operations.

Practice

1. What does define_method do in Ruby?

easy

A. Creates a method dynamically during program execution

B. Deletes an existing method from a class

C. Calls a method with given arguments

D. Defines a constant value in a class

Solution

1. Step 1: Understand the purpose of define_method

   define_method allows creating methods while the program runs, not just when writing code.

2. Step 2: Compare options with define_method behavior

   Only Creates a method dynamically during program execution correctly describes dynamic method creation. Other options describe unrelated actions.

3. Final Answer:

   Creates a method dynamically during program execution -> Option A

4. Quick Check:

   define_method = dynamic method creation [OK]

Hint: define_method creates methods while program runs [OK]

Common Mistakes:

• Thinking define_method deletes methods
• Confusing define_method with method calls
• Assuming define_method defines constants

2. Which of the following is the correct syntax to define a method named greet dynamically inside a class using define_method?

easy

A. define_method('greet') { puts 'Hello' }

B. define_method :greet puts 'Hello' end

C. def define_method :greet puts 'Hello' end

D. define_method greet puts 'Hello'

Solution

1. Step 1: Recall correct define_method syntax

   The method name can be a symbol or string, and the method body is given as a block.

2. Step 2: Check each option for syntax correctness

   define_method('greet') { puts 'Hello' } uses parentheses and a block correctly. define_method :greet do puts 'Hello' end misses parentheses and block braces, causing syntax error. Options C and D have invalid syntax.

3. Final Answer:

   define_method('greet') { puts 'Hello' } -> Option A

4. Quick Check:

   define_method syntax = method name + block [OK]

Hint: Use parentheses and block for define_method syntax [OK]

Common Mistakes:

• Omitting parentheses around method name
• Not using a block for method body
• Writing def inside define_method incorrectly

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

class Person
  [:walk, :run].each do |action|
    define_method(action) { puts "I can #{action}" }
  end
end

p = Person.new
p.walk
p.run

medium

A. I can run
I can run

B. I can walk
I can run

C. NoMethodError for walk

D. SyntaxError

Solution

1. Step 1: Understand the loop and define_method usage

   The code loops over [:walk, :run] using each do |action| and defines two methods dynamically. Ruby blocks capture the loop variable action by value for each iteration, so each method captures its own action value.

2. Step 2: Trace method calls on instance

   p.walk prints "I can walk" and p.run prints "I can run" as expected.

3. Final Answer:

   I can walk I can run -> Option B

4. Quick Check:

   Blocks capture loop variable per iteration [OK]

Hint: Blocks in Ruby loops capture loop variable per iteration [OK]

Common Mistakes:

• Expecting same output for both methods (confuses closure capture)
• Thinking methods are not defined
• Confusing syntax with errors

4. Identify the error in this code snippet:

class Calculator
  [:add, :subtract].each do |op|
    define_method(op) do |a, b|
      if op == :add
        a + b
      else
        a - b
      end
    end
  end
end

calc = Calculator.new
puts calc.add(5, 3)
puts calc.subtract(5, 3)

medium

A. Wrong number of arguments passed to methods

B. Missing parentheses in method calls

C. The variable op inside the block always refers to the last symbol

D. Syntax error in define_method block

Solution

1. Step 1: Understand variable capture in blocks

   The block uses op inside the method body, but op is from the outer loop and will be the last value (:subtract) when methods run.

2. Step 2: Explain effect on method behavior

   Both methods will behave as if op == :subtract, so add will subtract incorrectly.

3. Final Answer:

   The variable op inside the block always refers to the last symbol -> Option C

4. Quick Check:

   Block variable capture causes wrong method behavior [OK]

Hint: Block variables may capture last loop value, causing bugs [OK]

Common Mistakes:

• Assuming op is unique per method
• Ignoring variable capture in closures
• Thinking syntax is wrong

5. How can you fix the following code so that each dynamically defined method behaves correctly?

class Calculator
  [:add, :subtract].each do |op|
    define_method(op) do |a, b|
      if op == :add
        a + b
      else
        a - b
      end
    end
  end
end

hard

A. Pass op as a method argument

B. Replace define_method with def keyword

C. Remove the if-else and always return a + b

D. Use a local variable inside the loop to capture op value before define_method

Solution

1. Step 1: Understand variable capture problem

   The variable op is shared in the loop and captured by the block, causing all methods to use the last value.

2. Step 2: Fix by assigning op to a local variable inside the loop

   Assign current_op = op inside the loop, then use current_op inside define_method block to capture correct value.

3. Final Answer:

   Use a local variable inside the loop to capture op value before define_method -> Option D

4. Quick Check:

   Local variable capture fixes closure bug [OK]

Hint: Assign loop variable to local var before define_method [OK]

Common Mistakes:

• Trying to pass op as method argument (won't fix closure)
• Replacing define_method with def (loses dynamic behavior)
• Ignoring the variable capture issue