Array Declaration and Initialization in DSA Rust

Mental Model

An array is a fixed-size collection of items stored one after another in memory. Declaring and initializing means creating this collection and putting values inside it.

Analogy: Think of an egg carton with fixed slots. Declaring the array is like getting the carton, and initializing is like placing eggs in each slot.

[0] -> [1] -> [2] -> [3] -> [4] -> null
 ↑
 array start

Dry Run Walkthrough

Input: Declare an array of 5 integers and initialize with values [10, 20, 30, 40, 50]

Goal: Create an array with 5 slots and fill each slot with the given numbers

Step 1: Declare an array of size 5 with default values

[0] -> [0] -> [0] -> [0] -> [0] -> null
 ↑
 array start

Why: We need a fixed space to hold 5 integers

Step 2: Set index 0 to 10

[10] -> [0] -> [0] -> [0] -> [0] -> null
 ↑
 array start

Why: Put the first value in the first slot

Step 3: Set index 1 to 20

[10] -> [20] -> [0] -> [0] -> [0] -> null
 ↑
 array start

Why: Put the second value in the second slot

Step 4: Set index 2 to 30

[10] -> [20] -> [30] -> [0] -> [0] -> null
 ↑
 array start

Why: Put the third value in the third slot

Step 5: Set index 3 to 40

[10] -> [20] -> [30] -> [40] -> [0] -> null
 ↑
 array start

Why: Put the fourth value in the fourth slot

Step 6: Set index 4 to 50

[10] -> [20] -> [30] -> [40] -> [50] -> null
 ↑
 array start

Why: Put the fifth value in the fifth slot

Result:

[10] -> [20] -> [30] -> [40] -> [50] -> null
 ↑
 array start

Annotated Code

DSA Rust

fn main() {
    // Declare and initialize an array of 5 integers
    let arr: [i32; 5] = [10, 20, 30, 40, 50];

    // Print the array elements
    for i in 0..arr.len() {
        print!("{} ", arr[i]);
    }
    println!();
}

let arr: [i32; 5] = [10, 20, 30, 40, 50];

Declare fixed-size array and initialize with values

for i in 0..arr.len() {

Loop through each index of the array

print!("{} ", arr[i]);

Access and print each element by index

Output

10 20 30 40 50 

Complexity Analysis

Time: O(n) because printing all n elements requires visiting each once

Space: O(n) because the array stores n elements in contiguous memory

vs Alternative: Compared to dynamic collections, arrays have fixed size but faster access by index

Edge Cases

Array of size zero

Array exists but has no elements; loop does not run

DSA Rust

for i in 0..arr.len() {

Array with all elements zero

Array is initialized with zeros; printing shows zeros

DSA Rust

let arr: [i32; 5] = [0; 5];

When to Use This Pattern

When you need a fixed number of elements stored together with fast access, use array declaration and initialization.

Common Mistakes

Mistake: Trying to change the size of the array after declaration
Fix: Remember arrays have fixed size; use vectors for dynamic size

Mistake: Accessing index out of bounds
Fix: Always ensure index is within 0 to length-1

Summary

Creates a fixed-size collection of elements stored in order.

Use when you know the number of elements in advance and want fast access.

Arrays are like fixed egg cartons: size is fixed, and each slot holds one item.

Practice

1. Which of the following is the correct way to declare an array of 5 integers initialized to zero in Rust?

easy

A. let arr = [5; 0];

B. let arr: [i32; 5] = [0; 5];

C. let arr: [i32] = [0; 5];

D. let arr = [0, 5];

Solution

1. Step 1: Understand Rust array syntax

   Rust arrays require a fixed size and type, declared as [type; size].

2. Step 2: Check initialization correctness

   [0; 5] means 5 elements all set to 0, which matches the declaration.

3. Final Answer:

   let arr: [i32; 5] = [0; 5]; -> Option B

4. Quick Check:

   Correct Rust array declaration = let arr: [i32; 5] = [0; 5]; [OK]

Hint: Use [value; size] to initialize arrays quickly [OK]

Common Mistakes:

• Missing size in array type declaration
• Using wrong syntax like [0, 5] for repeated values
• Declaring array without fixed size

2. What is the correct syntax to declare a mutable array of 3 floating-point numbers initialized to 1.0 in Rust?

easy

A. let mut arr: [f64; 3] = [1.0; 3];

B. let arr mut: [f64; 3] = [1.0; 3];

C. mut let arr: [f64; 3] = [1.0; 3];

D. let arr: mut [f64; 3] = [1.0; 3];

Solution

1. Step 1: Identify mutable variable syntax in Rust

   Mutable variables use 'let mut' before the variable name.

2. Step 2: Confirm array declaration and initialization

   Array type is [f64; 3] and initialized with [1.0; 3], which is correct.

3. Final Answer:

   let mut arr: [f64; 3] = [1.0; 3]; -> Option A

4. Quick Check:

   Mutable array syntax = let mut arr: [f64; 3] = [1.0; 3]; [OK]

Hint: Place 'mut' right after 'let' for mutable arrays [OK]

Common Mistakes:

• Placing 'mut' after variable name
• Using 'mut let' instead of 'let mut'
• Incorrect array type syntax

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

let arr = [2; 4];
println!("{:?}", arr);

medium

A. [2; 4]

B. [4, 4, 4, 4]

C. [2, 2, 2, 2]

D. Compilation error

Solution

1. Step 1: Understand array initialization [2; 4]

   This creates an array with 4 elements, each set to 2.

2. Step 2: Print array with debug format

   Using {:?} prints the array elements as a list.

3. Final Answer:

   [2, 2, 2, 2] -> Option C

4. Quick Check:

   Array with repeated values prints as list [OK]

Hint: Remember [value; size] repeats value size times [OK]

Common Mistakes:

• Confusing size and value positions
• Expecting syntax [2;4] to print literally
• Assuming compilation error due to syntax

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

let arr: [i32; 3] = [1, 2];

medium

A. Array size mismatch error

B. Type mismatch error

C. Mutable variable required

D. No error, code is correct

Solution

1. Step 1: Check declared array size

   Array is declared with size 3 but initialized with only 2 elements.

2. Step 2: Understand Rust array size rules

   Rust requires the number of elements to match the declared size exactly.

3. Final Answer:

   Array size mismatch error -> Option A

4. Quick Check:

   Declared size must match initializer length [OK]

Hint: Array size and initializer length must be equal [OK]

Common Mistakes:

• Ignoring size mismatch
• Assuming Rust allows shorter initializers
• Confusing type mismatch with size error

5. You want to create a 2D array (matrix) of size 3x3 filled with the value 7 in Rust. Which code correctly declares and initializes this array?

hard

A. let matrix: [i32; 3][3] = [[7; 3]; 3];

B. let matrix: [[i32; 3]; 3] = [7; 9];

C. let matrix: [i32; 9] = [[7; 3]; 3];

D. let matrix: [[i32; 3]; 3] = [[7; 3]; 3];

Solution

1. Step 1: Understand 2D array type declaration

   A 3x3 array of i32 is declared as [[i32; 3]; 3], meaning 3 arrays each of size 3.

2. Step 2: Check initialization syntax

   [[7; 3]; 3] creates 3 arrays each filled with 3 sevens, forming a 3x3 matrix.

3. Final Answer:

   let matrix: [[i32; 3]; 3] = [[7; 3]; 3]; -> Option D

4. Quick Check:

   Nested arrays use [[type; cols]; rows] [OK]

Hint: Use nested [value; size] for multi-dimensional arrays [OK]

Common Mistakes:

• Incorrect type syntax like [i32; 3][3]
• Initializing flat array instead of nested
• Mismatch between declared size and initializer