Array basics in Rust - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust code?

Consider the following Rust program that works with arrays. What will it print?

Rust

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let slice = &arr[1..4];
    println!("{:?}", slice);
}

A [10, 20, 30]

B [20, 30, 40]

C [20, 30, 40, 50]

D [10, 20, 30, 40]

💡 Hint

Remember that slicing in Rust uses the start index inclusive and end index exclusive.

The slice &arr[1..4] includes elements at indices 1, 2, and 3, which are 20, 30, and 40.

🧠 Conceptual

intermediate

How many elements does this array have?

Given the Rust array declaration below, how many elements does numbers contain?

Rust

let numbers: [i32; 6] = [1, 2, 3, 4, 5, 6];

A 5

B 7

C 6

D 0

💡 Hint

The number after the semicolon in the type declaration shows the array length.

The array numbers is declared with length 6, so it contains 6 elements.

🔧 Debug

advanced

What error does this Rust code produce?

Examine the Rust code below. What error will the compiler report?

Rust

fn main() {
    let arr = [1, 2, 3];
    let x = arr[3];
    println!("{}", x);
}

A Index out of bounds at runtime

B Syntax error: missing semicolon

C No error, prints 3

D Compile-time error: index out of bounds

💡 Hint

Rust checks array bounds at runtime for indexing.

Accessing arr[3] is out of bounds since valid indices are 0, 1, 2. This causes a runtime panic.

📝 Syntax

advanced

Which option correctly declares a fixed-size array of 4 zeros?

Choose the Rust code that correctly declares an array of four zeros.

A let arr = [0; 4];

B let arr = [0, 4];

C let arr = [4; 0];

D let arr = [0] * 4;

💡 Hint

Rust uses the syntax [value; count] to create arrays with repeated values.

Option A uses the correct syntax to create an array with four zeros. Option A creates an array with two elements. Option A creates an empty array (invalid). Option A is invalid syntax in Rust.

🚀 Application

expert

What is the sum of elements in this array after modification?

Consider the Rust code below. What is the value of sum after running?

Rust

fn main() {
    let mut arr = [1, 2, 3, 4, 5];
    for i in 0..arr.len() {
        arr[i] *= 2;
    }
    let sum: i32 = arr.iter().sum();
    println!("{}", sum);
}

A 25

B 15

C 20

D 30

💡 Hint

Each element is doubled before summing.

The original array is [1,2,3,4,5]. After doubling: [2,4,6,8,10]. Sum is 2+4+6+8+10 = 30.

Practice

1. What is true about arrays in Rust?

easy

A. Their size can change after creation.

B. They store multiple values of the same type in a fixed-size list.

C. They can store values of different types together.

D. They do not allow access by index.

Solution

1. Step 1: Understand array type restrictions

   Arrays in Rust hold values all of the same type, ensuring type safety.

2. Step 2: Understand array size behavior

   Arrays have a fixed size that cannot be changed after creation.

3. Final Answer:

   They store multiple values of the same type in a fixed-size list. -> Option B

4. Quick Check:

   Array = fixed size + same type [OK]

Hint: Remember: Rust arrays are fixed size and single type [OK]

Common Mistakes:

• Thinking arrays can hold mixed types
• Assuming arrays can grow or shrink
• Believing arrays don't use indexes

2. Which of the following is the correct way to declare an array of 3 integers in Rust?

easy

A. let arr = [1, 2, 3];

B. let arr = (1, 2, 3);

C. let arr = {1, 2, 3};

D. let arr = <1, 2, 3>;

Solution

1. Step 1: Identify Rust array syntax

   Arrays use square brackets [] with comma-separated values.

2. Step 2: Check other options

   Parentheses () create tuples, curly braces {} are blocks, angle brackets <> are not valid here.

3. Final Answer:

   let arr = [1, 2, 3]; -> Option A

4. Quick Check:

   Array syntax uses [] [OK]

Hint: Arrays use square brackets [] with commas [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Confusing arrays with tuples
• Using invalid symbols like {} or <>

3. What will be the output of this Rust code?

let arr = [10, 20, 30, 40];
println!("{}", arr[2]);

medium

A. Index out of bounds error

B. 20

C. 40

D. 30

Solution

1. Step 1: Understand array indexing

   Rust arrays start indexing at 0, so arr[2] is the third element.

2. Step 2: Identify the element at index 2

   The elements are [10, 20, 30, 40], so arr[2] is 30.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Index 2 = 30 [OK]

Hint: Count from zero to find the correct index [OK]

Common Mistakes:

• Starting count at 1 instead of 0
• Confusing element positions
• Expecting runtime error for valid index

4. Find the error in this Rust code snippet:

let arr = [1, 2, 3];
println!("{}", arr[3]);

medium

A. No error, prints 3

B. Type mismatch error

C. Index out of bounds error at runtime

D. Syntax error due to missing semicolon

Solution

1. Step 1: Check array length and index used

   The array has 3 elements with indexes 0, 1, 2. Index 3 is invalid.

2. Step 2: Understand Rust runtime behavior

   Accessing arr[3] causes a runtime panic due to index out of bounds.

3. Final Answer:

   Index out of bounds error at runtime -> Option C

4. Quick Check:

   Invalid index causes runtime panic [OK]

Hint: Check if index is less than array length [OK]

Common Mistakes:

• Assuming index 3 is valid for 3-element array
• Confusing syntax error with runtime error
• Ignoring Rust's panic on invalid index

5. You want to create an array of 5 zeros in Rust. Which code correctly does this?

hard

A. let arr = [0; 5];

B. let arr = [0, 5];

C. let arr = [5; 0];

D. let arr = [0] * 5;

Solution

1. Step 1: Understand Rust array repetition syntax

   The syntax [value; count] creates an array repeating value count times.

2. Step 2: Check each option

   let arr = [0; 5]; uses [0; 5], which creates 5 zeros. Others are invalid or create wrong arrays.

3. Final Answer:

   let arr = [0; 5]; -> Option A

4. Quick Check:

   Use [value; count] to repeat values [OK]

Hint: Use [value; count] to make repeated arrays [OK]

Common Mistakes:

• Using commas instead of semicolon for repetition
• Confusing multiplication syntax with arrays
• Reversing value and count in repetition