Array methods (length, include?, flatten) in Ruby - Step-by-Step Execution

Concept Flow - Array methods (length, include?, flatten)

Start with Array

↓

Call length

→Return number of elements

↓

Call include?(item)

→Check each element

↓

If found, return true

↓

If not found, return false

↓

Call flatten

→Check each element

↓

If element is array, expand it

↓

If not, keep element

↓

Return new flattened array

↓

End

Start with an array, then call length to get count, include? to check presence, or flatten to expand nested arrays into one.

Execution Sample

Ruby

arr = [1, [2, 3], 4]
len = arr.length
has_two = arr.include?(2)
flat = arr.flatten

This code gets the length of arr, checks if 2 is included, and flattens nested arrays.

Execution Table

Step	Action	Array State	Variable	Value	Output
1	Initialize arr	[1, [2, 3], 4]	arr	[1, [2, 3], 4]
2	Call arr.length	[1, [2, 3], 4]	len	3	3
3	Call arr.include?(2)	[1, [2, 3], 4]	has_two	false	false
4	Call arr.flatten	[1, [2, 3], 4]	flat	[1, 2, 3, 4]	[1, 2, 3, 4]
5	End	[1, [2, 3], 4]			Execution complete

💡 All methods called and results stored; arr remains unchanged.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
arr	[1, [2, 3], 4]	[1, [2, 3], 4]	[1, [2, 3], 4]	[1, [2, 3], 4]	[1, [2, 3], 4]
len	undefined	3	3	3	3
has_two	undefined	undefined	false	false	false
flat	undefined	undefined	undefined	[1, 2, 3, 4]	[1, 2, 3, 4]

Key Moments - 3 Insights

Why does arr.include?(2) return false even though 2 is inside a nested array?

include? checks only the top-level elements. Since 2 is inside [2, 3], which is a nested array, include? does not find 2 directly in arr (see step 3 in execution_table).

Does flatten change the original array arr?

No, flatten returns a new array with nested arrays expanded but does not modify arr itself (see variable_tracker for arr's unchanged state after step 4).

What does length count when the array has nested arrays?

length counts only the top-level elements, so nested arrays count as one element each (see step 2 in execution_table where length is 3).

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What is the value of has_two after calling arr.include?(2)?

A false

B true

C nil

D error

💡 Hint

Check the 'Value' column at step 3 in execution_table.

At which step does the array get flattened into a single-level array?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the action 'Call arr.flatten' in execution_table.

If arr was [1, 2, 3], what would arr.include?(2) return?

A false

B true

C nil

D error

💡 Hint

include? returns true if the element is directly in the array; see variable_tracker for has_two.

Concept Snapshot

Array methods in Ruby:
- length: returns number of top-level elements
- include?(item): checks if item is a top-level element
- flatten: returns new array with nested arrays expanded
Original array stays unchanged by flatten.

Full Transcript

We start with an array arr containing numbers and a nested array. Calling length returns the count of top-level elements, which is 3. include?(2) checks if 2 is directly inside arr, but since 2 is inside a nested array, it returns false. flatten returns a new array where nested arrays are expanded into one level, resulting in [1, 2, 3, 4]. The original array arr remains unchanged throughout. These methods help us count, check presence, and simplify nested arrays easily.

Practice

1. What does the length method do when called on an array in Ruby?

easy

A. Returns the number of elements in the array

B. Checks if an element exists in the array

C. Flattens nested arrays into a single array

D. Removes duplicate elements from the array

Solution

1. Step 1: Understand the purpose of length

   The length method counts how many items are inside an array.

2. Step 2: Compare with other methods

   include? checks for presence, flatten merges nested arrays, so they do different things.

3. Final Answer:

   Returns the number of elements in the array -> Option A

4. Quick Check:

   length = count items [OK]

Hint: Remember length counts items, not checks or changes arrays [OK]

Common Mistakes:

• Confusing length with include? method
• Thinking length flattens nested arrays
• Assuming length removes duplicates

2. Which of the following is the correct syntax to check if the array arr includes the number 5?

easy

A. arr.include(5)

B. arr.includes?(5)

C. arr.has?(5)

D. arr.include?(5)

Solution

1. Step 1: Recall the correct method name and syntax

   The method to check presence is include? with a question mark at the end.

2. Step 2: Verify method call on array

   It should be called as arr.include?(5), not include or includes?.

3. Final Answer:

   arr.include?(5) -> Option D

4. Quick Check:

   Correct method is include? with question mark [OK]

Hint: Remember Ruby methods with ? end with a question mark [OK]

Common Mistakes:

• Omitting the question mark in include?
• Using incorrect method names like includes? or has?
• Using parentheses incorrectly

3. What is the output of the following Ruby code?

arr = [1, [2, 3], [4, [5]]]
puts arr.flatten.length

medium

A. 5

B. 3

C. 6

D. 7

Solution

1. Step 1: Apply flatten to the array

   The nested array [1, [2, 3], [4, [5]]] becomes [1, 2, 3, 4, 5] after flattening.

2. Step 2: Calculate the length of the flattened array

   The flattened array has 5 elements, so length returns 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Flattened array length = 5 [OK]

Hint: Flatten first, then count elements with length [OK]

Common Mistakes:

• Counting nested arrays as single elements
• Forgetting flatten changes nested arrays
• Miscounting elements after flatten

4. The following code is intended to check if the array nums contains the number 10, but it raises an error. What is the problem?

nums = [5, 10, 15]
if nums.include(10)
  puts "Found 10"
end

medium

A. The array should be flattened before checking

B. The method should be include? with a question mark

C. The number 10 should be a string "10"

D. The if statement syntax is incorrect

Solution

1. Step 1: Identify the method name error

   The method to check presence is include? with a question mark, not include.

2. Step 2: Understand why error occurs

   Calling include without question mark is undefined, causing an error.

3. Final Answer:

   The method should be include? with a question mark -> Option B

4. Quick Check:

   Use include? to check presence [OK]

Hint: Check method names carefully; include? needs question mark [OK]

Common Mistakes:

• Using include without question mark
• Thinking flatten is needed to check presence
• Confusing number and string types
• Miswriting if statement syntax

5. Given the nested array data = [[1, 2], [3, [4, 5]], 6], which Ruby code correctly flattens it and checks if the number 4 is included?

hard

A. data.include?(4.flatten)

B. data.include?(4).flatten

C. data.flatten.include?(4)

D. data.flatten.include(4)

Solution

1. Step 1: Flatten the nested array first

   Use data.flatten to convert nested arrays into a single-level array.

2. Step 2: Check if 4 is included in the flattened array

   Call include?(4) on the flattened array to get true or false.

3. Final Answer:

   data.flatten.include?(4) -> Option C

4. Quick Check:

   Flatten then include? is correct order [OK]

Hint: Flatten first, then check inclusion with include? [OK]

Common Mistakes:

• Calling include? before flatten
• Using include without question mark
• Trying to flatten the number 4
• Incorrect method chaining order