Übungsstunde 6
Einführung in die Programmierung
Probleme bei Übung 5
[TODO Assistent]
Nachbesprechung Übung 6
Feedback nach der Korrektur direkt per SVN
Person(int alter, double gewicht,
double groesse, boolean istMaennlich,
double schulterBreite, double brustTiefe, double brustBreite) {
this.alter = alter;
this.gewicht = gewicht;
this.groesse = groesse;
this.istMaennlich = istMaennlich;
this.schulterBreite = schulterBreite;
this.brustTiefe = brustTiefe;
this.brustBreite = brustBreite;
} public class Person {
int alter; // Jahre double gewicht; // kg double groesse; // cm boolean istMaennlich;
double schulterBreite; // cm double brustTiefe; // cm double brustBreite; // cm
String beschreibung() { …
}
double bodyMassIndex() {
return 10000 * gewicht / (groesse * groesse);
}
‘this.alter’ um Konflikt mit Parameter ‘alter’ zu vermeiden
static Person[] liesPersonen(Scanner scanner) {
Person[] personen = new Person[scanner.nextInt()];
for (int i = 0; i < personen.length; i++) personen[i] = liesPerson(scanner);
return personen;
}
static Person liesPerson(Scanner scanner) {
double schulterBreite = scanner.nextDouble();
double brustTiefe = scanner.nextDouble();
double brustBreite = scanner.nextDouble();
int alter = scanner.nextInt();
double gewicht = scanner.nextDouble();
double groesse = scanner.nextDouble();
boolean istMaennlich = scanner.nextInt() == 1;
return new Person(....);
}
in main()-Methode
Scanner scanner = new Scanner(
new File("body.dat.txt"));
Person[] personen = liesPersonen(scanner);
scanner.close();
static void druckeUngesunde(Person[] personen, PrintStream ausgabe) { for (int i = 0; i < personen.length; i++) {
Person person = personen[i];
String klasse = gewichtsKlasse(person);
if (!klasse.equals("normalgewichtig"))
ausgabe.println(person.beschreibung() + " ist " + klasse);
} }
static String gewichtsKlasse(Person person) { if (person.bodyMassIndex() >= 30)
return "fettleibig";
if (person.bodyMassIndex() >= 25) return "übergewichtig";
if (person.bodyMassIndex() < 18.5) return "untergewichtig";
return "normalgewichtig";
}
static double partnerQualitaet(Person p1, Person p2) { double distanz = Math.pow(p1.groesse - p2.groesse, 2)
+ 0.2 * Math.abs(p1.brustTiefe * p1.brustBreite - p2.brustTiefe * p2.brustBreite)
+ 0.5 * Math.pow(p1.schulterBreite - p2.schulterBreite, 2);
return 1 / (1 + distanz);
}
P1 P2 P3 P4 P5 P6 P7 P8 P9
P1 P2 P3 P4 P5 P6 P7 P8 P9 Personen:
Personen:
……...
static void druckeGuteTrainingsPartner(Person[] personen, PrintStream ausgabe) { for (int i = 0; i < personen.length; i++) {
for (int j = i + 1; j < personen.length; j++) {
double q = partnerQualitaet(personen[i], personen[j]);
if (q > 0.8) {
ausgabe.println(personen[i].beschreibung() + ", "
+ gewichtsKlasse(personen[i]));
ausgabe.println(personen[j].beschreibung() + ", "
+ gewichtsKlasse(personen[j]));
ausgabe.println("Qualität: " + q);
} }
} }
// test corner cases // null
BlackBox.rotateArray(null, 0);
BlackBox.rotateArray(null, 1);
BlackBox.rotateArray(null, -1);
// empty
int[] expected = new int[] {};
int[] values = new int[] {};
BlackBox.rotateArray(values, 0);
assertArrayEquals(expected, values);
// 1-elem
expected = new int[] { 1 };
values = new int[] { 1 };
BlackBox.rotateArray(values, 0);
assertArrayEquals(expected, values);
BlackBox.rotateArray(values, 1);
assertArrayEquals(expected, values);
BlackBox.rotateArray(values, -1);
assertArrayEquals(expected, values);
// 2-elem
expected = new int[] { 1, 2 };
values = new int[] { 1, 2 };
BlackBox.rotateArray(values, 0);
assertArrayEquals(expected, values);
BlackBox.rotateArray(values, 2);
assertArrayEquals(expected, values);
BlackBox.rotateArray(values, -2);
assertArrayEquals(expected, values);
expected = new int[] { 2, 1 };
values = new int[] { 1, 2 };
BlackBox.rotateArray(values, 1);
assertArrayEquals(expected, values);
values = new int[] { 1, 2 };
BlackBox.rotateArray(values, -1);
assertArrayEquals(expected, values);
static private int[] createRangeArray(int start, int end) { int size = end - start;
int[] res = new int[size];
for (int i = 0; i < size; i++) { res[i] = start + i;
}
return res;
}
// general test
int[] rotations = createRangeArray(-42, 43);
for (int n = 0; n < 13; n++) { for (int steps : rotations) {
expected = createRangeArray(-1, n - 1);
values = expected.clone();
BlackBox.rotateArray(values, steps);
for (int i = 0; i < values.length; i++) {
assertEquals(expected[((i - steps) % n + n) % n], values[i]);
} }
}
start start+1 start+2 …... end-3 end-2 end-1
<yz> <= Y | ZZZ
<xyz> <= { X <xyz> <yz> | <yz> <xyz> X }
<abc> <= A {CC} { XY {CC} | XZ | A {CC} | B {CC} } B
(x,y) (nx,ny)
// 1. Zeichnen des aktuellen Segments
double nx = x + Math.cos(angle) * length;
double ny = y - Math.sin(angle) * length;
win.setStrokeWidth(length / 20);
win.setColor(0, 0, 0);
win.drawLine(x, y, nx, ny);
Recursion exits // Falls l < 10 endet die Rekursion und // am Ende des Segments wird ein Blatt // gemalt.
if (length < 10.0) {
win.setColor(0, 180, 0);
win.fillCircle(nx, ny, 3);
}
// Jede Rekursion muss einen Ausgang // haben!
(x,y)
(nx’,ny’)(nx’’,ny’’)
drawTree(win, nx, ny, length * 0.8,
angle + Math.PI / 5);
drawTree(win, nx, ny, length * 0.6,
angle - Math.PI / 3);
//recursive method
public static void drawTree(Window win, double x, double y, double length, double angle) { double nx = x + Math.cos(angle) * length;
double ny = y - Math.sin(angle) * length;
win.setStrokeWidth(length / 20);
win.setColor(0, 0, 0);
win.drawLine(x, y, nx, ny);
if (length < 10.0) {
win.setColor(0, 180, 0);
win.fillCircle(nx, ny, 3);
} else {
drawTree(win, nx, ny, length * 0.8, angle + Math.PI / 5);
drawTree(win, nx, ny, length * 0.6, angle - Math.PI / 3);
} }
Vorbesprechung Übung 7
Aufgabe 1: Linked List
null
Überprüfen von fehlerhaften Bedingungen:
if (condition) {
Errors.error(message);
}
Aufgabe 2: Unit-Tests für die Linked List
public class LinkedIntListTest {
@Test
public void testGet() {}
@Test
public void testSet() {}
@Test
public void testIsEmpty() {}
@Test
public void testAddFirst() {}
@Test
public void testAddLast() {}
@Test
public void testRemoveFirst() {}
@Test
public void testRemoveLast() {}
@Test
public void testClear() {}
@Test
public void testToArray() {}
}
LinkedIntListTest.java
LinkedIntList list =
new LinkedIntList();list.addFirst(1);
list.addFirst(2);
list.addFirst(3);
assertArrayEquals(new int[]{3, 2, 1}, list.toArray());
Beispiel:
Praktisch!
testRandom() vom Übungsblatt
@Test
public void testRandom() {
Random rand = new Random(42);
LinkedIntList ll = new LinkedIntList();
for(int n = 0; n < 9721; n++) { int choice = rand.nextInt(6);
int value = rand.nextInt();
if(choice == 0)
ll.addFirst(value);
else if(choice == 1) ll.addLast(value);
else if(choice == 2 && !ll.isEmpty()) ll.removeFirst();
else if(choice == 3 && !ll.isEmpty()) ll.removeLast();
else if(choice == 4 && !ll.isEmpty()) ll.set(rand.nextInt(ll.size), value);
else if(choice == 5 && value % 5 == 0) ll.clear();
}
String msg = "There is a bug in your LinkedIntList";
assertFalse(msg, ll.isEmpty());
assertEquals(msg, 5, ll.size);
int[] expect = new int[]{-1759285598, -424345731, -1746103561,
-1623993329, -1831395423};
assertArrayEquals(msg, expect, ll.toArray());
}
Aufgabe 3: Dominator (Bonus)
Schreiben Sie Junit-Tests für die Methode int[] dominators( int[] elevations)
Die Methode bekommt ein Array, mit Höhenangaben für jeden Punkt P, als Input und gibt ein Array mit dem Index des jeweiligen Dominators zurück.
Ein Dominator D eines Punktes P hat von allen Punkten, welche höher als P liegen, die kleinste
(horizontale) Distanz zu P. Falls zwei solche Punkte existieren, ist der höhere der beiden der einzige
Dominator. Falls beide dieser Punkte gleich hoch sind, gibt es zwei mögliche Dominatoren. Falls kein
Dominator für P existiert, enthält result[P] die Zahl -1.
Aufgabe 3: Dominator (Bonus)
result = {3, 0, 3, 5, 5, -1,
5, -1}oder
result = {3, 0, 3, 5, 5, -1,
7, -1}Aufgabe 3: Dominator (Bonus)
Weiteres Beispiel:
elevations = {5, 1, 5, 6}
result = {3, 0, 3,
-1}result = {3, 2, 3,
-1}Aufgabe 3: Dominator (Bonus)
Um die Stärke Ihrer Tests zu beurteilen, werden verschiedene, teilweise fehlerhafte
Implementierungen mithilfe Ihrer Tests überprüft. Je mehr Fehler Ihre Tests aufdecken, desto besser.
Tests sollten fehlschlagen, falls die Implementierung fehlerhaft ist, und erfolgreich durchlaufen, falls keine Fehler vorhanden sind.
Als Hilfe können Sie sich die Lösung der Aufgabe ”Black-Box Testing” aus der letzten Serie
anschauen.
Aufgabe 4: Self-avoiding Random Walks
Die Stadt besteht aus 2*N Strassen, die in einem regelmässigen Gitter angeordnet sind (N ist ungerade und > 1.). Die Stadt kann also vollständig durch die N*N Kreuzungen der Strassen beschrieben werden.
Eine einmal besuchte Kreuzung wird nicht nochmal besucht. Der Wolf wählt zufällig unter
den Richtungen, die ihn zu einer neuen, noch nicht besuchten Kreuzung führen. Wenn der
Wolf den Stadtrand erreicht hat, ist die Flucht erfolgreich verlaufen. Wenn der Wolf an
eine Kreuzung kommt, von der aus er keine unbesuchte Kreuzung erreichen kann, dann ist
die Flucht fehlgeschlagen.
Aufgabe 4: Self-avoiding Random Walks
s
2D-Array
int [] [] array2d = new int [zeilen] [spalten];
Ein 2D-Array ist ein lineares Array von Zeilen. Der new Operator initialisiert die Elemente der Zeilen mit dem Nullwert des Typs, z.B. 0 für int.
0 0 0 0
0 0 0 0
0 0 0 0
…
