Tafelbilder und Beispiele 30.11.2023

20231130/hanoi-0.c

+#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;
+}

20231130/hanoi-1.c

+#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;
+}

20231130/hanoi-2.c

+#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;
+}

20231130/hanoi-3.c

+#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;
+}

20231130/hanoi-4.c

+#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;
+}

20231130/hanoi-5.c

+#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;
+}

20231130/hanoi-6.c

+#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;
+}

20231130/hanoi-7.c

+#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;
+}

20231130/hanoi-8.c

+#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;
+}

20231130/hanoi-9.c

+#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;
+}

20231130/hp-20231130.tex

@@ -20,7 +20,7 @@
 % Attribution-ShareAlike 3.0 Unported License along with this
 % document.  If not, see <http://creativecommons.org/licenses/>.
 
-% README: Algorithmen: Rekursion, Aufwandsabschätzungen
+% README: Algorithmen: Rekursion
 
 \documentclass[10pt,t]{beamer}
 
@@ -64,6 +64,7 @@
         \item[5.1] Differentialgleichungen
         \color{red}
         \item[5.2] Rekursion
+        \color{black}
         \item[5.3] Aufwandsabschätzungen
       \end{itemize}
     \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
@@ -442,6 +443,8 @@
 
 \end{frame}
 
+\iffalse
+
 \subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
 
 \begin{frame}[fragile]
@@ -592,4 +595,6 @@
 
 \end{frame}
 
+\fi
+
 \end{document}

20231130/landau-symbols-2.pdf

-../common/landau-symbols-2.pdf
\ No newline at end of file

20231130/landau-symbols-3.pdf

-../common/landau-symbols-3.pdf
\ No newline at end of file

20231130/landau-symbols.pdf

-../common/landau-symbols.pdf
\ No newline at end of file

20231130/pendulum-1.c

+#include <gtk/gtk.h>
+#include <math.h>
+
+#define WIDTH 320
+#define HEIGHT 240
+#define GAP (HEIGHT / 20)
+#define r GAP
+#define visual_length (HEIGHT - 2 * GAP - r)
+
+#define phi0 (-0.5)
+#define omega0 0.0
+#define t0 0.0
+#define g 9.81
+#define l 1.0
+#define dt 0.02
+
+double t = t0;
+double phi = phi0;
+double omega = omega0;
+
+gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
+{
+  GdkRGBA blue = { 0.0, 0.5, 1.0, 1.0 };
+
+  int x = WIDTH / 2 + visual_length * sin (phi);
+  int y = GAP + visual_length * cos (phi);
+
+  gdk_cairo_set_source_rgba (c, &blue);
+  cairo_move_to (c, WIDTH / 2, GAP);
+  cairo_line_to (c, x, y);
+  cairo_stroke (c);
+  cairo_arc (c, x, y, r, 0, 2 * G_PI);
+  cairo_fill (c);
+
+  return FALSE;  /* TRUE to stop other handlers from being invoked for the event.
+                    FALSE to propagate the event further. */
+}
+
+gboolean timer (GtkWidget *widget)
+{
+  t += dt;
+  phi += omega * dt;
+  omega += - dt * g / l * sin (phi);
+
+  gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
+  g_timeout_add (50, (GSourceFunc) timer, widget);
+  return FALSE;
+}
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_show (window);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_widget_show (drawing_area);
+  gtk_container_add (GTK_CONTAINER (window), drawing_area);
+  gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
+  g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
+
+  g_timeout_add (50, (GSourceFunc) timer, drawing_area);
+
+  gtk_main ();
+  return 0;
+}

20231130/pendulum-2.c

+#include <gtk/gtk.h>
+#include <math.h>
+
+#define WIDTH 320
+#define HEIGHT 240
+#define GAP (HEIGHT / 20)
+#define r GAP
+#define visual_length (HEIGHT - 2 * GAP - r)
+
+#define phi0 (-0.5)
+#define omega0 0.0
+#define t0 0.0
+#define g 9.81
+#define l 1.0
+#define dt 0.02
+
+double t = t0;
+double phi = phi0;
+double omega= omega0;
+
+void draw_pendulum (cairo_t *c, double phi, GdkRGBA *colour)
+{
+  int x = WIDTH / 2 + visual_length * sin (phi);
+  int y = GAP + visual_length * cos (phi);
+
+  gdk_cairo_set_source_rgba (c, colour);
+  cairo_move_to (c, WIDTH / 2, GAP);
+  cairo_line_to (c, x, y);
+  cairo_stroke (c);
+  cairo_arc (c, x, y, r, 0, 2 * G_PI);
+  cairo_fill (c);
+}
+
+gboolean draw (GtkWidget *widget, cairo_t *c, gpointer data)
+{
+  GdkRGBA blue   = { 0.0, 0.5, 1.0, 1.0 };
+  GdkRGBA green  = { 0.0, 0.5, 0.0, 1.0 };
+
+  double A = phi0;
+  double B = 0.5 * M_PI;  /* 90° */
+  double phi_analytic = A * sin (sqrt (g / l) * t + B);
+
+  draw_pendulum (c, phi, &blue);
+  draw_pendulum (c, phi_analytic, &green);
+
+  return FALSE;
+}
+
+gboolean timer (GtkWidget *widget)
+{
+  t += dt;
+  phi += omega * dt;
+  omega += - dt * g / l * sin (phi);
+
+  gtk_widget_queue_draw_area (widget, 0, 0, WIDTH, HEIGHT);
+  g_timeout_add (50, (GSourceFunc) timer, widget);
+  return FALSE;
+}
+
+int main (int argc, char **argv)
+{
+  gtk_init (&argc, &argv);
+
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_show (window);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_widget_show (drawing_area);
+  gtk_container_add (GTK_CONTAINER (window), drawing_area);
+  gtk_widget_set_size_request (drawing_area, WIDTH, HEIGHT);
+  g_signal_connect (drawing_area, "draw", G_CALLBACK (draw), NULL);
+
+  g_timeout_add (50, (GSourceFunc) timer, drawing_area);
+
+  gtk_main ();
+  return 0;
+}