Submission #108538

---

Source Code Expand

let (|>) x f = f x ;;
let (@@) f x = f x ;;

let ident x = x ;;

let char_to_int x = int_of_char x - int_of_char '0' ;;
let int_to_char x = char_of_int (x + int_of_char '0') ;;

module List = struct
  include ListLabels ;;

  let rec iteri i f = function
    | [] -> ()
    | a::l -> f i a; iteri (i + 1) f l

  let iteri ~f l = iteri 0 f l
end
;;

module Array = struct
  include ArrayLabels ;;

  let reduce ~f xs =
    let acc = ref xs.(0) in
    for i = 1 to length xs - 1 do
      acc := f !acc xs.(i)
    done;
    !acc
  ;;
end
;;

module String = struct
  include StringLabels ;;

  let map_to_list ~f ss =
    let res = ref [] in
    iter ss ~f:(fun c -> res := f c :: !res);
    List.rev !res
  ;;

  let of_char_list ss =
    let res = String.create @@ List.length ss in
    List.iteri ss ~f:(fun i c -> res.[i] <- c);
    res
  ;;

  let iteri ~f a =
    for i = 0 to length a - 1 do f i (unsafe_get a i) done
  ;;
end
;;

module Float = struct
  let (+) = (+.)
  let (-) = (-.)
  let ( * ) = ( *. )
  let (/) = (/.)
end
;;

module Int64 = struct
  include Int64
  let (+) = add
  let (-) = sub
  let ( * ) = mul
  let (/) = div
end
;;

let fold_for ?(skip=1) min max ~init ~f =
  let acc = ref init in
  let cur = ref min in
  while !cur < max do
    acc := f !acc !cur;
    cur := !cur + skip;
  done;
  !acc
;;

let iter_for ?(skip=1) min max ~f =
  let cur = ref min in
  while !cur < max do
    f !cur;
    cur := !cur + skip;
  done
;;

let () =
  let n = Scanf.scanf "%d " (fun x -> x) in
  let rec iter i =
    if i = 0 then []
    else
      let time = Scanf.scanf "%2d%2d-%2d%2d " (fun x y z w -> (x, y), (z, w)) in
      time :: iter (i - 1) in
  let lst =
    iter n |>
    List.map ~f:(fun ((s1, s2), (e1, e2)) -> (s1, s2 - s2 mod 5),
      (e1, (e2 - e2 mod 5) + if e2 mod 5 = 0 then 0 else 5)) |>
    List.map ~f:(fun ((s1, s2) as s, ((e1, e2) as e)) ->
      let s = if s2 = 60 then (s1 + 1, 0) else s in
      let e = if e2 = 60 then (e1 + 1, 0) else e in
      (s, e)) |>
    List.sort ~cmp:compare in
  List.iter lst ~f:(fun ((s1, s2), (e1, e2)) -> Printf.eprintf "debug:%02d%02d-%02d%02d\n" s1 s2 e1 e2);
  let h :: t = lst in
  let (res, last) = List.fold_left t ~init:([], h) ~f:(fun (acc, (lstart, lend)) (start, end_) ->
    if lend < start then ((lstart, lend) :: acc, (start, end_))
    else (acc, (lstart, max lend end_))) in
  let res = List.rev (last :: res) in
  List.iter res ~f:(fun ((s1, s2), (e1, e2)) ->
    Printf.printf "%02d%02d-%02d%02d\n" s1 s2 e1 e2)
;;

Submission Info

Compile Error

File "./Main.ml", line 106, characters 6-12:
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
[]

Judge Result