Yandrik/oscars-dojo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: initial commit

Browse Source
This commit is contained in:
Yandrik
2025-07-05 00:07:04 +02:00
commit 2668db0f18
14 changed files with 3679 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

565
data/exercises.ts Normal file
View File

@ -0,0 +1,565 @@
import { Exercise } from '../types';
export const exercises: Exercise[] = [
{
id: 'ex1',
title: 'Aufgabe 7: Datenstruktur - Dictionary',
parts: [
{
id: 'a',
prompt: 'Definieren Sie in der Programmiersprache C eine Struktur `dictionary` mit drei Komponenten:\n- `key` für ein Wort mit bis zu 40 Zeichen\n- `answer` für einen Satz mit bis zu 100 Zeichen\n- `random` für ganzzahlige Zufallswerte\n\nDefinieren Sie dann eine neuen Datentyp `DICT` für diese Struktur.',
solution: 'typedef struct dictionary {\n char key[40];\n char answer[100];\n int random;\n} DICT;',
points: 5,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Initialisieren Sie ein Array `chatGPT` vom Datentyp `DICT` mit 3 Einträgen mit den Werten der nachfolgenden Tabelle:\n| key | answer | random |\n|---|---|---|\n| hello | hi | 1 |\n| you | me? | 2 |\n| I | you? | 3 |',
solution: 'DICT chatGPT[3] = {\n {"hello", "hi", 1},\n {"you", "me?", 2},\n {"I", "you?", 3}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Setzen Sie einen Strukturzeiger `p_chat` auf den dritten Struktureintrag aus Teil b) und setzen Sie die Komponente `random` auf einen zufälligen Wert 0 bis 3. (`rand() % 4` liefert Zufallswerte)',
solution: 'DICT *p_chat = &chatGPT[2];\np_chat->random = rand() % 4;',
points: 1,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct dictionary {\n char key[40];\n char answer[100];\n int random;\n} DICT;\n```\n- `typedef struct ... NAME;` wird verwendet, um einen neuen Datentyp zu definieren. Das ist kürzer als jedes Mal `struct dictionary` zu schreiben.\n- `char key[40];` deklariert ein Zeichen-Array (String) für das `key`-Feld.\n- `int random;` deklariert ein einfaches Integer für den `random`-Wert.\n- Die Reihenfolge der Elemente in der Struktur ist für die Funktionalität nicht relevant, aber es ist guter Stil, sie logisch zu gruppieren.\n\n**Teil b)**\n```c\nDICT chatGPT[3] = {\n {"hello", "hi", 1},\n {"you", "me?", 2},\n {"I", "you?", 3}\n};\n```\n- `DICT chatGPT[3]` deklariert ein Array mit 3 Elementen vom Typ `DICT`.\n- Die Initialisierung `{ ... }` verwendet geschweifte Klammern für jedes Strukturelement im Array, wobei die Werte in der Reihenfolge der Strukturdefinition angegeben werden.\n\n**Teil c)**\n```c\nDICT *p_chat = &chatGPT[2];\np_chat->random = rand() % 4;\n```\n- `DICT *p_chat` deklariert einen Zeiger auf eine `DICT`-Struktur.\n- `&chatGPT[2]` holt die Speicheradresse des dritten Elements im Array (Indizes sind 0-basiert).\n- Der `->` Operator wird verwendet, um auf Strukturelemente über einen Zeiger zuzugreifen. `p_chat->random` ist äquivalent zu `(*p_chat).random`.'
},
{
id: 'ex2',
title: 'Aufgabe 7: Datenstruktur - Bundesliga',
parts: [
{
id: 'a',
prompt: 'Definieren Sie in C einen eigenen Datentyp `BUNDESLIGA` und gleichzeitig einen Strukturzeigertyp `PBUNDESLIGA` zu einer unbenannten Struktur mit:\n- `verein`: Zeichenkette mit 20 Buchstaben\n- `platz`: ganze, vorzeichenlose Zahl\n- `torv`: Datentyp `struct torverhaeltnis` (vorgegeben: `struct torverhaeltnis{ int tore; int gegentore;};`)',
solution: 'struct torverhaeltnis{ int tore; int gegentore;};\ntypedef struct {\n char verein[20];\n unsigned int platz;\n struct torverhaeltnis torv;\n} BUNDESLIGA, *PBUNDESLIGA;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `podest` mit 3 Einträgen und initialisieren Sie es. Deklarieren Sie einen Zeiger `ppodest` und lassen Sie ihn auf das Array zeigen.\n| Vereinsname | Platz | Torverhältnis |\n|---|---|---|\n| Bayern Muenchen | 1 | 92 zu 68 |\n| Borussia Dortmund | 2 | 83 zu 44 |\n| RB Leipzig | 3 | 64 zu 41 |',
solution: 'BUNDESLIGA podest[3] = {\n {"Bayern Muenchen", 1, {92, 68}},\n {"Borussia Dortmund", 2, {83, 44}},\n {"RB Leipzig", 3, {64, 41}}\n};\nPBUNDESLIGA ppodest = podest;',
points: 5,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Geben Sie mithilfe der `printf()`-Funktion den Eintrag `torv` von Borussia Dortmund in der Formatierung `83:44` aus. Verwenden Sie hierzu den Zeiger `ppodest`.',
solution: 'printf("%d:%d", (ppodest + 1)->torv.tore, (ppodest + 1)->torv.gegentore);',
points: 2,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\nstruct torverhaeltnis{ int tore; int gegentore;};\ntypedef struct {\n char verein[20];\n unsigned int platz;\n struct torverhaeltnis torv;\n} BUNDESLIGA, *PBUNDESLIGA;\n```\n- Eine anonyme Struktur wird verwendet (`struct { ... }`), da der Name der Struktur selbst nicht benötigt wird, nur der `typedef`.\n- `typedef struct { ... } BUNDESLIGA, *PBUNDESLIGA;` ist eine Abkürzung, um sowohl den Datentyp als auch einen Zeigertyp zu definieren.\n- `unsigned int` wird für `platz` verwendet, da Tabellenplätze nicht negativ sind.\n- Die `struct torverhaeltnis` ist verschachtelt.\n\n**Teil b)**\n```c\nBUNDESLIGA podest[3] = {\n {"Bayern Muenchen", 1, {92, 68}},\n {"Borussia Dortmund", 2, {83, 44}},\n {"RB Leipzig", 3, {64, 41}}\n};\nPBUNDESLIGA ppodest = podest;\n```\n- Bei der Initialisierung einer verschachtelten Struktur werden innere geschweifte Klammern `{}` verwendet: `{92, 68}` für `torv`.\n- Ein Zeiger auf ein Array zu setzen (`PBUNDESLIGA ppodest = podest;`) lässt den Zeiger auf das erste Element des Arrays (`&podest[0]`) zeigen.\n\n**Teil c)**\n```c\nprintf("%d:%d", (ppodest + 1)->torv.tore, (ppodest + 1)->torv.gegentore);\n```\n- Zeigerarithmetik wird verwendet, um auf das zweite Element zuzugreifen: `ppodest + 1`.\n- `(ppodest + 1)->torv` greift auf die verschachtelte Struktur zu.\n- `.tore` und `.gegentore` werden dann von dieser inneren Struktur aus mit dem Punkt-Operator aufgerufen.'
},
{
id: 'ex3',
title: 'Aufgabe: Studentendatenbank',
parts: [
{
id: 'a',
prompt: 'Definieren Sie eine Struktur `student` mit den Elementen `name` (Zeichenkette, max. 50), `student_id` (Integer) und `grades` (Array von 5 Integern). Erstellen Sie einen neuen Datentyp `STUDENT` und einen Zeigertyp `PSTUDENT` dafür.',
solution: 'typedef struct student {\n char name[50];\n int student_id;\n int grades[5];\n} STUDENT, *PSTUDENT;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren und initialisieren Sie ein Array `klasse` vom Typ `STUDENT` mit zwei Studenten:\n1. Max Mustermann, ID 12345, Noten: 1, 2, 1, 3, 2\n2. Erika Mustermann, ID 54321, Noten: 2, 2, 3, 1, 1',
solution: 'STUDENT klasse[2] = {\n {"Max Mustermann", 12345, {1, 2, 1, 3, 2}},\n {"Erika Mustermann", 54321, {2, 2, 3, 1, 1}}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_student` vom Typ `PSTUDENT`, der auf den zweiten Studenten im `klasse`-Array zeigt. Ändern Sie die dritte Note dieses Studenten auf `1`.',
solution: 'PSTUDENT p_student = &klasse[1];\np_student->grades[2] = 1;',
points: 2,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct student {\n char name[50];\n int student_id;\n int grades[5];\n} STUDENT, *PSTUDENT;\n```\n- Die Struktur `student` kombiniert verschiedene Datentypen.\n- `grades[5]` ist ein Array als Strukturelement.\n- `*PSTUDENT` definiert `PSTUDENT` als Zeigertyp auf die `STUDENT`-Struktur.\n\n**Teil b)**\n```c\nSTUDENT klasse[2] = {\n {"Max Mustermann", 12345, {1, 2, 1, 3, 2}},\n {"Erika Mustermann", 54321, {2, 2, 3, 1, 1}}\n};\n```\n- Das Array von Strukturen wird initialisiert.\n- `{1, 2, 1, 3, 2}` ist die Initialisierungsliste für das `grades`-Array innerhalb der Struktur.\n\n**Teil c)**\n```c\nPSTUDENT p_student = &klasse[1];\np_student->grades[2] = 1;\n```\n- Der Zeiger `p_student` wird mit dem Typ `PSTUDENT` deklariert.\n- `&klasse[1]` holt die Adresse des zweiten Elements.\n- `p_student->grades` greift auf das Noten-Array zu. `[2]` wählt das dritte Element aus, das dann überschrieben wird.'
},
{
id: 'ex4',
title: 'Aufgabe: Punkt im 3D-Raum',
parts: [
{
id: 'a',
prompt: 'Definieren Sie mittels `typedef` einen Datentyp `POINT3D` und einen Zeigertyp `PPOINT3D` für eine anonyme Struktur, die drei `double`-Werte `x`, `y` und `z` enthält.',
solution: 'typedef struct {\n double x;\n double y;\n double z;\n} POINT3D, *PPOINT3D;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren und initialisieren Sie zwei Variablen `p1` und `p2` vom Typ `POINT3D` mit beliebigen Werten.',
solution: 'POINT3D p1 = {10.5, -5.0, 3.2};\nPOINT3D p2 = {-2.0, 4.1, 7.8};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_p2` vom Typ `PPOINT3D`, der auf die Variable `p2` zeigt. Geben Sie die z-Koordinate von `p2` mittels des Zeigers und `printf` aus.',
solution: 'PPOINT3D p_p2 = &p2;\nprintf("Z-Koordinate: %f", p_p2->z);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n double x;\n double y;\n double z;\n} POINT3D, *PPOINT3D;\n```\n- Eine anonyme Struktur wird direkt mit `typedef` verwendet, um den Typ `POINT3D` und den Zeigertyp `PPOINT3D` zu erstellen.\n\n**Teil b)**\n```c\nPOINT3D p1 = {10.5, -5.0, 3.2};\nPOINT3D p2 = {-2.0, 4.1, 7.8};\n```\n- Variablen vom Struktur-Typ werden mit einer Initialisierungsliste `{}` deklariert.\n\n**Teil c)**\n```c\nPPOINT3D p_p2 = &p2;\nprintf("Z-Koordinate: %f", p_p2->z);\n```\n- Der Zeiger `p_p2` wird mit dem Typ `PPOINT3D` und der Adresse von `p2` initialisiert.\n- `p_p2->z` ist die korrekte Schreibweise, um über einen Zeiger auf ein Strukturelement zuzugreifen. Der Format-Specifier für `double` ist `%f`.'
},
{
id: 'ex5',
title: 'Aufgabe: Buchinventar',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `BOOK` und einen Zeigertyp `PBOOK` für eine Struktur mit:\n- `title` (max. 100 Zeichen)\n- `author` (max. 50 Zeichen)\n- `isbn` (long integer)\n- `stock` (vorzeichenlose Ganzzahl)',
solution: 'typedef struct {\n char title[100];\n char author[50];\n long isbn;\n unsigned int stock;\n} BOOK, *PBOOK;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `inventory` mit 2 Büchern und initialisieren Sie es mit fiktiven Daten.',
solution: 'BOOK inventory[2] = {\n {"The C Programming Language", "Kernighan & Ritchie", 9780131103627, 10},\n {"Clean Code", "Robert C. Martin", 9780132350884, 5}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Erstellen Sie einen Zeiger `p_book` vom Typ `PBOOK`, der auf das zweite Buch im `inventory` zeigt. Reduzieren Sie dessen `stock` um 1.',
solution: 'PBOOK p_book = &inventory[1];\np_book->stock--;',
points: 2,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n char title[100];\n char author[50];\n long isbn;\n unsigned int stock;\n} BOOK, *PBOOK;\n```\n- Die Struktur fasst relevante Informationen zu einem Buch zusammen. `long` wird für die ISBN verwendet, um große Zahlen zu speichern.\n- `*PBOOK` definiert den Zeigertyp `PBOOK`.\n\n**Teil b)**\n```c\nBOOK inventory[2] = {\n {"The C Programming Language", "Kernighan & Ritchie", 9780131103627, 10},\n {"Clean Code", "Robert C. Martin", 9780132350884, 5}\n};\n```\n- Ein Array von Strukturen wird deklariert und mit den Daten für zwei Bücher initialisiert.\n\n**Teil c)**\n```c\nPBOOK p_book = &inventory[1];\np_book->stock--;\n```\n- Der Zeiger `p_book` vom Typ `PBOOK` zeigt auf das Element mit Index 1 (das zweite Buch).\n- Der Dekrement-Operator `--` kann direkt auf das Strukturelement `stock` über den Zeiger angewendet werden.'
},
{
id: 'ex6',
title: 'Aufgabe: Computerspezifikationen',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `PC` und einen Zeigertyp `PPC` für eine Struktur `computer` mit:\n- `cpu_speed_ghz` (Fließkommazahl)\n- `ram_gb` (Ganzzahl)\n- `storage_gb` (Ganzzahl)',
solution: 'typedef struct computer {\n float cpu_speed_ghz;\n int ram_gb;\n int storage_gb;\n} PC, *PPC;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `office_pcs` mit 2 Einträgen vom Typ `PC` und initialisieren Sie es.',
solution: 'PC office_pcs[2] = {\n {3.4, 16, 512},\n {2.9, 8, 256}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_pc` vom Typ `PPC`, der auf den ersten PC im Array zeigt. Geben Sie dessen `ram_gb` mit `printf` aus.',
solution: 'PPC p_pc = office_pcs;\nprintf("RAM: %d GB", p_pc->ram_gb);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct computer {\n float cpu_speed_ghz;\n int ram_gb;\n int storage_gb;\n} PC, *PPC;\n```\n- `float` ist für die CPU-Geschwindigkeit geeignet.\n- Gleichzeitig wird der Zeigertyp `PPC` (äquivalent zu `PC*`) definiert.\n\n**Teil b)**\n```c\nPC office_pcs[2] = {\n {3.4, 16, 512},\n {2.9, 8, 256}\n};\n```\n- Initialisierung eines Arrays von Strukturen.\n\n**Teil c)**\n```c\nPPC p_pc = office_pcs;\nprintf("RAM: %d GB", p_pc->ram_gb);\n```\n- Der Zeiger `p_pc` wird mit dem Typ `PPC` deklariert. Eine Zuweisung auf den Array-Namen (`office_pcs`) lässt ihn auf das erste Element zeigen.\n- `p_pc->ram_gb` greift auf den Arbeitsspeicher des ersten PCs zu.'
},
{
id: 'ex7',
title: 'Aufgabe: Mitarbeiterakte (verschachtelt)',
parts: [
{
id: 'a',
prompt: 'Definieren Sie eine Struktur `personal_info` mit `name` (max. 50 Zeichen) und `address` (max. 100 Zeichen). Definieren Sie dann eine Struktur `employee`, die eine `employee_id` (long), ein `salary` (double) und eine verschachtelte Struktur vom Typ `personal_info` mit dem Namen `contact` enthält. Erstellen Sie den Datentyp `EMPLOYEE` und den Zeigertyp `PEMPLOYEE`.',
solution: 'struct personal_info {\n char name[50];\n char address[100];\n};\ntypedef struct employee {\n long employee_id;\n double salary;\n struct personal_info contact;\n} EMPLOYEE, *PEMPLOYEE;',
points: 4,
type: 'struct-definition',
},
{
id: 'b',
prompt: 'Deklarieren und initialisieren Sie eine Variable `new_hire` vom Typ `EMPLOYEE` mit fiktiven Daten.',
solution: 'EMPLOYEE new_hire = {\n 1001,\n 65000.50,\n {"John Doe", "123 Main St, Anytown"}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_emp` vom Typ `PEMPLOYEE` auf `new_hire`. Geben Sie die Adresse des Mitarbeiters über den Zeiger aus.',
solution: 'PEMPLOYEE p_emp = &new_hire;\nprintf("Address: %s", p_emp->contact.address);',
points: 2,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\nstruct personal_info {\n char name[50];\n char address[100];\n};\ntypedef struct employee {\n long employee_id;\n double salary;\n struct personal_info contact;\n} EMPLOYEE, *PEMPLOYEE;\n```\n- Dies zeigt die Definition einer verschachtelten Struktur. `employee` enthält eine Variable vom Typ `struct personal_info`.\n- Der `typedef` erstellt `EMPLOYEE` für die Struktur und `PEMPLOYEE` für einen Zeiger darauf.\n\n**Teil b)**\n```c\nEMPLOYEE new_hire = {\n 1001,\n 65000.50,\n {"John Doe", "123 Main St, Anytown"}\n};\n```\n- Bei der Initialisierung einer Struktur, die eine andere Struktur enthält, werden verschachtelte `{}` für die innere Struktur verwendet.\n\n**Teil c)**\n```c\nPEMPLOYEE p_emp = &new_hire;\nprintf("Address: %s", p_emp->contact.address);\n```\n- Der Zeiger `p_emp` wird mit dem Typ `PEMPLOYEE` deklariert.\n- `p_emp->contact` greift auf die innere `personal_info`-Struktur zu. Von dort aus wird mit `.address` auf das `address`-Feld zugegriffen.'
},
{
id: 'ex8',
title: 'Aufgabe: Musik-Track',
parts: [
{
id: 'a',
prompt: 'Definieren Sie via `typedef` einen Datentyp `TRACK` und einen Zeigertyp `PTRACK` für eine anonyme Struktur mit `title` (max. 60), `artist` (max. 40) und `duration_seconds` (int).',
solution: 'typedef struct {\n char title[60];\n char artist[40];\n int duration_seconds;\n} TRACK, *PTRACK;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `playlist` vom Typ `TRACK` mit 3 Einträgen und initialisieren Sie es.',
solution: 'TRACK playlist[3] = {\n {"Bohemian Rhapsody", "Queen", 355},\n {"Stairway to Heaven", "Led Zeppelin", 482},\n {"Hotel California", "Eagles", 391}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Lassen Sie einen Zeiger `p_track` vom Typ `PTRACK` auf den letzten Track der Playlist zeigen. Geben Sie Titel und Dauer dieses Tracks mit `printf` aus.',
solution: 'PTRACK p_track = &playlist[2];\nprintf("Now playing: %s (%ds)", p_track->title, p_track->duration_seconds);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n char title[60];\n char artist[40];\n int duration_seconds;\n} TRACK, *PTRACK;\n```\n- Eine typische Struktur zur Speicherung von Daten, ergänzt um den Zeiger-`typedef` `PTRACK`.\n\n**Teil b)**\n```c\nTRACK playlist[3] = {\n {"Bohemian Rhapsody", "Queen", 355},\n {"Stairway to Heaven", "Led Zeppelin", 482},\n {"Hotel California", "Eagles", 391}\n};\n```\n- Das Array wird mit den Daten der drei Songs initialisiert.\n\n**Teil c)**\n```c\nPTRACK p_track = &playlist[2];\nprintf("Now playing: %s (%ds)", p_track->title, p_track->duration_seconds);\n```\n- Der Zeiger `p_track` wird mit dem Typ `PTRACK` deklariert.\n- `&playlist[2]` gibt die Adresse des dritten (letzten) Elements an, da die Indizierung bei 0 beginnt.\n- `printf` kann mehrere Elemente einer Struktur ausgeben, die über einen Zeiger abgerufen werden.'
},
{
id: 'ex9',
title: 'Aufgabe: Rezept-Zutaten',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `INGREDIENT` und Zeigertyp `PINGREDIENT` für eine Struktur `ingredient` mit `name` (max. 30), `quantity` (float) und `unit` (max. 10).',
solution: 'typedef struct ingredient {\n char name[30];\n float quantity;\n char unit[10];\n} INGREDIENT, *PINGREDIENT;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `recipe_steps` mit 3 Zutaten und initialisieren Sie es (z.B. für Pfannkuchen: Mehl, Eier, Milch).',
solution: 'INGREDIENT recipe_steps[3] = {\n {"Mehl", 250.0, "g"},\n {"Eier", 2.0, "Stk"},\n {"Milch", 500.0, "ml"}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_ingredient` vom Typ `PINGREDIENT` auf die zweite Zutat im Rezept. Verdoppeln Sie die Menge (`quantity`) dieser Zutat.',
solution: 'PINGREDIENT p_ingredient = &recipe_steps[1];\np_ingredient->quantity *= 2;',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct ingredient {\n char name[30];\n float quantity;\n char unit[10];\n} INGREDIENT, *PINGREDIENT;\n```\n- Die Struktur ist ideal, um zusammengehörige Daten für eine Zutat zu speichern. Der `typedef` wird um den Zeigertyp `PINGREDIENT` erweitert.\n\n**Teil b)**\n```c\nINGREDIENT recipe_steps[3] = {\n {"Mehl", 250.0, "g"},\n {"Eier", 2.0, "Stk"},\n {"Milch", 500.0, "ml"}\n};\n```\n- Das Array stellt eine Liste von Zutaten dar.\n\n**Teil c)**\n```c\nPINGREDIENT p_ingredient = &recipe_steps[1];\np_ingredient->quantity *= 2;\n```\n- Der Zeiger `p_ingredient` wird mit dem Typ `PINGREDIENT` deklariert und zeigt auf die zweite Zutat (Index 1).\n- `*=` ist der Multiplikationszuweisungsoperator. `p_ingredient->quantity *= 2;` ist eine Kurzform für `p_ingredient->quantity = p_ingredient->quantity * 2;`.'
},
{
id: 'ex10',
title: 'Aufgabe: Fahrzeugdaten',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `CAR` und einen Zeigertyp `PCAR` für eine anonyme Struktur mit:\n- `make` (max. 20)\n- `model` (max. 20)\n- `year` (int)\n- `mileage` (unsigned long)',
solution: 'typedef struct {\n char make[20];\n char model[20];\n int year;\n unsigned long mileage;\n} CAR, *PCAR;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein `CAR`-Array `fleet` mit 2 Fahrzeugen und initialisieren Sie es.',
solution: 'CAR fleet[2] = {\n {"Volkswagen", "Golf", 2020, 50000},\n {"BMW", "3er", 2021, 25000}\n};',
points: 3,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_car` vom Typ `PCAR`, der auf das zweite Auto in der Flotte zeigt. Geben Sie den Kilometerstand (`mileage`) dieses Autos aus.',
solution: 'PCAR p_car = &fleet[1];\nprintf("Kilometerstand: %lu", p_car->mileage);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n char make[20];\n char model[20];\n int year;\n unsigned long mileage;\n} CAR, *PCAR;\n```\n- `typedef ... CAR, *PCAR;` ist eine kompakte Methode, um sowohl den Strukturtyp `CAR` als auch den Zeigertyp `PCAR` (äquivalent zu `CAR*`) zu definieren.\n\n**Teil b)**\n```c\nCAR fleet[2] = {\n {"Volkswagen", "Golf", 2020, 50000},\n {"BMW", "3er", 2021, 25000}\n};\n```\n- Standardmäßige Initialisierung eines Arrays von Strukturen.\n\n**Teil c)**\n```c\nPCAR p_car = &fleet[1];\nprintf("Kilometerstand: %lu", p_car->mileage);\n```\n- Der Zeiger `p_car` wird mit dem vordefinierten Zeigertyp `PCAR` deklariert.\n- Der Format-Specifier für `unsigned long` ist `%lu`.'
},
{
id: 'ex11',
title: 'Aufgabe: GPS-Koordinate',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen `typedef` `GPS_COORD` und einen Zeigertyp `PGPS_COORD` für eine Struktur, die `latitude` und `longitude` (beides `double`) speichert.',
solution: 'typedef struct {\n double latitude;\n double longitude;\n} GPS_COORD, *PGPS_COORD;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `path` mit 2 Koordinaten und initialisieren Sie es mit Werten für z.B. Start und Ziel.',
solution: 'GPS_COORD path[2] = {\n {48.137154, 11.576124},\n {52.520008, 13.404954}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_coord` vom Typ `PGPS_COORD`, der auf den Anfang des `path`-Arrays zeigt. Geben Sie den Breitengrad (`latitude`) des Startpunktes über den Zeiger aus.',
solution: 'PGPS_COORD p_coord = path;\nprintf("Start Latitude: %f", p_coord->latitude);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n double latitude;\n double longitude;\n} GPS_COORD, *PGPS_COORD;\n```\n- Eine einfache Struktur zur Kapselung von zwei `double`-Werten. `PGPS_COORD` ist nun der Zeigertyp.\n\n**Teil b)**\n```c\nGPS_COORD path[2] = {\n {48.137154, 11.576124},\n {52.520008, 13.404954}\n};\n```\n- Das `path`-Array speichert zwei GPS-Punkte, die eine Route definieren könnten.\n\n**Teil c)**\n```c\nPGPS_COORD p_coord = path;\nprintf("Start Latitude: %f", p_coord->latitude);\n```\n- Der Zeiger `p_coord` wird mit dem neuen Typ `PGPS_COORD` deklariert. Wenn ein Zeiger auf den Namen eines Arrays gesetzt wird, zeigt er automatisch auf das erste Element des Arrays (`&path[0]`).\n- `p_coord->latitude` greift auf das `latitude`-Element des ersten Strukturelements im Array zu.'
},
{
id: 'ex12',
title: 'Aufgabe: Spielfigur-Werte',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `STATS` und einen Zeigertyp `PSTATS` für eine Struktur mit den Werten `health`, `mana`, `strength` und `defense` (alles `unsigned int`).',
solution: 'typedef struct {\n unsigned int health;\n unsigned int mana;\n unsigned int strength;\n unsigned int defense;\n} STATS, *PSTATS;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie zwei Variablen `hero` und `villain` vom Typ `STATS` und initialisieren Sie sie mit passenden Werten.',
solution: 'STATS hero = {100, 50, 15, 10};\nSTATS villain = {120, 30, 20, 5};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_hero` vom Typ `PSTATS`, der auf die `hero`-Struktur zeigt. Reduzieren Sie die `health` des Helden um 25 Punkte.',
solution: 'PSTATS p_hero = &hero;\np_hero->health -= 25;',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n unsigned int health;\n unsigned int mana;\n unsigned int strength;\n unsigned int defense;\n} STATS, *PSTATS;\n```\n- `unsigned int` ist eine gute Wahl für Spielwerte, da sie typischerweise nicht negativ sind. Der Zeigertyp `PSTATS` wird mitdefiniert.\n\n**Teil b)**\n```c\nSTATS hero = {100, 50, 15, 10};\nSTATS villain = {120, 30, 20, 5};\n```\n- Zwei separate Strukturvariablen werden deklariert und initialisiert.\n\n**Teil c)**\n```c\nPSTATS p_hero = &hero;\np_hero->health -= 25;\n```\n- Der Zeiger `p_hero` wird mit dem Typ `PSTATS` deklariert und mit der Adresse der `hero`-Variable initialisiert.\n- `-=` ist der Subtraktionszuweisungsoperator und eine Kurzform für `p_hero->health = p_hero->health - 25`.'
},
{
id: 'ex13',
title: 'Aufgabe: RGB-Farbwerte',
parts: [
{
id: 'a',
prompt: 'Definieren Sie eine Struktur `color` mit den drei Komponenten `r`, `g`, und `b`. Verwenden Sie den Datentyp `unsigned char`, da die Werte von 0-255 reichen. Erstellen Sie einen `typedef` `COLOR`.',
solution: 'typedef struct color {\n unsigned char r;\n unsigned char g;\n unsigned char b;\n} COLOR;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `palette` mit 3 Farben und initialisieren Sie es mit den Werten für Rot (255,0,0), Grün (0,255,0) und Blau (0,0,255).',
solution: 'COLOR palette[3] = {\n {255, 0, 0},\n {0, 255, 0},\n {0, 0, 255}\n};',
points: 3,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Greifen Sie direkt (ohne Zeiger) auf die zweite Farbe in der `palette` zu und ändern Sie deren Rot-Wert (`r`) auf 128.',
solution: 'palette[1].r = 128;',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct color {\n unsigned char r;\n unsigned char g;\n unsigned char b;\n} COLOR;\n```\n- `unsigned char` ist der optimale Datentyp für RGB-Werte, da er genau den Bereich von 0 bis 255 abdeckt und nur 1 Byte pro Komponente belegt.\n\n**Teil b)**\n```c\nCOLOR palette[3] = {\n {255, 0, 0},\n {0, 255, 0},\n {0, 0, 255}\n};\n```\n- Das Array `palette` speichert die drei Grundfarben.\n\n**Teil c)**\n```c\npalette[1].r = 128;\n```\n- Dies zeigt den direkten Zugriff auf ein Strukturelement innerhalb eines Arrays. `palette[1]` wählt das zweite Element (die grüne Farbe) aus, und `.r` greift auf dessen Rot-Komponente zu, die dann geändert wird. Es entsteht ein dunkleres Grün.'
},
{
id: 'ex14',
title: 'Aufgabe: Bankkonto',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen `typedef` `ACCOUNT`, sowie einen Zeigertyp `PACCOUNT`, für eine Struktur mit `account_number` (long long), `owner_name` (max. 40 Zeichen) und `balance` (double).',
solution: 'typedef struct {\n long long account_number;\n char owner_name[40];\n double balance;\n} ACCOUNT, *PACCOUNT;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie eine Variable `customer_account` vom Typ `ACCOUNT` und initialisieren Sie sie mit fiktiven Daten.',
solution: 'ACCOUNT customer_account = {123456789012, "Jane Smith", 1500.75};',
points: 3,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_acc` vom Typ `PACCOUNT` auf `customer_account`. Addieren Sie 500.25 zum Kontostand (`balance`) über den Zeiger.',
solution: 'PACCOUNT p_acc = &customer_account;\np_acc->balance += 500.25;',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n long long account_number;\n char owner_name[40];\n double balance;\n} ACCOUNT, *PACCOUNT;\n```\n- `long long` wird für die Kontonummer verwendet, um sicherzustellen, dass auch sehr lange Nummern Platz finden. `double` ist für Geldbeträge geeignet.\n- Der Zeigertyp `PACCOUNT` wird gleichzeitig mitdefiniert.\n\n**Teil b)**\n```c\nACCOUNT customer_account = {123456789012, "Jane Smith", 1500.75};\n```\n- Eine einzelne Strukturvariable wird mit den Kontodaten initialisiert.\n\n**Teil c)**\n```c\nPACCOUNT p_acc = &customer_account;\np_acc->balance += 500.25;\n```\n- Der Zeiger `p_acc` wird mit dem Typ `PACCOUNT` deklariert und zeigt auf das Kundenkonto. Der Additionszuweisungsoperator `+=` wird verwendet, um den Kontostand zu erhöhen.'
},
{
id: 'ex15',
title: 'Aufgabe: Kalendertermin (verschachtelt)',
parts: [
{
id: 'a',
prompt: 'Definieren Sie eine Struktur `date` mit `day`, `month`, `year` (alle `int`). Definieren Sie dann eine Struktur `appointment`, die `description` (max. 100) und eine `date`-Struktur namens `when` enthält. Erstellen Sie `typedef`s `APPOINTMENT` und `PAPPOINTMENT`.',
solution: 'struct date {\n int day;\n int month;\n int year;\n};\ntypedef struct appointment {\n char description[100];\n struct date when;\n} APPOINTMENT, *PAPPOINTMENT;',
points: 4,
type: 'struct-definition',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein `APPOINTMENT`-Array `calendar` mit 2 Terminen und initialisieren Sie es.',
solution: 'APPOINTMENT calendar[2] = {\n {"Zahnarzt", {15, 10, 2024}},\n {"Projekt-Deadline", {31, 10, 2024}}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_appt` vom Typ `PAPPOINTMENT`, der auf den ersten Termin im Kalender zeigt. Geben Sie das Jahr dieses Termins mit `printf` aus.',
solution: 'PAPPOINTMENT p_appt = calendar;\nprintf("Jahr des Termins: %d", p_appt->when.year);',
points: 2,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\nstruct date {\n int day;\n int month;\n int year;\n};\ntypedef struct appointment {\n char description[100];\n struct date when;\n} APPOINTMENT, *PAPPOINTMENT;\n```\n- Ein gutes Beispiel für Wiederverwendbarkeit: Die `date`-Struktur könnte auch in anderen Teilen des Programms genutzt werden. Der `typedef` für `appointment` schließt den Zeigertyp `PAPPOINTMENT` mit ein.\n\n**Teil b)**\n```c\nAPPOINTMENT calendar[2] = {\n {"Zahnarzt", {15, 10, 2024}},\n {"Projekt-Deadline", {31, 10, 2024}}\n};\n```\n- Die Initialisierung `{15, 10, 2024}` gehört zur inneren `when`-Struktur.\n\n**Teil c)**\n```c\nPAPPOINTMENT p_appt = calendar;\nprintf("Jahr des Termins: %d", p_appt->when.year);\n```\n- Der Zeiger `p_appt` wird mit dem Typ `PAPPOINTMENT` deklariert.\n- `p_appt->when` greift auf die `date`-Struktur zu. Von dort aus wird `.year` verwendet, um auf das Jahr zuzugreifen.'
},
{
id: 'ex16',
title: 'Aufgabe: Messwert',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen `typedef` `MEASUREMENT` für eine Struktur mit `value` (double) und `unit` (max. 15 Zeichen).',
solution: 'typedef struct {\n double value;\n char unit[15];\n} MEASUREMENT;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `sensor_data` für 3 Messwerte und initialisieren Sie es (z.B. Temperatur, Luftdruck, Feuchtigkeit).',
solution: 'MEASUREMENT sensor_data[3] = {\n {23.5, "Celsius"},\n {1013.25, "hPa"},\n {45.5, "Percent"}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Geben Sie den `value` des dritten Messwerts (Index 2) direkt (ohne Zeiger) mit `printf` aus.',
solution: 'printf("Wert: %f %s", sensor_data[2].value, sensor_data[2].unit);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n double value;\n char unit[15];\n} MEASUREMENT;\n```\n- Diese Struktur ist nützlich, um Messwerte zusammen mit ihren Einheiten zu speichern, was die Daten aussagekräftiger macht.\n\n**Teil b)**\n```c\nMEASUREMENT sensor_data[3] = {\n {23.5, "Celsius"},\n {1013.25, "hPa"},\n {45.5, "Percent"}\n};\n```\n- Ein Array, das eine Reihe von Messungen von verschiedenen Sensoren darstellen könnte.\n\n**Teil c)**\n```c\nprintf("Wert: %f %s", sensor_data[2].value, sensor_data[2].unit);\n```\n- Dies zeigt den direkten Zugriff auf ein Element in einem Array von Strukturen mit `array[index].member`.\n- `%f` wird für den `double`-Wert und `%s` für die `unit`-Zeichenkette verwendet.'
},
{
id: 'ex17',
title: 'Aufgabe: Kontaktinformationen',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen Datentyp `CONTACT` für eine Struktur mit `name` (max. 50), `phone` (max. 20) und `email` (max. 50).',
solution: 'typedef struct {\n char name[50];\n char phone[20];\n char email[50];\n} CONTACT;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `address_book` mit 2 Kontakten und initialisieren Sie es.',
solution: 'CONTACT address_book[2] = {\n {"Alice", "123-456-7890", "alice@example.com"},\n {"Bob", "098-765-4321", "bob@example.com"}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_contact`, der auf den ersten Kontakt zeigt. Ändern Sie dessen Telefonnummer auf "555-555-5555". Beachten Sie: Zeichenketten können nicht direkt zugewiesen werden. (Die Lösung verwendet `strcpy`, aber für diese Übung reicht es, dies konzeptionell zu beschreiben - wir gehen davon aus, die Zuweisung wäre einfach.)',
solution: 'CONTACT *p_contact = address_book;\n// In echtem C wäre strcpy(p_contact->phone, "555-555-5555"); nötig.\n// Für diese Übung akzeptieren wir eine konzeptionelle Zuweisung.',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n char name[50];\n char phone[20];\n char email[50];\n} CONTACT;\n```\n- Eine Standardstruktur für ein Adressbuch.\n\n**Teil b)**\n```c\nCONTACT address_book[2] = {\n {"Alice", "123-456-7890", "alice@example.com"},\n {"Bob", "098-765-4321", "bob@example.com"}\n};\n```\n- Initialisierung des Adressbuch-Arrays.\n\n**Teil c)**\n```c\n#include <string.h> // Erforderlich für strcpy\nCONTACT *p_contact = address_book;\nstrcpy(p_contact->phone, "555-555-5555");\n```\n- `p_contact` zeigt auf den ersten Kontakt.\n- **Wichtiger Hinweis zu C:** Zeichenketten (char-Arrays) können nicht mit `=` zugewiesen werden. Man muss die Funktion `strcpy()` aus `<string.h>` verwenden, um den Inhalt einer Zeichenkette in eine andere zu kopieren. Die einfache Zuweisung würde nur den Zeiger kopieren, nicht den Inhalt, was hier nicht funktioniert.'
},
{
id: 'ex18',
title: 'Aufgabe: Datei-Metadaten',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen `typedef` `FILE_META` für eine Struktur mit `filename` (max. 256), `size_kb` (unsigned long) und `permissions` (char-Array der Größe 11, z.B. "-rwxr-xr--").',
solution: 'typedef struct {\n char filename[256];\n unsigned long size_kb;\n char permissions[11];\n} FILE_META;',
points: 4,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren und initialisieren Sie eine `FILE_META`-Variable `my_file`.',
solution: 'FILE_META my_file = {"document.txt", 128, "-rw-r--r--"};',
points: 3,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_file` auf `my_file`. Geben Sie Dateinamen und Größe über den Zeiger aus.',
solution: 'FILE_META *p_file = &my_file;\nprintf("File: %s, Size: %lu KB", p_file->filename, p_file->size_kb);',
points: 3,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n char filename[256];\n unsigned long size_kb;\n char permissions[11];\n} FILE_META;\n```\n- Diese Struktur modelliert die Art von Metadaten, die ein Dateisystem speichert. `permissions` ist ein String fester Länge.\n\n**Teil b)**\n```c\nFILE_META my_file = {"document.txt", 128, "-rw-r--r--"};\n```\n- Initialisierung einer einzelnen Strukturvariable.\n\n**Teil c)**\n```c\nFILE_META *p_file = &my_file;\nprintf("File: %s, Size: %lu KB", p_file->filename, p_file->size_kb);\n```\n- Der Zeiger `p_file` wird verwendet, um auf die Member der `my_file`-Struktur zuzugreifen und sie auszugeben.'
},
{
id: 'ex19',
title: 'Aufgabe: Rechteck (verschachtelt)',
parts: [
{
id: 'a',
prompt: 'Definieren Sie eine Struktur `point` mit `x` und `y` (beides `int`). Definieren Sie dann eine Struktur `rectangle`, die zwei `point`-Strukturen enthält: `top_left` und `bottom_right`. Erstellen Sie `typedef`s `POINT` und `RECTANGLE`.',
solution: 'typedef struct {\n int x;\n int y;\n} POINT;\ntypedef struct {\n POINT top_left;\n POINT bottom_right;\n} RECTANGLE;',
points: 4,
type: 'struct-definition',
},
{
id: 'b',
prompt: 'Deklarieren Sie eine `RECTANGLE`-Variable `selection` und initialisieren Sie sie so, dass sie den Bereich von (10, 50) bis (100, 200) abdeckt.',
solution: 'RECTANGLE selection = {{10, 50}, {100, 200}};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Greifen Sie direkt (ohne Zeiger) auf die `y`-Koordinate des `bottom_right`-Punktes der `selection` zu und geben Sie sie aus.',
solution: 'printf("Untere Y-Koordinate: %d", selection.bottom_right.y);',
points: 2,
type: 'printf',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n int x;\n int y;\n} POINT;\ntypedef struct {\n POINT top_left;\n POINT bottom_right;\n} RECTANGLE;\n```\n- Hier wird eine Struktur (`RECTANGLE`) definiert, die selbst zwei Instanzen einer anderen Struktur (`POINT`) enthält. Dies ist eine sehr häufige und nützliche Technik.\n\n**Teil b)**\n```c\nRECTANGLE selection = {{10, 50}, {100, 200}};\n```\n- Die verschachtelten Klammern sind wichtig. Das äußere Paar ist für die `RECTANGLE`-Struktur. Jedes innere Paar ist für eine der `POINT`-Strukturen.\n\n**Teil c)**\n```c\nprintf("Untere Y-Koordinate: %d", selection.bottom_right.y);\n```\n- Der Zugriff auf tief verschachtelte Elemente erfolgt durch Aneinanderreihung des Punkt-Operators: `variable.outer_member.inner_member`.'
},
{
id: 'ex20',
title: 'Aufgabe: Wählerverzeichnis',
parts: [
{
id: 'a',
prompt: 'Definieren Sie einen `typedef` `VOTER` und einen Zeigertyp `PVOTER` für eine Struktur mit `voter_id` (int), `name` (max. 60) und `has_voted` (int, wobei 0=nein, 1=ja).',
solution: 'typedef struct {\n int voter_id;\n char name[60];\n int has_voted;\n} VOTER, *PVOTER;',
points: 3,
type: 'typedef-struct',
},
{
id: 'b',
prompt: 'Deklarieren Sie ein Array `voter_list` mit 2 Wählern und initialisieren Sie es. Der erste hat bereits gewählt, der zweite nicht.',
solution: 'VOTER voter_list[2] = {\n {101, "Peter Pan", 1},\n {102, "Wendy Darling", 0}\n};',
points: 4,
type: 'array-initialization',
},
{
id: 'c',
prompt: 'Deklarieren Sie einen Zeiger `p_voter` vom Typ `PVOTER`, der auf den zweiten Wähler zeigt. Setzen Sie dessen `has_voted`-Status auf 1.',
solution: 'PVOTER p_voter = &voter_list[1];\np_voter->has_voted = 1;',
points: 3,
type: 'pointer-manipulation',
},
],
explanation: '### Lösungserklärung\n\n**Teil a)**\n```c\ntypedef struct {\n int voter_id;\n char name[60];\n int has_voted;\n} VOTER, *PVOTER;\n```\n- `has_voted` als `int` zu verwenden ist eine gängige Praxis in C, um einen booleschen Wert darzustellen. Der Zeigertyp `PVOTER` wird mitdefiniert.\n\n**Teil b)**\n```c\nVOTER voter_list[2] = {\n {101, "Peter Pan", 1},\n {102, "Wendy Darling", 0}\n};\n```\n- Das Array wird mit den Daten der beiden Wähler initialisiert.\n\n**Teil c)**\n```c\nPVOTER p_voter = &voter_list[1];\np_voter->has_voted = 1;\n```\n- Der Zeiger `p_voter` wird mit dem Typ `PVOTER` auf das zweite Element des Arrays gesetzt.\n- `p_voter->has_voted = 1;` aktualisiert den Status des Wählers, um zu markieren, dass er gewählt hat.'
}
];