Version 1.0.0 (2024-12-29): Material ZPG (2019)

04_loesungen/01_processing/alg03b_figuren_loesung/figuren/figuren.pde

@@ -0,0 +1,38 @@
+
+void zeichneBildC() {
+  // Zeichne dir zunächst eine Skizze auf ein Blatt Papier und überlege dir, welche
+  // Werte du den Methoden rect(x,y,b,h) und ellipse(x,y,b,h) übergeben musst, 
+  // dass Bild C gezeichnet wird
+
+  // ***** hier kommen deine Anweisungen hin ************
+  rect(10, 10, 100, 100);
+
+  ellipse(60, 60, 80, 80);
+  ellipse(60, 60, 60, 60);
+  ellipse(60, 60, 40, 40);
+
+  ellipse(60, 170, 100, 100);
+
+  rect(30, 140, 60, 60);
+  rect(40, 150, 40, 40);
+  rect(50, 160, 20, 20);
+
+  // ***** Ende der eigenen Anweisungen **********
+}
+
+void zeichneBildA() {
+  
+  ellipse(260, 60, 100, 100);
+
+  rect(210, 110, 100, 100);
+
+  triangle(210, 300, 310, 300, 260, 210);
+  
+}
+
+
+void setup() {
+  size(500, 350); // Festlegen der Fenstergröße
+  zeichneBildC(); // Aufruf deiner Methode
+  zeichneBildA();
+}

04_loesungen/01_processing/alg04_figurC_mitSchleife_loesung/figurC_mitSchleife/figurC_mitSchleife.pde

@@ -0,0 +1,16 @@
+void zeichneBildC() {
+  rect(10, 10, 100, 100);
+  for (int i=0; i<=2; i++) {
+    ellipse(60, 60, 80-i*20, 80-i*20);
+  }
+
+  ellipse(60, 170, 100, 100);
+  for (int i=0; i<=2; i++) {
+    rect(30+i*10, 140+i*10, 60-i*20, 60-i*20);
+  }
+}
+
+void setup() {
+  size(120, 250);
+  zeichneBildC();
+}

04_loesungen/01_processing/alg04_uebungen_loesung/zehn_quadrate/zehn_quadrate.pde

@@ -0,0 +1,17 @@
+void zeichneQuadrate() {
+  for (int i=0; i<=9; i++) {
+    rect(30+i*30, 50, 30, 30);
+  }
+}
+
+void zeichneKreise() {
+  for (int i=0; i<=19; i++) {
+    ellipse(200, 200, 200-i*10, 200-i*10);
+  }
+}
+
+void setup() {
+  size(400, 400);
+  zeichneQuadrate();
+  zeichneKreise();
+}

04_loesungen/01_processing/alg04_uebungen_loesung/zehn_quadrate_differenziert/zehn_quadrate_differenziert.pde

@@ -0,0 +1,17 @@
+void zeichneQuadrate() {
+  for (int i=0; i<=9; i++) {
+    rect(30+i*30, 50, 30, 30);
+  }
+}
+
+void zeichneKreise() {
+  for (int i=0; i<=19; i++) {
+    ellipse(200, 200, 200-i*10, 200-i*10);
+  }
+}
+
+void setup() {
+  size(400, 400);
+  zeichneQuadrate();
+  zeichneKreise();
+}

04_loesungen/01_processing/alg04_uebungen_loesung/zehn_quadrate_differenziert2/zehn_quadrate_differenziert2.pde

@@ -0,0 +1,17 @@
+void zeichneQuadrate(int anz, int s) { // Anzahl der Quadrate und Seitenlänge werden übergeben
+  for (int i=0; i<=anz-1; i++) {
+    rect(30+i*s, 50, s, s);
+  }
+}
+
+void zeichneKreise(int anz, int d) {  // Anzahl der Kreise und Abstand werden übergeben
+  for (int i=0; i<=anz-1; i++) {
+    ellipse(200, 200, 200-i*d, 200-i*d);
+  }
+}
+
+void setup() {
+  size(800, 400);
+  zeichneQuadrate(20, 10);
+  zeichneKreise(10, 5);
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer1/nummer1.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 300);
+
+  // Nummer 1
+
+  for (int i=0; i<10; i++) {
+    ellipse(50+i*50, 50, 50, 50);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer2/nummer2.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 2
+
+  for (int i=0; i<10; i++) {
+    ellipse(50+i*50, 50+i*25, 50, 50);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer3/nummer3.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 3
+
+  for (int i=0; i<10; i++) {
+    ellipse(100, 100, 110-i*10, 110-i*10);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer4/nummer4.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 4
+
+  for (int i=0; i<20; i++) {
+    ellipse(100+i*10, 100+i*10, 200-i*10, 200-i*10);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer5/nummer5.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 5
+
+  for (int i=0; i<5; i++) {
+    rect(10+i*60, 10, 50, 40);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer6/nummer6.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 6
+
+  for (int i=0; i<5; i++) {
+    rect(10+i*60, 10+i*40, 50, 40);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/nummer7/nummer7.pde

@@ -0,0 +1,10 @@
+void setup() {
+
+  size(600, 400);
+
+  // Nummer 7
+
+  for (int i=0; i<10; i++) {
+    rect(10, 10, 100-i*10, 100-i*10);
+  }
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle/puzzle.pde

@@ -0,0 +1,40 @@
+void setup(){
+
+  size(600,400);
+  
+  // Nummer 1 
+  for (int i=0; i<10; i++){
+    ellipse(50+i*50,100,50,50);
+  }
+  
+  // Nummer 2
+  for (int i=0; i<10; i++) {
+    ellipse(50+i*50, 50+i*25, 50, 50);
+  }
+  
+  // Nummer 3
+  for (int i=0; i<10; i++) {
+    ellipse(100, 100, 110-i*10, 110-i*10);
+  }
+  
+  // Nummer 4
+  for (int i=0; i<20; i++) {
+    ellipse(100+i*10, 100+i*10, 200-i*10, 200-i*10);
+  }
+  
+  // Nummer 5
+  for (int i=0; i<5; i++) {
+    rect(10+i*60, 10, 50, 40);
+  }
+  
+  // Nummer 6
+  for (int i=0; i<5; i++) {
+    rect(10+i*60, 10+i*40, 50, 40);
+  }
+  
+  // Nummer 7
+  for (int i=0; i<10; i++) {
+    rect(10, 10, 100-i*10, 100-i*10);
+  }
+  
+}

04_loesungen/01_processing/alg04_zaehlschleife_puzzle_loesung/puzzle_alle/puzzle_alle.pde

@@ -0,0 +1,47 @@
+void setup(){
+
+  size(1000,700);
+  
+  // Nummer 1
+  
+  for (int i=0; i<10; i++){
+    ellipse(50+i*50,100,50,50);
+  }
+  
+  // Nummer 2
+  
+  for (int i=0; i<10; i++){
+    ellipse(50+i*50,200+i*25,50,50);
+  }
+  
+  // Nummer 3
+  
+  for (int i=0; i<10; i++){
+    ellipse(200,400,110-i*10,110-i*10);
+  }
+  
+  // Nummer 4
+  
+  for (int i=0; i<20; i++){
+    ellipse(700+i*10,300+i*10,200-i*10,200-i*10);
+  }
+  
+  // Nummer 5
+  
+  for (int i=0; i<5; i++){
+    rect(10+i*60,500,50,40);
+  }
+  
+  // Nummer 6
+  
+  for (int i=0; i<5; i++){
+    rect(10+i*60, 500+i*40, 50,40);
+  }
+  
+  // Nummer 7
+  
+  for (int i=0; i<10; i++){
+    rect(500,500,100-i*10, 100-i*10);
+  }
+
+}

04_loesungen/01_processing/alg05_kaffeehaus_loesungen/kaffeehaus/kaffeehaus.pde

@@ -0,0 +1,50 @@
+// globale Variablen
+int s = 40; // Seitenlänge der Quadrate bzw. Abstand der Parallelen
+
+int[] abstaende = {10, 20, 30, 20, 10, 20, 30, 20, 10}; // Abstände des 1. Quadrates nach links
+
+void parallelen(){ // zeichnet 10 graue Parallelen
+  stroke(125); // Linienfarbe Graustufe
+  for (int i=0; i<=9; i++){
+    line(0,5+i*s, 640, 5+i*s);
+  }
+}
+
+void zeichneAlleQuadrate(){
+  fill(0); // Füllfarbe schwarz
+  for (int j=0; j<=8; j++){
+    for (int i=0; i<=7; i++){
+      // rect(10+2*s*i,5+j*s,s,s);  // Abstand bei allen Reihen gleich: d=10
+      rect(abstaende[j]+2*s*i, 5+j*s, s, s);  // Abstand wird jeweils aus dem Feld gelesen
+    }
+  }
+}
+
+void setup(){
+  size(640, 400);
+  background(255); // Hintergrund weiß
+  parallelen();  // Aufruf der Methode zum Zeichnen der Parallelen
+  zeichneAlleQuadrate();
+  //zeichneQuadrate(); // Aufruf der Methode zum Zeichnen der Quadrate
+}
+
+
+
+
+void zeichneQuadrate(){
+  fill(0);  // Füllfarbe schwarz
+  // fülle die erste Reihe mit Quadraten
+  for (int i=0; i<=7; i++){
+    rect(10+2*s*i,5,s,s);
+  }
+
+  // fülle die zweite Reihe mit Quadraten
+  for (int i=0; i<=7; i++){
+    rect(20+2*s*i,5+s,s,s);
+  }
+  
+  // fülle die dritte Reihe mit Quadraten
+  for (int i=0; i<=7; i++){
+    rect(30+2*s*i,5+2*s,s,s);
+  }
+}

04_loesungen/01_processing/alg06_uebungen_loesungen/hermann_gitter_1/hermann_gitter_1.pde

@@ -0,0 +1,20 @@
+// globale Variablen
+int s = 30; // Seitenlaenge Quadrat
+int a = 10; // Abstand Quadrate
+
+// Methode, die optische Täuschung zeichnet
+void quadrate() {
+  fill(0); // Füllfarbe schwarz
+  for (int j=0; j<=6; j++) {
+    for (int i=0; i<=6; i++) {
+      rect(30+i*(s+a), 30+j*(s+a), s, s);
+    }
+  }
+}
+
+// setup-Methode
+void setup() {
+  size(500, 500);
+  background(255); // Hintergrund weiß
+  quadrate();
+}

04_loesungen/01_processing/alg06_uebungen_loesungen/hermann_gitter_2/hermann_gitter_2.pde

@@ -0,0 +1,33 @@
+// globale Variablen
+int s = 50; // Seitenlaenge Quadrat
+int a = 15; // Abstand Quadrate
+int start = 30; // Abstand zum Rand
+
+// Methode, die schwarze Quadrate zeichnet
+void quadrate() {
+  fill(0);
+  for (int i=0; i<=6; i++) {
+    for (int j=0; j<=6; j++) {
+      rect(start+j*(s+a), start+i*(s+a), s, s);
+    }
+  }
+}
+
+// Methode, die weiße Kreise zeichnet
+void kreise() {
+  fill(255);
+  noStroke(); // keine Umrandung
+  for (int j=0; j<6; j++) {
+    for (int i=0; i<6; i++) {
+      ellipse(start+s+a/2+(s+a)*i, start+s+a/2+(s+a)*j, a+2, a+2);
+    }
+  }
+}
+
+// setup-Methode
+void setup() {
+  size(500, 500);
+  background(66, 165, 250);  // Hintergrundfarbe hellblau
+  quadrate();
+  kreise();
+}

04_loesungen/01_processing/alg07a_wellen1_loesungen/wellen1/wellen1.pde

@@ -0,0 +1,83 @@
+// globale Variable
+int s = 40; // Seitenlänge der Quadrate
+
+void zeichneQuadrat(int x, int y, int farbe, boolean links) {
+  fill(farbe); // der übergebene Wert der Variable farbe wird als Füllfarbe übergeben
+  rect(x, y, s, s); // ein Quadrat mit Seitenlänge s wird an der Position (x|y) gezeichnet
+
+  // Farbauswahl Kreise
+  if (farbe == 255) {  // Quadrat ist weiß
+    fill(0); // Füllfarbe schwarz wird gewählt
+  } else {  // Quadrat ist nicht weiß (schwarz)
+    fill(255);  // Füllfarbe weiß wird gewählt
+  }
+
+  // Zeichnen der beiden kleinen Kreise
+  ellipseMode(CORNERS);
+  noStroke();
+  int d = s/4;
+  if (links == true) {
+    ellipse(x, y, x+d, y+d);  // links oben
+    ellipse(x, y + 3*d, x+d, y+s); // links unten
+  } else {
+    ellipse(x + 3*d, y, x+s, y+d);  // rechts oben
+    ellipse(x + 3*d, y + 3*d, x+ s, y+s);  // rechts unten
+  }
+}
+
+void alleQuadrate() {
+  noStroke();
+  // erste Reihe
+  int aktuellefarbe = 255; // Farbe des ersten Quadrates ist weiß
+  for (int i=0; i<=7; i++) {
+    zeichneQuadrat(i*s, 0, aktuellefarbe, true);
+    // Farbwechsel für nächstes Quadrat
+    if (aktuellefarbe == 255) {
+      aktuellefarbe = 0;
+    } else {
+      aktuellefarbe = 255;
+    }
+  }
+  // zweite Reihe
+  aktuellefarbe = 0; // Farbe des ersten Quadrates ist schwarz
+  for (int i=0; i<=7; i++) {
+    zeichneQuadrat(i*s, s, aktuellefarbe, false);
+    // Farbwechsel für nächstes Quadrat
+    if (aktuellefarbe == 255) {
+      aktuellefarbe = 0;
+    } else {
+      aktuellefarbe = 255;
+    }
+  }
+    // dritte Reihe
+  aktuellefarbe = 255; // Farbe des ersten Quadrates ist weiß
+  for (int i=0; i<=7; i++) {
+    zeichneQuadrat(i*s, 2*s, aktuellefarbe, true);
+    // Farbwechsel für nächstes Quadrat
+    if (aktuellefarbe == 255) {
+      aktuellefarbe = 0;
+    } else {
+      aktuellefarbe = 255;
+    }
+  }
+  // vierte Reihe
+  aktuellefarbe = 0; // Farbe des ersten Quadrates ist schwarz
+  for (int i=0; i<=7; i++) {
+    zeichneQuadrat(i*s, 3*s, aktuellefarbe, false);
+    // Farbwechsel für nächstes Quadrat
+    if (aktuellefarbe == 255) {
+      aktuellefarbe = 0;
+    } else {
+      aktuellefarbe = 255;
+    }
+  }
+}
+
+void setup() {
+  size(600, 400);
+  // Test Zeichnen zweier Quadrate
+  // zeichneQuadrat(100, 100, 0, true);
+  // zeichneQuadrat(100, 200, 255, false);
+  // Zeichnen der optischen Täuschung
+  alleQuadrate();
+}

04_loesungen/01_processing/alg07a_wellen1_loesungen/wellen1_ab_aufgabe20/wellen1_ab_aufgabe20.pde

@@ -0,0 +1,85 @@
+// globale Variable
+int s = 40; // Seitenlänge der Quadrate
+int a = 2; // Abstand Kreise - Quadratrand
+int d = 20; // Abstand der optischen Täuschung zum Rand
+
+int farbwechsel (int farbe) {
+  if (farbe == 255) { // Farbe ist weiß
+    farbe = 0;
+  } else {  // Farbe ist nicht weiß
+    farbe = 255;
+  }
+  return farbe;
+}
+
+
+
+void zeichneQuadrat(int x, int y, int farbe, boolean links) {
+  fill(farbe); // der übergebene Wert der Variable farbe wird als Füllfarbe übergeben
+  rect(x, y, s, s); // ein Quadrat mit Seitenlänge s wird an der Position (x|y) gezeichnet
+
+  // Farbauswahl Kreise
+  if (farbe == 255) {  // Quadrat ist weiß
+    fill(0); // Füllfarbe schwarz wird gewählt
+  } else {  // Quadrat ist nicht weiß (schwarz)
+    fill(255);  // Füllfarbe weiß wird gewählt
+  }
+
+  // Zeichnen der beiden kleinen Kreise
+  ellipseMode(CORNERS);
+  noStroke();
+  int d = s/4;
+  if (links == true) {
+    ellipse(x+a, y+a, x+d+a, y+d+a);  // links oben
+    ellipse(x+a, y + 3*d-a, x+d+a, y+s-a); // links unten
+  } else {
+    ellipse(x + 3*d-a, y+a, x+s-a, y+d+a);  // rechts oben
+    ellipse(x + 3*d-a, y + 3*d-a, x+ s-a, y+s-a);  // rechts unten
+  }
+}
+
+void alleQuadrate() {
+  noStroke();
+  int aktuellefarbe = 255; // Farbe des ersten Quadrates ist weiß
+  boolean pos_aktuell = true; // Kreise sind zunächst links
+  for (int j=0; j<=3; j++) {
+    for (int i=0; i<=7; i++) {
+      zeichneQuadrat(d + i*s, d + j*s, aktuellefarbe, pos_aktuell);
+      // Farbwechsel für nächstes Quadrat
+      if (aktuellefarbe == 255) {
+        aktuellefarbe = 0;
+      } else {
+        aktuellefarbe = 255;
+      }
+    } // end Zeichnen einer Reihe
+    // Wechsel Startfarbe
+    if (aktuellefarbe == 255) {
+      aktuellefarbe = 0;
+    } else {
+      aktuellefarbe = 255;
+    }
+    // Wechsel Position der Kreise
+    if (pos_aktuell == true) {
+      pos_aktuell = false;
+    } else {
+      pos_aktuell = true;
+    }
+  }
+
+  //zeichne die drei Linien zwischen die Quadrate
+  for (int i=0; i<=2; i++) {
+    stroke(8, 250, 78);  // Linienfarbe hellgrün
+    strokeWeight(2);
+    line(d, d + s + s*i, d + 8*s, d + s + s*i);
+  }
+}
+
+void setup() {
+  size(600, 400);
+  background(#FAA317);
+  // Test Zeichnen zweier Quadrate
+  // zeichneQuadrat(100, 100, 0, true);
+  // zeichneQuadrat(100, 200, 255, false);
+  // Zeichnen der optischen Täuschung
+  alleQuadrate();
+}

04_loesungen/01_processing/alg07a_wellen1_loesungen/wellen1_mit_farbwechsel/wellen1_mit_farbwechsel.pde

@@ -0,0 +1,68 @@
+// globale Variable
+int s = 40; // Seitenlänge der Quadrate
+int a = 2; // Abstand Kreise - Quadratrand
+int d = 20; // Abstand der optischen Täuschung zum Rand
+
+int farbwechsel (int farbe) {
+  if (farbe == 255) { // Farbe ist weiß
+    farbe = 0;
+  } else {  // Farbe ist nicht weiß
+    farbe = 255;
+  }
+  return farbe;
+}
+
+void zeichneQuadrat(int x, int y, int farbe, boolean links) {
+  fill(farbe); // der übergebene Wert der Variable farbe wird als Füllfarbe übergeben
+  rect(x, y, s, s); // ein Quadrat mit Seitenlänge s wird an der Position (x|y) gezeichnet
+
+  // Farbauswahl Kreise
+  fill(farbwechsel(farbe));
+
+  // Zeichnen der beiden kleinen Kreise
+  ellipseMode(CORNERS);
+  noStroke();
+  int d = s/4;
+  if (links == true) {
+    ellipse(x+a, y+a, x+d+a, y+d+a);  // links oben
+    ellipse(x+a, y + 3*d-a, x+d+a, y+s-a); // links unten
+  } else {
+    ellipse(x + 3*d-a, y+a, x+s-a, y+d+a);  // rechts oben
+    ellipse(x + 3*d-a, y + 3*d-a, x+ s-a, y+s-a);  // rechts unten
+  }
+}
+
+void alleQuadrate() {
+  noStroke();
+  int aktuellefarbe = 255; // Farbe des ersten Quadrates ist weiß
+  boolean pos_aktuell = true; // Kreise sind zunächst links
+  for (int j=0; j<=3; j++) {
+    for (int i=0; i<=7; i++) {
+      zeichneQuadrat(d + i*s, d + j*s, aktuellefarbe, pos_aktuell);
+      // Farbwechsel für nächstes Quadrat
+      aktuellefarbe = farbwechsel(aktuellefarbe);
+    } // end Zeichnen einer Reihe
+    // Wechsel Startfarbe
+    aktuellefarbe = farbwechsel(aktuellefarbe);
+    // Wechsel Position der Kreise
+    if (pos_aktuell == true) {
+      pos_aktuell = false;
+    } else {
+      pos_aktuell = true;
+    }
+  }
+
+  //zeichne die drei Linien zwischen die Quadrate
+  for (int i=0; i<=2; i++) {
+    stroke(8, 250, 78);  // Linienfarbe hellgrün
+    strokeWeight(2);
+    line(d, d + s + s*i, d + 8*s, d + s + s*i);
+  }
+}
+
+void setup() {
+  size(600, 400);
+  background(#FAA317);
+  // Zeichnen der optischen Täuschung
+  alleQuadrate();
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen2_fest/wellen2_fest.pde

@@ -0,0 +1,121 @@
+// globale Variable
+
+int s=40; // Seitenlaenge Quadrat
+int k=10; // Seitenlaenge kleines Quadrat
+int d=2; // Abstand kleine Quadrate zum Rand
+int f=0;  // Farbe: Start mit schwarz
+int[][] feld ={{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
+  {0, 0, 0, 0, 0, 0, 1, 5, 2, 0, 0, 0, 0, 0, 0}, 
+  {0, 0, 0, 0, 1, 1, 1, 5, 2, 2, 2, 0, 0, 0, 0}, 
+  {0, 0, 0, 1, 1, 1, 1, 5, 2, 2, 2, 2, 0, 0, 0}, 
+  {0, 0, 1, 1, 1, 1, 1, 5, 2, 2, 2, 2, 2, 0, 0}, 
+  {0, 0, 1, 1, 1, 1, 1, 5, 2, 2, 2, 2, 2, 0, 0}, 
+  {0, 1, 1, 1, 1, 1, 1, 5, 2, 2, 2, 2, 2, 2, 0}, 
+  {0, 3, 3, 3, 3, 3, 3, 0, 4, 4, 4, 4, 4, 4, 0}, 
+  {0, 2, 2, 2, 2, 2, 2, 6, 1, 1, 1, 1, 1, 1, 0}, 
+  {0, 0, 2, 2, 2, 2, 2, 6, 1, 1, 1, 1, 1, 0, 0}, 
+  {0, 0, 2, 2, 2, 2, 2, 6, 1, 1, 1, 1, 1, 0, 0}, 
+  {0, 0, 0, 2, 2, 2, 2, 6, 1, 1, 1, 1, 0, 0, 0}, 
+  {0, 0, 0, 0, 2, 2, 2, 6, 1, 1, 1, 0, 0, 0, 0}, 
+  {0, 0, 0, 0, 0, 0, 2, 6, 1, 0, 0, 0, 0, 0, 0}, 
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+
+// setup-Methode
+void setup() {
+  size(800, 800);
+  background(#F5E77C);
+  optischeTaeuschung();
+}
+
+
+void optischeTaeuschung(){
+  if(s/3 < k){
+    k = s/3;
+  }
+  for (int i=0; i<=14; i++) {
+    for (int j=0; j<=14; j++) {
+      zeichneQuadrat(10+i*s, 10+j*s, f, feld[i][j]);
+      f=255-f;
+    }
+  }
+}
+
+
+void zeichneQuadrat(int posX, int posY, int farbe, int art) {
+  fill(farbe);
+  noStroke();
+  rect(posX, posY, s, s);
+
+  // Position der kleinen Quadrate festlegen
+  boolean lo=false; 
+  boolean lu=false; 
+  boolean ro=false; 
+  boolean ru=false;
+  switch(art) {  // geht natürlich auch mit einer normalen Verzweigung
+  case 0:
+    lo=false; 
+    lu=false; 
+    ro=false; 
+    ru=false;
+    break;
+  case 1:
+    lo=false; 
+    lu=true; 
+    ro=true; 
+    ru=false;
+    break;
+  case 2:
+    lo=true; 
+    lu=false; 
+    ro=false; 
+    ru=true;
+    break;
+  case 3:
+    lo=false; 
+    lu=true; 
+    ro=false; 
+    ru=true;
+    break;
+  case 4:
+    lo=true; 
+    lu=false; 
+    ro=true; 
+    ru=false;
+    break;
+  case 5:
+    lo=false; 
+    lu=false; 
+    ro=true; 
+    ru=true;
+    break;
+  case 6:
+    lo=true; 
+    lu=true; 
+    ro=false; 
+    ru=false;
+    break;
+  }
+
+  // "Farbe" der kleinen Quadrate innen
+  fill(255-farbe); // Wechsel zwischen weiß und schwarz
+
+  zeichneKleineQuadrate(posX, posY, lo, lu, ro, ru);
+}
+
+void zeichneKleineQuadrate(int X, int Y, boolean lo0, boolean lu0, boolean ro0, boolean ru0) {
+  noStroke();
+
+  if (lo0 == true) {
+    rect(X+d, Y+d, k, k);
+  }
+  if (lu0 == true) {
+    rect(X+d, Y+s-k-d, k, k);
+  }
+  if (ro0 == true) {
+    rect(X+s-k-d, Y+d, k, k);
+  }
+  if (ru0 == true) {
+    rect(X+s-k-d, Y+s-k-d, k, k);
+  }
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen2_zufall/wellen2_zufall.pde

@@ -0,0 +1,106 @@
+// globale Variablen
+
+int s=40; // Seitenlaenge Quadrat
+int k=10; // Seitenlaenge kleines Quadrat
+int d=2; // Abstand kleine Quadrate zum Rand
+int f=0;  // Farbe: Start mit schwarz
+
+
+// setup-Methode
+void setup() {
+  size(800, 800);
+  background(#F5E77C);
+  optischeTaeuschung();
+}
+
+
+void optischeTaeuschung(){
+  if(s/3 < k){
+    k = s/3;
+  }
+  for (int i=0; i<=14; i++) {
+    for (int j=0; j<=14; j++) {
+      zeichneQuadrat(10+i*s, 10+j*s, f, round(random(0,6)));
+      f=255-f;
+    }
+  }
+}
+
+
+void zeichneQuadrat(int posX, int posY, int farbe, int art) {
+  fill(farbe);
+  noStroke();
+  rect(posX, posY, s, s);
+
+  // Position der kleinen Quadrate festlegen
+  boolean lo=false; 
+  boolean lu=false; 
+  boolean ro=false; 
+  boolean ru=false;
+  switch(art) {  // geht natürlich auch mit einer normalen Verzweigung
+  case 0:
+    lo=false; 
+    lu=false; 
+    ro=false; 
+    ru=false;
+    break;
+  case 1:
+    lo=false; 
+    lu=true; 
+    ro=true; 
+    ru=false;
+    break;
+  case 2:
+    lo=true; 
+    lu=false; 
+    ro=false; 
+    ru=true;
+    break;
+  case 3:
+    lo=false; 
+    lu=true; 
+    ro=false; 
+    ru=true;
+    break;
+  case 4:
+    lo=true; 
+    lu=false; 
+    ro=true; 
+    ru=false;
+    break;
+  case 5:
+    lo=false; 
+    lu=false; 
+    ro=true; 
+    ru=true;
+    break;
+  case 6:
+    lo=true; 
+    lu=true; 
+    ro=false; 
+    ru=false;
+    break;
+  }
+
+  // "Farbe" der kleinen Quadrate innen
+  fill(255-farbe); // Wechsel zwischen weiß und schwarz
+
+  zeichneKleineQuadrate(posX, posY, lo, lu, ro, ru);
+}
+
+void zeichneKleineQuadrate(int X, int Y, boolean lo0, boolean lu0, boolean ro0, boolean ru0) {
+  noStroke();
+
+  if (lo0 == true) {
+    rect(X+d, Y+d, k, k);
+  }
+  if (lu0 == true) {
+    rect(X+d, Y+s-k-d, k, k);
+  }
+  if (ro0 == true) {
+    rect(X+s-k-d, Y+d, k, k);
+  }
+  if (ru0 == true) {
+    rect(X+s-k-d, Y+s-k-d, k, k);
+  }
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen_b1_alle_reihen/wellen_b1_alle_reihen.pde

@@ -0,0 +1,50 @@
+// globale Variable
+int s=30; // Seitenlänge der Quadrate
+int d=5; // Abstand inneres Quadrat zum Rand
+int weiss = 255; 
+int gruen = #1CAF38;
+
+
+// setup-Methode
+void setup() {
+  size(700, 700);
+  background(255); // weißer Hintergrund
+  alleQuadrate();
+}
+
+void zeichneQuadrat(int x, int y, int rahmenfarbe) {
+
+  fill(rahmenfarbe); // Linienfarbe einstellen
+  noStroke();
+  rect(x, y, s, s); // Zeichnen des hinteren Quadrates
+
+  // Bestimmen der Farbe des inneren Quadrates
+  if (rahmenfarbe == weiss) {
+    fill(gruen);
+  } else {
+    fill(weiss);
+  }
+
+  rect(x+d, y+d, s-2*d, s-2*d); // Zeichnen des inneren Quadrates
+}
+
+void alleQuadrate(){
+  int farbe = gruen; // Festlegen der ersten Rahmenfarbe
+  for (int j=0; j<12; j++) { // j zählt die Reihen
+
+    for (int i=0; i<12; i++) {  // i zählt die Quadrate in einer Reihe
+      zeichneQuadrat(30+i*s, 30+j*s, farbe);
+      if (farbe == gruen) {  // du könntest hier wieder eine Methode Farbwechsel schreiben
+        farbe = weiss;
+      } else {
+        farbe = gruen;
+      }
+    }
+    // Wechsel der Farbe des ersten Quadrates für die nächste Reihe
+    if (farbe == gruen) {  // du könntest hier wieder eine Methode Farbwechsel schreiben
+      farbe = weiss;
+    } else {
+      farbe = gruen;
+    }
+  }
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen_b1_die_erste_reihe/wellen_b1_die_erste_reihe.pde

@@ -0,0 +1,42 @@
+// globale Variable
+int s=50; // Seitenlänge der Quadrate
+int d=5; // Abstand inneres Quadrat zum Rand
+int weiss = 255; 
+int gruen = #1CAF38;
+
+
+// setup-Methode
+void setup() {
+  size(700, 700);
+  background(255); // weißer Hintergrund
+  alleQuadrate();
+}
+
+void zeichneQuadrat(int x, int y, int rahmenfarbe) {
+
+  fill(rahmenfarbe); // Linienfarbe einstellen
+  noStroke();
+  rect(x, y, s, s); // Zeichnen des hinteren Quadrates
+
+  // Bestimmen der Farbe des inneren Quadrates
+  if (rahmenfarbe == weiss) {
+    fill(gruen);
+  } else {
+    fill(weiss);
+  }
+
+  rect(x+d, y+d, s-2*d, s-2*d); // Zeichnen des inneren Quadrates
+}
+
+void alleQuadrate(){
+  int farbe = gruen; // Festlegen der ersten Rahmenfarbe
+  // erste Reihe
+  for (int i=0; i<12; i++) {
+    zeichneQuadrat(30+i*s, 30, farbe);
+    if (farbe == gruen) {  // du könntest hier wieder eine Methode Farbwechsel schreiben
+      farbe = weiss;
+    } else {
+      farbe = gruen;
+    }
+  }
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen_b1_lsg_farbwechsel/wellen_b1_lsg_farbwechsel.pde

@@ -0,0 +1,46 @@
+// globale Variable
+int s=30; // Seitenlänge der Quadrate
+int d=5; // Abstand inneres Quadrat zum Rand
+int weiss = 255; 
+int gruen = #1CAF38;
+
+
+// setup-Methode
+void setup() {
+  size(700, 700);
+  background(255); // weißer Hintergrund
+  alleQuadrate();
+}
+
+int farbwechsel(int farbe) {
+  if (farbe == weiss) {  // Wechsel von weiß auf grün
+    return gruen;
+  } else {  // Wechsel von grün auf weiß
+    return weiss;
+  }
+}
+
+void zeichneQuadrat(int x, int y, int rahmenfarbe) {
+
+  fill(rahmenfarbe); // Linienfarbe einstellen
+  noStroke();
+  rect(x, y, s, s); // Zeichnen des hinteren Quadrates
+
+  // Bestimmen der Farbe des inneren Quadrates
+  fill(farbwechsel(rahmenfarbe));
+
+  rect(x+d, y+d, s-2*d, s-2*d); // Zeichnen des inneren Quadrates
+}
+
+void alleQuadrate(){
+  int farbe = gruen; // Festlegen der ersten Rahmenfarbe
+  for (int j=0; j<12; j++) { // j zählt die Reihen
+
+    for (int i=0; i<12; i++) {  // i zählt die Quadrate in einer Reihe
+      zeichneQuadrat(30+i*s, 30+j*s, farbe);
+      farbe = farbwechsel(farbe);
+    }
+    // Wechsel der Farbe des ersten Quadrates für die nächste Reihe
+    farbe = farbwechsel(farbe);
+  }
+}

04_loesungen/01_processing/alg07b_wellen_uebungen_loesungen/wellen_b1_mit_while_schleife/wellen_b1_mit_while_schleife.pde

@@ -0,0 +1,52 @@
+// globale Variable
+int s=30; // Seitenlänge der Quadrate
+int d=5; // Abstand inneres Quadrat zum Rand
+int weiss = 255; 
+int gruen = #1CAF38;
+
+
+// setup-Methode
+void setup() {
+  size(700, 700);
+  background(255); // weißer Hintergrund
+  alleQuadrate();
+}
+
+int farbwechsel(int farbe) {
+  if (farbe == weiss) {  // Wechsel von weiß auf grün
+    return gruen;
+  } else {  // Wechsel von grün auf weiß
+    return weiss;
+  }
+}
+
+void zeichneQuadrat(int x, int y, int rahmenfarbe) {
+
+  fill(rahmenfarbe); // Linienfarbe einstellen
+  noStroke();
+  rect(x, y, s, s); // Zeichnen des hinteren Quadrates
+
+  // Bestimmen der Farbe des inneren Quadrates
+  fill(farbwechsel(rahmenfarbe));
+
+  rect(x+d, y+d, s-2*d, s-2*d); // Zeichnen des inneren Quadrates
+}
+
+void alleQuadrate(){
+  int farbe = gruen; // Festlegen der ersten Rahmenfarbe
+  int pos_x = 0;
+  int pos_y = 0;
+  while (pos_y < 700) { // unterer Rand ist noch nicht erreicht
+
+    while (pos_x < 700) {  // rechter Rand ist noch nicht erreicht
+      zeichneQuadrat(pos_x, pos_y, farbe);
+      farbe = farbwechsel(farbe);
+      pos_x = pos_x + s;  // verändern der x-Position um s
+    }
+    // Wechsel der Farbe des ersten Quadrates für die nächste Reihe
+    farbe = farbwechsel(farbe);
+    // x-Position wieder an linken Rand setzen
+    pos_x = 0;
+    pos_y = pos_y + s; // verändern der y-Position um s
+  }
+}

04_loesungen/01_processing/alg08a_weitere_uebungen_loesungen/alg08a_weitere_uebungen_loesungen.pde

@@ -0,0 +1,41 @@
+// globale Variablen
+int e = 60; // Länge der waagrechten Diagonale der grauen Raute
+int f = 35; // Länge der senkrechten Diagonale der grauen Raute
+
+int farbe1 = #3F71C4;  // blau
+int farbe2 = #54B966;  // grün
+int farbe3 = #969B96; // grau
+
+// setup-Methode
+void setup() {
+  size(600, 400);
+  background(farbe3);
+  drei_d();
+}
+
+void viereck(int farbe, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){
+  fill(farbe);
+  stroke(farbe);
+  quad(x1,y1,x2,y2,x3,y3,x4,y4);
+}
+
+void drei_d() {
+  int x = 0;
+  int y = 0;
+  boolean ungerade = true; // es beginnt mit Farbe 1 - jede ungerade Reihe
+  while (y < height) {
+    while (x < width) {
+      viereck(farbe1, x,y,x+ e/2,y+f/2,x+e/2,y+3*f/2,x,y+f);
+      viereck(farbe2, x+ e/2,y+f/2,x+e/2,y+3*f/2,x+e,y+f,x+e,y);
+      x = x + e;
+    }
+    if (ungerade == true){
+      ungerade = false;
+      x = -e/2;  // erste sichtbare Farbe links ist Farbe 2
+    } else {
+      ungerade = true;
+      x = 0;
+    }
+    y = y + 3*f/2;
+  }
+}

04_loesungen/01_processing/alg08b_weitere_uebungen_loesungen/alg08b_weitere_uebungen_loesungen.pde

@@ -0,0 +1,71 @@
+// globale Variablen
+int breite = 40; // Breite der schwarzen Streifen
+int hellblau = #07B0D8; // r=7, g=176, b=216
+int dunkelblau = #064590; // r=6, g=69, b=144
+
+void schwarze_streifen() {
+  fill(0); // Füllfarbe schwarz
+  int pos = breite/2; // Abstand erster Streifen zum linken Rand
+  while (pos < width) {
+    rect(pos, 0, breite, height);
+    pos = pos + 2*breite;
+  }
+}
+
+void blaue_streifen() {
+  int startfarbe = dunkelblau;
+  int farbe = startfarbe;
+  int d_nach_oben = breite;  // Abstand zum oberen Rand
+  int d_nach_links = 0; // Abstand nach links
+  int farbe_raute = 0;
+  noStroke();
+  while (d_nach_oben < height) {
+    while (d_nach_links < width) {
+      fill(farbe);
+      rect(d_nach_links, d_nach_oben, breite, breite);
+      vier_rauten(farbe_raute, d_nach_links + breite/2, d_nach_oben); // obere Rauten
+      vier_rauten(255-farbe_raute, d_nach_links + breite/2, d_nach_oben + breite); // untere
+      d_nach_links = d_nach_links + breite;
+      farbe = farbwechsel(farbe);
+      farbe_raute = 255 - farbe_raute;
+    }
+    d_nach_oben = d_nach_oben + breite + breite + breite/2;
+    d_nach_links = 0;
+    startfarbe = farbwechsel(startfarbe);
+  }
+}
+
+int farbwechsel(int farbe0) { // ändert zwischen hell- und dunkelblau
+  int neuefarbe;
+  if (farbe0 == hellblau) {
+    neuefarbe = dunkelblau;
+  } else {
+    neuefarbe = hellblau;
+  }
+  return neuefarbe;
+}
+
+void viereck(int farbe, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
+  fill(farbe);
+  quad(x1,y1,x2,y2,x3,y3,x4,y4);
+}
+
+void vier_rauten(int farbe, int x_m, int y_m) {
+  int a = 12;
+  noStroke();
+  //Raute links
+  viereck(farbe, x_m-a, y_m, x_m - a/2, y_m-a/2, x_m, y_m, x_m - a/2, y_m+a/2);
+  //Raute unten
+  viereck(255-farbe, x_m, y_m, x_m - a/2, y_m + a/2, x_m, y_m + a, x_m + a/2, y_m + a/2);
+  //Raute rechts
+  viereck(farbe, x_m, y_m, x_m + a/2, y_m + a/2, x_m + a, y_m, x_m + a/2, y_m - a/2);
+  //Raute oben
+  viereck(255-farbe, x_m, y_m, x_m - a/2, y_m - a/2, x_m, y_m - a, x_m + a/2, y_m - a/2);
+}
+
+void setup() {
+  size(600, 400);
+  background(255);  // weißer Hintergrund
+  schwarze_streifen();
+  blaue_streifen();
+}

04_loesungen/01_processing/alg08c_weitere_uebungen_loesungen/alg08c_weitere_uebungen_loesungen.pde

@@ -0,0 +1,55 @@
+// globale Variable
+
+int s=20; // Seitenlaenge Quadrat
+int k=5; // Seitenlaenge kleines Quadrat
+int d=1; // Abstand kleine Quadrate zum Rand
+
+void zeichneQuadrat(int x, int y, int farbe, boolean minus) {
+  fill(farbe);
+  noStroke();
+  rect(x, y, s, s);
+  fill(255-farbe); // Farbwechsel zwischen weiß und schwarz
+  if (minus == true) { // links oben, rechts unten
+    rect(x+d, y+d, k, k);
+    rect(x+s-d-k, y+s-d-k, k, k);
+  } else { // links unten, rechts oben
+    rect(x+d, y+s-d-k, k, k);
+    rect(x+s-d-k, y+d, k, k);
+  }
+}
+
+void optischeTaeuschung() {
+  int farbe_akt = 0;
+  // kompletter Hintergrund
+  for (int j=0; j<24; j++) {
+    for (int i=0; i<24; i++) {
+      zeichneQuadrat(i*s, j*s, farbe_akt, true);
+      farbe_akt = 255 - farbe_akt;
+    }
+    farbe_akt = 255 - farbe_akt;
+  }
+  // Mitte gefüllt mit schwarz - weiß...
+  for (int j=0; j<12; j++){
+    for (int i=0; i<12; i++){
+      fill(farbe_akt);
+      rect(6*s +i*s, 6*s+ j*s, s, s);
+      farbe_akt = 255 - farbe_akt;
+    }
+    farbe_akt = 255 - farbe_akt;
+  }
+  // innere Mitte
+  for (int j=0; j<10; j++) {
+    for (int i=0; i<10; i++) {
+      zeichneQuadrat(7*s+i*s, 7*s+ j*s, farbe_akt, false);
+      farbe_akt = 255 - farbe_akt;
+    }
+    farbe_akt = 255 - farbe_akt;
+  }
+  
+}
+
+// setup-Methode
+void setup() {
+  size(500, 500);
+  optischeTaeuschung();
+}

04_loesungen/01_processing/alg08d_weitere_uebungen_loesungen/alg08d_weitere_uebungen_loesungen.pde

@@ -0,0 +1,89 @@
+int rot = 0;
+int blau = 0;
+int gruen = 0;
+int h_rot; 
+int h_blau; 
+int h_gruen;
+boolean schnell = false;
+
+void setup() {
+  size(650, 150);
+  vorbereitung();
+  //background(h_rot,h_gruen,h_blau); */
+  noLoop();
+}
+
+void vorbereitung() {
+  h_rot = int(random(0, 255));
+  h_gruen = int(random(0, 255));
+  h_blau= int(random(0, 255));
+  fill(h_rot, h_gruen, h_blau);
+  rect(25, 25, 100, 100);
+  fill(0);
+  text("Start mit Mausklick: Schrittweite 10", 150, 50);
+  text("Umschalten der Schrittweite von 10 auf 1 (und umgekehrt) durch Mausklick", 150, 75);
+  text("Erhöhen der Farbwerte durch Tastendruck: r - rot, g - grün, b - blau", 150, 100);
+  text("Überprüfen mit Leertaste: Ausgabe in der Konsole", 150, 125);
+}
+
+void draw() {
+  noStroke();
+  fill(rot, gruen, blau);
+  rect(50, 50, 50, 50);
+}
+
+void ueberpruefen() {
+  String ausgabe_rot;
+  String ausgabe_gruen;
+  String ausgabe_blau;
+  if (rot>h_rot) {
+    ausgabe_rot = "zu viel rot";
+  } else if (rot < h_rot) {
+    ausgabe_rot = "zu wenig rot";
+  } else {
+    ausgabe_rot = "rot stimmt!";
+  }
+  if (gruen>h_gruen) {
+    ausgabe_gruen = "zu viel grün";
+  } else if (gruen < h_gruen) {
+    ausgabe_gruen = "zu wenig grün";
+  } else {
+    ausgabe_gruen = "grün stimmt!";
+  }
+  if (blau>h_blau) {
+    ausgabe_blau = "zu viel blau";
+  } else if (blau < h_blau) {
+    ausgabe_blau = "zu wenig blau";
+  } else {
+    ausgabe_blau = "blau stimmt!";
+  }
+  println(ausgabe_rot+", "+ausgabe_gruen+", "+ausgabe_blau);
+}
+
+void keyPressed() {
+  int d;
+  if (schnell == true) {
+    d=10;
+  } else {
+    d=1;
+  }
+  if (key == 32) {  // Leertaste
+    ueberpruefen();
+  }
+  if (key == 'r' || key == 'R') {
+    rot = (rot + d) % 255;
+    println("rot: "+rot+" richtig: "+h_rot);
+  } else if (key == 'g' || key == 'G') {
+    gruen = (gruen+d) % 255;
+    println("grün: "+gruen+" richtig: "+h_gruen);
+  } else if (key == 'b' || key == 'B') {
+    blau = (blau+d) % 255;
+    println("blau: "+blau+" richtig: "+h_blau);
+  }
+  redraw();
+}
+
+void mousePressed() {
+  schnell = ! schnell;
+  println(schnell);
+}

04_loesungen/01_processing/alg08e_android_weitere_uebungen_loesungen/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="">
+    <uses-sdk android:minSdkVersion="17" android:targetSdkVersion="26"/>
+    <application android:icon="@drawable/icon" android:label="">
+        <activity android:name=".MainActivity" android:theme="@style/Theme.AppCompat.Light.NoActionBar.FullScreen">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

04_loesungen/01_processing/alg08e_android_weitere_uebungen_loesungen/alg08e_android_weitere_uebungen_loesungen.pde

@@ -0,0 +1,14 @@
+
+
+void setup() {
+  size(displayWidth, displayHeight);
+}
+
+void draw() {
+}
+
+
+void mouseDragged() {
+    fill(int(random(0, 255)), int(random(0, 255)), int(random(0, 255)));
+    ellipse(pmouseX, pmouseY, 40, 40);
+}

04_loesungen/01_processing/alg08e_android_weitere_uebungen_loesungen/code/sketch.properties

@@ -0,0 +1,3 @@
+mode=Android
+component=app
+mode.id=processing.mode.android.AndroidMode

04_loesungen/01_processing/alg08e_weitere_uebungen_loesungen/AndroidManifest.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package=""
+          android:versionCode="1"
+          android:versionName="1.0">              
+    <uses-sdk android:minSdkVersion="17" />    
+    <application android:label=""
+                 android:icon="@drawable/icon">
+        <activity android:name=".MainActivity"
+                  android:theme="@style/Theme.AppCompat.Light.NoActionBar.FullScreen">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity> 
+    </application>
+</manifest>

04_loesungen/01_processing/alg08e_weitere_uebungen_loesungen/alg08e_weitere_uebungen_loesungen.pde

@@ -0,0 +1,17 @@
+
+void setup() {
+  size(600, 400);
+}
+
+void draw() {
+}
+
+void mousePressed() {
+  fill(int(random(0, 255)), int(random(0, 255)), int(random(0, 255)));
+  ellipse(mouseX, mouseY, 40, 40);
+}
+
+void mouseDragged() {
+  fill(int(random(0, 255)), int(random(0, 255)), int(random(0, 255)));
+  ellipse(mouseX, mouseY, 40, 40);
+}

04_loesungen/01_processing/alg08e_weitere_uebungen_loesungen/code/sketch.properties

@@ -0,0 +1,3 @@
+mode=Java
+component=app
+mode.id=processing.mode.java.JavaMode

04_loesungen/01_processing/alg09_weitere_optische_taeuschungen/alg09a_loesung.pde

@@ -0,0 +1,69 @@
+// globale Variablen
+int s = 40; // Seitenlänge Quadrate
+int hell = #B2B0C4; // r=7, g=176, b=216
+int dunkel = #9C98C1; // r=6, g=69, b=144
+
+
+int farbwechsel(int farbe0) { // ändert zwischen hell- und dunkel
+  int neuefarbe;
+  if (farbe0 == hell) {
+    neuefarbe = dunkel;
+  } else {
+    neuefarbe = hell;
+  }
+  return neuefarbe;
+}
+
+void quadrate() {
+  int startfarbe = hell;
+  int farbe = startfarbe;
+  noStroke();
+  for (int j=0; j<13; j++) {
+    for (int i=0; i< 13; i++) {
+      fill(farbe);
+      rect(i*s, j*s, s, s);
+      farbe = farbwechsel(farbe);
+    }
+  }
+}
+
+void rauten(){
+  int farbe_raute = 0;
+  for (int j=0;j<6; j++){
+    for (int i=0; i<6; i++){
+      vier_rauten(farbe_raute, (i+1)*s, (j+1)*s);  // Quadrant 4
+      vier_rauten(farbe_raute, (12-i)*s, (j+1)*s); // Quadrant 1
+      vier_rauten(farbe_raute, (i+1)*s, (12-j)*s);  // Quadrant 3
+      vier_rauten(farbe_raute, (12-i)*s, (12-j)*s); // Quadrant 2    
+      farbe_raute = 255 - farbe_raute;
+    }
+    farbe_raute = 255 - farbe_raute;
+  }
+
+}
+
+
+void viereck(int farbe, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) {
+  fill(farbe);
+  quad(x1, y1, x2, y2, x3, y3, x4, y4);
+}
+
+void vier_rauten(int farbe, int x_m, int y_m) {
+  int a = 8;
+  noStroke();
+  //Raute links
+  viereck(farbe, x_m-a, y_m, x_m - a/2, y_m-a/2, x_m, y_m, x_m - a/2, y_m+a/2);
+  //Raute unten
+  viereck(255-farbe, x_m, y_m, x_m - a/2, y_m + a/2, x_m, y_m + a, x_m + a/2, y_m + a/2);
+  //Raute rechts
+  viereck(farbe, x_m, y_m, x_m + a/2, y_m + a/2, x_m + a, y_m, x_m + a/2, y_m - a/2);
+  //Raute oben
+  viereck(255-farbe, x_m, y_m, x_m - a/2, y_m - a/2, x_m, y_m - a, x_m + a/2, y_m - a/2);
+}
+
+void setup() {
+  size(600, 600);
+  background(255);  // weißer Hintergrund
+  quadrate();
+  rauten();
+}

04_loesungen/01_processing/alg09_weitere_optische_taeuschungen/alg09b_loesung.pde

@@ -0,0 +1,64 @@
+// globale Variablen
+int s = 40; // Seitenlänge Quadrate
+int hell = #E5A05A; // r=7, g=176, b=216
+int dunkel = #E57607; // r=6, g=69, b=144
+
+
+int farbwechsel(int farbe0) { // ändert zwischen hell- und dunkel
+  int neuefarbe;
+  if (farbe0 == hell) {
+    neuefarbe = dunkel;
+  } else {
+    neuefarbe = hell;
+  }
+  return neuefarbe;
+}
+
+void quadrate_hintergrund() {
+  int startfarbe = dunkel;
+  int farbe = startfarbe;
+  noStroke();
+  for (int j=0; j<11; j++) {
+    for (int i=0; i< 11; i++) {
+      fill(farbe);
+      rect(i*s, j*s, s, s);
+      farbe = farbwechsel(farbe);
+    }
+  }
+}
+
+void quadrat_klein(int farbe, int x, int y, int seite) {
+  strokeWeight(3);
+  if (farbe == 255) {
+    stroke(hell);
+    fill(255);
+  } else {
+    stroke(dunkel);
+    fill(0);
+  }
+  rect(x, y, seite, seite);
+}
+
+void quadrate_vordergrund() {
+  int s0 = s / 2;
+  int startfarbe = 0;
+  for (int j=0; j<10; j++) {
+    for (int i=0; i<10; i++) {
+      quadrat_klein(startfarbe, (i+1)*s-s0/2, (j+1)*s-s0/2, s0);
+      if (i!=4) {
+        startfarbe = 255 - startfarbe;
+      }
+    }
+    if (j==4){
+      startfarbe = 255 - startfarbe;
+    }
+  }
+}
+
+
+void setup() {
+  size(440, 440);
+  background(255);  // weißer Hintergrund
+  quadrate_hintergrund();
+  quadrate_vordergrund();
+}

04_loesungen/01_processing/alg09_weitere_optische_taeuschungen/alg09b_v2_loesung.pde

@@ -0,0 +1,78 @@
+// globale Variablen
+int s = 40; // Seitenlänge Quadrate
+int hell = #E5A05A; // r=7, g=176, b=216
+int dunkel = #E57607; // r=6, g=69, b=144
+
+
+int farbwechsel(int farbe0) { // ändert zwischen hell- und dunkel
+  int neuefarbe;
+  if (farbe0 == hell) {
+    neuefarbe = dunkel;
+  } else {
+    neuefarbe = hell;
+  }
+  return neuefarbe;
+}
+
+void quadrate_hintergrund() {
+  int startfarbe = dunkel;
+  int farbe = startfarbe;
+  noStroke();
+  for (int j=0; j<11; j++) {
+    for (int i=0; i< 11; i++) {
+      fill(farbe);
+      rect(i*s, j*s, s, s);
+      farbe = farbwechsel(farbe);
+    }
+  }
+}
+
+void quadrat_klein(int farbe, int x, int y, int seite) {
+  strokeWeight(3);
+  if (farbe == 255) {
+    stroke(hell);
+    fill(255);
+  } else {
+    stroke(dunkel);
+    fill(0);
+  }
+  rect(x, y, seite, seite);
+}
+
+void quadrate_vordergrund() {
+  int s0 = s /2;
+  int startfarbe = 0;
+  for (int j=0; j<10; j++) {
+    for (int i=0; i<10; i++) {
+
+      if (quadrat_zeichnen(i, j) == true) {
+
+        quadrat_klein(startfarbe, (i+1)*s-s0/2, (j+1)*s-s0/2, s0);
+      }
+      if (i!=4) {
+        startfarbe = 255 - startfarbe;
+      }
+    }
+    if (j==4) {
+      startfarbe = 255 - startfarbe;
+    }
+  }
+}
+
+boolean quadrat_zeichnen(int i0, int j0) {
+  boolean ergebnis = true;
+
+  if (((j0==0 || j0==9) && (i0<3 || i0>6)) || ((j0<3 || j0>6) && (i0==0 || i0==9))) {
+    ergebnis = false;
+  }
+
+  return ergebnis;
+}
+
+
+void setup() {
+  size(440, 440);
+  background(255);  // weißer Hintergrund
+  quadrate_hintergrund();
+  quadrate_vordergrund();
+}

04_loesungen/01_processing/alg10_balkendiagramm_loesung/alg10_balkendiagramm_loesung.pde

@@ -0,0 +1,47 @@
+// Programm zur Darstellung eines Arrays als Balkendiagramm
+// Autor: Thomas Schaller
+// Version: 1.0 vom 12.02.2019
+
+
+ // Liste mit allen Werten //<>//
+int[]   zahlen={45, 23, 123, 87, 98, 2, 1, 23, 23, 34};    
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+    // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  // Balkendiagramm zeichnen
+  zeichneBalken();
+}
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Balkendiagramm", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  for (int i = 0; i< zahlen.length; i++) {
+    
+    fill(20,30,170);
+    
+    // Balkendiagramm zeichnen
+    rect(120, 25+i*15, zahlen[i]+1, 13);
+    
+    // Beschriftung
+    fill(255,255,255);
+    text("i="+i, 2, 35+i*15);
+    text("zahlen["+i+"]="+zahlen[i], 30, 35+i*15);
+  }
+}

04_loesungen/01_processing/alg10_balkendiagramm_loesung2/alg10_balkendiagramm_loesung2.pde

@@ -0,0 +1,48 @@
+// Programm zur Darstellung eines Arrays als Balkendiagramm
+// Autor: Thomas Schaller
+// Version: 1.0 vom 12.02.2019
+
+ // Liste mit allen Werten //<>//
+int[]   zahlen={45, 23, 123, 87, 98, 2, 1, 23, 23, 34};    
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+    // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  // Balkendiagramm zeichnen
+  zeichneBalken();
+}
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Balkendiagramm", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if(zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+      
+      fill(20,30,170);
+      
+      // Balkendiagramm zeichnen
+      if(zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+      
+      // Beschriftung
+      fill(255,255,255);
+      text("i="+i, 2, 35+i*15);
+      text("zahlen["+i+"]="+zahlen[i], 30, 35+i*15);
+    }
+  }
+}

04_loesungen/01_processing/alg11_balkendiagramm_zufall_loesung/alg11_balkendiagramm_zufall_loesung.pde

@@ -0,0 +1,67 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden zufällig erzeugt.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+
+ // Liste mit allen Werten //<>//
+int[]   zahlen;    
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  
+  // Zufallszahlen erzeugen und anzeigen
+  erzeugeZufallsarray(20);
+  zeichneBalken();
+}
+
+public int getZufallszahl(int min, int max) {
+  java.util.Random r = new java.util.Random();
+  return r.nextInt(max-min+1)+min;
+}
+
+public void erzeugeZufallsarray(int laenge) {
+  // Neues Array der richtigen Länge erzeugen
+  zahlen = new int[laenge];
+  
+  // Jedes Element mit einer Zufallszahl belegen
+  for(int i= 0; i< laenge; i++) {
+    zahlen[i] = getZufallszahl(1, 300);
+  }
+}
+  
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Balkendiagramm", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  for (int i = 0; i< zahlen.length; i++) {
+    
+    fill(20,30,170);
+    
+    // Balkendiagramm zeichnen
+    rect(120, 25+i*15, zahlen[i]+1, 13);
+    
+    // Beschriftung
+    fill(255,255,255);
+    text("i="+i, 2, 35+i*15);
+    text("zahlen["+i+"]="+zahlen[i], 30, 35+i*15);
+  }
+}

04_loesungen/01_processing/alg11_balkendiagramm_zufall_loesung2/alg11_balkendiagramm_zufall_loesung2.pde

@@ -0,0 +1,71 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden zufällig erzeugt.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+
+ // Liste mit allen Werten //<>//
+int[]   zahlen;    
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  
+  // Zufallszahlen erzeugen und anzeigen
+  erzeugeZufallsarray(20);
+  zeichneBalken();
+}
+
+public int getZufallszahl(int min, int max) {
+  java.util.Random r = new java.util.Random();
+  return r.nextInt(max-min+1)+min;
+}
+
+public void erzeugeZufallsarray(int laenge) {
+  if(laenge >= 0) {
+    // Neues Array der richtigen Länge erzeugen
+    zahlen = new int[laenge];
+  
+    // Jedes Element mit einer Zufallszahl belegen
+    for(int i= 0; i< laenge; i++) {
+      zahlen[i] = getZufallszahl(1, 300);
+    }
+  }
+}
+  
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Balkendiagramm", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if(zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+    
+      fill(20,30,170);
+      
+      // Balkendiagramm zeichnen
+      if(zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+      
+      // Beschriftung
+      fill(255,255,255);
+      text("i="+i, 2, 35+i*15);
+      text("zahlen["+i+"]="+zahlen[i], 30, 35+i*15);
+    }
+  }
+}

04_loesungen/01_processing/alg12_balkendiagramm_csv_loesung/alg12_balkendiagramm_csv_loesung.pde

@@ -0,0 +1,71 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden aus CSV-Datei gelesen.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+
+ // Liste mit allen Werten //<>//
+int[]    zahlen;    
+String[] namen;
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  zeichneBalken();
+}
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden
+  Table csv = loadTable(name,"header,csv");
+  
+  // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+  zahlen = new int[csv.getRowCount()];
+  namen = new String[csv.getRowCount()];
+  
+  // Fülle die Arrays mit Werten aus der Tabelle
+  for (int i = 0; i < zahlen.length; i++) {
+    // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+    zahlen[i] = csv.getInt(i,"Punkte");
+    namen[i] = csv.getString(i,"Name");
+  }
+}
+  
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+
+  for (int i = 0; i< zahlen.length; i++) {
+  
+    fill(20,30,170);
+    
+    // Balkendiagramm zeichnen
+    rect(120, 25+i*15, zahlen[i]+1, 13);
+    
+    // Beschriftung
+    fill(255,255,255);
+    text(namen[i], 2, 35+i*15);
+    text(""+zahlen[i], 70, 35+i*15);
+  }
+}

04_loesungen/01_processing/alg12_balkendiagramm_csv_loesung/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg12_balkendiagramm_csv_loesung2/alg12_balkendiagramm_csv_loesung2.pde

@@ -0,0 +1,75 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden aus CSV-Datei gelesen.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+
+ // Liste mit allen Werten //<>//
+int[]    zahlen;    
+String[] namen;
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  zeichneBalken();
+}
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden
+  Table csv = loadTable(name,"header,csv");
+  
+  if (csv != null  && csv.getColumnCount()==2) {
+    
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    zahlen = new int[csv.getRowCount()];
+    namen = new String[csv.getRowCount()];
+    
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < zahlen.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      zahlen[i] = csv.getInt(i,"Punkte");
+      namen[i] = csv.getString(i,"Name");
+    }
+  }
+}
+  
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if(zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+    
+      fill(20,30,170);
+      
+      // Balkendiagramm zeichnen
+      if(zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+      
+      // Beschriftung
+      fill(255,255,255);
+      text(namen[i], 2, 35+i*15);
+      text(""+zahlen[i], 70, 35+i*15);
+    }
+  }
+}

04_loesungen/01_processing/alg12_balkendiagramm_csv_loesung2/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg12_balkendiagramm_variante_xml/alg12_balkendiagramm_variante_xml.pde

@@ -0,0 +1,69 @@
+ // Liste mit allen Werten //<>//
+int[]    zahlen;    
+String[] namen;
+
+ // Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+  
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.xml");
+  zeichneBalken();
+}
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus XML-Datei laden
+  XML xml = loadXML(name);
+  XML[] rows = xml.getChildren("Row");
+  
+  // Initialisiere Arrays, in die alle Zeilen passen
+  zahlen = new int[rows.length];
+  namen  = new String[rows.length];
+  
+  // Fülle die Arrays mit Werten aus der Tabelle
+  for (int i = 0; i < zahlen.length; i++) {
+    // Lies Wert aus der i. Zeile und dort den Unterpunkten "Punkte" bzw. "Name"
+    XML eintragPunkte = rows[i].getChild("Punkte");
+    XML eintragName = rows[i].getChild("Name");
+    
+    zahlen[i] = eintragPunkte.getIntContent();
+    namen[i] = eintragName.getContent();
+  }
+}
+  
+
+public void zeichneBalken() {
+
+  clear();
+  
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+
+  for (int i = 0; i< zahlen.length; i++) {
+  
+    fill(20,30,170);
+    
+    // Balkendiagramm zeichnen
+    rect(120, 25+i*15, zahlen[i]+1, 13);
+    
+    // Beschriftung
+    fill(255,255,255);
+    text(namen[i], 2, 35+i*15);
+    text(""+zahlen[i], 70, 35+i*15);
+  }
+}

04_loesungen/01_processing/alg12_balkendiagramm_variante_xml/punkte.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CSV-Data>
+  <Header>
+    <Column name="Name" type="String" />
+    <Column name="Punkte" type="Integer" />
+  </Header>
+  <Row>
+    <Name>Nikolaus</Name>
+    <Punkte>216</Punkte>
+  </Row>
+  <Row>
+    <Name>Nikolaus</Name>
+    <Punkte>591</Punkte>
+  </Row>
+  <Row>
+    <Name>Nikolaus</Name>
+    <Punkte>1057</Punkte>
+  </Row>
+  <Row>
+    <Name>Nikolaus</Name>
+    <Punkte>180</Punkte>
+  </Row>
+  <Row>
+    <Name>Winfried</Name>
+    <Punkte>168</Punkte>
+  </Row>
+</CSV-Data>
+

04_loesungen/01_processing/alg13_maximumsuche_loesung/alg13_maximumsuche_loesung.pde

@@ -0,0 +1,170 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden aus CSV-Datei gelesen, Maximum der Werte wird bestimmt.
+ * Hinweis zur Benutzung:
+ * Klicke in das Zeichenfenster
+ * Animierte Suche mit Taste "a"
+ * Automatisches Testen mit Taste "t"* 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+ 
+// Liste mit allen Werten
+int[]    zahlen;    
+String[] namen;
+
+
+// Hilfsvariablen für die Suche
+int akt_maximum=-1;    // aktuell groesstes Element
+int akt=-1;            // aktuell untersuchtes Element
+int verzoegerung=1000;  // Geschwindigkeit der Ausführung
+
+// Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  zeichneBalken();
+}
+
+public void draw() {
+  zeichneBalken();
+}
+
+public void keyPressed() {
+  // Animierte Suche mit Taste "a"
+    if (key=='a') {
+    thread("maximumsuche");
+  }
+
+  // Automatisches Testen mit Taste "t"
+  if(key == 't') {
+    // Testfall 1
+    verzoegerung = 0; //<>//
+    ladeTabelle("testfall1.csv");
+    int m1 = maximumsuche();
+    if (m1 == 12) {
+      System.out.println("Maximum korrekt gefunden. In Datei testfall1.csv ist der größte Wert "+ zahlen[m1]+" von "+namen[m1]+" an Position "+m1);
+    } else {
+      System.out.println("Maximum in testfall.csv nicht gefunden. Du ermittelst "+m1+" richtig wäre 12");
+    }
+    // Testfall 2: negative Zahlen
+    ladeTabelle("testfall2.csv");
+    int m2 = maximumsuche();
+    if (m2 == 3) {
+      System.out.println("Maximum korrekt gefunden. In Datei testfall2.csv ist der größte Wert "+ zahlen[m2]+" von "+namen[m2]+" an Position "+m2);
+    } else {
+      System.out.println("Maximum in testfall2.csv nicht gefunden. Du ermittelst "+m2+" richtig wäre 3");
+    }
+    // Testfall 3: Nur 1 Element
+    ladeTabelle("testfall3.csv");
+    int m3 = maximumsuche();
+    if (m3 == 0) {
+      System.out.println("Maximum korrekt gefunden. In Datei testfall3.csv ist der größte Wert "+ zahlen[m3]+" von "+namen[m3]+" an Position "+m3);
+    } else {
+      System.out.println("Maximum in testfall3.csv nicht gefunden. Du ermittelst "+m3+" richtig wäre 0");
+    }
+    // Testfall 4: Leere Liste
+    ladeTabelle("testfall4.csv");
+    int m4 = maximumsuche();
+    if (m4 == -1) {
+      System.out.println("Maximum korrekt gefunden. Da die Datei keine Spieler enthält wird -1 zurückgegeben.");
+    } else {
+      System.out.println("Maximum in testfall4.csv nicht gefunden. Du ermittelst "+m4+" richtig wäre -1, da die Datei leer ist.");
+    }    
+  }
+}
+
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden //<>//
+  Table csv = loadTable(name, "header,csv");
+
+  if (csv != null  && csv.getColumnCount()==2) {
+
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    zahlen = new int[csv.getRowCount()];
+    namen = new String[csv.getRowCount()];
+
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < zahlen.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      zahlen[i] = csv.getInt(i, "Punkte");
+      namen[i] = csv.getString(i, "Name");
+    }
+  }
+}
+
+public void zeichneBalken() {
+
+  clear();
+
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if (zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+
+      fill(20,25,165);
+      // aktuelle Elemente farblich hervorheben
+      if (i == akt) {
+        fill(140,230,20);
+      } 
+      if (i == akt_maximum) {
+        fill(230,60,140);
+      } 
+
+      // Balkendiagramm zeichnen
+      if (zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+
+      // Beschriftung
+      fill(255,255,255);
+      text(namen[i], 2, 35+i*15);
+      text(""+zahlen[i], 70, 35+i*15);
+    }
+  }
+}
+
+
+public int maximumsuche() {
+  // Sind überhaupt Daten da?
+  if(zahlen.length==0 ) { //<>//
+    return -1;
+  }
+  
+  // Startwerte setzen
+  akt_maximum = 0;
+  akt = 1;
+  
+  // Alle Arrayelemente untersuchen
+  while (akt < zahlen.length) {
+    // Neu zeichnen, da akt neu gesetzt wurde 
+    redraw();
+    delay(verzoegerung);
+    // Neues größtes Element??
+    if (zahlen[akt]> zahlen[akt_maximum]) {
+      // Dann merke dir das neue 
+      akt_maximum = akt;
+      // Zeichne Balken neu, da neues größtes Element
+      redraw();
+      delay(verzoegerung);
+    }
+    akt = akt + 1;
+  }
+  // Gib Position des größten Elements zurück
+  return akt_maximum;
+}

04_loesungen/01_processing/alg13_maximumsuche_loesung/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg13_maximumsuche_loesung/testfall1.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,0
+Spieler1,6
+Spieler2,19
+Spieler6,1
+Spieler4,45
+Spieler3,23
+Spieler3,12
+Spieler2,44
+Spieler1,72
+Spieler5,12
+Spieler6,4
+Spieler7,2
+Spieler4,98
+Spieler3,21
+Spieler3,12
+Spieler2,32
+Spieler1,12
+Spieler5,44
+Spieler3,12

04_loesungen/01_processing/alg13_maximumsuche_loesung/testfall2.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,-5
+Spieler1,-6
+Spieler2,-19
+Spieler6,-1
+Spieler4,-45
+Spieler3,-23
+Spieler3,-12
+Spieler2,-44
+Spieler1,-72
+Spieler5,-12
+Spieler6,-4
+Spieler7,-2
+Spieler4,-98
+Spieler3,-21
+Spieler3,-12
+Spieler2,-32
+Spieler1,-12
+Spieler5,-44
+Spieler3,-12

04_loesungen/01_processing/alg13_maximumsuche_loesung/testfall3.csv

@@ -0,0 +1,2 @@
+"Name","Punkte"
+Spieler1,45

04_loesungen/01_processing/alg13_maximumsuche_loesung/testfall4.csv

@@ -0,0 +1 @@
+"Name","Punkte"

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/alg13_variante_minimumsuche_loesung.pde

@@ -0,0 +1,169 @@
+/**
+ * Balkendiagramm für int-Array, Zahlen werden aus CSV-Datei gelesen, Minimum der Werte wird bestimmt.
+ * Hinweis zur Benutzung:
+ * Klicke in das Zeichenfenster
+ * Animierte Suche mit Taste "a"
+ * Automatisches Testen mit Taste "t"* 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+ 
+ // Liste mit allen Werten
+int[]    zahlen;    
+String[] namen;
+
+// Hilfsvariablen für die Suche
+int akt_minimum=-1;    // aktuell groesstes Element
+int akt=-1;            // aktuell untersuchtes Element
+int verzoegerung=1000;  // Geschwindigkeit der Ausführung
+
+// Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  zeichneBalken();
+}
+
+public void draw() {
+  zeichneBalken();
+}
+
+public void keyPressed() {
+  // Animierte Suche mit Taste "a"
+    if (key=='a') {
+    thread("minimumsuche");
+  }
+
+  // Automatisches Testen mit Taste "t"
+  if(key == 't') {
+    // Testfall 1
+    verzoegerung = 0; //<>//
+    ladeTabelle("testfall1.csv");
+    int m1 = minimumsuche();
+    if (m1 == 0) {
+      System.out.println("Minimum korrekt gefunden. In Datei testfall1.csv ist der größte Wert "+ zahlen[m1]+" von "+namen[m1]+" an Position "+m1);
+    } else {
+      System.out.println("Minimum in testfall.csv nicht gefunden. Du ermittelst "+m1+" richtig wäre 12");
+    }
+    // Testfall 2: negative Zahlen
+    ladeTabelle("testfall2.csv");
+    int m2 = minimumsuche();
+    if (m2 == 12) {
+      System.out.println("Minimum korrekt gefunden. In Datei testfall2.csv ist der größte Wert "+ zahlen[m2]+" von "+namen[m2]+" an Position "+m2);
+    } else {
+      System.out.println("Minimum in testfall2.csv nicht gefunden. Du ermittelst "+m2+" richtig wäre 3");
+    }
+    // Testfall 3: Nur 1 Element
+    ladeTabelle("testfall3.csv");
+    int m3 = minimumsuche();
+    if (m3 == 0) {
+      System.out.println("Minimum korrekt gefunden. In Datei testfall3.csv ist der größte Wert "+ zahlen[m3]+" von "+namen[m3]+" an Position "+m3);
+    } else {
+      System.out.println("Minimum in testfall3.csv nicht gefunden. Du ermittelst "+m3+" richtig wäre 0");
+    }
+    // Testfall 4: Leere Liste
+    ladeTabelle("testfall4.csv");
+    int m4 = minimumsuche();
+    if (m4 == -1) {
+      System.out.println("Minimum korrekt gefunden. Da die Datei keine Spieler enthält wird -1 zurückgegeben.");
+    } else {
+      System.out.println("Minimum in testfall4.csv nicht gefunden. Du ermittelst "+m4+" richtig wäre -1, da die Datei leer ist.");
+    }    
+  }
+}
+
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden //<>//
+  Table csv = loadTable(name, "header,csv");
+
+  if (csv != null  && csv.getColumnCount()==2) {
+
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    zahlen = new int[csv.getRowCount()];
+    namen = new String[csv.getRowCount()];
+
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < zahlen.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      zahlen[i] = csv.getInt(i, "Punkte");
+      namen[i] = csv.getString(i, "Name");
+    }
+  }
+}
+
+public void zeichneBalken() {
+
+  clear();
+
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if (zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+
+      fill(20,25,165);
+      // aktuelle Elemente farblich hervorheben
+      if (i == akt) {
+        fill(140,230,20);
+      } 
+      if (i == akt_minimum) {
+        fill(230,60,140);
+      } 
+
+      // Balkendiagramm zeichnen
+      if (zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+
+      // Beschriftung
+      fill(255,255,255);
+      text(namen[i], 2, 35+i*15);
+      text(zahlen[i], 70, 35+i*15);
+    }
+  }
+}
+
+
+public int minimumsuche() {
+  // Sind überhaupt Daten da?
+  if(zahlen.length==0 ) { //<>//
+    return -1;
+  }
+  
+  // Startwerte setzen
+  akt_minimum = 0;
+  akt = 1;
+  
+  // Alle Arrayelemente untersuchen
+  while (akt < zahlen.length) {
+    // Neu zeichnen, da akt neu gesetzt wurde 
+    redraw();
+    delay(verzoegerung);
+    // Neues kleinstes Element??
+    if (zahlen[akt] < zahlen[akt_minimum]) {
+      // Dann merke dir das neue 
+      akt_minimum = akt;
+      // Zeichne Balken neu, da neues kleinstes Element
+      redraw();
+      delay(verzoegerung);
+    }
+    akt = akt + 1;
+  }
+  // Gib Position des kleinsten Elements zurück
+  return akt_minimum;
+}

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/testfall1.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,0
+Spieler1,6
+Spieler2,19
+Spieler6,1
+Spieler4,45
+Spieler3,23
+Spieler3,12
+Spieler2,44
+Spieler1,72
+Spieler5,12
+Spieler6,4
+Spieler7,2
+Spieler4,98
+Spieler3,21
+Spieler3,12
+Spieler2,32
+Spieler1,12
+Spieler5,44
+Spieler3,12

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/testfall2.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,-5
+Spieler1,-6
+Spieler2,-19
+Spieler6,-1
+Spieler4,-45
+Spieler3,-23
+Spieler3,-12
+Spieler2,-44
+Spieler1,-72
+Spieler5,-12
+Spieler6,-4
+Spieler7,-2
+Spieler4,-98
+Spieler3,-21
+Spieler3,-12
+Spieler2,-32
+Spieler1,-12
+Spieler5,-44
+Spieler3,-12

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/testfall3.csv

@@ -0,0 +1,2 @@
+"Name","Punkte"
+Spieler1,45

04_loesungen/01_processing/alg13_variante_minimumsuche_loesung/testfall4.csv

@@ -0,0 +1 @@
+"Name","Punkte"

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/alg14a_zeitungsmeldung_loesung.pde

@@ -0,0 +1,137 @@
+/**
+ * Automatische Zeitungsmeldung mit Maximum und Durchschnitt, Zahlen werden aus CSV-Datei gelesen.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+ 
+// Liste mit allen Werten
+int[]    punkte;    
+String[] namen;
+
+// Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  int summe = berechneSumme(punkte);
+  System.out.println("Summe: "+summe);
+  schreibeZeitungsmeldung();
+}
+
+public void ladeTabelle(String name) { //<>//
+  // Tabelle aus CSV-Datei laden //<>//
+  Table csv = loadTable(name, "header,csv");
+
+  if (csv != null  && csv.getColumnCount()==2) {
+
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    punkte = new int[csv.getRowCount()];
+    namen = new String[csv.getRowCount()];
+
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < punkte.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      punkte[i] = csv.getInt(i, "Punkte");
+      namen[i] = csv.getString(i, "Name");
+    }
+  }
+}
+
+public void schreibeZeitungsmeldung() {
+
+  clear();
+
+  // Überschrift
+  fill(225,225,255);
+  stroke(155,155,255);
+  textFont(grosseSchrift);
+  text("BREAKING NEWS",5,32);
+  strokeWeight(3);
+  line(2,4,400,4);
+  line(2,45,400,45);
+  strokeWeight(2);
+  line(2,7,400,7);
+  line(2,42,400,42);
+  strokeWeight(1);
+  textFont(kleineSchrift); 
+  fill(240);
+  
+  int anzahlSpieler   = anzahlSpieler(namen);
+  int anzahlSpiele    = punkte.length;
+  int summe           = berechneSumme(punkte);
+  double durchschnitt = berechneDurchschnitt(punkte);
+  
+  text("Großartiges Ergebnis - Klasse XY nimmt an Binärwettbewerb teil.", 2, 60);
+  text("Die Klasse XY hat beim diesjährigen Binärwettbewerb teilgenommen", 2, 82);
+  text("und ein großartiges Ergebnis erzielt. Die "+anzahlSpieler+" Schülerinnen und", 2, 94);
+  text("Schüler der Klasse erreichten in "+anzahlSpiele+" Spielen eine Gesamtpunktzahl",2,106);
+  text("von "+summe+". Das ist ein Durchschnitt von "+durchschnitt+" pro Spiel.",2,118);
+
+}
+
+
+public int berechneSumme(int[] zahlen) {
+  int summe;
+
+  // Sind überhaupt Daten da?
+  if(zahlen.length==0 ) { //<>//
+    return -1;
+  }
+  
+  // Startwerte setzen
+  summe = 0;
+  
+  // Alle Arrayelemente untersuchen
+  for (int i=0; i< zahlen.length; i++) {
+    summe = summe + zahlen[i];
+  }
+  // Gib die Summe zurück
+  return summe;
+}
+
+
+public double berechneDurchschnitt(int[] zahlen) {
+   double durchschnitt;
+   
+   // Berechne Durchschnitt aus der Summe
+   durchschnitt = (double) berechneSumme(zahlen)/zahlen.length;
+   
+   return durchschnitt;
+}
+
+public int anzahlSpieler(String[] namen) {
+  int anzahl;
+  boolean gefunden;
+  // Startwerte setzen
+  anzahl = 0;
+  
+  // Nach jedem Namen suchen
+  for(int i=0; i< namen.length; i ++) {
+    // Prüfe, ob der i. Name ein neuer Name ist
+    // Kontrolliere dazu alle vorhergehenden, ob ein gleicher Name dabei ist.
+    gefunden = false;
+    for(int j=0; j < i; j++) {
+      // Wenn der Name gleich ist, dann merke dir das
+      if(namen[i].equals(namen[j])) {
+        gefunden = true;
+      }
+    }
+    // Wenn nach Kontrolle aller vorhergehender Namen der aktuelle nicht dabei
+    // ist, dann ist er neu und muss gezählt werden.
+    if (!gefunden) {
+      anzahl++;
+    }
+  }
+  return anzahl;
+}

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/testfall1.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,0
+Spieler1,6
+Spieler2,19
+Spieler6,1
+Spieler4,45
+Spieler3,23
+Spieler3,12
+Spieler2,44
+Spieler1,72
+Spieler5,12
+Spieler6,4
+Spieler7,2
+Spieler4,98
+Spieler3,21
+Spieler3,12
+Spieler2,32
+Spieler1,12
+Spieler5,44
+Spieler3,12

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/testfall2.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,-5
+Spieler1,-6
+Spieler2,-19
+Spieler6,-1
+Spieler4,-45
+Spieler3,-23
+Spieler3,-12
+Spieler2,-44
+Spieler1,-72
+Spieler5,-12
+Spieler6,-4
+Spieler7,-2
+Spieler4,-98
+Spieler3,-21
+Spieler3,-12
+Spieler2,-32
+Spieler1,-12
+Spieler5,-44
+Spieler3,-12

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/testfall3.csv

@@ -0,0 +1,2 @@
+"Name","Punkte"
+Spieler1,45

04_loesungen/01_processing/alg14a_zeitungsmeldung_loesung/testfall4.csv

@@ -0,0 +1 @@
+"Name","Punkte"

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/alg14b_highscoretabelle_loesung.pde

@@ -0,0 +1,136 @@
+
+/**
+ * Balkendiagramm für int-Array, Zahlen werden aus CSV-Datei gelesen, Umwandlung in sortierte Tabelle.
+ * Hinweis zur Benutzung: 
+ * Klicke in das Zeichenfenster
+ * Start des Algorithmus "wastutes" mit Taste "a"
+ * @author Schaller 
+ * @version 29.11.18
+ */
+
+
+// Liste mit allen Werten //<>// //<>// //<>//
+int[]    zahlen;    
+String[] namen;
+
+// Hilfsvariablen für die Suche
+int akt_maximum=-1;    // aktuell groesstes Element
+int akt=-2;            // aktuell untersuchtes Element
+int verzoegerung=1000;  // Geschwindigkeit der Ausführung
+
+// Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("punkte.csv");
+  zeichneBalken();
+}
+
+public void draw() {
+  zeichneBalken();
+}
+
+public void keyPressed() {
+  // Animierte Suche mit Taste "a"
+  if (key=='a') {
+    thread("wastutes");
+  }
+}
+
+
+
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden
+  Table csv = loadTable(name, "header,csv");
+
+  if (csv != null  && csv.getColumnCount()==2) {
+
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    zahlen = new int[csv.getRowCount()];
+    namen = new String[csv.getRowCount()];
+
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < zahlen.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      zahlen[i] = csv.getInt(i, "Punkte");
+      namen[i] = csv.getString(i, "Name");
+    }
+  }
+}
+
+public void zeichneBalken() {
+
+  clear();
+
+  // Überschrift
+  fill(255, 255, 255);
+  textFont(grosseSchrift);
+  text("Punkte", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if (zahlen != null) {
+    for (int i = 0; i< zahlen.length; i++) {
+
+      fill(20, 25, 165);
+      // aktuelle Elemente farblich hervorheben
+      if (i == akt || i == akt+1 ) {
+        fill(140, 230, 20);
+      } 
+
+      // Balkendiagramm zeichnen
+      if (zahlen[i]>=0) rect(120, 25+i*15, zahlen[i]+1, 13);
+
+      // Beschriftung
+      fill(255, 255, 255);
+      text(namen[i], 2, 35+i*15);
+      text(zahlen[i], 70, 35+i*15);
+    }
+  }
+}
+
+
+public void wastutes() {
+  // Sind überhaupt Daten da?
+  if (zahlen.length==0 ) {
+    return;
+  }
+
+
+  // Wiederholen den Durchlauf n-1 mal
+  for (int i = 1; i< zahlen.length; i++) {
+    // Durchlaufe alle Array-Elemente
+    for (akt=0; akt+1 < zahlen.length; akt++) {
+      // Neu zeichnen, da akt neu gesetzt wurde 
+      redraw();
+      delay(verzoegerung);
+      // Vergleiche mit Nachbarelement. Falsch sortiert?
+      if (zahlen[akt+1]> zahlen[akt]) {
+        // Dreieckstausch bei Zahlen und Namen 
+        int dummy = zahlen[akt];
+        zahlen[akt] = zahlen[akt+1];
+        zahlen[akt+1] = dummy;
+
+        String s = namen[akt];
+        namen[akt] = namen[akt+1];
+        namen[akt+1] = s;
+
+        // Zeichne Balken neu, da getauscht wurde
+        redraw();
+        delay(verzoegerung);
+      }
+    }
+  }
+  // Sortierung beendet
+  akt = -2;
+}

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/testfall1.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,0
+Spieler1,6
+Spieler2,19
+Spieler6,1
+Spieler4,45
+Spieler3,23
+Spieler3,12
+Spieler2,44
+Spieler1,72
+Spieler5,12
+Spieler6,4
+Spieler7,2
+Spieler4,98
+Spieler3,21
+Spieler3,12
+Spieler2,32
+Spieler1,12
+Spieler5,44
+Spieler3,12

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/testfall2.csv

@@ -0,0 +1,20 @@
+"Name","Punkte"
+Spieler1,-5
+Spieler1,-6
+Spieler2,-19
+Spieler6,-1
+Spieler4,-45
+Spieler3,-23
+Spieler3,-12
+Spieler2,-44
+Spieler1,-72
+Spieler5,-12
+Spieler6,-4
+Spieler7,-2
+Spieler4,-98
+Spieler3,-21
+Spieler3,-12
+Spieler2,-32
+Spieler1,-12
+Spieler5,-44
+Spieler3,-12

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/testfall3.csv

@@ -0,0 +1,2 @@
+"Name","Punkte"
+Spieler1,45

04_loesungen/01_processing/alg14b_highscoretabelle_loesung/testfall4.csv

@@ -0,0 +1 @@
+"Name","Punkte"

04_loesungen/01_processing/alg15_xydiagramm_loesung_a1/alg15_xydiagramm_loesung_a1.pde

@@ -0,0 +1,114 @@
+/**
+ * XY-Diagramm für Schalldruckpegel, Zahlen werden aus CSV-Datei gelesen.
+ * 
+ * @author Schaller 
+ * @version 29.11.18
+ */
+ 
+ // Liste mit allen Werten
+double[] x_werte;    
+double[] y_werte;    
+
+// Hilfsvariablen für die Suche
+int akt_maximum=-1;    // aktuell groesstes Element
+int akt=-1;            // aktuell untersuchtes Element
+int verzoegerung=0;  // Geschwindigkeit der Ausführung
+
+// Schriften
+PFont kleineSchrift;  
+PFont grosseSchrift;
+
+
+public void setup() {
+  // Zeichenfläche erzeugen
+  size(1000, 700);
+  background(0);
+  // Schriften laden
+  kleineSchrift = loadFont("KleineSchrift.vlw");
+  grosseSchrift = loadFont("GrosseSchrift.vlw");
+
+  // CSV-Datei laden und anzeigen
+  ladeTabelle("Amplitudes.csv");
+  stroke(250,250,200);
+  zeichneBalken();
+}
+
+ //<>//
+public void ladeTabelle(String name) {
+  // Tabelle aus CSV-Datei laden //<>//
+  Table csv = loadTable(name, "header,csv");
+
+  if (csv != null  && csv.getColumnCount()==2) {
+
+    // Initialisiere Arrays, in die alle Zeilen der Tabelle passen
+    x_werte = new double[csv.getRowCount()];
+    y_werte = new double[csv.getRowCount()];
+
+    // Fülle die Arrays mit Werten aus der Tabelle
+    for (int i = 0; i < x_werte.length; i++) {
+      // Lies Wert aus der i. Zeile und der Spalte "Punkte" bzw. "Name"
+      x_werte[i] = csv.getDouble(i, "Time (s)");
+      y_werte[i] = csv.getDouble(i, "Sound pressure level (dB)");
+    }
+  }
+}
+
+public void zeichneBalken() {
+
+
+  // Überschrift
+  fill(255,255,255);
+  textFont(grosseSchrift);
+  text("Lärmpegel", 2, 20);
+  textFont(kleineSchrift);  
+
+  // Alle Einträge darstellen
+  if (x_werte != null) {
+    for (int i = 0; i< x_werte.length; i++) {
+
+      fill(20,25,165);
+      // aktuelle Elemente farblich hervorheben
+      if (i == akt) {
+        fill(140,230,20);
+      } 
+      if (i == akt_maximum) {
+        fill(230,60,140);
+      } 
+
+      // Balkendiagramm zeichnen
+      int breite = (int) y_werte[i];
+      if (x_werte[i]>=0) rect(160, 25+i*15, breite+1, 13);
+
+      // Beschriftung
+      fill(255,255,255);
+      text(""+x_werte[i], 2, 35+i*15);
+      text(""+y_werte[i], 70, 35+i*15);
+    }
+  }
+}
+
+
+public int sucheMaximum(int[] zahlen) {
+  // Sind überhaupt Daten da?
+  if (zahlen.length==0 ) {
+    return -1;
+  }
+
+  // Startwerte setzen
+  akt_maximum = 0;
+  akt = 1;
+
+  // Alle Arrayelemente untersuchen
+  while (akt < zahlen.length) {
+
+    // Neues größtes Element??
+    if (zahlen[akt]> zahlen[akt_maximum]) {
+      // Dann merke dir das neue 
+      akt_maximum = akt;
+
+    }
+    akt = akt + 1;
+  }
+  // Gib Position des größten Elements zurück
+  return akt_maximum;
+} //<>//

04_loesungen/01_processing/alg15_xydiagramm_loesung_a1/punkte.csv

@@ -0,0 +1,6 @@
+"Name","Punkte"
+Niko,216
+Klaus,591
+Anna,857
+Lena,180
+Winfried,168