diff --git a/20230109/aufgabe-1b-gpt.c b/20230109/aufgabe-1b-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..3b75051963b0f8f325725a2b71305c88f9a6b8e6
--- /dev/null
+++ b/20230109/aufgabe-1b-gpt.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <string.h>
+
+void insert_into_string (char src, char *target, int pos) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
+ for (int i = len; i > pos; i--) {
+ target[i] = target[i-1];
+ }
+
+ // Füge das Zeichen src an der Stelle pos ein
+ target[pos] = src;
+}
+
+int main (void)
+{
+ char test[] = "Hochshule Bochum";
+ insert_into_string ('c', test, 5);
+ printf ("%s\n", test);
+ return 0;
+}
diff --git a/20230109/aufgabe-1e-gpt.c b/20230109/aufgabe-1e-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..7e010cb2b66d3dd447b0aa9e64c9d591fc9cb0d3
--- /dev/null
+++ b/20230109/aufgabe-1e-gpt.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <string.h>
+
+void insert_into_string (char src, char *target, int pos) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
+ for (int i = len; i > pos; i--) {
+ target[i] = target[i-1];
+ }
+
+ // Füge das Zeichen src an der Stelle pos ein
+ target[pos] = src;
+}
+
+void insert_into_string_sorted (char src, char *target) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Iteriere über alle Zeichen des Strings target
+ for (int i = 0; i < len; i++) { // Wenn das aktuelle Zeichen alphabetisch hinter src liegt, füge src an dieser Stelle ein
+ if (target[i] > src) {
+ insert_into_string(src, target, i);
+ return;
+ }
+ }
+
+ // Wenn src das letzte Zeichen im String ist, füge es am Ende des Strings ein
+ insert_into_string(src, target, len);
+}
+
+int main (void)
+{
+ char test[100] = "";
+ insert_into_string_sorted ('c', test);
+ insert_into_string_sorted ('a', test);
+ insert_into_string_sorted ('d', test);
+ insert_into_string_sorted ('b', test);
+ printf ("%s\n", test);
+ return 0;
+}
diff --git a/20230109/aufgabe-1g-gpt.c b/20230109/aufgabe-1g-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..047fa6f565913323f715d8b9a7ce413e70a2b07a
--- /dev/null
+++ b/20230109/aufgabe-1g-gpt.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+
+void insert_into_string (char src, char *target, int pos) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
+ for (int i = len; i > pos; i--) {
+ target[i] = target[i-1];
+ }
+
+ // Füge das Zeichen src an der Stelle pos ein
+ target[pos] = src;
+}
+
+void insert_into_string_sorted (char src, char *target) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Setze die Grenzen für die binäre Suche auf das erste und letzte Zeichen des Strings
+ int left = 0;
+ int right = len - 1;
+
+ // Führe die binäre Suche durch, bis left und right auf dasselbe Zeichen zeigen
+ while (left < right) { // Bestimme die Mitte des aktuellen Suchbereichs
+ int mid = (left + right) / 2;
+
+ // Wenn src alphabetisch vor dem aktuellen Zeichen liegt, suche im linken Teilbereich weiter
+ if (src < target[mid]) {
+ right = mid;
+ }
+ // Wenn src alphabetisch hinter dem aktuellen Zeichen liegt, suche im rechten Teilbereich weiter
+ else {
+ left = mid + 1;
+ }
+ }
+
+ // Füge src an der Stelle left in den String ein
+ insert_into_string(src, target, left);
+}
+
+int main (void)
+{
+ char test[100] = "";
+ insert_into_string_sorted ('c', test);
+ insert_into_string_sorted ('a', test);
+ insert_into_string_sorted ('d', test);
+ insert_into_string_sorted ('b', test);
+ printf ("%s\n", test);
+ return 0;
+}
diff --git a/20230109/hp-20230109.txt b/20230109/hp-20230109.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ab89c2811358da947d215743cabf74d1b93f3416
--- /dev/null
+++ b/20230109/hp-20230109.txt
@@ -0,0 +1,411 @@
+Klausur vom 13.2.2018, gelöst von ChatGPT
+
+Aufgabe 1
+
+(b) void insert_into_string (char src, char *target, int pos) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Verschiebe alle Zeichen des Strings ab der Stelle pos um eine Stelle nach rechts
+ for (int i = len; i > pos; i--) {
+ target[i] = target[i-1];
+ }
+
+ // Füge das Zeichen src an der Stelle pos ein
+ target[pos] = src;
+ }
+
+--> Funktioniert, aber Null-Symbol am Ende nicht berücksichtigt. 1 Punkt Abzug.
+
+(c) Wenn man char test[] = "Hochshule Bochum"; anstelle von char test[100] =
+ "Hochshule Bochum"; schreibt, wird der Compiler den Array test automatisch
+ auf die notwendige Größe anpassen, um den String "Hochshule Bochum"
+ aufnehmen zu können. Wenn man die Funktion insert_into_string aufruft und
+ versucht, ein Zeichen an eine Stelle jenseits des Endes des Strings
+ einzufügen, könnte dies zu einem Speicherzugriffsfehler führen, da der
+ Array test nicht ausreichend groß ist, um das Zeichen aufzunehmen
+
+--> Richtig. Volle Punktzahl.
+
+(d) Wenn man char *test = "Hochshule Bochum"; anstelle von char test[100] =
+ "Hochshule Bochum"; schreibt, deklariert man test als Zeiger auf einen
+ char, der auf den ersten Buchstaben des Strings "Hochshule Bochum" zeigt.
+ In diesem Fall kann man nicht mehr auf die einzelnen Zeichen des Strings
+ test zugreifen, da der String "Hochshule Bochum" im ROM-Speicher
+ gespeichert ist und nicht verändert werden darf. Wenn man versucht, in der
+ Funktion insert_into_string das Zeichen an einer bestimmten Stelle im
+ String test zu ändern, wird dies zu einem Fehler führen
+
+--> Richtig, auch wenn die Formulierung eher in Richtung "ändern" als "einfügen" geht.
+ Volle Punktzahl.
+
+(e) void insert_into_string_sorted (char src, char *target) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Iteriere über alle Zeichen des Strings target
+ for (int i = 0; i < len; i++) { // Wenn das aktuelle Zeichen alphabetisch hinter src liegt, füge src an dieser Stelle ein
+ if (target[i] > src) {
+ insert_into_string(src, target, i);
+ return;
+ }
+ }
+
+ // Wenn src das letzte Zeichen im String ist, füge es am Ende des Strings ein
+ insert_into_string(src, target, len);
+ }
+
+--> Scheint zu funktionieren. Könnte volle Punktzahl geben.
+
+(f) Die Funktion void insert_into_string_sorted (char src, char *target)
+ arbeitet in O(n)-Zeit, da sie die Länge des Strings target durchläuft
+ und in jedem Durchlauf das Zeichen src in den String einfügt.
+
+--> Korrekt.
+
+(g) void insert_into_string_sorted (char src, char *target) {
+ // Bestimme die Länge des Strings target
+ int len = strlen(target);
+
+ // Setze die Grenzen für die binäre Suche auf das erste und letzte Zeichen des Strings
+ int left = 0;
+ int right = len - 1;
+
+ // Führe die binäre Suche durch, bis left und right auf dasselbe Zeichen zeigen
+ while (left < right) { // Bestimme die Mitte des aktuellen Suchbereichs
+ int mid = (left + right) / 2;
+
+ // Wenn src alphabetisch vor dem aktuellen Zeichen liegt, suche im linken Teilbereich weiter
+ if (src < target[mid]) {
+ right = mid;
+ }
+ // Wenn src alphabetisch hinter dem aktuellen Zeichen liegt, suche im rechten Teilbereich weiter
+ else {
+ left = mid + 1;
+ }
+ }
+
+ // Füge src an der Stelle left in den String ein
+ insert_into_string(src, target, left);
+ }
+
+--> Nicht ganz ausgereift, aber i.w. korrekt. Spontan 2 von 3 Punkten.
+
+Aufgabe 2
+
+(a) Die beim Compilieren auftretende Warnung wird angezeigt, weil in der
+ printf-Anweisung in Zeile 14 der Typ des zweiten Arguments ("&xyz") als
+ "three_numbers * {aka struct *}" angegeben ist, aber der Format-String "%s"
+ erwartet, dass das zweite Argument ein Zeiger auf einen char-Wert (also
+ einen String) ist. Die Formatierungsanweisung "%s" gibt an, dass das
+ Argument, auf das der Zeiger verweist, als String interpretiert werden
+ soll. Da das zweite Argument aber ein Zeiger auf ein three_numbers-Struct
+ ist, kann es nicht als String interpretiert werden und es wird daher eine
+ Warnung angezeigt.
+
+--> Sehr lang formuliert, trotzdem volle Punktzahl.
+
+(a) Die beim Compilieren auftretende Warnung wird angezeigt, weil in der
+ printf-Anweisung der Typ des zweiten Arguments ("&xyz", ein Zeiger auf
+ ein three_numbers-Struct) und der Format-String "%s" (erwartet einen
+ String) inkonsistent sind. Das bedeutet, dass das Programm versucht,
+ ein three_numbers-Struct als String auszugeben, was nicht möglich ist
+ und daher eine Warnung ausgelöst wird.
+
+--> Besser formuliert. Volle Punktzahl. (Ein Komma fehlt.;-)
+
+(b) Das Programm enthält einen Fehler in der Verwendung von printf auf Zeile
+ 14. Der "%s" Formatstring erwartet einen "char *" als Argument, aber &xyz
+ wurde übergeben, was ein "three_numbers *" (also ein Zeiger auf eine
+ Struktur) ist. Dies führt zu unerwartetem Verhalten und einer Warnung bei
+ der Compilierung.
+
+--> Bis hierin: Geschwafel.
+
+ In diesem Fall gibt printf jedoch "Hallo, Welt!" aus, da es den Inhalt
+ der Speicheradresse als Zeichenkette interpretiert.
+
+--> Das ist sogar richtig.
+
+ Es ist jedoch unwahrscheinlich, dass dieser Speicherbereich tatsächlich
+ eine gültige Zeichenkette enthält, daher sollte dieser Code vermieden
+ werden.
+
+--> Daraus kann ich entnehmen, daß ChatGPT die Aufgabe nicht wirklich verstanden hat.
+ Es feht eine Analyse, weshalb die Ausgabe genau "Hallo, Welt!" sein muß.
+
+--> Großzügig: 2 von 4 Punkten.
+
+--> Richtige Lösung: Zahlen nach Hexadezimal umwandeln.
+ In der ersten Zahl steht dann ganz rechts "48" für "H",
+ links davon "61" für "a", danach zweimal "6c" für "l".
+ --> Der Rechner ist Little-Endian (schon mal für (c)).
+
+ Was liegt im Speicher?
+
+ l l a H ! t l e W _ , o \0
+ 6c6c6148 21746c6557202C6f 00
+ `------' `--------------' `'
+ a b c <-- direkt hintereinander, weil gemeinsam im Struct
+ (Dies dazuzuschreiben, könnte einen Extra-Punkt bringen.)
+ (Achtung: auch hier kann Alignment eine Rolle spielen!)
+
+ Reihenfolge im Speicher: für jede Zahl andersherum, da Little Endian
+
+ H a l l o , _ W e l t ! \0
+ 48 61 6c 6c 6f 2C 20 57 65 6c 74 21 00 <-- String im Speicher
+ `---------' `----------------------' `'
+ a b c
+
+ Wenn man die Inhalte der Speicherzellen visualisiert, aus denen das Struct
+ xyz besteht, erkennt man, daß bei Little Endian die Speicherzellen gemäß
+ ASCII-Zeichensatz den String "Hallo, Welt!" einschließlich Null-Symbol am
+ Ende ergeben.
+
+(c) Es ist nicht möglich, die Endianness des verwendeten Rechners anhand des
+ obigen Programms zu bestimmen. Die Endianness beschreibt die Reihenfolge,
+ in der Bytes in einem Wort gespeichert werden, und hat keine Auswirkungen
+ auf die Ausgabe von printf.
+
+--> Leider falsch.
+
+ Die Ausgabe des Programms hängt davon ab, welche Daten sich in dem
+ Speicherbereich befinden, der an printf übergeben wird. In diesem Fall
+ wurde &xyz, also die Adresse der Struktur "three_numbers", übergeben. Wenn
+ der Speicherbereich an dieser Adresse tatsächlich eine gültige Zeichenkette
+ enthält, würde die Ausgabe auf jedem Rechner gleich sein, unabhängig von
+ der Endianness. Wenn der Speicherbereich jedoch zufällige Daten enthält,
+ würde die Ausgabe auf jedem Rechner unterschiedlich sein.
+
+--> Das klingt erstaunlich überzeugend, ist aber eigentlich ziemlich falsch.
+
+ Es ist wichtig zu beachten, dass der Code in der obigen Frage fehlerhaft
+ ist und nicht wie erwartet funktionieren wird. Es wird empfohlen, diesen
+ Code zu überarbeiten, um korrektes Verhalten zu gewährleisten.
+
+--> Daß man so nicht programmieren sollte, ist klar. Leider hat dies nichts
+ mit der Aufgabenstellung zu tun.
+
+--> 0 Punkte.
+
+--> Richtige Lösung: Little Endian (Begründung: siehe oben)
+
+ Rechner nit entgegengesetzter Endianness:
+ Wir behalten die Reihenfolge von a, b und c bei und drehen nur innerhalb
+ jeder Variable die Reihenfolge der Speicherzellen um:
+
+ l l a H ! t l e W _ , o \0
+ 6c 6c 61 48 21 74 6c 65 57 20 2C 6f 00 <-- String im Speicher
+ `---------' `----------------------' `'
+ a b c
+
+ Aufgabe auf einem Big-Endian-Rechner: "llaH!tleW ,o"
+
+(d) Die Ausgabe des Programms hängt davon ab, welche Daten sich in dem
+ Speicherbereich befinden, der an printf übergeben wird. In diesem Fall
+ wurde &xyz, also die Adresse der Struktur "three_numbers", übergeben. Wenn
+ der Speicherbereich an dieser Adresse tatsächlich eine gültige Zeichenkette
+ enthält, würde die Ausgabe auf jedem Rechner gleich sein, unabhängig von
+ der Architektur des Rechners. Wenn der Speicherbereich jedoch zufällige
+ Daten enthält, würde die Ausgabe auf jedem Rechner unterschiedlich sein.
+
+--> Geschwafel. Wiederholung von (a).
+
+ Es ist wichtig zu beachten, dass der Code in der obigen Frage fehlerhaft
+ ist und nicht wie erwartet funktionieren wird. Es wird empfohlen, diesen
+ Code zu überarbeiten, um korrektes Verhalten zu gewährleisten. Die
+ Tatsache, dass die Ausgabe des Programms auf einem 64-Bit-Rechner anders
+ aussieht als auf einem 32-Bit-Rechner, ist wahrscheinlich auf die
+ unterschiedliche Speicherstruktur zurückzuführen und hat nichts mit der
+ Endianness zu tun.
+
+--> Geschwafel, aber enthält auch etwas Korrektes: Es hat tatsächlich nicht
+ mit der Endianness zu tun, sondern mit dem Alignment.
+
+ Möchten Sie noch etwas wissen oder haben Sie weitere Fragen zum obigen
+ Programm?
+
+--> *in die Tischkante beiß*
+
+--> 0 Punkte.
+
+--> Richtige Lösung: 64-Bit-Rechner
+
+ Ausgabe: Hall5V
+
+ typedef struct
+ {
+ uint32_t a;
+ uint64_t b;
+ uint8_t c;
+ } three_numbers;
+
+ l l a H 5 V \0 \? ! t l e W _ , o \0
+ 6c 6c 61 48 35 56 00 ?? 21 74 6c 65 57 20 2C 6f 00 <-- String im Speicher
+ `---------' `---------' `----------------------' `'
+ a dummy b c
+ wegen 64-Bit-Alignment
+
+ Um das 64-Bit-Alignment der Variablen b einzuhalten, hat der Compiler zwischen
+ a und b 32 Bits, also 4 Speicherzellen, freigelassen und mit zufälligen Werten
+ gefüllt. Gemäß der Ausgabe sind diese zufälligen Werte die Ziffer 5, Der Buchstabe V,
+ ein Null-Symbol und ein für uns unbekannter Wert.
+
+ $ gcc -Wall -m64 -O aufgabe-2.c -o aufgabe-2
+ aufgabe-2.c: In function ‘main’:
+ aufgabe-2.c:14:13: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘three_numbers *’ {aka ‘struct <anonymous> *’} [-Wformat=]
+ printf ("%s\n", &xyz);
+ ~^ ~~~~
+ $ ./aufgabe-2
+ Vall
+ $ ./aufgabe-2
+ Hall V
+ $ ./aufgabe-2
+ HallfU
+ $ ./aufgabe-2
+ Hall\U
+ $ ./aufgabe-2
+ HallV
+ $
+
+ Das "Vall" ist in Wirklichkeit: "Hall\rV"
+ ("\r" bedeutet: zurückgehen an den Zeilenanfang)
+
+ $ echo -e "Hall\rV"
+ Vall
+
+Aufgabe 3
+
+(a) void (*fun)(int x) bedeutet, dass "fun" ein Zeiger auf eine Funktion ist,
+ die einen int-Wert als Argument nimmt und keinen Rückgabewert hat.
+
+--> Korrekt. Schon mal 1 Punkt.
+
+ Die Verwendung von fun in der Funktion foreach() ermöglicht es, jedes
+ Element im Array "a" der Funktion "fun" zu übergeben, sodass diese auf
+ jedes Element angewendet werden kann.
+
+--> Etwas merkwürdig, aber trotzdem korrekt beantwortet.
+ Noch ein Punkt. Volle Punktzahl. 8-)
+
+ (Ich vermisse das Stichwort "Callback-Funktion" oder von mir aus auch
+ "virtuelle Methode". Aber die Beschreibung dessen, was foreach() mit
+ der übergebenen Funktion macht, ist korrekt.)
+
+(b) #include <stdio.h>
+
+ int sum; // globale Variable für die Summe
+
+ void add_to_sum (int x)
+ {
+ if (x > 0)
+ {
+ sum += x;
+ }
+ }
+
+ void foreach (int *a, void (*fun) (int x))
+ {
+ for (int *p = a; *p >= 0; p++)
+ {
+ fun (*p);
+ }
+ }
+
+ int main (void)
+ {
+ int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
+ foreach (numbers, add_to_sum);
+ printf ("Summe der positiven Zahlen: %d\n", sum);
+ return 0;
+ }
+
+--> Ich vermisse ein explizites "sum = 0"; ansonsten ist alles korrekt. Volle Punktzahl.
+ (Die Initialisierung auf 0 erfolgt bei globalen Variablen automatisch. Das ist für
+ ChatGPT anscheinend so selbstverständlich, daß es das nicht erwähnt.)
+
+Aufgabe 4
+
+ Es scheint, dass du eine Aufgabe aus einem Computer Science Kurs hast, bei
+ der du ein Programm schreiben sollst, das eine XBM-Grafikdatei liest und
+ in eine PBM-Grafikdatei umwandelt. XBM-Grafikdateien sind als C-Quelltext
+ abgespeicherte Arrays, die Bildinformationen enthalten. PBM-Grafikdateien sind
+ binär abgespeicherte C-Arrays von Bytes, die auch Bildinformationen enthalten.
+
+ Um diese Aufgabe zu lösen, musst du das XBM-Array lesen und die Bilddaten
+ in das PBM-Format umwandeln. Du musst die Breite und Höhe des Bildes aus den
+ Konstantendefinitionen in der XBM-Datei extrahieren und diese Informationen in
+ der PBM-Datei speichern. Du musst auch sicherstellen, dass du die Bilddaten im
+ PBM-Format speicherst, indem du jedes Bit des XBM-Arrays liest und es im MSB
+ first Format in das PBM-Array schreibst.
+
+ Eine Möglichkeit, dies zu erreichen, wäre die Verwendung von
+ Bit-Shift-Operationen, um die Bits des XBM-Arrays zu lesen und sie im
+ PBM-Format zu speichern. Du könntest auch Funktionen wie fprintf verwenden, um
+ die Breite und Höhe des Bildes und die Bilddaten in die PBM-Datei zu schreiben
+
+ Hier ist ein Beispiel für ein Programm, das die Aufgabe löst, eine
+ XBM-Grafikdatei in eine PBM-Grafikdatei umzuwandeln. Beachte, dass dieses
+ Beispiel nur als Anregung dient und dass es möglicherweise Anpassungen oder
+ Erweiterungen benötigt, um es für deine spezifischen Bedürfnisse zu optimieren:
+
+ #include <stdio.h>
+ #include <stdint.h>
+
+ #define XBM_WIDTH 14
+ #define XBM_HEIGHT 14
+
+ static unsigned char xbm_bits[] = {
+ 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+ 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+ 0xf0, 0x03, 0x00, 0x00
+ };
+
+ int main(int argc, char **argv)
+ {
+ // Öffne die Ausgabedatei
+ FILE *output_file = fopen("test.pbm", "w");
+ if (output_file == NULL) {
+ printf("Fehler beim Öffnen der Ausgabedatei\n");
+ return 1;
+ }
+
+ // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+ fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+ // Iteriere über jedes Byte im XBM-Array
+ for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
+ for (int j = 7; j >= 0; j--) {
+ // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+ uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+ fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+ }
+ }
+
+ // Schließe die Ausgabedatei
+ fclose(output_file);
+
+ return 0;
+ }
+
+--> Mehrere Fehler, aber durchaus sinnvolle Ansätze.
+ Großzügig: 4 von 8 Punkten (möglicherweise weniger)
+
+Zusammenfassung:
+
+Aufgabe 1 (a) 3 / 3
+ (b) 1 / 2
+ (c) 2 / 2
+ (d) 2 / 2
+ (e) 4 / 4
+ (f) 1 / 1
+ (g) 2 / 3
+Aufgabe 2 (a) 2 / 2
+ (b) 2 / 4
+ (c) 0 / 2
+ (d) 0 / 3
+Aufgabe 3 (a) 2 / 2
+ (b) 4 / 4
+Aufgabe 4 4 / 8
+ -- ---
+ 29 / 42 --> 2.7. Immerhin.
diff --git a/20230109/loesung-3b-gpt.c b/20230109/loesung-3b-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..467813bbaf0bb0ca60e6e983769bfbb98e74b96a
--- /dev/null
+++ b/20230109/loesung-3b-gpt.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+
+int sum; // globale Variable für die Summe
+
+void add_to_sum (int x)
+{
+ if (x > 0)
+ {
+ sum += x;
+ }
+}
+
+void foreach (int *a, void (*fun) (int x))
+{
+ for (int *p = a; *p >= 0; p++)
+ {
+ fun (*p);
+ }
+}
+
+int main (void)
+{
+ int numbers[] = { 12, 17, 32, 1, 3, 16, 19, 18, -1 };
+ foreach (numbers, add_to_sum);
+ printf ("Summe der positiven Zahlen: %d\n", sum);
+ return 0;
+}
diff --git a/20230109/loesung-4-gpt-pg.c b/20230109/loesung-4-gpt-pg.c
new file mode 100644
index 0000000000000000000000000000000000000000..50270f858e7de49ea99cb6e125b4775b652ada81
--- /dev/null
+++ b/20230109/loesung-4-gpt-pg.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdint.h>
+
+/* eigentlich: #include "aufgabe-4.xbm" */
+
+#define XBM_WIDTH 14
+#define XBM_HEIGHT 14
+
+static unsigned char xbm_bits[] = {
+ 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+ 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+ 0xf0, 0x03, 0x00, 0x00
+};
+
+int main(int argc, char **argv)
+{
+ // Öffne die Ausgabedatei
+ FILE *output_file = fopen("test.pbm", "w");
+ if (output_file == NULL) {
+ printf("Fehler beim Öffnen der Ausgabedatei\n");
+ return 1;
+ }
+
+ // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+ fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+ // Iteriere über jedes Byte im XBM-Array
+ for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
+ for (int j = 7; j >= 0; j--) {
+ // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+ // PG: nicht berücksichtigt: umgekehrte Bit-Reihenfolge (MSB/LSB first)
+ uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+ fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+ }
+ }
+
+ // Schließe die Ausgabedatei
+ fclose(output_file);
+
+ return 0;
+}
+
diff --git a/20230109/loesung-4-gpt.c b/20230109/loesung-4-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..8a47e33344c510eb059c7e876ae5300aca3c35ed
--- /dev/null
+++ b/20230109/loesung-4-gpt.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define XBM_WIDTH 14
+#define XBM_HEIGHT 14
+
+static unsigned char xbm_bits[] = {
+ 0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+ 0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+ 0xf0, 0x03, 0x00, 0x00
+};
+
+int main(int argc, char **argv)
+{
+ // Öffne die Ausgabedatei
+ FILE *output_file = fopen("test.pbm", "w");
+ if (output_file == NULL) {
+ printf("Fehler beim Öffnen der Ausgabedatei\n");
+ return 1;
+ }
+
+ // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+ fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+ // Iteriere über jedes Byte im XBM-Array
+ for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) { // Iteriere über jedes Bit im aktuellen Byte
+ for (int j = 7; j >= 0; j--) {
+ // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+ uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+ fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+ }
+ }
+
+ // Schließe die Ausgabedatei
+ fclose(output_file);
+
+ return 0;
+}
+
diff --git a/20230109/output-01.c b/20230109/output-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..d4f8b191d6d4491df2661046ce99c21ec2045a60
--- /dev/null
+++ b/20230109/output-01.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main (void)
+{
+ printf (42);
+ return 0;
+}
diff --git a/20230109/test-gpt-pg.pbm b/20230109/test-gpt-pg.pbm
new file mode 100644
index 0000000000000000000000000000000000000000..f0e9e7e193831ff0a079359d6808c7bcaad78670
--- /dev/null
+++ b/20230109/test-gpt-pg.pbm
@@ -0,0 +1,3 @@
+P1
+16 14
+000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
diff --git a/20230109/test-gpt.pbm b/20230109/test-gpt.pbm
new file mode 100644
index 0000000000000000000000000000000000000000..485ad2684c82d10da9d600467ddd1e89f7682080
--- /dev/null
+++ b/20230109/test-gpt.pbm
@@ -0,0 +1,3 @@
+P4
+14 14
+000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
\ No newline at end of file