Lambda creation and behavior in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a lambda that adds 5 to its input.

Ruby

add_five = ->(x) { x [1] 5 }

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

A/

B-

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using - instead of + will subtract instead of add.

Using * or / will multiply or divide, which is not the goal.

The lambda adds 5 to the input using the + operator.

2fill in blank

medium

Complete the code to call the lambda with argument 10.

Ruby

result = add_five.[1](10)

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

Aexecute

Bcall

Crun

Dapply

Attempts:

3 left

💡 Hint

Common Mistakes

Using run, execute, or apply will cause errors because these methods don't exist for lambdas.

In Ruby, lambdas are called using the call method.

3fill in blank

hard

Fix the error in the lambda creation syntax.

Ruby

my_lambda = lambda [1] |x| x * 2 }

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

A[

B(

C{

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or square brackets instead of curly braces causes syntax errors.

The correct syntax for lambda creation uses curly braces {} around the block.

4fill in blank

hard

Fill both blanks to create a lambda that checks if a number is even.

Ruby

is_even = ->(n) { n [1] 2 [2] 0 }

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

A%

B==

C!=

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using != instead of == will check for odd numbers.

Using + instead of % will add numbers, not check evenness.

The lambda uses the modulo operator % to get the remainder and checks if it equals 0 with ==.

5fill in blank

hard

Fill both blanks to create a lambda that returns the uppercase version of a string if its length is greater than 3.

Ruby

transform = ->(s) { s.length [1] 3 ? s.[2] : s }

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

A<

Bupcase

C>

Ddowncase

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > will invert the condition.

Using downcase instead of upcase changes the string to lowercase.

The lambda checks if the string length is greater than 3 using >. If true, it returns the uppercase string with upcase, otherwise returns the original string.

Practice

1. What is a lambda in Ruby?

easy

A. A type of loop that repeats code multiple times

B. A special variable that holds numbers only

C. A method that automatically runs when a program starts

D. A small block of code stored in a variable that can be called later

Solution

1. Step 1: Understand what a lambda represents

   A lambda is a reusable piece of code stored in a variable, like a mini-function.

2. Step 2: Compare with other options

   Options A, C, and D describe loops, methods, or variables, not lambdas.

3. Final Answer:

   A small block of code stored in a variable that can be called later -> Option D

4. Quick Check:

   Lambda = reusable code block [OK]

Hint: Lambdas are like mini-functions stored in variables [OK]

Common Mistakes:

• Confusing lambdas with loops
• Thinking lambdas run automatically
• Believing lambdas hold only numbers

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

easy

A. ->(x) { x * 2 }

B. def lambda(x) x * 2 end

C. lambda(x) => x * 2

D. lambda(x) { x * 2 }

Solution

1. Step 1: Identify valid lambda syntax

   In Ruby, lambdas can be created using the arrow syntax ->(params) { code } or lambda { |params| code }.

2. Step 2: Check each option

   lambda(x) { x * 2 }: invalid syntax (lambda keyword expects block with |params|, not parenthesized args). def lambda(x) x * 2 end: method definition, not a lambda. lambda(x) => x * 2: invalid syntax. ->(x) { x * 2 }: correct arrow syntax.

3. Final Answer:

   ->(x) { x * 2 } -> Option A

4. Quick Check:

   Arrow syntax ->(x) { ... } creates lambda [OK]

Hint: Use ->(params) { code } or lambda { |params| code } [OK]

Common Mistakes:

• Using def instead of lambda
• Incorrect arrow syntax
• Confusing method and lambda syntax

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

my_lambda = ->(x) { x + 3 }
puts my_lambda.call(4)

medium

A. 3

B. 4

C. 7

D. Error

Solution

1. Step 1: Understand the lambda behavior

   The lambda adds 3 to the input number x.

2. Step 2: Calculate the output

   Calling my_lambda.call(4) computes 4 + 3 = 7.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   4 + 3 = 7 [OK]

Hint: Call lambda with .call and input to get output [OK]

Common Mistakes:

• Forgetting to use .call to invoke lambda
• Confusing input and output values
• Expecting syntax error

4. What is wrong with this Ruby code?

my_lambda = lambda { |x, y| x + y }
puts my_lambda.call(5)

medium

A. It will raise an ArgumentError

B. It will print nil

C. It will print 5

D. It will raise a SyntaxError

Solution

1. Step 1: Check lambda argument requirements

   Lambdas check arguments strictly. This lambda expects 2 arguments (x and y).

2. Step 2: Analyze the call with one argument

   Calling my_lambda.call(5) provides only 1 argument, causing ArgumentError.

3. Final Answer:

   It will raise an ArgumentError -> Option A

4. Quick Check:

   Lambda argument count mismatch = ArgumentError [OK]

Hint: Lambdas need exact argument count or error [OK]

Common Mistakes:

• Assuming missing arguments default to nil
• Expecting no error on fewer arguments
• Confusing lambdas with procs (which are lenient)

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

def test_lambda
  l = -> { return "Inside lambda" }
  result = l.call
  return "Outside lambda"
end
puts test_lambda

hard

A. Inside lambda

B. Outside lambda

C. nil

D. Error

Solution

1. Step 1: Understand lambda return behavior

   Return inside a lambda exits only the lambda, not the enclosing method.

2. Step 2: Trace method execution

   The lambda returns "Inside lambda" to variable result, but method continues and returns "Outside lambda".

3. Final Answer:

   Outside lambda -> Option B

4. Quick Check:

   Lambda return exits lambda only, method returns after [OK]

Hint: Return inside lambda exits lambda, not method [OK]

Common Mistakes:

• Thinking return inside lambda exits method
• Expecting "Inside lambda" as output
• Confusing lambda with proc return behavior