(* Exercice 1 *)
type nat = Z | S of nat ;;

let quatre = S (S (S (S Z)));;

let rec int_of_nat (n : nat ) : int =
  match n with
  | Z -> 0
  | S (m) -> 1 + int_of_nat m;;

int_of_nat quatre ;;

let rec nat_of_int (n : int) : nat =
  match n with
  | 0 -> Z
  | _ -> S (nat_of_int (n - 1));;

quatre = nat_of_int 4;;

let rec add (a : nat) (b : nat) : nat =
  match b with
  | Z -> a
  | S(c) -> S(add a c);;

add quatre quatre;;

let rec mul (a : nat) (b : nat) : nat =
  match b with
  | Z -> Z
  | S(c) -> add a (mul a c) ;;

mul quatre quatre;;

(* Exercice 2 *)

type couleur = Bleue | Rouge and assiette = couleur * int;;

let pile = Stack.create () ;;

Stack.push (Bleue, 1) pile ;;
Stack.push (Bleue, 2) pile ;;
Stack.push (Bleue, 3) pile ;;
Stack.push (Rouge, 1) pile ;;
Stack.push (Rouge, 2) pile ;;
Stack.push (Bleue, 4) pile ;;

let ranger (pile : assiette Stack.t) : unit = (* J'impose ici une pile d'assiettes, plutôt qu'une pile générique *)
  let red = Stack.create () and blue = Stack.create () in
  while not (Stack.length pile = 0) do
    let assiette = Stack.pop pile in
    if (fst assiette) = Bleue then
      Stack.push assiette blue
      else
      Stack.push assiette red
  done ;
  
  while not (Stack.length blue = 0) do
    let assiette = Stack.pop blue in
    Stack.push assiette pile
  done ;

  while not (Stack.length red = 0) do
    let assiette = Stack.pop red in
    Stack.push assiette pile
  done ;;

ranger pile ;;
Stack.pop pile ;;

(* Exercice 3 : génération des nombres de Hamming *)
let hamming (n : int) : unit =
  let f2 = Queue.create () and f3 = Queue.create () and f5 = Queue.create () and garb = ref 0 in
  Queue.add 1 f2; Queue.add 1 f3; Queue.add 1 f5 ;
  for i = 1 to n do
    let minimum = min (min (Queue.peek f2) (Queue.peek f3)) (Queue.peek f5) in
    print_int minimum ;
    print_newline () ;
    if (Queue.peek f2) = minimum then garb := Queue.take f2 ;
    if (Queue.peek f3) = minimum then garb := Queue.take f3 ;
    if (Queue.peek f5) = minimum then garb := Queue.take f5 ;
    Queue.add (2 * minimum) f2 ;
    Queue.add (3 * minimum) f3 ;
    Queue.add (5 * minimum) f5 ;
  done ;;

hamming 100 ;;