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 rec f1 tt ll =
  tt = ll ||
  match ll with
  | [] -> false
  | _ :: yy -> f1 tt yy
;;

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

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

let f2 g = try g () ; None with e -> Some e  
;;

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

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

let f3 cat = List.filter (fun t -> t.size <> XL) cat
;;

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

(*****  QUESTION 4  *****)
let f4 c p ll = List.length (List.filter (fun t -> t.color = c && t.price <= p) ll)

(* Variant *)
let rec f4 c p = function
  | [] -> 0
  | t :: rest -> if t.color = c && t.price <= p then 1 + f4 c p rest else f4 c p rest
;;

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

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

(* Insert x in list l, if not already there. *)
let insert x l = if List.mem x l then l else x :: l

let f5 s ll = List.fold_left (fun acu t -> if t.size = s then insert t.color acu else acu) [] ll
;;

let () = q5 { ff = f5 } ;;

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

(* Insert t in association list 'asso'. Its key is given by f t. *)
let ins f asso t =

  let key = f t in

  (* Insert in the association list *)
  let rec loop acu = function
    (* Not found => we create a new entry *)
    | [] -> (key, [t]) :: acu

    | (k,l) as p :: rest ->
      (* This is the key we are looking for. *)
      if k = key then List.rev_append ((k, t :: l) :: acu) rest

      (* This is another key *)
      else loop (p :: acu) rest
  in

  loop [] asso
;;

let f6 ll = List.fold_left (ins (fun t -> t.color)) [] ll


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

(*****  QUESTION 7  *****)
let f7 tree =

  let rec loop acu t =
    let acu0 = if t.value.size = XL then t.id :: acu else acu in
    List.fold_left loop acu0 t.children
  in

  loop [] tree

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

(*****  QUESTION 8  *****)

let mk_leaf i = { value = i ; id = 0 ; children = [] }
let mk_node i l = { value = i ; id = 0 ; children = l }

(* mk_tree : crits contient la liste des niveaux. Un niveau est une liste de filtres. *)
let mk_tree cat crits =
  let rec loop cat = function
    | [] -> mk_leaf (List.length cat)
    | ks :: rest -> mk_node (List.length cat) (List.map (fun k -> loop (List.filter k cat) rest) ks)
  in
  loop cat crits

let mk_size_crit l  = List.map (fun s t -> t.size = s) l
let mk_color_crit l = List.map (fun c t -> t.color = c) l

let f8 sizes colors cat = mk_tree cat [ mk_size_crit sizes ; mk_color_crit colors ]

;;
let () = q8 { ff = f8 } ;;