Array Declaration and Initialization in DSA Rust - Time & Space Complexity

Time Complexity: Array Declaration and Initialization

O(n)

Understanding Time Complexity

We want to understand how long it takes to create and fill an array in Rust.

How does the time needed grow when the array size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn main() {
    let size = 5;
    let mut arr = [0; 5];
    for i in 0..size {
        arr[i] = i * 2;
    }
    println!("{:?}", arr);
}

This code creates an array of 5 integers and fills it with values.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that assigns values to each array element.
• How many times: It runs exactly once for each element, so 5 times here, or n times in general.

How Execution Grows With Input

As the array size grows, the number of assignments grows the same way.

Input Size (n)	Approx. Operations
10	10 assignments
100	100 assignments
1000	1000 assignments

Pattern observation: The work grows directly with the size of the array.

Final Time Complexity

Time Complexity: O(n)

This means the time to fill the array grows in a straight line with the number of elements.

Common Mistake

[X] Wrong: "Creating and initializing an array is instant and does not depend on size."

[OK] Correct: Each element must be set, so the time grows with the number of elements.

Interview Connect

Knowing how array initialization scales helps you understand basic data structure setup, a key skill in coding interviews.

Self-Check

"What if we used a vector and pushed elements one by one? How would the time complexity change?"

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