Flat_map for nested flattening in Ruby - Step-by-Step Execution

Concept Flow - Flat_map for nested flattening

Start with nested array

↓

Apply flat_map

↓

For each element: map to inner array

↓

Flatten one level

↓

Result: single-level array

flat_map takes each element, maps it to an inner array, then flattens the result by one level to create a single-level array.

Execution Sample

Ruby

nested = [[1, 2], [3, 4], [5]]
flat = nested.flat_map { |arr| arr }
puts flat.inspect

This code flattens one level of nested arrays into a single array using flat_map.

Execution Table

Step	Current Element (arr)	Mapping Result	Accumulated Result
1	[1, 2]	[1, 2]	[1, 2]
2	[3, 4]	[3, 4]	[1, 2, 3, 4]
3	[5]	[5]	[1, 2, 3, 4, 5]
4	No more elements	N/A	[1, 2, 3, 4, 5]

💡 All nested arrays processed; flat_map returns the flattened array.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
nested	[[1, 2], [3, 4], [5]]	[[1, 2], [3, 4], [5]]	[[1, 2], [3, 4], [5]]	[[1, 2], [3, 4], [5]]	[[1, 2], [3, 4], [5]]
flat	[]	[1, 2]	[1, 2, 3, 4]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]

Key Moments - 2 Insights

Why does flat_map flatten only one level instead of all nested levels?

flat_map applies the block to each element and then flattens the result by one level only, as shown in execution_table rows 1-3 where each inner array is added directly without deeper flattening.

What happens if the block returns a non-array element?

If the block returns a non-array, flat_map treats it as a single element and adds it to the result, flattening only one level. This is implied by the mapping result column in the execution_table.

Visual Quiz - 3 Questions

Look at the execution table, what is the accumulated result after step 2?

A [1, 2, 3, 4]

B [1, 2]

C [3, 4]

D [1, 2, 3]

💡 Hint

Check the 'Accumulated Result' column at step 2 in the execution_table.

At which step does flat_map finish processing all elements?

A Step 3

B Step 4

C Step 2

D Step 1

💡 Hint

Look for the step where 'No more elements' appears in the 'Current Element' column.

If the block returned a single number instead of an array, how would the accumulated result change after step 1?

A [1, 2]

B [[1, 2]]

C [1]

D [[1]]

💡 Hint

Recall flat_map flattens one level; a single number would be added as is, see 'Mapping Result' in execution_table.

Concept Snapshot

flat_map applies a block to each element of a nested array,
then flattens the result by one level.
Syntax: array.flat_map { |element| ... }
Useful to combine map and flatten in one step.
Only flattens one level deep.

Full Transcript

This visual execution shows how Ruby's flat_map works to flatten nested arrays by one level. Starting with a nested array, flat_map applies a block to each inner array element, then combines all results into a single flat array. The execution table tracks each step, showing the current element, the mapping result, and the accumulated result. The variable tracker shows how the 'flat' variable grows after each step. Key moments clarify common confusions about flattening depth and block return types. The quiz tests understanding of the step-by-step process and effects of different block returns.