How to find the greatest product of 3 adjacent numbers in the same (any) direction in a grid with Rust

1 Answer

0 votes
fn find_greatest_product(grid: &[Vec<i32>]) -> (i32, i32, i32, i32) {
    let rows = grid.len();
    let cols = grid[0].len();
    let mut max_product = 0;
    let mut maxnumber1 = 0;
    let mut maxnumber2 = 0;
    let mut maxnumber3 = 0;

    for i in 0..rows {
        for j in 0..cols {
            // Horizontal (right)
            if j + 2 < cols {
                let product = grid[i][j] * grid[i][j + 1] * grid[i][j + 2];
                if product > max_product {
                    max_product = product;
                    maxnumber1 = grid[i][j];
                    maxnumber2 = grid[i][j + 1];
                    maxnumber3 = grid[i][j + 2];
                }
            }

            // Vertical (down)
            if i + 2 < rows {
                let product = grid[i][j] * grid[i + 1][j] * grid[i + 2][j];
                if product > max_product {
                    max_product = product;
                    maxnumber1 = grid[i][j];
                    maxnumber2 = grid[i + 1][j];
                    maxnumber3 = grid[i + 2][j];
                }
            }

            // Diagonal (down-right)
            if i + 2 < rows && j + 2 < cols {
                let product = grid[i][j] * grid[i + 1][j + 1] * grid[i + 2][j + 2];
                if product > max_product {
                    max_product = product;
                    maxnumber1 = grid[i][j];
                    maxnumber2 = grid[i + 1][j + 1];
                    maxnumber3 = grid[i + 2][j + 2];
                }
            }

            // Diagonal (down-left)
            if i + 2 < rows && j >= 2 {
                let product = grid[i][j] * grid[i + 1][j - 1] * grid[i + 2][j - 2];
                if product > max_product {
                    max_product = product;
                    maxnumber1 = grid[i][j];
                    maxnumber2 = grid[i + 1][j - 1];
                    maxnumber3 = grid[i + 2][j - 2];
                }
            }
        }
    }

    println!("maxnumber1: {}", maxnumber1);
    println!("maxnumber2: {}", maxnumber2);
    println!("maxnumber3: {}", maxnumber3);

    (max_product, maxnumber1, maxnumber2, maxnumber3)
}

fn main() {
    let grid: Vec<Vec<i32>> = vec![
        vec![1, 2, 3, 4, 5, 6, 7],
        vec![8, 9, 10, 11, 12, 13, 14],
        vec![49, 49, 99, 40, 17, 81, 18],
        vec![44, 20, 45, 35, 14, 0, 61],
        vec![26, 97, 17, 78, 80, 96, 83],
        vec![16, 7, 97, 57, 32, 16, 27],
        vec![60, 74, 31, 49, 71, 48, 86],
    ];

    let (result, _, _, _) = find_greatest_product(&grid);

    println!("Greatest product of 3 adjacent numbers: {}", result);
}


    
/*
run:

maxnumber1: 80
maxnumber2: 96
maxnumber3: 83
Greatest product of 3 adjacent numbers: 637440
   
*/
  
 

 



answered Jul 26, 2025 by avibootz
...