a) falsch
b) richtig (z.B. durch Prüfe-Handle-Situationen)
c) falsch
d) falsch
e) richtig
f) Speedup = 6, Effizienz = 3/4
g) falsch (Null ist lediglich Untertyp aller AnyRef-Typen, Nothing ist Untertyp aller Scala-Typen)

a)

S: 
(1, 1, 0, 0, 0) (Traversiert)

M: 
(-1,  0,  0,  0,  1)
( 1,  2, -1, -1,  0)
( 0, -1,  1,  0,  0)
( 0, -1,  0,  1,  0)
( 0, -1,  0,  1, -1)

b) t1 → t4 → t3 → t5

c) Ja

d) E: (0, 7, 0, 0)

  import java.util.concurrent.*;
  public class ParallelPrefixSums {
	  private static CyclicBarrier barrier;
	  public static void calculateSums(int[] values) throws InterruptedException {
		  barrier = new CyclicBarrier(values.length);
		  Thread[] workers = new Thread[values.length];
		  for (int i = 0; i < values.length; i++) {
			  workers[i] = new Thread(new Worker(values, i));
			  workers[i].start();
		  }
		  for (int i = 0; i < values.length; i++) {
			  workers[i].join();
		  }
	  }
	  public static class Worker implements Runnable {
		  private int[] values;
		  private int index;
		  public Worker (int[] values, int index) {
			  this.values = values;
			  this.index = index;
		  }
		  public void run() {
			  try {
				  int distance = 1;
				  while (distance < values.length) {
					  barrier.await();
					  int target = index + distance;
					  int rem = values[index];
					  barrier.await();
					  if (target < values.length) {
						  values[target] += rem;
					  }
					  dist *= 2;
				  }
			  } catch (Exception e) {
				  e.printStackTrace();
			  }
		  } 
	  }
  }

sortAsc, sortDes waren nicht Teil der Aufgabe, sind aber zum Testen implementiert.

import System.{ currentTimeMillis => ct }

type Row = List[Int]
type Matrix = List[Row]

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 sortCols: Matrix => Matrix = m =>
  (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 sortRows: Matrix => Matrix = m =>{
   def helper: (Matrix, Int) => Matrix = {
     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) => sortDes(m)::helper(ms,n+1)
   }
   helper(m,0)
 }
 
 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 helper: (Matrix, Int) => Matrix ={
		   (m,n) => {
			   val a = sortHelper(0,m)(n)
		       if(a._1 == a._2) a._2 else helper(m,n+1)		   
		   	}
		   }
		   
 
 
 helper(m,0)
 }