Rust Collections Quiz

0 Passed

0% acceptance

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

40 Questions

~80 minutes

Question 1

What is a Vec in Rust?

A growable array that stores elements of the same type

A fixed-size array

A linked list

A hash table

Question 2

How do you create an empty Vec?

Vec::new()

vec![]

Vec::empty()

Both A and B

Question 3

How do you create a Vec with initial values?

vec![1, 2, 3]

Vec::from([1, 2, 3])

Both A and B

Neither

Question 4

What will this code do?

rust

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

Print 'First element: 1'

Compilation error

Runtime panic

Print nothing

Question 5

What happens when you access an invalid index in a Vec?

Runtime panic

Compilation error

Returns default value

Wraps around

Question 6

How do you safely access Vec elements?

get() method returns Option<&T>

at() method

safe_get() method

Direct indexing only

Question 7

How do you add elements to a Vec?

push() method

add() method

append() method

insert() method

Question 8

What does pop() do on a Vec?

Removes and returns the last element

Removes the first element

Clears the entire vector

Returns the last element without removing

Question 9

How do you iterate over a Vec?

for element in &vec { ... }

for i in 0..vec.len() { ... }

Both A and B

Neither

Question 10

What is the difference between iter() and iter_mut()?

iter() borrows immutably, iter_mut() mutably

iter() is faster

They are identical

iter_mut() doesn't exist

Question 11

What will this code do?

rust

fn main() {
    let mut v = vec![1, 2, 3];
    for x in &mut v {
        *x += 1;
    }
    println!("{:?}", v);
}

Print [2, 3, 4]

Compilation error

Print [1, 2, 3]

Runtime panic

Question 12

What is a HashMap in Rust?

A collection of key-value pairs with fast lookup

A sorted map

A vector of pairs

A linked list

Question 13

How do you create an empty HashMap?

HashMap::new()

hashmap!{}

Both A and B

Neither

Question 14

How do you insert into a HashMap?

insert() method returns Option<V>

put() method

add() method

set() method

Question 15

How do you get a value from a HashMap?

get() returns Option<&V>

get_mut() for mutable access

Both A and B

Direct indexing with []

Question 16

What happens when you access a non-existent key with []?

Runtime panic

Returns None

Compilation error

Returns default value

Question 17

How do you check if a key exists in a HashMap?

contains_key() method

has_key() method

exists() method

key_exists() method

Question 18

What does entry() method do?

Provides Entry API for conditional insertion

Returns a single entry

Lists all entries

Removes an entry

Question 19

What will this code do?

rust

use std::collections::HashMap;
fn main() {
    let mut scores = HashMap::new();
    scores.insert("Alice", 10);
    scores.insert("Alice", 20);
    println!("Alice's score: {}", scores[&"Alice"]);
}

Print 'Alice's score: 20'

Print 'Alice's score: 10'

Compilation error

Runtime panic

Question 20

What is a VecDeque?

A double-ended queue with efficient front/back operations

A circular buffer

A priority queue

A stack

Question 21

How do you add to the front of a VecDeque?

push_front() method

push() method

add_front() method

Cannot add to front

Question 22

What does pop_back() do on VecDeque?

Removes and returns the back element

Removes the front element

Returns without removing

Clears the deque

Question 23

When should you use VecDeque instead of Vec?

When you need efficient front operations

When elements are always added to the end

When you need random access

Always

Question 24

What is capacity in collections?

Allocated memory size without reallocation

Number of elements stored

Maximum possible size

Memory used by elements

Question 25

How do you reserve capacity in a Vec?

reserve() or with_capacity()

allocate() method

capacity() method

Cannot reserve capacity

Question 26

What happens when you exceed Vec capacity?

Automatic reallocation with more capacity

Panic

Compilation error

Data loss

Question 27

How do you shrink a Vec to fit its contents?

shrink_to_fit() method

shrink() method

fit() method

Cannot shrink capacity

Question 28

What is the difference between len() and capacity()?

len() is elements used, capacity() is allocated space

They are identical

capacity() is elements used

len() is allocated space

Question 29

How do you iterate over a HashMap?

for (key, value) in &map { ... }

for element in map { ... }

for i in 0..map.len() { ... }

HashMaps cannot be iterated

Question 30

What does into_iter() do?

Consumes the collection, returning owned elements

Borrows immutably

Borrows mutably

Creates a copy

Question 31

How do you sort a Vec?

sort() method

sort_by() for custom comparison

Both A and B

Vec cannot be sorted

Question 32

What does retain() do on a Vec?

Keeps elements that match a predicate

Removes all elements

Keeps only the first element

Duplicates all elements

Question 33

How do you remove elements from a Vec by index?

remove() shifts elements, swap_remove() swaps with last

delete() method

erase() method

Cannot remove by index

Question 34

What is the entry API pattern?

map.entry(key).or_insert(value) for conditional insertion

map.get_entry(key)

map.insert_entry(key, value)

Entry API doesn't exist

Question 35

How do you clear all elements from a collection?

clear() method

empty() method

reset() method

truncate(0)

Question 36

What is the most efficient way to build a large Vec?

Use with_capacity() then push() elements

Push elements without pre-allocation

Use collect() on iterator

Create with known size

Question 37

How do you check if a Vec is empty?

is_empty() method

len() == 0

Both A and B

Neither

Question 38

What does dedup() do on a Vec?

Removes consecutive duplicate elements

Removes all duplicate elements

Sorts and removes duplicates

Adds duplicate elements

Question 39

How do you convert between collections?

Use From/Into traits or collect()

Direct casting

Conversion methods

Cannot convert between collections

Question 40

When should you use HashMap over Vec?

When you need key-based lookup instead of positional access

When elements are always accessed sequentially

When you need to maintain insertion order

Always

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Collections Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

About This Rust Collections Quiz

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization