Desafío de ejemplo

struct Sudoku {
  data: Vec<Vec<u32>>,
}

impl Sudoku {
  fn new(data: Vec<Vec<u32>>) -> Self {
      Sudoku { data }
  }

  fn is_valid(&self) -> bool {
      let lil_squares_qty = self.data.len();
      let sqr_size = (lil_squares_qty as f64).sqrt() as usize;
      let sum_required: u32 = (1..=lil_squares_qty as u32).sum();

      let is_array_x = |arr: &Vec<u32>| arr.iter().sum::<u32>() == sum_required;

      let col_to_arr = |n: usize| self.data.iter().map(|v| v[n]).collect::<Vec<u32>>();
      let sqr_to_arr = |r: usize, c: usize| {
          let mut result = Vec::new();
          for i in r..r + sqr_size {
              result.extend_from_slice(&self.data[i][c..c + sqr_size]);
          }
          result
      };

      let validate_sqrs = || -> bool {
          for i in 0..lil_squares_qty {
              let r = sqr_size * (i / sqr_size);
              let c = sqr_size * (i % sqr_size);
              let arr = sqr_to_arr(r, c);
              if !is_array_x(&arr) {
                  return false;
              }
          }
          true
      };

      let validate_rows = || -> bool {
          self.data.iter().all(|row| is_array_x(row))
      };

      let validate_cols = || -> bool {
          (0..lil_squares_qty).all(|i| is_array_x(&col_to_arr(i)))
      };

      validate_rows() && validate_cols() && validate_sqrs()
  }
}

fn main() {
  let sudoku_data: Vec<Vec<u32>> = vec![
      vec![7, 8, 4, 1, 5, 9, 3, 2, 6],
      vec![5, 3, 9, 6, 7, 2, 8, 4, 1],
      vec![6, 1, 2, 4, 3, 8, 7, 5, 9],
      vec![9, 2, 8, 7, 1, 5, 4, 6, 3],
      vec![3, 5, 7, 8, 4, 6, 1, 9, 2],
      vec![4, 6, 1, 9, 2, 3, 5, 8, 7],
      vec![8, 7, 6, 3, 9, 4, 2, 1, 5],
      vec![2, 4, 3, 5, 6, 1, 9, 7, 8],
      vec![1, 9, 5, 2, 8, 7, 6, 3, 4],
  ];

  let sudoku = Sudoku::new(sudoku_data);
  let is_valid = sudoku.is_valid();

  println!("Is Sudoku valid? {}", is_valid);
}