Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Forendiskussionen   (Übersicht)

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige ÜberarbeitungVorherige Überarbeitung
Nächste Überarbeitung
Vorherige Überarbeitung
pruefungen:bachelor:pfp:loesungws13 [16.07.2014 11:23] lemurpruefungen:bachelor:pfp:loesungws13 [05.08.2017 16:21] (aktuell) Bsanchez
Zeile 4: Zeile 4:
  
 ===== Lösungsversuch ===== ===== Lösungsversuch =====
- 
-Fehlende Aufgaben: 4, 6 
  
 ==== Aufgabe 1: Wissensfragen ==== ==== Aufgabe 1: Wissensfragen ====
Zeile 42: Zeile 40:
  
 Endbild Endbild
 +EDIT: ich glaube, in Stelle C soll kein Marke sein. 
 +EDIT: Bin ich auch der Meinung.
  
-**d)** Nein+**d)** Nein (siehe Ablauf t3 -> t1 -> t1)
  
 **e)** e) S = {0, 1, 1}T ; M = {t1: {-1, 1, 0}, t2: {-1, 0, 1}, t3: {2, -1, -1} }T **e)** e) S = {0, 1, 1}T ; M = {t1: {-1, 1, 0}, t2: {-1, 0, 1}, t3: {2, -1, -1} }T
Zeile 52: Zeile 52:
 activeFolderSearchers = new AtomicInteger(0); activeFolderSearchers = new AtomicInteger(0);
 Thread t = new FolderSearcher(rootDir); Thread t = new FolderSearcher(rootDir);
-t.start();+ 
 +// incrementAndGet() muss vor dem Starten kommen!
 activeFolderSearchers.incrementAndGet(); activeFolderSearchers.incrementAndGet();
 +t.start();
 +
 //t.join(); //t.join();
 </code> </code>
Zeile 59: Zeile 62:
 **b)** **b)**
 <code java> <code java>
-if(file.isDirectory){ +if(file.isDirectory()) { 
-Thread t = new FolderSearcher(file); +  Thread t = new FolderSearcher(file); 
-activeFolderSearchers.incrementAndGet(); +  activeFolderSearchers.incrementAndGet(); 
-t.start(); +  t.start(); 
-} else if(file.isFile()){  +} else if(file.isFile()) { 
- pool.submit(new FileSearcher(file)); +  pool.submit(new FileSearcher(file));
-  }+
 } }
 </code> </code>
Zeile 71: Zeile 73:
 **c)** **c)**
 <code java> <code java>
-activeFolderSearchers.decrementAndGet(); +int i = activeFolderSearchers.decrementAndGet(); 
-if(activeFolderSearchers.get() == 0){ +if(== 0){ 
- pool.shutdown(); // Shall only be called once!+  pool.shutdown(); // Shall only be called once!
 } }
 </code> </code>
 +
 +==== Aufgabe 4: Scala - Teilersummen ====
 +
 +**a)**
 +<code>
 +def construct: (Int => List[Int]) => (List[Int] => Int) => Int  => Int = 
 + f => s => n => s(f(n))
 +</code>
 +**b)**
 +<code>
 +def fss: Int => Stream[(Int, Int)] = n => (n, fs(n)) #:: fss(n+1)
 +</code>
 +**c)**
 +<code>
 +def count: (Int, Int) => Int = (n0, m) => fss(n0).take(m).foldLeft(0){
 +  (a, b) => if(b._1 > b._2) a+1 else a;
 +}
 +</code>
 +
  
 ==== Aufgabe 5: Schreibtischlauf ==== ==== Aufgabe 5: Schreibtischlauf ====
Zeile 95: Zeile 116:
  
   * The Universe:   * The Universe:
-  * Zeile 30 & 82:    synchronized(this)    =>    synchronized(map)+  * Zeile 30 & 82:    synchronized(this)    =>    synchronized(Bar.class)
  
 ====Aufgabe 6 (Scala - Ausgehende Kanten) ==== ====Aufgabe 6 (Scala - Ausgehende Kanten) ====
Zeile 112: Zeile 133:
  
  
 +
 +
 +==== Aufgabe 7 (Backtracking) ====
 +was hat das hier verloren? ich vermute mal magicSquare aus Aud ? :D
 +
 +[[pruefungen:bachelor:pfp:loesungws13:codezuraufgabe7|>>>code zum selber testen<<<]]
 +
 +**a)**
 +
 +<code java>
 +static boolean isSolved(int[][] sq) {
 + int n = sq.length;
 + int checkSum = ((n * n * n) + n) / 2;
 + int rowSum = 0, colSum = 0, diag1Sum = 0, diag2Sum = 0;
 +
 + for(int y= 0 ; y< n; y++){
 +
 + diag1Sum += sq[y][y];
 + diag2Sum += sq[n-1-y][n-1-y];
 +
 + for(int x=0; x < n ; x++){
 + rowSum += sq[y][x];
 + colSum += sq[x][y];
 + }
 +
 + if(rowSum != checkSum || colSum != checkSum)
 + return false;
 +
 + rowSum=colSum=0;
 + }
 +
 + if(diag1Sum != checkSum || diag2Sum != checkSum)
 + return false;
 +
 + return true;
 + }
 +
 +</code>
 +
 +**b)**
 +
 +<code java>
 + static boolean solve(int[][] sq, int pos, boolean[] used) {
 + int n = sq.length;
 + int col = pos % n;
 + int row = (pos - col) / n;
 +
 + // Basisfall
 + if(isSolved(sq))
 + return true;
 +
 + //Rekursion
 + for(int i=0; i < n*n; i++){
 + if(!used[i]){
 + used[i]=true;
 + int c=i+1;
 + sq[col][row]=c;
 +
 + if(solve(sq,pos+1,used))
 + return true;
 +
 + sq[col][row]=0;
 + used[i]=false;
 + }
 + }
 + return false;
 + }
 +</code>