Array Declaration and Initialization in DSA Rust - Execution Trace

Concept Flow - Array Declaration and Initialization

Declare array variable

↓

Allocate fixed size memory

↓

Initialize elements with values

↓

Array ready to use

The flow shows declaring an array variable, allocating fixed size memory, initializing each element, and then the array is ready for use.

Execution Sample

DSA Rust

let arr: [i32; 3] = [10, 20, 30];
println!("{:?}", arr);

This code declares an integer array of size 3, initializes it with values 10, 20, 30, and prints the array.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Declare array variable 'arr' of size 3	[]	arr -> allocated memory	[]
2	Initialize arr[0] = 10	[10, _, _]	arr points to index 0	[10, _, _]
3	Initialize arr[1] = 20	[10, 20, _]	arr points to index 1	[10, 20, _]
4	Initialize arr[2] = 30	[10, 20, 30]	arr points to index 2	[10, 20, 30]
5	Print array	[10, 20, 30]	arr unchanged	[10, 20, 30]
6	End	[10, 20, 30]	arr unchanged	[10, 20, 30]

💡 All elements initialized; array ready and printed.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
arr	uninitialized	[10, _, _]	[10, 20, _]	[10, 20, 30]	[10, 20, 30]

Key Moments - 3 Insights

Why does the array size need to be fixed at declaration?

Rust arrays have fixed size known at compile time, so memory is allocated once. See execution_table step 1 where memory is allocated for size 3.

What happens if we try to access an index outside the array size?

Rust will cause a runtime panic (error) because the array size is fixed. The execution_table shows only indices 0 to 2 initialized.

Why do we see underscores '_' in the array state during initialization?

Underscores represent uninitialized elements at that step. For example, after step 2 only arr[0] is set, others are still uninitialized.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the array state?

A [10, _, 30]

B [10, 20, _]

C [_, 20, 30]

D [_, _, _]

💡 Hint

Check the 'Array State' column at step 3 in execution_table.

At which step is the array fully initialized?

A Step 4

B Step 5

C Step 2

D Step 1

💡 Hint

Look for the step where all elements have values in the 'Array State' column.

If we declare the array size as 4 but initialize only 3 elements, what happens?

A The 4th element is uninitialized and causes runtime error if accessed

B The 4th element is zero by default

C Compilation error

D The array size automatically shrinks to 3

💡 Hint

Rust requires all elements to be initialized; see how initialization is done step-by-step in execution_table.

Concept Snapshot

Array Declaration and Initialization in Rust:
- Syntax: let arr: [Type; size] = [val1, val2, ...];
- Fixed size known at compile time
- All elements must be initialized
- Memory allocated once for all elements
- Access with zero-based index
- Example: let arr: [i32; 3] = [10, 20, 30];

Full Transcript

This visualization shows how to declare and initialize an array in Rust. First, the array variable is declared with a fixed size, which allocates memory. Then each element is initialized one by one. The array state changes from empty to fully initialized. The final array is ready to use and print. Key points include fixed size, full initialization, and zero-based indexing. The execution table tracks each step and the array's content. Common confusions about size, initialization, and indexing are clarified.

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