Opgaven Binair Zoeken en Invarianten Datastructuren, 28 april 2017, Werkgroep.

Transcriptie

1 Opgaven Binair Zoeken en Invarianten Datastructuren, 28 april 2017, Werkgroep. Gebruik deze opgaven, naast die uit het boek, om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven. 1. Verwijder uit ongesorteerd array: Uit een ongesorteerde array A met n elementen wil je het element A[i] verwijderen. Hoe kun je dit zo snel mogelijk doen? (Hint: het kan in constante tijd.) Oplossing: Omdat de volgorde van de elementen mag veranderen, kun je A[i] overschrijven met het laatste element, en die positie wissen: A[i]=A[--n]; A[n]=0;. Dit werkt ook als i de laatste (gebruikte) positie was. Beoordeling/Toelichting: Je kunt alle elementen na i verschuiven, maar dan gebruik je lineaire tijd. 2. Binair Zoeken: Midpoint: Bert en Ernie praten over Binair Zoeken, met name de vraag of het nodig is om voor het te bekijken element m, exact midden tussen i en j te gaan zitten. Bert zegt dat het algoritme ook werkt als je een andere m tussen i en j kiest. Ernie vindt dat je altijd de codevoorbeelden van Gerard zo exact mogelijk moet overnemen (want daar heeft hij goede ervaringen mee). Kun je de theorie van Invariant en Variant gebruiken om Bert en Ernie verder te helpen? Oplossing: Volgens de theorie van de Invariant mag ik de Body van de loop best veranderen, als de nieuwe body maar de invaiant respecteert. Ook met een andere keuze van m (alleen zinvol in het bereik [i..j]) wordt de invariant gerespecteerd, en het veranderde programma is dus nog steeds partieel correct. Of het ook termineert, en hoe snel het is, ligt subtieler. Als m gekozen wordt strikt tussen i en j, zijn zowel m i als j m strikt kleiner dan j i, zodat afname van de Variant j i zeker is. Wanneer de range te groot wordt gekozen en ook de keuze m = i of m = j mogelijk is, kan de Variant blijven steken, oneindige lus! Voor zowel correctheid als terminatie blijkt de midpoint-formule dus vrij onbelangrijk! Het mooie van de keuze van de formule m = (i+j)/2 is, dat als j i 2 t, dan is zowel m i 2 t 1 als j m 2 t 1. Daardoor zorgt de halveringsformule voor een gegarandeerd logaritmische tijd. Maar andere keuzes kunnen ook snel zijn, zoek bv. maar eens Interpolation Search op Wikipedia. Beoordeling/Toelichting: R = Een Random keuze is niet hetzelfde als het invullen van willekeurig welke formule.

2 3. Midpoint: Bij Binair Zoeken kun je het Midpoint m kiezen als m = (i+j)/2. (a) Kan het ook met m = Math.Floor((i+j)/2) en wat is het voordeel of nadeel hiervan? (b) Kan het ook met m = i+1 en wat is het voordeel of nadeel hiervan? (c) Kan het ook met m = i + (j-i)/2 en wat is het voordeel of nadeel hiervan? (d) Kan het ook met m = (i+j)>>1 en wat is het voordeel of nadeel hiervan? Oplossing: (a) De Math.Floor verzorgt een geheeltallige afronding naar beneden maar de normale integer deling in Java of C# doet dat ook al. De extra toevoeging is dus volkomen overbodig. (b) De berekende waarde van m ligt strikt tussen i en j (het wordt namelijk alleen uitgerekend als j > i + 1). Dat is alles wat nodig is voor het invarianten-bewijs van deze zoekmethode, en daarmee levert het een correcte zoekmethode op. Probleem ervan is natuurlijk dat de Variant j i erg langzaam daalt wanneer het i is die door m wordt vervangen. Je zoekt in feite lineair door de array. Het kost dan ook lineaire tijd, O(n), om in n getallen te zoeken. (c) De uitkomst van deze formule is gelijk aan de korte formule (in alle gevallen van even/oneven i, j of verschil). De simpele formule berekent i + j, wat overflow kan geven als i en j dicht bij de maximale waarde van een int liggen. Ik denk niet dat veel studenten dit probleem in 2016 al hebben meegemaakt, want het treedt pas op bij arrays van 1G lang of meer, maar in 2017 zou het kunnen. (d) Een shift naar rechts is hetzelfde als een deling door 2 op de meeste computers/platforms. Of dat ook echt altijd zo gegarandeerd is weet ik niet. Soms beeldt je compiler een deling door 2 af op een rightshift. Beoordeling/Toelichting: 4. Sommatie: Je kunt n getallen in A zo optellen: s=0; i=0; while(i<n) { s += A[i]; i += 1; }; return s; Geef invariant en variant van deze lus. Oplossing: Invariant: s is de som van de eerste i getallen, s = i 1 k=0 A[k]. Variant: n i wordt in elke slag van de lus kleiner. Beoordeling/Toelichting: Je kunt je code ook beginnen met s=a[0]; i=1; met dezelfde Variant en Invariant. Maar dan moet je het geval n = 0 als uitzondering behandelen.

3 5. Kriebels op de Krim: In Simferopol is een straat met n huizen (aan één kant, 0 t/m n 1) waar op nr 0 een Rus woont en op nr n 1 een Oekraiener; ertussenin kunnen allerlei nationaliteiten wonen. Vind na het vragen van hoogstens lg n nationaliteiten twee buren (personen met opeenvolgende huisnummers) van verschillende nationaliteit. Geef een variant en invariant van je algoritme. Oplossing: Dat er Alien Neighbors zijn in een deel i..j van de straat volgt uit land(i) land(j). Dit is gegeven voor (i, j) = (0, n 1) en geeft direct het antwoord als j = i + 1. Je kunt dus dit algoritme maken met invariant land(i) land(j): i = 0; j= n-1 { m = (i+j)/2 if (land(m)!= land(i)) j=m else i=m } return i Het verschil j i halveert per stap, dit is je variant, dit doe je dus hoogstens lg(n 1) keer voordat het verschil 1 is. Per ronde vraag je maar 1 nationaliteit op, nl. land(m) omdat je land(i) al weet. Beoordeling/Toelichting: Max 3pt. Voor een goed geformuleerde invariant en variant 1pt; voor een kort en goed algoritme 1pt en als dit ook aansluit bij inv/var nog een punt. E = Een early Stopping variant (die steeds kijkt of m en m + 1 verschillen van nationaliteit en eventueel vanuit de loop direct termineert) kan, maar is meestal niet zinvol. Het geëiste aantal bekeken nationaliteiten wordt niet gehaald (zie T). L = Je zoekt Lineair, dus WorstCase Θ(n) personen bekijken. Max 1/2 pt voor het algoritme. M = Midpoint m = i + (j-i)/2 is nodeloos ingewikkeld; geen aftrek. G = Werkt alleen als iedereen van de Genoemde nationaliteiten is, min 1/2. T = Je vraagt Twee nationaliteiten per ronde, dus ongeveer 2 lg n, dit kost 1/2 punt. 6. Machtsverheffen: Om, gegeven x en (int) a, de waarde M = x a te berekenen gebruiken we een variabele R en de invariant inv: M = R x a. (a) Geef een bijpassende initialisatie en een loop-conditie die na afloop de conclusie M = R rechtvaardigt. (Je code kan de variabelen R, x en a wijzigen, maar de gewenste uitkomst M is onbekend en ligt al vantevoren vast.) (b) Geef een Body die inv respecteert en een variant reduceert. Het kan in lg a slagen! Oplossing: (a) Het algoritme wijzigt alleen R, x en a, de contante M blijft ongewijzigd (en is de gewenste uitvoerwaarde). Je introduceert inv met de toekenning R = 1 en de conclusie volgt als a == 0 dus de conditie is (a>0). (b) Kies als variant: a. Doel van de body is dan a te verlagen onder behoud van inv. De code { a--; R *= x; } kan altijd maar verlaagt a met maar 1. Als a even is gebruik je { a /= 2; x *= x; }. Doe in de body in ieder geval een keer het tweede. Dan halveert a iedere ronde en weet je zeker dat je een logaritmische tijd haalt. Beoordeling/Toelichting: Te halen 3pt, 1 voor (a) en 2 voor (b)

4 7. Invariant: Pizza: Een berg van k pizza s van omvang p 0 t/m p k 1 wordt verdeeld onder n programmeurs. Elk krijgt (i) een stuk uit één pizza (ii) van integer grootte, (iii) ieders stuk is even groot en (iv) ze hebben honger dus ze willen zo veel mogelijk eten. Voorbeeld: Als n = 3 en er zijn twee pizzas van omvang 7 en 9, is de uitkomst 4. Uit de eerste pizza kan 1 stuk van 4 en uit de 2e kunnen twee stukken van 4, maar als je stukken van 5 wilt snijden kan er uit beide pizza s maar 1. Geef een algoritme dat de maximaal mogelijke portie-omvang berekent met binair zoeken. Geef een variant en invariant van je algoritme. Is de rekentijd polynomiaal? Oplossing: Geef mog(i) de betekenis: omvang i is mogelijk. Je zoekt een i met mog(i) mog(i + 1). In ieder geval is 0 mogelijk en de maximale pizza plus 1 niet. Of m mogelijk is kun je testen door op te tellen hoeveel stukken je van grootte m kunt snijden uit alle pizza s. Je kunt dus dit algoritme maken met invariant mog(i) mog(j): i = 0; j = p.max + 1; { m = (i+j)/2; v = 0; for (w=1; w<k; w++) v+= p[w]/m; if (v < n) j=m else i=m } return i Het verschil j i halveert per stap, dit is je variant. Daaruit volgt een aantal ronden van lg(max(p)) en omdat het optellen van de stukken k tijd kost, is de totale tijd O(k lg(max(p))). Deze tijd is polynomiaal omdat lg(max(p)) overeenkomt met het aantal bits waarmee de getallen worden opgeschreven. Beoordeling/Toelichting: Voor algoritme 1pt en voor (in)variant en rekentijd 2pt (en voor beide samen dan 3pt). I = Initialisatie met j = p.max is fout omdat deze waarde soms kan. Zelfs j = p.sum is fout omdat die waarde kan als portie, nl. wanneer k = n = 1. L = Zoekt Lineair ipv binair, dit kost veel te veel tijd.

5 8. Het Gat: Gegeven is een gesorteerde array A van integers, waarbij A[n 1] A[0] n. Geef de invariant voor een algoritme dat een getal tussen A[0] en A[n 1] vindt, dat niet voorkomt in A. Geef ook het algoritme (het moet logaritmische tijd gebruiken). Oplossing: Dat er een getal niet voorkomt in segment [i..j] volgt uit A[j] A[i] > j i. Dit is gegeven voor i = 0 en j = n 1. Als A[i + 1] A[i] > 1, ontbreekt A[i] + 1. Je kunt dus dit algoritme maken met invariant A[j] A[i] > j i: i = 0; j= n-1 { m = (i+j)/2 if (A[m]-A[i] > m-i) j=m else i=m } return A[i]+1 Beoordeling/Toelichting: Voor een goed geformuleerde invariant 2pt; voor een kort en goed algoritme 1pt (en voor beide samen dan 3pt). Centraal punt in deze vraag is, dat je een logisch argument (waaruit volgt het bestaan van een gat) kunt operationaliseren naar een heldere invariant, en van daar uit code kunt genereren. A = Je invariant is wel OK, maar omzetten naar een Algoritme lukt niet. B = Zegt: variant van Binary search dus logaritmisch; pas hier mee op, want ik kan code schrijven die nog veel meer op BS lijkt maar toch niet logaritmisch is. Gelukkig werd het beredeneren van de tijdgrens niet gevraagd. C = Geen invariant, maar wel goede (inzichtelijke, correcte, compacte, logaritmische) Code; toch die 1pt. E = Je kunt niet binair zoeken met Eén variabele. G = Levert een index op ipv. een getal; fout, bv. als alle getallen groter dan n zijn. I = Je vergelijkt een Index en een waarde (als in if (A[m] > m)); gaat bv. fout wanneer alle waarden groter zijn dan n. Dan is het altijd true, maar je komt niet altijd goed uit. M = Midpointformule simpeler dan m = (i+j)/2 bestaat niet! Waarom toch m = i + (j-i)/2 zovaak voorkomt is me een raadsel. Het handigst is, deze midpointformule aan het begin van de body te zetten; onhandig is, een midpointformule te zetten op elke plek waar je i of j verandert. R = Je levert A[i+i] op ipv A[i]+1, die waarde komt juist wel voor! T = Waarde Teruggeven ontbreekt (of verkeerde waarde). V = Je moet stoppen bij Verschil 1, dus niet bij 0, als in while (j > i). Bij verschil 1 wordt je midpoint gekozen als de ondergrens, mogelijk verandert je ondergrens niet en kom je in een infinite loop. Z = Absoluut Zoeken, je vergelijkt A[m] met A[0]+m. Dit kan een correct algoritme opleveren (maar niet als je op gelijkheid test). Uiteraard is wel een andere invariant nodig, nl A[i] A[0] + i A[j] > A[0] + j.

6 9. Het Duplicaat: Gegeven is een gesorteerde array A van integers, waarbij A[n 1] A[0] < n 1. Geef een algoritme dat een getal tussen A[0] en A[n 1] vindt, dat meervoudig voorkomt in A. Geef ook de invariant van je algoritme. Oplossing: Dat er een getal dubbel voorkomt in segment [i..j] volgt uit A[j] A[i] < j i. Dit is gegeven voor i = 0 en j = n 1. Als A[i + 1] A[i] < 1, is A[i] = A[i + 1], dus dubbel. Je kunt dus dit algoritme maken met invariant A[j] A[i] < j i: i = 0; j= n-1 { m = (i+j)/2 if (A[m]-A[i] < m-i) j=m else i=m } return A[i] Beoordeling/Toelichting: Voor een goed geformuleerde invariant 1pt; voor een kort en goed algoritme 1pt (en voor beide samen dan 2pt). Centraal punt in deze vraag is, dat je een logisch argument (waaruit volgt het bestaan van een duplicaat) kunt operationaliseren naar een heldere invariant, en van daar uit code kunt genereren. A = Je invariant is wel OK, maar omzetten naar een Algoritme lukt niet. E = Je kunt niet binair zoeken met Eén variabele. I = Je vergelijkt tussen een Index en een waarde (als in if (A[m] > m)); dit is nooit goed, wat je kunt inzien door een voorbeeld waarin alle waarden groter zijn dan n. Dan is het altijd true, maar je komt niet altijd goed uit. L = Lineaire tijd; hoogstens 1pt totaal. M = Midpointformule simpeler dan m = (i+j)/2 bestaat niet! Waarom toch m = i + (j-i)/2 zovaak voorkomt is me een raadsel. Het handigst is, deze midpointformule aan het begin van de body te zetten; onhandig is, een midpointformule te zetten op elke plek waar je i of j verandert. S = Succestest rond m (if (A[m] == A[m+1])) is overbodig. T = Termineert niet omdat je doorgaat tot j-i == 0; Je moet stoppen bij 1. Bij verschil 1 wordt je midpoint gekozen als de ondergrens, mogelijk verandert je ondergrens niet en kom je in een infinite loop. 10. Interpolation Search: Volgens Wikipedia heeft Interpolation Search een verwachte complexiteit van O(lg lg n) stappen. Kun je dit bewijzen of experimenteel bevestigen? Oplossing: Beoordeling/Toelichting: Dit is een onderzoeksopdrachtje waarvoor geen kort zinvol antwoord bestaat. Wel heel leuk om te doen (correct te krijgen!!) en er een beetje mee te experimenteren. Boeiend om te zien hoe je programma met 5 of 6 vergelijkingen een waarde vindt in een catalogus van miljoenen getallen.

7 11. LinkaBurka: Van een rij kabouters is de meest linkse, nr 1, een meisje en de meeste rechtse, nr n, een jongen. De rest draagt burka s zodat het geslacht niet bekend is. Je moet de meest linkse positie (laagste) vinden waar verschillende seksen aangrenzend staan. (a) Kan dit in O(lg n) stappen? Leg uit! (b) Geef een zo snel mogelijk algoritme. (c) Wat is de asymptotische complexiteit van je algoritme? Oplossing: Het kan niet in O(lg n) stappen, het kan zelfs niet beter dan lineair, dwz. niet in o(n) stappen. Als namelijk kabouter n de enige jongen is, dan is natuurlijk posities n 1 en n het juiste antwoord. Maar hiervan kun je niet zeker zijn zonder alle andere kabouters te checken dat het meisjes zijn. In het slechtste geval (hier: aalemaal meisje op 1 na) is dus ieder algoritme gedwongen om alle kabouters te bekijken. (b) Lineair algoritme met invariant ( i < j : K[i] == M): j=2; while(k[j] == M) j++; Print posities j-1 en j; (c) Dit algoritme is lineair, dus O(n) of Θ(n) is hier het goede antwoord. Beoordeling/Toelichting: Te behalen 3pt: 1 voor een bewijs dat Θ(n) nodig is, 1 voor het algoritme, en 1 voor de complexiteit. Voor wie binair zoeken gebruikte, ook al was dit perfect gereproduceerd, helaas geen punten omdat dit hier niet werkt. A = Een Andere complexiteit: als je minder dan lineair hebt klopt je algoritme of je analyse niet (zie (a)). Als je meer dan lineair hebt is je algoritme niet snel genoeg. B = Er is niet gegeven dat meisjes en jongens in twee Blokken staan (ahw gesorteerd). De vraag heeft de duidelijke suggestie in zich dat er meerdere wisselingen tussen meisjes en jongens kunnen optreden. D = Doorgaan als je de eerste positie al gevonden hebt is zinloos, -1/2. E = Een Early Stopping algoritme is nodeloos gecompliceerd, zie ook hoorcollege en notes. H = een halveringsmethode om dan toch alles van links te bekijken is veel te omslachtig. K = Je kunt geen Kansen aan de invoer toekennen, want er is niets gegeven over een willekeurige samenstelling van de kaboutergroep. L = Antwoord Lineair is niet genoeg, je moet echt O(n) opschrijven. M = Antwoord O(n 1) of O(n/2) is niet genoeg vereenvoudigd. S = Als het gesorteerd is... ; wat is sortering in deze context? Zie ook B. V = Te Vage omschrijving van het algoritme.

8 12. Gelijke buren: Van een integer array A is gegeven dat A[0] even is en A[999] ook. (a) Bewijs dat er in A twee getallen naast elkaar staan met gelijke pariteit (dwz., er is een i waarvoor A[i] en A[i + 1] beide even, of beide oneven zijn). (b) Iwan zegt dat je, om opeenvolgende getallen van gelijke pariteit snel te vinden, de invariant even(i + A[i]) odd(j + A[j]) kunt gebruiken. Laat zien hoe je een programma kunt initialiseren voor die invariant, en hoe je uit j = i + 1 concludeert dat je een oplossing gevonden hebt. (c) Geef code die hoogstens 10 getallen van A bekijkt en twee opeenvolgende getallen van gelijke pariteit afdrukt. Oplossing: (a) Bewijs uit het ongerijmde. Stel dat er nergens twee gelijke pariteiten naast elkaar staan. Dan komt na elk even getal een oneven getal en omgekeerd. Omdat op de even positie A[0] een even getal staat, staat dan op elke even positie een even getal en op elke oneven positie een oneven getal. Dus is A[999] oneven, wat in tegenspraak is met het gegeven. (b) Als de pariteit van A[i] gelijk is aan die van i, zoals voor i = 0, dan is A[i] + i even, en als de pariteit ongelijk is, zoals voor j = 999, dan is A[j] + j oneven. De invariant: even(i + A[i]) odd(j + A[j]) kun je dus verkrijgen met initialisatie i=0; j=999;. Verder, als i + A[i] even is maar i A[i + 1] is oneven, dan hebben A[i] en A[i + 1] gelijke pariteit. (c) Het kan heel snel met binair zoeken: i = 0; j = 999; { m = (i+j)/2; if (even(m+a[m])) i=m; else j=m; } print A[i] en A[i+1]; Beoordeling/Toelichting: Tot 3pt, 1 per deelvraag. Omdat na initialisatie j i 2 10, is j i 2 0 na hoogstens 10 stappen, maar hierover hoefde je niets te zeggen voor punten. Codes: C = Conditie (A[m] % 2 == 0) geeft je steeds een even A[i] en (als je ooit een oneven getal tegenkomt) een oneven A[j]). Uiteindelijk lever je juist een even/oneven paar op. E = Early Stopper, kijkt naar twee getallen per ronde dus totaal max 20, 1pt. L = Lineair zoeken geeft geen punt. Als je het afbreekt na tien stappen (om aan de grens op aantal te bekijken waarden te voldoen) vindt je methode natuurlijk iet altijd een antwoord! N = Heeft Niets met de gegeven invariant van doen.

9 13. Geheeltallige Logaritme: Loes moet een methode public int flog(long x schrijven die voor positieve x de floor (naar beneden afgeronde waarde) van de 2-logaritme van x oplevert. De returnwaarde R voldoet aan 2 R x en 2 R+1 > x; voorbeeld flog(30) zou 4 teruggeven. (a) Geef een invariant van een loop waarmee Loes R kan uitrekenen. (b) Geef de initialisatie die jouw invariant waar maakt. (c) Geef een loop die R uitrekent en maximaal 6 vergelijkingen met x doet. Oplossing: (a) Houd exponenten i en j bij, waarvan je weet dat (Inv): 2 i x 2 j > x. (b) Omdat x positief is, geldt 2 0 x en omdat x een long is geldt 2 63 > x. Je kunt je invariant daarom initialiseren met int i = 0; int j = 63;. (c) Behalve de initialisatie heb je een body nodig die j i halveert: m = (i+j)/2; if ((1<<m) <= x) i=m; else j=m; gevolgd door een return statement retun i;. Het verschil j i is in het begin 63 en halveert in elke stap, zodat het na hoogstens zes stappen 1 is. Beoordeling/Toelichting: Per deelvraag een punt