Ownership with smart pointers in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new Box smart pointer holding the value 5.

Rust

let b = Box::[1](5);

Drag options to blanks, or click blank then click option'

Anew

Bcreate

Cmake

Dbuild

Attempts:

3 left

💡 Hint

Common Mistakes

Using functions like create or make which do not exist for Box.

Trying to call Box as a function directly.

The Box::new function creates a new Box smart pointer that owns the value inside it.

2fill in blank

medium

Complete the code to clone a Rc smart pointer.

Rust

let rc2 = Rc::[1](&rc1);

Drag options to blanks, or click blank then click option'

Acopy

Bclone

Cduplicate

Dreplicate

Attempts:

3 left

💡 Hint

Common Mistakes

Using copy which is not implemented for Rc.

Trying to use duplicate or replicate which do not exist.

The clone method on Rc increases the reference count and returns a new pointer to the same data.

3fill in blank

hard

Fix the error in the code by completing the blank to get a mutable reference from a RefCell.

Rust

let mut_ref = refcell.[1]().unwrap();

Drag options to blanks, or click blank then click option'

Aborrow_mut

Bborrow

Cget_mut

Dtake_mut

Attempts:

3 left

💡 Hint

Common Mistakes

Using borrow which only gives an immutable reference.

Trying to use get_mut which requires exclusive ownership.

The borrow_mut method on RefCell returns a mutable reference wrapped in a RefMut, which you can unwrap safely if no other borrows exist.

4fill in blank

hard

Fill both blanks to create a HashMap from strings to their lengths, only including words longer than 3 characters.

Rust

let lengths = words.iter().filter(|&word| word.len() [1] 3).map(|word| (word.to_string(), word.[2]())).collect::<HashMap<_, _>>();

Drag options to blanks, or click blank then click option'

A>

Blen

C<

Dis_empty

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > in the filter condition.

Using is_empty which returns a boolean, not length.

The filter keeps words with length greater than 3, and the map creates pairs of the word and its length.

5fill in blank

hard

Fill both blanks to create a HashMap from uppercase keys to values, including only entries with positive values.

Rust

let result = data.iter().map(|(k, v)| (k.[1](), *v)).filter(|(_, v)| *v [2] 0).collect::<HashMap<_, _>>();

Drag options to blanks, or click blank then click option'

Ato_uppercase

B>

C==

Dto_lowercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using to_lowercase instead of uppercase.

Filtering values equal to zero instead of greater than zero.

The map converts keys to uppercase strings, the filter keeps only positive values, and the collect gathers them into a HashMap.