Compact for removing nil values in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of using compact on an array with nils?

Consider the following Ruby code:

arr = [1, nil, 2, nil, 3]
result = arr.compact
puts result.inspect

What will be printed?

Ruby

arr = [1, nil, 2, nil, 3]
result = arr.compact
puts result.inspect

A [1, 2, 3]

B [1, nil, 2, nil, 3]

C [nil, nil]

D Error: undefined method 'compact'

💡 Hint

compact removes all nil values from the array.

The compact method returns a new array without any nil elements. So all nils are removed, leaving only the numbers.

❓ Predict Output

intermediate

What does compact! return when no nils are present?

Look at this Ruby code:

arr = [4, 5, 6]
result = arr.compact!
puts result.inspect

What will be printed?

Ruby

arr = [4, 5, 6]
result = arr.compact!
puts result.inspect

A []

B [4, 5, 6]

C nil

D Error: undefined method 'compact!'

💡 Hint

compact! returns nil if no changes were made.

The compact! method modifies the array in place and returns nil if no nil elements were removed.

🔧 Debug

advanced

Why does this code raise an error?

This Ruby code is intended to remove nils from a hash's values:

h = {a: 1, b: nil, c: 3}
h.compact

But it raises an error. Why?

Ruby

h = {a: 1, b: nil, c: 3}
h.compact

A compact removes keys with nil values automatically

B Hash does not have a compact method in Ruby 3.12

C compact only works on arrays, not hashes

D compact requires a block for hashes

💡 Hint

Check if Hash class supports compact method in this Ruby version.

In Ruby 2.4 and later, Hash#compact is available, but if the environment is older or the method is undefined, calling compact on a hash raises NoMethodError.

❓ Predict Output

advanced

What is the output of chaining compact with map?

What does this Ruby code print?

arr = [nil, 2, nil, 4]
result = arr.compact.map { |x| x * 3 }
puts result.inspect

Ruby

arr = [nil, 2, nil, 4]
result = arr.compact.map { |x| x * 3 }
puts result.inspect

A [6, 12]

B [nil, 6, nil, 12]

C [2, 4]

D Error: undefined method 'map' for nil

💡 Hint

compact removes nils before map multiplies each number by 3.

compact removes nils, leaving [2,4]. Then map multiplies each by 3, resulting in [6,12].

🧠 Conceptual

expert

How many items remain after compact on nested arrays?

Given this Ruby code:

arr = [1, nil, [2, nil], [nil, 3], nil]
result = arr.compact
puts result.size

What number will be printed?

Ruby

arr = [1, nil, [2, nil], [nil, 3], nil]
result = arr.compact
puts result.size

A 2

B 5

C 4

D 3

💡 Hint

compact removes only top-level nils, not inside nested arrays.

compact removes the nil elements at the top level, so the array becomes [1, [2, nil], [nil, 3]]. This has 3 elements.

Practice

1.

What does the Ruby method compact do when called on an array?

easy

A. It returns a new array without any nil values.

B. It removes all duplicate values from the array.

C. It sorts the array in ascending order.

D. It changes all nil values to zero.

Solution

1. Step 1: Understand the purpose of compact

   The compact method creates a new array by removing all nil values from the original array.

2. Step 2: Compare with other options

   Other options describe different array methods or behaviors, but only compact removes nil values without modifying the original array.

3. Final Answer:

   It returns a new array without any nil values. -> Option A

4. Quick Check:

   compact removes nil values = B [OK]

Hint: Remember: compact removes nil, keeps original unchanged [OK]

Common Mistakes:

• Confusing compact with uniq (removes duplicates)
• Thinking compact sorts the array
• Believing compact replaces nil with zero

2.

Which of the following is the correct syntax to remove nil values from an array arr without changing arr itself?

arr = [1, nil, 2, nil, 3]

easy

A. arr.delete(nil)

B. arr.compact!

C. arr.remove_nil

D. arr.compact

Solution

1. Step 1: Identify method that returns new array without nil

   compact returns a new array without nil values and does not modify the original array.

2. Step 2: Understand difference with compact!

   compact! modifies the original array, so it changes arr. delete(nil) removes nil but modifies arr. remove_nil is not a Ruby method.

3. Final Answer:

   arr.compact -> Option D

4. Quick Check:

   compact returns new array, compact! modifies [OK]

Hint: Use compact for new array, compact! to modify original [OK]

Common Mistakes:

• Using compact! when original array should stay unchanged
• Using delete(nil) which modifies the original array
• Assuming remove_nil is a valid Ruby method

3.

What is the output of the following Ruby code?

arr = [nil, 5, nil, 10]
new_arr = arr.compact
puts new_arr.inspect
puts arr.inspect

medium

A. [5, 10]
[nil, 5, nil, 10]

B. [nil, 5, nil, 10]
[5, 10]

C. [5, 10]
[5, 10]

D. [nil, nil]
[nil, 5, nil, 10]

Solution

1. Step 1: Understand what compact returns

   compact returns a new array without nil values, so new_arr is [5, 10].

2. Step 2: Check if original array changes

   The original array arr remains unchanged as [nil, 5, nil, 10].

3. Final Answer:

   [5, 10] [nil, 5, nil, 10] -> Option A

4. Quick Check:

   compact returns new array, original unchanged = A [OK]

Hint: compact returns new array; original stays same [OK]

Common Mistakes:

• Assuming original array changes after compact
• Confusing compact with compact! which modifies original
• Misreading output order

4.

Consider this Ruby code snippet:

arr = [1, nil, 2, nil, 3]
arr.compact
puts arr.inspect

Why does the output still include nil values?

medium

A. Because arr was reassigned incorrectly.

B. Because compact does not remove nil values at all.

C. Because compact returns a new array but does not modify arr.

D. Because puts cannot print arrays correctly.

Solution

1. Step 1: Understand compact behavior

   compact returns a new array without nil values but does not change the original array.

2. Step 2: Check why arr still has nil

   Since arr.compact was called without assignment, arr remains unchanged and still contains nil.

3. Final Answer:

   Because compact returns a new array but does not modify arr. -> Option C

4. Quick Check:

   compact returns new array, original unchanged = D [OK]

Hint: Use compact! or assign compact result to change original [OK]

Common Mistakes:

• Thinking compact modifies original array
• Believing puts cannot print arrays properly
• Assuming arr was reassigned automatically

5.

You have an array data = [nil, 0, false, '', nil, 5]. You want to remove only nil values but keep 0, false, and empty strings. Which code correctly does this?

hard

A. clean_data = data.reject!(&:nil?)

B. clean_data = data.compact

C. clean_data = data.select { |v| v }

D. clean_data = data.delete_if { |v| v.nil? }

Solution

1. Step 1: Understand what compact does

   compact removes only nil values and keeps all other values including 0, false, and empty strings.

2. Step 2: Analyze other options

   select { |v| v } removes all falsy values (nil, false, 0 is truthy in Ruby but empty string is truthy), so it removes false. reject!(&:nil?) modifies the original array. delete_if { |v| v.nil? } modifies original array.

3. Step 3: Choose best option for new array without nil

   compact is simplest and returns new array without modifying original.

4. Final Answer:

   clean_data = data.compact -> Option B

5. Quick Check:

   compact removes nil only, keeps false and empty string = C [OK]

Hint: Use compact to remove nil only, keep false and empty strings [OK]

Common Mistakes:

• Using select which removes false values
• Using delete_if which modifies original array
• Using reject! which modifies the original array