Skip to content
Snippets Groups Projects
Commit 80e414ff authored by Peter Gerwinski's avatar Peter Gerwinski
Browse files

Lösung der Klausur vom 13.2.2018 durch ChatGPT

parent 517fde7b
Branches 2018ws
No related tags found
No related merge requests found
#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;
}
#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;
}
#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;
}
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.
#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;
}
#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;
}
#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;
}
#include <stdio.h>
int main (void)
{
printf (42);
return 0;
}
P1
16 14
000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
P4
14 14
000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment