Reduce/inject for accumulation in Ruby - Step-by-Step Execution

Concept Flow - Reduce/inject for accumulation

Start with initial accumulator

↓

Take next element from collection

↓

Apply block: accumulator + element

↓

Update accumulator with result

↓

More elements?

Yes→Repeat

No↓

Return accumulator

The reduce/inject method starts with an initial value and combines it with each element of a collection step-by-step, updating the accumulator until all elements are processed.

Execution Sample

Ruby

numbers = [1, 2, 3, 4]
result = numbers.reduce(0) { |sum, n| sum + n }
puts result

This code sums all numbers in the array using reduce, starting from 0.

Execution Table

Step	Accumulator (sum)	Current Element (n)	Block Operation	New Accumulator Value
1	0	1	0 + 1	1
2	1	2	1 + 2	3
3	3	3	3 + 3	6
4	6	4	6 + 4	10
End	10	-	-	All elements processed, return 10

💡 All elements processed, reduce returns final accumulator value 10

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
sum	0	1	3	6	10	10
n	-	1	2	3	4	-

Key Moments - 3 Insights

Why does the accumulator start at 0 and not the first element?

Because we explicitly gave 0 as the initial value in reduce(0). This means sum starts at 0, not the first array element. See execution_table step 1 where sum is 0 before adding 1.

What happens if we don't provide an initial value to reduce?

Then reduce uses the first element as the initial accumulator and starts from the second element. This changes how the block runs and the initial sum value. Our example shows the version with an explicit initial value.

How does the block update the accumulator?

At each step, the block takes the current accumulator and the current element, adds them, and returns the new accumulator. This is shown in the 'Block Operation' and 'New Accumulator Value' columns in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the accumulator value after processing the second element?

A 1

B 3

C 2

D 0

💡 Hint

Check the 'After 2' column in variable_tracker or step 2 row in execution_table.

At which step does the accumulator first become 6?

A Step 3

B Step 1

C Step 4

D End

💡 Hint

Look at the 'New Accumulator Value' column in execution_table for when sum is 6.

If the initial value was changed from 0 to 10, what would be the final accumulator value?

A 30

B 10

C 20

D 14

💡 Hint

Sum all elements (1+2+3+4=10) plus initial 10 equals 20.

Concept Snapshot

reduce/inject combines elements into one value
Syntax: collection.reduce(initial) { |acc, elem| ... }
Starts with initial accumulator
Block updates accumulator with each element
Returns final accumulator after all elements

Full Transcript

This visual trace shows how Ruby's reduce (also called inject) method works for accumulation. We start with an initial value (0) as the accumulator. Then for each element in the array, the block adds the element to the accumulator and returns the new sum. This repeats until all elements are processed. The final accumulator value is returned. The execution table shows each step's accumulator, current element, operation, and new accumulator. The variable tracker shows how sum and current element change over time. Key moments clarify why the initial value matters and how the block updates the accumulator. The quiz tests understanding of accumulator values at different steps and effects of changing the initial value.

Practice

1. What does the Ruby method inject do when used on an array?

easy

A. It combines all elements into a single value using a block.

B. It sorts the array in ascending order.

C. It removes duplicate elements from the array.

D. It returns the first element of the array.

Solution

1. Step 1: Understand the purpose of inject

   The inject method takes all elements of an array and combines them into one value using the block provided.

2. Step 2: Compare with other options

   Sorting, removing duplicates, or returning the first element are different methods like sort, uniq, or first.

3. Final Answer:

   It combines all elements into a single value using a block. -> Option A

4. Quick Check:

   inject combines elements = C [OK]

Hint: Remember: inject reduces many to one value [OK]

Common Mistakes:

• Confusing inject with sorting methods
• Thinking inject returns an array
• Assuming inject removes duplicates

2. Which of the following is the correct syntax to sum all elements in an array arr using inject?

easy

A. arr.inject { |sum, n| sum / n }

B. arr.inject(0) { |sum, n| sum + n }

C. arr.inject(1) { |sum, n| sum * n }

D. arr.inject { |sum, n| sum - n }

Solution

1. Step 1: Identify the correct initial value and operation

   To sum elements, start with 0 and add each element: inject(0) { |sum, n| sum + n }.

2. Step 2: Check other options

   arr.inject { |sum, n| sum - n } subtracts, C multiplies starting at 1, A divides. Only D sums correctly.

3. Final Answer:

   arr.inject(0) { |sum, n| sum + n } -> Option B

4. Quick Check:

   Sum with inject = D [OK]

Hint: Sum needs 0 start and + inside block [OK]

Common Mistakes:

• Starting sum with 1 instead of 0
• Using wrong operation like subtraction
• Omitting initial value causing errors

3. What is the output of this Ruby code?

numbers = [2, 3, 4]
result = numbers.inject(1) { |product, n| product * n }
puts result

medium

A. Error

B. 9

C. 10

D. 24

Solution

1. Step 1: Understand the initial value and operation

   The initial value is 1, and each element multiplies the accumulator: 1*2=2, 2*3=6, 6*4=24.

2. Step 2: Calculate the final product

   The final result after all multiplications is 24.

3. Final Answer:

   24 -> Option D

4. Quick Check:

   2*3*4 = 24 [OK]

Hint: Multiply with inject starts at 1 [OK]

Common Mistakes:

• Adding instead of multiplying
• Starting with 0 causing zero result
• Confusing output with sum

4. Identify the error in this code snippet:

arr = [1, 2, 3]
sum = arr.inject { |total, n| total + n }
puts sum

medium

A. No error; code works fine.

B. Missing initial value causes incorrect sum.

C. Block parameters are reversed.

D. inject cannot be used without a symbol.

Solution

1. Step 1: Check if initial value is required

   When no initial value is given, inject uses the first element as the start and iterates from the second element.

2. Step 2: Verify the sum calculation

   It correctly sums 1 + 2 + 3 = 6 without error.

3. Final Answer:

   No error; code works fine. -> Option A

4. Quick Check:

   inject without initial value sums correctly = A [OK]

Hint: inject uses first element as start if no initial value [OK]

Common Mistakes:

• Assuming initial value is always required
• Thinking block parameters order is wrong
• Believing inject needs symbol argument

5. Given an array of hashes representing products with keys :name and :price, how can you use inject to find the total price of all products?

products = [
  { name: "Book", price: 12 },
  { name: "Pen", price: 3 },
  { name: "Notebook", price: 7 }
]

hard

A. products.inject { |total, product| total + product.name }

B. products.inject(1) { |total, product| total * product[:price] }

C. products.inject(0) { |total, product| total + product[:price] }

D. products.inject(0) { |total, product| total + product.price }

Solution

1. Step 1: Access the price key correctly

   Each product is a hash, so access price with product[:price].

2. Step 2: Sum prices starting at 0

   Start with 0 and add each price to get total price.

3. Step 3: Check other options

   products.inject { |total, product| total + product.name } uses dot notation which is invalid for hashes, C multiplies prices, D uses dot notation again.

4. Final Answer:

   products.inject(0) { |total, product| total + product[:price] } -> Option C

5. Quick Check:

   Sum prices with inject and hash keys = B [OK]

Hint: Use hash keys with [:key] inside inject block [OK]

Common Mistakes:

• Using dot notation for hash keys
• Multiplying prices instead of summing
• Starting sum at 1 instead of 0