p11.fs

let solve_p11 () =
  let num_matrix : int [] [] = [|
    [|08;02;22;97;38;15;00;40;00;75;04;05;07;78;52;12;50;77;91;08|];
    [|49;49;99;40;17;81;18;57;60;87;17;40;98;43;69;48;04;56;62;00|];
    [|81;49;31;73;55;79;14;29;93;71;40;67;53;88;30;03;49;13;36;65|];
    [|52;70;95;23;04;60;11;42;69;24;68;56;01;32;56;71;37;02;36;91|];
    [|22;31;16;71;51;67;63;89;41;92;36;54;22;40;40;28;66;33;13;80|];
    [|24;47;32;60;99;03;45;02;44;75;33;53;78;36;84;20;35;17;12;50|];
    [|32;98;81;28;64;23;67;10;26;38;40;67;59;54;70;66;18;38;64;70|];
    [|67;26;20;68;02;62;12;20;95;63;94;39;63;08;40;91;66;49;94;21|];
    [|24;55;58;05;66;73;99;26;97;17;78;78;96;83;14;88;34;89;63;72|];
    [|21;36;23;09;75;00;76;44;20;45;35;14;00;61;33;97;34;31;33;95|];
    [|78;17;53;28;22;75;31;67;15;94;03;80;04;62;16;14;09;53;56;92|];
    [|16;39;05;42;96;35;31;47;55;58;88;24;00;17;54;24;36;29;85;57|];
    [|86;56;00;48;35;71;89;07;05;44;44;37;44;60;21;58;51;54;17;58|];
    [|19;80;81;68;05;94;47;69;28;73;92;13;86;52;17;77;04;89;55;40|];
    [|04;52;08;83;97;35;99;16;07;97;57;32;16;26;26;79;33;27;98;66|];
    [|88;36;68;87;57;62;20;72;03;46;33;67;46;55;12;32;63;93;53;69|];
    [|04;42;16;73;38;25;39;11;24;94;72;18;08;46;29;32;40;62;76;36|];
    [|20;69;36;41;72;30;23;88;34;62;99;69;82;67;59;85;74;04;36;16|];
    [|20;73;35;29;78;31;90;01;74;31;49;71;48;86;81;16;23;57;05;54|];
    [|01;70;54;71;83;51;54;69;16;92;33;48;61;43;52;01;89;19;67;48|]; |]
  in
  let rotate_matrix (matrix: int [] []) =
    let nr_row = Array.length matrix - 1 in
      [| for i in 0 .. nr_row do yield Array.map (fun (row: int[]) ->
                                                    row.[i]) matrix |]
  in
  let rev_matrix (matrix: int [] []) =
    (* reverse each row in the matrix *)
    Array.map (fun row -> Array.rev row) matrix
  in
  let bottom_diagonal_ul2br start_row_idx (matrix: int [] []) =
    (* Get bottom half diagonal line from upper-left to bottom-right. *)
    let max_row_idx = Array.length matrix - 1 in
    let rec build_line cur_row_idx cur_col_idx acc =
      if cur_row_idx > max_row_idx then acc
      else
        let cur_ele = matrix.[cur_row_idx].[cur_col_idx] in
          build_line (cur_row_idx + 1) (cur_col_idx + 1) (cur_ele :: acc)
    in
      build_line start_row_idx 0 [] |> List.rev |> List.toArray
  in
  let diagonal_ul2br (matrix: int [] []) =
    let max_row_idx = Array.length matrix - 1 in
    let bottom_half =
      Array.map (fun idx ->
                   bottom_diagonal_ul2br idx matrix) [|0 .. max_row_idx|] in
    let upper_half =
      Array.map (fun idx ->
                   bottom_diagonal_ul2br idx (rotate_matrix matrix)) [|1..max_row_idx|]
    in
      Array.append bottom_half upper_half
  in
  let diagonal_ur2bl (matrix: int [] []) =
    diagonal_ul2br (rev_matrix matrix)
  in
  let find_max_prod4 = Util.max_prod_of_adjacent 4 in
  let x1s = Array.map find_max_prod4 num_matrix in
  let x2s = Array.map find_max_prod4 (rotate_matrix num_matrix) in
  let x3s = Array.map find_max_prod4 (diagonal_ul2br num_matrix) in
  let x4s = Array.map find_max_prod4 (diagonal_ur2bl num_matrix) in
  let accumulator acc n = if acc > n then acc else n in
    List.fold accumulator 0
      (List.map (Array.fold accumulator 0) [x1s; x2s; x3s; x4s])

printfn "%d" (solve_p11())