20191017/if-3.c

-#include <stdio.h>
-
-int main (void)
-{
-  int b = 12;
-  if (b)
-    printf ("100 / b = %d\n", 100 / b);
-    printf ("100 % b = %d\n", 100 % b);
-  return 0;
-}

20191017/if-8.c

-#include <stdio.h>
-
-int main (void)
-{
-  int a = 7;
-  if (a = 0)
-    printf ("Bitte nicht durch 0 teilen!\n");
-  else
-    printf ("100 / a = %d\n", 100 / a);
-  return 0;
-}

20191017/if-9.c

-#include <stdio.h>
-
-int main (void)
-{
-  int a = 7;
-  int b;
-  if ((b = a) == 0)
-    printf ("Bitte nicht durch 0 teilen!\n");
-  else
-    printf ("100 / a = %d\n", 100 / a);
-  return 0;
-}

20191017/while-1.c

-#include <stdio.h>
-
-int main (void) { while (0) printf ("Hello, world!\n"); return 0; }

20191017/while-5.c

-#include <stdio.h>
-
-int main (void) {
-    while (1) {
-        printf ("Hello, world!\n");
-    }
-  return 0;
-}

20191017/while-6.c

-#include <stdio.h>
-
-int
-main (void)
-{
-  while (1)
-    {
-      printf ("Hello, world!\n");
-    }
-  return 0;
-}

20191024/aufgabe-2.c

-  year = ORIGINYEAR;  /* = 1980 */
-
-  while (days > 365)
-    {
-      if (IsLeapYear (year))
-        {
-          if (days > 366)
-            {
-              days -= 366;
-              year += 1;
-            }
-        }
-      else
-        {
-          days -= 365;
-          year += 1;
-        }
-    }

20191024/test-5.c

-#include <stdio.h>
-
-int main (void)
-{
-  printf ("Die Antwort lautet: %x.\n", 'B');
-  return 0;
-}

20191031/chars-1.c

-#include <stdio.h>
-
-int main (void)
-{
-  printf ("%c\n", 117);
-  return 0;
-}

20191031/files-2.c

-#include <stdio.h>
-
-int main (void)
-{
-  FILE *f = fopen ("bla/fhello.txt", "w");
-  fprintf (f, "Hello, world!\n");
-  fclose (f);
-  return 0;
-}

20191031/files-3.c

-#include <stdio.h>
-
-int main (void)
-{
-  FILE *f = fopen ("c:\\windows\\system\\kern64.dll", "w");
-  fprintf (f, "Hello, world!\n");
-  fclose (f);
-  return 0;
-}

20191031/hp-musterloesung-20191031.tex

-% hp-musterloesung-20191024.pdf - Solutions to the Exercises on Low-Level Programming
-% 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: Strings, Programm analysieren, fehlerhaftes Primzahl-Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\begin{document}
-
-  \section*{Hardwarenahe Programmierung\\
-            Musterlösung zu den Übungsaufgaben -- 31.\ Oktober 2019}
-
-  \exercise{Strings}
-
-  Strings werden in der Programmiersprache C
-  durch Zeiger auf \lstinline{char}-Variable realisiert.
-
-  Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{20191031}{aufgabe-1.c}):
-  \begin{center}
-    \begin{minipage}{8cm}
-      \begin{lstlisting}[gobble=8]
-        int fun_1 (char *s1, char *s2)
-        {
-          int result = 1;
-          for (int i = 0; s1[i] && s2[i]; i++)
-            if (s1[i] != s2[i])
-              result = 0;
-          return result;
-        }
-      \end{lstlisting}
-    \end{minipage}%
-  \end{center}
-  \begin{itemize}
-    \item[(a)]
-      Was bewirkt die Funktion? % \points{3}
-    \item[(b)]
-      Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife? % \points{2}
-    \item[(c)]
-      Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife\\
-      zu "`\lstinline{s1[i]}"' verkürzt würde? % \points{3}
-%    \item[(d)]
-%      Von welcher Ordnung (Landau-Symbol) ist die Funktion \lstinline{fun_1()}
-%      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen in den Strings
-%      -- und warum? % \points{2}
-    \item[(d)]
-      Schreiben Sie eine eigene Funktion,
-      die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.
-%      und geben Sie die Ordnung (Landau-Symbol) der von Ihnen geschriebenen Funktion an. % \points{5}
-  \end{itemize}
-
-  \solution
-
-  \begin{itemize}
-    \item[(a)]
-      \textbf{Was bewirkt die Funktion?}
-
-      Sie vergleicht zwei Strings miteinander bis zur Länge des kürzeren Strings
-      und gibt bei Gleichheit 1 zurück, ansonsten 0.
-
-      Mit anderen Worten:
-      Die Funktion prüft, ob zwei Strings bis zur Länge des kürzeren übereinstimmen,
-      und gibt bei Gleichheit 1 zurück, ansonsten 0.
-
-      Die Funktion prüft insbesondere \textbf{nicht} zwei Strings auf Gleichheit,
-      und sie ist \textbf{nicht} funktionsgleich zur
-      Standard-Bibliotheksfunktion \lstinline{strcmp()}.
-
-    \item[(b)]
-      \textbf{Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife?}
-
-      Die Bedingung prüft, ob \emph{bei einem der beiden Strings\/}
-      die Ende-Markierung (Null-Symbol) erreicht ist.
-      Falls ja, wird die Schleife beendet.
-
-    \item[(c)]
-      \textbf{Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife\\
-      zu "`\lstinline{s1[i]}"' verkürzt würde?}
-
-      In diesem Fall würde nur für \lstinline{s1} geprüft,
-      ob das Ende erreicht ist.
-      Wenn \lstinline{s1} länger ist als \lstinline{s2},
-      würde \lstinline{s2} über sein Ende hinaus ausgelesen.
-      Dies kann zu Lesezugriffen auf Speicher außerhalb des Programms
-      und damit zu einem Absturz führen
-      ("`Speicherzugriffsfehler"', "`Schutzverletzung"').
-
-    \item[(d)]
-      \textbf{Schreiben Sie eine eigene Funktion,
-      die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.}
-
-      Die Effizienz läßt sich steigern, indem man die Schleife abbricht,
-      sobald das Ergebnis feststeht.
-      Es folgen drei Möglichkeiten, dies zu realisieren.
-  \end{itemize}
-
-  \begin{center}
-    \begin{minipage}[t]{8cm}
-      Erweiterung der Schleifenbedingung:
-
-      \begin{lstlisting}[gobble=8]
-        int fun_2 (char *s1, char *s2)
-        {
-          int result = 1;
-          for (int i = 0; s1[i] && s2[i] && result; i++)
-            if (s1[i] != s2[i])
-              result = 0;
-          return result;
-        }
-      \end{lstlisting}
-    \end{minipage}%
-    \begin{minipage}[t]{6cm}
-      Verwendung von \lstinline{return}:
-
-      \begin{lstlisting}[gobble=8]
-        int fun_3 (char *s1, char *s2)
-        {
-          for (int i = 0; s1[i] && s2[i]; i++)
-            if (s1[i] != s2[i])
-              return 0;
-          return 1;
-        }
-      \end{lstlisting}
-    \end{minipage}
-  \end{center}
-  \vspace*{-1cm}\goodbreak
-
-  \begin{center}
-    \begin{minipage}{9cm}
-      Die nebenstehende Lösung unter Verwendung von \lstinline{break}
-      ist zwar ebenfalls richtig, aber länger und weniger übersichtlich
-      als die beiden anderen Lösungen.
-
-      \smallskip
-
-      Die Datei \gitfile{hp}{20191031}{loesung-1.c} enthält ein Testprogramm
-      für alle o.\,a.\ Lösungen.
-      Das Programm testet nur die offensichtlichsten Fälle;
-      für den Einsatz der Funktionen in einer Produktivumgebung
-      wären weitaus umfassendere Tests erforderlich.
-
-      \smallskip
-
-      Das Testprogramm enthält String-Zuweisungen wie z.\,B.\
-      \lstinline{s2 = "Apfel"}.
-      Dies funktioniert, weil wir damit einen Zeiger (\lstinline{char *s2})
-      auf einen neuen Speicherbereich (\lstinline{"Apfel"}) zeigen lassen.
-      Eine entsprechende Zuweisung zwischen Arrays
-      (\lstinline{char s3[] = "Birne"; s3 = "Pfirsich";)}
-      funktioniert \emph{nicht}.
-      
-    \end{minipage}\hspace*{1cm}%
-    \begin{minipage}{6cm}
-      \begin{lstlisting}[gobble=8]
-        int fun_4 (char *s1, char *s2)
-        {
-          int result = 1;
-          for (int i = 0; s1[i] && s2[i]; i++)
-            if (s1[i] != s2[i])
-              {
-                result = 0;
-                break;
-              }
-          return result;
-        }
-      \end{lstlisting}
-    \end{minipage}
-  \end{center}
-
-  \exercise{Programm analysieren}
-
-  Wir betrachten das folgende C-Programm (Datei: \gitfile{hp}{20191031}{aufgabe-2.c}):
-  \begin{lstlisting}
-    char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
-  \end{lstlisting}
-  \vspace{-\medskipamount}
-  \begin{itemize}
-    \item[(a)]
-      Was bewirkt dieses Programm?
-    \item[(b)]
-      Wofür stehen die Zahlen?
-    \item[(c)]
-      Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
-      \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
-      wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.
-  \end{itemize}
-
-  \solution
-
-  \begin{itemize}
-    \item[(a)]
-      \textbf{Was bewirkt dieses Programm?}
-
-      Es gibt \emph{seinen eigenen Quelltext\/} aus.
-
-      (Wichtig ist die Bezugnahme auf den eigenen Quelltext.
-      Die Angabe\\
-      "`Es gibt
-      \lstinline|char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}|
-      aus"'\\
-      genügt insbesondere nicht.)
-
-    \item[(b)]
-      \textbf{Wofür stehen die Zahlen?}
-
-      Die 34 steht für ein Anführungszeichen und die 10 für ein
-      Zeilenendezeichen (\lstinline{\n}).
-
-      Hintergrund: Um den eigenen Quelltext ausgeben zu können, muß
-      das Programm auch Anführungszeichen und Zeilenendezeichen
-      ausgeben. Dies geschieht normalerweise mit vorangestelltem
-      Backslash: \lstinline{\"} bzw.\ \lstinline{\n}. Um dann aber
-      den Backslash ausgeben zu können, müßte man diesem ebenfalls
-      einen Backslash voranstellen: \lstinline{\\}. Damit dies nicht
-      zu einer Endlosschleife wird, verwendet der Programmierer
-      dieses Programms den Trick mit den Zahlen, die durch
-      \lstinline{%c} als Zeichen ausgegeben werden.
-
-    \item[(c)]
-      \textbf{Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
-      \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
-      wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.}
-
-      Datei: \gitfile{hp}{20191031}{loesung-2.c}
-      \begin{lstlisting}[gobble=8]
-        char*f="char*f=%c%s%c;int main(void){printf(f,34,f,34,10);return 0;}%c";
-        int main(void){printf(f,34,f,34,10);return 0;}
-      \end{lstlisting}
-      Das Programm ist eine einzige, lange Zeile, die hier nur aus
-      Platzgründen als zwei Zeilen abgedruckt wird. Auf das
-      Semikolon am Ende der "`ersten Zeile"' folgt unmittelbar -- ohne Leerzeichen --
-      das Schlüsselwort \lstinline{int} am Anfang der "`zweiten Zeile"'.
-
-      Mit "`die in Aufgabenteil (a) festgestellte Eigenschaft"' ist
-      gemeint, daß das Programm weiterhin seinen eigenen Quelltext
-      ausgeben soll. Die Herausforderung dieser Aufgabe besteht
-      darin, das Programm zu modifizieren, ohne diese Eigenschaft zu
-      verlieren.
-
-      Zusatzaufgabe für Interessierte: Ergänzen Sie das Programm so,
-      daß es auch mit \lstinline[style=cmd]{-Wall} ohne Warnungen
-      compiliert werden kann.
-      
-      Hinweis dazu: \lstinline{#include<stdio.h>}
-      (ohne Leerzeichen, um Platz zu sparen)
-      
-      Lösung der Zusatzaufgabe: \gitfile{hp}{20191031}{loesung-2x.c}
-
-  \end{itemize}
-
-  \exercise{Fehlerhaftes Primzahl-Programm}
-
-  \begin{minipage}[t]{5.5cm}
-    Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{20191031}{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}{20191031}{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}{20191031}{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}{20191031}{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}{20191031}{loesung-2-4.c}.
-
-  \bigskip
-
-  Nach der Korrektur dieses Fehlers verhält sich das Programm korrekt.
-
-  Die Datei \gitfile{hp}{20191031}{loesung-2-4.c} enthält somit das korrigierte Programm.
-
-\end{document}

20191031/hp-uebung-20191031.tex

-% hp-uebung-20191031.pdf - Exercises on Low-Level Programming
-% 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: Strings, Programm analysieren, fehlerhaftes Primzahl-Programm
-
-\documentclass[a4paper]{article}
-
-\usepackage{pgscript}
-
-\thispagestyle{empty}
-
-\begin{document}
-
-  \thispagestyle{empty}
-
-  \section*{Hardwarenahe Programmierung\\
-            Übungsaufgaben -- 31.\ Oktober 2019}
-
-  \exercise{Strings}
-
-  Strings werden in der Programmiersprache C
-  durch Zeiger auf \lstinline{char}-Variable realisiert.
-
-  Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{20191031}{aufgabe-1.c}):
-  \begin{center}
-    \begin{minipage}{8cm}
-      \begin{lstlisting}[gobble=8]
-        int fun_1 (char *s1, char *s2)
-        {
-          int result = 1;
-          for (int i = 0; s1[i] && s2[i]; i++)
-            if (s1[i] != s2[i])
-              result = 0;
-          return result;
-        }
-      \end{lstlisting}
-    \end{minipage}%
-  \end{center}
-  \begin{itemize}
-    \item[(a)]
-      Was bewirkt die Funktion? % \points{3}
-    \item[(b)]
-      Welchen Sinn hat die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife? % \points{2}
-    \item[(c)]
-      Was würde sich ändern, wenn die Bedingung "`\lstinline{s1[i] && s2[i]}"'
-      in der \lstinline{for}-Schleife\\
-      zu "`\lstinline{s1[i]}"' verkürzt würde? % \points{3}
-%    \item[(d)]
-%      Von welcher Ordnung (Landau-Symbol) ist die Funktion \lstinline{fun_1()}
-%      hinsichtlich der Anzahl ihrer Zugriffe auf die Zeichen in den Strings
-%      -- und warum? % \points{2}
-    \item[(d)]
-      Schreiben Sie eine eigene Funktion,
-      die dieselbe Aufgabe erledigt wie \lstinline{fun_1()}, nur effizienter.
-%      und geben Sie die Ordnung (Landau-Symbol) der von Ihnen geschriebenen Funktion an. % \points{5}
-  \end{itemize}
-
-  \exercise{Programm analysieren}
-
-  Wir betrachten das folgende C-Programm (Datei: \gitfile{hp}{20191031}{aufgabe-2.c}):
-  \begin{lstlisting}
-    char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
-  \end{lstlisting}
-  \vspace{-\medskipamount}
-  \begin{itemize}
-    \item[(a)]
-      Was bewirkt dieses Programm?
-    \item[(b)]
-      Wofür stehen die Zahlen?
-    \item[(c)]
-      Ergänzen Sie das Programm derart, daß seine \lstinline{main()}-Funktion
-      \lstinline{int main (void)} lautet und eine \lstinline{return}-Anweisung hat,
-      wobei die in Aufgabenteil (a) festgestellte Eigenschaft erhalten bleiben soll.
-  \end{itemize}
-
-  \exercise{Fehlerhaftes Primzahl-Programm}
-
-  \begin{minipage}[t]{5.5cm}
-    Das nebenstehende Primzahlsuchprogramm (Datei: \gitfile{hp}{20191031}{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}
-
-\end{document}

20191031/strings-10.c

-#include <stdio.h>
-
-int main (void)
-{
-  volatile char answer[] = {42, 137, 13, 117};
-  char *a = answer;
-  char hello[14] = "Hello, world!\n";
-  printf ("%s", hello);
-  a -= 4;
-  printf ("a: %d %d %d %d %d %d %d %d\n", a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
-  return 0;
-}