Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Aufgabe 1 (Übersicht)
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.
Beide Seiten, vorherige ÜberarbeitungVorherige ÜberarbeitungNächste Überarbeitung | Vorherige ÜberarbeitungLetzte ÜberarbeitungBeide Seiten, nächste Überarbeitung | ||
pruefungen:bachelor:pfp:loesungws15 [18.07.2016 16:08] – angelegt + Aufgabe 1,2,4 Tenma | pruefungen:bachelor:pfp:loesungws15 [19.07.2018 15:47] – evren | ||
---|---|---|---|
Zeile 1: | Zeile 1: | ||
====== Aufgabe 1 ====== | ====== Aufgabe 1 ====== | ||
- | a) 1 und 4 | + | * a) 1 und 4 |
- | b) 2 und 4 (???) (einerseits | + | * b) 2 und 4 |
+ | Da nur nach gefragt ist, was den Speedup verbessern **könne**, ist 4 auch richtig, da es in manchen Fällen eine bessere Lastverteilung | ||
- | c) 2 und 3 (siehe Seite 26 VL Folie: https:// | + | * c) 2 und 3 (siehe Seite 26 VL Folie: https:// |
====== Aufgabe 2 ====== | ====== Aufgabe 2 ====== | ||
- | a) | ||
- | < | ||
- | AtomicInteger activeThreads = new AtomicInteger(0); | ||
- | </ | ||
- | b) | + | * a) |
- | < | + | < |
+ | |||
+ | * b) | ||
+ | <code=java> | ||
boolean manageThreads(String linkUrl) { | boolean manageThreads(String linkUrl) { | ||
- | if (curThreads.incrementAndget() <= maxThreads) { | + | |
- | CrawlThread t = new CrawlThread(linkUrl); | + | CrawlThread t = new CrawlThread(linkUrl); |
- | t.start(); | + | t.start(); |
- | } else { | + | } |
- | curThreads.decrementAndGet(); | + | |
- | return false; | + | curThreads.decrementAndGet(); |
- | } | + | return false; |
+ | } | ||
} // END OF manageThreads | } // END OF manageThreads | ||
</ | </ | ||
- | c) | + | * c) |
- | < | + | <code=java> |
public void run() { | public void run() { | ||
- | process(); | + | |
- | curThreads.decrementAndGet(); | + | curThreads.decrementAndGet(); |
} | } | ||
</ | </ | ||
- | d) | + | * d) |
- | < | + | <code=java> |
synchronized(visitedUrls) { | synchronized(visitedUrls) { | ||
- | if(!visitedUrls.contains(linkUrl)){ | + | |
- | doVisit = true; | + | doVisit = true; |
- | visitedUrls.add(linkUrl); | + | visitedUrls.add(linkUrl); |
- | } | + | } |
} | } | ||
</ | </ | ||
+ | ====== Aufgabe 3 ====== | ||
+ | {{: | ||
+ | |||
+ | Nicht gefragt, hier aber erwähnt: | ||
+ | |||
+ | Beschränktheit: | ||
+ | |||
+ | Lebendigkeit: | ||
====== Aufgabe 4 ====== | ====== Aufgabe 4 ====== | ||
- | a) | + | * a) 3 |
- | 3 | + | Nein ist nicht möglich, s wird bereits mit anderen Werten belegt, bevor das Programm parallel ausgeführt wird. Die Sichtbarkeit der in Zeile 25 festgelegten Werte ist gewährleistet (genauer [nicht VL-Stoff]: Es existiert im Allgemeinen eine Happens-Before Ordnung zwischen Code vor start() und dem Thread-Code.) |
- | Nein ist nicht möglich, s wird bereits mit anderen Werten belegt bevor das Programm parallel ausgeführt wird. Die Sichtbarkeit | + | * b) 2 |
+ | | ||
- | b) | + | * c) 4 |
- | 3 | + | Nein, da die Threads wieder gejoint wurden. Das Programm ist somit nicht mehr parallel. Die Sichtbarkeit ist im (einzigen) Haupt-Thread gewährleistet (genauer [nicht VL-Stoff]: Es existiert im Allgemeinen eine Happens-Before Ordnung zwischen Thread-Code und Code nach einem erfolgreichen join()-Aufruf). |
+ | |||
+ | Was bringt hier, dass s als volatile deklariert ist? volatile wirkt sich nur auf die Referenz selbst aus, diese wird aber nie geändert, könnte also genauso gut finaln sein. | ||
- | Ja, " | + | ====== Aufgabe 5 ====== |
- | c) | + | * a) |
- | 4 | + | < |
+ | def insert: (List[Int], Int) => List[Int] = (ls, v) => ls match { | ||
+ | case Nil => List(v) | ||
+ | case x::xs => { | ||
+ | if (v <= x) { | ||
+ | v :: x :: xs | ||
+ | } | ||
+ | else { | ||
+ | x :: insert(xs, v) | ||
+ | } | ||
+ | }</ | ||
+ | |||
+ | Alternativ: | ||
+ | < | ||
+ | def insert: (List[Int], Int) => List[Int] = (ls, v) => { | ||
+ | val p = ls.partition(_ <= v) | ||
+ | p._1 ::: v :: p._2 | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Alternativ: | ||
+ | < | ||
+ | def insert: (List[Int], Int) => List[Int] = (ls, v) => | ||
+ | (for (l <- ls if l <= v) yield l) ::: (v :: (for (l <- ls if l > v) yield l)) | ||
+ | </ | ||
+ | |||
+ | * b) | ||
+ | |||
+ | < | ||
+ | def sort: List[Int] => List[Int] = ls => | ||
+ | ls.foldRight(List[Int]())((v, | ||
+ | // Alternativ zu " | ||
+ | // Nil: List[Int] | ||
+ | // Aber unbedingt mit Typangabe, sonst schlägt Scala' | ||
+ | </ | ||
+ | |||
+ | * c) | ||
+ | |||
+ | < | ||
+ | def sortAllWith: | ||
+ | sortFun => ls => for (cur <- ls) yield sortFun(cur) | ||
+ | </ | ||
+ | |||
+ | Falls man nicht unbedingt eine Listenabstraktion verwenden hätte müssen: | ||
+ | < | ||
+ | def sortAllWith: | ||
+ | list.map(x => function(x)) | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | ====== Aufgabe 6 ====== | ||
+ | |||
+ | * a) | ||
+ | |||
+ | < | ||
+ | def testInside: (Ellipse, Ellipse) => (Double, Double) => Boolean = | ||
+ | (e1, e2) => (x, y) => isInside(e1, | ||
+ | </ | ||
+ | |||
+ | |||
+ | * b) | ||
+ | |||
+ | < | ||
+ | def tupleStream: | ||
+ | (s.head, s.tail.head) #:: tupleStream(s.tail.tail) | ||
+ | |||
+ | // alternativ | ||
+ | (s(0), s(1)) #:: tupleStream(s.drop(2)) | ||
+ | </ | ||
+ | |||
+ | * c) | ||
+ | |||
+ | < | ||
+ | def monteCarlo: (Ellipse, Ellipse) => Int => Int = (e1, e2) => count => { | ||
+ | |||
+ | // Stream aus Punkten | ||
+ | val pointStream = tupleStream(randomStream) | ||
+ | |||
+ | pointStream.take(count).par.filter(p => testInside(e1, | ||
+ | // .count wirft einen komischen Fehler von Scalas Type Inference System | ||
+ | // " | ||
+ | } | ||
+ | </ | ||
- | Nein, da die Threads wieder gejoint wurden. Das Programm ist somit nicht mehr parallel. Die Sichtbarkeit ist im (einzigen) Thread gewährleistet. |