ID1018 Programmering I Tentamen: lösning av Fadil Galjic apr 2021

Tentamen: lösning
Uppgifter: lösningar
Uppgift 1 (3 poäng + 3 poäng)
a) (3 poäng)

u
3 4 5 1 2

b) (3 poäng)

v[0]
0 3 6 9

v v[1]
1 4 7 10

v[2]
2 5 8 11

Uppgift 2 (3 poäng + 3 poäng + 3 poäng)

a) (3 poäng)
public static Car findCar (Car[] cars, String type)
{
if (cars.length == 0)
throw new java.lang.IllegalArgumentException ("no cars");

Car car = null;

int pos = 0;
while (pos < cars.length && !cars[pos].getType ().equals (type))
pos++;
if (pos < cars.length)
{
car = cars[pos];
double price = car.getPrice ();
pos++;
while (pos < cars.length)
{
if (cars[pos].getType ().equals (type) &&
cars[pos].getPrice () < price)
{
car = cars[pos];

1
ID1018 Programmering I Tentamen: lösning av Fadil Galjic apr 2021

price = car.getPrice ();

}
pos++;
}
}

return car;
}

b) (3 poäng)
public static Car[] selectCars (Car[] cars, double minPrice, double maxPrice)
{
int countCars = 0;
for (Car car : cars)
if (car.getPrice () >= minPrice && car.getPrice () <= maxPrice)
countCars++;

Car[] selectedCars = new Car[countCars];

int i = 0;
int j = 0;
while (j < countCars)
{
if (cars[i].getPrice () >= minPrice && cars[i].getPrice () <= maxPrice)
selectedCars[j++] = cars[i];
i++;
}

return selectedCars;
}

c) (3 poäng)
Car[] cars = { new Car("Audi", 210),
new Car("BMW", 220),
new Car("Volvo", 180),
new Car("Mazda", 190),
new Car("BMW", 230),
new Car("Mazda", 180) };

Car car = findCar (cars, "Mazda");

Car[] selectedCars = selectCars (cars, 190, 220);

Uppgift 3 (3 poäng + 3 poäng + 3 poäng)

a) (3 poäng)

ms chars
L o v e

b) (3 poäng)
public void addFirst (char ch)

2
ID1018 Programmering I Tentamen: lösning av Fadil Galjic apr 2021

{
char[] newChars = new char [this.chars.length + 1];
newChars[0] = ch;
for (int i = 0; i < this.chars.length; i++)
newChars[i + 1] = this.chars[i];
this.chars = newChars;
}

c) (3 poäng)
public void deleteCharAt (int index)
throws java.lang.IndexOutOfBoundsException
{
if (index < 0 || index >= this.chars.length)
throw new java.lang.IndexOutOfBoundsException ("bad index: " + index);

char[] newChars = new char [this.chars.length - 1];

for (int i = 0; i < index; i++)
newChars[i] = this.chars[i];
for (int i = index + 1; i < this.chars.length; i++)
newChars[i - 1] = this.chars[i];

this.chars = newChars;

Uppgift 4 (3 poäng + 3 poäng + 3 poäng)

a) (3 poäng)
public int compareTo (Rectangle r)
{
int comp = 0;
if (this.length * this.width < r.length * r.width)
comp = -1;
else if (this.length * this.width > r.length * r.width)
comp = 1;

return comp;
}

b) (3 poäng)
public static <T extends ComparableShape<T>> T min (T[] shapes)
{
if (shapes.length == 0)
throw new java.lang.IllegalArgumentException ("no shapes");

T minShape = shapes[0];
for (int i = 1; i < shapes.length; i++)
if (shapes[i].compareTo (minShape) == -1)
minShape = shapes[i];

return minShape;
}

c) (3 poäng)
Rectangle[] rectangles = { new Rectangle (2, 4),
new Rectangle (5, 2),
new Rectangle (7, 6),
new Rectangle (4, 1),
new Rectangle (8, 9) };

3
ID1018 Programmering I Tentamen: lösning av Fadil Galjic apr 2021

Rectangle minRectangle = min (rectangles);

Uppgift 5 (5 poäng + 4 poäng)

a) (5 poäng)
public static void sort (int[] sequence)
{
int lastPos = sequence.length - 1;
int maxPos = 0;
int e = 0;
for (int pos = 0; pos < lastPos; pos++)
{
maxPos = pos;
for (int p = pos + 1; p <= lastPos; p++)
if (sequence[p] > sequence[maxPos])
maxPos = p;

if (maxPos != pos)
{
e = sequence[pos];
sequence[pos] = sequence[maxPos];
sequence[maxPos] = e;
}
}
}

b) (4 poäng)

För att bestämma det element som ska ligga på den första positionen, utförs n – 1 elementjämförelser. För att bestämma det
element som ska ligga på den andra positionen utförs n – 2 jämförelser. Antalet jämförelser minskar med 1 för varje ny
position. Det totala antalet jämförelser är:

(n – 1) + (n – 2) + … + 1 = n(n – 1) /2
Motsvarande komplexitetsfunktion är:

t(n) = n(n – 1) /2
t(n) = n2/2 – n/2
För stora n dominerar termen med n2. Därför:

t(n) ϵ θ(n2)
Algoritmen är kvadratisk när det gäller antalet elementjämförelser.

Man sätter n – 1 element på rätt plats, och därmed sorteras alla element. När ett element sätts in på rätt ställe, byter det plats
med det element som redan finns där. Om ett element redan finns på rätt position, behöver det inte byta plats med något annat
element. Det betyder att i värsta fall utförs n – 1 elementutbyten.

Algoritmens tidskomplexitet i värsta fall, när det gäller antalet elementutbyten, kan ges med följande komplexitetsfunktion:

w(n) = n – 1
w(n) ϵ Θ(n)
Algoritmen är linjär när det gäller antalet elementutbyten i värsta fall.