Tentamen Bionformatica, 8C070, 9 maart 2009, u.

Transcriptie

1 Tentamen Bionformatica, 8C070, 9 maart 2009, u. Drie algemene opmerkingen Het tentamen bestaat uit 7 opgaven. Onderaan de laatste pagina staat voor iedere opgave het maximale aantal punten dat voor de opgave behaald kan worden! Enkel het formuleblad mag gebruikt worden, dus noch het boek noch de collegeaantekeningen noch een notebook zijn bij dit tentamen toegestaan. Voor iedere programmeeropgave geldt dat je eerst een specificatie van het probleem geeft, dan een analyse inclusief de introductie van mogelijke invariant(en) en vervolgens een Python-programmafragment construeert voor het probleem. Voeg commentaar aan je programma toe als toelichting. Succes!!! Opgave 1 (a) Wat wordt met het Human Genome Project bedoeld? (b) Wat is RNA? (c) Wat is het verschil tussen DNA en RNA? (d) Geef 2 verschillende vormen van RNA. Uitwerking opgave 1 (a) In het Human Genome Project wordt het menselijk genoom geidentificeerd, dwz de samenstellling van het totale DNA van een pool van 9 mensen is bepaald en er is aangegeven welke plaatsen in het DNA overeenkomen en welke verschillen. (b) RNA is een enkelstrengs keten van nucleotiden. Een nucleotide bestaat uit een een fosfaatgroep, een suiker met vijf C-atomen (pentose) en een purine of een pyrimidine. (c) DNA verschilt van RNA in DNA is dubbelstrengs, RNA doorgaans enkelstrengs de suiker is bij RNA ribose in plaats van desoxyribose bij DNA de base T(hymine) van DNA wordt is in RNA U(racil) (d) mrna, trna, rrna, microrna etc. Normering opgave 1 Normering: alle onderdelen 0.25 punt Opgave 2 1

2 (a) Laat l een lijst van DNA strings zijn. Ontwerp een Python methode met l als argument die een gesorteerde lijst outl retourneert van de lengtes van de DNA strings van l met een oneven aantal basen. (b) Ontwerp een Python methode met als argument de lijst outl van onderdeel (a) en die een lijst retourneert die gelijk is aan outl met alle items die vaker dan twee keer voorkomen verwijderd. Uitwerking opgave 2 (a) Specificatie: Pre: l, een lijst van DNA strings progr: onevenlengtes Post: outl: lijst van lengtes van DNA strings van l met oneven lengte Om te kunnen bepalen welke elementen van l een oneven lengte hebben, moeten we ze een voor een aflopen: we hebben dus een herhaling nodig. Voor het itereren maken we gebruik van de standaardconstructie voor het doorlopen van de items van een lijst: for s in l: De lengte van een element wordt gegeven door len en het oneven zijn is simpelweg testen of de rest bij deling door 2 1 is: def onevenlengtes(l): outl=[] for s in l: if len(s)%2 == 1: outl.append(len(s)) outl.sort() return outl (b) Specificatie: Pre: outl, een gesorteerde lijst van oneven positieve integer waarden. progr: maxtwice Post:m een kopie van outl met enkel de elementen die een of twee keer voorkomen. Ook hier is een inspectie van ieder van de elementen nodig en dus moeten we weer een herhaling gebruiken. Er zijn meerdere oplossingen mogelijk. De eenvoudigste lijkt te itereren over de items van outl en met behulp van count na te gaan hoe vaak het item voorkomt. Als het item 1 of 2 keer voorkomt, moet het aan m toegevoegd worden en anders hoeft er geen actie ondernomen te worden: def maxtwice(outl): m=[] for s in outl: if outl.count(s)<3: m.append(s) return m 2

3 Het nadeel van deze oplossing is dat er geen gebruik gemaakt wordt van het gesorteerd zijn van outl en dus de count een relatief dure operatie is. Eleganter is daarom bij een item zelf te bepalen hoe vaak het voorkomt en dan de acties te ondernemen die boven beschreven zijn: def maxtwice(outl): m=[] i=0 while i< len(outl): n=i+1 #n-i is het aantal keren dat outl[i] voorkomt while ((n<len(outl)) and (outl[n]==outl[i])): n=n+1 #n-i is het aantal keren dat outl[i] voorkomt if n-i<3: m.extend(outl[i:n]) i=n return m Normering opgave 2 Onderdeel (a): 0.5 punt: specificatie 0.1, analyse 0.2, programma 0.2 Onderdeel (b): 0.5 punt: specificatie 0.1, analyse 0.2, programma 0.2 Opgave 3 Ontwerp een programma dat een gelijkbenige driehoek met beenlengte k/2 en basisbreedte k afdrukt, waarbij k een oneven invoergetal van tenminste 3 is. Bijvoorbeeld ziet voor k = 5 als invoer de uitvoer er als volgt uit * * * ***** Uitwerking opgave 3 De crux van deze opgave is het bepalen van het patroon dat herhaald wordt. Eenvoudige inspectie leert dat de eerste en de laatste regel afwijkend zijn van de overige regels(s). Deze twee afwijkende regels behandelen we apart De eerste regel bestaat uit eerst k/2 spaties en dan een sterretje. Een Python methode die dit bij aanroep bewerkstelligt is: def eersteregel(k): print " "*(k/2)+"*" De laatste regel bestaat uit k sterretjes. Een Python methode die dit bij aanroep bewerkstelligt is: 3

4 def laatsteregel(k): print "*"*k De overige regels hebben allen het patroon eerst een aantal spaties dan een sterretje, weer een aantal spaties en dan tenslotte weer een sterretje. Zo n patroon is eenvoudig te vertalen in een Python methode: def tussenregel(beginspaties, tussenspaties): print " "*beginspaties+"*"+" "*tussenspaties+"*" Resteert het dus om de beginspaties en tussenspaties te bepalen. Regel 2 heeft een spatie minder dan de eerste regel, dus de eerste waarde van beginspaties is k/2-1. Iedere volgende regel heeft telkens een spatie minder en we moeten tussenregels blijven produceren tot beginspaties 0 geworden is. Tussenspaties is de eerste keer, in regel 2, 1, daarna neemt tussenspaties telkens met 2 toe, want de regel ervoor heeft het eerste sterretje een positie naar rechts en het laatste sterretje een positie naar links. Het gehele programma om een gelijkbenige driehoek af te drukken wordt dus: def eersteregel(k): print " "*(k/2)+"*" def laatsteregel(k): print "*"*k def tussenregel(beginspaties, tussenspaties): print " "*beginspaties+"*"+" "*tussenspaties+"*" eersteregel(k) beginspaties=k/2-1 tussenspaties=1 while beginspaties>0: tussenregel(beginspaties, tussenspaties) beginspaties=beginspaties-1 tussenspaties=tussenspaties+2 laatsteregel(k) Normering opgave 3 Goede analyse: 0.6 punt: eerste regel 0.1, laatste regel 0.1, beginspaties 0.1, tussenspaties 0.1, herhaling 0.2 4

5 goed programma 0.4 punt Opgave 4 (a) Ontwerp een class Gen met een constructor die naast self 2 parameters, abb en aas, kent en bij aanroep de waarden van abb en aas toekent aan de data attributen abbrev respectievelijk aantalas van het te creëren object. abb moet als default waarde een lege string hebben en aas de waarde 0. (b) Creëer 2 objecten g0 en g1 met waarden INS en 45 respectievelijk INSA en 46 voor de velden abbrev en aantalas. (c) Ontwerp een methode zelfdeaantalas met 2 parameters g0 en g1 (beide genen) die retourneert of de genen dezelfde aantalas waarde hebben. (d) Ontwerp een methode verschilas met 2 parameters g0 en g1 (beide genen) die het verschil van het aantal A s van de 2 genen retourneert. (e) Geef een Python statement waarin het verschil van het aantal A s van de genen g0 en g1 van onderdeel (b) aan de variabele l toegekend wordt. Uitwerking opgave 4 (a) We volstaan met het geven van de oplossing class Gen: def init (self, abb="", aas=0): self.abbrev=abb self.aantalas=aas (b) Er wordt naar 2 object instantiaties gevraagd: g0=gen( INS, 45) g1=gen( INSA, 46) (c) def zelfdeaantalas(g0, g1): return g0.aantalas==g1.aantalas (d) def verschilas(g0, g1): return g0.aantalas-g1.aantalas (e) g0=gen( INS, 45) g1=gen( INSA, 46) l=verschilas(g0, g1) Normering opgave 4 alle onderdelen 0.2 punt 5

6 Opgave 5 Gegeven is een in dalende volgorde gesorteerde rij mw van geheeltallige meetwaarden. Gevraagd wordt een binary search programma te ontwerpen dat bepaalt of het getal 17 als meetwaarde voorkomt en zo ja de index van het middelste voorkomen van 17 geeft. Uitwerking opgave 5 We beginnen met de specificatie: pre: mw, een in dalende volgorde gesorteerde rij van integers naam van methode: binsearch post: present = 17 komt voor in mw if present: pos is de index van het middelste voorkomen van 17 Om het middelste voorkomen te bepalen hebben we het eerste en het laatste voorkomen nodig. We beginnen met het laatste voorkomen. In onze afleiding en dus niet in ons programma breiden we de lijst uit met 2 elementen. Als we de lengte van de lijst aanduiden met size: 1. mw[-1]=+ 2. mw[size]=, We kunnen dus altijd een i vinden zodat mw[i]>=17>mw[i+1] en zal als 17 voorkomt dit ook het laatste voorkomen zijn (want als het volgend element bestaat zal het kleiner zijn). De postconditie voor het laatste voorkomen wordt dus present=(0<=i) and (i<size) and (mw[i]==17) Analyse Om de postconditie te bewerkstelligen moeten we herhaaldelijk een actie uitvoeren en dus maken we gebruik van de DBC -invariant constructie. In dit geval gebruiken we de term zoekgebied voor het deel waarin 17 mogelijk voorkomt (her B -deel van de constructie), en dus het andere deel (het D -deel) waarin 17 zeker niet voorkomt, terwijl het constante gedeelte (de C ) de gehele lijst is uitgebreid met de 2 speciale elementen, d.w.z., alle items mw[i] met -1<=i<=size. De strategie is het zoekgebeid telkens te halveren, totdat het zoekgebied uit één element bestaat en dus dan de eerder beschreven test uit te voeren. We gebruiken een linker- en een rechterwijzer die we met respectievelijk l (linker) and r (rechter) aanduiden: Invariant zoekgebied: mw[l]>=17>mw[r] Een invariant moet eenvoudig te finaliseren en te initialiseren zijn: Finalisatie Uiteindelijk moet ons zoekgebied uit een enkel element bestaan. moeten dus doorgaan met het zoekgebied verkleinen d.m.v. We 6

7 while (r!=l+1): Initialisatie Als we beginnen is het gebied dat al doorzocht is leeg en het te doen gedeelte de gehele lijst uitgebreid met de 2 speciale elementen. Het zoekgebied bestaat uit alle items van en met mw[l] tot en zonder mw[r] dus de initialisatie is: l=-1 r=size de lus Het programma dat we tot dusver verkregen hebben is: l=-1 r=size # mw[l]>=17>mw[r] while (r!=l+1): # (r!=l+1) and mw[l]>=17>mw[r]... # mw[l]>=17mw[r] # (r==l+1) and mw[l]>=17>mw[r] # mw[l]>=17>mw[l+1] present=(0<=l) and (l<size) and (mw[l]==17) Als we de lus binnengaan bestaat het zoekgebied nog uit tenminste 2 items en kunnen we het gebied dus nog halveren. Bij die halvering moeten we het zoekgebied kleiner maken en dus het het gebied waarin 17 zeker niet voorkomt vergroten. Als h de index van het middelste item van het zoekgebied is, dan kunnen we door mw[h] met 17 te vergelijken het gebied bepalen waarin 17 mogelijk voorkomt: als mw[h]>=17, dan moet als 17 voorkomt het minstens een keer in het rechtergebied zijn, d.w.z., in het gebied van h naar r, en we kunnen dan het zoekgebied van mw[l] naar mw[r] aanpassen door l te veranderen: l=h. in het andere geval dus mw[h]<17, dan wil 17 voorkomen, het in het linkergebied moeten zijn en nu moeten we dus de variabele r aanpassen: r=h. In beide gevallen geldt de invariant weer en we vinden dus als programma voor het laatste voorkomen: def binsearch(mw): # mw is an decreasingly ordered list of integers l=-1; r=size # mw[l]>=17>mw[r] while (r!=l+1): # (r!=l+1) and mw[l]>=17>mw[r] h=(r+l)/2 if mw[h]>=17: 7

8 # 17 is to be searched in the right halve l=h else: # 17 is to be searched in the left halve r=h # mw[l]>=17>mw[r] # (r==l+1) and mw[l]>=17>mw[r] # mw[l]>=17>mw[l+1] present=(0<=l) and (l<size) and (mw[l]==17) if present: laatste=l Als we het laatste voorkomen hebben, dan moeten we nog het eerste voorkomen bepalen. Ook daar moeten we de binary search methode voor gebruiken. Natuurlijk behoeft de bovenstaande invariant een aanpassing. Als postconditie voor het laatste voorkomen hebben we mw[i]>=17>mw[i+1]. Voor het eerste voorkomen is er slechts een subtiele aanpassing nodig: mw[i]>17>=mw[i+1] Omdat we al weten dat als 17 voorkomt mw[laatste] gelijk is aan 17, kunnen we laatste als initiele waarde voor r nemen, voor l moeten we weer -1 kiezen. Op deze wijze hebben we als invariant Invariant zoekgebied: mw[l]>17>=mw[r] en soortgelijk als boven vonden we als programma: # mw is an decreasingly ordered list of integers l=-1; r=laatste # mw[l]>17>=mw[r] while (r!=l+1): # (r!=l+1) and mw[l]>17>=mw[r] h=(r+l)/2 if mw[h]>17: # 17 is to be searched in the right halve l=h else: # 17 is to be searched in the left halve r=h # mw[l]>17>=mw[r] # (r==l+1) and mw[l]>17>=mw[r] # mw[l]>17>=mw[l+1] eerste=l+1 Als we het eerste en laatste voorkomen hebben, dan kunnen we eenvoudigweg het middelste voorkomen berekenen door: middelste=(eerste+laatste)/2 Normering opgave 5 8

9 Indien enkel 1 correcte binary search maximaal 1.5 punt. Specificatie 0.5 Goede analyse: 0.75 Goed programma: 0.75 Opgave 6 Het doel van deze opgave is een grafisch user interface met een blauwe achtergrond te ontwerpen dat van een DNA sequentie alle voorkomens van enkele A s en dubbele AA s in geel respectievelijk rood weergeeft, terwijl alle overige basen in wit weergegeven worden. Het ontwerp moet gerealiseerd worden in een aantal stappen: (a) Ontwerp een class voor een grafisch user interface met één frame. Het frame moet een blauwe achtergrond hebben en een label en een button bevatten. De achtergrondkleur van het label is blauw, de voorgrondkleur rood, terwijl de tekst van het label een parameter van de constructor van de class is en als default waarde AGAA heeft. De button moet als achtergrondkleur wit hebben en als voorgrondkleur rood en als tekst Kleur A en AA. (b) Ontwerp een methode van de class die als waarde een label retourneert en als invoerparameters een frame, een tekst en een voorgrondkleur heeft. (c) Als onderdeel (a) maar nu moeten 3 labels in het frame geplaatst worden, de eerste met de voorgrondkleur geel, de tweede met de voorgrondkleur rood en de derde met wit als voorgrondkleur. Maak in je oplossing gebruik van de methode die je bij (b) ontworpen hebt. (d) Ontwerp een methode die de beginposities van alle enkele A s in de tekst van het label bepaalt en deze als lijst retourneert. Hierbij geldt dat de eis dat op de positie voor de A óf niets staat óf een niet A en analoog voor op de positie na de A. (e) Idem maar nu voor de beginposities van alle dubbele A s in de tekst van het label bepaalt en deze als lijst retourneert. Hierbij geldt weer als eis dat voor de eerste A van de AA er óf niets staat óf een niet A en idem voor de de positie na de tweede A van de AA. (f) Ontwerp een class voor een grafisch user interface met een blauwe achtergrond dat van een DNA sequentie alle voorkomens van enkele A s en dubbele AA s in geel respectievelijk rood weergeeft, terwijl alle overige basen in wit weergegeven worden. Uitwerking opgave 6 (a) Specificatie van class constructor 9

10 pre: geen eisen program: coloraandaa post: GUI 1 frame - frame heeft een blauwe bg, 1 label en 1 button. - De tekst van de label is een parameter van de constructor, default AGAA, bg van label blauw, fg van label rood. - De tekst van de button is Kleur A en AA, bg van button wit, fg van button rood. Analyse: Omdat naar het ontwerp van grafisch user interface gevraagd wordt, beginnen we met de standaard import constructie from Tkinter import * Vervolgens geven we de benodigde constructies en hun assemblage. Voor het construeren van een frame f en het plaatsen gebruiken we f=frame(parent, bg= blue ) f.pack() Voor het construeren van een label gebruiken we de Label widget. l=label(f,fg= red, bg="blue", text=txtparam) l.pack() Voor het construeren van de button gebruiken we de Button widget. b=button(f,fg= red, bg="white", text= Kleur A en AA ) b.pack() Vervolgens definiëren we de instructies om een object my van de class en de event afhandeling te regelen: win=tk() my=coloraandaa(win) win.mainloop() Het samenvoegen van al deze constructies in een class definitie geeft: from Tkinter import * class coloraandaa: def init (self, parent, txtparam= AGAA ): self.parent=parent self.f=frame(self.parent, bg= blue ) self.l=label(self.f,fg= red, bg="blue", text=txtparam) self.l.pack() self.b=button(self.f,fg= red, bg="white", text= Kleur A en AA ) self.b.pack() 10

11 self.f.pack() win=tk() my=coloraandaa(win) win.mainloop() (b) We moeten een methode van de class ontwerpen dus de eerste parameter van de methode moet self zijn. De overige parameters zijn vergelijkbaar met die van onderdeel (a). def makelabel(self, frm, txtlb= AGAA, fgcolor= red ): label=label(frm, text=txtlb, fg=fgcolor, bg= blue ) label.pack(side=left) return label (c) Combinatie van de oplossingen voor (a) en (b) levert from Tkinter import * class coloraandaa: def init (self, parent, txtparam= AGAA ): self.parent=parent self.f=frame(self.parent, bg= blue ) self.f.pack() # Add the yellow label widget self.l0=self.makelabel(self.f, txtparam, yellow ) # Add the red label widget self.l1=self.makelabel(self.f, txtparam, red ) # Add the white label widget self.l2=self.makelabel(self.f, txtparam, white ) def makelabel(self, frm, txtlb= AGAA, fgcolor= red ): label=label(frm, text=txtlb, fg=fgcolor, bg= blue ) label.pack(side=left) return label win=tk() my=coloraandaa(win) win.mainloop() (d) We moeten een methode ontwerpen die de beginposities van alle enkele A s in de tekst van het label bepaalt en deze als lijst retourneert. We beginnen met de specificatie 11

12 pre: DNA string s program: allsingleas post: outla is een lijst met beginposities van enkele A s in s Analyse: Omdat s meerdere voorkomens van enkele A s kan hebben, is een repetitie nodig. We maken natuurlijk weer gebruik van onze DBC -invariant en daartoe introduceren we een variabele cur die ons de gewenste informatie over het Done gedeelte geeft: Done : alle beginposities van enkele A s tot aan cur zijn in outla vastgelegd tobedone : alle beginposities van enkele A s in het s[cur:] moeten nog gezocht worden Constant : het totaal van beginposities van enkele A s in s Twee aspecten die de geschiktheid van een invariant bepalen zijn de initialisatie en finalisatie initialisatie: als we beginnen hebben we nog geen beginposities, dus moet cur op 0 en outla met [] geinitialiseerd worden. finalisatie: als we weten dat in s[cur:] geen enkele A meer voorkomt, zijn we klaar. Een eenvoudige test die dat bewerkstelligt is: s.find( A, cur). Als deze de waarde -1 oplevert, zijn er geen beginposities van enkele A s meer in s[cur:], anders wordt precies de beginpositie van het eerstvolgende voorkomen van een A opgeleverd. De guard van de repetitie zou dus s.find( A, cur)!= -1 kunnen zijn, maar omdat we ook de positie willen weten als de guard True oplevert, veranderen we dit in: foundpos=s.find( A, cur) while (foundpos!=-1): De finalisatie levert ons echter precies de clou om de acties in de loop uit te kunnen voeren. Als er een nieuwe beginpositie gevonden is, moet deze aan outla toegevoegd worden als op de positie ervoor, mits deze bestaat, en de positie erna, mits deze bestaat, geen A staat en altijd moet cur aangepast worden. Als we een A gevonden hebben, en het is een enkele A, dan staat op positie erna dus een niet A en kunnen we als nieuwe positie vanaf waar gezocht moet gaan worden de gevonden positie verhoogd met 2 nemen. Als er op de positie na de gevonden positie ook een A staat, dan kunnen we ook zonder probleem de gevonden positie met 2 verhogen als nieuwe start voor de zoekposities kiezen, want die tweede A is ook geen enkele A. Het programma wordt dus: def allsingleas(s): cur=0; outla=[]; foundpos=s.find( A, cur) while (foundpos!=-1): if (foundpos>0): previousnonea=s[foundpos-1]!= A else: previousnonea=true if (foundpos<len(s)-1): successornonea=s[foundpos+1]!= A else: successornonea=true 12

13 if previousnonea and successornonea: outla.append(foundpos) cur=foundpos+2 foundpos=s.find( A, cur) return outla (e) Dit is vrijwel een kopie van het vorige onderdeel enkel zoeken we nu naar AA s en moeten we de opvolger van de dubbele A een positie verder inspecteren. Tevens kunnen we efficienter de startpositie van de nieuwe zoekactie bepalen: Als erna een AA en niet A staat, kunnen we als startpositie de gevonden positie verhoogd met 3 stellen. Als er wel een A staat (dus in totaal AAA), mogen we ook als startpositie de gevonden positie verhoogd met 3 nemen, want de eerstvolgende succesvolle AA kan pas op positie gevonden positie verhoogd met 4 beginnen. Het programma wordt dus: def alldoubleaas(s): cur=0; outlaa=[]; foundpos=s.find( AA, cur) while (foundpos!=-1): if (foundpos>0): previousnonea=s[foundpos-1]!= A else: previousnonea=true if (foundpos<len(s)-2): successornonea=s[foundpos+2]!= A else: successornonea=true if previousnonea and successornonea: outlaa.append(foundpos) cur=foundpos+3 foundpos=s.find( AA, cur) return outlaa (f) Omdat er meerdere voorkomens van geisoleerde A s en/of AA s in de DNA sequentie s kunnen zijn is een repetitie nodig. We maken natuurlijk weer gebruik van onze DBC -invariant en daartoe introduceren we een variabele cur die ons de gewenste informatie over het Done gedeelte geeft: Done : alle voorkomens van geisoleerde A en AA basen tot aan cur zijn in geel respectievelijk rood weergegeven en alle overige basen in wit. tobedone : alle overige voorkomens van geisoleerde A en AA s en overige basen in s[cur:] moeten bezocht worden Constant : de sequentie van basen in s Daarnaast gaan we natuurlijk gebruik maken van de methodes die bij onderdeel (d) en (e) ontworpen zijn en moeten dus op een slimme manier de waarde van cur zien aan te passen. Stel dat we in het nog te onderzoeken deel s[cur:] het eerst volgende voorkomen, nextaoraa, van een geisoleerde A of geisoleerde AA weten. We moeten dan 2 bewerkingen uitvoeren: Het deel van s van cur tot nextaoraa in wit weergeven: 13

14 makelabel(self.f, s[cur:nextaoraa], white ) en vervolgens Als de nextaoraa een enkele A is de A op positie nextaoraa in geel weergeven, en als de nextaoraa een dubbele A is de A s op positie nextaoraa en nextaoraa+1 in rood weergeven. We hebben dus naast de positie ook nog informatie nodig over welke van de twee, enkele A of dubbele AA, mogelijkheden zich voordoet. Deze informatie laten we beschikbaar zijn in een nieuwe variabele met als naam singlea. Als deze variable de waarde True heeft, dan is het een enkele A, en anders de dubbele AA situatie. Natuurlijk moeten we cur aanpassen op grond van de DBC -invariant. We krijgen dus if singlea: makelabel(self.f, s[nextnaoraa:nextaoraa+1], yellow ) cur=nextaoraa+1 else: makelabel(self.f, s[nextaoraa:nextaoraa+2], red ) cur=nextaoraa+2 Als we alle beginposities van gisoleerde enkele A s en dubbele AA s gehad hebben volstaat het de overige basen in wit weer te geven. Het laatste maar wel essentiële onderdeel dat we nog moeten verzorgen, is de methode next die naast de volgende positie van een geisoleerde enkele A of een dubbele AA, ook moet retourneren welke van de 2 aan de orde is. Hierbij moeten we oppassen op het nog aanwezig zijn ven elementen in de outla en outlaa lijsten. Als beide lijsten afgelopen zijn, dan moeten we None retourneren: # na is the next position in the outla list to be considered # naa is the next position in the outla list to be considered # to be returned is the smallest of the two, or None, and its matching # kind single A or double AA def next(self, na, naa, outla, outlaa, maxpos): if na<len(outla): nextposa=outla[na] else: nextposa=maxpos if naa<len(outlaa): nextposaa=outlaa[naa] else: nextposaa=maxpos if nextposa<nextposaa: return nextposa, True else: if nextposaa<nextposa: return nextposaa, False else: return None, None Voorzien van deze ingredienten wordt de methode dus: cur=0; na=0; naa=0 nextaoraa, singlea=self.next(na, naa, outla, outlaa, len(s)) while nextaoraa!= None : 14

15 lw=self.makelabel(self.f, s[cur:nextaoraa], white ) if singlea: lw=self.makelabel(self.f, s[nextaoraa:nextaoraa+1], yellow ) cur=nextaoraa+1 na=na+1 else: lw=self.makelabel(self.f, s[nextaoraa:nextaoraa+2], red ) cur=nextaoraa+2 naa=naa+1 nextaoraa, singlea=self.next(na, naa, outla, outlaa, len(s)) lw=self.makelabel(self.f, s[cur:], white ) Voegen we alles samen in één class definitie, dan krijgen we: from Tkinter import * class coloraandaa: def init (self, parent, txtparam= nextaoraa ): self.parent=parent self.f=frame(self.parent, bg= blue ) self.f.pack() self.colourayaar_otherswhite(txtparam) def makelabel(self, frm, txtlb= nextaoraa, fgcolor= red ): label=label(frm, text=txtlb, fg=fgcolor, bg= blue ) label.pack(side=left) return label def next(self, na, naa, outla, outlaa, maxpos): if na<len(outla): nextposa=outla[na] else: nextposa=maxpos if naa<len(outlaa): nextposaa=outlaa[naa] else: nextposaa=maxpos if nextposa<nextposaa: return nextposa, True else: if nextposaa<nextposa: return nextposaa, False else: return None, None def allsingleas(self, s): cur=0; outla=[]; foundpos=s.find( A, cur) while (foundpos!=-1): if (foundpos>0): previousnonea=s[foundpos-1]!= A else: previousnonea=true 15

16 if (foundpos<len(s)-1): successornonea=s[foundpos+1]!= A else: successornonea=true if previousnonea and successornonea: outla.append(foundpos) cur=foundpos+2 foundpos=s.find( A, cur) return outla def alldoubleaas(self, s): cur=0; outlaa=[]; foundpos=s.find( AA, cur) while (foundpos!=-1): if (foundpos>0): previousnonea=s[foundpos-1]!= A else: previousnonea=true if (foundpos<len(s)-2): successornonea=s[foundpos+2]!= A else: successornonea=true if previousnonea and successornonea: outlaa.append(foundpos) cur=foundpos+3 foundpos=s.find( AA, cur) return outlaa def colourayaar_otherswhite(self, s): outla=self.allsingleas(s) outlaa=self.alldoubleaas(s) cur=0; na=0; naa=0 nextaoraa, singlea=self.next(na, naa, outla, outlaa, len(s)) while nextaoraa!= None : lw=self.makelabel(self.f, s[cur:nextaoraa], white ) if singlea: lw=self.makelabel(self.f, s[nextaoraa:nextaoraa+1], yellow ) cur=nextaoraa+1 na=na+1 else: lw=self.makelabel(self.f, s[nextaoraa:nextaoraa+2], red ) cur=nextaoraa+2 naa=naa+1 nextaoraa, singlea=self.next(na, naa, outla, outlaa, len(s)) lw=self.makelabel(self.f, s[cur:], white ) win=tk() win.title("gui voor DNA sequentie colored AorAA, overige wit") win.configure(bg= blue ) 16

17 my=coloraandaa(win, txtparam="acaaacgaaaaccccatcgtcccaagggaaagaa") win.mainloop() Normering opgave 6 Onderdeel (d) en (e): 0.4, overige onderdelen ieder 0.3 Opgave 7 In deze opgave wordt het ontwerp van een Python class IntegerImage gevraagd. (a) Ontwerp een methode met een geheeltallige parameter n die een lijst van n items retourneert die allen de waarde 0 hebben. (b) Ontwerp een constructor voor de class die naast self twee geheeltallige parameters m en n heeft. In de constructor moet een lijst worden gedefiniëerd bestaande uit m items. Elk item in die lijst is zelf een lijst van n integers is, die allen de waarde 0 hebben. (c) Ontwerp een methode largestrow voor de class die van de lijst van een object van de class de index van een item retourneert waarin de som van de integers die in de lijst van het item aanwezig zijn, het hoogst is. (d) Ontwerp een methode sumofrows die als waarde retourneert de som van alle items in de lijst. Uitwerking opgave 7 (a) def alistofzeros(n): l=[] for i in range(n): l.append(0) return l (b) class IntegerImage: def init (self, m, n) l=[] for i in range(m): im=self.alistofzeros(n) l.append(im) self.l=l def alistofzeros(self, n): l=[] for i in range(n): l.append(0) return l 17

18 (c) def calcsum(self, l): s=0 for i in l: s=s+i return s def largestrow(self): l=self.l if not l: return None else: largest=0 som=self.calcsum(l[0]) for i in range(1, len(l)): s=self.calcsum(l[i]) if s>som: som=s largest=i return largest (d) def sumofrows(self): l=self.l s=0 for i in l: s=calcsum(i)+s return s Normering opgave 7 Ieder onderdeel 0.5 punt Honorering: opgave 1 maximaal 1 punt opgave 2 maximaal 1 punt opgave 3 maximaal 1 punt opgave 4 maximaal 1 punt opgave 5 maximaal 2 punten opgave 6 maximaal 2 punten opgave 7 maximaal 2 punten 18

19 List of Python built-in methods 1 Operations on string s s.count(sub) Return the number of non-overlapping occurrences of substring sub in string s. s.upper() Return a copy of the string converted s to uppercase. s.rstrip() Return a copy of the string s with trailing whitespace characters (the characters space, tab, linefeed, return, formfeed, and vertical tab) removed. s.find(sub) Return the lowest index in the string s where substring sub is found. Return -1 if sub is not found. s.replace(old, new) returns a copy of string s with all occurrences of substring old replaced by new. s.split(sep) return a list of the words in the string, using sep as the delimiter string. 2 Operations on files f=open(fname, option) returns a new object f of type file with filename fnam for reading when option is omitted or option= r, for writing when option= w. f.close() close the file. f.readline() readline returns the next line from the file. character (\n) The line includes the end of line f.read() returns the contents of the file in a string. f.readlines() returns a list of all lines from the file, where each line includes the newline character. 1

20 f.write(s) write the string s to the file f. 3 Operations on list objects Given a list l the following methods can be applied to l l.append(x) Add an item to the end of the list. l.extend(l) Extend the list l by appending all the items in the given list L. l.insert(i, x) Insert item x at given position i. l.remove(x) Remove the first item from the list whose value is x. It is an error if there is no such item. l.pop([i]) Remove the item at the given position in the list, and return it. If no index is specified, l.pop() returns the last item in the list. The item is also removed from the list. l.index(x) Return the index in the list of the first item whose value is x. It is an error if there is no such item. l.count(x) Return the number of times x appears in the list. l.sort() Sort the items of the list, in place. l.reverse() Reverse the elements of the list, in place. list(s) Return a list whose items are the same and in the same order as in the string s sep.join(l) Return a string which is the concatenation of the strings in the list l. The separator between elements is the string sep providing this method. 2