Compact for removing nil values in Ruby - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to remove nil values from the array.

Ruby

array = [1, nil, 2, nil, 3]
clean_array = array.[1]

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

Acompact

Bflatten

Cuniq

Dsort

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'flatten' which changes nested arrays instead of removing nils.

Using 'uniq' which removes duplicates but keeps nils.

Using 'sort' which orders elements but does not remove nils.

The compact method removes all nil values from an array.

2fill in blank

medium

Complete the code to remove nil values from the hash values.

Ruby

hash = {a: 1, b: nil, c: 3, d: nil}
clean_hash = hash.select { |_, v| v [1] }

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

A>= 0

B== nil

C!= nil

D< 3

Attempts:

3 left

💡 Hint

Common Mistakes

Using '== nil' which keeps only nil values.

Using comparison operators that don't relate to nil.

The block keeps pairs where the value is not nil, effectively removing nil values.

3fill in blank

hard

Fix the error in the code to remove nil values from the array.

Ruby

numbers = [5, nil, 7, nil, 9]
numbers = numbers.[1]()

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

Acompact!

Bcompact

Ccompacted

Dremove_nil

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'compact!' without parentheses which can cause syntax errors.

Using non-existent methods like 'compacted' or 'remove_nil'.

The method compact returns a new array without nils. compact! modifies in place but requires parentheses.

4fill in blank

hard

Complete the code to create a hash with word lengths, excluding nil words.

Ruby

words = ["apple", nil, "pear", nil, "plum"]
lengths = {word => 0: word.{BLANK_2}}

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

A =>

B:

Clength

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using colon ':' instead of '=>', which is invalid in this context.

Using 'length' instead of 'size' (both work but only one is correct here).

The hash uses word => 0 syntax and size method to get word length.

5fill in blank

hard

Fill all three blanks to create a hash of uppercase words and their lengths, excluding nils.

Ruby

words = ["dog", nil, "cat", "bird"]
result = { [1]: [2] for word in words if word [3] nil }

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

Aword.upcase()

Blen(word)

C!=

Dword.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'len(word)' which is Python syntax, not Ruby.

Using '==' instead of '!=' to exclude nil values.

The key is the uppercase word, the value is its length, and the condition excludes nils.

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