1. Recursieve Algoritmen

1. Recursieve Algoritmen Doel : Verdiepen van je inzicht in recursieve procedures ; bestudeer ook hoofdstuk 15 van de WWW-B1- reader op www.cs.kun.nl/~gerp/b1 (en/of Savitch Hfst 14) Aan het einde van de B1 cursus heb je al kennis gemaakt met recursie. Er is sprake van recursie wanneer procedures zichzelf aanroepen. Recursie kan zowel direct als indirect plaatsvinden. Bij directe recursie roept de procedure zichzelf aan binnen de eigen procedure body. Tot deze vorm beperken wij ons op dit moment. 1.1 Herhalingstestjes Om je begrip van recursie te testen volgen hieronder enkele testvragen. Herinner je dat bij een recursief werkend programma(deel) je steeds via een stop -conditie moet testen of er met een volgende recursiestap verder gegaan moet worden, of dat het recursie-proces gestopt kan worden. Bestudeer het onderstaande programmaatje: Program Recursietest; Procedure RecursieDiepte ( getal : INTEGER ); write ( getal, ) ; IF getal > 0 THEN RecursieDiepte ( getal - 1 ) ; write ( getal, ) ; { RecursieDiepte } VAR startwaarde : INTEGER ; {program} startwaarde := 4 ; RecursieDiepte ( startwaarde ) ; writeln ; writeln ( Startwaarde heeft nu de waarde :, startwaarde ) {program} Vragen: 1) Ga na waarom het volgende resultaat op het scherm verschijnt: 4 3 2 1 0 0 1 2 3 4 Startwaarde heeft nu de waarde : 4 2) Wat is in dit voorbeeld de (recursie-) terminatie-voorwaarde? Bij de volgende vraag heb je ook je kennis over het effect van het doorgeven van globale waarden via een valueof een VAR- (variabele) parameter nodig: Program Recursie_met_variabele_parameters; Procedure RecursieMetVarParameter ( VAR getal : INTEGER ) ; write ( getal, ) ; getal := getal - 1 ; IF getal > 0 THEN RecursieMetVarParameter ( getal ); write ( getal, ) ; { RecursieMetVarParameter } VAR getalswaarde : INTEGER ; { globale variabele declaratie } { program } getalswaarde := 4 ; RecursieMetVarParameter ( getalswaarde ) ; Writeln ( Na afloop geldt: getalswaarde =, getalswaarde ) { program } Vraag: - Wat drukt het programma nu af op het scherm? - Speciaal: wat is de waarde van getalswaarde na terugkeer uit de procedure aanroep? 1

1.2 Andere voorbeelden met recursie Hier volgt een recursieve uitwerking voor het als binair getal neerschrijven van een opgegeven decimale waarde. Aanroep van deze procedure met b.v. de decimale waarde 9 levert output ' 1001' op. program Recursief_Binair_Schrijven ; PROCEDURE Schrijf_Binair ( decimaalgetal : WORD ) ; IF decimaalgetal <= 1 THEN write ( decimaalgetal : 1 ) Schrijf_Binair ( decimaalgetal DIV 2 ) ; write ( decimaalgetal MOD 2 ) ; VAR decimale_waarde : INTEGER ; { declaratie van de globale variabele } write ( 'Tik positief geheel getal in: ') ; readln ( decimale_waarde ); {eventuele herhaling voor afdwingen positief getal} Schrijf_Binair ( decimale_waarde ) ; Voor de puzzelaars volgt hier nog een wat uitgebreider vraagstuk. Het is een aan Kernighan ontleende procedure itoc (Integer TO Character): program itoc_gebruik; PROCEDURE itoc ( getal : INTEGER ; VAR cijferstring : STRING ) ; { deze itoc converteert het getal getal naar een karakterstring in cijferstring } IF getal < 0 THEN cijferstring := - ; itoc ( -getal, cijferstring ) IF getal>=10 THEN itoc (getal DIV 10, cijferstring ) ; cijferstring := cijferstring + Chr( getal MOD 10 + Ord ( 0 ) ) ; { itoc_gebruik } VAR getalswaarde : INTEGER ; getalstekst : STRING; { program } write ( Tik getal in: ) ; readln( getalswaarde ) ; getalstekst := ; itoc ( getalswaarde, getalstekst ) ; write ( Na conversie naar tekst :, getalstekst, met lengte :, Length ( getalstekst )) Opdracht: ga na wat van dit programma de (totale!) uitvoer naar het beeldscherm is indien je het getal 123 als getalswaarde via het toetsenbord invoert. Opmerking tussendoor: De leesbare Ascii tekens lopen van 32 (de spatie) t/m 126 (de ~). De Ascii-codes 48 t/m 57 stellen de lettertekens 0 t/m 9 voor. De Ascii-codes 65 t/m 90 stellen de lettertekens A t/m Z voor. De Ascii-codes 97 t/m 122 stellen de lettertekens a t/m z voor. De resterende codes zijn allerlei leestekens en haakjes. 2

1.2.1.1 Opgave ( ter overpeinzing ): Een programmeur heeft (zie hierna) een recursieve routine geschreven om INTEGER-getallen als STRINGS te kunnen afdrukken (zie hierna). Helaas heeft hij een fout gemaakt. De routine werkt wel, maar doet niet precies wat er van verwacht wordt. Vraag: a. Beredeneer de uitvoer naar het scherm van de opdracht print_getal ( getal ). b. Herstel de fout die de programmeur gemaakt heeft. CONST cijferreeks : STRING = 0123456789 ; PROCEDURE print_cijfer ( cijf : INTEGER ) ; IF ( cijf < 0 ) OR ( cijf > 9 ) THEN write (? ) write ( cijferreeks [ cijf + 1 ] ) ; { print_cijfer } PROCEDURE print_getal (getal : INTEGER) ; IF getal < 0 THEN write ( - ) ; print_getal ( - getal ) IF getal < 10 THEN print_cijfer ( getal ) print_cijfer ( getal MOD 10 ) ; print_getal ( getal DIV 10 ) ; { print_getal } { program } print_getal (-1732) Een ander voorbeeld (dat al bij B1 ter sprake kwam) is: program recursie_voorbeeld; FUNCTION Head ( Woord : STRING ) : CHAR ; Head := Woord[1] ; FUNCTION Tail ( Zin : STRING ) : STRING ; Tail := copy ( Zin, 2, Length ( Zin ) - 1) ; {= alles behalve eerste teken} FUNCTION Vervang_Teken_In_Regel_Door ( Oudteken, Nieuwteken : CHAR; Regel: STRING ): STRING ; IF Regel = '' { d.w.z. de regel is leeg } THEN Vervang_Teken_In_Regel_Door := '' { resultaat: een lege string } IF Head ( Regel ) = Oudteken THEN Vervang_Teken_In_Regel_Door := NieuwTeken + Vervang_Teken_In_Regel_Door( Oudteken, Nieuwteken, Tail(Regel)) Vervang_Teken_In_Regel_Door := HEAD ( Regel ) + Vervang_Teken_In_Regel_Door( Oudteken, Nieuwteken, Tail(Regel)) ; writeln ( Vervang_Teken_In_Regel_Door ( 'l', 'k', 'lepelbak' ) ) Opdracht: ga na wat van dit programma de uitvoer naar het beeldscherm is. 3

1.3 Enkele moeilijkere constructies bij recursie We bespreken hier voorbeelden van enkele constructies, die we bij recursie kunnen tegenkomen: een recursieve functie/procedure die zichzelf meerdere malen aanroept het aanroepen van een recursieve procedure via een tussen-aanroep het gebruik van de FORWARD -declaratie 1.3.1 Een klassiek voorbeeld: de torens van Hanoi Het klassieke probleem van de torens van Hanoi kwam bij de behandeling van recursie in de B1-cursus reeds ter sprake. We geven hier nogmaals de probleem-definitie en de oplossing. Merk op dat in die uitwerking de recursieve procedure Transporteer_Toren zichzelf twéémaal aanroept. 1.3.1.1 Probleemdefinitie: Voor een tempel in Hanoi staan drie zuilen; de eerste is gemaakt van koper, de tweede van zilver en de derde van goud. Om de koperen zuil bevinden zich honderd schijven. Van onder naar boven nemen de schijven steeds in doorsnede af. Een oude wijze monnik stelde zich de volgende taak: Verplaats de schijven van de koperen zuil naar de gouden zuil, schijf voor schijf door telkens de bovenste schijf van een zuil weg te nemen en op een andere zuil te plaatsen. Zorg ervoor dat nooit een grotere schijf op een kleinere terecht komt. Volgens de legende zou, als de monnik met zijn werk klaar was, het einde van de wereld daar zijn. 1.3.1.2 Probleemoplossing: Het probleem kan in drie stappen worden opgelost. 1) Transporteer de toren bestaande uit de bovenste 99 schijven van de koperen naar de zilveren zuil. 2) Verplaats de laatste, grootste, schijf van de koperen naar de gouden zuil. 3) Transporteer tot slot de toren van 99 schijven van de zilveren naar de gouden zuil. In dit recursievoorbeeld wordt het (recursief) aanroepen van een procedure vergeleken met het geven van een opdracht door een persoon (de oudere monnik) aan een ander (de minder oude leerling-monnik). PROGRAM Torens_van_Hanoi; TYPE Zuilen = ( Koperen, Gouden, Zilveren ); { enumerated TYPE } CONST NaamZuil: ARRAY[Zuilen] OF String[8] = ( koperen, gouden, zilveren ); PROCEDURE Verplaats_schijf (Schijfnummer:Integer; Bron, Doel : Zuilen); Writeln ( Verplaats schijf,schijfnummer:2, van de, NaamZuil [Bron], naar de, NaamZuil [ Doel ], zuil ) { Verplaats_schijf } ; PROCEDURE Transporteer_toren (Schijfnummer:Integer; Bron, Doel, Via : Zuilen); {verplaats schijf met Schijfnummer van de Bron(zuil) naar de Doel(zuil) met als tussenstation de Via(zuil)} IF Schijfnummer > 1 THEN Transporteer_toren ( Schijfnummer - 1, Bron, Via, Doel ); Verplaats_schijf ( Schijfnummer, Bron, Doel ); IF Schijfnummer > 1 THEN Transporteer_toren ( Schijfnummer - 1, Via, Doel, Bron ) {Transporteer_toren} ; Writeln ( De torens van Hanoi : ); Transporteer_toren ( 4, Koperen, Gouden, Zilveren ) Opdracht: ga voor jezelf na, wat de uitvoer van dit programma is. 4

1.3.2 Aanroepen van een recursieve procedure via een tussenaanroep Het is mogelijk om een recursieve procedure niet direct maar via een tussenstap aan te roepen. Zoiets kan bijvoorbeeld gebruikt worden om de leesbaarheid van een programmatekst te verbeteren; bijvoorbeeld als je wat extra parameters bij de recursieve aanroep wilt meegeven, terwijl je in eerste instantie niet zou verwachten dat dergelijke extra parameters nodig zijn. Een voorbeeld om dit te verduidelijken, gaat over een numeriek probleem: het (in dit hoofdstuk uiteraard: recursief) benaderend bepalen van de derde machtswortel van een reëel getal. Daarbij roept (zie hieronder) de eerst (vanuit het hoofdprogramma) aangeroepen procedure Derde_Machts_Wortel_van de echte benaderende procedure Wortel_3_Benadering op met een eerste benaderende waarde van 1.0. In die procedure Wortel_3_Benadering wordt steeds bepaald of het (absolute) verschil tussen het oorspronkelijke getal en de derde macht van die benaderde waarde voldoende klein is. Als die benadering nog niet voldoende nauwkeurig is, dan wordt een volgende (betere) benaderde waarde bepaald en het proces wordt recursief voortgezet. Bij dat steeds tussentijds bepalen van de derde macht van die benaderde waarde, maken we gebruik van een eveneens recursief geformuleerde functie Tot_de_Macht_N. program recursieve_benadering_derde_machts_wortel ; FUNCTION Tot_de_Macht_N ( getal : REAL ; macht : INTEGER ): REAL; {recursief} IF macht < 0 THEN Tot_de_Macht_N := 1 / Tot_de_Macht_N ( getal, - macht ) IF macht = 0 THEN Tot_de_Macht_N := 1.0 Tot_de_Macht_N := getal * Tot_de_Macht_N ( getal, macht - 1 ) ; FUNCTION Wortel_3_Benadering ( benadering, waarde, precisie : REAL ): REAL ; IF ( Abs (waarde - Tot_de_Macht_N ( benadering, 3 )) < Abs ( precisie )) THEN Wortel_3_Benadering := benadering Wortel_3_Benadering := Wortel_3_Benadering ( ( benadering + waarde /(benadering*benadering)) / 2, waarde, precisie ) ; FUNCTION Derde_Machts_Wortel_van ( waarde : REAL ) : REAL ; CONST precisie = 0.000001 ; Derde_Machts_Wortel_van := Wortel_3_Benadering ( 1.0, waarde, precisie ) ; VAR waarde, uitkomst : REAL ; { globale variabelen } { program } write ( 'Geef getal: ') ; readln ( waarde ) ; uitkomst := Derde_Machts_Wortel_van ( waarde ) ; writeln( 'De derde macht''s wortel van ', waarde:10:4,' is: ',uitkomst:10:5) We zien in dit voorbeeld, dat eerst op een natuurlijke manier een tussenfunctie aan geroepen wordt (immers: we verwachten, dat we inderdaad kunnen zeggen: geef me de derdemachtswortel van een getal. Die tussen - functie zorgt ervoor, dat de èchte recursieve functie Wortel_3_Benadering_van met 2 extra parameters wordt aangeroepen: een parameter, waarmee een initiële benaderde waarde (1.0) wordt meegegeven en een andere extra parameter, waarmee een precisie-wens wordt vastgelegd. Bij de functie Tot_de_Macht_N zien we trouwens, dat een van de parameterwaarden (namelijk die voor macht ) gebruikt wordt om de recursiediepte te bepalen. 5

1.3.3 Het gebruik van de FORWARD -declaratie Bij het gebruik van recursie kan het voorkomen, dat twee (of meer) recursieve procedures elkaar wederzijds aanroepen; bijvoorbeeld dat de procedures Doe_iets een procedure Doe_anders aanroept en dat daarna Doe_anders op haar beurt Doe_iets aanroept. We komen dan te staan voor het probleem, dat de compiler normaal gesproken vereist, dat Doe_iets al vóór Doe_anders gedeclareerd moet zijn, maar ook dat Doe_anders al vóór Doe_iets gedeclareerd is. Omdat dit een onmogelijk dilemma zou opleveren, is in Pascal het gebruik van een FORWARD -declaratie mogelijk: je kunt daarbij de normale kop (inclusief parameterlijst) van een procedure, laten volgen door het gereserveerde woord FORWARD, om aan te geven dat de verdere uitwerking van die procedure een stuk verderop zal komen. De compiler staat het ná zo n FORWARD -declaratie al toe, om de betreffende procedure al aan te roepen, nog vóórdat hij echt ingevuld is. 1.4 Practicumopdracht 1: over Recursieve algoritmen 1.4.1 Hoofdlettergebruik in een zin Maak een recursief programma waarmee een (niet al te lange!; b.v. <= 20 tekens) ingetikte zin/regel, waarin slordig met hoofdletters is omgesprongen, omgezet wordt in een regel, die met een hoofdletter begint en waarbij in de rest van de regel alle hoofdletters door overeenkomstige kleine letters zijn vervangen. Voorbeeld: waar gaat DiT naar Toe? moet worden: Waar gaat dit naar toe? Hint: zoek op wat de TP-procedures Ord(..) en Chr(..) doen en gebruik ze in je programma. 1.4.2 Het Byte -gewijs recursief schrijven van een getal Maak een (eveneens recursieve) variant op het als voorbeeld gegeven programma waarmee een decimaal gegeven getal niet slechts als een binair getal (met nullen en énen) wordt afgedrukt, maar waarbij die uitvoer bovendien byte -gewijs wordt getoond. Daarmee wordt bedoeld, dat de uitvoer steeds uit één of meer groepjes van 8 bits moet bestaan. Zo moet het programma voor het getal 9 als output ' 00001001' opleveren (dus: mèt leading zeros) en voor het getal 34567: ' 10000111-00000111'. 1.4.3 Recursief de sinus -waarde van een hoek bepalen Het is misschien al lang geleden dat je voor het laatst iets hebt moeten doen met de sin (α) = a/c zogenaamde sinus van een hoek. In de meetkunde geldt voor een rechthoekige c driehoek, dat de sinus van een van de (niet -rechte) hoeken het quotiënt is van de a lengte van de tegenoverliggende rechthoekszijde en van de schuine zijde. Een paar (benaderde) waarden zijn: sin(0 o ) = 0 ; sin(30 o ) = 0,500 ; sin(45 o ) = 0,707 ; α sin(90 o ) = 1,000 en (meer abstract): sin(180 o ) = 0 en sin( -30 o ) = - 0,500. b Via de analyse, een aparte tak van sport in de wiskunde, is het mogelijk om voor de sinuswaarde van een hoek x de volgende b enaderende reeks -formule af te leiden: x **3 x **5 ( x **(2 * n + 1)) sin( x ) = x +... + ( 1) ** n * 3! 5! (2* n + 1)! waarbij de dubbele sterretjes staan voor machtsverheffen (dus bijvoorbeeld: x**3 betekent x -tot-de-derdemacht) en het uitroepteken staat voor faculteit (waarvoor bijvoorbeeld geldt: 5! = 5*4*3*2*1 = 120). N.B. Platvloers, zonder gebruik te maken van de horizontale deelstrepen, kun je schrijven: sin (x) = x - x**3/3! + x**5/5! -... + (-1)**n * (x**(2*n+1)/(2*n+1)! Je kunt de reeks zien als een kop -term, gevolgd door een staart -term, die ook weer een benaderende reeks is. In het Borland Pascal-systeem is een ingebouwde functie sin aanwezig, maar wij willen nu zelf een functie Sinus ontwerpen en implementeren, die [via aanroep van een recursieve vervolgfunctie] steeds verder e bijdragen (lees: breukwaarden) laat bepalen waarmee de sinus benaderd wordt. Zowel voor de aanroep van die ingebouwde sin- als onze eigen sinus-functie moeten we eerst de hoek-waardein-graden omrekenen naar radialen (cirkeldelen, waarbij een halve cirkel π radialen zijn). De waarde π is binnen Borland Pascal onder de constante-naam pi. De omrekening van graden naar radialen kan als volgt: Hoek_in_radialen = Hoek_in_graden * (π / 180 ) Zo geldt: 0 o = 0 radialen ; 30 o = π/6 radialen ; 90 o = π/2 radialen. Implementeer je functie eerst door hem een vast aantal termen van de reeks te laten meenemen in de berekening en verfijn je implementatie later door de recursie te stoppen als de termen te klein worden. 6