Datalogi 0 GA Forelæsning oktober 2003 Nils Andersen. Undtagelser. Kombinatorisk søgning

Transkript

1 Datalogi 0 GA Forelæsning oktober 2003 Nils Andersen Undtagelser. Kombinatorisk søgning Undtagelser Erklæring Kast Gribning Det grådige princip til løsning af et kombinatorisk problem Frembringelse af alle et kombinatorisk problems løsninger Kun første brugbare løsning Hansen & Rischel afsnit , kursusbogens bind 4 kapitel 15, Paulson side 83 85,

2 Undtagelser: erklæring Den generelle regel i SML om, at størrelser skal erklæres, før de kan bruges (eneste undtagelse: parallelle erklæringer med and) gælder også undtagelser: exception Umuligt; exception Daarligt of int; Standardundtagelser Følgende undtagelser er erklæret på forhånd (jævnfør H&R D.1.1 og Paulson side ): Overflow Div Domain Chr Subscript Size Empty Bind Match Interrupt Option Fail of string 2

3 Undtagelser: kast if b * b * a * c < 0.0 then raise Umuligt else...; if i < 0 then raise Daarligt i else...; Undtagelses pakker forplanter sig (med mindre de gribes undervejs) ud gennem udtryk og funktionskald, til de meldes på yderste niveau og standser beregningen. Undtagelser: gribning u handle Umuligt => v; Hvis beregning af udtrykket u resulterer i kast af undtagelsen Umuligt, beregnes i stedet v. Ellers fås værdien af u. (Eventuelle andre undtagelser forplanter sig videre.) f (x,y) handle => 1.0; g n handle Daarligt k => g ( k); 3

4 Grådige princip Pengevekslingsproblemet (eller: betale med lige penge); i det danske møntsystem for eksempel 1425 = Metode: Prøv mulighederne af fra en ende af, idet den største mønt prøves først; når den ikke længere kan bruges, så den næststørste, osv. (det kaldes det grådige princip). Man må holde styr på mntr = en liste af møntværdier (i øre) i faldende orden og blb = beløb, der skal dannes. - fun betalg (_,0) = [] betalg ([],_) = raise Fail "ubetaleligt" betalg (mntr1 as mnt :: mntr,blb) = if mnt > blb then betalg (mntr,blb) else mnt :: betalg (mntr1,blb - mnt) De to simplere delproblemer har henholdsvis færre møntstørrelser at prøve med og et mindre beløb at betale. - val DKmntr = [2000,1000,500,200,100,50,25]; - betalg (DKmntr,1425); > val it = [1000,200,200,25] : int list 4

5 Alle løsninger Det grådige princip fungerer ikke altid: - betalg ([500,200],1100);! Uncaught exception:! Fail "ubetaleligt" Med andre ord: Man skal ikke altid bruge den første den bedste mønt. Dan i stedet listen af alle løsninger: - fun foranalle (_,[]) = [] foranalle (x,xr :: xrr) = (x :: xr) :: foranalle (x, xrr) - fun betala (_,0) = [[]] betala ([],_) = [] betala (mntr1 as mnt :: mntr,blb) = if mnt > blb then betala (mntr,blb) else foranalle (mnt, betala (mntr1,blb - betala (mntr,blb); - betala ([500,200],1100); > val it = [[500, 200, 200, 200]] : int list list - betala (DKmntr,1425); > val it = 5

6 Forenklinger 1 Deludtrykket betala (mntr,blb) kun en gang: - fun betala1 (_,0) = [[]] betala1 ([],_) = [] betala1 (mntr1 as mnt :: mntr,blb) = (if mnt > blb then [] else foranalle (mnt, betala1 betala1 (mntr,blb) Man kan tillade en subtraktion mere: - fun betala2 (_,0) = [[]] betala2 ([],_) = [] betala2 (mntr1 as mnt :: mntr,blb) = if blb < 0 then [] else foranalle (mnt, betala2 betala2 (mntr,blb) 6

7 Forenklinger 2 Opsamles de foransatte mønter i en ekstra parameter, overflødiggøres foranalle. Lad forreste parameter bmntr ( betalingsmønter) være de mønter, det allerede er besluttet at bruge: - fun betala (bmntr,_,0) = [bmntr] betala (_,[],_) = [] betala (bmntr,mntr1 as mnt :: mntr,blb) = if blb < 0 then [] else betala betala (bmntr,mntr,blb) - fun betala3 (mntr,blb) = betala ([],mntr,blb); - betala3 (DKmntr,125); > val it = [[25, 100], [25, 50, 50], [25, 25, 25, 50], [25, 25, 25, 25, 25]] : int list list (Paulson afsnit 3.7) 7

8 Første løsning - exception Ubetaleligt; - fun betalb (_,0) = [] betalb ([],_) = raise Ubetaleligt betalb (mntr1 as mnt :: mntr,blb) = if blb < 0 then raise Ubetaleligt else mnt :: betalb (mntr1,blb - mnt) handle Ubetaleligt => betalb (mntr,blb); - betalb (DKmntr,1425); > val it = [1000, 200, 200, 25] : int list - betalb ([500,200],1100); > val it = [500, 200, 200, 200] : int list (Paulson afsnit 4.8) 8

9 Otte-dronninge-problemet En dronning i skak slår vandret, lodret og diagonalt. Placer på et skakbræt otte dronninger, så ingen af dem kan slå nogen af de andre. Problemet blev blandt andet stillet af Leonhard(t) Euler ( ). Modulo symmetri er der 12 løsninger. (92 løsninger, hvis symmetri ikke tages i betragtning.) 9

10 Blindgydesøgning Placer en dronning i hver søjle, idet søjlerne tages i betragtning en ad gangen (for x = 8, 7, 6, 5, 4, 3, 2, 1). Når en dronning skal placeres i en søjle, så prøv rækkerne en ad gangen (for y = 8, 7, 6, 5, 4, 3, 2, 1). Funktionen dronning (x, y, [y x+1,..., y 7, y 8 ]) løser det delproblem at placere en dronning i søjle x, række y (eller en lavere række), under forudsætning af, at der allerede er placeret dronninger i (x + 1, y x+1 ),..., (7, y 7 ), (8, y 8 ). exception Dronning; (* Hjaelpedefinitioner indsaettes her *) fun dronning (x,y,yr) = if x < 1 then yr else if y < 1 then raise Dronning else if sikker ((x,y),x+1,yr) then dronning (x-1,8,y :: yr) handle Dronning => dronning (x,y-1,yr) else dronning (x,y-1,yr); (* Kaldes saaledes paa yderste niveau: print (visbraet (dronning (8,8,[]))); *) 10

11 Hjælpedefinitioner Tekst med n prikker fun prikker 0 = "" prikker n = ". " ^ prikker (n - 1); Brættet med dronninger vises som et (8 x 8)- felt af prikker, med dronningerne som asterisker: fun visbraet [] = "" visbraet (y :: yr) = prikker (y-1) ^ "* " ^ prikker (8-y) ^ "\n" ^ visbraet yr; Dronningerne på (x, y) og (x1, y1) kan slå hinanden. (Vi ved x < x1.) fun slaar ((x,y),(x1,y1)) = (* x = x1 orelse *) y = y1 orelse x + y = x1 + y1 orelse x - y = x1 - y1; Dronningen på (x, y) kan ikke slås af nogen af dem på listen i tredje parameter (hvor de tilsvarende x er løber fra x1 til 8): fun sikker ((x,y),_,[]) = true sikker ((x,y),x1,y1 :: yr) = not (slaar ((x,y),(x1,y1))) andalso sikker ((x,y),x1 + 1,yr) 11

12 Udførelse - print (visbraet (dronning (8,8,[])));.... * *.. * *.... *..... * * * > val it = () : unit Edsger W. Dijkstra (1970): Notes on structured programming, Technical University Eindhoven. Nilaus Wirth (April 1971): Program Development by Stepwise Refinement, Comm. ACM 14, Peter Naur (1972): An Experiment on Program Development, BIT 12,