Array Declaration and Initialization in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an array in Rust?

An array in Rust is a fixed-size collection of elements of the same type stored in contiguous memory. The size is known at compile time.

beginner

How do you declare an array of 5 integers initialized to zero in Rust?

You can declare it as: <code>let arr: [i32; 5] = [0; 5];</code> This creates an array of 5 integers, all set to 0.

beginner

What does the syntax [value; size] mean in Rust array initialization?

It means create an array of length size where each element is initialized to value.

beginner

Can you change the size of an array after declaration in Rust?

No, arrays in Rust have a fixed size known at compile time and cannot be resized. For dynamic sizes, use vectors.

beginner

How to declare and initialize an array with different values in Rust?

You can declare it like: <code>let arr = [1, 2, 3, 4, 5];</code> The compiler infers the type and size from the values.

What is the correct way to declare an array of 3 floats initialized to 1.0 in Rust?

A let arr: [f32; 3] = [1.0; 3];

B let arr = [1.0, 3];

C let arr: [f32] = [1.0; 3];

D let arr = (1.0; 3);

Option A correctly declares an array of 3 floats all initialized to 1.0. The syntax [value; size] is used for initialization.

What happens if you try to change the size of an array after declaration in Rust?

A Compiler error because arrays have fixed size.

B The array is automatically converted to a vector.

C The array size changes dynamically.

D The program crashes at runtime.

Rust arrays have fixed size known at compile time. Changing size after declaration causes a compiler error.

Which of the following declares an array with elements 10, 20, 30 in Rust?

A let arr = (10, 20, 30);

B let arr = [10, 20, 30];

C let arr: [i32] = [10, 20, 30];

D let arr = [10; 20; 30];

Option B correctly declares an array with three elements 10, 20, 30. Option A is a tuple, not an array.

What is the type of let arr = [5; 4]; in Rust?

A Vec<i32>

B [i32; 5]

C [i32; 1]

D [i32; 4]

The array has 4 elements each initialized to 5, so type is [i32; 4].

How do you declare an empty array in Rust?

A let arr = [];

B let arr = [0];

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

D Rust does not support empty arrays.

Option C declares an array of size 0. Rust allows zero-length arrays with explicit size.

Explain how to declare and initialize an array in Rust with the same value repeated.

Think about how to create multiple copies of the same value.

Describe the limitations of arrays in Rust compared to vectors.

Consider what happens if you want to add or remove elements.

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