···

       
1
       
1
       
 
       
let filename = "./day_01_input.txt"

     

       
2
       
2
       
+
       
let try_read ic = try Some (input_line ic) with End_of_file -> None

     

       
2
       
3
       
 
       


     

       
3
       
3
       
-
       
let () =

     

       
4
       
4
       
-
       
  let ic = open_in filename in

     

       
4
       
4
       
+
       
let line_to_ints s =

     

       
5
       
5
       
+
       
  Str.split_delim (Str.regexp "   ") s |> List.map int_of_string

     

       
5
       
6
       
 
       


     

       
6
       
6
       
-
       
  let try_read () = try Some (input_line ic) with End_of_file -> None in

     

       
7
       
7
       
+
       
let rec read_lines left right ic =

     

       
8
       
8
       
+
       
  match try_read ic with

     

       
9
       
9
       
+
       
  | Some line -> (

     

       
10
       
10
       
+
       
      line_to_ints line |> fun ints ->

     

       
11
       
11
       
+
       
      match ints with

     

       
12
       
12
       
+
       
      | [ a; b ] -> read_lines (a :: left) (b :: right) ic

     

       
13
       
13
       
+
       
      | _ -> failwith "invalid")

     

       
14
       
14
       
+
       
  | None ->

     

       
15
       
15
       
+
       
      close_in ic;

     

       
16
       
16
       
+
       
      (List.sort compare left, List.sort compare right)

     

       
7
       
17
       
 
       


     

       
8
       
8
       
-
       
  let rec read_lines left right =

     

       
9
       
9
       
-
       
    match try_read () with

     

       
10
       
10
       
-
       
    | Some line -> (

     

       
11
       
11
       
-
       
        let ints =

     

       
12
       
12
       
-
       
          Str.split_delim (Str.regexp "   ") line |> List.map int_of_string

     

       
13
       
13
       
-
       
        in

     

       
14
       
14
       
-
       
        match ints with

     

       
15
       
15
       
-
       
        | [ a; b ] -> read_lines (a :: left) (b :: right)

     

       
16
       
16
       
-
       
        | _ -> failwith "invalid")

     

       
17
       
17
       
-
       
    | None ->

     

       
18
       
18
       
-
       
        close_in ic;

     

       
19
       
19
       
-
       
        (List.sort compare left, List.sort compare right)

     

       
20
       
20
       
-
       
  in

     

       
21
       
21
       
-
       
  let left, right = read_lines [] [] in

     

       
22
       
22
       
-
       
  let sum =

     

       
23
       
23
       
-
       
    List.map2 ( - ) left right |> List.map abs |> List.fold_left ( + ) 0

     

       
24
       
24
       
-
       
  in

     

       
25
       
25
       
-
       
  Printf.sprintf "Sum %d" sum |> print_endline;

     

       
26
       
26
       
-
       
  let sim =

     

       
27
       
27
       
-
       
    List.map

     

       
28
       
28
       
-
       
      (fun x -> x * (List.filter (fun y -> x == y) right |> List.length))

     

       
29
       
29
       
-
       
      left

     

       
30
       
30
       
-
       
    |> List.fold_left ( + ) 0

     

       
31
       
31
       
-
       
  in

     

       
32
       
32
       
-
       
  Printf.sprintf "Sim %d" sim |> print_endline

     

       
18
       
18
       
+
       
let calc_sum left right =

     

       
19
       
19
       
+
       
  List.map2 ( - ) left right |> List.map abs |> List.fold_left ( + ) 0

     

       
20
       
20
       
+
       


     

       
21
       
21
       
+
       
let calc_sim left right =

     

       
22
       
22
       
+
       
  List.map

     

       
23
       
23
       
+
       
    (fun x -> x * (List.filter (fun y -> x == y) right |> List.length))

     

       
24
       
24
       
+
       
    left

     

       
25
       
25
       
+
       
  |> List.fold_left ( + ) 0

     

       
26
       
26
       
+
       


     

       
27
       
27
       
+
       
let () =

     

       
28
       
28
       
+
       
  let left, right = open_in filename |> read_lines [] [] in

     

       
29
       
29
       
+
       
  calc_sum left right |> Printf.sprintf "Sum %d" |> print_endline;

     

       
30
       
30
       
+
       
  calc_sim left right |> Printf.sprintf "Sim %d" |> print_endline

     

···

       
1
       
1
       
 
       
(executable (name day_01)

     

       
2
       
2
       
 
       
(libraries str))

     

       
3
       
3
       
+
       
(executable (name day_02))