Discrete Wiskunde. D. Bruin J.M. Jansen

Transcriptie

1 Discrete Wiskunde D. Bruin J.M. Jnsen Opleiding Hogere Informtic Noordelijke Hogeschool Leeuwrden Nederlndse defensie cdemie, fculteit militire wetenschppen Juni oktoer 2013

2 Discrete Wiskunde 2

3 1. EXPRESSIES EXPRESSIES EN HERSCHRIJVINGEN REGELS VOOR EXPRESSIES Opgven BEREKENEN VAN EXPRESSIES Opgven EXPRESSIES IN AMANDA WAARHEIDSWAARDEN (BOOLEANS) Opgven HERSCHRIJFREGELS Opgven INLEIDING FUNCTIONEEL PROGRAMMEREN FUNCTIES De Amnd interpreter Functies met meer resultten en where cluses Functies in functies FUNCTIES MET CONDITIES Opgven ANDERS DAN GETALLEN Wrheidswrden (oolens) Krkters Opgven LIJSTEN & TUPLES Lijsten vn krkters Opgven Tuples LIJST-COMPREHENSIES Opgven ZIP Opgven TYPERING IN AMANDA Typering vn expressies Typering vn functies Typering vn lijsten TOEPASSINGEN VAN LIJSTCOMPREHENSIES Opgven VOORBEELD: CIJFER ADMINISTRATIE Opgven VERWERKEN VOETBALUITSLAGEN DATABASES MBV. LIJSTCOMPREHENSIES Queries over één tel Opgven Suqueries en hulpfuncties Opgven Queries over twee tellen Opgven Complexe queries Opgven ANALYSE VAN TEKSTEN Opgven Ly-out FUNCTIES OP LIJSTEN Ptronen Opgven Ingewikkelder ptronen...39 Discrete Wiskunde 3

4 4. RECURSIE EN INDUCTIE RECURSIE Opgven INDUCTIE Opgven TORENS VAN HANOI Opgven RECURSIEVE BOMEN Opgven Opgven RECURSIEVE DATASTRUCTUREN EN BOMEN ZELF DATASTRUCTUREN MAKEN Opgven BINAIRE BOMEN Functies op omen Afdrukken vn een oom Opgven Binire Zoekomen Opgven HUFFMAN CODERING HUFFMAN BOMEN Opgven CODEER- EN DECODEER-ALGORITMEN VOOR HUFFMAN BOMEN Codeer Decoderen CONSTRUCTIE VAN DE HUFFMAN BOOM EINDIGE AUTOMATEN TALEN EN EINDIGE AUTOMATEN Opgven EEN EINDIGE AUTOMAAT BOUWEN Opgven DETERMINISME Opgven DETERMINISTISCH MAKEN VAN EEN AUTOMAAT Opgven REGULIERE EXPRESSIES Opgven GRAMMATICA S REKENKUNDIGE EXPRESSIES Opgven BACKTRACKING INLEIDING KLEUREN VAN EEN LANDKAART HET ACHT KONINGINNEN PROBLEEM Opgven GULZIGE ALGORITMEN GRAFEN Representties MINIMALE OPSPANNENDE BOOM Het lgoritme vn Kruskl Het lgoritme vn Prim Opgven KORTSTE PAD...84 Discrete Wiskunde 4

5 Het lgoritme vn Dijkstr Opgven Het lgoritme vn Floyd Opgven...87 Discrete Wiskunde 5

6 Discrete Wiskunde 6

7 1. Expressies 1.1 Expressies en herschrijvingen Discrete wiskunde gt over wiskundige structuren en technieken die vn fundmenteel elng zijn voor de informtic. Zols wiskundige eschrijvingen vn de vorm, de syntx, vn progrmmeertlen. Zols wiskundige eschrijvingen vn erekeningen. Zols het wiskundig nlyseren vn complexe dtstructuren en lgoritmen. Een veel geruikte techniek is om een oject te eschrijven met een formule (meestl een expressie genmd) en deze expressie stp voor stp te herschrijven volgens eplde rekenregels. In deze inleidende prgrf ekijken we dt procede voor de ons ekende wiskunde. De siselementen vn gewone wiskunde zijn getllen, punten, lijnen, mtrixen etc. De getllen kunnen we onderscheiden in ntuurlijke getllen (0, 1, 2...), de gehele getllen (... -2, -1, 0, 1, 2...), de reuken (1/2, 3/4..) en de reele getllen (π, 2...). Uit de siselementen kunnen we expressies opouwen m..v. functies zols sin, cos, ln en opertoren zols +, -, *, /. Vooreelden: sin π * (ln 1 + 3) (= 0) (8-2) * (8+2) (= 60) Voor de opertoren gelden llerlei rekenregels zols: (1) x + y = y + x (2) x * y = y * x (3) x * (y + z) = x * y + x * z (4) (x+y) 2 = x * x * y + y 2 (5) (x+y) * (x-y) = x 2 - y 2 Het nut vn de rekenregels is dt we er expressies mee kunnen herschrijven tot een hndiger vorm. Bijvooreeld: (8-2) * (8+2) = = 64-4 = 60 (volgens (5)) (8-2) * (8+2) = 6 * 10 = 60 Vi herschrijvingen kunnen we ook vergelijkingen oplossen: Vooreeld: 2 * x + 4 = 0 2 * x = 0-4 (vn gelijke dingen 4 ftrekken) 2 * x = * 2 * x = 0.5 * -4 x = -2 Discrete Wiskunde 7

8 Vooreeld: x * x - 12 = 0 x * x = 0 (x + 2) 2-16 = 0 (x + 2) 2 = 16 x + 2 = 4 \/ x + 2 = -4 x = 2 \/ x = -6 Vooreeld: x + 2 * y = 8 2 * x - y = 6 (stelsel vn 2 vergelijkingen met 2 onekenden) x = 8-2 * y 2 * (8-2 * y) - y = 6 (invullen in tweede vergelijking) 16-5 * y = 6-5 * y = -10 y = 2 x = 8-2 * 2 = 4 Met herschrijven moet je wel voorzichtig zijn wnt een verkeerde toepssing vn regel (2) is: * = * (x = en y = 2 + 1) Wel correct is: (1 + 2) * (2 + 1) = (2 + 1) * (1 + 2) (x = (1 + 2) en y = (2 + 1)) In het vk discrete wiskunde zullen we llerlei nieuwe wrden estuderen zols wrheidswrden (True, Flse) en lijsten. We zullen de functionele progrmmeertl Amnd estuderen die herschrijven geruikt om dingen uit te rekenen. We zullen formlismen estuderen die de precieze vorm vn expressies eschrijven. Wr het in de wiskunde voorl gt om het edenken vn efficiente lgoritmen voor het oplossen vn numerieke of ruimtelijke prolemen, gt het in de informtic veel meer om de structuur: de vorm vn expressies, de opouw vn progrmm s. 1.2 Regels voor expressies Voor rekenkundige expressies gelden er llerlei regels: * heeft een hogere prioriteit dn +, - - c moet gelezen worden ls: ( - ) - c. Indien we vn de stndrd regels willen fwijken dn geruiken we hkjes: 3 * (4 + 5) 6 - (3-1) Bij + + c mkt het niet uit hoe we de hkjes pltsen: + ( + c) ( + ) + c Discrete Wiskunde 8

9 heen eide hetzelfde resultt. Dit geldt ook voor de * opertor. + en * heten drom ook wel ssocitieve operties. Dit geldt niet voor - en /. - en / heten links-ssocitieve operties, omdt we in - - c de hkjes links moeten zetten: ( - ) - c. Er estn ook rechts-ssocitieve operties. Mchtsverheffing is hier een vooreeld vn. ^ ^ c moet gelezen worden ls ^ ( ^ c) Opgven Opgve 1.1 Zet in onderstnde expressies de hkjes op de juiste plts: 3 * ^ 7 * * ( ) 7 ^ 2-2 ^ 3 Verwijder in onderstnde expressies de overtollige hkjes: (3 * 2) (3 + (6 * 2)) (2 ^ 3) ^ ((5-2) + 1) 1.3 Berekenen vn expressies Je kunt het reultt vn een rekenkundige expressie vk op meerdere mnieren erekenen: (3 + 2) ^ 2 -> 5 ^ 2 -> 5 * 5 -> 25 of (3 + 2) ^ 2 -> (3 + 2) * (3 + 2) -> 5 * (3 + 2) -> 5 * 5 -> 25 of (3 + 2) ^ 2 -> (3 + 2) * (3 + 2) -> (3 + 2) * 5 -> 5 * 5 -> 25 Alle mnieren vn erekenen leiden tot hetzelfde resultt, lleen de eerste mnier gt het snelste. Bij rekenkundige expressies is het ltijd zo dt het resultt onfhnkelijk is vn de mnier vn erekenen. We zullen lter ndere expressies zien wrij het resultt wel fhngt vn de mnier vn erekenen Opgven Opgve 1.2 Discrete Wiskunde 9

10 Op hoeveel mnieren kn erekend worden? Op hoeveel mnieren kn 3 * * 3 erekend worden? Op hoeveel mnieren kn ((2 + 3) ^ 2) ^ 2 erekend worden? 1.4 Expressies in Amnd In de Amnd interpreter kunnen gewone rekenkundige expressies erekend worden. Amnd is in dit opzicht niet meer dn een uitgereide rekenmchine. Amnd geruikt de stndrd regels voor prioriteiten en ssocitie. In Amnd kunnen expressies echter nog veel ingewikkelder zijn. Er kunnen v. functienroepen en lijsten in voorkomen. Hieronder volgen een ntl vooreelden met functienroepen: sqr 3 telop 2 3 sqr sqr (3 + 1) // sqr en telop zijn in een file gedefinieerde functies Omdit goed te kunnen egrijpen moeten we in Amnd extr fsprken mken over proriteiteiten. sqr moeten we lezen ls (sqr 3) + 1. Het toepssen vn een functie op een rgument heeft de llerhoogste prioriteit. telop is een functie met twee rgumenten. Ook voor functies met meerdere rgumenten geruiken we lleen hkjes ls dit echt nodig is: telop etekent (telop 2 3) + 1 telop (2+3) (4+5) -> telop 5 9 -> Wrheidswrden (oolens) Tot dusver heen we lleen expressies met getllen (en functies vn getllen) ekeken. Amnd kent echter ook zgn. wrheidswrden (oolens). Zols getllen worden geruikt om te tellen of fstnden te meten worden de wrheidswrden True en Flse geruikt om n te geven of een uitsprk wr of onwr is. Vooreelden: de rde is rond = True lle zoogdieren kunnen vliegen = Flse De wrheidswrden of eigenlijk de uitsprken kunnen we comineren met de opertoren niet, en, of, ls dn. Vooreelden: Discrete Wiskunde 10

11 niet de rde is rond = Flse de rde is rond en lle zoogdieren kunnen vliegen = Flse de rde is rond of lle zoogdieren kunnen vliegen = True ls de rde is rond dn lle zoogdieren kunnen vliegen = Flse ls lle zoogdieren kunnen vliegen dn de rde is rond = True De uitkomsten vn de opertoren hngen lleen f vn de wrheidswrden vn hun opernden. Met zogenmde wrheidstellen kunnen we de werking vn de opertoren precies vstleggen. p ~p (niet p) T F F T Voor het gemk geruiken we T ls fkorting vn True en F ls fkorting vn Flse. In het vk computerorgnistie wordt hetzelfde gedn met its die dn 0 en 1 heten. p q p /\ q (p en q) T T T T F F F T F F F F p q p \/ q (p of q) T T T T F T F T T F F F p q p -> q (ls p dn q) (-> komt niet voor in Amnd) T T T T F F F T T F F T De tellen voor \/ en -> verschillen mr heel weinig. Het is niet zo moeilijk om te zien dt: p -> q = ~p \/ q We kunnen dit nrekenen met een wrheidstel voor ~p \/ q Discrete Wiskunde 11

12 p q ~p ~p \/ q T T F T T F F F F T T T F F T T Het ntl rijen vn een wrheidstel hngt f vn het ntl vrielen dt erin voorkomt. Als er 1 vriele is dn zijn 2 rijen genoeg. Bij 2 vrielen zijn er 4 rijen. Bij 3 vrielen zijn er 8 rijen. Zols het volgende vooreeld lt zien: p q r p /\ q /\ r (p /\ q /\ r) -> p T T T T T T T F F T T F T F T T F F F T F T T F T F T F F T F F T F T F F F F T Hier is iets ijzonders n de hnd: de uitsprk is ltijd wr ongecht de wrheidswrden vn de vrielen. Zo n uitsprk noemen we een tutologie. Om het ntl hkjes in expressies te eperken geruiken we de conventie dt ~ het sterkst indt, dn /\, dn \/ en ls ltste -> De expressie: p \/ ~q /\ q -> ~p moeten we dus lezen ls (p \/ ((~q) /\ q)) -> (~p) Wrheidswrden spelen een elngrijke rol ij de werking vn computersystemen. True en Fklse corresponderen hier met wel of geen spnning. In essentie zitten er in een microprocessor lleen mr schkkelingen die nd en or uit kunnen rekenen. Alle ndere operties worden hier op teruggevoerd. In het vk Computer Orgnistie komt dit uitgereid n de orde en zl er ook dieper worden ingegn op oolense logic Opgven Opgve 1.3 Bepl n de hnd vn een wrheidstel of de volgende uitsprken tutologien zijn:. p /\ ~p -> q. q -> p \/ ~p c. p -> (q -> p) d. ~p -> p \/ q e. p -> (q -> (r -> ~q)) f. p /\ q -> p \/ q Opgve 1.4 Gegeven zijn de volgende uitsprken: Discrete Wiskunde 12

13 p = het regent q = de zon schijnt Formuleer mv p en q en de logische opertoren de volgende uitsprken:. het regent niet, mr de zon schijnt wel. ls het regent dn schijnt de zon niet c. ls de zon schijnt dn regent het niet d. de zon schijnt of het regent Opgve 1.5 Geef de ontkenning vn de volgende uitsprken:. 10 is groter dn 12. het regent en de zon schijnt c. ik heet Piet of jij heet Kls d. ls het regent dn schijnt de zon niet 1.6 Herschrijfregels Voor de logische opertoren gelden llerlei ekende regels: p /\ q = q /\ p p /\ (q /\ r) = (p /\ q) /\ r p \/ q = q \/ p p \/ (q \/ r) = (p \/ q) \/ r p /\ (q \/ r) = (p /\ q) \/ (p /\ r) Veel mensen onthouden deze regels door /\ te lezen ls * en \/ ls + Er zijn meer regels: T \/ p = T F \/ p = p T /\ p = p F /\ p = F ~p /\ p = F ~p \/ p = T p \/ (q /\ r) = (p \/ q) /\ (p \/ r) ~(~ p) = p p -> q = ~p \/ q ~(p /\ q) = ~p \/ ~q ~(p \/ q) = ~p /\ ~q (ls dn regel) (regel vn De Morgn) (regel vn De Morgn) Let er ij de regels vn De Morgn op dt /\ verndert in \/ en ndersom! We kunnen de regels geruiken om expressies te vereenvoudigen. Discrete Wiskunde 13

14 p /\ q -> p = (ls dn regel) ~(p /\ q) \/ p = (De Morgn) (~p \/ ~q) \/ p = ~p \/ ~q \/ p = ~p \/ p \/ ~q = T \/ ~q = T Dus p /\ q -> p is een tutologie. De volgorde wrin de regels werden toegepst is niet willekeurig. Vk is het hndig om lle -> weg te werken met de ls dn regel en drn ~ innen hkjes te werken met De Morgn. Nog een vooreeld: ~(p -> q) -> p = (ls dn regel) ~(~(p -> q)) \/ p = (p -> q) \/ p = (ls dn regel) (~p \/ q) \/ p = ~p \/ p \/ q = T \/ q = T Alweer een tutologie Opgven Opgve 1.6 Bepl n de hnd vn herschrijving of de volgende uitsprken tutologien zijn:. p /\ ~p -> q. q -> p \/ ~p c. p -> (q -> p) d. ~p -> p \/ q e. p -> (q -> (r -> ~q)) f. p /\ q -> p \/ q Opgve 1.5 Vereenvoudig de volgende uitsprken:. (p \/ q) /\ ~p. ~(p -> q) -> p c. (~p -> ~q) -> (q -> p) d. (p -> q) -> (~q -> ~p) Discrete Wiskunde 14

15 2. Inleiding Functioneel Progrmmeren In dit hoofdstuk geven we een inleiding in Functioneel Progrmmeren. We geruiken hiervoor de functionele progrmmeertl Amnd. Functionele progrmmeertlen onderscheiden zich vn de 'gewone' progrmmeertlen, zols Pscl, C en C++, omdt ze het wiskundige functieegrip ls uitgngspunt geruiken i.p.v. het model vn de computer. De nottie vn Functioneel Progrmmeren sluit drom eter n ij de wiskunde, hetgeen ij dit vk goed vn ps komt. 2.1 Functies De functies zols ze in functioneel progrmmeren geruikt worden lijken veel op de functies zols je die ij wiskunde het gehd: verhoog x = x + 1 De functie verhoog heeft een rgument x en heeft ls resultt x + 1. Wt zijn de verschillen met de functies die je ij wiskunde gewend ws. 1. We geven de functie een nm die de lding dekt i.p.v. f, g of h. De nm moet met een kleine letter eginnen. 2. Het rgument vn de functie stt niet tussen hkjes; dus geen verhoog(x)=x+1. De reden om het rgument niet tussen hkjes te zetten is een prktische, je wilt gewoon zo weinig mogelijk typen! Hkjes worden lleen geruikt ls dit nodig is om de etekenis goed te egrijpen. Nu nog wt terminologie: 1. verhoog heet de nm vn de functie 2. x heet de nm vn het rgument 3. x + 1 heet de definiërende expressie vn de functie De definiërende expressie vn een functie mg een willekeurige rekenkundige expressie zijn wrin de rgumenten mogen voorkomen. Een functie mg ook meerdere rgumenten heen. gem x y = (x + y) // 2 gem erekent het gemiddelde vn de getllen x en y. Ook ls er meerdere rgumenten zijn geruiken we geen hkjes n de linkerknt vn de functiedefinitie. In de definiërende expressie vn deze functie (x+y) // 2 heen we wel hkjes nodig vnwege de hogere prioriteit vn // oven +. In Amnd is // deling voor reële getllen. / is deling voor gehele getllen en wordt ook wel met div ngeduid. Discrete Wiskunde 15

16 Dus: 10 // 3 = / 3 = 3 10 div 3 = De Amnd interpreter Tijdens het werkplts heen we l kennisgemkt met de Amnd interpreter. Vn de Amnd interpreter estn verschillende versies. Als we in dit diktt een vooreeld willen geven vn een expressie die geëvlueerd wordt dn doen we dit ls volgt: > 3 * Op de eerste regel voorfgegn door een > stt de expressie die geëvlueerd moet worden, op de regel drn het resultt. Functie definities stn in een file. Deze kunnen in de Amnd omgeving gelden worden Functies met meer resultten en where cluses. We gn nu eens een wt meer ingewikkelde functie ekijken. Een functie die de nulpunten vn een tweedegrds polynoom erekent. Dit gt m..v. de c-formule. In eerste instntie definiëren we twee functies, voor iedere wortel één. Als rgumenten voor deze functie geven we de coefficiënten, en c. x1 c = (- - sqrt (^2-4 * * c) // (2 * ) x2 c = (- + sqrt (^2-4 * * c) // (2 * ) Het zou frier zijn ls we een functie hdden die eide resultten in een keer oplevert. Dit kn m..v. zogenmde tuples. Een tuple is een expressie estnde uit meerdere expressies tussen hkjes en gescheiden met komm's. Vooreelden: (1,2) is het tuple estnde uit de getllen 1 en 2. (5,7,3,3*4) is het tuple estnde uit de getllen 5, 7, 3 en de expressie 3 * 4. Typ in Amnd zelf ook een ntl tuples in en kijk wt er geeurt ls je ze evlueert. We definiëren nu een nieuwe functie die eide nulpunten vn een tweedegrds polynoom erekent en het resultt oplevert in een tuple: x12 c = ((- - sqrt (^2-4**c) // (2*), (--sqrt (^2-4**c) // (2*)) Deze functiedefinitie heeft een ndeel: de expressie sqrt (^2-4**c) moet twee keer worden uitgerekend. Dit kn voorkomen worden door een zgn. where cluse te geruiken. x12 c = ((- - wd) // (2*), (- + wd) // (2*)) where wd = sqrt (^2-4 * * c) Discrete Wiskunde 16

17 Op deze mnier wordt sqrt (^2-4**c) mr één keer uitgerekend en is ook de definitie overzichtelijker geworden. Let op: In de definitie vn x12 is er nog geen rekening mee gehouden dt de discriminnt wel eens negtief kn zijn Functies in functies In de definitie vn een functie mg ook geruik gemkt worden vn ndere functies: vfunctie n = verhoog n * 2 > vfunctie 4 10 verhoog n * 2 moet hier gelezen worden ls (verhoog n) * 2. Toepssing vn een functie op een rgument gt voor iedere ndere oppertie. Wil je eerst vermenigvuldiging met 2 en drn ps verhogen, dn moet je hkjes pltsen: vfunctie2 n = verhoog (n*2) 2.2 Functies met condities Vk is het resultt vn een functie fhnkelijk vn een conditie. Neem v. de functie die de solute wrde vn een getl erekent. Dit is het getl zelf ls het getl positief is en - getl ls het getl negtief is. In Amnd wordt dit nu: s x = x, if x >= 0 = - x, if x < 0 In deze definitie moeten de = tekens precies onder elkr stn. Een lterntieve definitie die hetzelfde resultt oplevert: s x = x, if x >= 0 = -x, otherwise otherwise geruik je ls de conditie er niet toe doet. In het tweede gevl is dit zo omdt een niet positief getl utomtisch negtief is. Achter if stt een zgn. wrheidsexpressie die True of Flse oplevert. Deze mg ook ingewikkelder zijn. Een nder vooreeld vn een functie met condities: f n = 1, if x > 0 /\ x < 5 = 2, if x >= 5 /\ x < 10 = 3, otherwise Een nder vooreeld vn een functie geseerd op een conditie (let op: mx2 is l gedefinieerd in Amnd): Discrete Wiskunde 17

18 mx2 x y = x, if x >= y = y, otherwise Opgven Opgve 2.1 Definieer een functie mx3 x y z, die het mximum vn x, y en z oplevert. Opgve 2.2 Definieer een functie grootsteverschil x y z, die het mximum vn de verschillen tussen x, y en z oplevert. 2.3 Anders dn getllen Tot dusver heen we lleen functies ekeken die getllen ls rgument en resultt heen. Om echt interessnte progrmm's te mken moeten we ook met ndere zgn. dt typen kunnen werken. Vooreelden vn deze dttypen zijn krkters (v letters), wrheidswrden (True en Flse), en strings (v. nmen) Wrheidswrden (oolens) Hiervn heen we l vooreelden gezien ij functies met condities. Een functie kn echter ook True of Flse opleveren (denk om de hoofdletters). kleinerdn3 x = x < 3 > kleinerdn3 5 Flse > kleinerdn3 2 True Krkters Dit zijn 256 tekens wrmee onder ndere teksten zijn opgeouwd. Er zijn zichtre en onzichtre krkters. Zichtre krkers zijn (onder ndere):!" %^&*()_+-=[]{};:'@#~/?.>,<\ zAB..Z Onzichtre krkters zijn v: sptie, regelovergng, t, el etc. Een krkter wordt in een functie genoteerd ls zijn wrde tussen quotes: '', '', '1'. Dit wordt gedn om een krkter te onderscheiden vn een functie- of rgument-nm! Voor onzichtre krkters estn er veell specile notties: '\n' voor een regelovergng, '\t' voor een t, etc. Let op: Mk goed onderscheid tussen v. 0 (het getl nul) en '0' het krkter nul. Getllen kun je optellen, krkters niet. Discrete Wiskunde 18

19 Ieder krkter heeft een specile wrde, zijn zgn. scii code. Deze code is stndrd (dus hetzelfde voor lle computer systemen). Amnd heeft een tweetl functies om met scii codes te kunnen werken: code en decode. code levert voor een krkter zijn scii code. decode geeft voor een code het ijehorende krkter. > code '' 97 > decode 97 '' Dmv. deze codering is er ook een volgorde gedefinieerd op krkters: er geldt voor twee krkters x en y, x < y ls code x < code y. Angezien letters en cijfers in de 'goede' volgorde gecodeerd zijn levert dit geen conflikten op Opgven Opgve 2.3 Definieer de functie iseven die een getl ls rgument heeft en True oplevert ls het getl even is en Flse ls het oneven is (denk n mod (%)). Opgve 2.4 Vergelijk de scii codes vn '' en 'A', '' en 'B' etc. Bedenk nu een functie kletter die vn een hoofdletter een kleine letter mkt. Opgve 2.5 Definieer een functie isletter die gegeven een krkter ngeeft of dit een letter is:..z of A..Z. Doe hetzelfde voor cijfers. 2.4 Lijsten & Tuples Rijen vn gelijksoortige dingen heten lijsten. Lijsten worden genoteerd tussen [ en ], wrij de elementen gescheiden zijn door komm's. [1,2,3,6,3,9] [True,Flse,True] ['d','i','c','k'] [] (lege lijst) Let erop dt er lleen gelijksoortige dingen in een lijst mogen. Dus: [1,True], ['',3,4] zijn niet toegestn. De elementen in een lijst zijn genummerd vnf 0. Om het i-de element in een lijst te selecteren geruiken we de! opertor: > [4,2,6]! 0 4 > [4,2,6]! 2 Discrete Wiskunde 19

20 6 De # opertor geeft het ntl elementen vn een lijst: > # [1,2,3] 3 Mv. ++ kunnen twee lijsten n elkr geplkt worden: > [1,2] ++ [3,4] [1,2,3,4] > ['',''] ++ ['c','d'] ['','','c','d'] Let erop dt de lijsten vn dezelfde soort zijn! Met -- erekenen we het verschil vn twee lijsten. > [1,2,3,4,5,6] -- [4,2,3] [1,5,6] Let goed op ij de volgende vooreelden: > [1,1,2,2,3,3,3,3] -- [1,2,3] [1,2,3,3,3] elk element uit de tweede lijst wordt mr een keer verwijderd. > [1,2,3,4,5] -- [3,6] [1,2,4,5] met 6 geeurt niets De : opertor wordt geruikt om een element n het egin vn een lijst te plkken. > 3 : [4,5] [3,4,5] Ntuurlijk hdden we dit ook met [3] ++ [4,5] kunnen ereiken. Het geruik vn : is echter efficiënter en verdient drom de voorkeur. Er estn een ntl nuttige functies op lijsten. We geven hier lleen vooreelden vn het geruik: > tke 3 [5,6,7,8,9,1,2] [5,6,7] > drop 3 [5,6,7,8,9,1,2] [8,9,1,2] > hd [1,2,3] 1 > tl [1,2,3] [2,3] Discrete Wiskunde 20

21 hd en tl (hed en til) zijn niet gedefinieerd voor lege lijsten. tke en drop zijn complementir. Als xs een lijst is en n een getl, dn geldt er: tke n xs ++ drop n xs = xs Voor lijsten estn een ntl hndige fkortingsnotties: > [1..10] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] > [2,4..10] [2, 4, 6, 8, 10] > [7,6..1] [7, 6, 5, 4, 3, 2, 1] Let op: Lijsten kunnen ook oneindig zijn: > [1..] [1,2,3,4,5,6,7,8,9,.. etc Oneindige lijsten kunnen hndig zijn in expressies wrin mr een (eindig) deel vn de lijst geruikt wordt. > tke 20 [1..] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] Andere hndige voorgedefinieerde functies op lijsten zijn: > sum [1,2,3,4] 10 > prod [1,2,3,4] 24 > min [4,1,2,6,7] 1 > mx [4,5,7,3,1,2] 7 > nd [1 < 2,4 < 9] True > or [8 < 2,4 < 9] True De functie prod kunnen we geruiken om n! (fculteit) te erekenen. n! is gedefinieerd ls 1 * 2 *.. * n In Amnd wordt dit: fc n = prod [1..n] Discrete Wiskunde 21

22 2.4.1 Lijsten vn krkters Voor lijsten vn krkters is er een ijzondere nottie: ['','','p'] mg ook worden geschreven ls: "p". Lijsten vn krkters worden ook wel strings genoemd en deze spelen een elngrijke rol in veel computer progrmm's. Veel operties en functies voor lijsten gelden ook voor strings! Opgven Opgve 2.6 Welke vn de ovenstnde functies gelden niet voor strings? Tuples Lijsten geruiken we om elementen vn dezelfde soort te groeperen. Willen we elementen vn verschillende soort groeperen dn geruiken we tuples. We zijn tuples l eerder tegengekomen: (1,True), ('',1',Flse) Tuples zijn minder flexiel in het geruik dn lijsten. Je kunt geen tuples n elkr plkken. Ook estn er geen specile functies om elementen uit een tuple te selecteren, ehlve voor twee-tuples (fst en snd). > fst (3,4) 3 > snd (3,4) 4 Je kunt eenvoudig functies op tuples definiëren dmv. ptronen: fst3 (x,y,z) = x snd3 (x,y,z) = y thd3 (x,y,z) = z Op het geruik vn ptronen in functie definities zullen we lter nog terugkomen. Tuples heen dus een veel minder krchtige functionliteit dn lijsten en worden dn ook voornmelijk geruikt om resultten te groeperen, zols in het vooreeld vn de nulpunten vn een tweedegrds polynoom. 2.5 Lijst-comprehensies Lijsten zijn we l eerder tegengekomen. Amnd evt krchtige operties op lijsten, de zgn. lijst-comprehensies. We geven weer een ntl vooreelden om dit egrip te introduceren: Discrete Wiskunde 22

23 > [2*x x <- [3,4,1,6]] [6, 8, 2, 12] Lees dit ls: de lijst vn lle wrden 2 * x, wrij x komt uit de lijst [3,4,1,6]. Andere vooreelden: > [x+2 x <- [1..10]] [3, 4, 5, 6, 7, 8, 9, 10, 11, 12] > [3 x <- [1..10]] [3, 3, 3, 3, 3, 3, 3, 3, 3, 3] Een iets ingewikkelder vooreeld: > [x x <- [1..10]; x mod 2 = 0] [2, 4, 6, 8, 10] Lees dit ls: de lijst vn lle wrden x, wrij x komt uit de lijst [1..10] en wrij x voldoet n x mod 2 = 0 (x is even). > [3*x x <- [1..10]; x mod 2 = 0] [6, 12, 18, 24, 30] Lees dit ls: de lijst vn lle wrden 3 * x, wrij x komt uit de lijst [1..10] en wrij x voldoet n x mod 2 = 0 (x is even). Nu even wt terminologie: x <- [1..10] heet een genertor. x mod 2 = 0 heet een conditie. An de linkerknt vn de pijl in een genertor moet een vriele stn, n de rechter knt een expressie die een lijst oplevert. In deze expressie mogen vrielen uit eerdere genertoren voorkomen. De conditie is een expressie die True of Flse oplevert en wrin vrielen uit eerder gedefinieerde genertoren kunnen optreden. Er mogen in een lijst-comprehensie est meerdere genertoren en condities voorkomen. > [x + y x <- [1..3]; y <- [7..9]] [1+7,1+8,1+9, 2+7,2+8,2+9, 3+7,3+8,3+9] (dit is een tussenstp) [8,9,10,9,10,11,10,11,12] We zien hier dt de tweede genertor 3 keer herhld wordt, voor iedere wrde uit de eerste genertor een keer. De tweede genertor loopt het hrdst. Mv. lijstcomprehensies kunnen velen progrmmeerprolemen opgelost worden. We zullen hiervn in dit vk nog veel vooreelden tegenkomen. Het eerste vooreeld dt we ekijken is het volgende: Discrete Wiskunde 23

24 Geef lle drietllen (x,y,z) tussen de 1 en 32 zodt: x - y = 6, z + x = 17 en y * z = 18. Mv. een lijstcomprehensie los je dit proleem in één regel op: [(x,y,z) x <- [1..32]; y <- [1..32]; z <- [1..32]; x - y = 6; z + x = 17; y * z = 18] Vrg Hoeveel cominties vn (x,y,z) worden er in deze lijstcomprehensie uitgeproeerd? Bovenstnde lijstcomprehensie geeft ons wel de juiste oplossing voor ons proleem, mr is niet erg efficiënt. Immers ls voor x een wrde gekozen is, dn liggen y en z l vst omdt: x - y = 6 en z + x = 17. We pssen onze lijstcomprehensie hiervoor n: [(x,y,z) x <- [1..32]; y <- [x - 6]; z <- [17 - x]; y * z = 18] We zien hier twee genertoren met een lijst met slechts een element: y <- [x - 6] en z <- [17 - x]. Hiervoor estt in Amnd een specile nottie: y := x - 6 en z := 17 - x. Onze lijstcomprehensie wordt nu: [(x,y,z) x <- [1..32]; y := x - 6; z := 17 - x; y * z = 18] Vrg Hoeveel keer efficiënter is de tweede oplossing? Opgven Opgve 2.7 Wt is er fout in onderstnde oplossingen vn ovengenoemde puzzel? [(x,y,z) x <- [1..32]; x - y = 6; y <- [1..32]; z <- [1..32]; z + x = 17; y * z = 18] [(x,y,z) x <- [1..32]; y <- x - 6; z <- [17 - x]; y * z = 18] [(x,y,z) x <- [1..32]; y = x - 6; z <- [17 - x]; y * z = 18] Voorl de ltste fout wordt veel gemkt! Opgve 2.8 De stndrd functie memer test of een lijst een epld element evt: > memer [1,2,3] 3 True > memer [1,2,3] 4 Flse Definieer nu zelf mv. een lijstcomprehensie de functie mem die hetzelfde doet ls memer. Definieer de functies nd en or mv. een lijstcomprehensie (tellen!). Opgve 2.9 Definieer mv. een lijstcomprehensie een functie ntldelers n, die voor gegeven n het ntl delers vn n erekent (d is een deler vn n, ls n mod d = 0). Opgve 2.10 Discrete Wiskunde 24

25 Mv. lijstcomprehensies kunnen we echte progrmm s mken. Toepssing telefoonoek: De inhoud vn een telefoonoek kunnen we opsln in een lijst vn tupels estnde uit nm en telefoonnummer: teloek = [("jn",123),("piet",234),...] Definieer nu mv lijstcomprehensies de opzoekfuncties telnr en : telnr : geeft voor gegeven nm (een lijst vn) telefoonnummer(s). : geeft ij telnr de ijehorende (lijst vn) n()m(en). Opgve 2.11 Toepssing gepst etlen: Definieer mv. een lijstcomprehensie de functie inmunten, die gegeven een edrg lle mogelijke 4 tuples (g,k,d,s) (guldens, kwrtjes, dueltjes en stuivers) geeft die smen het edrg vormen. 2.6 Zip Een hndige opertie op lijsten, die vk in lijstcomprehensies geruikt wordt, is zip (rits). Met zip kun je twee lijsten prsgewijs koppelen. > zip ([1,2,3],["p","noot","mies"]) [(1,"p",(2,"noot"),(3,"mies")] Het is hierij niet noodzkelijk dt de lijsten even lng zijn, het resultt is echter nooit lnger dn de kortste lijst. Zip is voorl hndig in comintie met lijstcomprehensies. Bekijk de volgende definitie die het i-de element vn een lijst oplevert: elem n xs = hd [x (x,m) <- zip (xs,[0..]); n = m] Omdt zip zo vk geruikt wordt in lijstcomprehensies is er in Amnd een prte fkortingsnottie voor: elem n xs = hd [x x,m <- xs,[0..]; n = m] zip kn ook hndig zijn wnneer je ieder element uit een lijst met zijn uurmn moet vergelijken. Dit kun je ereiken door de lijst met zijn til te 'zippen'. In het volgende vooreeld wordt zo gecontroleerd of een lijst gesorteerd is: issorted xs = nd [x <= y x,y <- xs,tl xs] In de volgende prgrf zullen we nog een ntl toepssingen vn zip tegenkomen Opgven Opgve 2.12 Discrete Wiskunde 25

26 G n wt het resultt is vn: zip ([1,2,3,4,5],[4..]) Opgve 2.13 Geruik zip in een lijstcomprehensie om te tellen hoe vk, in een lijst vn getllen, een getl precies een groter is dn zijn voorgnger. Opgve 2.14 In een lijstcomprehensie kun je ook een zip nemen vn meer dn twee lijsten. Dit gt op de volgende mnier: [...,,c <- s,s,cs] Geruik dit om te testen hoe vk de lettercomintie "een" in een string voorkomt. 2.7 Typering in Amnd Amnd is een zgn. sterk getypeerde tl. Dit etekent dt iedere expressie en functie een type heeft. Door de sterke typering vn Amnd kunnen veel progrmmeerfouten tijdig door de interpreter worden opgespoord Typering vn expressies Het type vn een expressie is het soort vn de wrde vn de expressie. Amnd kent drie sis types: num, ool en chr. num is het type vn getllen. Iedere rekenkundige expressie heeft dit type. ool is het type vn de wrheidswrden. Iedere oolense expressie heeft dit type. chr is het type vn de krkters zols, etc. Je kunt het type vn een expressie is Amnd opvrgen door chter de expressie :: te typen en drn op enter te drukken. > :: num > 1 = 3 :: ool > chr Omdt er in Amnd ook lijsten gemkt kunnen worden estt er ook het type lijst vn: > [1,2,3] :: [num] Discrete Wiskunde 26

27 > [True,Flse] :: [ool] > [, v ] :: [chr] > p [chr] Er estt ook een type voor tupels: > (1,True) :: (num,ool) Amnd is in stt om fouten in het type vn een expressie op te sporen: > 1 + True incorrect use of: + type1: (num -> ool -> *) type2: (num -> num -> num) ERROR: 1 type error Typering vn functies Iedere functie heeft ook een type. Het type vn een functie is een comintie vn het type vn de rgumenten en het type vn het resultt: verhoog x = x + 1 > verhoog :: num -> num Dit etekent dt het type vn rgument x vn verhoog een getl (num) moet zijn en dt het resultt vn verhoog toegepst op een getl weer een getl is. Als je in Amnd een functie toepst op een element vn een verkeerd type, wordt er een foutmelding gegeven. > inc True incorrect use of: inc type1: (ool -> *) type2: (num -> num) ERROR: 1 type error Nu een vooreeld vn een functie met twee rgumenten: telop x y = x + y > telop:: num -> num -> num Dit is enigszins merkwrdig. Je zou v. num, num -> num verwchten. Amnd ziet een functie vn twee rgumenten ls een functie die toegepst op het eerste element een nieuwe functie oplevert die drn op het tweede rgument kn worden toegepst! num -> num -> num moet je dus lezen ls num -> (num -> num), -> ssocieerd nr rechts. Discrete Wiskunde 27

28 Het toepssen vn een functie op mr een deel vn de rgumenten heet currying (nr H.B. Curry). Currying is vk erg hndig. > mp (telop 3) [1..10] [4, 5, 6, 7, 8, 9, 10, 11, 12, 13] Het eerste rgument vn mp (telop 3) is een gecurryde functie Typering vn lijsten > [1..10]:: [num] > hllo [chr] Voor veel functies op lijsten geldt dt het type vn de elementen vn de lijst er niet toe doet. Dit wordt in Amnd met een * ngegeven. > tke :: num -> [*] -> [*] Voor * kn nu een willekeurig type worden ingevuld. Merk wel op dt voor tke de rgument lijst en de resultt lijst hetzelfde type heen. Discrete Wiskunde 28

29 3. Toepssingen vn lijstcomprehensies Veel wiskundige prolemen zijn vn de soort: G n of lle elementen in een verzmeling voldoen n..., of is er een element in deze verzmeling dt voldoet n..., hoeveel elementen in deze verzmeling voldoen n... Lijstcomprehensies ieden een mogelijkheid dit soort prolemen te verwoorden, wrij we lijsten ls stnd-in voor verzmelingen geruiken: Zijn lle elementen in de verzmeling vs even (een getl g is even ls g mod 2 = 0)? nd [ v mod 2 = 0 v <- vs] Geldt voor lle elementen in de verzmeling vs dt ze groter zijn dn 3 en kleiner dn 20? nd [ v > 3 /\ v < 20 v <- vs] Is er een element in vs dt even is? or [ v % 2 = 0 v <- vs] Nu een wt ingewikkelder vooreeld: Is er voor ieder element v in vs een nder element w in vs zodt: of v = 3 * w of w = 3 * v. In feite lopen hier twee eweringen door elkr heen, lle elementen uit vs moeten n iets voldoen, dus: nd[??? v <- vs] Hierij is??? de voorwrde (tweede ewering), wrn v moet voldoen. Dus is er een element w in vs zo dt: v = 3*w of w = 3 * v: or [v = 3 * w \/ w = 3 * v w <- vs] Deze ltse ewering moeten we dus op de plts vn??? invullen. Totl krijgen we: nd [or [v = 3 * w \/ w = 3 * v w <- vs] v <- vs] Opgven Opgve 3.1 Schrijf lijstcomprehensies voor de volgende eweringen: Geldt voor lle element in vs dt ze een drievoud zijn. Is er een element in vs dt groter is dn 25 en deelr door 18. Voor ieder element v in vs is er een nder element w in vs, dt gelijk is n v. Mw. ieder element komt miniml 2 keer voor. Discrete Wiskunde 29

30 3.2 Vooreeld: Cijfer dministrtie Nu een wt groter vooreeld. Gegeven een lijst vn cijfers voor het vk discrete wiskunde cfs. We willen hier grg wt sttistiek op plegen: Wt is het gemiddelde cijfer? Hoeveel (on)voldoendes zijn er? Hoe vk werd er tussen de 7 en 8 gescoord? Komen er cijfers duel (of meer) voor? gem cfs = sum [c c <- cfs] // # cfs onvoldoendes cfs = # [c c <- cfs; c < 5.5] tussen7en8 cfs = # [c c <- cfs; c >= 7 /\ c <= 8] duel cfs = or [# [k k <- cfs; k = c] > 1 c <- cfs] De eerste 3 uitwerking spreken voor zich, de ltste heeft misschien wt toelichting nodig: Gevrgd wordt of er een cijfer is dt duel voorkomt. Dit etekent dt het een proleem is vn het type: or [??? c <- cfs] Hierij moet??? een test zijn die ngeeft of c meer dn een keer voorkomt. Alle voorkomens vn c in cfs wordt gegeven door: [k k <- cfs; k = c] Nu nog testen of c vker dn een keer voorkomt: # [k k <- cfs; k = c] > 1 Het ltste ingevuld op de plts vn??? geeft nu het gevrgde Opgven Opgve 3.2 Geef verder lijstcomprehensies voor: Hoe vk kwm het cijfer 8 voor. Hoe vk werd het hoogste cijfer ehld. Discrete Wiskunde 30

31 3.3 Verwerken voetluitslgen Gegeven zijn een lijst vn uitslgen vn voetlwedstrijden (v lle wedstrijden tot nu toe gespeeld) en een lijst vn deelnemende tems, in de volgende vorm: uitslgen = [("jx","psv",2,0), (thuisclu, uitclu, doelp voor, doelp tegen) ("go hed", "fc utrecht",0,3),... ] clus = ["jx","feyenoord","psv",...] Bereken nu : Lijst vn wedstrijdpunten (3 voor gewonnen, 1 voor gelijk, 0 voor verloren). Het totl ntl punten per ploeg. Welke ploegen heen thuis nooit verloren? Om de wedstrijdpunten te kunnen erekenen geruiken we een functie die een uitslg omzet in punten voor eide tems: punten (c1,c2,p1,p2) = [(c1,3),(c2,0)], if p1 > p2 = [(c1,1),(c2,1)], if p1 = p2 = [(c1,0),(c2,3)], if p1 < p2 We kunnen nu eenvoudig een lijst vn lle wedstrijdpunten mken: wedstrijdpunten uitslgen = [(c,p) u <- uitslgen; (c,p) <- punten u] We kunnen de wedstrijdpunten ook zonder hulpfunctie in een keer mv. een lijstcomprehensie uitrekenen: wedstrijdpunten uitslgen = [(c1,0) (c1,c2,p1,p2) <- uitslgen; p1 < p2] ++ [(c1,1) (c1,c2,p1,p2) <- uitslgen; p1 = p2] ++ [(c1,3) (c1,c2,p1,p2) <- uitslgen; p1 > p2] ++ [(c2,0) (c1,c2,p1,p2) <- uitslgen; p1 > p2] ++ [(c2,1) (c1,c2,p1,p2) <- uitslgen; p1 = p2] ++ [(c3,3) (c1,c2,p1,p2) <- uitslgen; p1 < p2] Het is een kwestie vn smk welke oplossing je prefereert. De eerste oplossing is wel korter, mr heeft een hulpfunctie nodig. Nu we de wedstrijdpunten heen, is het eenvoudig het totl ntl punten per clu te erekenen: We moeten informtie per clu heen. Dit etekent een lijstcomprehensie vn de vorm: [??? c <- clus] Hierij is??? een expressie die ons de punten vn clu c levert. De lijst vn punten voor een clu c wordt gegeven door. Discrete Wiskunde 31

32 [p (c1,p) <- wedstrijdpunten uitslgen; c1 = c] Om het totl ntl punten voor een clu te krijgen, moeten we hiervn de som nemen: sum [p (c1,p) <- wedstrijdpunten uitslgen; c1 = c] Het ltste vullen we in op de plts vn???: totlen uitslgen = [(c, sum [p (c1,p) <- wedstrijdpunten uitslgen; c1 = c]) c <- clus] 3.4 Dtses mv. lijstcomprehensies Een tel uit een dtse kn in Amnd worden voorgesteld ls een lijst vn tuples. Queries op een tel kunnen vk geformuleerd worden mv. een lijstcomprehensie. Net ls in SQL worden de queries ps echt interessnt ls er gegevens vn meerdere tellen gecomineerd moeten worden. We eginnen ons vooreeld met een tel vn persoongegegevens. Om de leesrheid te vergroten voeren we eerst een ntl nieuwe typen in. Dit kn op de volgende mnier: nieuwe nm == estnd type Voor onze eerste tel definiëren we de volgende nieuwe typen: nm == [chr] dres == [chr] woonplts == [chr] leeftijd == num persoon == (nm,dres,woonplts,leeftijd) personen :: [persoon] personen = [("Piet Augustein","de Kwkel 23","Leeuwrden",18), ("Freek de Boer","Besterdyk 23","Sneek",23), ("Jcoien Bosch","Hegedyk 53","Bolswrd",21), ("Richrd Boum","Tjerkepd 12","St. Annprochie",20), ("Cornelis vd Heide","Buorren 3","Ferwerd",19), ("Piet de Jong","Tongerwei 4","Birdrd",21), ("Sytze Lemstr","Oude dyk 78","Leeuwrden",19) ] De tweede tel is de resultten tel: vk == [chr] cijfer == num stp == num resultt == (nm,vk,cijfer) resultten :: [resultt] resultten = [("Piet Augustein","Discrete Wiskunde",6), Discrete Wiskunde 32

33 ("Piet Augustein","Computer Orgnistie",7), ("Piet Augustein","Progrmmeren 1",5), ("Piet Augustein","Dtse systemen 1",6), ("Piet Augustein","Project 1",8), ("Freek de Boer","Discrete Wiskunde",7), ("Freek de Boer","Computer Orgnistie",9), ("Freek de Boer","Progrmmeren 1",6), ("Freek de Boer","Computer Orgnistie",8), ("Freek de Boer","Telemtic I",7), etc. ] Als ltste tel heen we de vkgegevens: vkgegeven == (vk,stp) vkken :: [vkgegeven] vkken = [("Discrete Wiskunde",3), ("Computer Orgnistie",3), ("Progrmmeren 1",4), ("Dtse systemen 1",4), ("Project 1",7), ("Telemtic I",3), ("Informtie Anlyse",3)] Queries over één tel We gn nu queries formuleren. We eginnen met eenvoudige queries over één tel. Lijst vn resultten (Nm en Cijfer) voor het vk Discrete Wiskunde resdiwi = [(nm,cijfer) (nm,vk,cijfer) <- resultten; ] vk = "Discrete Wiskunde" Nmen vn studenten uit Leeuwrden: nmleeuw = [nm (nm,dres,woonplts,leeftijd) <- personen; ] woonplts = "Leeuwrden" Voor de leesrheid is het eter om de tuple velden wrin we niet zijn geïnteresseerd te vervngen door een streepje: nmleeuw = [nm (nm,_,woonplts,_) <- personen; woonplts = "Leeuwrden" ] Opgven Opgve 3.3 Formuleer queries voor: Discrete Wiskunde 33

34 Hoogste cijfer voor Informtie Anlyse Suqueries en hulpfuncties Net ls in SQL is het soms noodzkelijk om een query innen een query te geruiken. Vooreeld: Wt is het vk met de meeste studiepunten? mxstp = [(vk,stp) (vk,stp) <- vkken; stp = mxstp ] where mxstp = mx [stp (_,stp) <- vkken] Een lterntief zonder where cluse is: mxstp = [(vk,stp) (vk,stp) <- vkken; ] stp = mx [stp (_,stp) <- vkken] Het ndeel vn de ltste functie is dt mx [stp (_,stp) <- vkken] steeds weer opniew wordt uitgerekend. De eerste formulering verdient drom de voorkeur (ook vnwege de leesrheid). We zien dus dt we hier de suquery ls een hulpfunctie reliseren. Bij complexere queries is het vk verstndig het resultt op te ouwen mv. een ntl hulpfuncties Opgven Opgve 3.4 Welke student heeft het hoogste cijfer? Queries over twee tellen Bij queries over twee tellen moet er vk een join gemkt worden. Binnen een lijstcomprehensie ziet dit er in de regel ls volgt uit: [result_expr t1 <- tle1; t2 <- tle2; join_conditie; overige condities ] Als eerste vooreeld: de resultten vn de studenten uit Leeuwrden [(nm,vk,cijfer) (nm,_,woonplts,_) <- personen; (nm2, vk, cijfer) <- resultten; nm = nm2; woonplts = Leeuwrden ] Discrete Wiskunde 34

35 3.4.6 Opgven Opgve 3.4 Studiepunten voor de vkken ehld door Cornelis vd Heide Complexe queries Bij complexe is het meestl hndig eerst een ntl hulptellen(functies) te definiëren voor deelresultten. Vooreeld: Het vk met de meeste onvoldoendes. Mk hiertoe eerst een hulptel: vkonvoldoendes met ls type: [(vk,num)], wrin het tweede veld het ntl onvoldoendes voor het vk uit het eerste veld geeft. vkonvoldoende = [(vk,count) (vk,_) <- vkken; count := # [cijfer (_,vk2,cijfer) <- resultten; vk = vk2; cijfer < 5.5 ] ] meesteonvoldoendes = [vk (vk,o) <- vkonvoldoende; o = meesteon] where meesteon = mx [o (vk,o) <- vkonvoldoende] Opgven Opgve 3.5 Welke student heeft de meeste studiepunten ehld. 3.5 Anlyse vn teksten Gegeven is een tekst in de vorm vn een string (lijst vn krkters). We willen grg een sttistische nlyse op de tekst plegen. Eerst een ntl eenvoudige zken: Mk een histogrm vn de verschillende letters. Het resultt moet zijn een lijst vn tuples vn letter en het ntl keer dt de letter voorkomt. v: het ntl keren dt '' in een tekst voorkomt: # [c c <- tekst; c = ''] Voor lle letters wordt dit nu: histogrm tekst = [(c,# [k k <- tekst; k = c]) c <- "cdefghijklmnopqrstuvwxyz"] Nu een wt lstiger proleem: Hoe vk komt de comintie "de" voor? Discrete Wiskunde 35

36 Hiervoor estn verschillende oplossingen. Eerst een ntl 'dure' oplossingen: # [i i <- [0..#tekst-2]; tekst! i = 'd' /\ tekst! (i+1) = 'e'] # [i i <- [0..#tekst-2]; tke 2 (drop i) tekst = "de"] En dn nu de efficiente (en friere) oplossing mv. zip. We zippen hiertoe tekst met tl tekst, wrdoor we een lijst vn pren vn een krkter en zijn opvolger in de tekst krijgen: # [(c1,c2) c1,c2 <- tekst, tl tekst; c1 = 'd' /\ c2 = 'e'] Nog wt lstiger: Hoeveel woorden evt de tekst. Om dit proleem op te kunnen lossen, moeten we ons eerst reliseren wt een woord is. Woorden worden gescheiden door interpunctie tekens. Dit zijn: sptie, punt, komm en puntkomm. Het is echter niet voldoende het ntl interpunctie tekens in een tekst te tellen, omdt er est meerdere spties chter elkr kunnen stn. Dit kunnen we ondervngen door niet het ntl interpunctie tekens te tellen, mr cominties vn een interpunctie teken gevolgd door een niet interpunctie teken. Dus v: (' ', 'd') of ('.','e'). Hiertoe zippen we de tekst weer met zijn tl. # [(c1,c2) c1, c2 <- tekst,tl tekst; interpunctie c1 /\ ~ (interpunctie c2)] De functie interpunctie kunnen we ls volgt definiëren: interpunctie c = memer " ;,." c ~ etekent niet. Op deze mnier vergeten we echter het eerste woord, tenminste, ls er een eerste woord is. Dit komt omdt er n het eerste woord geen interpunctieteken voorf gt. Dit kunnen we ondervngen door n het egin vn de tekst een 'kunstmtig' interpunctieteken te zetten: # [(c1,c2) c1, c2 <- '.' : tekst, tekst; interpunctie c1 /\ ~ (interpunctie c2)] Let op: tl in het tweede rgument vn de zip komt nu te vervllen! Opgven Opgve 3.6 Schrijf een lijstcomprehensie voor: welke letter komt het meeste voor. Hieroven heen we het ntl keren dt "de" in een tekst voorkwm geteld. Tel nu eens het ntl keren dt het woord "de" voorkomt in de tekst. Lstig: Wt is de lengte vn het lngste woord. Tip mk eerst functies voor het egin en eind vn ieder woord. Discrete Wiskunde 36

37 3.5.2 Ly-out Als we een lijst vn getllen netjes nst elkr op het scherm willen lten zien, dn moeten we de getllen eerst nr strings converteren. Hiervoor estt in Amnd een specile functie ito. Verder he je, om een lijst vn strings n elkr te plkken, de functie conct, die een lijst vn lijsten neenrijgt tot een lnge lijst: > conct [ito n ++ " " n <- [1..10]] Vrg Wrom kn dit niet met: [n ++ " " n <- [1..10]]? Opgve 3.7 Definieer de functie histogrm xs die voor een lijstje vn getllen een histogrm uitprint. > histogrm [3,1,5,8,2,3] **** ** ****** ******** *** **** Het zou nog mooier zijn ls we n ieder rijtje sterren het ijehorende getl voorf lten. Een prolem hierij echter is, dt ls het getl uit meerdere cijfers estt, de lyout vn het histogrm niet meer klopt: 8: ******** 10: ********** Gelukkig vlt hier wt n te doen. Amnd heeft een drietl uitlijningsfuncties: ljustify, cjustify en rjustify. ljustify n xs, vult de string xs n de rechterknt n met spties tot een lengte n. G zelf n wt cjustify en rjustify doen. Ps nu histogrm n volgens het volgende vooreeld: > histogrm [3,1,5,8,14,2,3] 3 : **** 1 : ** 5 : ****** 8 : ********* 14 : *************** 2 : *** 3 : **** Definieer, gewpend met de kennis uit de vorige opgve, de functie tfel n, die voor gegeven n de tfel vn vermenigvuldiging voor n print: > tfel 4 1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 5 * 4 = 20 Discrete Wiskunde 37

38 6 * 4 = 24 7 * 4 = 28 8 * 4 = 32 9 * 4 = * 4 = Functies op lijsten We heen l een ntl voorgedefinieerde functies op lijsten ekeken zols: mx, min, sum, prod etc. Verder heen we gezien dt sommige functies mv. een lijstcomprehensie gedefinieerd kunnen worden. Mr dit geldt niet voor lle functies op lijsten. Proeer mr eens v. de functie sum mv. een lijstcomprehensie te definiëren. Als we zelf zo'n functie moeten definiëren, dn gt dit ltijd mv. een zgn. recursieve definitie. Een functie heet recursief ls hij zichzelf nroept. Lten we eens eginnen met de functie die het ntl elementen vn een lijst uitrekent: ntlel xs = 0, if xs = [] = 1 + ntlel (tl xs), otherwise In woorden: Het ntl elementen vn een lege lijst is 0; het ntl elementen vn een niet lege lijst is 1 plus het ntl elementen vn de strt (tl) vn de lijst. Vrg Schrijf mv. deze definitie eens ntlel [1,2,3] uit Ptronen Ipv. met if en otherwise kunnen we in Amnd functies vk ook op een elegntere mnier definiëren. Dit geldt met nme voor recursieve functies. ntlel [] = 0 ntlel (x:xs) = 1 + ntlel xs Dit heet een definitie mv. ptronen. Hier zijn [] en (x:xs) de ptronen. Bij een nroep vn de functie wordt vn oven nr eneden het rgument vn de functie met de ptronen vergeleken. Als het rgument een lege lijst is mtched het eerste ptroon en wordt de eerste definitie uitgevoerd. Voor een niet lege lijst mtched het tweede ptroon. Dit ptroon is hier (x:xs). We heen eerder gezien dt : de opertor is om een element voor n een lijst toe te voegen. Als we lijst met het ptroon (x:xs) mtchen dn wordt het eerste element vn de lijst (hd) geonden n x en de rest vn de lijst (tl) n xs. Dit kn ntuurlijk lleen voor een niet lege lijst, mr dit is ltijd het gevl omdt een lege lijst 'mtched' met het ovenste ptroon. Nu een wt moeilijker vooreeld. We willen grg een definitie geven voor de! opertor. Als we! ls functie schrijven, dn zou een nroep er ls volgt uit zien: elem 3 [1,2,3,4,5,6,7] elem 0 (x:xs) = x elem n (x:xs) = elem (n-1) xs Discrete Wiskunde 38

39 De recursie loopt hier over n, mr we geruiken toch ptronen voor de lijst Opgven Opgve 3.8 Definieer nu zelf de functie sum, die de som vn lle elementen vn een lijst erekent. Definieer mv. ptronen de functies hd en tl. Denk ern, hd en tl zijn niet gedefinieerd voor lege lijsten! G n wt er geeurt ls je elem nroept voor een lege lijst. Proeer nu zelf op recursieve wijze de functies memer, drop, tke, min en mx te definiëren. Lstig: min en mx kunnen wel mv. een lijstcomprehensie gedefinieerd worden, proeer deze definitie te geven. Tip: edenk eerst wt het etekent ls een element het mximum vn een lijst is Ingewikkelder ptronen Ptronen in lijsten kunnen est ingewikkelder zijn dn in het ovenstnde vooreeld. De volgende functie controleert of een lijst is gesorteerd vn klein nr groot: issorted [] = True issorted [x] = True issorted (x:y:xs) = x <= y /\ issorted (y:xs) Het idee hierij is: de lege lijst is gesorteerd een lijst estnde uit een element is gesorteerd een lijst estnde uit miniml twee elementen is gesorteerd ls het eerste element kleiner of gelijk is ls het tweede element en vnf het tweede element de lijst gesorteerd is. We zien hier een tweetl nieuwe ptronen: [x] 'mtched' met een lijst vn lengte precies een, het ene element wordt geonden n x. (x:y:xs) 'mtched' met een lijst vn lengte tenminste 2. Het eerste element wordt geonden n x, het tweede n y en de rest n xs. Opmerking In de tweede regel: issorted [x] = True, komt in het ptroon de vriele x voor die n de rechter knt niet wordt geruikt. In dit soort gevllen mg de vriele door _ vervngen worden. De tweede regel wordt dn: issorted [_] = True In lijstcomprehensies mogen vrielen n de linkerknt vn genertoren, die verder niet geruikt worden, ook worden vervngen door _. herhl n s = [s _ <- [1..n]] Discrete Wiskunde 39

40 Het geruiken vn _ ipv. een vriele nm voorkomt niet lleen het edenken vn nmen, mr zorgt ook voor een etere leesrheid vn progrmm's. Discrete Wiskunde 40

41 4. Recursie en inductie 4.1 Recursie Een recursieve functie is een functie die gedefinieerd is m..v. zichzelf. We heen dr l diverse vooreelden vn gezien: fc 0 = 1 fc n = n * fc (n-1) ntlel [] = 0 ntlel (x:xs) = 1 + ntlel xs issorted [] = True issorted [x] = True issorted (x:y:xs) = x <= y /\ issorted (y:xs) Deze definities heen een vst ptroon: voor een ntl sisgevllen worden directe definities gegeven en voor de ndere gevllen wordt de functie zelf weer ngeroepen mr met prmeters die dichter ij de sisgevllen zijn. Zulke definities leiden ltijd tot een eindige erekening zols uit de volgende vooreelden lijkt: fc 4 = 4 * fc 3 = 4 * 3 * fc 2 = 4 * 3 * 2 * fc 1 = 4 * 3 * 2 * 1 * fc 0 = 4 * 3 * 2 * 1 * 1 = 24 ntlel [1, 2, 3] = 1 + ntlel [2, 3] = ntlel [3] = ntlel [] = 3 issorted [1, 3, 2, 4, 5] = 1 <= 3 /\ issorted [3, 2, 4, 5] = issorted [3, 2, 4, 5] = 3 <= 2 /\ issorted [2, 4, 5] = Flse Er zijn ook wel recursieve definities denkr die niet tot een eindige erekening leiden zols de volgende definitie vn de fculteitsfunctie: fc n = fc (n+1) / (n+1) Het eigenrdige is dt deze definitie in wiskundige zin correct is, mr voor erekeningen tot niets leidt. Nog krsser is de volgende definitie: Discrete Wiskunde 41

42 fc n = fc n Ook dt is in wiskundige zin een wre ewering, mr voor erekeningen he je er niets n Opgven Opgve 4.1 Beredeneer dt de volgende sorteerfuncties correct zijn en ltijd tot een eindige erekening leiden (welke is de snelste?). minsort [] = [] minsort xs = minxs : minsort (xs -- [minxs]) where minxs = min xs. quicksort [] = [] quicksort (x:xs) = quicksort [y y <- xs; y <= x] ++ [x] ++ quicksort [y y <- xs; y > x] Opgve 4.2 De fioncci-reeks is [1, 1, 2, 3, 5, 8, 13, 21...] Geef een recursieve definitie vn de functie fi n, die het n-de element vn deze reeks oplevert. (voor lle duidelijkheid: fi 0 = 1, fi 1 = 1, fi 2 = 2, fi 3 = 3, fi 4 = 5 enz.) Opgve 4.3 De functie sum die de som vn de elementen vn een lijst erekent kunnen we ls volgt definieren met een hulpfunctie, die een zogenoemde opsprende prmeter geruikt om tussenresultten in te ewren: mysum xs = dd 0 xs dd s [] = s dd s (x:xs) = dd (s+x) xs Definieer op net zo n mnier de functie reverse die een lijst omdrit. myreverse xs = rev [] xs rev s [] = s rev s (x:xs) = Inductie Inductie is een wiskundige ewijstechniek geseerd op het idee dt de verzmeling vn ntuurlijke getllen (in Amnd nottie: [0..]) recursief gedefinieerd kn worden: Discrete Wiskunde 42

43 ntuurlijkegetllen = from 0 from n = n : from (n+1) Hieruit volgt het inductieprincipe: een ewering p is wr voor lle ntuurlijke getllen ls p is wr voor 0 en ls p wr is voor n, dn is p wr voor n+1 Een ndere formulering is: een ewering p is wr voor lle ntuurlijke getllen ls p is wr voor 0 en ls p wr is voor lle ntuurlijke getllen kleiner dn n, dn is p wr voor n Hiermee kunnen we wiskundig ewijzen dt de oorspronkelijke definitie vn de fculteitsfunctie voor lle ntuurlijke getllen tot een eindige erekening leidt. De ewering is dn: p n = fc n leidt tot een eindige erekening Omdt fc 0 = 1 is de erekening vn fc 0 eindig dus p is wr voor 0. Als p n wr is dn leidt fc n tot een eindige erekening. Dn is fc (n+1) te erekenen volgens fc (n+1) = (n+1) * fc n. De erekening voor fc (n+1) is drmee ook eindig. M..w. p geldt voor n+1. Volgens het inductieprincipe geldt p nu voor lle ntuurlijke getllen. Ofwel voor lle ntuurlijke getllen leidt de fculteitsfunctie tot een eindige erekening. Net zo kunnen we ewijzen dt de functie ntlel voor lle eindige lijsten leidt tot een eindige erekening. We nemen dn ls ewering: p n = de functie ntlel leidt tot een eindige erekening voor lle lijsten met lengte n Wiskundigen geruiken inductie om te controleren of eplde formules kloppen. Bijvooreeld: voor lle ntuurlijke getllen n geldt: sum [1..n] = n * (n+1) / 2 De ewering p n is nu sum [1..n] = n * (n+1) / 2 Voor 0 is de ewering wr, wnt sum [1..0] = 0 en 0 * (0+1) / 2 = 0 Als de ewering wr is voor n, dn geldt sum [1..n] = n * (n+1) / 2. We gn nu kijken of de ewering ook wr is voor n+1: sum[1..n+1] = sum[1..n] + (n+1) = n*(n+1)/2 + (n+1) = (n+2) * (n+1) / 2 = (n+1) * ((n+1)+1)/2 Inderdd klopt de ewering ook voor n Opgven Opgve 4.4 Bewijs dt de functie quicksort voor lle eindige lijsten leidt tot een eindige erekening. Discrete Wiskunde 43

44 Opgve 4.5 De functie ltsum is (informeel) gedefinieerd ls: ltsum n = (+/-) n Bewijs dt voor lle ntuurlijke getllen n geldt: ltsum n = -n / 2,if n mod 2 = 0 = (n+1) / 2,otherwise 4.3 Torens vn Hnoi In het verre verleden stonden er in Hnoi 3 plen met op pl 0 een stpel vn 64 schijven lleml vn verschillende dimeter en nooit een grotere ovenop een kleinere schijf. Een monnik ws ezig de schijven nr pl 2 te verpltsen. Hij kon mr een schijf per keer verpltsen en er mocht nooit een grotere ovenop een kleinere komen te liggen. Verder moesten de schijven ltijd om een vn de plen worden gelegd. De vrg ws nu: ls de monnik er 1 minuut over deed om een schijf te verpltsen, hoe lng zou het duren voor de hele toren verpltst ws? Om de gedchten te eplen zullen we eerst een wt kleiner vooreeld uitwerken: pl 0 pl 1 pl 2 pl 0 pl 1 pl pl 0 pl 1 pl 2 pl 0 pl 1 pl pl 0 pl 1 pl 2 pl 0 pl 1 pl pl 0 pl 1 pl 2 pl 0 pl 1 pl 2 Werk het nu zelf heleml uit. We zien er misschien een ptroon in: Discrete Wiskunde 44

45 in een oneven zet wordt de kleinste schijf verpltst (en wel 1 pl circulir verder) in een even zet wordt een ndere schijf verpltst (hiervoor is mr 1 mogelijkheid) N wt experimenteren met torens vn verschillende groottes kunnen we inzien dt ij een toren vn n schijven in een oneven zet telkens de kleinste schijf (1 + n mod 2) plen verder verpltst wordt en in een even zet telkens een ndere schijf verpltst wordt. Bovendien heen we misschien gezien dt er (2^n - 1) verpltsingen nodig zijn. Hoe kunnen we dt wiskundig hrd mken? Er is een recursief lgoritme: Om een toren vn 0 schijven vn pl 0 nr pl 2 te verpltsen, hoeven we niets te doen. Om een toren vn n schijven vn pl 0 nr pl 2 te verpltsen, verpltsen we eerst een toren vn (n-1) schijven vn pl 0 nr pl 1, dn verpltsen we de grootste schijf vn pl 0 nr pl 2 en dn verpltsen we een toren vn (n-1) schijven vn pl 1 nr pl 2. In Amnd zouden we een functie hnoi kunnen definieren die een lijst vn verpltsingen oplevert: hnoi 0 vn vi nr = [] hnoi n vn vi nr = hnoi (n-1) vn nr vi ++ [(vn, nr)] ++ hnoi (n-1) vi vn nr Opgven Opgve 4.6 Bewijs met inductie dt geldt #(hnoi n vn vi nr) = 2^n Recursieve omen (extr) In Amnd kun je de functie grphicsout geruiken om te tekenen. Het tekenen geeurt in een vierknt met coordinten vn (-1, -1) tot (1, 1) Opgven Opgve 4.7 De volgende opgve moet met de grfische versie vn Amnd gemkt worden. Proeer het volgende uit in Amnd: grphicsout[grphpolyline 2 [(0, 0), (0.5, 0), (0.5, 1), (0, 0)], GrphDisc 5 (-0.5, -0.5) (0, 0)] We willen nu een recursieve oom tekenen die er ls volgt uitziet: Discrete Wiskunde 45

46 Informeel kunnen we deze oom eschrijven ls stm + linker tk + rechter tk, wrij de linker en de rechter tk er weer net zo uitzien ls de hele oom lleen een stukje verpltst en over een hoek gedrid. Een oom kunnen we eschouwen ls een lijst vn lijnstukken, die we met een functie tekenboom tekenen: tekenboom oom = grphicsout[grphpolyline 0 lijnstuk lijnstuk <- oom] Een oom vn hoogte n kunnen we nu definieren ls: oom 0 = [] oom n = [[(0, 0), (0, 0.3)]] ++ /* de stm */ links (oom (n-1)) ++ rechts (oom (n-1)) Hierij zijn links en rechts functies die een oom op de goede mnier verdrien, verschuiven en verkleinen. Drom definieren we eerst een ntl meetkundige functies: Discrete Wiskunde 46

47 vergroot fctor (x, y) = (fctor*x, fctor*y) dri hoek (x, y) = (c*x+s*y, -s*x+c*y) where c = cos hoek s = sin hoek verschuif (dx, dy) (x, y) = (x+dx, y+dy) De functies links en rechts worden dn: links oom = [[f p1, f p2] [p1, p2] <- oom] where f = verschuif (0, 0.3). dri (-0.7). vergroot 0.7 rechts oom = [[f p1, f p2] [p1, p2] <- oom] where f = verschuif (0, 0.3). dri (0.7). vergroot 0.7 Met l dit voorwerk kunnen we een oom lten tekenen vi > tekenboom (oom 7) Opgven Opgve 4.8 Experimenteer in Amnd met ovenstnde definities. Uit hoeveel lijnstukken estt oom n? Opgve 4.9 Het erekenen vn de lijnstukken gt nog niet erg vlug, omdt de linker en rechter oom telkens heleml opnieuw erekend worden. Een veel sneller resultt krijgen we ls volgt: recoom = oom where oom = [[(0, 0), (0, 0.3)]] ++ [lijnstuk [p1, p2] <- oom; lijnstuk <- [[fl p1, fl p2], [fr p1, fr p2]]] where fl = verschuif (0, 0.3). dri (-0.7). vergroot 0.7 fr = verschuif (0, 0.3). dri (0.7). vergroot 0.7 Je kunt dit lten tekenen vi (n: het is een oneindige definitie) > tekenboom recoom Experimenteer met deze definitie. Proeer te egrijpen hoe deze ingenieuze constructie werkt. Discrete Wiskunde 47

48 5. Recursieve dtstructuren en Bomen We heen l gezien dt recursie een uiterst krchtig middel is om functies mee te definieren. We zullen nu zien dt we recursie ook kunnen geruiken om krchtige dtstructuren te mken. 5.1 Zelf dtstructuren mken Amnd evt een ntl voorgedefinieerde types zols: num, chr, ool en lijsten hiervn. Soms heen we ehoefte n ndere dttypen. We kunnen deze in Amnd op eenvoudige wijze mken. Vooreeld In een pplictie spelen de mnden vn het jr en hun lengte een rol. We kunnen deze mnden ntuurlijk ls een string definieren, mr dit geeft soms nleiding tot vervelende fouten: mnden = [( Jnuri,31),( Feruri,28),...] We kunnen de functie lengte nu ls volgt definieren: lengte m = hd [l (n,l) <- mnden; n = m] Mr ls je deze functie nu per ongeluk ls volgt nroept: lengte jnuri // let op jnuri met kleine letter!! Dn leidt dit tot de run-time foutmelding: hd of empty list. We hdden liever gezien dt er ij het interpreteren l een foutmelding wordt gegeven. Dit kn ereikt worden door het volgende nieuwe type te definieren: mnd ::= Jnuri Feruri Mrt April Mei Juni Juli Augustus Septemer Oktoer Novemer Decemer Let hierij op ontreken vn nhlings tekens en het geruik vn. De hoofdletters zijn verplicht! We heen nu een nieuw type mnd gedefiniëerd en hierij ngegeven welke wrden dit type kn nnemen. We definiëren nu mndlengtes en lengte ls volgt: mndlengtes = [(Jnuri,31),(Feruri,28),(Mrt,31),...] lengte m = hd [l (n,l) <- mndlengtes; n = m] Een foutieve nroep zols: lengte Jnuri wordt nu l ij het vertlen vn het progrmm opgemerkt. Discrete Wiskunde 48

49 Zelfgedefinieerde types kunnen ook ingewikkelder zijn. Beschouw hiertoe het volgende type tempertuur: tempertuur ::= Celcius num Fhrenheit num Een tempertuur kn in Celcius of in Fhrenheit worden gegeven. Elementen vn dit type zijn: Celcius 23, Fhrenheit 43. Een lijst met elementen vn het type tempertuur zou er nu ls volgt uit kunnen zien: [Celsius 23, Fhrenheit 40,Celsius 88] We kunnen nu functies definieren door geruik te mken vn ptroonherkenning. koud (Celcius t) = t < 0 koud (Fhrenheit t) = t < Opgven Opgve 5.1 Mk een functie convert die een tempertuur in Celsius in een tempertuur in Fhrenheit converteert. De formule die je hier ij moet geruiken is: F = 1.8 * C Binire Bomen Een elngrijke dtstructuur is de inire oom. Er estn verschillende versies vn inire omen. Hier ekijken we de inire oom vn getllen: inoom ::= Leeg Knoop num inoom inoom Deze definitie heeft een recursief krkter, immers inoom komt ook n de rechterknt vn de definitie voor. Een oom is dus of leeg of estt uit een knoop met drin een getl (lel) en dronder een linker en rechter suoom. Dit lijkt op de definitie vn een lijst, die ook of leeg is of estt uit een element hed en een ndere lijst til. Het verschil is hier dt we nu een duele vertkking heen ipv. één. Vooreelden vn inire omen: Leeg Knoop 1 Leeg Leeg een lege oom een oom met één lel Knoop 1 (Knoop 2 (Knoop 3 Leeg Leeg) Leeg) (Knoop 4 Leeg Leeg)) Bomen kunnen overzichtelijker in een pltje weergeven worden. De ltste oom ziet er dn ls volgt uit: Discrete Wiskunde 49

50 1 / \ / -- 3 Terminologie De wortel vn een oom is de ovenste knoop. Een knoop heet een uiteinde of ld ls de twee suomen in deze knoop eide leeg zijn. Een pd is een rij vn lels vn de wortel tot en met een ld. De diepte vn een oom is de lengte vn het lngste pd. Een oom heet volledig ls lle pden even lng zijn. Een oom heet evenwichtig ls in iedere knoop de dieptes vn de twee suomen ten hoogste één verschillen Functies op omen Functies op omen worden ltijd recursief gedefinieerd. De recursieve structuur vn de oom zelf lt ons geen ndere mogelijkheid. Lten we eerst een functie definieren die het ntl getllen in een oom telt: ntlget Leeg = 0 ntlget (Knoop g links rechts) = 1 + ntlget links + ntlget rechts Een lege oom evt 0 getllen, een oom estnde uit een knoop en twee suomen evt 1 plus het ntl elementen vn de linker suoom plus het ntl elementen vn de rechter suoom Afdrukken vn een oom Je kunt een oom op verschillende mnieven fdrukken. De elngrijkste zijn, pre-order, inorder en post-order. In-order: druk voor iedere knoop eerst de elementen vn de linker suoom f, dn je eigen lel en dn de elementen vn de rechter suoom. Pre-order: druk voor iedere knoop eerst je eigen lel f, dn de elementen vn de linker suoom f en dn de elementen vn de rechter suoom. Post-order: druk voor iedere knoop eerst de elementen vn de linker suoom f, dn de elementen vn de rechter suoom en dn je eigen lel Vooreeld Knoop 1 (Knoop 2 (Knoop 3 Leeg Leeg) (Knoop 4 Leeg Leeg) ) (Knoop 5 (Knoop 6 Leeg Leeg) (Knoop 7 Leeg Leeg) ) Discrete Wiskunde 50

51 1 / \ / \ / \ in-order: [3,2,4,1,6,5,7] pre-order: [1,2,3,4,5,6,7] post-order: [3,4,2,6,7,5,1] Opgven Opgve 5.2 Definieer een functie diepte. Opgve 5.3 Definieer een functie sumtree die de som vn lle lels in een oom erekent. Opgve 5.4 Definieer een functie sumlef die de som vn lle lderen erekent. Opgve 5.5 Definieer een functie komtvoor die gegeven een oom t en een getl n ngt of het getl in de oom voorkomt. Opgve 5.6 Definieer een functie mltien die lle lels met 10 vermenigvuldigt. Opgve 5.7 Definieer een functie mptree die een functie f :: num -> num op lle lels vn een oom toepst. Opgve 5.8 Definieer een functie spiegelboom die een oom spiegelt in een verticle s door het midden. Opgve 5.9 Definieer functies, in_order, pre_order en post_order voor het fdrukken vn een oom. Opgve 5.10 Definieer een functie pden die lle pden vn een oom geeft (het resultt is dus een lijst vn lijsten vn getllen). Discrete Wiskunde 51

52 Opgve 5.11 Definieer een functie isvolledig die n gt of een oom volledig is. Opgve 5.12 Definieer een functie isevenwichtig die n gt of een oom evenwichtig is. Opgve 5.13 Definieer een functie mkboom die een lijst vn getllen omzet in een evenwichtige oom. Hint: doe dit door de lijst steeds te hlveren Binire Zoekomen Een elngrijke ctegorie vn omen zijn de inire zoekomen. Deze heen dezelfde definitie ls de voorgnde omen en moeten voldoen n de volgende extr voorwrden: In iedere knoop geldt: de lels in de linker suoom heen een wrde kleiner dn de knoop de lels in de rechter suoom heen een wrde groter dn de knoop Er mogen dus ook geen duele wrden voorkomen. Vooreeld 5 / \ / \ / \ / / \ / \ 6 10 Binire zoekomen worden geruikt voor de opslg vn informtie. Om ze goed te kunnen geruiken heen we de volgende functies nodig: insertoom: om een getl toe te voegen n een estnde oom. printoom: on de inhoud vn een inire zoekoom f te drukken. remoom: om een lel uit een inire zoekoom te verwijderen. De definitie vn de functie insertoom is recht toe recht n. insertoom n Leeg = Knoop n Leeg Leeg insertoom n (Knoop m l r) = Knoop m (insertoom n l) r, if n < m = Knoop m l (insertoom n r), if n > m = Knoop m l r, otherwise Discrete Wiskunde 52

53 mkoom zet een lijst vn getllen om in een inire zoekoom door ze één voor één n een oom toe te voegen. mkoom [] = Leeg mkoom (x:xs) = insertoom x (mkoom xs) Oefening Wt is het resultt vn mkoom [7,3,5,2,1,6]. printoom drukt de oom in-order volgorde f. Het resultt is dus een gesorteerde lijst vn getllen: printoom Leeg = [] printoom (Knoop n l r) = printoom l ++ [n] ++ printoom r De moeilijkste functie is remoom. Om een knoop te kunnen verwijderen uit de oom moeten we, ls het element dt we verwijderen niet een ld is, het opengevllen gt weer opvullen. Als een vn eide suomen leeg is, is dit geen proleem. We vervngen dn de knoop zelf door de niet lege suoom. Als eide suomen niet leeg zijn, dn vervngen we het lel vn de knoop door de kleinste wrde uit de rechter suoom, wrn we deze kleinste wrde (recursief) uit de rechter suoom verwijderen. Om dit te kunnen doen heen we een hulpfunctie minoom nodig die de kleinste wrde uit een oom oplevert. Vooreeld Als we 10 willen verwijderen uit de volgende oom, geeft dt geen proleem, omdt 10 een ld is. 5 / \ / \ / \ / / \ / \ 6 10 We kunnen gewoon de knoop die 10 evt vervngen door de lege knoop. 5 / \ / \ / \ / / \ / 6 Discrete Wiskunde 53

54 In het volgende vooreeld verwijderen we een knoop (met lel 4) met één suoom. We hoeven nu lleen de knoop te vervngen door de niet lege suoom. 5 / \ / \ / \ / \ 7 9 / \ 6 10 In het ltste vooreeld willen een knoop (met lel 8) verwijderen met twee niet lege suomen. Hiertoe moeten we 8 vervngen door het minimum vn de rechter suoom (9), wrn we 9 weer verwijderen uit deze suoom. 5 / \ / \ / \ / / \ / 6 minoom (Knoop n Leeg r) = n minoom (Knoop n l r) = minoom l remoom n Leeg = Leeg remoom n (Knoop m Leeg Leeg) = Leeg, if n=m = Knoop m Leeg Leeg,otherwise remoom n (Knoop m Leeg r) = r, if n = m = Knoop m Leeg (remoom n r), if n > m = Knoop m Leeg r, otherwise remoom n (Knoop m l Leeg) = l, if n = m = Knoop m (remoom n l) Leeg, if n < m = Knoop m l Leeg, otherwise remoom n (Knoop m l r) = Knoop minr l (remoom minr r), if m = n = Knoop m (remoom n l) r, if n < m = Knoop m l (remoom n r), otherwise where minr = minoom r Opgven Opgve 5.14 Discrete Wiskunde 54

55 Geef een efficiente versie vn de functie evt die controleert of een zoekoom een gegeven element evt. Opgve 5.15 Definiëer een functie sorteer die een lijst vn getllen sorteert door deze eerst om te zetten in inire zoekoom en deze zoekoom drn in pre-order volgorde f te drukken. Discrete Wiskunde 55

56 6. Huffmn codering 6.1 Huffmn Bomen We zullen nu een toepssing vn inire omen ekijken. Het etreft hier het coderen vn teksten op een dusdnige mnier dt ze zo weinig mogelijk ruimte in eslg nemen. Norml gesproken neemt in een tekst ieder krkter precies 1 yte (8 its in eslg). Een tekst vn 1024 krkters neemt dus 1 kyte in eslg. Door slimme codering kn dit veel efficiënter. Een vn deze coderingstechnieken is Huffmn codering. Dit is een zgn. vriele lengte codering. Dit etekent dt niet ieder krkter evenveel ruimte in eslg neemt. Deze techniek is op het volgende idee geseerd: Krkters die vk voorkomen in een tekst heen een kortere codering dn krkters die minder vk voorkomen De ruimte die een krkter in eslg neemt is miniml 1 it. Er is theoretisch een mximum dt net zo lng is ls het ntl verschillende krkters dt kn voorkomen. In de prktijk wordt dit mximum vrijwel nooit ereikt. We moeten voorkomen dt een korte code het eginstuk is vn een lngere code. Bv. ls e coderen ls 1, t ls 10 en h ls 11, dn kn 1110 zowel voor eet ls ht stn. Door geruik te mken vn inire omen kn dit ltste proleem eenvoudig voorkomen worden. Bekijk hiertoe de volgende inire oom: n / \ / \ e t We zien hier dt lleen de lderen (uiteinden) lels heen. De interne knopen heen geen lel. De dtstructuur die ij dit soort omen hoort is ls volgt: huffoom ::= Bld chr Knoop huffoom huffoom De oom geeft n hoe we de krkters n, t en e moeten coderen. Om de code te vinden voor een krkter volgen we de weg vnf de top vn de oom tot het krkter. Iedere keer ls we linksf gn noteren we een 0, ls we rechtf gn noteren we een 1. Dus voor n wordt de code 00, voor t 01 en voor e 1. Merk op dt we nu niet het proleem heen dt een korte code (die vn e ) het egin is vn een ndere code ( n of t ). Hiervoor is utomtisch gezorgd door de codering mv. een oom. Als we nu het woord teen willen coderen krijgen we de code Discrete Wiskunde 56

57 Oefening Geef zelf de codering vn het woord eten. Mv. vn ovenstnde oom kunnen we ntuurlijk lleen mr woorden met e, t en n coderen. Verder gn we ervn uit dt de e het meest voorkomt. Decoderen gt op nloge wijze. Als we de code willen decoderen, eginnen we oven in de oom en volgen een pd nr eneden mv. de code: Eerst gn we twee keer linksf (00) en komen ij n. Dn eginnen we weer oven en gn we rechtsf (1) en komen ij e. Drn nog een keer een e. En tot slot een t stt dus voor neet Opgven Opgve 6.1 Beschouw de volgende huffmn-code-oom. / \ / \ / \ e / \ / \ h / \ / \ / \ l o / \ / \ t m r, g stt hier voor sptie. Codeer nu de volgende woorden: moer, geel, tol en de zin hllo, hoe gt het (denk om de spties). Decodeer de volgende codes mv. ovenstnde oom: Codeer- en decodeer-lgoritmen voor Huffmn omen We zullen nu codeer en decodeer lgoritmen in Amnd mken Codeer De dtstructuur voor de Huffmn-oom ws: huffoom ::= Bld chr Knoop huffoom huffoom Discrete Wiskunde 57

58 Om te kunnen coderen moeten we eerst uit de Huffmn oom de codes voor lle krkters (lderen) drin fleiden. Dit gt mv. de functie oomtotel: oomtotel (Bld c) = [(c,[])] oomtotel (Knoop l r) = [(c,'0':code) (c,code) <- oomtotel l] ++ [(c,'1':code) (c,code) <- oomtotel r] oomtotel werkt vn de lderen f nr oven. Controleer zelf de werking vn oomtotel n de hnd vn een eenvoudige oom. Voor de oom uit de vorige opgve geeft oomtotel de onderstnde tel: [('t', "000"), ('', "001"), ('e', "01"), ('h', "100"), ('l', "1010"), ('o', "1011"), ('m', "11000"), ('r', "11001"), (',', "11010"), ('g', "11011"), (' ', "111")] Het is nu eenvoudig een tekst te coderen mv. deze tel. Dit gt met de functies codeer en vindcode. vindcode zoekt de code vn een krkter op in de tel. codeer zoekt voor lle krkters in de tekst de code op en plkt deze codes n elkr. codeer codetel txt = conct [vindcode c codetel c <- txt] vindcode c codetel = hd [code (l,code) <- codetel; l = c] Decoderen Decoderen is een kwestie vn mv. de code de oom f lopen tot je ij een ld komt. Begin drn weer oven in de oom: decodeer hufoom cs = dc hufoom cs where dc (Bld c) [] = [c] ltste it ereikt dc (Bld c) cs = c : dc hufoom cs krkter herkend dc (Knoop l r) ('0':cs) = dc l cs linksf ij 0 dc (Knoop l r) ('1':cs) = dc r cs rechtsf ij Constructie vn de Huffmn oom Opmerking: Het onderstnde is geen tentmenstof! Om een Huffmn oom te kunnen construeren moeten we eerst een frequentie nlyse vn de te coderen tekst doen. De functie freqtel telt voor ieder krkter hoe vk het in een tekst voorkomt: freqtel xs = sort [(x,x) x <- "cdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz,."; x := # [y y <- xs; y = x]; x>0] freqtel losgelten op de tekst hllo, hoe gt het er mee levert ons: [(1, ','), (1, 'g'), (1, 'm'), (1, 'r'), (2, 'l'), (2, 'o'), (2, 't'), (3, ''), (3, 'h'), (4, ' '), (5, 'e')] Discrete Wiskunde 58

59 Omdt we willen sorteren op frequentie stt de frequentie voorop. Voor het ouwen vn de oom is het nodig dt we de definitie vn huffoom iets npssen. In ieder ld houden we ij hoe vk het krkter voorkomt. In iedere knoop houden we ij wt de som vn de frequenties vn lle krkters in de lderen vn eide suomen zijn. huffoom ::= Bld num chr Knoop num huffoom huffoom Het ouwen vn de oom gt nu in een ntl stppen: Eerst mken we een lijst vn omen estnde uit lleen mr lderen. Dit geeurt in de uitdrukking: [Bld f c (f,c) <- freqlist] Deze lijst vn omen gn we net zolng comineren totdt we nog mr één oom overhouden. Deze oom is nu het eindresultt. We comineren steeds de eerste twee omen uit de lijst. Het comineren vn twee omen l en r estt uit het smenvoegen tot een knoop Knoop wrde l r, met ls wrde de som vn de wrden vn de twee suomen. De zo geconstrueerde oom wordt weer ingevoegd in de lijst vn omen wrij er voor wordt gezorgd dt deze gesorteerd op freqentie lijft. Uiteindelijk houden we een lijst met één oom over. Dit is nu de gezochte oom. mkboom freqlist = m [Bld f c (f,c) <- freqlist] m [t] = t m (t1 : t2 : ts) = m (insert (Knoop (wrde t1 + wrde t2) t1 t2) ts) insert t [] = [t] insert t (t1:ts) = t : t1 : ts, if wrde t <= wrde t1 = t1 : insert t ts, otherwise wrde (Knoop n ) = n wrde (Bld n _) = n Discrete Wiskunde 59

60 7. Eindige utomten 7.1 Tlen en eindige utomten Tlen en zeker progrmmeertlen heen een duidelijke structuur. Eindige utomten en grmmtic s zijn mnieren om die structuur te eschrijven. Definities: een tl is een verzmeling strings een string is een rij letters een lfet is een verzmeling letters Vooreelden: {, } is een lfet is een string is een string ε is een string (een specil gevl: de string vn nul letters) {,,,,... } is een tl De ovenstnde tl heeft een nogl simpele structuur: enkele s gevolgd door een. Zulke vrij eenvoudige tlen kunnen met een eindige utomt gegenereerd worden. Voor de vooreeldtl voldoet de volgende eindige utomt: 1 2 Deze utomt estt uit toestnden (ngegeven met een cirkel) en overgngen (ngegeven met een pijl). De toestnden heen ls lels 1 en 2. Er zijn overgngen vn 1 nr 1 met ls lel en vn 1 nr 2 met ls lel. Het symool => geeft n dt toestnd 1 de egintoestnd is. De duele rnd om toestnd 2 geeft n dt dit een eindtoestnd is. Elke utomt heeft ltijd 1 egintoestnd, mr kn meerdere eindtoestnden heen. Een utomt werkt ls volgt: hij egint in de egintoestnd hij mkt telkens een overgng hij stopt in een eindtoestnd Belngrijk hierij is dt de utomt mg stoppen in een eindtoestnd, mr ook door kn gn. De lels vn de gemkte overgngen vormen chter elkr een string. Alle strings die de utomt zo kn mken vormen tezmen de tl vn de utomt. Discrete Wiskunde 60

61 Vooreeld: 1 2 De tl vn deze utomt is de verzmeling vn lle strings die estn uit een oneven ntl s. Vooreeld: De tl vn deze utomt is de verzmeling vn lle strings estnde uit s en s, wrin voorkomt ls deelstring. Met deze utomt is iets ijzonders n de hnd, wnt hij kn de string op 2 mnieren mken: 1 --> 1 --> 2 --> > 2 --> 3 --> 3 Dit is op zich een ongewenst gedrg, wnt de utomt moet ls het wre kiezen en ls hij zou proeren te mken door te eginnen met 1 --> 1 --> 1 dn lukt het niet meer om te mken. Definitie: een eindige utomt is deterministisch ls hij elke string op hoogstens 1 mnier kn mken. Een eindige utomt die een eplde string op meer dn 1 mnier kn mken, noemen we non-deterministisch. Zo n utomt is te herkennen n het feit dt hij een toestnd evt vn wruit je met een eplde letter nr meer dn 1 toestnd kn gn. In het vooreeld geeurt dit ij toestnd 1 wnt met de letter kun je zowel nr toestnd 1 ls nr toestnd 2 gn Opgven Opgve 7.1 Mk een eindige utomt voor de volgende tlen vn strings estnde uit s en s:. lle strings wrin precies 2 s voorkomen. lle strings wrin n een ltijd een of meer s komen c. lle strings die estn uit een even ntl s gevolgd door een even ntl s d. lle strings wrin niet voorkomt e. lle strings wrin precies 2 keer voorkomt (in is dit ook het gevl) f. lle strings wrin een even ntl s of een even ntl s voorkomt Discrete Wiskunde 61

62 Opgve 7.2 Gegeven is de volgende eindige utomt: Is de utomt deterministisch?. Beschrijf de tl vn de utomt 7.2 Een eindige utomt ouwen Een rdige mnier om een deterministische eindige utomt te construeren voor een eplde tl is om elke toestnd iets te lten onthouden vn de tot nog toe gegenereerde letters. Vooreeld: mk een utomt voor de tl vn lle strings estnde uit s en s wrin voorkomt. Vn elng om te weten is nu P: we heen l gehd Q: de ltste letter ws een Voor de utomt zijn de volgende toestnden vn elng: 1: ~P /\ ~Q 2: ~P /\ Q 3: P We zouden toestnd 3 ook weer op kunnen splitsen in P /\ ~Q en P /\ Q mr dit hoeft niet omdt we ls we l gehd heen er willekeurig wt chter kunnen zetten. Het verschil tussen wel of niet ls ltse een speelt geen enkele rol meer. De utomt wordt: In het egin heen we het lege woord. Dus we heen nog niet gehd en de ltste letter ws geen. De egintoestnd is dus 1. Als er in toestnd 1 een komt, dn heen we nog steeds niet gehd mr de ltste letter is wel een, drom wordt de toestnd 2. Als er in toestnd 1 een komt, dn is de ltste letter geen en lijven we dus in toestnd 1. Zo kun je ook de ndere overgngen eredeneren. Dt toestnd 3 eindtoestnd is, is omdt we dn gehd heen. Discrete Wiskunde 62

63 Vooreeld: mk een utomt voor de tl vn lle strings estnde uit s en s die precies 2 s en minstens 2 s evtten. We moeten nu weten of we 0, 1 of 2 s gehd heen en of we 0, 1 of meer dn 1 gehd heen. De utomt wordt: 0, 0 1, 0 2, 0 0, 1 1, 1 2, 1 0, >1 1, >1 2, >1 De lels vn de toestnden heen de volgende etekenis: het eerste cijfer geeft het ntl s n en het tweede cijfer geeft het ntl s dt we l gehd heen. Vnuit de toestnd 2, 0 is er geen overgng met de letter, omdt we geen strings mogen genereren met meer dn 2 s Opgven Opgve 7.3 Mk een eindige utomt voor de volgende tlen vn strings estnde uit s en s door de etekenis vn de toestnden goed te definieren:. lle strings wrin precies 3 s voorkomen. lle strings wrin n een ltijd precies twee s komen c. lle strings wrin een even ntl s en een even ntl s voorkomt 7.3 Determinisme Een deterministische eindige utomt kunnen we geruiken om te testen of een string tot zijn tl ehoort, wnt ij elke string hoort er dn hoogstens 1 pd en dus hoogstens 1 toestnd wr we met deze string uitkomen. Als die resulterende toestnd een eindtoestnd is dn hoort de string tot de tl en nders niet. Vooreeld: Discrete Wiskunde 63

64 1 2 3 De string heeft ls pd: 1 --> 2 --> 3 --> 3 --> 3. Omdt we in 3 uitkomen en 3 eindtoestnd is kn de utomt de string mken. De string heeft ls pd: 1 --> 1 --> 1 --> 2. Nu komen we in 2 uit en 2 is geen eindtoestnd; drom kn de utomt deze string niet mken. Dit procede kunnen we in Amnd ls volgt progrmmeren: test string = stp 1 string where stp 1 ( :cs) = stp 2 cs stp 1 ( :cs) = stp 1 cs stp 2 ( :cs) = stp 3 cs stp 2 ( :cs) = stp 1 cs stp 3 ( :cs) = stp 3 cs stp 3 ( :cs) = stp 3 cs stp 3 = True stp = Flse De lokle functie stp heeft de volgende etekenis: stp toestnd string = True,if de utomt kn vnuit de gegeven toestnd de gegeven string mken = Flse,otherwise Zo n vertling vn een utomt in Amnd code werkt lleen goed voor een deterministische utomt, omdt Amnd ook deterministisch werkt. Vooreeld: mk een Amnd functie om te testen of een string estt uit een even ntl s en een willekeurig ntl s. De ijehorende utomt heeft 2 toestnden: 1: we heen een even ntl s 2: we heen een oneven ntl s 1 2 De Amnd functie wordt: Discrete Wiskunde 64

65 test string = stp 1 string where stp 1 ( :cs) = stp 2 cs stp 1 ( :cs) = stp 1 cs stp 2 ( :cs) = stp 1 cs stp 2 ( :cs) = stp 2 cs stp 1 = True stp = Flse Opgven Opgve 7.4 Mk voor elk vn de volgende tlen een Amnd functie die test of een string tot die tl hoort:. lle strings wrin minstens 3 s voorkomen. lle strings wrin n een ltijd precies een komt c. lle strings wrin een even ntl s en een even ntl s voorkomt Proeer de functies ook direct in Amnd te progrmmeren mv lijstcomprehensies. 7.4 Deterministisch mken vn een utomt Om strings te herkennen is een deterministische eindige utomt hndig, mr vk is het eenvoudiger om een non-deterministische utomt ervoor te construeren. Stel we willen een eindige utomt mken voor lle strings estnde uit s en s wrin de string voorkomt. Een non-deterministische utomt hiervoor is: Een deterministische utomt hiervoor mken is lstiger. Mr het lijkt dt er een lgoritme is om vn een non-deterministische utomt een deterministische utomt te mken, die precies dezelfde tl genereert. De deterministische utomt ootst de non-deterministische utomt n. De string heeft de volgende pden in de non-deterministische utomt: 1 --> 1 --> 1 --> > 1 --> 1 --> > 1 --> 2 --> 3 Dus vnuit 1 kom je met in 1, 2 of 3. Discrete Wiskunde 65

66 De deterministische utomt heeft hoogstens 1 pd voor. De toestnd die uiteindelijk ereikt wordt zullen we 1, 2, 3 noemen, omdt hij overeenkomt met pden in de oorspronkelijke utomt die in 1, 2 of 3 uitkomen. Kijken we nu nr de string, dn kn die in de oorspronkelijke utomt uitkomen in 1 of 4. Hiervoor hoeven we lleen te kijken hoe je de pden vn kunt verlengen met een overgng met een. We hoeven dus lleen te kijken nr de eindtoestnden vn en hoe je vn druit verder kn met een. In een schem: 1 - -> > 3 - -> ,2,3 - -> 1,4 In de nieuw te mken deterministische utomt komt dus de overgng vn 1,2,3 nr 1,4 voor met de letter. Omdt er mr 1 egintoestnd is, egint de nieuwe utomt op dezelfde mnier ls de oorspronkelijke: 1 Beginnend vnuit de unieke egintoestnd krijgen we: 1 - -> > > 1, > 1 Dit levert de eerste stp: 1 1,2 Vnuit 1,2 he je overgngen: Discrete Wiskunde 66

67 1 - -> > > ,2 - -> 1,2, > > ,2 - -> 1 1 1,2 1,2,3 Nu gn we kijken wt we vnuit 1,2,3 kunnen doen: 1 - -> > > > ,2,3 - -> 1,2, > > 3 - -> ,2,3 - -> 1,4 Nu is 4 een eindtoestnd in de oorspronkelijke utomt, dus 1,4 is ook een eindtoestnd in de nieuwe utomt. Het resulteert in: 1 1,2 1,2,3 1,4 We kunnen dit procede stug doorzetten en de totle deterministische utomt wordt dn: Discrete Wiskunde 67

68 1 1,2 1,2,3 1,4 1,2,3,4 1,2, Opgven Opgve 7.5 Mk equivlente deterministische eindige utomten voor de volgende utomten: Opgve 7.6. Mk een nondeterministische eindige utomt voor de tl vn lle strings estnde uit s en s wrin voorkomt. Mk voor de utomt uit onderdeel. een equivlente deterministische utomt 7.5 Reguliere expressies De tl vn een eindige utomt heeft doorgns een eenvoudige herhlende structuur zols de volgende vooreelden lten zien: 1 2 Tl:,,,... Ptroon: * Discrete Wiskunde 68

69 1 2 Tl:,,,... Ptroon: ()* Tl: ε,,,...,,,... Ptroon: * * Bij de utomten heen we het ptroon wrn hun strings voldoen vermeld. Zo n ptroon heet ook wel een reguliere expressie. Hij kn estn uit letters, keuze en herhling. De keuze tussen x en y geven we n ls x y. Een herhling vn 0 of meer keer x geven we n ls x*. De conventie is dt herhling (*) sterker indt dn keuze ( ). Dus * * etekent (*) (*) en is iets heel nders dn ( )*. Het is meestl niet zo moeilijk om ij een reguliere expressie een equivlente utomt te construeren. Vooreeld: mk een utomt met ls tl ( )*( )* Andersom dus vn een utomt een reguliere expressie geven is doorgns ook niet l te ingewikkeld. Wr het op neer komt is dt je toestnden ls het wre wegwerkt. Vooreeld: epl een reguliere expressie voor de tl vn de utomt Discrete Wiskunde 69

70 1 2 3 Dit lijkt een onhndelr ding met l die pijlen heen en weer terug. Toch is de situtie in de uurt vn toestnd 3 vrij eenvoudig. We kunnen toestnd 3 wegwerken ls we een reguliere expressie lngs een pijl zetten: * 1 2 N deze mnipultie is ook de situtie rond toestnd 2 eenvoudig geworden. We werken dus nu toestnd 2 weg. 1 (*)* Dus de reguliere expressie is: ((*)*)* Nog een vooreeld: Nu kunnen we toestnd 2 wegwerken door elke overgng nr 2 met 1 stp te verlengen: 1 3 Alle overgngen nr toestnd 1 kunnen we op dezelfde mnier ehndelen, wrdoor we toestnd 1 gedeeltelijk wegwerken. Discrete Wiskunde 70

71 ( )()* 1 3 De f te lezen reguliere expressie is dn: ()* ( ( )()* )* Opgven Opgve 7.7 Bepl reguliere expressies voor de tlen vn de volgende utomten: c Opgve 7.8 Bepl eindige utomten ij de volgende reguliere expressies:. ( )* ()*. ( )* ()* c. ( ()*)* ()* Discrete Wiskunde 71

72 8. Grmmtic s 8.1 Rekenkundige expressies De tl vn de rekenkundige expressies estt uit strings zols: * (1 + 8) * (7-14) Als we even fzien vn de hkjes en tussenliggende spties, dn eschrijft de volgende reguliere expressie hun structuur: (0 ( ) ( )*) ( (+ - * /) (0 ( ) ( )*) )* Een onleesre formule, die wt helderder gemkt kn worden door hem op te reken in onderdelen: cijfer = egincijfer = getl = 0 egincijfer cijfer* opertor = + - * / sectie = opertor getl expressie = getl sectie* De expressie 13 * estt uit het getl 13 gevolgd door de secties * 17 en - 5 en De sectie * 17 op zijn eurt estt uit de opertor * en het getl 17. Het zo enoemen vn lle onderdelen heet ontleden. Nu de hkjes nog. Dt is niet zo eenvoudig ls het misschien lijkt, wnt hkjes moeten netjes in pren voorkomen. Dus we moeten op een of ndere mnier hkjes tellen en dt is iets wt met een eindige utomt niet kn. Immers een eindige utomt kn nooit verder tellen dn het ntl toestnden wr hij uit estt. Het rdige is dt we wel hkjes kunnen tellen ls we onze definities recursief mken, wt zoveel wil zeggen dt de definities willekeurig nr elkr mogen verwijzen zols in een where-cluse vn Amnd. De volgende verzmeling definities is voldoende: cijfer = egincijfer = getl = 0 egincijfer cijfer* ( expressie ) opertor = + - * / sectie = opertor getl expressie = getl sectie* Het enige dt vernderd is, is de definitie vn een getl. Definitie: een verzmeling (recursieve) reguliere expressies noemen we een grmmtic. Discrete Wiskunde 72

73 (1 + 8) * (7-14) kunnen we volgens de gegeven grmmtic ls volgt ontleden: (1 + 8) is een getl, wnt is een expressie * (7-14) is een sectie, wnt (7-14) is een getl, wnt 7-14 is een expressie Een ontleedoom geeft de structuur visueel weer: ( ) * ( ) eginc eginc eginc eginc cijfer getl op getl getl op getl sectie sectie expressie expressie getl op getl sectie expressie De grmmtic voor rekenkundige expressies is nogl rijk. Drom zullen we ons in het vervolg vn dit hoofdstuk eperken tot de volgende deelgrmmtic vn rekenkundige expressies estnde uit cijfers, optellen en ftrekken, en ntuurlijk hkjes. cijfer = getl = cijfer cijfer* ( expressie ) sectie = + getl - getl expressie = getl sectie* Voor deze grmmtic zullen we stp voor stp in Amnd een ontleder (Engels: prser) mken. Dit is een stukje progrmm dt controleert of een string voldoet n de grmmtic en dt eventueel de ijehorende wrde vn de string eplt. Om te lten zien hoe de grmmtic in stt is de wrde vn een rekenkundige expressie te eplen gn we de string ontleden. In de ontleedoom geven we ook de wrde vn onderdelen n. Discrete Wiskunde 73

74 cijfer(1) cijfer(3) cijfer(8) cijfer(7) getl(1*10+3 = 13) getl(8) getl(7) sectie(8) sectie(-7) expressie(13+8+(-7) = 14) Opgven Opgve 8.1 Gegeven is de volgende grmmtic: X = X Geef ontleedomen voor de volgende strings:.. c. d. eredeneer dt de tl vn X = { n n n >= 1 } wrij n etekent n s chter elkr Opgve 8.2 Gegeven is de volgende grmmtic: S = X c S X = X Geef ontleedomen voor de volgende strings:. c. cc c. ccccccc d. wt is de tl vn X? Opgve 8.3 Gegeven is de volgende grmmtic: S = d X c S X = X Y Y = Y ε Geef ontleedomen voor de volgende strings:. cd. ccd c. cccccccd Discrete Wiskunde 74

75 Geef een reguliere expressie en een eindige utomt voor de tl S Opgve 8.4 Stel voor de volgende tlen grmmtic s op ( n etekent n s chter elkr):. { n n n >= 0 }. { n m n >= 0 /\ m >= 0 /\ m <= n } c. { ( n n )* c* n >= 0 } Opgve 8.5 De volgende grmmtic kn ook lle rekenkundige expressies n: cijfer = getl = cijfer cijfer getl opertor = + - * / expressie = getl ( expressie ) expressie opertor expressie Geef zoveel mogelijk ontleedomen voor de volgende rekenkundige expressies en vermeld ook telkens de wrde vn de onderdelen: * 3. (8-90) / 7 * 8 c. ( ) - (6) Wt zou het ndeel zijn vn deze grmmtic? Opgve 8.6 Mk de volgende (deel)grmmtic voor Pscl sttements f: sttement = ssignment ifsttement whilesttement forsttement repetsttement group ε group = egin sttements end sttements = ε sttement sttement ( ; sttement)* ssignment = vrile := expression ifsttement = if condition then sttement... whilesttement =... forsttement =... repetsttement =... Hierij hoeven vrile, expression en condition niet verder uitgewerkt te worden. Deze grmmtic werkt niet op letters zols we gewend zijn, mr op strings zols if en while en repet. 8.2 Vereenvoudigde schrijfwijze Hieroven werden grmmtic s eschreven ls recursieve regulier expressies. We zullen nu lten zien dt we grmmtic s nog eenvoudiger kunnen eschrijven. In grmmtic s zijn nml de herhling (*), de optie ([iets]) en de keuze ( ) niet nodig. Deze constructie kunnen met recursie eschreven worden. Discrete Wiskunde 75

76 Vooreelden: S -> * wordt: S -> eps S -> S S -> [] wordt: S -> eps S -> S -> wordt: S -> S -> Wel worden hierij voor non-terminls vk meerdere regels geïntroduceerd. Dit is ij implementtie vk lstig omdt het kn geeuren dt je ij het toepssen vn een regel er soms ps n een tijdje chterkomt dt deze regel niet vn toepssing is en je een ndere regel hd moeten geruiken (cktrcking). Dit mkt prsers trg. We streven er drom nr grmmtic s zo in elkr te steken dt op ieder moment dt een nieuwe regel moet worden toegepst het eerst volgende symool uniek eplt welke versie vn de regel er vn toepssing is. We noemen een grmmtic dn LL1. Voor prktisch geruik is iedere grmmtic ls een LL1 grmmtic te reliseren. De relistie vn een prser voor een LL1 grmmtic m.v. recursieve functie noemen we een recursive descent prser. Er zijn ook ndere mnieren om prsers te mken (genereren) m..v tellen. De grmmtic hoeft dn niet noodzkelijk LL1 te zijn. Deze prsers zijn i.h. efficiënter dn LL1 prsers. Discrete Wiskunde 76

77 9. Bcktrcking 9.1 Inleiding Een elngrijke, veelgeruikte, progrmmeertechniek is cktrcking. Bcktrcking wordt geruikt voor zgn. zoekprolemen. Dit zijn prolemen wrij er één (lle) mogelijke oplossing(en) gezocht moet(en) worden. Vooreelden: Vind een (lle) inkleuring(en) voor een lndkrt zodt twee ieder tweetl n elkr grenzende lnden verschillende kleuren heen. Vind een route lng verschillende steden zodt de totle fstnd miniml is. Vind een pltsing op een schkord vn cht dmes, zodt ze elkr niet kunnen sln. Vind een korrekte oplossing voor de volgende puzzel Kleuren vn een lndkrt Uit de wiskunde is ekend dt het mogelijk is een lndkrt zo in te kleuren dt twee n elkr grenzende lnden verschillende kleuren heen, met slechts vier verschillende kleuren. Het ewijs vn deze stelling is uitengewoon ingewikkeld. Het ws het eerste wiskundige ewijs wrij uitgereid geruik werd gemkt vn computers om een groot ntl ijzondere gevllen door te rekenen. Een lndkrt ddwerkelijk met vier kleuren inkleuren gt gelukkig een stuk mkkelijker, l kn ook hierij de computer de tk een stuk eenvoudiger mken: Gegeven zijn een lijst vn 4 kleuren, een lijst vn lnden en een lijst die per lnd ngeeft n welke ndere lnden dit lnd grenst. lnden = ["Ned","Lux","Bel","Fr","Dui"] kleuren = ["Rood","Bluw","Geel","Groen"] grenzen = [("Ned",["Bel","Dui"]), ("Bel",["Ned","Fr","Dui","Lux"]), ("Dui",["Fr","Ned","Bel","Lux"]), ("Lux",["Fr","Dui","Bel"]), ("Fr",["Bel","Lux","Dui"])] De functie kleuringen moet lle mogelijke lijsten vn (lnd,kleur) opleveren die n de vrg voldoen. De oplossing is dus een lijst vn lijsten! We gn het proleem recursief oplossen. De recursie loopt over de lnden die we moeten kleuren. Stel we heen een ntl lnden korrekt gekleurd en we willen het volgende lnd kleuren. We kunnen dn kiezen uit lle kleuren, wrij we er op moeten letten of de kleur Discrete Wiskunde 77

78 die we n het ltste lnd heen gegeven niet conflicteert met de kleuren vn de lnden die l gekleurd zijn. De controle geeurt in de functie sve. Sfe m k ks controleert of kleur k voor lnd m niet in strijd is met de lijst vn pren (lnd,kleur) in ks. Hoe gieten we dit in een recursieve functie? Een recursieve functie estt ltijd uit (miniml) twee gevllen. Eén drvn is de stop cse. Hier is dt het gevl dt we een lege lijst vn lnden moeten kleuren. Als we nul lnden moeten kleuren levert ons dt één oplossing: de lege lijst. Dr we een lijst vn lle mogelijke kleuringen moeten opleveren, wordt het resultt nu [[]]. Een niet lege lijst vn lnden estt uit een kop m en een strt ms. We willen het proleem recursief oplossen, dus we gn eerst de lnden uit de strt kleuren met een recursieve nroep vn kleuringen. Dit levert ons een lijst vn lle mogelijke kleuringen vn ms op. Voor ieder vn deze kleuringen ks, gn we nu proeren de kop m een kleur k (gekozen uit kleuren) te geven die niet in strijd is met de kleuren uit ks. Deze check kn gedn worden met een nroep vn sfe. Smen geeft ons dit: kleuringen [] = [[]] kleuringen (m:ms) = [(m,k) : ks ks <- kleuringen ms; lle kleuringen vn de overige lnden k <- kleuren; voor m een kleur kiezen uit kleuren sfe m k ks test of deze kleur is toegestn ] where sfe m k ks = [lnd (lnd,kleur) <- ks; kleur = k; ieder lnd met dezelfde kleur ls m (l2,uren) <- grenzen; l2 = lnd; memer uren m] mg m niet ls uur heen = [] Het schem dt we nu edcht heen is heel lgemeen. In de meeste cktrck-prolemen gt het erom om een voorwerpen te koppelen n iets nders op een dusdnige mnier dt de koppelingen niet in strijd met elkr zijn. 9.3 Het cht koninginnen proleem Geef lle mogelijke mnieren om 8 koninginnen op een schkord te pltsen zonder dt ze elkr kunnen sln. Bij dit proleem is het zk eerst een goede representtie te vinden. We willen het proleem grg weer reduceren tot een koppelingsproleem. Mr wt moeten we n wt koppelen? Op het eerste gezicht zou men zeggen koninginnen n ordposities. Mr wt is een koningin? Als we even ndenken komen we er chter dt lle koninginnen in verschillenden rijen moeten stn en dt er in iedere rij precies één koningin komt te stn. Het is drom ntuurlijker om rijposities n kolomposities te koppelen. Discrete Wiskunde 78

79 We noteren een positie op het schkord ls (r,k) wrij r de rij is en k de kolom. r en k vriëren eide vn 1 tot 8. We kunnen nu voor twee koninginnen de functie slt definiëren die ngeeft of de eerste koningin de tweede slt (en vice vers): slt (i,j) (m,n) = i = m \/ j = n \/ s(i-m) = s(j-n) Een koningin slt een ndere koningin ls ze, of in dezelde rij stn, of in dezelfde kolom, of in dezelfde digonl. Queens wordt nu ngeroepen met ls prmeter de lijst vn rijen wrvoor een ijehorende kolom postitie moet worden gevonden. Voor het chtkoninginnenproleem wordt dit dus: queens [1..8] queens [] = [[]] queens (r:rs) = [(r,k) : qs ] qs <- queens rs; oplossingen voor overige rijen k <- [1..8]; koppel rij n kolom nd [~(slt (i,j) (r,k)) (i,j) <- qs] Het ptroon is weer hetzelfde ls ij de oplossingen vn het vorige prolemeen. De recursieve nroep lost het proleem op voor de overige rijen. We proeren hiern een koningin toe te voegen op rij r. We controleren hierij of de nieuwe koningin niet geslgen wordt door een reeds gepltste koningin Opgven Opgve 9.1 Vind het (unieke) getl n estnde uit 9 cijfers met de volgende eigenschppen: - de cijfers 1 t/m 9 komen precies één keer voor - de eerste k cijfers vn n zijn deelr door k voor k 1 t/m 9 Opgve 9.2 Vind lle deellijsten vn een lijst vn getllen wrvn de som precies gelijk is n de helft vn de som vn lle getllen in de lijst. Opgve 9.3 Gegeven een lijst vn winkels met fnme hoeveelheid en een lijst vn distriutiecentr met cpciteit. Geef lle toekenningen vn winkels n distriutiecentr zodt de totle cpciteit vn een distriutiecentrum niet wordt overschreden. Er mogen meerdere winkels n 1 distriutiecentrum gekoppeld worden. winkels = [("h1",15),("h2",18),("h3",17),("h4",25)] distr = [("d1",40),("d2",19),("d3",20)] Tip: definiëer eerst een functie updte d h ds, die in een lijst vn distriutiecentr ds de cpciteit vn distriutiecentrum d verlgt met hoeveelheid h. Discrete Wiskunde 79

80 Discrete Wiskunde 80

81 10. Gulzige lgoritmen 10.1 Grfen Een grf is een netwerk estnde uit een verzmeling knopen en een verzmeling verindingen tussen de knopen. De verindingen kunnen voorzien zijn vn een lel (ijvooreeld een lengte of kosten). De verindingen kunnen een richting heen. Vooreelden: Een eindige utomt is een gerichte grf wrvn de lels letters zijn. 1 2 Een wegenkrt is een ongerichte grf wrvn de lels fstnden voorstellen. Leeuwrden 60 Groningen 25 Heerenveen Drchten Een pd in een grf is een reeks op elkr nsluitende verindingen. Bijvooreeld: Leeuwrden -> Drchten -> Groningen In de informtic kom je grfen tegen in de vorm vn dtcommunictienetwerken. De knopen zijn dn computers (internetservers, repeters, routers, ridges, gtewys e.d.). De verindingen zijn dn de dtcommunictielinks. Ook het world wide we kun je opvtten ls een grf met ls knopen de wepgin s en ls verindingen de hyperlinks Representties In Amnd kunnen we een grf op verschillende mnieren representeren. Discrete Wiskunde 81

82 Vooreeld: c 2 d Voor de hnd ligt een representtie estnde uit een lijst vn knopen en een lijst vn verindingen. knopen = [,, c, d ] verindingen = [(,, 5), (, c, 3), (, c, 3), ( c, d, 2)] Eigenlijk zouden we ook de omgekeerde verindingen zols (,, 5) moeten opsln, mr in een ongerichte grf kunnen we deze ntuurlijk ltijd erekenen. (deze representtie is geruikt in de opgve over de voetlcompetitie in hoofdstuk 2) Een ndere veelgeruikte representtie is een lijst vn knopen met per knoop een lijst vn verindingen. Voor het vooreeld: grf = [(, [(, 5), ( c, 3)]), (, [(, 5), ( c, 3)]), ( c, [(, 3), (, 3), ( d, 2)]), ( d, [( c, 2)])] Hierij is het verstndig om wel lle verindingen op te sln, omdt het erekenen vn de omgekeerde verindingen lstig is. In Pscl kunnen we een mtrix geruiken om de lels vn de verindingen in op te sln. Als de lels ijvooreeld fstnden tussen knopen voorstellen, kunnen we een specile grote wrde geruiken om n te geven dt er geen verinding is. CONST ntlknopen = 4; inf = 10000; (* infinite *) TYPE Mtrix = rry[1..ntlknopen, 1..ntlKnopen] of integer; CONST fstnd: Mtrix = (( 0, 5, 3,inf), ( 5, 0, 3,inf), ( 3, 3, 0, 2), (inf,inf, 2, 0,)); Discrete Wiskunde 82

83 10.2 Minimle opspnnende oom We gn nu uit vn een smenhngende ongerichte grf, wrvn de lels positieve getllen zijn. Dit kn ijvooreeld een dtcommunictienetwerk zijn met de kosten vn nleg vn de verschillende verindingen. Gevrgd wordt een deelnetwerk te eplen met minimle kosten, wrij nog wel elke knoop vnuit elke ndere knoop te ereiken vlt. Vooreeld: d 1 4 f 3 c 2 e 3 Het gevrgde minimle deelnetwerk evt lle knopen mr niet lle verindingen. In het ijzonder evt het geen lussen. Wnt ls we vn een lus een verinding weglten, dn heen we een goedkoper netwerk dt nog steeds lle knopen met elkr verindt Het lgoritme vn Kruskl Een voor de hnd liggend lgoritme is nu: sorteer de verindingen in volgorde vn kosten en lt hieruit een voor een de verindingen weg die voor een lus zorgen. In het vooreeld: d e d e weglten c e c weglten c weglten e f d f weglten 2 c 2 2 d e 1 3 f Het lgoritme vn Prim Een ndere npk is om in een willekeurige knoop te eginnen en vn druit telkens uit te reiden met de goedkoopste verinding vnuit de l gekozen punten nr een nder punt. Op die mnier krijgen we nooit lussen en vinden we een miniml netwerk. In het vooreeld: Discrete Wiskunde 83

84 egin ij knoop de verinding - is de goedkoopste vnuit de verinding - d is de goedkoopste vnuit en de verinding d - e is de goedkoopste vnuit,, en d de verinding e - c is de goedkoopste vnuit,, d en c de verinding e - f is de goedkoopste vnuit,, d, c en e Min of meer toevllig krijgen we dezelfde oplossing Opgven Opgve 10.1 Ps eide lgoritmen toe op de volgende grf: d 5 4 f 3 c 2 e 3 Opgve 10.2 Welke representtie vn een grf is het meest geschikt voor het lgoritme vn Kruskl en welke voor het lgoritme vn Prim? 10.3 Kortste pd We gn nu uit vn een smenhngende grf wrvn de lels positieve getllen zijn die de lengte vn een verinding voorstellen. Gevrgd wordt om het kortste pd tussen twee gegeven knopen te eplen. Discrete Wiskunde 84

85 Vooreeld: d 1 4 f 3 c 2 e 3 Gevrgd: het kortste pd tussen en f Het lgoritme vn Dijkstr We kunnen op dezelfde mnier te werk gn ls ij het lgoritme vn Prim. D.w.z. we eginnen ij en reiden de verzmeling knopen steeds uit met de dichtsijzijnde ndere knoop. Vn deze verzmeling knopen weten we precies de kortste fstnd tot. Zodr we f n de verzmeling heen toegevoegd weten we de kortste fstnd vn tot f. We eginnen ij, de minimle fstnd vn nr is duidelijk 0. Omdt het dichtste ij ligt, is de minimle fstnd vn nr ook ekend en wel 2. We ekijken nu lle directe verindingen vnuit,. Dit zijn -c, -c, -e en -d. Voor c levert dit een pd nr met lengte 3 of met lengte 5 op. Voor e levert dit een pd vn lengte 4 op. Voor d levert dit een pd vn lengte 4 op. Voor c vinden we de kleinste wrde (3) dit moet dus wel het kortste pd vn nr c zijn, wnt elk nder pd loopt vi de ndere en is dus lnger. Vnuit,, c zijn er directe verindingen nr d en e. Voor d vinden we een pd met lengte 4. Voor e vinden we een pd met lengte 4 en een pd met lengte 5. Het minimum is 4 en we voegen d en e toe. Tenslotte vinden we pden nr f vn lengte 7 en 8. Omdt 7 de kleinste wrde is moet dit dus wel de lengte vn het kortste pd vn nr f zijn. We weten nu wel voor elke knoop wt zijn minimle fstnd tot is, mr hoe vinden we nu het kortste pd? Door terug te rekenen: f ligt 7 vn f en is veronden met d en e. Vi d levert op 4 + 4, vi e levert op Dus het kortste pd vn nr f gt vi e. Vnuit e kunnen we hetzelfde doen. Enzovoorts Opgven Opgve 10.3 Discrete Wiskunde 85

86 Ps Dijkstr s lgoritme toe op de volgende grf om het kortste pd vn nr f te vinden. 2 4 d f 3 c e 3 2 Opgve 10.4 We heen Dijkstr s lgoritme toegepst op een ongerichte grf. Werkt het lgoritme ook correct op een gerichte grf, wrij de verindingen een richting heen en de fstnd vn x nr y ongelijk kn zijn n de fstnd terug vn y nr x? Opgve 10.5 In veel puzzels kun je een grf herkennen. Het oplossen vn de puzzel komt dn eigenlijk neer op het vinden vn het kortste pd tussen de eginstnd en een gevrgde eindstnd. Teken de (gerichte) grf ehorend ij het volgende wterknnenproleem en geef n hoe Dijkstr s lgoritme een oplossing kn vinden. Wterknnenproleem: Gegeven zijn een wterkn met een cpciteit vn 3 liter en een wterkn met een cpciteit vn 4 liter. Op de knnen stn geen mtstrepen. Verder is er krn wruit de knnen oneperkt kunnen worden gevuld en er is een put wrin de knnen kunnen worden geleegd. In het egin zijn de knnen leeg. Door ijvullen, leeggieten en overgieten moet er uiteindelijk 2 liter wter in de 3 liter kn overlijven Het lgoritme vn Floyd Dikwijls wordt gevrgd nr de kortste fstnden tussen lle knopen. Dit kn ntuurlijk met Dijkstr s lgoritme gedn worden, mr er zijn meer eenvoudige methoden. We zullen dit illustreren in Pscl, wrij we ls representtie vn de grf een fstndenmtrix geruiken. Voor de kortste fstnden geruiken we ook zo n mtrix (KA genmd). KA initiliseren we met de fstndsmtrix. Als de fstnd vn knoop i nr knoop j vi knoop k kleiner is dn de tot nu ekende fstnd vn knoop i nr knoop j, dn kunnen we die fstnd vereteren. In Pscl: if KA[i,k] + KA[k,j] < KA[i,j] then KA[i,j] := KA[i,k] + KA[k,j]; Dit wordt herhld tot de kortste fstnden niet meer vernderen. Discrete Wiskunde 86

87 procedure KortsteAfstnd(fstnd: Mtrix; VAR KA: Mtrix); vr i, j, k: integer; vernderd: oolen; egin KA := fstnd; repet vernderd := flse; for i:=1 to ntlknopen do for j:=1 to ntlknopen do for k:=1 to ntlknopen do if KA[i,k] + KA[k,j] < KA[i,j] then egin KA[i,j] := KA[i,k] + KA[k,j]; vernderd := true; end; until not vernderd; end; Dit werkt l ehoorlijk snel wnt het ntl keren dt de repet-lus wordt uitgevoerd is ongeveer gelijk n de 2-log vn het ntl knopen. Wnt in het egin is KA[i,j] de lengte vn een pd vn i nr j estnde uit hoogstens 1 verinding. N de eerste slg vn de repet-lus is KA[i,j] de kleinste lengte vn een pd vn i nr j estnde uit hoogstens 2 verindingen. N de tweede slg is KA[i,j] de kleinste lengte vn een pd vn i nr j estnde uit hoogstens 4 verindingen. N de derde slg gt het om pden estnde uit 8 verindingen. Met dit verduelen komen we l snel n de mximle lengte, die hoogstens gelijk is n ntlknopen-1. Mr het kn nog sneller door de volgorde vn de for-lussen te vernderen, we krijgen dn het lgoritme vn Floyd: procedure KortsteAfstnd(fstnd: Mtrix; VAR KA: Mtrix); vr i, j, k: integer; egin KA := fstnd; for k:=1 to ntlknopen do for i:=1 to ntlknopen do for j:=1 to ntlknopen do if KA[i,k] + KA[k,j] < KA[i,j] then KA[i,j] := KA[i,k] + KA[k,j]; end; Wrom is dit correct? KA[i,j] evt de kleinste lengte vn een pd vn i nr j lopend vi de knopen 1, 2 t/m k-1. De innenste twee for-lussen pssen KA zo n, dt ook gekeken wordt nr pden die vi knoop k lopen Opgven Opgve 10.6 Discrete Wiskunde 87

88 In een provincie moet een ziekenhuis geouwd worden. Het ziekenhuis moet in een vn de steden komen, zodnig dt er zo weinig mogelijk met de mulnce gereden hoeft te worden. Het ntl ernstige ziektegevllen is procentueel in lle steden gelijk. Welke std heeft de voorkeur uitgnde vn de volgende gegevens: std ntl inwoners c d e f std std fstnd c 15 d 20 c 5 d 5 e 10 c e 12 c f 12 d f 5 Hint: mk hier een (Amnd) progrmm voor. Opgve 10.7 Gegeven is de volgende niet-smenhngende grf. Geef n hoe we het lgoritme vn Floyd kunnen geruiken om te eplen welke knopen vnuit welke ndere knopen ereikr zijn. d f g i c e h Bedenk ook zelf een lgoritme om te eplen of knoop i vnuit knoop ereikr is. Discrete Wiskunde 88