Rust, with its robust features and powerful constructs, empowers developers to solve intricate problems efficiently. Let's dive into some coding questions revolving around tuples, closures, and enums, crucial aspects of Rust programming, followed by their solutions. Additionally, we'll provide practice questions to solidify your understanding.
Tuples
Coding Question 1: Tuple Manipulation
Task: Create a function that receives a tuple (i32, i32) and returns the sum and product of its elements.
Example Solution:
fn sum_and_product(tup: (i32, i32)) -> (i32, i32) {
let (a, b) = tup;
(a + b, a * b)
}
fn main() {
let input = (3, 5);
let result = sum_and_product(input);
println!("Sum: {}, Product: {}", result.0, result.1);
}
Task: Implement a function that takes a tuple (i32, String, f64) and returns its elements in reverse order.
Example Solution:
fn reverse_tuple(tup: (i32, String, f64)) -> (f64, String, i32) {
let (a, b, c) = tup;
(c, b, a)
}
fn main() {
let input = (42, String::from("Rust"), 3.14);
let result = reverse_tuple(input);
println!("{:?}", result);
}
Closures
Coding Question 3: Closure Composition
Task: Write a closure that takes an i32 input and returns its square, then create another closure that squares the result of the first closure.
Example Solution:
fn main() {
let square = |x| x * x;
let square_result = square(5);
let square_square = |y| square(y) * square(y);
let square_square_result = square_square(5);
println!("Square: {}, Square of Square: {}", square_result, square_square_result);
}
Coding Question 4: Closure Counter
Task: Create a closure that acts as a counter, incrementing its internal count with each call.
Example Solution:
fn main() {
let mut counter = 0;
let mut increment_counter = || {
counter += 1;
counter
};
println!("{}", increment_counter());
println!("{}", increment_counter());
}
Enums
Coding Question 5: Direction Enum
Task: Define an enum representing cardinal directions (North, South, East, West), and implement a function that returns the opposite direction.
Example Solution:
#[derive(Debug)]
enum Direction {
North,
South,
East,
West,
}
fn opposite_direction(dir: Direction) -> Direction {
match dir {
Direction::North => Direction::South,
Direction::South => Direction::North,
Direction::East => Direction::West,
Direction::West => Direction::East,
}
}
fn main() {
let current = Direction::North;
let opposite = opposite_direction(current);
println!("Opposite Direction: {:?}", opposite);
}
Coding Question 6: Enum Matching
Task: Write a function that takes an enum variant and performs different operations based on the variant.
Example Solution:
#[derive(Debug)]
enum MathOperation {
Add(i32, i32),
Subtract(i32, i32),
Multiply(i32, i32),
}
fn perform_operation(op: MathOperation) -> i32 {
match op {
MathOperation::Add(a, b) => a + b,
MathOperation::Subtract(a, b) => a - b,
MathOperation::Multiply(a, b) => a * b,
}
}
fn main() {
let add = MathOperation::Add(10, 5);
let subtract = MathOperation::Subtract(10, 5);
let multiply = MathOperation::Multiply(10, 5);
println!("Addition: {}", perform_operation(add));
println!("Subtraction: {}", perform_operation(subtract));
println!("Multiplication: {}", perform_operation(multiply));
}
Practice Questions:
Tuple Concatenation: Write a function that concatenates two tuples of the same type.
Closure Accumulator: Implement a closure that accumulates and returns the sum of all passed values.
Enum and Struct: Create an enum representing shapes (Circle, Square, Rectangle) and define a struct for each shape containing necessary properties.
These coding questions, solutions, and practice problems on tuples, closures, and enums are designed to enhance your Rust programming skills. Use these exercises as a starting point to delve deeper into Rust's advanced features and further solidify your understanding. Happy coding!
I hope this helps, you!!
More such articles:
https://medium.com/techwasti
https://www.youtube.com/@maheshwarligade
https://www.techwasti.com/
\==========================**=========================
If this article adds any value to you then please clap and comment.
Let’s connect on Stackoverflow, LinkedIn, & Twitter.
