Nested Loops

Introduction: Nested loops are a powerful feature in Rust, especially when dealing with multi-dimensional arrays. In this blog post, we'll dive into the concept of nested loops, their syntax, and provide examples of how they can be used effectively in Rust programming.

Understanding Nested Loops: Nested loops refer to the situation where one loop is contained within another loop. This setup is commonly used when iterating over multi-dimensional data structures like arrays. In Rust, nested loops provide a clean and efficient way to access and manipulate elements in such arrays.

Syntax of Nested Loops in Rust:

// Example of Nested Loops in Rust
fn main() {
    let matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

    for row in matrix.iter() {
        for num in row.iter() {
            print!("{}\t", num); // Using tab character for spacing
        }
        println!(); // Print new line after each row
    }
}

Explanation: In the above code snippet, we have a 3x3 matrix represented as a nested array. We use nested for loops to iterate over each element in the matrix. The outer loop iterates over the rows of the matrix, while the inner loop iterates over the elements within each row. By doing so, we can individually access and process each element of the matrix.

Example: Modifying Array Values with Nested Loops:

// Example of Modifying Array Values with Nested Loops
fn main() {
    let mut matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

    for row in matrix.iter_mut() {
        for num in row.iter_mut() {
            *num += 10; // Increment each element by 10
        }
    }

    // Print modified matrix
    for row in matrix.iter() {
        for num in row.iter() {
            print!("{}\t", num);
        }
        println!();
    }
}

Explanation: In this example, we first declare the matrix as mutable using the mut keyword. Then, we use nested mutable iterators (iter_mut()) to iterate over each element of the matrix. Within the inner loop, we use the += operator to increment each element by 10. Finally, we print the modified matrix to verify the changes.

Conclusion: Nested loops are a fundamental concept in Rust programming, especially when working with multi-dimensional arrays. They provide a clean and concise way to access, iterate, and modify elements within complex data structures. By mastering nested loops, Rust developers can efficiently manipulate arrays and other data collections in their programs.