Rust Coding Challenges for Practice

Use HashMap entry() and or_insert() to count word frequencies.

Implement the Iterator trait for a custom struct that yields a sequence of numbers.

Use Rust's iterator chain .iter().filter().map().collect() to transform a vector.

Use iterator .filter().count() to count elements in a collection that match a condition.

Use Vec::push() to add elements to a vector one at a time, growing it dynamically.

Use Vec::drain() to remove a range of elements from a vector and collect them into a new vector.

Use len() to get the number of elements in a Vec and is_empty() to check if it's empty.

Use the vec![] macro to create a vector from a list of elements.

Use Rc<RefCell<T>> to share and mutate a value through multiple owners with interior mutability.

Use Vec::get() to safely access elements by index, returning Option<&T> instead of panicking on out of bounds.

Use Vec::retain() with a closure to remove elements that don't match a condition, modifying the vector in-place.

Use Rust's tuple field access syntax .0 and .1 to extract elements from a tuple.

Define a struct and use dot notation to access its named fields.

Use Rust's ! (not) operator to invert a boolean value.

Use Box<dyn Trait> for dynamic dispatch to call different implementations through the same trait interface.

Use Rust's 0..n range syntax with for loop to iterate over a sequence of numbers.

Use Result<T,E> with map_err() to transform error types while preserving success values.

Use where clauses to constrain generic type parameters with trait bounds for compile-time polymorphism.

Use Option<T> with unwrap_or() to safely access values that may be missing without panicking.

Use Option::is_some() and Option::is_none() to safely check if a value exists.

Use explicit lifetime annotations to specify that a returned reference lives as long as the parameters.

Use Result::is_ok() and Result::is_err() to check whether an operation succeeded without unwrapping.

Use String::push_str() to append a string slice to an existing String, growing it dynamically.

Use char::is_alphabetic() to determine if a character is a letter (a-z, A-Z).

Use &str::starts_with() to check if a string begins with a given prefix.

Use Rust's &str string slicing syntax to extract substrings from a string at given byte indices.

Use String::from() to create an owned String from a string literal (&str).

Use &str::contains() to check if a string contains a given substring.

Implement the From trait to convert a &str into a custom Name struct.

Define a trait with a default method implementation and override it for a specific type.

Create a generic Wrapper<T> struct that holds a single value of any type and returns it.

Create a generic Pair<T> struct with a method that works for any type T.

Write a function with a trait bound that accepts any type implementing a specific trait.

Implement the Display trait for a custom struct so it can be formatted with the {} placeholder.

Use #[derive(Clone, Copy)] to automatically implement the Clone and Copy traits for a struct.

Use #[derive(Eq, PartialOrd, Ord)] to compare and sort struct instances.

Use #[derive(PartialEq)] to compare struct instances for equality using the == operator.