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 09: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(i == 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 / Graphen faerben ==== +====Aufgabe 6 (Scala - Ausgehende Kanten) ====
-**a)** +
  
-  def getFreeColor: List[Color] => Color = c => { +*a) 
-    def helper : (List[Color], Int) => Color = { + def outEdges: (List[V],G) => List[E] = (vs,g) => 
-      case (Nil,n) => n + g.par.filter(x => vs.contains(x._1) && !vs.contains(x._2)).toList 
-      case (cs,n) => if(!cs.contains(n)) n else helper(cs,n+1) +*b) 
-    } + def tree: (V,G) => G = (v,g) => { 
-  helper(c,0) +    def helper: List[V] => G = vs =>{ 
-  }+      val a = outEdges(vs,g) 
 +      if(a==Nil)Nil else a.head::helper(a.head._2::vs) 
 +    } 
 +    helper(List(v)) 
 + }
  
  
-oder eleganter: 
  
  
-  def getFreeColor: List[Color] => Color = l => (for(i <- List.range(0, l.length + 1 ) if !l.contains(i))yield i).head+==== 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)** **b)**
-   def colorGraph: List[Node] => List[Coloring] => List[Coloring] = { 
-     case Nil => cols => cols 
-     case n::nod => cols => colorGraph(nod)(nextFreeColor(cols)(n)::cols) 
-   } 
  
 +<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>