answers.ml

Download file: answers.ml
(*** Keep these lines. ***)
let qfile = "qqs.ml" ;;
let formatter = Format.(make_formatter (fun _ _ _ -> ()) (fun () -> ())) ;;
Topdirs.dir_use formatter (if Sys.file_exists qfile then qfile else Sys.getenv "HOME" ^ "/Exam-OCaml/" ^ qfile) ;;

(************************************)


(*****  QUESTION 1  *****)

let f1 l = List.map (fun n -> Hobbit (n,110)) l

let () = q1 { ff = f1 } ;;

(*****  QUESTION 2  *****)

let f2 n l = List.map (fun r -> Elf (n,r)) l

let () = q2 { ff = f2 } ;;


(*****  QUESTION 3  *****)

let f3 l = List.fold_left (fun tall -> function Hobbit (_,s) -> max tall s | _ -> tall) 0 l 

(* Ou encore *)
let rec f3 = function
  | [] -> 0
  | Hobbit (_, s) :: rest -> max s (f3 rest)
  | _ :: rest -> f3 rest

let () = q3 { ff = f3 } ;;


(*****  QUESTION 4  *****)

let f4 f l = List.for_all f (List.filter (function Dwarf _ -> true | _ -> false) l)

(* Ou encore *)
let f4 f = function
  | [] -> true
  | Dwarf _ as guy :: rest -> f guy && f4 f rest
  | _ :: rest -> f4 f rest

;;

let () = q4 { ff = f4 } ;;


(*****  QUESTION 5  *****)

let f5 l = List.map (fun r1 -> (r1, List.filter (function Elf (_,r2) -> r1 = r2 | _ -> false) l)) [ Mirkwood ; Imladris ; Lorien ]

(* Ou encore *)
let rec from_region r = function
  | [] -> []
  | Elf (_, r2) as e :: rest -> if r = r2 then e :: from_region r rest else from_region r rest
  | _ :: rest -> from_region r rest

let f5 l = 
  [ (Mirkwood, from_region Mirkwood l) ;
    (Lorien,   from_region Lorien l) ;
    (Imladris, from_region Imladris l) ]
;;
let () = q5 { ff = f5 } ;;


(*****  QUESTION 6  *****)

let has_size s1 = function
  | Hobbit (n, s2) -> if s1 = s2 then Some n else None
  | _ -> None

let rec get_all_sizes acu = function
  | [] -> acu
  | Hobbit (_, s) :: rest -> 
    let acu2 = if List.mem s acu then acu else s :: acu in
    get_all_sizes acu2 rest

  | _ :: rest -> get_all_sizes acu rest

let f6 l = List.map (fun s -> s, List.filter_map (has_size s) l) (get_all_sizes [] l)

;;
let () = q6 { ff = f6 } ;;

(*****  QUESTION 7  *****)

let get_name = function
  | Elf (n, _) | Hobbit (n, _) | Dwarf (n, _) -> n

(* Explores recursively. The last argument is a room option. 
 * The path is the reversed path to the current room. *)
let rec f7_aux n path = function
  | None -> []
  | Some r -> 
      let path = r.tag :: path in

        if get_name r.guard = n then path (* Bingo *)
        else
          let l1 = f7_aux n path r.out1 in
            if l1 <> [] then l1 (* left branch was successfull  *)
            else f7_aux n path r.out2 (* Try right branch *)

let f7 n room = List.rev (f7_aux n [] (Some room))

;;
let () = q7 { ff = f7 } ;;