Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Lösungsversuch   (Ü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:loesungws14 [23.07.2015 14:51] – ThiloKpruefungen:bachelor:pfp:loesungws14 [21.07.2018 19:41] (aktuell) – evren
Zeile 35: Zeile 35:
 ^ ^ Ausgabe (MyThread1) ^ Ausgabe (MyThread2) ^ ^ ^ Ausgabe (MyThread1) ^ Ausgabe (MyThread2) ^
 | Möglichkeit 1 | T1 = done. | T2 = done. | | Möglichkeit 1 | T1 = done. | T2 = done. |
-| ... | T1 = done. | |+| ... | T1 = done. | T2 = |
 Begründung: Begründung:
 value ist nicht volatile, durch Sichbarkeitsprobleme kann es hier zu einem Deadlock kommen, nämlich gerade dann wenn MyThread2 nichts von der Änderung in MyThread1 mitbekommt. value ist nicht volatile, durch Sichbarkeitsprobleme kann es hier zu einem Deadlock kommen, nämlich gerade dann wenn MyThread2 nichts von der Änderung in MyThread1 mitbekommt.
Zeile 44: Zeile 44:
  
 **b)** **b)**
-Keine Zyklen, aus denen man nicht mehr heraus kommt!+Wenn irgendwann einmal wieder jede Transition (t1 - t4) schalten/feuern kann, dann ist ein Petri-Netz lebendig, wenn nicht, dann nicht. ;) 
 + 
 +Beispiele für ein **nicht** lebendiges Petri-Netz:\\ 
 +- Eine Belegung [x, y, z] in einem Erreichbarkeitsgraphen aus dem keine Pfeile gehen (Deadlock)\\ 
 +- Zyklus in dem nicht alle möglichen Belegungen erreicht werden (Lifelock)\\
  
 **c)** **c)**
Zeile 101: Zeile 105:
  }  }
  // add values of count to globalCounts 3  // add values of count to globalCounts 3
- for (int i = begin; i < end; i++) { + for (int i = 0; i < 256; i++) { 
- globalCounts.addAndGet(i, count[array[i] + 128]);+ globalCounts.addAndGet(i, count[i]);
  }  }
  barrier.await();  barrier.await();
Zeile 110: Zeile 114:
   }   }
 </code> </code>
 +\\ 
 +(ich glaube im oberen Code ist ein barrier.await() zu viel) \\ 
 +Alternativlösung: \\ 
 +1: 
 +<code java> 
 +this.barrier = new CyclicBarrier(threads + 1); 
 +</code> 
 +\\ 
 +2: 
 +<code java> 
 +for (int i = 0; i < thread; i++) { 
 +    int end = start + step; 
 +    if (end >= array.length) end = array.length - 1; 
 +     
 +    (new CountingThread(start, end)).start(); 
 +     
 +    start = end + 1; 
 +    if (i != array.length - 1 && start >= array.length) { 
 +        threads = i; 
 +        barrier = new CyclicBarrier(i + 1); 
 +        break; 
 +    } 
 +} 
 +</code> 
 +\\ 
 +3: 
 +<code java> 
 +for (int i = 0; i < count.length; i++) globalCounts.addAndGet(i, count[i]); 
 +</code> 
 +\\ 
 +4 (nur oberes Feld): 
 +<code java> 
 +barrier.await(); 
 +</code> 
 +\\ 
 +\\
 ==== Aufgabe 5 (Scala - Listenoperationen) ==== ==== Aufgabe 5 (Scala - Listenoperationen) ====
 **a)** **a)**
-<code>+<code scala>
   def flatten : List[(Char, Char)] => List[Char] = {   def flatten : List[(Char, Char)] => List[Char] = {
       case Nil => List()       case Nil => List()
       case t :: ts => List(t._1, t._2) ::: flatten(ts)       case t :: ts => List(t._1, t._2) ::: flatten(ts)
   }   }
 +</code>
 +
 +Alternativlösung:
 +<code scala>
 +def flatten : List[(Char, Char)] => List[Char] = {
 +    case Nil => Nil
 +    case (a, b) :: tailList => a :: List(b) ::: flatten(tailList)
 +}
 </code> </code>
  
 **b)** **b)**
-<code>+<code scala>
   def countPar : List[Char] => List[(Char, Int)] = cs => {   def countPar : List[Char] => List[(Char, Int)] = cs => {
       for (c <- cs) yield (c, cs.par.filter(_ == c).size)       for (c <- cs) yield (c, cs.par.filter(_ == c).size)
Zeile 128: Zeile 175:
  
 **c)** **c)**
-<code>+<code scala>
   def distinct : List[(Char, Int)] => List[(Char, Int)] = cs => {   def distinct : List[(Char, Int)] => List[(Char, Int)] = cs => {
       cs.foldLeft(List[(Char, Int)]())((ls, c) => if (ls.contains(c)) ls else c :: ls)       cs.foldLeft(List[(Char, Int)]())((ls, c) => if (ls.contains(c)) ls else c :: ls)
Zeile 136: Zeile 183:
 ==== Aufgabe 6 (Scala - Lauflängenkodierung) ==== ==== Aufgabe 6 (Scala - Lauflängenkodierung) ====
 **a)** **a)**
-<code> +<code scala> 
-  def decodeTupel: ((Char, Int)) => Stream[Char] = { +def decodeTuple: ((Char, Int)) => Stream[Char] = { 
-      case (c, 1) => Stream(c) +    case (c, 1) => Stream(c) 
-      case (c, k) => c #:: decodeTupel(c, k - 1) +    case (c, k) => c #:: decodeTuple(c, k - 1) 
-  }+}
 </code> </code>
  
 **b)** **b)**
-<code> +Geht für ''decode(Stream())'' und ''decode(Stream( ('a', 3) )).toList'' kaputt: 
-  def decode: Stream[(Char, Int)] => Stream[Char] = { +<code scala> 
-      case null => Stream() +def decode: Stream[(Char, Int)] => Stream[Char] = { 
-      case ts => decodeTupel(ts.head) #::: decode(ts.tail) +    case null => Stream() 
-  }+    case ts => decodeTuple(ts.head) #::: decode(ts.tail) 
 +} 
 +</code> 
 +Alternativlösungen: 
 +<code scala> 
 +def decode: Stream[(Char, Int)] => Stream[Char] = { 
 +  case Stream.Empty => Stream.Empty 
 +  case ts => decodeTuple(ts.head) #::: decode(ts.tail) 
 +} 
 +</code> 
 +<code scala> 
 +def decode: Stream[(Char, Int)] => Stream[Char] = { 
 +    case Stream.Empty => Stream.Empty 
 +    case first #:: tailList => decodeTuple(first) #::: decode(tailList) 
 +}
 </code> </code>