Übungsaufgaben zu Datentypen, Variablen und Arrays

Kopiere den Text in ein KI-Sprachmodell Deiner Wahl und passe Kompetenzstufe, Anzahl, Bearbeitungszeit und Szenario bei Bedarf an. Wie die Aufgaben aufgebaut sind, beschreibt der Artikel Wie sind die Aufgaben aufgebaut?. Prüfe die Ergebnisse mit dem Lehrartikel: KI-Sprachmodelle machen Fehler.

Erstelle neue Übungsaufgaben zum Thema „Datentypen, Variablen und
Arrays“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/datentypen-variablen
- https://oer-informatik.de/algorithmen-prozedural
- https://oer-informatik.de/speicherbedarf
- https://oer-informatik.de/datenaustauschformate
- Stilbeispiel: https://oer-informatik.de/datentypen-variablen-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Datentyp
- Wertebereich
- Überlauf
- Speicherbedarf
- Array
- Index
- globale Variable
- Namenskonvention
- CSV

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Geg.: int8_t = 8 Bit mit Vorzeichen, uint16_t = 16 Bit ohne Vorzeichen, größter CO₂-Wert 5.000

Ges.: Wertebereiche; kleinste Bitzahl n mit 2^n - 1 \geq 5.000

\begin{aligned} \texttt{int8\_t:}\quad -2^{7} = -128 \ \dots\ 2^{7} - 1 &\Rightarrow \underline{\underline{-128 \ \dots\ 127}}\\ \texttt{uint16\_t:}\quad 0 \ \dots\ 2^{16} - 1 &\Rightarrow \underline{\underline{0 \ \dots\ 65.535}}\\ 2^{12} - 1 = 4.095 < 5.000 \leq 8.191 = 2^{13} - 1 &\Rightarrow \underline{\underline{n = 13\ \text{Bit}}} \end{aligned}

13 Bit gibt es als Typ nicht; der nächstgrößere Typ ist uint16_t (2 Byte).

Punkte: je Wertebereich 2 Punkte (je 1 Punkt für untere und obere Grenze), Bitzahl mit Typwahl 1 Punkt.

Je Zeile 2 Punkte (Urteil 1 Punkt, besserer Typ mit Begründung 1 Punkt; bei „passt“ zählt die Begründung):

Geg.: 12 Türschilder, eine Messung alle 5 min, 7 Tage; Datensatz int16_t (2 Byte) + uint16_t (2 Byte) + uint8_t (1 Byte) + bool (1 Byte); Vergleich float (4 Byte) + 2 × int32_t (je 4 Byte) + bool (1 Byte)

Ges.: Speicherbedarf je Woche in KiB für beide Varianten, Ersparnis in %

\begin{aligned} \text{I:}\quad n_{\text{Messungen}} &= \frac{24 \cdot 60\ \text{min}}{5\ \text{min}} \cdot 7 \cdot 12 = 288 \cdot 84 = 24.192\\ \text{II:}\quad s_{\text{Datensatz}} &= 2\ \text{B} + 2\ \text{B} + 1\ \text{B} + 1\ \text{B} = 6\ \text{B}\\ \text{I, II eingesetzt:}\quad S &= 24.192 \cdot 6\ \text{B} = 145.152\ \text{B} = \frac{145.152}{1.024}\ \text{KiB} = \underline{\underline{141{,}75\ \text{KiB}}}\\ \text{Vergleich:}\quad S' &= 24.192 \cdot (4 + 4 + 4 + 1)\ \text{B} = 314.496\ \text{B} = \frac{314.496}{1.024}\ \text{KiB} = \underline{\underline{307{,}125\ \text{KiB}}}\\ \text{Ersparnis:}\quad & 1 - \frac{6}{13} \approx \underline{\underline{53{,}8\ \%}} \end{aligned}

Die speichersparende Variante braucht weniger als die Hälfte des Speichers.

Punkte: Anzahl der Messungen 1 P, Datensatzgröße 1 P, Speicherbedarf 1 P, Vergleichswert 1 P, Ersparnis 1 P.

Erläuterung (2 Punkte): Es kommt zu einem Überlauf. Der größte Wert ist 65.535; wird er um 1 erhöht, passt das Ergebnis nicht mehr in 16 Bit. Das überzählige Bit fällt weg, und der Zähler springt auf 0 zurück. Es gibt keine Fehlermeldung, die Statistik ist danach einfach falsch.

Geg.: größter Wert 65.535, eine Aktualisierung je 5 min

Ges.: Zeit bis zum ersten Überlauf in Tagen

t = (65.535 + 1) \cdot 5\ \text{min} = 327.680\ \text{min} = \frac{327.680}{60 \cdot 24}\ \text{d} \approx \underline{\underline{227{,}556\ \text{d}}}

Nach gut 227 Tagen (etwa 7,5 Monaten) Dauerbetrieb läuft der Zähler über (2 Punkte; ein Ergebnis mit 65.535 statt 65.536 Aktualisierungen ist ebenfalls zu werten).

Je Möglichkeit mit richtigem Ergebnis 2 Punkte, z. B.:

Hinweis: Für eine Anzeige ist Runden meist sinnvoller als Abschneiden, weil 21,7 °C näher an 22 °C liegt.

uint8_t akkustand[12];
akkustand[11] = 100;

• Das Array braucht 12 Elemente, eines je Türschild (1 Punkt).
• Der Index beginnt bei 0, Türschild Nr. 12 liegt deshalb bei Index 11 (1 Punkt).
• Folge im Entwurf (2 Punkte): Ein Array mit 11 Elementen hat die Indizes 0 bis 10. akkustand[12] liegt außerhalb. C++ prüft die Grenzen nicht; der Wert 100 wird einfach in den Speicher hinter dem Array geschrieben und kann dort eine andere Variable unbemerkt überschreiben. Java oder C# würden stattdessen eine Ausnahme werfen.

In Zeile 7 wird in der Methode pruefe() eine neue lokale Variable z deklariert. Sie hat denselben Namen wie die Klassenvariable z aus Zeile 3 und verdeckt diese innerhalb der Methode. Die Schleife erhöht deshalb nur die lokale Variable (2 Punkte). Diese verschwindet am Ende der Methode; die Klassenvariable z, die in Zeile 18 ausgegeben wird, behält ihren Startwert 0 (2 Punkte).

static int zaehleSchwacheAkkus(int[] kapazitaeten) {
    int anzahl = 0;                              // lokaler Zähler
    for (int i = 0; i < kapazitaeten.length; i++) {
        if (kapazitaeten[i] < grenze) {
            anzahl = anzahl + 1;
        }
    }
    return anzahl;
}

public static void main(String[] args) {
    int[] kapazitaeten = {92, 64, 71, 38, 85, 69, 100, 77};
    int schwache = zaehleSchwacheAkkus(kapazitaeten);
    System.out.println("Schwache Akkus: " + schwache);   // 3
}

Punkte: Methodenkopf mit Array-Parameter und Rückgabetyp int 2 P, lokaler Zähler und return 2 P, Aufruf mit Übernahme des Rückgabewerts in eine lokale Variable 1 P, Begründung 1 P.

Begründung: Es gibt nur noch einen Zähler, und der ist lokal in der Methode. Das Ergebnis verlässt die Methode ausschließlich über den Rückgabewert; eine gleichnamige Variable an anderer Stelle kann nichts mehr verdecken oder verfälschen. Die Klassenvariablen k und z werden überflüssig. Die Konstante grenze darf in der Klasse bleiben, weil sie nur gelesen wird. Nebenbei lässt sich die Methode jetzt mit beliebigen Testarrays einzeln prüfen.

static double berechneZustand(int gemesseneWh, int nennWh)

Methodenkopf 3 Punkte: Rückgabetyp double (Nachkommastellen), zwei int-Parameter, Reihenfolge wie in der Beschreibung.

Aufrufe je 1 Punkt:

• A – Compilerfehler: Der Rückgabewert ist double und darf nicht ohne Cast einer int-Variablen zugewiesen werden, weil Nachkommastellen verloren gingen.
• B – wird übersetzt, rechnet aber falsch: Die Argumente sind vertauscht. Statt 412 : 500 \cdot 100 = 82{,}4\ \% ergibt sich 500 : 412 \cdot 100 \approx 121{,}4\ \%. Der Compiler bemerkt das nicht, weil beide Parameter denselben Typ haben.
• C – korrekt, liefert 82,4.

Je Bezeichner 1 Punkt (aussagekräftig und richtige Schreibweise), Begründung 1 Punkt, z. B.:

Begründung: grenze ist mit static final eine Konstante. Die durchgehende Großschreibung zeigt an jeder Verwendungsstelle sofort, dass sich der Wert nicht ändert und an einer zentralen Stelle festgelegt ist; Variablen dagegen werden in lowerCamelCase geschrieben.

• Dafür (2 Punkte), z. B.: Über den Index ist jeder Ladeplatz direkt und sehr schnell erreichbar; die Werte liegen ohne Verwaltungsaufwand hintereinander im Speicher und lassen sich bequem mit einer Schleife durchlaufen.

• Dagegen (2 Punkte), z. B.: Ein Array hat eine feste Länge. Kommen Ladeplätze hinzu, muss ein neues, größeres Array angelegt und umkopiert werden; fallen Plätze weg, belegen ungenutzte Elemente trotzdem Speicher. Außerdem kann ein Array nur Werte eines Datentyps aufnehmen (z. B. keine Seriennummer neben der Kapazität).

• Alternative (2 Punkte): eine dynamische Liste wie ArrayList<Integer> (bzw. eine Liste von Objekten einer Klasse Ladeplatz mit Nummer, Seriennummer und Kapazität), die bei Bedarf wächst und schrumpft.

Je richtigem Schritt 1 Punkt. Ohne Hilfsvariable wäre der alte Wert von k[i] nach k[i] = k[j]; verloren.

Ursache (3 Punkte): Das Komma wird doppelt verwendet – als Trennzeichen zwischen den Feldern und, wegen der deutschen Formatierung, als Dezimalzeichen. Die Tabellenkalkulation trennt 92,5 deshalb in die zwei Spalten 92 und 5. Für CSV gibt es keine verbindliche Festlegung, welches Trenn- und Dezimalzeichen gilt; das schreibende und das lesende Programm müssen aufeinander abgestimmt werden.

Abhilfen (je 1 Punkt), z. B.:

• Semikolon als Trennzeichen verwenden (in deutschsprachigen Programmen üblich): 1;BX-4471;92,5.
• Felder mit Dezimalkomma in Anführungszeichen setzen: 1,BX-4471,"92,5" (so sieht es RFC 4180 vor).
• Die Zahl ohne Dezimalkomma schreiben, z. B. in Zehntelprozent als Ganzzahl (925) oder mit Punkt und beim Import als englisches Zahlenformat einlesen.

Beurteilung JSON (2 Punkte): JSON trennt Felder eindeutig und kennt Zahlen als eigenen Datentyp, das Problem träte also nicht auf. Eine Tabellenkalkulation öffnet JSON aber nicht direkt als Tabelle, Natalia bräuchte einen Import-Schritt oder ein Zusatzwerkzeug. Für flache Tageslisten, die in eine Tabelle sollen, bleibt eine sauber abgestimmte CSV-Datei die einfachere Lösung. (Eine begründete Entscheidung für JSON ist ebenfalls zu werten.)

Je richtiger Entscheidung 1 Punkt:

1. richtig – Deklaration und Initialisierung lassen sich zusammenfassen; das ist sogar der Normalfall.
2. richtig – Klassen- und Objektattribute erhalten in Java Standardwerte (0, false, null). Nur lokale Variablen bekommen keinen und müssen vor dem Lesen einen Wert erhalten.
3. falsch – beide Operanden sind int, es findet eine Ganzzahldivision statt: mitte enthält 3.
4. falsch – das ist eine Zuweisung. Sie setzt voraus, dass anzahl schon einen Wert hat, sonst meldet der Compiler bei einer lokalen Variablen einen Fehler.
5. richtig – z. B. final int grenze; und später genau einmal grenze = 70;. Eine zweite Zuweisung lehnt der Compiler ab.