Vorbereitung 26.10.2023

20231019/hp-20231019.tex

@@ -1152,6 +1152,8 @@
 
 \end{frame}
 
+\iffalse
+
 \begin{frame}[fragile]
 
   \showsubsection
@@ -1304,4 +1306,6 @@
 
 \end{frame}
 
+\fi
+
 \end{document}

20231026/aufgabe-1.c

+#include <stdio.h>
+
+void f (int *s0, int *s1)
+{
+  while (*s0 >= 0)
+  {
+    int *s = s1;
+    while (*s >= 0)
+      if (*s0 == *s++)
+        printf ("%d ", *s0);
+    s0++;
+  }
+  printf ("\n");
+}
+
+int main (void)
+{
+  int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
+  int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
+  f (a, b);
+  return 0;
+}

20231026/aufgabe-1c.c

+#include <stdio.h>
+
+void f (int *s0, int *s1)
+{
+  while (*s0 >= 0)
+  {
+    int *s = s1;
+    while (*s >= 0)
+      if (*s0 == *s++)
+        printf ("%d ", *s0);
+    s0++;
+  }
+  printf ("\n");
+}
+
+int main (void)
+{
+  int a[] = { 10, 4, 3, 7, 12, 0, 1 };
+  int b[] = { 7, 14, 0, 8, 9, 22, 10 };
+  f (a, b);
+  return 0;
+}

20231026/aufgabe-3.c

+#include <stdio.h>
+
+int main (void)
+{
+  int n, i, divisors;
+  for (n = 0; n < 100; n++)
+    divisors = 0;
+    for (i = 0; i < n; i++)
+      if (n % i == 0)
+        divisors++;
+    if (divisors = 2)
+      printf ("%d ist eine Primzahl.\n", n);
+  return 0;
+}

20231026/gtk-01.c

+#include <gtk/gtk.h>
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/gtk-02.c

+#include <gtk/gtk.h>
+
+static void hello (GtkWidget *this, gpointer user_data)
+{
+  char *world = user_data;
+  printf ("Hello, %s!\n", world);
+}
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  GtkWidget *button = gtk_button_new_with_label ("Hello, world!");
+  g_signal_connect (button, "clicked", G_CALLBACK (hello), "world");
+  gtk_window_set_child (GTK_WINDOW (window), button);
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/gtk-03.c

+#include <gtk/gtk.h>
+
+static void close_window (GtkWidget *this, gpointer user_data)
+{
+  GtkWindow *window = user_data;
+  gtk_window_destroy (window);
+}
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect (button, "clicked", G_CALLBACK (close_window), window);
+  gtk_window_set_child (GTK_WINDOW (window), button);
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/gtk-04.c

+#include <gtk/gtk.h>
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+  GtkWidget *button = gtk_button_new_with_label ("Quit");
+  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+  gtk_window_set_child (GTK_WINDOW (window), button);
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/gtk-05.c

+#include <gtk/gtk.h>
+
+static void hello (GtkWidget *this, gpointer user_data)
+{
+  char *world = user_data;
+  printf ("Hello, %s!\n", world);
+}
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_window_set_child (GTK_WINDOW (window), vbox);
+
+  GtkWidget *hello_button = gtk_button_new_with_label ("Hello, world!");
+  g_signal_connect (hello_button, "clicked", G_CALLBACK (hello), "world");
+  gtk_box_append (GTK_BOX (vbox), hello_button);
+
+  GtkWidget *quit_button = gtk_button_new_with_label ("Quit");
+  g_signal_connect_swapped (quit_button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+  gtk_box_append (GTK_BOX (vbox), quit_button);
+
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/gtk-06.c

+#include <gtk/gtk.h>
+
+static void draw (GtkDrawingArea *drawing_area, cairo_t *c,
+                  int width, int height, gpointer user_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);
+}
+
+static void activate (GtkApplication *app, gpointer user_data)
+{
+  GtkWidget *window = gtk_application_window_new (app);
+  gtk_window_set_title (GTK_WINDOW (window), "Hello");
+
+  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+  gtk_window_set_child (GTK_WINDOW (window), vbox);
+
+  GtkWidget *drawing_area = gtk_drawing_area_new ();
+  gtk_widget_set_size_request (drawing_area, 100, 100);
+  gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (drawing_area), draw, NULL, NULL);
+  gtk_box_append (GTK_BOX (vbox), drawing_area);
+
+  GtkWidget *quit_button = gtk_button_new_with_label ("Quit");
+  g_signal_connect_swapped (quit_button, "clicked", G_CALLBACK (gtk_window_destroy), window);
+  gtk_box_append (GTK_BOX (vbox), quit_button);
+
+  gtk_window_present (GTK_WINDOW (window));
+}
+
+int main (int argc, char **argv)
+{
+  GtkApplication *app = gtk_application_new ("de.hs-bochum.cvh.hp.hello-gtk", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+  int status = g_application_run (G_APPLICATION (app), argc, argv);
+  g_object_unref (app);
+  return status;
+}

20231026/hexe.h

+eine kleine Hexe.

20231026/hp-musterloesung-20231026.tex

+% hp-musterloesung-20231026.pdf - Solutions to the Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023  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: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+\renewcommand{\breath}{\bigskip}
+
+\begin{document}
+
+  \section*{Hardwarenahe Programmierung\\
+            Musterlösung zu den Übungsaufgaben -- 26.\ Oktober 2023}
+
+  \exercise{Arrays mit Zahlen}
+
+  \begin{minipage}[t]{0.4\textwidth}
+    Wir betrachten das folgende Programm\\
+    (Datei: \gitfile{hp}{2023ws/20231026}{aufgabe-1.c}):
+    \begin{lstlisting}[gobble=6]
+      #include <stdio.h>
+
+      void f (int *s0, int *s1)
+      {
+        while (*s0 >= 0)
+        {
+          int *s = s1;
+          while (*s >= 0)
+            if (*s0 == *s++)
+              printf ("%d ", *s0);
+          s0++;
+        }
+        printf ("\n");
+      }
+
+      int main (void)
+      {
+        int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
+        int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
+        f (a, b);
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.55\textwidth}
+    \vspace*{-\bigskipamount}
+    \begin{enumerate}[\quad(a)]
+      \item
+        Was bewirkt die Funktion \lstinline{f},\\
+        und wie funktioniert sie?
+        \points{4}
+%      \item
+%        Von welcher Ordnung (Landau-Symbol) ist die Funktion?
+%        Begründen Sie Ihre Antwort.
+%
+%        Wir beziehen uns hierbei auf die Anzahl der Vergleiche
+%        in Abhängigkeit von der Länge der Eingabedaten \lstinline{s0} und \lstinline{s1}.
+%        Für die Rechnung dürfen Sie beide Längen mit $n$ gleichsetzen,
+%        obwohl sie normalerweise nicht gleich sind.
+%        \points{2}
+      \item
+        Was passiert, wenn Sie beim Aufruf der Funktion für einen der
+        Parameter den Wert \lstinline{NULL} übergeben?
+        Begründen Sie Ihre Antwort.
+        \points{2}
+      \item
+        Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
+        (\gitfile{hp}{2023ws/20231026}{aufgabe-1c.c})?
+        Begründen Sie Ihre Antwort.
+        \begin{lstlisting}[gobble=8]
+          int main (void)
+          {
+            int a[] = { 10, 4, 3, 7, 12, 0, 1 };
+            int b[] = { 7, 14, 0, 8, 9, 22, 10 };
+            f (a, b);
+            return 0;
+          }
+        \end{lstlisting}
+        \points{2}
+%      \item
+%        Beschreiben Sie -- in Worten und/oder als C-Quelltext --, wie
+%        sich die Funktion \lstinline{f} effizienter gestalten läßt,
+%        wenn man die ihr übergebenen Arrays \lstinline{s0} und
+%        \lstinline{s1} als sortiert voraussetzt.
+%        \points{5}
+%
+%        Hinweis: Wie würden Sie als Mensch die Aufgabe erledigen?
+%      \item
+%        Von welcher
+%        Ordnung (Landau-Symbol) ist Ihre effizientere Version der Funktion und warum?
+%        \points{2}
+    \end{enumerate}
+  \end{minipage}
+
+  \solution
+
+  \begin{enumerate}[\quad(a)]
+    \item
+      \textbf{Was bewirkt die Funktion \lstinline{f}, und wie funktioniert sie?}
+
+      Die Funktion gibt alle Zahlen aus, die sowohl im Array \lstinline{s0}
+      als auch im Array \lstinline{s1} vorkommen (Schnittmenge).
+
+      Dies geschieht, indem der Zeiger \lstinline{s0} das gesamte Array durchläuft
+      (äußere Schleife).
+      Für jedes Element des ersten Arrays durchläuft der Zeiger \lstinline{s}
+      das gesamte zweite Array (innere Schleife).
+      Auf diese Weise wird jedes Element von \lstinline{s0}
+      mit jedem von \lstinline{s1} verglichen und bei Gleichheit ausgegeben.
+
+      Um die Schleifen abbrechen zu können, enthalten beide Arrays
+      als Ende-Markierung eine negative Zahl (\lstinline{-1}).
+
+    \item
+      \textbf{Was passiert, wenn Sie beim Aufruf der Funktion für einen der
+      Parameter den Wert \lstinline{NULL} übergeben?
+      Begründen Sie Ihre Antwort.}
+
+      In dem Moment, wo auf den jeweiligen Parameter-Zeiger zugegriffen wird
+      (\lstinline{while (*s0 >= 0)} für \lstinline{s0} bzw.\
+      \lstinline{int *s = s1; while (*s >= 0)} für \lstinline{s1}),
+      kommt es zu einem Absturz (Speicherzugriffsfehler).
+      Die Dereferenzierung eines Zeigers mit dem Wert \lstinline{NULL}
+      ist nicht zulässig.
+
+    \item
+      \textbf{Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
+      (\gitfile{hp}{2023ws/20231026}{aufgabe-1c.c})?
+      Begründen Sie Ihre Antwort.}
+
+      \begin{minipage}{0.35\textwidth}
+        \begin{lstlisting}[gobble=10]
+          int main (void)
+          {
+            int a[] = { 10, 4, 3, 7, 12, 0, 1 };
+            int b[] = { 7, 14, 0, 8, 9, 22, 10 };
+            f (a, b);
+            return 0;
+          }
+        \end{lstlisting}
+      \end{minipage}\hfill
+      \begin{minipage}{0.575\textwidth}
+        Durch die fehlenden Ende-Markierungen der Arrays
+        laufen die Schleifen immer weiter,
+        bis sie irgendwann zufällig auf Speicherzellen stoßen,
+        die sich als Ende-Markierungen interpretieren lassen (negative Zahlen).
+        Dadurch kann es zu einem Lesezugriff auf Speicher kommen,
+        für den das Programm kein Lesezugriffsrecht hat,
+        also zu einem Absturz (Speicherzugriffsfehler).
+      \end{minipage}
+  \end{enumerate}
+
+  \exercise{Datum-Bibliothek}
+
+  Schreiben Sie eine Bibliothek (\file{.c}-Datei und \file{.h}-Datei)
+  zur Behandlung von Datumsangaben.
+
+  Diese soll enthalten:
+  \begin{itemize}
+    \item
+      einen \lstinline{struct}-Datentyp \lstinline{date},
+      der eine Datumsangabe speichert,
+    \item
+      eine Funktion \lstinline{void date_print (date *d)}, die ein Datum ausgibt,
+    \item
+      eine Funktion \lstinline{int date_set (date *d, int day, int month, int year)},
+      die ein Datum auf einen gegebenen Tag setzt
+      und zurückgibt, ob es sich um ein gültiges Datum handelt (0 = nein, 1 = ja),
+    \item
+      eine Funktion \lstinline{void date_next (date *d)},
+      die ein Datum auf den nächsten Tag vorrückt.
+  \end{itemize}
+
+  Schreiben Sie auch ein Programm, das die o.\,a.\ Funktionen testet.
+
+  \solution
+
+  Die Dateien \gitfile{hp}{2023ws/20231026}{loesung-2.c},
+  \gitfile{hp}{2023ws/20231026}{loesung-2.h}
+  und \gitfile{hp}{2023ws/20231026}{loesung-2-test.c}
+  enthalten die Bibliothek und das Test-Programm.
+
+  Eine detaillierte Anleitung,
+  wie man auf die Funktion \lstinline{date_next()} kommt,
+  finden Sie im Skript zur Lehrveranstaltung,
+  Datei \gitfile{hp}{2023ws/script/hp-2023ws.pdf}{hp-2023ws.pdf},
+  ab Seite 29.
+
+  \exercise{Fehlerhaftes Primzahl-Programm}
+
+  \begin{minipage}[t]{5.5cm}
+    Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{2023ws/20231026}{aufgabe-3.c})
+    soll Zahlen ausgeben, die genau zwei Teiler haben, ist aber fehlerhaft.
+
+    \smallskip
+
+    Korrigieren Sie das Programm derart, daß ein Programm entsteht,
+    welches alle Primzahlen kleiner 100 ausgibt.% \points 5
+  \end{minipage}\hfill
+  \begin{minipage}[t]{9cm}
+     \vspace*{-0.5cm}
+    \begin{lstlisting}[gobble=6]
+      #include <stdio.h>
+
+      int main (void)
+      {
+        int n, i, divisors;
+        for (n = 0; n < 100; n++)
+          divisors = 0;
+          for (i = 0; i < n; i++)
+            if (n % i == 0)
+              divisors++;
+          if (divisors = 2)
+            printf ("%d ist eine Primzahl.\n", n);
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}
+
+  \solution
+
+  Beim Compilieren des Beispiel-Programms mit
+  \lstinline[style=cmd]{gcc -Wall} erhalten wir die folgende Warnung:
+  \begin{lstlisting}[style=terminal]
+    aufgabe-2.c:11:5: warning: suggest parentheses around assignment
+                      used as truth value [-Wparentheses]
+  \end{lstlisting}
+  Beim Ausführen gibt das Programm die folgende (falsche) Behauptung aus:
+  \begin{lstlisting}[style=terminal]
+    100 ist eine Primzahl.
+  \end{lstlisting}
+
+  Einen ersten Hinweis auf den Fehler im Programm liefert die Warnung.
+  Die Bedingung \lstinline{if (divisors = 2)} in Zeile 11
+  steht \emph{nicht\/} für einen Vergleich
+  der Variablen \lstinline{divisors} mit der Zahl 2,
+  sondern für eine Zuweisung der Zahl 2 an die Variable \lstinline{divisors}.
+  Neben dem \emph{Seiteneffekt\/} der Zuweisung gibt \lstinline{divisors = 2}
+  den Wert \lstinline{2} zurück.
+  Als Bedingung interpretiert, hat \lstinline{2} den Wahrheitswert "`wahr"' ("`true"');
+  die \lstinline{printf()}-Anweisung wird daher in jedem Fall ausgeführt.
+
+  Korrektur dieses Fehlers: \lstinline{if (divisors == 2)}
+  -- siehe die Datei \gitfile{hp}{2023ws/20231026}{loesung-2-1.c}.
+
+  \bigskip
+
+  Nach der Korrektur dieses Fehlers compiliert das Programm ohne Warnung,
+  gibt aber beim Ausführen die folgende Fehlermeldung aus:
+  \begin{lstlisting}[style=terminal]
+    Gleitkomma-Ausnahme
+  \end{lstlisting}
+  (Bemerkung: Bei ausgeschalteter Optimierung
+  -- \lstinline[style=cmd]{gcc} ohne \lstinline[style=cmd]{-O} --
+  kommt diese Fehlermeldung bereits beim ersten Versuch, das Programm auszuführen.
+  Der Grund für dieses Verhalten ist, daß bei eingeschalteter Optimierung
+  irrelevante Teile des Programms entfernt und gar nicht ausgeführt werden,
+  so daß der Fehler nicht zum Tragen kommt.
+  In diesem Fall wurde die Berechnung von \lstinline{divisors} komplett wegoptimiert,
+  da der Wert dieser Variablen nirgendwo abgefragt,
+  sondern durch die Zuweisung \lstinline{if (divisors = 2)}
+  sofort wieder überschrieben wurde.)
+
+  Die Fehlermeldung "`\lstinline[style=terminal]{Gleitkomma-Ausnahme}"'
+  ist insofern irreführend, als daß hier gar keine Gleitkommazahlen im Spiel sind;
+  andererseits deutet sie auf einen Rechenfehler hin, was auch tatsächlich zutrifft.
+  Durch Untersuchen aller Rechenoperationen
+  -- z.\,B.\ durch das Einfügen zusätzlicher \lstinline{printf()} --
+  finden wir den Fehler in Zeile 9:
+  Die Modulo-Operation \lstinline{n % i} ist eine Division,
+  die dann fehlschlägt, wenn der Divisor \lstinline{i} den Wert 0 hat.
+  Die Fehlerursache ist die bei 0 beginnende \lstinline{for}-Schleife in Zeile 8:
+  \lstinline{for (i = 0; i < n; i++)}.
+
+  Korrektur dieses Fehlers: Beginn der Schleife mit \lstinline{i = 1}
+  statt \lstinline{i = 0} -- siehe die Datei \gitfile{hp}{2023ws/20231026}{loesung-2-2.c}.
+
+  \bigskip
+
+  Nach der Korrektur dieses Fehlers gibt das Programm überhaupt nichts mehr aus.
+
+  Durch Untersuchen des Verhaltens des Programms
+  -- z.\,B.\ durch das Einfügen zusätzlicher \lstinline{printf()} --
+  stellen wir fest, daß die Zeilen 8 bis 12 des Programms nur einmal ausgeführt werden
+  und nicht, wie die \lstinline{for}-Schleife in Zeile 6 vermuten ließe, 100mal.
+  Der Grund dafür ist, daß sich die \lstinline{for}-Schleife
+  nur auf die unmittelbar folgende Anweisung \lstinline{divisors = 0} bezieht.
+  Nur diese Zuweisung wird 100mal ausgeführt;
+  alles andere befindet sich außerhalb der \lstinline{for}-Schleife.
+  (Die Einrückung hat in C keine inhaltliche Bedeutung,
+  sondern dient nur zur Verdeutlichung der Struktur des Programms.
+  In diesem Fall entsprach die tatsächliche Struktur nicht der beabsichtigten.)
+
+  Korrektur dieses Fehlers:
+  geschweifte Klammern um den Inhalt der äußeren \lstinline{for}-Schleife
+  -- siehe die Datei \gitfile{hp}{2023ws/20231026}{loesung-2-3.c}.
+
+  \bigskip
+
+  Nach der Korrektur dieses Fehlers gibt das Programm folgendes aus:
+  \begin{lstlisting}[style=terminal]
+    4 ist eine Primzahl.
+    9 ist eine Primzahl.
+    25 ist eine Primzahl.
+    49 ist eine Primzahl.
+  \end{lstlisting}
+  Diese Zahlen sind keine Primzahlen (mit zwei Teilern),
+  sondern sie haben drei Teiler.
+  Demnach findet das Programm einen Teiler zu wenig.
+  (Um diesen Fehler zu finden, kann man sich zu jeder Zahl
+  die gefundene Anzahl der Teiler \lstinline{divisors} ausgeben lassen.)
+
+  Der nicht gefundene Teiler ist jeweils die Zahl selbst.
+  Dies kommt daher, daß die Schleife
+  \lstinline{for (i = 1; i < n; i++)} nur bis \lstinline{n - 1} geht,
+  also keine Division durch \lstinline{n} stattfindet.
+
+  Korrektur dieses Fehlers: Schleifenbedingung \lstinline{i <= n}
+  statt \lstinline{i < n}
+  -- siehe die Datei \gitfile{hp}{2023ws/20231026}{loesung-2-4.c}.
+
+  \bigskip
+
+  Nach der Korrektur dieses Fehlers verhält sich das Programm korrekt.
+
+  Die Datei \gitfile{hp}{2023ws/20231026}{loesung-2-4.c} enthält somit das korrigierte Programm.
+
+\end{document}

20231026/hp-uebung-20231026.tex

+% hp-uebung-20231026.pdf - Exercises on Low-Level Programming / Applied Computer Sciences
+% Copyright (C) 2013, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023  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: Arrays mit Zahlen, Datum-Bibliothek, fehlerhaftes Primzahl-Programm
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+  \thispagestyle{empty}
+
+  \section*{Hardwarenahe Programmierung\\
+            Übungsaufgaben -- 26.\ Oktober 2023}
+
+  Diese Übung enthält Punkteangaben wie in einer Klausur.
+  Um zu "`bestehen"', müssen Sie innerhalb von 60 Minuten
+  unter Verwendung ausschließlich zugelassener Hilfsmittel
+  10 Punkte (von insgesamt \totalpoints) erreichen.
+
+  \exercise{Arrays mit Zahlen}
+
+  \begin{minipage}[t]{0.4\textwidth}
+    Wir betrachten das folgende Programm\\
+    (Datei: \gitfile{hp}{2023ws/20231026}{aufgabe-1.c}):
+    \begin{lstlisting}[gobble=6]
+      #include <stdio.h>
+
+      void f (int *s0, int *s1)
+      {
+        while (*s0 >= 0)
+        {
+          int *s = s1;
+          while (*s >= 0)
+            if (*s0 == *s++)
+              printf ("%d ", *s0);
+          s0++;
+        }
+        printf ("\n");
+      }
+
+      int main (void)
+      {
+        int a[] = { 10, 4, 3, 7, 12, 0, 1, -1 };
+        int b[] = { 7, 14, 0, 8, 9, 22, 10, -1 };
+        f (a, b);
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{0.55\textwidth}
+    \vspace*{-\bigskipamount}
+    \begin{enumerate}[\quad(a)]
+      \item
+        Was bewirkt die Funktion \lstinline{f},\\
+        und wie funktioniert sie?
+        \points{4}
+%      \item
+%        Von welcher Ordnung (Landau-Symbol) ist die Funktion?
+%        Begründen Sie Ihre Antwort.
+%
+%        Wir beziehen uns hierbei auf die Anzahl der Vergleiche
+%        in Abhängigkeit von der Länge der Eingabedaten \lstinline{s0} und \lstinline{s1}.
+%        Für die Rechnung dürfen Sie beide Längen mit $n$ gleichsetzen,
+%        obwohl sie normalerweise nicht gleich sind.
+%        \points{2}
+      \item
+        Was passiert, wenn Sie beim Aufruf der Funktion für einen der
+        Parameter den Wert \lstinline{NULL} übergeben?
+        Begründen Sie Ihre Antwort.
+        \points{2}
+      \item
+        Was kann passieren, wenn Sie das Hauptprogramm wie folgt abändern
+        (\gitfile{hp}{2023ws/20231026}{aufgabe-1c.c})?
+        Begründen Sie Ihre Antwort.
+        \begin{lstlisting}[gobble=8]
+          int main (void)
+          {
+            int a[] = { 10, 4, 3, 7, 12, 0, 1 };
+            int b[] = { 7, 14, 0, 8, 9, 22, 10 };
+            f (a, b);
+            return 0;
+          }
+        \end{lstlisting}
+        \points{2}
+%      \item
+%        Beschreiben Sie -- in Worten und/oder als C-Quelltext --, wie
+%        sich die Funktion \lstinline{f} effizienter gestalten läßt,
+%        wenn man die ihr übergebenen Arrays \lstinline{s0} und
+%        \lstinline{s1} als sortiert voraussetzt.
+%        \points{5}
+%
+%        Hinweis: Wie würden Sie als Mensch die Aufgabe erledigen?
+%      \item
+%        Von welcher
+%        Ordnung (Landau-Symbol) ist Ihre effizientere Version der Funktion und warum?
+%        \points{2}
+    \end{enumerate}
+  \end{minipage}
+
+  \exercise{Datum-Bibliothek}
+
+  Schreiben Sie eine Bibliothek (\file{.c}-Datei und \file{.h}-Datei)
+  zur Behandlung von Datumsangaben.
+
+  Diese soll enthalten:
+  \begin{itemize}
+    \item
+      einen \lstinline{struct}-Datentyp \lstinline{date},
+      der eine Datumsangabe speichert,
+    \item
+      eine Funktion \lstinline{void date_print (date *d)}, die ein Datum ausgibt,
+    \item
+      eine Funktion \lstinline{int date_set (date *d, int day, int month, int year)},
+      die ein Datum auf einen gegebenen Tag setzt
+      und zurückgibt, ob es sich um ein gültiges Datum handelt (0 = nein, 1 = ja),
+    \item
+      eine Funktion \lstinline{void date_next (date *d)},
+      die ein Datum auf den nächsten Tag vorrückt.
+  \end{itemize}
+
+  Schreiben Sie auch ein Programm, das die o.\,a.\ Funktionen testet.
+
+  \points{8}
+
+  \exercise{Fehlerhaftes Primzahl-Programm}
+
+  \begin{minipage}[t]{5.5cm}
+    Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{2023ws/20231026}{aufgabe-3.c})
+    soll Zahlen ausgeben, die genau zwei Teiler haben, ist aber fehlerhaft.
+
+    \smallskip
+
+    Korrigieren Sie das Programm derart, daß ein Programm entsteht,
+    welches alle Primzahlen kleiner 100 ausgibt. \points 5
+  \end{minipage}\hfill
+  \begin{minipage}[t]{9cm}
+     \vspace*{-0.5cm}
+    \begin{lstlisting}[gobble=6]
+      #include <stdio.h>
+
+      int main (void)
+      {
+        int n, i, divisors;
+        for (n = 0; n < 100; n++)
+          divisors = 0;
+          for (i = 0; i < n; i++)
+            if (n % i == 0)
+              divisors++;
+          if (divisors = 2)
+            printf ("%d ist eine Primzahl.\n", n);
+        return 0;
+      }
+    \end{lstlisting}
+  \end{minipage}
+
+  \makeatletter
+    \immediate\write\@mainaux{\string\gdef\string\totalpoints{\arabic{points}}}
+  \makeatother
+
+\end{document}

20231026/loesung-2-test.c

+#include <stdio.h>
+#include "loesung-2.h"
+
+void check (char day, char month, int year)
+{
+  date d;
+  if (date_set (&d, day, month, year))
+    {
+      date_print (&d);
+      printf (" --> ");
+      date_next (&d);
+      date_print (&d);
+      printf ("\n");
+    }
+  else
+    printf ("%02d.%02d.%04d: invalid date\n", day, month, year);
+}
+
+int main (void)
+{
+  check (6, 11, 2018);
+  check (29, 11, 2018);
+  check (30, 11, 2018);
+  check (31, 11, 2018);
+  check (29, 12, 2018);
+  check (30, 12, 2018);
+  check (31, 12, 2018);
+  check (28, 2, 2016);
+  check (29, 2, 2016);
+  check (30, 2, 2016);
+  check (28, 2, 2015);
+  check (29, 2, 2015);
+  check (30, 2, 2015);
+  check (31, 12, 2008);
+  check (28, 2, 2000);
+  check (29, 2, 2000);
+  check (30, 2, 2000);
+  check (28, 2, 1900);
+  check (29, 2, 1900);
+  check (30, 2, 1900);
+  return 0;
+}