Array slicing and ranges in Ruby - Mini Project: Build & Apply

Array slicing and ranges

📖 Scenario: You are working with a list of daily temperatures recorded over a week. You want to extract specific parts of this list to analyze temperature trends.

🎯 Goal: Learn how to use array slicing and ranges in Ruby to select parts of an array.

📋 What You'll Learn

Create an array called temperatures with exact values for 7 days

Create a variable called start_day to mark the beginning index for slicing

Use array slicing with a range to get a subarray of temperatures

Print the sliced array to show the selected temperatures

💡 Why This Matters

🌍 Real World

Selecting parts of data from a list is common when analyzing time series like temperatures, sales, or website visits.

💼 Career

Understanding array slicing and ranges helps in data processing, filtering, and preparing data for reports or visualizations.

1

Create the temperatures array

Create an array called temperatures with these exact values: 22, 24, 19, 23, 25, 20, 18

Ruby

# Create the temperatures array with 7 values
# Your code here

Hint

Use square brackets [] to create an array and separate values with commas.

2

Set the start day index

Create a variable called start_day and set it to 2 to mark the starting index for slicing

Ruby

temperatures = [22, 24, 19, 23, 25, 20, 18]
# Create start_day variable and set it to 2
# Your code here

Hint

Just assign the number 2 to the variable start_day.

3

Slice the array using a range

Create a variable called selected_temps and assign it the slice of temperatures from start_day to index 4 using a range

Ruby

temperatures = [22, 24, 19, 23, 25, 20, 18]
start_day = 2
# Slice temperatures from start_day to 4 and assign to selected_temps
# Your code here

Hint

Use array[start..end] syntax to slice with a range.

4

Print the selected temperatures

Write a puts statement to print the selected_temps array

Ruby

temperatures = [22, 24, 19, 23, 25, 20, 18]
start_day = 2
selected_temps = temperatures[start_day..4]
# Print selected_temps
# Your code here

Hint

Use puts selected_temps.inspect to print the array in a readable format.

Practice

1. What does the expression arr[1..3] do when arr = [10, 20, 30, 40, 50]?

easy

A. Returns a new array with elements at indexes 1, 2, and 3

B. Returns a new array with elements at indexes 1 and 3 only

C. Returns a new array with elements at indexes 1 and 2 only

D. Returns a single element at index 3

Solution

1. Step 1: Understand the range operator '..'

   The range 1..3 includes both 1 and 3, so it covers indexes 1, 2, and 3.

2. Step 2: Apply slicing to the array

   Slicing arr[1..3] returns elements at indexes 1, 2, and 3, which are 20, 30, and 40.

3. Final Answer:

   Returns a new array with elements at indexes 1, 2, and 3 -> Option A

4. Quick Check:

   Range '..' includes end index = elements 20, 30, 40 [OK]

Hint: Remember '..' includes the end index in slicing [OK]

Common Mistakes:

• Thinking '..' excludes the end index
• Confusing indexes with values
• Assuming slicing changes the original array

2. Which of the following is the correct syntax to get elements from index 2 up to but not including index 5 in Ruby array arr?

easy

A. arr[2...5]

B. arr[2:5]

C. arr[2..5]

D. arr[2-5]

Solution

1. Step 1: Identify the range operator for excluding end

   In Ruby, ... excludes the end index, so 2...5 means indexes 2, 3, and 4.

2. Step 2: Check syntax correctness

   Only arr[2...5] uses valid Ruby syntax for slicing excluding the end index.

3. Final Answer:

   arr[2...5] -> Option A

4. Quick Check:

   Use '...' to exclude end index in range [OK]

Hint: Use '...' to exclude the last index in range slicing [OK]

Common Mistakes:

• Using '..' when exclusion is needed
• Using Python-style slicing syntax like ':'
• Using invalid range syntax like '2-5'

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

arr = [5, 10, 15, 20, 25]
slice = arr[1...4]
puts slice.inspect

medium

A. [10, 15, 20, 25]

B. [15, 20, 25]

C. [10, 15, 20]

D. [5, 10, 15]

Solution

1. Step 1: Understand the slicing range

   The range 1...4 includes indexes 1, 2, and 3 but excludes 4.

2. Step 2: Extract elements at these indexes

   Elements at indexes 1, 2, 3 are 10, 15, and 20 respectively.

3. Final Answer:

   [10, 15, 20] -> Option C

4. Quick Check:

   Range '...' excludes end index = [10, 15, 20] [OK]

Hint: Remember '...' excludes the last index in slicing [OK]

Common Mistakes:

• Including element at index 4 mistakenly
• Confusing indexes with values
• Printing original array instead of slice

4. Identify the error in the following Ruby code snippet:

arr = [1, 2, 3, 4, 5]
slice = arr[2..6]
puts slice.inspect

medium

A. Syntax error due to invalid range

B. Range end index 6 is out of bounds but Ruby returns elements up to the end of the array

C. Runtime error because index 6 does not exist

D. slice will be empty array because range is invalid

Solution

1. Step 1: Check the range indexes against array size

   The array has indexes 0 to 4. The range 2..6 goes beyond the last index.

2. Step 2: Understand Ruby slicing behavior for out-of-bounds

   Ruby returns elements from index 2 to the end (indexes 2, 3, 4) and ignores indexes beyond 4 without error.

3. Final Answer:

   Range end index 6 is out of bounds but Ruby returns elements up to the end of the array -> Option B

4. Quick Check:

   Ruby slices safely even if range exceeds array size [OK]

Hint: Ruby slicing ignores out-of-bound indexes without error [OK]

Common Mistakes:

• Expecting runtime or syntax error
• Assuming slice will be empty
• Confusing Ruby with other languages that error here

5. Given arr = [2, 4, 6, 8, 10, 12], which expression returns a new array with every second element starting from index 1 up to index 5?

hard

A. arr[1..5].select.with_index { |_, i| i.even? }

B. arr[1..5].select.with_index { |_, i| i.odd? }

C. arr[1...6].values_at(*arr[1...6].each_index.select(&:even?))

D. arr[1..5].values_at(*arr[1..5].each_index.select(&:odd?))

Solution

1. Step 1: Slice array from index 1 to 5

   arr[1..5] gives [4, 6, 8, 10, 12].

2. Step 2: Select every second element starting from index 1 of the slice

   Indexes inside the slice are 0 to 4. Selecting odd indexes (1, 3) gives elements 6 and 10.

3. Step 3: Check options for correct syntax and output

   arr[1..5].values_at(*arr[1..5].each_index.select(&:odd?)) uses values_at with odd indexes on the slice correctly, returning [6, 10].

4. Final Answer:

   arr[1..5].values_at(*arr[1..5].each_index.select(&:odd?)) -> Option D

5. Quick Check:

   Use values_at with odd indexes on slice for every second element [OK]

Hint: Use values_at with selected indexes for custom slicing [OK]

Common Mistakes:

• Confusing odd/even indexes inside the slice
• Using select without values_at returns elements, not indexes
• Using wrong range operator causing off-by-one errors