Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Aufgabe 1 (Wissensfragen)   (Ü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:loesungws12 [23.07.2015 08:42] – ThiloKpruefungen:bachelor:pfp:loesungws12 [01.08.2017 19:45] (aktuell) – ab21ajus
Zeile 1: Zeile 1:
 ==== Aufgabe 1 (Wissensfragen) ==== ==== Aufgabe 1 (Wissensfragen) ====
   a) falsch   a) falsch
-  b) richtig (z.B. durch Prüfe-Handle-Situationen)+  b) richtig (z. B. durch Prüfe-Handle-Situationen)
   c) falsch   c) falsch
   d) falsch   d) falsch
Zeile 12: Zeile 12:
  
   S:    S: 
-  (1, 1, 0, 0, 0) (Traversiert)+  (1, 1, 0, 0, 0) (Transponiert)
      
   M:    M: 
Zeile 29: Zeile 29:
  
 ====Aufgabe 3 (Java - Präfixsumme) ==== ====Aufgabe 3 (Java - Präfixsumme) ====
-a) Gauß-Filter / Weichzeichner+a) Gauß-Filter / Weichzeichner (? -> eher Zeigerverdopplung)
 <code java> <code java>
-  import java.util.concurrent.*; +import java.util.concurrent.*; 
-  public class ParallelPrefixSums { + 
-   private static CyclicBarrier barrier; +public class ParallelPrefixSums { 
-   public static void calculateSums(int[] values) throws InterruptedException { + private static CyclicBarrier barrier; 
-   barrier = new CyclicBarrier(values.length); + public static void calculateSums(int[] values) throws InterruptedException { 
-   Thread[] workers = new Thread[values.length]; + barrier = new CyclicBarrier(values.length); 
-   for (int i = 0; i < values.length; i++) { + Thread[] workers = new Thread[values.length]; 
-   workers[i] = new Thread(new Worker(values, i)); + for (int i = 0; i < values.length; i++) { 
-   workers[i].start(); + workers[i] = new Thread(new Worker(values, i)); 
-   } + workers[i].start(); 
-   for (int i = 0; i < values.length; i++) { + } 
-   workers[i].join(); + for (int i = 0; i < values.length; i++) { 
-   } + workers[i].join(); 
-   } + } 
-   public static class Worker implements Runnable { + } 
-   private int[] values; + 
-   private int index; + public static class Worker implements Runnable { 
-   public Worker (int[] values, int index) { + private int[] values; 
-   this.values = values; + private int index; 
-   this.index = index; + public Worker (int[] values, int index) { 
-   } + this.values = values; 
-   public void run() { + this.index = index; 
-   try { + } 
-   int distance = 1; + public void run() { 
-   while (distance < values.length) { + try { 
-   barrier.await(); + int distance = 1; 
-   int target = index + distance; + while (distance < values.length) { 
-   int rem = values[index]; + barrier.await(); 
-   barrier.await(); + int target = index + distance; 
-   if (target < values.length) { + int rem = values[index]; 
-   values[target] += rem; + barrier.await(); 
-   } + if (target < values.length) { 
-   dist *= 2; + values[target] += rem; 
-   } + } 
-   } catch (Exception e) { + dist *= 2; 
-   e.printStackTrace(); + } 
-   } + } catch (Exception e) { 
-   }  + e.printStackTrace(); 
-   } + } 
-  }+ } 
 + } 
 +}
 </code> </code>
  
 +==== Aufgabe 4 (Schreibtischlauf - Barrieren) ====
  
-====Aufgabe 6 (Scala - Snake-Sort) ====+  * a) a = 1, weil sowohl a++ als auch die System.out.println-Ausgabe in einem synchronized-Block stehen und beide Threads auf dieselbe Marke synchronisieren. 
 +  * b) Mögliche Ausgaben sind:
  
-sortAsc, sortDes waren nicht Teil der Aufgabe, sind aber zum Testen implementiert.+<code> 
 +a=1 
 +a=2 
 +a=3 
 +Threads 1, 2, 3 started. 
 +</code>
  
 +Und
  
-  import System.{ currentTimeMillis => ct }+<code> 
 +a=1 
 +a=2 
 +Threads 1, 2, 3 started. 
 +a=3 
 +</code> 
 + 
 +Der Main-Thread synchronisiert nicht auf irgendeine Marke (insb. nicht auf BarrierTest.class), daher erscheinen ihm die synchronized-Blöcke der Threads nicht als unteilbare Einheit und er kann bereits nach a++, aber vor System.out.println die While-Schleife verlassen. 
 + 
 +  * c) 1, 2, 3, oder 4 Mal. Jeder Thread könnte gleichzeitig b=0 am Anfang feststellen oder erst prüfen, nachdem die anderen Threads (oder ein Teil davon) das IF verlassen. 
 +  * d) Vorletzte oder letzte Zeile. Der CountDownLatch ist nur mit 3 initialisiert worden. Daher kann sich der letzte Thread irgendwo zwischen barrier.await() und latch.countDown() befinden. 
 + 
 + 
 +==== Aufgabe 5 (Scala - Snake-Sort) ==== 
 + 
 +sortAsc, sortDes waren nicht Teil der Aufgabe, sind aber zum Testen implementiert. 
 + 
 +<code=Scala> 
 +import System.{ currentTimeMillis => ct }
  
-  type Row = List[Int] +type Row = List[Int] 
-  type Matrix = List[Row]+type Matrix = List[Row]
      
-  def sortAsc: Row => Row = rs => if(rs == Nil) Nil else rs.min :: sortAsc(rs.filter(_ > rs.min)) +def sortAsc: Row => Row = rs => if(rs == Nil) Nil else rs.min :: sortAsc(rs.filter(_ > rs.min)) 
-  def sortDes: Row => Row = rs => if(rs == Nil) Nil else rs.max :: sortDes(rs.filter(_ < rs.max))+def sortDes: Row => Row = rs => if(rs == Nil) Nil else rs.max :: sortDes(rs.filter(_ < rs.max))
      
  
-  def sortCols: Matrix => Matrix = m => +def sortCols: Matrix => Matrix = m => 
-    (for(col <- m.transpose) yield sortAsc(col)).toList.transpose+  (for(col <- m.transpose) yield sortAsc(col)).toList.transpose
          
-  def sortColsPar: Matrix => Matrix = m => (for(col<- m.transpose.par) yield sortAsc(col)).toList.transpose // Parallelität ist fragwürdig+def sortColsPar: Matrix => Matrix = m => (for(col<- m.transpose.par) yield sortAsc(col)).toList.transpose 
 +   
 +// Alternativ (laut #Scala ist die Paralleliät bei beiden äquivalent gegeben): 
 +     
 +def sortColsPar2: Matrix => Matrix = m => m.transpose.par.map(sortAsc(_)).toList.transpose
     
-   def sortRows: Matrix => Matrix = m =>{ +def sortRows: Matrix => Matrix = m =>{ 
-     def helper: (Matrix, Int) => Matrix = { +  def helper: (Matrix, Int) => Matrix = { 
-       case (Nil, n) => Nil +    case (Nil, n) => Nil 
-       case (m::ms, n) if(n % 2 == 0) => sortAsc(m)::helper(ms,n+1) +    case (m::ms, n) if(n % 2 == 0) => sortAsc(m)::helper(ms,n+1) 
-       case (m::ms, n) if(n % 2 != 0) => sortDes(m)::helper(ms,n+1) +    case (m::ms, n) if(n % 2 != 0) => sortDes(m)::helper(ms,n+1) 
-     } +  } 
-     helper(m,0) +  helper(m,0) 
-   } +} 
-    + 
-   def sortHelper: (Int, Matrix) => Stream[(Matrix,Matrix)] = {  +//Alternative ohne Helfer-Funktion: 
-     case (n,m) =>  if (n%2==0) (m, sortRows(m)) #::sortHelper(n+1,sortRows(m)) else (m,sortCols(m)) #::sortHelper(n+1,sortCols(m))      +  def sortRows2: Matrix => Matrix = m => m match { 
-   }+    case Nil => Nil 
 +    case (row::m)  => if (m.length % 2 == 0) 
 +                          sortAsc(row)::sortRows2(m) 
 +                     else  
 +                          sortDes(row)::sortRows2(m) 
 +  } 
 + 
 + 
 +def sortHelper: (Int, Matrix) => Stream[(Matrix,Matrix)] = {  
 +  case (n,m) =>  if (n%2==0) (m, sortRows(m)) #::sortHelper(n+1,sortRows(m)) else (m,sortCols(m)) #::sortHelper(n+1,sortCols(m))      
 +}
      
-   def snakeSort: Matrix => Matrix = m => { +def snakeSort: Matrix => Matrix = m => { 
-    def helper: (Matrix, Int) => Matrix ={ +  def helper: (Matrix, Int) => Matrix = (m,n) => { 
-    (m,n) => { +      val a = sortHelper(0,m)(n) 
-    val a = sortHelper(0,m)(n) +      if(a._1 == a._2) a._2 else helper(m,n+1)     
-        if(a._1 == a._2) a._2 else helper(m,n+1)     +  } 
-     } +  helper(m,0) 
-    } +} 
-     +</code> 
-    + 
-    +==== Aufgabe 6 ==== 
-   helper(m,0) +Nicht mehr Teil des Vorlesungsstoffes. 
-   }+