Prof. Dr.

Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

Prof. Dr. Robert Garmann

PR1 - Selbsttest ST2 (Musterlösung) Hochschule Hannover
WS2014/15 (Stand 2014-09-17 10:18) Fakultät IV – Abteilung Informatik
Raum 303, Tel. 0511-9296-1832
robert.garmann@hs-hannover.de

Aufgaben im Überblick Seite

1 Einfache Aufgaben zur Wiederholung mit Zuordnung zu Vorlesungskapiteln.......................................... 2
1.a Programmlogik und indefinite Schleifen ..............................................................................................2
1.a.i Scanner .................................................................................................................... 2
1.b Dateien und Exceptions..................................................................................................................2
1.b.i Scanner.(has)NextLine ................................................................................................. 2
1.b.ii Scanner.(has)Next ....................................................................................................... 2
1.b.iii Scanner.(has)NextInt .................................................................................................... 2
1.b.iv throws ....................................................................................................................... 2
1.b.v Alternative zu throws .................................................................................................... 2
1.b.vi Datei einlesen und ausgeben ......................................................................................... 2
1.b.vii System.out.......................................................................................................... 3
1.c Arrays ........................................................................................................................................3
1.c.i min-Methode .............................................................................................................. 3
1.c.ii Zweidimensionales Array ............................................................................................... 3
1.d Collections ..................................................................................................................................3
1.d.i ArrayList von Zeichen ................................................................................................... 3
1.d.ii Namen zu gegebenem Alter finden .................................................................................. 3
1.e Rekursion ...................................................................................................................................4
1.e.i Rekursion .................................................................................................................. 4
2 Realistische Klausuraufgaben ohne Kapitelzuordnung ..................................................................... 4
2.a Wörter in Zeichenkette zählen..........................................................................................................4
2.b Zeilen vertauschen........................................................................................................................5
2.c Minimaler Abstand im Array.............................................................................................................5
2.d Wörter rückwärts ausgeben .............................................................................................................5
2.e Mysteriöse Rekursion ....................................................................................................................5
2.f Harmonische Reihe .......................................................................................................................6
2.g Ziffern ........................................................................................................................................6
2.h Consolen-Grafik ausgeben ..............................................................................................................6
2.i Markierungsfahrzeug .....................................................................................................................7
2.j Rekursion ...................................................................................................................................8
2.k Münzen zählen ............................................................................................................................8
2.l Binäre Suche ...............................................................................................................................8
2.m Zufälliges Element einer Menge .......................................................................................................8
2.n Wahlergebnisse aggregieren ...........................................................................................................8

Stand 2014-09-17 10:18 Seite 1 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

1 Einfache Aufgaben zur Wiederholung mit Zuordnung zu

Vorlesungskapiteln
1.a Programmlogik und indefinite Schleifen
1.a.i Scanner
a) Ihr Name ist Hillary
b) Ihr IQ ist 104
c) Ihr Name ist 104.3

1.b Dateien und Exceptions

1.b.i Scanner.(has)NextLine
> 6.7 hi
> x-y a
>
> 10 20
4 Zeilen

1.b.ii Scanner.(has)Next
> 6.7
> hi
> x-y
> a
> 10
> 20
6 Zeilen

1.b.iii Scanner.(has)NextInt
0 Zeilen

1.b.iv throws
Die throws-Klausel deklariert im Methodenkopf, dass eine Anweisung der Methode potentiell
den in der throws-Klausel angegebenen Exception-Typ erzeugen kann.

1.b.v Alternative zu throws

Alternativ zur throws-Klausel schreibt man die potentiell fehlererzeugenden Statements in ein
try-catch-Statement, so dass die eventuell erzeugte Exception abgefangen wird.

1.b.vi Datei einlesen und ausgeben

import java.util.*;
import java.io.*;

public class FinallyTest {

public static void main(String[] args) {
Scanner input= null;
try {
input= new Scanner(new File("datei.txt"));
while (input.hasNextLine()) {
String text= input.nextLine();
System.out.println(text);

Stand 2014-09-17 10:18 Seite 2 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

}
} catch (FileNotFoundException e) {
System.out.println(e);
} finally {
if (input != null) {
input.close();
}
}
}
}

1.b.vii System.out
PrintStream

1.c Arrays
1.c.i min-Methode
Musterlösung:
public static double min(double[] arr) {
double min= arr[0];
for (int i=1; i<arr.length; i++) {
min= Math.min(min, arr[i]);
}
return min;
}
Alternativ kann in der for-Schleife eine if-Anweisung stehen.

1.c.ii Zweidimensionales Array

Musterlösung:

double[][] temp= new double[3][];

temp[0]= new double[]{11.6, 13.8, 15.5};
temp[1]= new double[0]; // kann entfallen (ist dann ==null)
temp[2]= new double[2];
temp[2][0]= 12.7;
temp[2][1]= 13.3;

Die Musterlösung demonstriert beide möglichen Wege:

1. Komplett-Initialisierung mit Angabe aller Werte einer Zeile in {}
2. Zuerst Array anlegen, dann Werte einzeln belegen.
Alternative Musterlösung:
double[][]temp ={{11.6,13.8,15.5},{},{12.7,13.3}}

1.d Collections
1.d.i ArrayList von Zeichen
 Zu a) Elemente einer ArrayList müssen von einem Objekt-Typ sein. char ist ein
primitiver Datentyp
 Zu b) Ersetze <char> durch <Character>

1.d.ii Namen zu gegebenem Alter finden

public static HashSet<String> getNamenMitGegebenemAlter(

Stand 2014-09-17 10:18 Seite 3 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

HashMap<String, Integer> menschen, HashSet<Integer> alter) {

HashSet<String> namen= new HashSet<String>();

for (String name : menschen.keySet()) {

if (alter.contains(menschen.get(name))) {
namen.add(name);
}
}

return namen;
}

1.e Rekursion
1.e.i Rekursion
Musterlösung:
public static void doubleReverse2(String s) {
if (s.length() > 0) {
char c= s.charAt(s.length()-1);
System.out.print(c);
System.out.print(c);
doubleReverse2(s.substring(0, s.length()-1));
}
}

Alternative:
public static void doubleReverse3(String s) {
if (s.length() <= 1) {
System.out.print(s+s);
} else {
char c= s.charAt(s.length()-1);
System.out.print(c);
System.out.print(c);
doubleReverse2(s.substring(0, s.length()-1));
}
}

2 Realistische Klausuraufgaben ohne Kapitelzuordnung

2.a Wörter in Zeichenkette zählen
public static void processData(String s) {
Scanner input= new Scanner(s);
int count = 0;
int sumLength = 0;
while (input.hasNext()) {
String next = input.next();
count++;
sumLength += next.length();
}
double average = (double)sumLength/count;
System.out.println("Wörter = " + count);
System.out.println("Durchschnittslänge = " + average);
}

Stand 2014-09-17 10:18 Seite 4 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

2.b Zeilen vertauschen

public static void processFile(Scanner input) {
while (input.hasNextLine()) {
String first = input.nextLine();
if (input.hasNextLine()) {
String second = input.nextLine();
System.out.println(second);
}
System.out.println(first);
}
}

2.c Minimaler Abstand im Array

public static int minGap(int[] arr) {
if (arr.length < 2) {
return 0;
}
int min = arr[1] - arr[0];
for (int i = 2; i < arr.length; i++) {
int abstand = arr[i] - arr[i - 1];
if (abstand < min) {
min = abstand;
}
}
return min;
}

2.d Wörter rückwärts ausgeben

public static void printReversed(String s) {
int pos= 0;
while (pos < s.length()) {
if (s.charAt(pos) == ' ') {
System.out.print(' ');
pos++;
} else {
int nextpos= s.indexOf(" ", pos);
if (nextpos < 0) {
nextpos= s.length();
}
for (int i=nextpos-1; i>= pos; i--) {
System.out.print(s.charAt(i));
}
pos= nextpos;
}
}
System.out.println();
}

2.e Mysteriöse Rekursion

Methodenaufruf Ausgabe

a) mystery6(4, 1) 4

Stand 2014-09-17 10:18 Seite 5 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

b) mystery6(4, 2) 8, 4, 8

c) mystery6(8, 2) 16, 8, 16

d) mystery6(4, 3) 12, 8, 4, 8, 12

e) mystery6(3, 4) 12, 9, 6, 3, 6, 9, 12

2.f Harmonische Reihe

public static double harmonic(int n) {
if (n < 0) {
throw new IllegalArgumentException("harmonic: n < 0");
} else if (n == 0) {
return 0.0;
} else {
return harmonic(n - 1) + 1.0 / n;
}
}

2.g Ziffern
public static int countEvenDigits(int n) {
int count = 0;
while (n != 0) {
int digit = n % 10;
n = n / 10;
if (digit % 2 == 0) {
count++;
}
}
return count;
}

Rekursive Variante (wer es mag):

public static int countEvenDigitsRecursive(int n) {
if (n == 0) { // sind noch Ziffern übrig?
return 0; // nein
}

int count= countEvenDigitsRecursive( n / 10 );

int ziffer= n % 10;

if (ziffer % 2 == 0) {
count++;
}
return count;
}

2.h Consolen-Grafik ausgeben

public static void printChars(int n, char c) {
for (int j=0; j<n; j++) {
System.out.print(c);

Stand 2014-09-17 10:18 Seite 6 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

}
}
public static void printFigure(int n) {
printChars(n-1, ' ');
System.out.println("|");
for (int i=1; i<n; i++) {
printChars(n-i-1, ' ');
System.out.print("/");
printChars(i-1, ' ');
System.out.print("|");
printChars(i-1, ' ');
System.out.print("\\");
System.out.println();
}
printChars(n*2-1, '-');
System.out.println();
}

2.i Markierungsfahrzeug
public class Markierung {
public static void main(String[] args) {
double teillaenge[]= {6.5, 1.5, 4.3, 2.1, 8.7, 8.3};
String farben[]= {"rot", "gelb", "blau"};
double abstand= 3; // Markierungsabstand
int stadtteilindex= 0; // In diesem Stadtteil bin ich gerade
double laenge= 0; // Bisher abgefahrende Gesamtlänge
double grenzlaenge= teillaenge[0]; // Bei dieser Länge fängt der
// nächste Stadtteil an
int farbindex= 0; // nächste Farmarkierung
while (stadtteilindex < teillaenge.length) {
System.out.print((char)('A'+stadtteilindex));
System.out.println(" "+laenge+" "+farben[farbindex]);
laenge += abstand;
// Prüfe nun, ob das Ende des Stadtteils oder gar das Ende der Gesamtroute
// erreicht ist:
while (laenge > grenzlaenge && stadtteilindex < teillaenge.length) {
// While-Schleife, da es mehrere sehr kurze Stadtteile geben kann, die
// ich alle überspringen muss:
stadtteilindex++;
if (stadtteilindex < teillaenge.length) {
grenzlaenge += teillaenge[stadtteilindex];
}
}
farbindex= (farbindex+1)%farben.length;
}
}
}

Stand 2014-09-17 10:18 Seite 7 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

2.j Rekursion
public static String m(int n) {
if (n>1) {
String s= m(n-1);
return n+s+s+n;
}
return "1";
}

2.k Münzen zählen

public static final double[] MUENZ_BETRAG
= { 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2 };

public static boolean istBetrag(int[] muenzen, double betrag) {

double summe= 0;
for (int i=0; i<muenzen.length; i++) {
summe += MUENZ_BETRAG[muenzen[i]];
}
return Math.abs(summe - betrag) < 1E-4;
}

2.l Binäre Suche

public static Point binarySearch(Point[] arr, int x) {
return binarySearch(arr, x, 0, arr.length);
}
public static Point binarySearch(Point[] arr, int x, int left, int right) {
if (left >= right) return null;
if (left == right-1) {
if (arr[left].x == x) return arr[left];
return null;
}
int mid= (left+right)/2;
if (arr[mid].x > x) return binarySearch(arr, x, left, mid);
return binarySearch(arr, x, mid, right);
}

2.m Zufälliges Element einer Menge

public static Integer randomInSet(Set<Integer> set) {
int index= new Random().nextInt(set.size());
int i = 0;
for(Integer iobj : set) {
if (i == index) return iobj;
i++;
}
return null; // never executed
}

2.n Wahlergebnisse aggregieren

public static void zaehlen(
Map<String, Integer> ergebnis,
String[] parteien,
String[] stimmen,
String[] gegenstimmen) {

int[] sum= new int[parteien.length]; // je Partei stimmen minus gegenstimmen

int kreuze= 0; // Anzahl aller Kreuze

Stand 2014-09-17 10:18 Seite 8 von 9

Prof. Dr. Robert Garmann Programmieren I (PR1) - Selbsttest ST2 (Musterlösung) - WS2014/15

for (int i=0; i<parteien.length; i++) {

int s= stimmen[i].length(); // Anzahl der Kreuze
int g= gegenstimmen[i].length(); // Anzahl der Kreuze
if (s!=0 && g!=0) return; // ungueltig
sum[i]= s-g;
kreuze += (s+g);
}
if (kreuze > 5) return; // ungueltig
// Aufsummieren erst, wenn Ungültigkeit sicher ausgeschlossen ist:
for (int i=0; i<parteien.length; i++) {
if (sum[i] != 0) {
// Integer-Objekt ist unveränderlich.
// Daher get und put:
ergebnis.put(parteien[i], ergebnis.get(parteien[i]) + sum[i]);
}
}
}

Stand 2014-09-17 10:18 Seite 9 von 9