Vector vs array comparison in Rust - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Comparing Vector and Array with == operator

What is the output of this Rust code comparing a vector and an array using the == operator?

Rust

fn main() {
    let v = vec![1, 2, 3];
    let a = [1, 2, 3];
    println!("{}", v == a);
}

A Compilation error

B false

C true

D Runtime panic

💡 Hint

Think about whether vectors and arrays can be directly compared with == in Rust.

In Rust, vectors (Vec) and arrays ([T; N]) are different types. The == operator requires both sides to have the same type or compatible types implementing PartialEq. Vec and [T; N] do not implement PartialEq between each other, so this code will not compile.

❓ Predict Output

intermediate

Comparing Vector and Slice with == operator

What is the output of this Rust code comparing a vector and a slice using the == operator?

Rust

fn main() {
    let v = vec![4, 5, 6];
    let s: &[i32] = &[4, 5, 6];
    println!("{}", v == s);
}

A Runtime panic

B false

C Compilation error

D true

💡 Hint

Recall that Vec can be compared to slices &[T] in Rust.

Vec implements PartialEq<&[T]>, so comparing a vector and a slice with == works and compares their elements. Since both contain [4, 5, 6], the result is true.

🔧 Debug

advanced

Fix the code to compare Vector and Array elements

This Rust code tries to compare a vector and an array for equality but fails to compile. Which option fixes the code so it compiles and prints true?

Rust

fn main() {
    let v = vec![7, 8, 9];
    let a = [7, 8, 9];
    println!("{}", v == a);
}

A Change println! line to: println!("{}", v.as_slice() == a);

B Change println! line to: println!("{}", v == a.to_vec());

C Change println! line to: println!("{}", v == &a);

D Change println! line to: println!("{}", v == a.as_slice());

💡 Hint

Convert the vector to a slice before comparing with the array.

Vec can be compared to slices &[T]. The array can be coerced to a slice automatically. Using v.as_slice() converts the vector to a slice, so v.as_slice() == a compares two slices and compiles.

🧠 Conceptual

advanced

Why can't Vec and [T; N] be compared directly?

Why does Rust not allow direct comparison between Vec and [T; N] using == operator?

A Because arrays do not implement PartialEq at all in Rust.

B Because Vec<T> and [T; N] are different types and PartialEq is not implemented between them.

C Because Vec<T> is mutable and arrays are immutable, so comparison is forbidden.

D Because the sizes of Vec<T> and [T; N] are always different, so comparison is meaningless.

💡 Hint

Think about Rust's type system and trait implementations.

Vec and [T; N] are distinct types. Rust only allows == if PartialEq is implemented between the two types. There is no implementation of PartialEq> for [T; N] or vice versa, so direct comparison is not allowed.

❓ Predict Output

expert

Output of comparing nested vectors and arrays

What is the output of this Rust code comparing a vector of arrays and an array of vectors?

Rust

fn main() {
    let v: Vec<[i32; 2]> = vec![[1, 2], [3, 4]];
    let a: [[i32; 2]; 2] = [[1, 2], [3, 4]];
    println!("{}", v == a);
}

A false

B true

C Compilation error

D Runtime panic

💡 Hint

Consider the types Vec<[i32; 2]> and [[i32; 2]; 2] and whether PartialEq is implemented between them.

Vec<[i32; 2]> and [[i32; 2]; 2] are different types. Rust does not implement PartialEq between Vec and arrays [T; N], so this comparison causes a compilation error.

Practice

1. Which of the following statements correctly describes the main difference between a Rust array and a Rust vector?

easy

A. Arrays have a fixed size known at compile time, while vectors can grow or shrink at runtime.

B. Vectors have a fixed size known at compile time, while arrays can grow or shrink at runtime.

C. Both arrays and vectors have fixed sizes and cannot change after creation.

D. Arrays are only used for strings, while vectors are used for numbers.

Solution

1. Step 1: Understand array size behavior

   Arrays in Rust have a fixed size that must be known when the program is compiled.

2. Step 2: Understand vector size behavior

   Vectors are dynamic and can grow or shrink during program execution.

3. Final Answer:

   Arrays have a fixed size known at compile time, while vectors can grow or shrink at runtime. -> Option A

4. Quick Check:

   Array fixed size, Vector dynamic size = C [OK]

Hint: Remember: arrays fixed size, vectors flexible size [OK]

Common Mistakes:

• Confusing which type is fixed or dynamic
• Thinking vectors are fixed size
• Assuming arrays can grow dynamically

2. Which of the following is the correct syntax to declare a vector of integers in Rust?

easy

A. let v = (1, 2, 3);

B. let v = [1, 2, 3];

C. let v = vector(1, 2, 3);

D. let v = vec![1, 2, 3];

Solution

1. Step 1: Identify vector creation syntax

   In Rust, vectors are created using the macro vec![...] with square brackets and exclamation mark.

2. Step 2: Compare options

   let v = vec![1, 2, 3]; uses vec![1, 2, 3], which is correct. let v = [1, 2, 3]; is an array, C and D are invalid syntax for vectors.

3. Final Answer:

   let v = vec![1, 2, 3]; -> Option D

4. Quick Check:

   Vector syntax uses vec! macro = A [OK]

Hint: Vectors use vec! macro with square brackets [OK]

Common Mistakes:

• Using array syntax instead of vec! macro
• Missing exclamation mark in vec! macro
• Using parentheses instead of brackets

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

let arr = [10, 20, 30];
let vec = vec![10, 20, 30];
println!("{} {}", arr.len(), vec.len());

medium

A. 3 0

B. 3 3

C. 0 3

D. Compilation error

Solution

1. Step 1: Check array length

   The array arr has 3 elements, so arr.len() returns 3.

2. Step 2: Check vector length

   The vector vec also has 3 elements, so vec.len() returns 3.

3. Final Answer:

   3 3 -> Option B

4. Quick Check:

   Both lengths are 3 = B [OK]

Hint: Both array and vector have length 3 here [OK]

Common Mistakes:

• Assuming vector length is zero initially
• Confusing array and vector length methods
• Expecting compilation error due to different types

4. Identify the error in this Rust code snippet:

let arr = [1, 2, 3];
arr.push(4);

medium

A. Arrays do not have a push method; only vectors do.

B. The array is missing a semicolon after declaration.

C. The push method requires a mutable reference to the array.

D. The code is correct and will compile.

Solution

1. Step 1: Check array methods

   Arrays in Rust have fixed size and do not support the push method.

2. Step 2: Understand push method usage

   The push method is only available for vectors, which are growable.

3. Final Answer:

   Arrays do not have a push method; only vectors do. -> Option A

4. Quick Check:

   push() only works on vectors = D [OK]

Hint: Only vectors support push(), arrays do not [OK]

Common Mistakes:

• Trying to push to arrays
• Thinking arrays can be resized
• Ignoring method availability on types

5. You want to store a list of user scores that can change size during the program. Which Rust type should you choose and why?

hard

A. Use a tuple because it can hold multiple types of scores.

B. Use an array because it is faster and fixed size is better for scores.

C. Use a vector because it can grow or shrink as scores are added or removed.

D. Use a string because scores are numbers stored as text.

Solution

1. Step 1: Analyze data size requirement

   The list of user scores can change size, so a fixed size container is not suitable.

2. Step 2: Choose appropriate Rust type

   Vectors are growable and flexible, making them ideal for dynamic lists like scores.

3. Final Answer:

   Use a vector because it can grow or shrink as scores are added or removed. -> Option C

4. Quick Check:

   Dynamic list needs vector = A [OK]

Hint: Dynamic size needs vector, fixed size needs array [OK]

Common Mistakes:

• Choosing array for dynamic data
• Confusing tuples with lists
• Using string for numeric data