(* FP-2 Opgave 7.2: *)

(* Til højrestillingsopgaven omskriver vi funktionen ljustify fra FP-2 og 
   tilføjer en exception, hvis strengen er længere end feltet. Vi 
   definerer først hjælpefunktionen blanke: *)

fun blanke(n) = if n = 0 then [] else #" " :: blanke(n-1);
   
fun rjustify(w,s) = 
	let val rest = w - size s
	in if w < size s then raise Size else implode(blanke(rest)) ^ s
	end;

(* TEST *)	
	
val testrjustify1 = rjustify(5,"o") = "    o" handle _ => false;
val testrjustify2 = (rjustify(1,"ooo"); false) handle Size => true | _ => false;
val testrjustify3 = rjustify(10,"Anders") = "    Anders" handle _ => false;

(* Til centreringsopgaven genbruger vi nogenlunde ovenstående, dog vælger vi, 
   at hvis der er et ulige antal mellemrum tilbage, forskyder vi strengen én 
   mod venstre (man kunne også have valgt at raise en exception, hvis w er ulige, 
   men det ville næsten være for kedeligt...): *)

fun cjustify (w,s) = 
	let val rest = w - size s
		val left = rest div 2
		val right = rest - left
	in if w < size s then raise Size else implode(blanke(left)) ^ s ^ implode(blanke(right))
	end;

(* TEST *)	
	
val testcjustify1 = cjustify(5,"o") = "  o  " handle _ => false;
val testcjustify2 = cjustify(10,"Anders") = "  Anders  " handle _ => false;
val testcjustify2 = cjustify(11,"Anders") = "  Anders   " handle _ => false;
val testcjustify3 = (cjustify(5,"Anders"); false) handle Size => true | _ => false;;



(* Opgave DT2: *)

(* Vi vil for nemheds skyld antage, at vi kun tjekker efter SMÅ bogstaver.
   Vi laver først den nødvendige typedefinition af vores træ: *)

datatype 'a tree = Leaf of 'a 
				 | Node of 'a * 'a tree * 'a tree;

(* Og laver så en hjælpefunktion, der giver 1, hvis en streng indledes af et af 
   bogstaverne a,e,i,o,u, og 0 ellers (kan selvfølgelig nemt udvides med flere 
   bogstaver i listen): *)
				 
val vokal = [#"a",#"e",#"i",#"o",#"u"];

fun testvokal("",_) = 0 
  | testvokal(s,[]) = 0
  | testvokal(s,x::xs) = if String.sub(s,0) = x then 1 else testvokal(s,xs);
					  
(* Og til sidst funktionen antalVok, som tæller variablen 1 op, hvis 
   et Leaf eller Node starter med de relevante bogstaver: *)					  
					  
fun antalVok(Leaf(t))     = testvokal(t,vokal)
  | antalVok(Node(a,b,c)) = testvokal(a,vokal) + antalVok(b) + antalVok(c);


(* TEST *)

val testantalVok4 = antalVok(Node("klaus",Node("otto",Leaf "gert",Leaf "ulla"),Leaf "anne")) = 3;
val testantalVok3 = antalVok(Leaf "anne") = 1;
val testantalVok2 = antalVok(Leaf "Hanne") = 0;
val testantalVok1 = antalVok(Leaf "Anne") = 0;
val testantalVok0 = antalVok(Node("",Node("otto",Leaf "gert",Leaf "ulla"),Leaf "anne")) = 3;



(* Opgave HF3: *)

(* Vi anvender funktionerne partition og quicksort fra FP-2, idet vi i stedet for 
   <= -operatoren i partition indsætter vores egen (samlg). Da vores egen operator skal 
   stå som argument i vores qsortWith-funktion, er hele møget nødt til at erklæres
   inden i vores qsortWith. Ud over det er det bare afskrift...: *)

local
    fun partition(_,[],samlg) = ([],[])
      | partition(pivot,x::xr,samlg)
        = let val (xv,xh) = partition(pivot,xr,samlg)
          in if samlg(x,pivot) then (x::xv,xh)
    	  					   else (xv,x::xh)
          end
	fun quicksort([],samlg)     = []
      | quicksort(x::xr,samlg)
        = let val (xv,xh) = partition(x,xr,samlg)
   	      in quicksort(xv,samlg) @ x :: quicksort(xh,samlg)
	      end
in
    fun qsortWith samlg s = quicksort(s,samlg)
end;

(* TEST *)

val testqsortWith1 = qsortWith (op<) [3,5,4,2,3] = [2,3,3,4,5];
val testqsortWith1 = qsortWith (op>) [3,5,4,2,3] = [5,4,3,3,2];
val testqsortWith3 = qsortWith (fn (c1,c2) => ord c1 > ord c2) (explode " 1 ^") = explode "^1  ";



(* Opgave HF4: *)

(* Vi definerer vores hjælpefunktion lti i den naive tro, at inddata rent faktisk 
   er gyldige (altså et triple af formen (string*int*bool) ): *)

fun lti((_,_,true),(_,_,false)) = true
  | lti((_,_,false),(_,_,true)) = false
  | lti((_,b1,_),(_,b2,_))      = b1 > b2;

(* TEST *)	  

local
val employees = [("Hans", 10000, true), ("Ole", 14000, false),
                ("Birgit", 22000, true), ("Fred", 15000, false)]
val sortedEmployees = [("Birgit", 22000, true), ("Hans", 10000, true),
("Fred", 15000, false), ("Ole", 14000, false)]
in
val testSortEmployees4 = qsortWith lti employees = sortedEmployees
end;

val testSortEmployees5 = qsortWith lti [("Anders",1000000,false),("Fritz",0,true),("Claus",1,true)]
    = [("Claus",1,true),("Fritz",0,true),("Anders",1000000,false)];