Datalogi 0 GA Forelæsning september 2003 Nils Andersen. Tegn og tekster. Listefunktionalen map. Naïv sortering

Transkript

1 Datalogi 0 GA Forelæsning september 2003 Nils Andersen Tegn og tekster. Listefunktionalen map. Naïv sortering Typen char af tegn Typen string af tekster Eksempler Højereordensfunktionen map Sortering af en liste: Boblesortering Indsættelsessortering Udtagelsessortering KB4: 9 11, H&R: NB: Dan grupper (hver med 2 eller 3 deltagere) til besvarelse af G-opgaven 1

2 Enkelttegn Grundelementerne i inddata (fra tastaturet) og uddata (på skærmen) er tegn, typen char (eng. character ). Standardoperator underliggende type < <= > >= = <> char * char -> bool Standardnavne: ord : char -> int chr : int -> char str : char -> string explode : string -> char list implode : char list -> string Tegnkonstant: #"tegnet", for eksempel #"N", #"+", #" ". Særlig notation for visse tegn: \a tegnet BEL \b tilbagerykning \t tabulering \n linjeskift \v vertikal tabulering \f sideskift \r vognretur \" anførelsestegn \\ spejlvendt skråstreg \^c chr (ord c - 64), idet ord c skal ligge mellem 64 og 95 \ddd chr ddd, idet ddd skal være tre decimale cifre mellem 000 og 255 2

3 Tekster I sidste ende omsættes uddata på skærmen til tekst, typen string. Standardoperator underliggende type < <= > >= = <> string * string -> bool ^ string * string -> string Standardnavne: size : string -> int print : string -> unit Tekstkonstant: "nul eller flere tegn", med særlig notation for visse tegn. Bemærk: Der må ikke direkte indsættes linjeskift i en tekstkonstant; linjeskifttegn kan skrives \n eller \010 eller \^J, og tekstkonstanter kan skrives over flere linjer ved hjælp af den konvention, at opstillingstegn (blanke, tabulering, linjeskift,... ) mellem \ sidst på en linje og \ først på en linje tillige med de to \ er overspringes inde i en tekstkonstant. Nyttig omsætningsfunktion Int.toString : int -> string 3

4 Eksempel: venstrestilling Venstrestil teksten s i et felt af bredde w: fun ljustify (w,s) = let fun blnk 0 = [] blnk n = #" " :: blnk (n - 1) val restlgd = w - size s in s ^ implode (blnk restlgd) end; > val ljustify = fn : int * string -> string - ljustify (8,".\\/."); > val it = ".\\/. " : string - print it;.\/. > val it = () : unit 4

5 Eksempel: søjlediagram load "Real"; > val it = () : unit - val bredde = 42 fun maximum [] = 0.0 maximum (x :: xr) = Real.max (x,maximum xr) fun normer talliste = let val M = maximum talliste fun norm [] = [] norm (x :: xr) = round (x / M * real bredde) :: norm xr in norm talliste end fun soejle 0 = [] soejle n = #"*" :: soejle (n - 1) fun soejler [] = [] soejler (n :: nr) = soejle n :: soejler nr fun histogram talliste = let val soejleliste = soejler (normer talliste) fun vis [] = [] vis (s :: sr) = vis sr in implode (vis soejleliste) end; 5

6 forts. > val bredde = 42 : int val maximum = fn : real list -> real val normer = fn : real list -> int list val soejle = fn : int -> char list val soejler = fn : int list -> char list list val histogram = fn : real list -> string - val data = [13.5, 6.2, 24.8, 1.5, 0.4]; > val data = [13.5, 6.2, 24.8, 1.5, 0.4] : real list - histogram data; > val it = "***********************\n**********\n********** : string - print (histogram data); *********************** ********** ****************************************** *** * > val it = () : unit 6

7 Listefunktionalen map Den nyttigste af alle højereordensfunktioner løfter en funktion f, der virker på elementer, til F, der virker på lister af elementer, F [a 1, a 2,..., a n ] = [fa 1, fa 2,..., fa n ] svarende til skabelonen fun F [] = [] F (x :: xr) = f x :: F xr (1) Her er F = map f. Funktionen er til rådighed på forhånd i biblioteket, map : (α -> β) -> α list -> β list, men en mulig definition kunne være fun map f [] = [] map f (x :: xr) = f x :: map f xr eller lidt mere effektivt fun map f = let fun g [] = [] g (x :: xr) = f x :: g xr in g end 7

8 Brug af map To steder i søjlediagram-programmet forekom skabelonen (1): val soejler = map soejle eller direkte inde i histogram : val soejleliste = map soejle (normer talliste) Desuden (med en anonym funktion): val norm = map (fn x => round (x / M * real bredde)) eller direkte fun normer talliste = let val M = maximum talliste in map (fn x => round(x/m*real bredde)) talliste end 8

9 Forbedring ved naboombytning En liste ønskes svagt stigende (eng. weakly ascending). Ned gennem listen ombyttes naboelementer, der står forkert : fun bytvh (x :: y :: xr) = if x > y then y :: bytvh (x :: xr) else x :: bytvh (y :: xr) bytvh xr = xr ( Sæt foran -operatoren associerer fra højre. Mønsteret x :: y :: xr betyder x :: (y :: xr) og passer på lister med to eller flere elementer. Resttilfældet bliver derfor lister med nul eller et element.) Ubetydelig forbedring, der med et mønstersynonym undgår en overflødig gendannelse: fun bytvh (x :: (yxr as y :: xr)) = if x > y then y :: bytvh (x :: xr) else x :: bytvh yxr bytvh xr = xr Ordnende gennemløb samt angivelse af, om der mindst en gang blev byttet: fun bytvh2 (x :: (yxr as y :: xr)) = if x > y then (y :: #1 (bytvh2 (x :: xr)),true) else let val (yr,b) = bytvh2 yxr in (x :: yr,b) end bytvh2 xr = (xr,false) 9

10 Boblesortering Fortsatte ordnende gennemløb vil sortere hele listen (svagt stigende). Hvor længe skal man blive ved? 1. n 1 gange, hvis der er n elementer i listen 2. I anden gentagelse behøver sidste element ikke deltage, i tredje gentagelse ikke de to sidste elementer, Når der ikke under et helt gennemløb er foretaget ombytninger, kan man standse fun boblesort xr = let val (yr,b) = bytvh2 xr in if b then boblesort yr else xr end Man kunne lave tilsvarende funktioner, der løb listerne igennem fra højre mod venstre. 10

11 Indsættelsessortering Indsættelse efter tur i en delliste af allerede sorterede elementer: (* I kald af formen indsaet (,xr) antages xr svagt stigende *) fun indsaet (x,xr as y :: yr) = if x > y then y :: indsaet (x,yr) else x :: xr indsaet (x,[]) = [x] fun indssort (x :: xr) = indsaet (x,indssort xr) indssort [] = [] 11

12 Udtagelsessortering Som hjælpefunktion programmeres opsplitning af en ikke tom liste i dens mindste element og resten af listen (* Må ikke kaldes med tom listeparameter *) fun splitmin [x] = (x,[]) splitmin (x :: xr) = let val (y,yr) = splitmin xr in if x > y then (y,x :: yr) else (x,xr) end fun udtsort [] = [] udtsort xr = let val (y,yr) = splitmin xr in y :: udtsort yr end I begge disse to sidste funktioner lapper mønstrene over, og de kunne ikke uden videre stå i modsat orden. 12

13 Køretidsovervejelser En metodes udførelsestid udtrykkes ved størrelsesordenen af antallet af skridt som funktion af inddatas størrelse, idet man ser bort fra konstante faktorer og eventuelle særforhold for små inddata. Hvis tiden ikke entydigt afhænger af inddatas størrelse, betragtes værste tilfælde. Derved fås et mål, som ikke afhænger af det konkrete program- eller maskinsystem. Køretiden for bytvh er lineær som funktion af indgangslistens længde. Det samme gælder bytvh2. Køretiden for boblesort er kvadratisk. Selv om indsættelses- og udtagelsessortering er bedre, ændres størrelsesordenen ikke n = n(n + 1) 2 Bevis: n 1 n n n 1 n n + 1 n + 1 n n + 1 n + 1 }{{} n 13