diff --git a/20190107/Tower_of_Hanoi.jpeg b/20190107/Tower_of_Hanoi.jpeg new file mode 120000 index 0000000000000000000000000000000000000000..a1a794afda08596ffa2f46f278db53455de25b6c --- /dev/null +++ b/20190107/Tower_of_Hanoi.jpeg @@ -0,0 +1 @@ +../common/Tower_of_Hanoi.jpeg \ No newline at end of file diff --git a/20190107/aufgabe-1-32.s b/20190107/aufgabe-1-32.s new file mode 100644 index 0000000000000000000000000000000000000000..0b757302715611319b01031e3c801a5ea694ce28 --- /dev/null +++ b/20190107/aufgabe-1-32.s @@ -0,0 +1,57 @@ + .file "aufgabe-1.c" + .text + .globl main + .type main, @function +main: +.LFB11: + .cfi_startproc + leal 4(%esp), %ecx + .cfi_def_cfa 1, 0 + andl $-16, %esp + pushl -4(%ecx) + pushl %ebp + .cfi_escape 0x10,0x5,0x2,0x75,0 + movl %esp, %ebp + pushl %ebx + pushl %ecx + .cfi_escape 0xf,0x3,0x75,0x78,0x6 + .cfi_escape 0x10,0x3,0x2,0x75,0x7c + subl $28, %esp + call __x86.get_pc_thunk.bx + addl $_GLOBAL_OFFSET_TABLE_, %ebx + movl $1819042120, -24(%ebp) + movl $1461726319, -20(%ebp) + movl $561278053, -16(%ebp) + movb $0, -12(%ebp) + leal -24(%ebp), %eax + pushl %eax + call puts@PLT + addl $16, %esp + movl $0, %eax + leal -8(%ebp), %esp + popl %ecx + .cfi_restore 1 + .cfi_def_cfa 1, 0 + popl %ebx + .cfi_restore 3 + popl %ebp + .cfi_restore 5 + leal -4(%ecx), %esp + .cfi_def_cfa 4, 4 + ret + .cfi_endproc +.LFE11: + .size main, .-main + .section .text.__x86.get_pc_thunk.bx,"axG",@progbits,__x86.get_pc_thunk.bx,comdat + .globl __x86.get_pc_thunk.bx + .hidden __x86.get_pc_thunk.bx + .type __x86.get_pc_thunk.bx, @function +__x86.get_pc_thunk.bx: +.LFB12: + .cfi_startproc + movl (%esp), %ebx + ret + .cfi_endproc +.LFE12: + .ident "GCC: (Debian 6.3.0-18+deb9u1) 6.3.0 20170516" + .section .note.GNU-stack,"",@progbits diff --git a/20190107/aufgabe-1-64.s b/20190107/aufgabe-1-64.s new file mode 100644 index 0000000000000000000000000000000000000000..74a689c7b46f0e6e4911eb0b0dbad88d17b3a8bd --- /dev/null +++ b/20190107/aufgabe-1-64.s @@ -0,0 +1,24 @@ + .file "aufgabe-1.c" + .text + .globl main + .type main, @function +main: +.LFB11: + .cfi_startproc + subq $40, %rsp + .cfi_def_cfa_offset 48 + movl $1819042120, (%rsp) + movabsq $2410670883059281007, %rax + movq %rax, 8(%rsp) + movb $0, 16(%rsp) + movq %rsp, %rdi + call puts@PLT + movl $0, %eax + addq $40, %rsp + .cfi_def_cfa_offset 8 + ret + .cfi_endproc +.LFE11: + .size main, .-main + .ident "GCC: (Debian 6.3.0-18+deb9u1) 6.3.0 20170516" + .section .note.GNU-stack,"",@progbits diff --git a/20190107/aufgabe-1.c b/20190107/aufgabe-1.c new file mode 100644 index 0000000000000000000000000000000000000000..cb09b0e10aade5c202ed88fddcb2e52d700d9915 --- /dev/null +++ b/20190107/aufgabe-1.c @@ -0,0 +1,16 @@ +#include <stdio.h> +#include <stdint.h> + +typedef struct +{ + uint32_t a; + uint64_t b; + uint8_t c; +} three_numbers; + +int main (void) +{ + three_numbers xyz = { 1819042120, 2410670883059281007, 0 }; + printf ("%s\n", &xyz); + return 0; +} diff --git a/20190107/aufgabe-2.c b/20190107/aufgabe-2.c new file mode 100644 index 0000000000000000000000000000000000000000..33dbe39325bbfe9bf2481194b0be3420f1e3344e --- /dev/null +++ b/20190107/aufgabe-2.c @@ -0,0 +1,26 @@ +#include <stdio.h> +#include <stdint.h> + +void output (uint16_t *a) +{ + for (int i = 0; a[i]; i++) + printf (" %d", a[i]); + printf ("\n"); +} + +int main (void) +{ + uint16_t prime_numbers[] = { 2, 3, 5, 7, 11, 13, 17, 0 }; + + uint16_t *p1 = prime_numbers; + output (p1); + p1++; + output (p1); + + char *p2 = prime_numbers; + output (p2); + p2++; + output (p2); + + return 0; +} diff --git a/20190107/aufgabe-3a.c b/20190107/aufgabe-3a.c new file mode 100644 index 0000000000000000000000000000000000000000..61b6e79400afbb8ac0609eb1b72c04b83a0fce41 --- /dev/null +++ b/20190107/aufgabe-3a.c @@ -0,0 +1,50 @@ +#include <stdio.h> + +#define ANIMAL 0 +#define WITH_WINGS 1 +#define WITH_LEGS 2 + +typedef struct animal +{ + int type; + char *name; +} animal; + +typedef struct with_wings +{ + int wings; +} with_wings; + +typedef struct with_legs +{ + int legs; +} with_legs; + +int main (void) +{ + animal *a[2]; + + animal duck; + a[0] = &duck; + a[0]->type = WITH_WINGS; + a[0]->name = "duck"; + a[0]->wings = 2; + + animal cow; + a[1] = &cow; + a[1]->type = WITH_LEGS; + a[1]->name = "cow"; + a[1]->legs = 4; + + for (int i = 0; i < 2; i++) + if (a[i]->type == WITH_LEGS) + printf ("A %s has %d legs.\n", a[i]->name, + ((with_legs *) a[i])-> legs); + else if (a[i]->type == WITH_WINGS) + printf ("A %s has %d wings.\n", a[i]->name, + ((with_wings *) a[i])-> wings); + else + printf ("Error in animal: %s\n", a[i]->name); + + return 0; +} diff --git a/20190107/aufgabe-3b.c b/20190107/aufgabe-3b.c new file mode 100644 index 0000000000000000000000000000000000000000..2cf3b56f4540f399d3761b0de929d80a1f1de611 --- /dev/null +++ b/20190107/aufgabe-3b.c @@ -0,0 +1,50 @@ +#include <stdio.h> + +#define ANIMAL 0 +#define WITH_WINGS 1 +#define WITH_LEGS 2 + +typedef struct animal +{ + int type; + char *name; +} animal; + +typedef struct with_wings +{ + int wings; +} with_wings; + +typedef struct with_legs +{ + int legs; +} with_legs; + +int main (void) +{ + animal *a[2]; + + animal duck; + a[0] = &duck; + a[0]->type = WITH_WINGS; + a[0]->name = "duck"; + ((with_wings *) a[0])->wings = 2; + + animal cow; + a[1] = &cow; + a[1]->type = WITH_LEGS; + a[1]->name = "cow"; + ((with_legs *) a[1])->legs = 4; + + for (int i = 0; i < 2; i++) + if (a[i]->type == WITH_LEGS) + printf ("A %s has %d legs.\n", a[i]->name, + ((with_legs *) a[i])-> legs); + else if (a[i]->type == WITH_WINGS) + printf ("A %s has %d wings.\n", a[i]->name, + ((with_wings *) a[i])-> wings); + else + printf ("Error in animal: %s\n", a[i]->name); + + return 0; +} diff --git a/20190107/bsort-1.c b/20190107/bsort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..3c02adc72e6a7e702e2c7c68c838fc94cc8ef547 --- /dev/null +++ b/20190107/bsort-1.c @@ -0,0 +1,48 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + for (int i = 1; name[i]; i++) + if (compare (name, i - 1, i) > 0) + { + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/bsort-2.c b/20190107/bsort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..d277be0182a40ecd0c66eaeef94d7aebac6aa542 --- /dev/null +++ b/20190107/bsort-2.c @@ -0,0 +1,55 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0) + { + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted--; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/bsort-3.c b/20190107/bsort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..67d0097b913171b4523f4f04b6b6ff494046dabd --- /dev/null +++ b/20190107/bsort-3.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int done = 0; + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0 && !done) + { + done = 1; + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + done = 0; + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted--; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/bsort-4.c b/20190107/bsort-4.c new file mode 100644 index 0000000000000000000000000000000000000000..241270a46f4ffa005d252207d769c3c4059ed7e2 --- /dev/null +++ b/20190107/bsort-4.c @@ -0,0 +1,57 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0) + { + int new_sorted = 0; + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + new_sorted = i; + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted = new_sorted; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/gtk-1.c b/20190107/gtk-1.c new file mode 100644 index 0000000000000000000000000000000000000000..884a14ea528431e54f8391c801958a6e494dfe43 --- /dev/null +++ b/20190107/gtk-1.c @@ -0,0 +1,11 @@ +#include <gtk/gtk.h> + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-2.c b/20190107/gtk-2.c new file mode 100644 index 0000000000000000000000000000000000000000..c5db19f8d7e859ff12b08ffd6425b84deab35d07 --- /dev/null +++ b/20190107/gtk-2.c @@ -0,0 +1,12 @@ +#include <gtk/gtk.h> + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-3.c b/20190107/gtk-3.c new file mode 100644 index 0000000000000000000000000000000000000000..26fcdd9bf83023b4f3e704a93218134149829f83 --- /dev/null +++ b/20190107/gtk-3.c @@ -0,0 +1,16 @@ +#include <gtk/gtk.h> + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (window), button); + gtk_widget_show (button); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-4.c b/20190107/gtk-4.c new file mode 100644 index 0000000000000000000000000000000000000000..3e15b640a0f1503294f93bb69fa0b457d60288e4 --- /dev/null +++ b/20190107/gtk-4.c @@ -0,0 +1,25 @@ +#include <gtk/gtk.h> + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + + GtkWidget *drawing_area = gtk_drawing_area_new (); + gtk_container_add (GTK_CONTAINER (vbox), drawing_area); + + gtk_widget_show (button); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-5.c b/20190107/gtk-5.c new file mode 100644 index 0000000000000000000000000000000000000000..132dbcb61fb979372da88225e8cb881d2b81a2d4 --- /dev/null +++ b/20190107/gtk-5.c @@ -0,0 +1,26 @@ +#include <gtk/gtk.h> + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + + GtkWidget *drawing_area = gtk_drawing_area_new (); + gtk_container_add (GTK_CONTAINER (vbox), drawing_area); + + gtk_widget_show (drawing_area); + gtk_widget_show (button); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-6.c b/20190107/gtk-6.c new file mode 100644 index 0000000000000000000000000000000000000000..81e12e6958d3c0adbed8d315927104482bc4c681 --- /dev/null +++ b/20190107/gtk-6.c @@ -0,0 +1,53 @@ +#include <gtk/gtk.h> + +gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data) +{ + GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 }; + GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 }; + GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 }; + + gdk_cairo_set_source_rgba (c, &red); + cairo_rectangle (c, 10, 10, 60, 40); + cairo_fill (c); + + gdk_cairo_set_source_rgba (c, &yellow); + cairo_arc (c, 65, 50, 30, 0, 2 * G_PI); + cairo_fill (c); + + gdk_cairo_set_source_rgba (c, &blue); + cairo_move_to (c, 10, 70); + cairo_line_to (c, 70, 70); + cairo_line_to (c, 40, 18); + cairo_close_path (c); + cairo_fill (c); + + return FALSE; /* TRUE to stop other handlers from being invoked for the event. + FALSE to propagate the event further. */ +} + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + + GtkWidget *drawing_area = gtk_drawing_area_new (); + gtk_container_add (GTK_CONTAINER (vbox), drawing_area); + g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL); + gtk_widget_set_size_request (drawing_area, 100, 100); + + gtk_widget_show (drawing_area); + gtk_widget_show (button); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/gtk-7.c b/20190107/gtk-7.c new file mode 100644 index 0000000000000000000000000000000000000000..11041fbe1d27585ca4edb951f195f114ddad126e --- /dev/null +++ b/20190107/gtk-7.c @@ -0,0 +1,71 @@ +#include <stdio.h> +#include <gtk/gtk.h> + +gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data) +{ + GdkRGBA red = { 1.0, 0.0, 0.0, 0.8 }; + GdkRGBA yellow = { 1.0, 1.0, 0.0, 0.6 }; + GdkRGBA blue = { 0.0, 0.5, 1.0, 0.4 }; + + gdk_cairo_set_source_rgba (c, &red); + cairo_rectangle (c, 10, 10, 60, 40); + cairo_fill (c); + + gdk_cairo_set_source_rgba (c, &yellow); + cairo_arc (c, 65, 50, 30, 0, 2 * G_PI); + cairo_fill (c); + + gdk_cairo_set_source_rgba (c, &blue); + cairo_move_to (c, 10, 70); + cairo_line_to (c, 70, 70); + cairo_line_to (c, 40, 18); + cairo_close_path (c); + cairo_fill (c); + + return FALSE; /* TRUE to stop other handlers from being invoked for the event. + FALSE to propagate the event further. */ +} + +gboolean button_press (GtkWidget *widget, GdkEventButton *e, gpointer data) +{ + printf ("button %d pressed at (%lf, %lf)\n", e->button, e->x, e->y); + return FALSE; +} + +gboolean key_press (GtkWidget *widget, GdkEventKey *e, gpointer data) +{ + printf ("key '%c' (%d) pressed\n", e->keyval, e->keyval); + return FALSE; +} + +int main (int argc, char **argv) +{ + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + + GtkWidget *drawing_area = gtk_drawing_area_new (); + gtk_container_add (GTK_CONTAINER (vbox), drawing_area); + g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL); + gtk_widget_set_size_request (drawing_area, 100, 100); + gtk_widget_add_events (drawing_area, GDK_BUTTON_PRESS_MASK); + g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press), NULL); + + gtk_widget_add_events (window, GDK_KEY_PRESS_MASK); + g_signal_connect (window, "key_press_event", G_CALLBACK (key_press), NULL); + + gtk_widget_show (drawing_area); + gtk_widget_show (button); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; +} diff --git a/20190107/hanoi-0.c b/20190107/hanoi-0.c new file mode 100644 index 0000000000000000000000000000000000000000..83b5f081e33e699f2d5eaa1f858320530e1b2820 --- /dev/null +++ b/20190107/hanoi-0.c @@ -0,0 +1,26 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = 0; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20190107/hanoi-1.c b/20190107/hanoi-1.c new file mode 100644 index 0000000000000000000000000000000000000000..6d005f0b12afa6086afb65e1794fb5c977b474e2 --- /dev/null +++ b/20190107/hanoi-1.c @@ -0,0 +1,30 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = 4; + tower[0][0] = 4; + tower[0][1] = 3; + tower[0][2] = 2; + tower[0][3] = 1; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20190107/hanoi-2.c b/20190107/hanoi-2.c new file mode 100644 index 0000000000000000000000000000000000000000..c928c1130539da08d0882249bdffc877d72289b2 --- /dev/null +++ b/20190107/hanoi-2.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20190107/hanoi-3.c b/20190107/hanoi-3.c new file mode 100644 index 0000000000000000000000000000000000000000..4b59c046962c1f79eca315882d93faf6b6c298c1 --- /dev/null +++ b/20190107/hanoi-3.c @@ -0,0 +1,44 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + move (2, 0, 1); + display (); + return 0; +} diff --git a/20190107/hanoi-4.c b/20190107/hanoi-4.c new file mode 100644 index 0000000000000000000000000000000000000000..162a5ba7cccedf64bff8ae9a514aaf146088e3a4 --- /dev/null +++ b/20190107/hanoi-4.c @@ -0,0 +1,44 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + move (0, 2, 1); + display (); + return 0; +} diff --git a/20190107/hanoi-5.c b/20190107/hanoi-5.c new file mode 100644 index 0000000000000000000000000000000000000000..e04ad85f63fe92e5c15d22646beb9e9107bf78d6 --- /dev/null +++ b/20190107/hanoi-5.c @@ -0,0 +1,45 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, 1); + return 0; +} diff --git a/20190107/hanoi-6.c b/20190107/hanoi-6.c new file mode 100644 index 0000000000000000000000000000000000000000..1267605f802246e857c32d29cc0a132609cb24ce --- /dev/null +++ b/20190107/hanoi-6.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20190107/hanoi-7.c b/20190107/hanoi-7.c new file mode 100644 index 0000000000000000000000000000000000000000..f71fcdc0c3f66047ee3ad870d019a06eb328050f --- /dev/null +++ b/20190107/hanoi-7.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 5 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20190107/hanoi-8.c b/20190107/hanoi-8.c new file mode 100644 index 0000000000000000000000000000000000000000..6d804063531d424a82924a89d85424c33994793b --- /dev/null +++ b/20190107/hanoi-8.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 64 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20190107/hanoi-9.c b/20190107/hanoi-9.c new file mode 100644 index 0000000000000000000000000000000000000000..7694b373b7011e96f6be0ad0f00ba54b67086158 --- /dev/null +++ b/20190107/hanoi-9.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 64 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + static int counter = 1; + if (counter++ >= 100000000) + { + display (); + counter = 1; + } + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + display (); + return 0; +} diff --git a/20190107/hanoi-9a.c b/20190107/hanoi-9a.c new file mode 100644 index 0000000000000000000000000000000000000000..55e8d74db6d7284d6db225a6f8f3e08ab4efdc06 --- /dev/null +++ b/20190107/hanoi-9a.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 32 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + static int counter = 1; + if (counter++ >= 100000000) + { + display (); + counter = 1; + } + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + display (); + return 0; +} diff --git a/20190107/hello-gtk.png b/20190107/hello-gtk.png new file mode 120000 index 0000000000000000000000000000000000000000..cca99209d86683a9a3b0f70bbc149780bae10ba6 --- /dev/null +++ b/20190107/hello-gtk.png @@ -0,0 +1 @@ +../common/hello-gtk.png \ No newline at end of file diff --git a/20190107/hp-20190107.pdf b/20190107/hp-20190107.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f29469844093a266764aadca67e69ca9a0bc9e4c Binary files /dev/null and b/20190107/hp-20190107.pdf differ diff --git a/20190107/hp-20190107.tex b/20190107/hp-20190107.tex new file mode 100644 index 0000000000000000000000000000000000000000..e87ff48825c5bfa9fd24eced460d36b2968eec9f --- /dev/null +++ b/20190107/hp-20190107.tex @@ -0,0 +1,826 @@ +% hp-20190107.pdf - Lecture Slides on Low-Level Programming +% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019 Peter Gerwinski +% +% This document is free software: you can redistribute it and/or +% modify it either under the terms of the Creative Commons +% Attribution-ShareAlike 3.0 License, or under the terms of the +% GNU General Public License as published by the Free Software +% Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% This document is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this document. If not, see <http://www.gnu.org/licenses/>. +% +% You should have received a copy of the Creative Commons +% Attribution-ShareAlike 3.0 Unported License along with this +% document. If not, see <http://creativecommons.org/licenses/>. + +% README: Aufwandsabschätzungen, objektorientierte Programmierung in C + +\documentclass[10pt,t]{beamer} + +\usepackage{pgslides} +\usepackage{pdftricks} +\usepackage{tikz} +\usepackage{rotating} + +\begin{psinputs} + \usepackage[utf8]{inputenc} + \usepackage[german]{babel} + \usepackage[T1]{fontenc} + \usepackage{helvet} + \renewcommand*\familydefault{\sfdefault} + \usepackage{pstricks,pst-grad} +\end{psinputs} + +\title{Hardwarenahe Programmierung} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{7.\ Januar 2019} + +\begin{document} + +\maketitleframe + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}} + \item[\textbf{2}] \textbf{Einführung in C} + \item[\textbf{3}] \textbf{Bibliotheken} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \item[\textbf{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \color{medgreen} + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{6}] \textbf{Objektorientierte Programmierung} + \begin{itemize} + \color{red} + \item[6.0] Dynamische Speicherverwaltung + \item[6.1] Konzepte und Ziele + \item[6.2] Beispiel: Zahlen und Buchstaben + \item[6.3] Beispiel: Graphische Benutzeroberfläche (GUI) + \vspace*{-\smallskipamount} + \item[\dots] + \end{itemize} + \item[\textbf{7}] \textbf{Datenstrukturen} + \end{itemize} + \vspace*{-1cm} + +\end{frame} + +\setcounter{section}{4} +\section{Algorithmen} +\setcounter{subsection}{1} +\subsection{Rekursion} + +\begin{frame}[fragile] + + \showsubsection + + Vollständige Induktion: + \vspace*{-0.725cm} + \begin{displaymath} + \hspace*{4cm} + \left. + \begin{array}{r} + \mbox{Aussage gilt für $n = 1$}\\[2pt] + \mbox{Schluß von $n - 1$ auf $n$} + \end{array} + \right\} + \mbox{Aussage gilt für alle $n\in\mathbb{N}$} + \end{displaymath} + \vspace*{-0.5cm} + +% \pause + + Türme von Hanoi + +% \begin{onlyenv}<2> +% \begin{center} +% \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg} +% \end{center} +% \end{onlyenv} + + \begin{onlyenv}<1-> + \begin{itemize} + \item + 64 Scheiben, 3 Plätze, + \only<1>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\ + immer 1 Scheibe verschieben + \item + Ziel: Turm verschieben + \item + Es dürfen nur kleinere Scheiben\\ + auf größeren liegen. + \bigskip +% \pause +% \pause + \item + $n = 1$ Scheibe: fertig + \item + Wenn $n - 1$ Scheiben verschiebbar:\\ + schiebe $n - 1$ Scheiben auf Hilfsplatz,\\ + verschiebe die darunterliegende,\\ + hole $n - 1$ Scheiben von Hilfsplatz + \end{itemize} + \begin{onlyenv}<2> + \vspace{-4.3cm} + \begin{lstlisting}[gobble=8,xleftmargin=6.4cm] + void move (int from, int to, int disks) + { + if (disks == 1) + move_one_disk (from, to); + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } + } + \end{lstlisting} + \end{onlyenv} + \begin{onlyenv}<3-> + \vspace{-5.0cm} + \hspace*{7.4cm}\begin{minipage}[t]{5cm} + 32 Scheiben: + \begin{lstlisting}[gobble=10,style=terminal] + $ ¡time ./hanoi-9a¿ + ... + real 0m32,712s + user 0m32,708s + sys 0m0,000s + \end{lstlisting} + \pause[4] + \begin{itemize} + \arrowitem + etwas über 1 Minute\\ + für 64 Scheiben + \end{itemize} +% \pause + \vspace*{-0.5cm} + \begin{picture}(0,0) + \color{red} + \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}} + \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}} + \end{picture} + + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + \end{minipage} + \end{onlyenv} + \end{onlyenv} + +\end{frame} + +\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse} + +\begin{frame}[fragile] + + \newcommand{\w}{\hspace*{0.75pt}} + + \showsubsection + + \begin{picture}(0,0) + \put(7.6,-0.3){% + \begin{minipage}[t]{5.3cm} +% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf} + \vspace*{-1.0cm}\alt<7->{\includegraphics{landau-symbols-2.pdf}}% + {\includegraphics{landau-symbols.pdf}} + \small + \begin{description}\itemsep0pt\leftskip-0.5cm + \item[$n$:] Eingabedaten + \item[$g(n)$:] Rechenzeit + \end{description} + \end{minipage}} + \end{picture} + + \vspace*{-1.5\bigskipamount} + + \begin{itemize} + \item + Türme von Hanoi: $\mathcal{O}(2^n)$ + \begin{onlyenv}<1> + \par\medskip + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + \end{onlyenv} +% \end{itemize} +% + \pause +% +% Beispiel: Sortieralgorithmen +% +% \begin{itemize} + \item + Minimum suchen: \alt<1->{$\mathcal{O}(n)$}{$\mathcal{O}(\textbf{\color{red}?})$} +% \pause + \item + \dots\ mit Schummeln: $\mathcal{O}(1)$ +% \pause +% \pause + \begin{picture}(0,0) + \put(-4.742,-4.3){\begin{minipage}[t]{12cm} + Faustregel:\\Schachtelung der Schleifen zählen\\ + $x$ Schleifen \textarrow\ $\mathcal{O}(n\w^x)$ + \vspace{0.5\smallskipamount} + \begin{onlyenv}<7-> + \begin{tabbing} + Verschlüsselung brechen (Primfaktorzerlegung):~\=\kill + \textbf{\color{red}RSA}: Schlüsselerzeugung (Berechnung von $d\/$): + \> \color{red}$\mathcal{O}\bigl((\log n)^2\bigr)$,\\[0.5\smallskipamount] + Ver- und Entschlüsselung (Exponentiation): + \> \color{red}$\mathcal{O}\kern0.5pt(n\log n)$,\\[0.5\smallskipamount] + Verschlüsselung brechen (Primfaktorzerlegung): + \> \color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$ + \end{tabbing} + \end{onlyenv} + \end{minipage}} + \end{picture} +% \pause + \item + Minimum an den Anfang tauschen,\\ + nächstes Minimum suchen:\\ + \textarrow\ Selectionsort: $\mathcal{O}(n\w^2)$ + \pause + \item + Während Minimumsuche prüfen\\und abbrechen, falls schon sortiert\\ + \textarrow\ Bubblesort\pause: $\mathcal{O}(n)$ bis $\mathcal{O}(n\w^2)$ + \pause + \item + Rekursiv sortieren\\ + \textarrow\ Quicksort\pause: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n\w^2)$\hfill + \end{itemize} + +\end{frame} + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}} + \item[\textbf{2}] \textbf{Einführung in C} + \item[\textbf{3}] \textbf{Bibliotheken} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \item[\textbf{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \color{medgreen} + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen + \end{itemize} + \item[\textbf{6}] \textbf{Objektorientierte Programmierung} + \begin{itemize} + \color{red} + \item[6.0] Dynamische Speicherverwaltung + \item[6.1] Konzepte und Ziele + \item[6.2] Beispiel: Zahlen und Buchstaben + \item[6.3] Beispiel: Graphische Benutzeroberfläche (GUI) + \vspace*{-\smallskipamount} + \item[\dots] + \end{itemize} + \item[\textbf{7}] \textbf{Datenstrukturen} + \end{itemize} + \vspace*{-1cm} + +\end{frame} + +\section{Objektorientierte Programmierung} +\addtocounter{subsection}{-1} +\subsection{Dynamische Speicherverwaltung} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \begin{itemize} + \item + Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen) + \item + Dynamisches Array: variable Anzahl von Elementen desselben Typs + \end{itemize} + + \bigskip + + \begin{lstlisting} + char *name[] = { "Anna", "Berthold", "Caesar" }; + + ... + + name[3] = "Dieter"; + \end{lstlisting} + + \begin{picture}(0,0) + \color{red} + \put(0,0){\line(3,1){3.5}} + \put(0,1){\line(3,-1){3.5}} + \end{picture} + +\end{frame} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \bigskip + + \begin{lstlisting} + #include <stdlib.h> + + ... + + char **name = malloc (3 * sizeof (char *)); + /* Speicherplatz für 3 Zeiger anfordern */ + + ... + + free (name) + /* Speicherplatz freigeben */ + + \end{lstlisting} + +\end{frame} + +\subsection{Konzepte und Ziele} + +\begin{frame} + + \showsection + \showsubsection + + \begin{itemize} + \item + Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen) + \item + Dynamisches Array: variable Anzahl von Elementen desselben Typs + \item + Problem: Elemente unterschiedlichen Typs + \item + Lösung: den Typ des Elements zusätzlich speichern + \end{itemize} + \begin{itemize} + \item + Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden} + \begin{onlyenv}<1> + \item + Was die Funktion bewirkt,\\ + hängt vom Typ des Objekts ab + \item + Realisierung über endlose \lstinline{if}-Ketten + \end{onlyenv} + \begin{onlyenv}<2> + \item + Was die Funktion bewirkt + \begin{picture}(0,0) + \color{red} + \put(-4.00,-0.10){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);% + \draw[thick](-0.1,-0.05)--(3.75,0.3);}} + \end{picture}% + Welche Funktion aufgerufen wird,\\ + hängt vom Typ des Objekts ab: \newterm{virtuelle Methode} + \item + Realisierung über endlose \lstinline{if}-Ketten% + \begin{picture}(0,0) + \color{red} + \put(-2.75,-0.10){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);% + \draw[thick](-0.1,-0.05)--(2.5,0.3);}} + \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\ kommt demnächst\end{rotate}} + \end{picture} + Zeiger, die im Objekt gespeichert sind\\ + (Genaugenommen: Tabelle von Zeigern) + \end{onlyenv} + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsection + \showsubsection + + \begin{itemize} + \item + Problem: Elemente unterschiedlichen Typs + \item + Lösung: den Typ des Elements zusätzlich speichern + \item + \newterm{Methoden\/} und \newterm{virtuelle Methoden} + \end{itemize} + + \begin{itemize} + \item + Zeiger auf verschiedene Strukturen\\ + mit einem gemeinsamen Anteil von Datenfeldern\\ + \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassen} von Objekten + \item + Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\ + \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung} + \item +% Explizite Typumwandlung eines Zeigers auf die Basisklasse\\ +% in einen Zeiger auf die \newterm{abgeleitete Klasse}\\ +% \textarrow\ Man kann ein Array unterschiedlicher Objekte\\ +% \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\ + Zeiger auf die Basisklasse dürfen auf Objekte\\ + der \newterm{abgeleiteten Klasse} zeigen\\ + \textarrow\ \newterm{Polymorphie} + \end{itemize} + +\end{frame} + +\subsection{Beispiel: Zahlen und Buchstaben} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + } t_base;¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\begin{frame}[fragile] + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + } t_base;¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage}\\[0.7cm] + \begin{onlyenv}<1> + \begin{minipage}{8cm} + \begin{lstlisting}[gobble=10] + ¡t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s };¿ + \end{lstlisting} + \end{minipage}% + \begin{picture}(0,0) + \color{red} + \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}} + \end{picture} + \end{onlyenv} +% \begin{onlyenv}<2> +% \begin{minipage}{5cm} +% \begin{lstlisting}[gobble=10] +% ¡typedef union +% { +% t_base base; +% t_integer integer; +% t_string string; +% } t_object;¿ +% \end{lstlisting} +% \end{minipage} +% \end{onlyenv} + \end{center} + +\end{frame} + +\iffalse + +\begin{frame}[fragile] + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + typedef struct + { + void (* print) (union t_object *this); + } t_base; + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + typedef struct + { + void (* print) (...); + int content; + } t_integer; + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + typedef struct + { + void (* print) (union t_object *this); + char *content; + } t_string; + \end{lstlisting} + \end{minipage}\\[0.7cm] + \begin{minipage}{7cm} + \begin{lstlisting}[gobble=8] + typedef union + { + t_base base; + t_integer integer; + t_string string; + } t_object; + \end{lstlisting} + \end{minipage} + \vspace*{-2.2cm}% + \begin{lstlisting}[gobble=6] + object[i]->base.print (object[i]); + \end{lstlisting} + \end{center} + +\end{frame} + +\fi + +\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)} + +\begin{frame}[fragile] + + \showsubsection + + \scriptsize + \begin{lstlisting} + #include <gtk/gtk.h> + + int main (int argc, char **argv) + { + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); + GtkWidget *label = gtk_label_new ("Hello, world!"); + gtk_container_add (GTK_CONTAINER (vbox), label); + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + gtk_widget_show (button); + gtk_widget_show (label); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; + } + \end{lstlisting} + + \vspace*{-6cm}\strut\hfill + \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm] + \begin{flushright} + \normalsize\bf Praktikumsversuch:\\ + Objektorientiertes Zeichenprogramm + \end{flushright} + +\end{frame} + +\iffalse + +\subsection{Unions} + +\begin{frame}[fragile] + + \showsubsection + + Variable teilen sich denselben Speicherplatz. + + \medskip + + \begin{minipage}[t]{4.5cm} + \begin{lstlisting}[gobble=6] + typedef union + { + int8_t i; + uint8_t u; + } num8_t; + \end{lstlisting} + \end{minipage} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Variable teilen sich denselben Speicherplatz. + + \medskip + + \begin{minipage}[t]{4.5cm} + \begin{lstlisting}[gobble=6] + typedef union + { + t_base base; + t_integer integer; + t_string string; + } t_object; + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3.5cm} + \begin{lstlisting}[gobble=6] + + typedef struct + { + int type; + int content; + } t_integer; + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3.5cm} + \begin{lstlisting}[gobble=6] + + typedef struct + { + int type; + char *content; + } t_string; + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{center} + \begin{minipage}{8.5cm} + \begin{lstlisting}[gobble=8] + if (this->base.type == T_INTEGER) + printf ("Integer: %d\n", this->integer.content); + else if (this->base.type == T_STRING) + printf ("String: \"%s\"\n", this->string.content); + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\subsection{Virtuelle Methoden} + +\begin{frame}[fragile] + \showsubsection + + \begin{lstlisting} + void print_object (t_object *this) + { + if (this->base.type == T_INTEGER) + printf ("Integer: %d\n", this->integer.content); + else if (this->base.type == T_STRING) + printf ("String: \"%s\"\n", this->string.content); + } + \end{lstlisting} + + \begin{picture}(0,0) + \color{red} + \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}} + \put(1,-2){\mbox{\textarrow}} + \put(0,-3){\mbox{Zeiger auf Funktionen}} + \end{picture} + + \begin{lstlisting}[xleftmargin=4cm] + void print_integer (t_object *this) + { + printf ("Integer: %d\n", this->integer.content); + } + + void print_string (t_object *this) + { + printf ("String: \"%s\"\n", this->string.content); + } + \end{lstlisting} + +\end{frame} + +\begin{frame}[fragile] + \showsubsection + + Zeiger auf Funktionen + + \medskip + + \begin{lstlisting} + void (* print) (t_object *this); + \end{lstlisting} + \begin{picture}(0,1.2)(0,-0.9) + \color{red} + \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}} + \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}} + \end{picture} + + \begin{itemize} + \item + Objekt enthält Zeiger auf Funktion + \item + Konstruktor initialisiert diesen Zeiger + \item + Aufruf: "`automatisch"' die richtige Funktion + \medskip + \item + in größeren Projekten:\\ + Objekt enthält Zeiger auf Tabelle von Funktionen + \end{itemize} +\end{frame} + +\fi + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}} + \item[\textbf{2}] \textbf{Einführung in C} + \item[\textbf{3}] \textbf{Bibliotheken} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \item[\textbf{5}] \textbf{Algorithmen} + \item[\textbf{6}] \textbf{Objektorientierte Programmierung} + \begin{itemize} + \color{medgreen} + \item[6.0] Dynamische Speicherverwaltung + \item[6.1] Konzepte und Ziele + \item[6.2] Beispiel: Zahlen und Buchstaben + \item[6.3] Beispiel: Graphische Benutzeroberfläche (GUI) + \color{red} + \item[6.4] Unions + \item[6.5] Virtuelle Methoden + \item[6.6] Einführung in C++ + \end{itemize} + \item[\textbf{7}] \textbf{Datenstrukturen} + \end{itemize} + \vspace*{-1cm} + +\end{frame} + +\end{document} diff --git a/20190107/hp-uebung-20190107.pdf b/20190107/hp-uebung-20190107.pdf new file mode 100644 index 0000000000000000000000000000000000000000..8a8113c575bdd50d401ef174ac8a2ed76ae94ad0 Binary files /dev/null and b/20190107/hp-uebung-20190107.pdf differ diff --git a/20190107/hp-uebung-20190107.tex b/20190107/hp-uebung-20190107.tex new file mode 100644 index 0000000000000000000000000000000000000000..d4299df321b1ba4b6e43c2ee9361aa310db907d9 --- /dev/null +++ b/20190107/hp-uebung-20190107.tex @@ -0,0 +1,307 @@ +% hp-uebung-20190107.pdf - Exercises on Low-Level Programming / Applied Computer Sciences +% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019 Peter Gerwinski +% +% This document is free software: you can redistribute it and/or +% modify it either under the terms of the Creative Commons +% Attribution-ShareAlike 3.0 License, or under the terms of the +% GNU General Public License as published by the Free Software +% Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% This document is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this document. If not, see <http://www.gnu.org/licenses/>. +% +% You should have received a copy of the Creative Commons +% Attribution-ShareAlike 3.0 Unported License along with this +% document. If not, see <http://creativecommons.org/licenses/>. + +% README: Speicherformate von Zahlen, Zeigerarithmetik, objektorientierte Tier-Datenbank + +\documentclass[a4paper]{article} + +\usepackage{pgscript} + +\begin{document} + +% \thispagestyle{empty} + + \section*{Hardwarenahe Programmierung\\ + Übungsaufgaben -- 7.\ Januar 2019} + + Diese Übung enthält Punkteangaben wie in einer Klausur. + Um zu "`bestehen"', müssen Sie innerhalb von 100 Minuten + unter Verwendung ausschließlich zugelassener Hilfsmittel + 18 Punkte (von insgesamt \totalpoints) erreichen. + + \exercise{Speicherformate von Zahlen} + + Wir betrachten das folgende Programm (\gitfile{hp}{20190107}{aufgabe-1.c}): + \begin{lstlisting}[style=numbered] + #include <stdio.h> + #include <stdint.h> + + typedef struct + { + uint32_t a; + uint64_t b; + uint8_t c; + } three_numbers; + + int main (void) + { + three_numbers xyz = { 1819042120, 2410670883059281007, 0 }; + printf ("%s\n", &xyz); + return 0; + } + \end{lstlisting} + + Das Programm wird für einen 32-Bit-Rechner compiliert und ausgeführt.\\ + (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m32} sorgt dafür, + daß \lstinline[style=cmd]{gcc} Code für einen 32-Bit-Prozessor erzeugt.) + + \begin{lstlisting}[style=terminal] + $ ¡gcc -Wall -m32 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¿ + Hallo, Welt! + \end{lstlisting} + + \begin{enumerate}[\quad(a)] + \item + Erklären Sie die beim Compilieren auftretende Warnung. + \points{2} + \item + Erklären Sie die Ausgabe des Programms. + \points{4} + \item + Welche Endianness hat der verwendete Rechner? + Wie sähe die Ausgabe auf einem Rechner mit entgegengesetzter Endianness aus? + \points{2} + \item + Dasselbe Programm wird nun für einen 64-Bit-Rechner compiliert und ausgeführt.\\ + (Die \lstinline[style=cmd]{gcc}-Option \lstinline[style=cmd]{-m64} sorgt dafür, + daß \lstinline[style=cmd]{gcc} Code für einen 64-Bit-Prozessor erzeugt.) + \begin{lstlisting}[style=terminal,gobble=8] + $ ¡gcc -Wall -m64 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¿ + Hall5V + \end{lstlisting} + (Es ist möglich, daß die konkrete Ausgabe auf Ihrem Rechner anders aussieht.)\par + Erklären Sie die geänderte Ausgabe des Programms. + \points{3} + \end{enumerate} + + \clearpage + + \exercise{Zeigerarithmetik} + + Wir betrachten das folgende Programm (\gitfile{hp}{20190107}{aufgabe-2.c}): + \begin{lstlisting} + #include <stdio.h> + #include <stdint.h> + + void output (uint16_t *a) + { + for (int i = 0; a[i]; i++) + printf (" %d", a[i]); + printf ("\n"); + } + + int main (void) + { + uint16_t prime_numbers[] = { 2, 3, 5, 7, 11, 13, 17, 0 }; + + uint16_t *p1 = prime_numbers; + output (p1); + p1++; + output (p1); + + char *p2 = prime_numbers; + output (p2); + p2++; + output (p2); + + return 0; + } + \end{lstlisting} + + Das Programm wird compiliert und ausgeführt: + + \begin{lstlisting}[style=terminal] + $ ¡gcc -Wall aufgabe-2.c -o aufgabe-2¿ + aufgabe-2.c: In function 'main': + aufgabe-2.c:20:13: warning: initialization from + incompatible pointer type [enabled by default] + aufgabe-2.c:21:3: warning: passing argument 1 of 'output' from + incompatible pointer type [enabled by default] + aufgabe-2.c:4:6: note: expected 'uint16_t *' but argument is of type 'char *' + aufgabe-2.c:23:3: warning: passing argument 1 of 'output' from + incompatible pointer type [enabled by default] + aufgabe-2.c:4:6: note: expected 'uint16_t *' but argument is of type 'char *' + $ ¡./aufgabe-2¿ + 2 3 5 7 11 13 17 + 3 5 7 11 13 17 + 2 3 5 7 11 13 17 + 768 1280 1792 2816 3328 4352 + \end{lstlisting} + + \begin{enumerate}[\quad(a)] + \item + Erklären Sie die Funktionsweise der Funktion \lstinline{output ()}. + \points{2} + \item + Begründen Sie den Unterschied zwischen der ersten (\lstinline{2 3 5 7 11 13 17})\\ + und der zweiten Zeile (\lstinline{3 5 7 11 13 17}) der Ausgabe des Programms. + \points{2} + \item + Erklären Sie die beim Compilieren auftretenden Warnungen\\ + und die dritte Zeile (\lstinline{2 3 5 7 11 13 17}) der Ausgabe des Programms. + \points{3} + \item + Erklären Sie die vierte Zeile (\lstinline{768 1280 1792 2816 3328 4352}) + der Ausgabe des Programms.\\ +% Welche Endianness hat der verwendete Rechner?\\ +% Wie sähe die Ausgabezeile bei umgekehrter Endianness aus? +% +% 2 0 3 0 5 0 7 0 11 --> 2 3 5 7 11 +% 0 3 0 5 0 7 0 11 --> 768 1280 ... +% +% 0 2 0 3 0 5 0 7 0 11 --> 2 3 5 7 11 +% 2 0 3 0 5 0 7 0 11 --> 768 1280 ... +% +% --> Endianness nicht erkennbar! +% + Sie dürfen einen Little-Endian-Rechner voraussetzen. + \points{4} + \end{enumerate} + + \clearpage + + \exercise{Objektorientierte Tier-Datenbank} + + \begin{minipage}[t]{0.34\textwidth} + \begin{lstlisting}[gobble=6,xleftmargin=0pt] + #include <stdio.h> + + #define ANIMAL 0 + #define WITH_WINGS 1 + #define WITH_LEGS 2 + + typedef struct animal + { + int type; + char *name; + } animal; + + typedef struct with_wings + { + int wings; + } with_wings; + + typedef struct with_legs + { + int legs; + } with_legs; + \end{lstlisting} + \end{minipage}\hfill + \begin{minipage}[t]{0.65\textwidth} + \begin{lstlisting}[gobble=6,xleftmargin=0pt] + int main (void) + { + animal *a[2]; + + animal duck; + a[0] = &duck; + a[0]->type = WITH_WINGS; + a[0]->name = "duck"; + a[0]->wings = 2; + + animal cow; + a[1] = &cow; + a[1]->type = WITH_LEGS; + a[1]->name = "cow"; + a[1]->legs = 4; + + for (int i = 0; i < 2; i++) + if (a[i]->type == WITH_LEGS) + printf ("A %s has %d legs.\n", a[i]->name, + ((with_legs *) a[i])-> legs); + else if (a[i]->type == WITH_WINGS) + printf ("A %s has %d wings.\n", a[i]->name, + ((with_wings *) a[i])-> wings); + else + printf ("Error in animal: %s\n", a[i]->name); + + return 0; + } + \end{lstlisting} + \begin{picture}(0,0) + \color{red} + \put(3.7,6.207){\vector(-1,0){0.7}} + \put(3.8,6.207){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_legs *) a[1])->legs = 4;}}} + \put(4.0,8.735){\vector(-1,0){0.7}} + \put(4.1,8.735){\makebox(0,0)[l]{\lstinline[basicstyle=\color{red}]{((with_wings *) a[0])->wings = 2;}}} + \end{picture} + \end{minipage} + + Das oben in Blau dargestellte Programm (Datei: \gitfile{hp}{20190107}{aufgabe-3a.c}) soll Daten von Tieren verwalten. + + Beim Compilieren erscheinen die folgende Fehlermeldungen: + \begin{lstlisting}[style=terminal] + $ ¡gcc -std=c99 -Wall -O aufgabe-2a.c -o aufgabe-2a¿ + aufgabe-2a.c: In function 'main': + aufgabe-2a.c:31: error: 'animal' has no member named 'wings' + aufgabe-2a.c:37: error: 'animal' has no member named 'legs' + \end{lstlisting} + + Der Programmierer nimmt die oben in Rot dargestellten Ersetzungen vor (Datei: \gitfile{hp}{20190107}{aufgabe-3b.c}).\\ + Daraufhin gelingt das Compilieren, und die Ausgabe des Programms lautet: + \begin{lstlisting}[style=terminal] + $ ¡gcc -std=c99 -Wall -O aufgabe-2b.c -o aufgabe-2b¿ + $ ¡./aufgabe-2b¿ + A duck has 2 legs. + Error in animal: cow + \end{lstlisting} + + \begin{itemize} + \item[(a)] + Erklären Sie die o.\,a.\ Compiler-Fehlermeldungen. + \points{2} + \item[(b)] + Wieso verschwinden die Fehlermeldungen nach den o.\,a.\ Ersetzungen? + \points{3} + \item[(c)] + Erklären Sie die Ausgabe des Programms. + \points{5} + \item[(d)] + Beschreiben Sie -- in Worten und/oder als C-Quelltext -- einen Weg, + das Programm so zu berichtigen, daß es die Eingabedaten + (``A duck has 2 wings. A cow has 4 legs.'') korrekt speichert und ausgibt.\\ + \points{4} + \end{itemize} + + \bigskip + \begin{flushright} + \textit{Viel Erfolg!} + \end{flushright} + + \makeatletter + \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}} + \makeatother + +\end{document} diff --git a/20190107/landau-symbols-2.pdf b/20190107/landau-symbols-2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4 --- /dev/null +++ b/20190107/landau-symbols-2.pdf @@ -0,0 +1 @@ +../common/landau-symbols-2.pdf \ No newline at end of file diff --git a/20190107/landau-symbols.pdf b/20190107/landau-symbols.pdf new file mode 120000 index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565 --- /dev/null +++ b/20190107/landau-symbols.pdf @@ -0,0 +1 @@ +../common/landau-symbols.pdf \ No newline at end of file diff --git a/20190107/logo-hochschule-bochum-cvh-text-v2.pdf b/20190107/logo-hochschule-bochum-cvh-text-v2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8 --- /dev/null +++ b/20190107/logo-hochschule-bochum-cvh-text-v2.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum-cvh-text-v2.pdf \ No newline at end of file diff --git a/20190107/logo-hochschule-bochum.pdf b/20190107/logo-hochschule-bochum.pdf new file mode 120000 index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1 --- /dev/null +++ b/20190107/logo-hochschule-bochum.pdf @@ -0,0 +1 @@ +../common/logo-hochschule-bochum.pdf \ No newline at end of file diff --git a/20190107/names.h b/20190107/names.h new file mode 100644 index 0000000000000000000000000000000000000000..a265ff4141a2cc578d3f6f402822a2dbbd5cea90 --- /dev/null +++ b/20190107/names.h @@ -0,0 +1,50 @@ +"Michael", "Laura", +"Elias", "Julia", +"Luca", "Anna", +"Liam", "Emma", +"Alexander", "Lena", +"Noah", "Vanessa", +"Jonas", "Lea", +"Marcel", "Mila", +"Daniel", "Lisa", +"David", "Lina", +"Milan", "Sarah", +"Julian", "Alina", +"Linus", "Emilia", +"Thomas", "Nina", +"Samuel", "Elena", +"Levin", "Lara", +"Levi", "Melanie", +"Jan", "Hannah", +"Lukas", "Sandra", +"Tim", "Leonie", +"Patrick", "Sophie", +"Marvin", "Mia", +"Andreas", "Amelie", +"Leon", "Selina", +"Tobias", "Luisa", +"Simon", "Maria", +"Valentin", "Jana", +"Robin", "Johanna", +"Paul", "Marie", +"Markus", "Milena", +"Benjamin", "Melina", +"Stefan", "Michelle", +"Felix", "Emily", +"Florian", "Renesmee", +"Fabian", "Aylin", +"Emil", "Jessica", +"Aaron", "Franziska", +"Manuel", "Jasmin", +"Christian", "Fiona", +"Dominik", "Sina", +"Joshua", "Jennifer", +"Moritz", "Claudia", +"Sebastian", "Nicole", +"Peter", "Annika", +"Philipp", "Sophia", +"Max", "Katharina", +"Johannes", "Isabella", +"Finn", "Nele", +"Adrian", "Elisabeth", +"Martin", "Pia", diff --git a/20190107/objects-1.c b/20190107/objects-1.c new file mode 100644 index 0000000000000000000000000000000000000000..1a628668fd7b8fb3a0d9886ac14e8e909bc23793 --- /dev/null +++ b/20190107/objects-1.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { &i, &s }; + + return 0; +} diff --git a/20190107/objects-2.c b/20190107/objects-2.c new file mode 100644 index 0000000000000000000000000000000000000000..a47cfb4276085399afb86795d04b1f6ae20c95bf --- /dev/null +++ b/20190107/objects-2.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + return 0; +} diff --git a/20190107/objects-3.c b/20190107/objects-3.c new file mode 100644 index 0000000000000000000000000000000000000000..ff9224c0767ccad39f5b1396720ee73b6a0455fb --- /dev/null +++ b/20190107/objects-3.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", object[i]->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", object[i]->content); + + return 0; +} diff --git a/20190107/objects-4.c b/20190107/objects-4.c new file mode 100644 index 0000000000000000000000000000000000000000..ef7bffe80471d4b014258824421dce0557fc41dd --- /dev/null +++ b/20190107/objects-4.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", (t_integer *) object[i]->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", (t_string *) object[i]->content); + + return 0; +} diff --git a/20190107/objects-5.c b/20190107/objects-5.c new file mode 100644 index 0000000000000000000000000000000000000000..820181d87e2a04b81cd2e03aa7980d970cd6c1a6 --- /dev/null +++ b/20190107/objects-5.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", ((t_integer *) object[i])->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", ((t_string *) object[i])->content); + + return 0; +} diff --git a/20190107/objects-6.c b/20190107/objects-6.c new file mode 100644 index 0000000000000000000000000000000000000000..86847c9085083e2d5093026619550fb272b5f4ec --- /dev/null +++ b/20190107/objects-6.c @@ -0,0 +1,39 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +void print_object (t_base *this) +{ + if (this->type == 1) + printf ("Integer: %d\n", ((t_integer *) this)->content); + else if (this->type == 2) + printf ("String: \"%s\"\n", ((t_string *) this)->content); +} + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + print_object (object[i]); + + return 0; +} diff --git a/20190107/pgscript.sty b/20190107/pgscript.sty new file mode 120000 index 0000000000000000000000000000000000000000..95c888478c99ea7fda0fd11ccf669ae91be7178b --- /dev/null +++ b/20190107/pgscript.sty @@ -0,0 +1 @@ +../common/pgscript.sty \ No newline at end of file diff --git a/20190107/pgslides.sty b/20190107/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64 --- /dev/null +++ b/20190107/pgslides.sty @@ -0,0 +1 @@ +../common/pgslides.sty \ No newline at end of file diff --git a/20190107/qsort-1.c b/20190107/qsort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..c5431b853862e62812016f4fd3a031eeb0b5c9df --- /dev/null +++ b/20190107/qsort-1.c @@ -0,0 +1,70 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20190107/qsort-2.c b/20190107/qsort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..cfdc2ec11a92a4292c9443e01453cce818e9e73a --- /dev/null +++ b/20190107/qsort-2.c @@ -0,0 +1,72 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } + if (l < right) + quicksort (name, l, right); +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20190107/qsort-3.c b/20190107/qsort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..e6b7d9909473af6d8c13d3745dc6b07e8ea75699 --- /dev/null +++ b/20190107/qsort-3.c @@ -0,0 +1,74 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } + if (r > left) + quicksort (name, left, r); + if (l < right) + quicksort (name, l, right); +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20190107/sort-0.c b/20190107/sort-0.c new file mode 100644 index 0000000000000000000000000000000000000000..70e0e717cbfd42a27bf90f419c216fa18b0783c7 --- /dev/null +++ b/20190107/sort-0.c @@ -0,0 +1,16 @@ +#include <stdio.h> + +int find_first (char **name) +{ + return 2; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + printf ("%s\n", name[first]); + return 0; +} diff --git a/20190107/sort-1.c b/20190107/sort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..3f009d45657f84e462db48a67fa22821819216ad --- /dev/null +++ b/20190107/sort-1.c @@ -0,0 +1,21 @@ +#include <stdio.h> +#include <string.h> + +int find_first (char **name) +{ + int first = 0; + for (int i = 1; name[i]; i++) + if (strcmp (name[i], name[first]) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + printf ("%s\n", name[first]); + return 0; +} diff --git a/20190107/sort-2.c b/20190107/sort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..638e6e2caa670ceace0a854d0827292dfcb59ca5 --- /dev/null +++ b/20190107/sort-2.c @@ -0,0 +1,46 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name) +{ + int first = 0; + for (int i = 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + display (name, first, -1); + return 0; +} diff --git a/20190107/sort-3.c b/20190107/sort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..430a6fc0e95fcb9bc225e3572566c8d187016130 --- /dev/null +++ b/20190107/sort-3.c @@ -0,0 +1,46 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name, 0); + display (name, first, -1); + return 0; +} diff --git a/20190107/sort-4.c b/20190107/sort-4.c new file mode 100644 index 0000000000000000000000000000000000000000..19d4f416a2d30c5181ad289fe1d0dcba91ee81cf --- /dev/null +++ b/20190107/sort-4.c @@ -0,0 +1,59 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/sort-5.c b/20190107/sort-5.c new file mode 100644 index 0000000000000000000000000000000000000000..f0742bc8665d0b13edf4ad4ad3fe4790c1e6b929 --- /dev/null +++ b/20190107/sort-5.c @@ -0,0 +1,60 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { + #include "names.h" + NULL + }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/sort-6.c b/20190107/sort-6.c new file mode 100644 index 0000000000000000000000000000000000000000..94a1a16abfacda7bb728f8d3317cd00b4cf8ccde --- /dev/null +++ b/20190107/sort-6.c @@ -0,0 +1,60 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; +// display (name, left, right); +// usleep (200); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { + #include "names.h" + NULL + }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20190107/sort-7.c b/20190107/sort-7.c new file mode 100644 index 0000000000000000000000000000000000000000..46132dd247a061dda0e5ebade9c5b818a1a74fcb --- /dev/null +++ b/20190107/sort-7.c @@ -0,0 +1,53 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = sorted; + for (int i = sorted + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +}