Datavetenskap
Tentamen för DAV A02 Programutvecklingsmetodik, 5p
tisdag 2001-03-20 Kl 08.15-13.15
Ansvarig lärare:
Martin Blom
Tillåtna hjälpmedel: Carrano, F.M., Data Abstraction and Problem Solving with C++
Engelsk-svenskt lexikon
Betygsgränser:
3 = 25-33 poäng
4 = 33,5-41 poäng
5 = 41,5-50 poäng
Ange alla antaganden!
Lycka till!
1. Begrepp (5p)
Förklara kortfattat följande begrepp:
a) Arv
b) Referensparameter (till funktion)
c) Variabel
d) Copy constructor
e) Iteration
2. För- och eftervillkor (10p)
För- och eftervillkor är ett sätt att försöka undvika felhantering genom att inte tillåta några fel
och genom att sätta upp kontrakt mellan olika delar i programmet. En programdel förbinder
sig att utföra ett visst jobb om den anropas på rätt sätt från någon annan del. Följande klass är
skapad utan tanke på förvillkor.
a) Beskriv klassens funktionalitet och vad den kan användas till (2p)
b) Din uppgift är att se vilka för- och eftervillkor (pre- och postconditions) som bör gälla för
klassens funktioner samt att lägga till eventuella funktioner för testning av
förvillkoren.(6p)
c) Hur påverkar för- och eftervillkor koden generellt sett? Förklara kortfattat och
exemplifiera gärna. (2p)
#include <iostream.h>
typedef int eT;
typedef struct node* pT;
typedef struct node{
eT data;
pT next;
node(eT d, pT n);
};
node::node(eT d, pT n)
{
data=d;
next=n;
}
class Uppgift2
{
public:
Uppgift2();
~Uppgift2();
void a(int aP);
eT b(int aP);
eT b(int aP, int aN);
void c(eT aE, int aP);
bool d(int aP){return s[aP]>0;};
int e(int aP){return s[aP];};
private:
pT array[MAX];
int s[MAX];
int tot;
};
Uppgift2::Uppgift2()
{
for(int i=0;i<MAX;i++)
{
array[i]=NULL;
s[i]=0;
}
tot=0;
}
Uppgift2::~Uppgift2()
{
for(int i=0;i<MAX;i++)
while(s[i]>0)
a(i);
}
void Uppgift2::c(eT aE, int aP)
{
pT temp=new node(aE, array[aP]);
array[aP]=temp;
s[aP]++;
tot++;
}
eT Uppgift2::b(int aP)
{
return array[aP]->data;
}
eT Uppgift2::b(int aP, int aN)
{
pT temp=array[aP];
for(int i=0;i<aN;i++)
temp=temp->next;
return temp->data;
}
void Uppgift2::a(int aP)
{
pT temp=array[aP];
array[aP]=array[aP]->next;
delete temp;
temp=NULL;
s[aP]--;
tot--;
}
3. Rekursion (5p)
Skriv en rekursiv funktion, sorted, för en länkad lista som kontrollerar om listan är sorterad
eller inte. Exempelkod:
Lista L;
...
print(L);
L.sorted();
L.sort();
print(L);
L.sorted();
//
//
//
//
//
//
//
Listan skapas
Värden läggs in
Utskrift: 1 2 3 2 6 10
Svarar ’false’
sorterar listan
Utskrift: 1 2 2 3 6 10
Svarar ’true’
Tänk på att head-pekaren inte är synlig utanför listan och att du därför behöver ha en
gränssnittsfunktion som i sin tur anropar den rekursiva (privata) funktionen.
4. Algoritmeffektivitet (5p)
Ange storleksordning för följande algoritmer. Använd O (”stora O”). 1p per korrekt svar.
a) void f(int n)
{
n=0;
for(int i=0;i<n;i++)
görNågot;
for(int j=0;j<n;j++)
görNågot;
}
b) void g(int n)
{
if(n>0)
{
görNågot;
g(n-1);
g(n-1);
}
}
c) void h(int n)
{
int max=n/2;
for(int i=0;i<max;i++)
for(int j=0;j<5;j++)
görNågot;
}
d) void k(int n)
{
for(int i=0;i<n;i=i+2)
for(int j=0;j<n;j=j+3)
görNågot;
for(int k=0;k<n;k=k+4)
görNågot;
}
e) void m(int n)
{
if(n>0)
{
m(n/2);
görNågot;
}
}
5. Binära sökträd (5p)
Ett binärt sökträd är en datastruktur bestående av ett antal noder, där varje nod dels innehåller
ett värde, men även två referenser till så kallade barn-noder, ett till höger och ett till vänster.
Alla barn, barnbarn etc till vänster om en given nod är har alltid mindre värden lagrade, och
alla barn till höger har större värden jämfört med aktuell nod. Varje nod har 0, 1 eller 2 barn,
men inte fler. Dessa barn kan i sin tur ha barn och så vidare. S 470 och framåt i Carrano
innehåller alla detaljer om BST inklusive full kod för alla algoritmer.
a) Sätt in följande värden (i den ordning de räknas upp) i ett binärt sökträd som från början är
tomt. M A R T I N C O P E S (3p)
b) Skriv ut alla noder i preorder. (2p)
6. Komplexa strukturer (10p)
Följande program (laboration 3) har din labbkompis gjort under tiden du var på skidsemester i
Åre. Kompisen har tröttnat på att du inte gör något och kräver nu att du skriver resten av
programmet. Använd cout för utskrift och cin för inmatning. De funktioner som saknas är:
a) Skriv ut alla personer som handlar och alla personer i alla kassor.
b) Flytta en person från allmänt handlande till en specifik kassa.
Du ska både skriva själva drivrutinen och de funktioner i affären som behövs. För list- och
köoperationer räcker det med deklarationen, dvs returtyp namn(parametrar).
Dina funktioner ska anropas enligt följande:
void print(Affar& enAffar)
{
// din kod för utskrift och anrop till affärens funktioner
}
void move(Affar& enAffar)
{
// din kod för inmatning och anrop till affärens funktion
}
void main(void)
{
Affar A;
...
//diverse inmatningar och förflyttningar
print(A);
move(A);
}
--------------------------------------------------------------------#include "person.h"
#include "list.cpp"
#include "queue.cpp"
class Affar
{
// dina funktioner för hämtning och förflyttning
...
private:
List <Person> kunder;
Queue<Person> kassor[MAX];
};
--------------------------------------------------------------------class Person
{
public:
Person();
Person(char* name, int age);
~Person();
void setName(char* newName);
void setAge(int newAge);
const char* getName();
const int getAge();
private:
int age;
char name[NAMESIZE];
};
7. Återanvändning (10p)
Du har som nyanställd på ett programmeringsföretag fått i uppgift att implementera en
telefonlista för SIM-kort i mobiltelefoner. Så långt allt väl. Problemet är att kortet bara kan
hantera små datamängder i varje modul på grund av dess minnesstruktur. Du har efter lite
beräkningar och efterforskningar kommit fram till att du får plats med en lista som rymmer 10
personer i varje modul. Kravet du har är att kortet ska kunna lagra minst 200 adresser. Du
måste alltså använda dig av många mindre listor och skapa ett gemensamt gränssnitt mot
dessa listor. Din uppgift är att skapa en datastruktur storLista, som ligger som ett skal runt ett
okänt antal (minst 20st) litenLista, som har vanlig listfunktionalitet, fast som mest kan lagra
10 personer. Du ska både definiera klassen storLista samt implementera funktionerna sattIn,
taBort och hamtaElement. Du ska även skriva för- och eftervillkor för funktionerna. Ett tips är
att tänka till lite extra vad gäller taBort-funktionen.
Modul 1
Gränssnitt mot
användaren
Modul 2
StorLista
Modul 3
LitenLista
Modul 4
LitenLista
...
Modul n
LitenLista
En trevlig bil att titta på när du väntar på att tiden ska ta slut. Mercedes Benz 420 SEL
