Informatik am GSG

Wählen Sie zunächst aus, ob Sie auf dem grünen Niveau (Einstieg), blauen Niveau (Standard) oder lila Niveau (Fortgeschritten) arbeiten möchten. Sie können jederzeit wechseln.

1. Dokumentieren Sie die Werteveränderung der folgenden Programme mittels Tracetabellen. Aufgabenteil a

   int x = 12;
   int y;
   if (x > 10) {
       y = x * 2;
   } else {
       y = x - 2;
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil b

   int summe = 0;
   for (int i = 1; i <= 6; i++) {
       if (i % 2 == 0) {
           summe += i;
       }
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil c

   int[] zahlen = {1, 2, 3, 4, 5};
   int summe = 0;
   for (int i = 0; i < zahlen.length; i++) {
       summe += zahlen[i];
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
2. Dokumentieren Sie die Werteveränderung der folgenden Programme mittels Tracetabellen. Aufgabenteil a

   Dieser Algorithmus ermittelt den größten Wert in einer Reihung. Prüfe mittels einer Tracetabelle, ob dies der Fall ist.

   int[] zahlen = {3, 5, 2, 8, 1};
   int max = zahlen[0];
   for (int i = 1; i < zahlen.length; i++) {
       if (zahlen[i] > max) {
           max = zahlen[i];
       }
   }
   println("Größte Zahl: " + max);
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil b

   Dieser Algorithmus ermittelt die Anzahl an negativen und positiven Werte aus einer Reihung.

   int[] zahlen = {-3, 5, -2, 8, 1, -7};
   int positiveCount = 0;
   int negativeCount = 0;
   
   for (int i = 0; i < zahlen.length; i++) {
       if (zahlen[i] > 0) {
           positiveCount++;
       } else {
           negativeCount++;
       }
   }
   println("Positive Zahlen: " + positiveCount);
   println("Negative Zahlen: " + negativeCount);
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil c

   Dieser Algorithmus speichert die Werte einer Reihung in umgekehrter Reihenfolge in einer zweiten Reihung. Dokumentieren Sie auch die Werteveränderung von zahlen.length - 1 - i.

   int[] zahlen = {1, 2, 3, 4, 5};
   int[] umgekehrt = new int[zahlen.length];
   
   for (int i = 0; i < zahlen.length; i++) {
       umgekehrt[i] = zahlen[zahlen.length - 1 - i];
   }
   
   println("Umgekehrte Reihenfolge:");
   for (int i = 0; i < umgekehrt.length; i++) {
       println(umgekehrt[i]);
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
3. Dokumentieren Sie die Werteveränderung der folgenden Programme mittels Tracetabellen. Aufgabenteil a

   Der folgende Algorithmus sortiert die Werte in einer Reihung und gibt am Ende die Reihung aus.

   int[] zahlen = {5, 3, 8, 4, 2};
   int n = zahlen.length;
   
   for (int i = 0; i < n - 1; i++) {
       for (int j = 0; j < n - 1 - i; j++) {
           if (zahlen[j] > zahlen[j + 1]) {
               // Tauschen
               int temp = zahlen[j];
               zahlen[j] = zahlen[j + 1];
               zahlen[j + 1] = temp;
           }
       }
   }
   
   println("Sortierte Zahlen:");
   for (int i = 0; i < zahlen.length; i++) {
       println(zahlen[i]);
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil b

   Der folgende Algorithmus zählt die Anzahl der Inversionen in einer Reihung. Eine Inversion liegt vor, wenn für ein Paar von Indizes i und j gilt, dass iarr[j]. Also anders ausgedrückt: i ist kleiner j, aber für die Werte der Reihungen bei den beiden Indizes ist es genau andersherum: bei ist i ist der größere Wert als bei j.

   int[] arr = {2, 4, 1, 3, 5};
   int inversions = 0;
   
   for (int i = 0; i < arr.length; i++) {
       for (int j = i + 1; j < arr.length; j++) {
           if (arr[i] > arr[j]) {
               inversions++;
           }
       }
   }
   
   println("Anzahl der Inversionen: " + inversions);
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen
   Aufgabenteil c

   Der folgende Algorithmus vergleicht die Werte zweier Reihungen miteinander und speichert die Werte, die einzigartig sind (also nur in einer Reihung vorkommt) in einer dritten Reihung. Der Befehl break sorgt dafür, dass in diesem Fall For-Schleife mit dem j beendet wird.

   int[] array1 = {1, 2, 3, 4, 5};
   int[] array2 = {4, 5, 6, 7, 8};
   int[] uniqueElements = new int[array1.length + array2.length];
   int count = 0;
   
   // Elemente nur in array1
   for (int i = 0; i < array1.length; i++) {
       boolean gefunden = false;
       for (int j = 0; j < array2.length; j++) {
           if (array1[i] == array2[j]) {
               gefunden = true;
               break;
           }
       }
       if (!gefunden) {
           uniqueElements[count] = array1[i];
           count++;
       }
   }
   
   // Elemente nur in array2
   for (int i = 0; i < array2.length; i++) {
       boolean gefunden = false;
       for (int j = 0; j < array1.length; j++) {
           if (array2[i] == array1[j]) {
               gefunden = true;
               break;
           }
       }
       if (!gefunden) {
           uniqueElements[count] = array2[i];
           count++;
       }
   }
   
   println("Einzigartige Elemente:");
   for (int i = 0; i < count; i++) {
       println(uniqueElements[i]);
   }
   
   

   Hilfe 1 anzeigen Hilfe 2 anzeigen