diff --git a/20231012/hp-20231012.pdf b/20231012/hp-20231012.pdf
index 93c71c869abba34501199b479e959a4dc9e50d04..3768ad212987328dc63a94ef85608178b7c23e60 100644
Binary files a/20231012/hp-20231012.pdf and b/20231012/hp-20231012.pdf differ
diff --git a/20231012/hp-20231012.tex b/20231012/hp-20231012.tex
index ed26b56d5b6efb14dc4617d4f6ade27732c3e318..7d9bb7f5f71a523b30999fb68fde94866550291a 100644
--- a/20231012/hp-20231012.tex
+++ b/20231012/hp-20231012.tex
@@ -1340,6 +1340,8 @@
\end{minipage}
\end{frame}
+\iffalse
+
% \begin{frame}[fragile]
% \showsubsection
%
@@ -1559,6 +1561,8 @@
\end{itemize}
\end{frame}
+\fi
+
\nosectionnonumber{\inserttitle}
\begin{frame}
@@ -1581,6 +1585,7 @@
\item[2.8] Seiteneffekte
\item[2.9] Funktionen
\item[2.10] Zeiger
+ \color{orange}
\item[2.11] Arrays und Strings
\color{red}
\item[2.12] Strukturen
diff --git a/20231019/aufgabe-3.c b/20231019/aufgabe-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad9d80416bad5c7c0edf9c9d4f175146c92a2755
--- /dev/null
+++ b/20231019/aufgabe-3.c
@@ -0,0 +1,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;
+}
diff --git a/20231019/aufgabe-4.c b/20231019/aufgabe-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc58b6e8ee4a7a023654aa0eb3a9715a5b9f75cf
--- /dev/null
+++ b/20231019/aufgabe-4.c
@@ -0,0 +1 @@
+char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}
diff --git a/20231019/gitlab.png b/20231019/gitlab.png
new file mode 100644
index 0000000000000000000000000000000000000000..5724da8b8338534857e5e845f1f1a9b67f0fab1a
Binary files /dev/null and b/20231019/gitlab.png differ
diff --git a/20231019/hp-20231019.pdf b/20231019/hp-20231019.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..37ccf57ed6f0d63235ac4d4beae3a835c71f7993
Binary files /dev/null and b/20231019/hp-20231019.pdf differ
diff --git a/20231019/hp-20231019.tex b/20231019/hp-20231019.tex
new file mode 100644
index 0000000000000000000000000000000000000000..266ebe9007677bb157c8f0dda3141dc016b42725
--- /dev/null
+++ b/20231019/hp-20231019.tex
@@ -0,0 +1,1307 @@
+% hp-20231019.pdf - Lecture Slides on Low-Level Programming
+% Copyright (C) 2012, 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: Einführung in C (ab 2.11: Arrays und Strings)
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{pdftricks}
+\usepackage{tikz}
+
+\begin{psinputs}
+ \usepackage[utf8]{inputenc}
+ \usepackage[german]{babel}
+ \usepackage[T1]{fontenc}
+ \usepackage{helvet}
+ \renewcommand*\familydefault{\sfdefault}
+ \usepackage{pstricks,pst-grad}
+\end{psinputs}
+
+\newcommand{\redurl}[1]{\href{#1}{\color{red}\nolinkurl{#1}}}
+
+\title{Hardwarenahe Programmierung}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{19.\ Oktober 2023}
+
+\begin{document}
+
+\maketitleframe
+
+%\date{\begin{picture}(0,0)
+% \color{red}
+% \put(0.65,1.05){\makebox(0,0)[t]{$\underbrace{\rule{1.45cm}{0pt}}_{%
+% \mbox{\emph{rerum naturalium\/} = der natürlichen Dinge (lat.)}}$}}
+% \put(1.65,-3){\makebox(0,0)[bl]{\redurl{https://www.peter.gerwinski.de/physik/}}}
+% \end{picture}%
+% 12.\ Oktober 2023}
+%
+%\maketitleframe
+
+\title{Hardwarenahe Programmierung}
+
+\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}}}
+ \item[\textbf{2}] \textbf{Einführung in C}
+ \begin{itemize}
+ \item[2.1] Hello, world!
+ \item[2.2] Programme compilieren und ausführen
+ \item[2.3] Elementare Aus- und Eingabe
+ \item[2.4] Elementares Rechnen
+ \item[2.5] Verzweigungen
+ \item[2.6] Schleifen
+ \color{medgreen}
+ \item[2.7] Strukturierte Programmierung
+ \item[2.8] Seiteneffekte
+ \item[2.9] Funktionen
+ \item[2.10] Zeiger
+ \color{orange}
+ \item[2.11] Arrays und Strings
+ \color{red}
+ \item[2.12] Strukturen
+ \item[\dots]
+ \end{itemize}
+ \color{gray}
+ \item[\textbf{3}] \textbf{Bibliotheken}
+ \vspace*{-\smallskipamount}
+ \item[\textbf{\dots}]
+% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+% \item[\textbf{5}] \textbf{Algorithmen}
+% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+ \end{itemize}
+
+\end{frame}
+
+\section{Einführung}
+\section{Einführung in C}
+\setcounter{subsection}{7}
+\subsection{Seiteneffekte}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ int main (void)
+ {
+ printf ("Hello, world!\n");
+ "Hello, world!\n";
+ return 0;
+ }
+ \end{lstlisting}
+ \pause
+ \begin{picture}(0,0)
+ \color{red}
+ \put(3.1,1.35){\tikz{\draw[-latex](0.0,0.0)--(-0.8,0);}}
+ \put(4.0,1.35){\makebox(0,0)[l]{Ausdruck als Anweisung: Wert wird ignoriert}}
+ \pause
+ \put(3.55,1.40){\tikz{\draw[-latex](0.0,0.0)--(-0.4,0.2);}}
+ \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int a = printf ("Hello, world!\n");
+ printf ("%d\n", a);
+ return 0;
+ }
+ \end{lstlisting}
+% \pause
+ \bigskip
+ \begin{lstlisting}[style=terminal]
+ $ ¡gcc -Wall -O side-effects-1.c -o side-effects-1¿
+ $ ¡./side-effects-1¿
+ Hello, world!
+ 14
+ $
+ \end{lstlisting}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int a = printf ("Hello, world!\n");
+ printf ("%d\n", a);
+ return 0;
+ }
+ \end{lstlisting}
+ \begin{itemize}
+ \item
+ \lstinline{printf()} ist eine Funktion.
+% \pause
+ \item
+ "`Haupteffekt"': Wert zurückliefern\\
+ (hier: Anzahl der ausgegebenen Zeichen)
+% \pause
+ \item
+ \newterm{Seiteneffekt\/}: Ausgabe
+ \end{itemize}
+
+\end{frame}
+
+\addtocounter{subsection}{-1}
+\subsection{Seiteneffekte \protect\color{gray}bei Operatoren}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{minipage}[t]{6cm}
+ Unäre Operatoren:
+ \begin{itemize}
+ \item
+ Negation: \lstinline{-foo}
+ \item
+ {\only<2->{\color{red}}Funktionsaufruf}: \lstinline{foo ()}
+ \item
+ {\only<2->{\color{red}}Post-Inkrement}: \lstinline{foo++}
+ \item
+ {\only<2->{\color{red}}Post-Dekrement}: \lstinline{foo--}
+ \item
+ {\only<2->{\color{red}}Prä-Inkrement}: \lstinline{++foo}
+ \item
+ {\only<2->{\color{red}}Prä-Dekrement}: \lstinline{--foo}
+ \end{itemize}
+ \medskip
+ Binäre Operatoren:
+ \begin{itemize}
+ \item
+ Rechnen: \lstinline{+ - * / %}
+ \item
+ Vergleich: \lstinline{== != < > <= >=}
+ \item
+ {\only<2->{\color{red}}Zuweisung}: \lstinline{= += -= *= /= %=}
+ \item
+ Ignorieren: \lstinline{,}\quad \lstinline{a, b}: berechne \lstinline{a}, ignoriere es, nimm stattdessen \lstinline{b}
+ \end{itemize}
+ \pause
+ \medskip
+ {\color{red}rot = mit Seiteneffekt}
+ \end{minipage}
+ \pause
+ \begin{minipage}[t]{6cm}
+ \vspace{-\bigskipamount}
+ \begin{lstlisting}
+ ¡int i;¿
+ \end{lstlisting}
+ \bigskip
+ \begin{lstlisting}
+ ¡i = 0;
+ while (i < 10)
+ {
+ printf ("%d\n", i);
+ i++;
+ }¿
+ \end{lstlisting}
+ \bigskip
+% \pause
+ \begin{lstlisting}
+ ¡for (i = 0; i < 10; i++)
+ printf ("%d\n", i);¿
+ \end{lstlisting}
+ \bigskip
+% \pause
+ \begin{lstlisting}
+ ¡i = 0;
+ while (i < 10)
+ printf ("%d\n", i++);¿
+ \end{lstlisting}
+ \bigskip
+% \pause
+ \begin{lstlisting}
+ ¡for (i = 0; i < 10; printf ("%d\n", i++));¿
+ \end{lstlisting}
+ \end{minipage}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\subsection{Funktionen}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{minipage}[t]{6.5cm}
+ \vspace{-\medskipamount}
+ \begin{lstlisting}[gobble=6]
+ ¡#include <stdio.h>
+
+ int answer (void)
+ {
+ return 42;
+ }
+
+ void foo (void)
+ {
+ printf ("%d\n", answer ());
+ }
+
+ int main (void)
+ {
+ foo ();
+ return 0;
+ }¿
+ \end{lstlisting}
+ \vspace*{-1cm}
+ \end{minipage}%
+ \begin{minipage}[t]{6cm}
+ \begin{itemize}
+% \pause
+ \item
+ Funktionsdeklaration:\\[\smallskipamount]
+ Typ Name ( Parameterliste )\\
+ \{\\
+ \quad Anweisungen\\
+ \}
+ \end{itemize}
+ \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{minipage}[t]{6.5cm}
+ \vspace{-\medskipamount}
+ \begin{lstlisting}[gobble=6]
+ ¡#include <stdio.h>
+
+ void add_verbose (int a, int b)
+ {
+ printf ("%d + %d = %d\n", a, b, a + b);
+ }
+
+ int main (void)
+ {
+ add_verbose (3, 7);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{minipage}%
+ \begin{minipage}[t]{6cm}
+ \begin{itemize}
+ \item
+ Funktionsdeklaration:\\[\smallskipamount]
+ Typ Name ( Parameterliste )\\
+ \{\\
+ \quad Anweisungen\\
+ \}
+% \pause
+ \bigskip
+ \item
+ Der Datentyp \lstinline{void}\\
+ steht für "`nichts"'\\
+ und \alt<2->{muß}{kann} ignoriert werden.
+ \end{itemize}
+ \end{minipage}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{minipage}{6cm}
+ \begin{lstlisting}[gobble=6]
+ ¡#include <stdio.h>
+
+ int a, b = 3;
+
+ void foo (void)
+ {
+ b++;
+ static int a = 5;
+ int b = 7;
+ printf ("foo(): "
+ "a = %d, b = %d\n",
+ a, b);
+ a++;
+ }¿
+ \end{lstlisting}
+ \end{minipage}%
+ \begin{minipage}{6cm}
+ \vspace{-0.4cm}
+ \begin{lstlisting}[gobble=6]
+ ¡int main (void)
+ {
+ printf ("main(): "
+ "a = %d, b = %d\n",
+ a, b);
+ foo ();
+ printf ("main(): "
+ "a = %d, b = %d\n",
+ a, b);
+ a = b = 12;
+ printf ("main(): "
+ "a = %d, b = %d\n",
+ a, b);
+ foo ();
+ printf ("main(): "
+ "a = %d, b = %d\n",
+ a, b);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{minipage}
+
+\end{frame}
+
+\subsection{Zeiger}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ void calc_answer (int *a)
+ {
+ *a = 42;
+ }
+
+ int main (void)
+ {
+ int answer;
+ calc_answer (&answer);
+ printf ("The answer is %d.\n", answer);
+ return 0;
+ }
+ \end{lstlisting}
+
+% \pause
+ \vspace{-5cm}\hspace{5cm}%
+ \begin{minipage}{7cm}
+ \begin{itemize}
+ \item
+ \lstinline{*a} ist eine \lstinline{int}.
+% \pause
+ \item
+ unärer Operator \lstinline{*}:\\
+ Pointer-Dererefenzierung
+% \pause
+ \arrowitem
+ \lstinline{a} ist ein Zeiger (Pointer) auf eine \lstinline{int}.
+% \pause
+ \bigskip
+ \item
+ unärer Operator \lstinline{&}: Adresse
+ \end{itemize}
+ \end{minipage}
+\end{frame}
+
+\subsection{Arrays und Strings}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ Ein Zeiger zeigt auf eine Variable\only<2->{ und deren Nachbarn}.
+
+ \bigskip
+ \pause
+ \pause
+
+ \begin{onlyenv}<1-8>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[5] = { 2, 3, 5, 7, 11 };
+ int *p = prime;
+ for (int i = 0; i < 5; i++)
+ printf ("%d\n", *(p + i));
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<9>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[5] = { 2, 3, 5, 7, 11 };
+ int *p = prime;
+ for (int i = 0; i < 5; i++)
+ printf ("%d\n", p[i]);
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<10>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[5] = { 2, 3, 5, 7, 11 };
+ for (int i = 0; i < 5; i++)
+ printf ("%d\n", prime[i]);
+ return 0;
+ }
+ ¡ ¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<11>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[5] = { 2, 3, 5, 7, 11 };
+ for (int *p = prime;
+ p < prime + 5; p++)
+ printf ("%d\n", *p);
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<12>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[6] = { 2, 3, 5, 7, 11, 0 };
+ for (int *p = prime; *p; p++)
+ printf ("%d\n", *p);
+ return 0;
+ }
+ ¡ ¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<13->
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ int prime[] = { 2, 3, 5, 7, 11, 0 };
+ for (int *p = prime; *p; p++)
+ printf ("%d\n", *p);
+ return 0;
+ }
+ ¡ ¿
+ \end{lstlisting}
+ \end{onlyenv}
+
+ \pause
+ \vspace{-3.05cm}\hspace{5.5cm}%
+ \begin{minipage}{6.5cm}
+ \begin{itemize}
+ \item
+ \lstinline{prime} ist \alt<5->{ein Array}{eine Ansammlung} von\\fünf ganzen Zahlen.
+ \pause
+ \pause
+ \item
+ \only<6-9>{\begin{picture}(0,0)
+ \color{red}
+ \put(-1.6,0.1){\tikz{\draw[-latex](0.0,0.0)--(-1,0);}}
+ \end{picture}}%
+ \lstinline{prime} ist ein Zeiger auf eine \lstinline{int}.
+ \pause
+ \item
+ \lstinline{p + i} ist ein Zeiger\\
+ auf den \lstinline{i}-ten Nachbarn von \lstinline{*p}.
+ \pause
+ \item
+ \lstinline{*(p + i)} ist der \lstinline{i}-te Nachbar von \lstinline{*p}.
+ \pause
+ \item
+ Andere Schreibweise:\\
+ \lstinline{p[i]} statt \lstinline{*(p + i)}
+ \pause
+ \pause
+ \item
+ Zeiger-Arithmetik:\\
+ \lstinline{p++} rückt den Zeiger \lstinline{p}\\
+ um eine \lstinline{int} weiter.
+ \pause
+ \pause
+ \item
+ Array ohne \only<14->{explizite }Längenangabe:\\
+ Compiler zählt selbst
+ \vspace*{-1cm}
+ \pause
+ \begin{picture}(0,0)
+ \put(-5.2,1.0){\makebox(0,0)[br]{\color{red}\bf\shortstack{Die Länge des Arrays\\ist \emph{nicht\/} veränderlich!}}}
+ \end{picture}
+ \end{itemize}
+ \end{minipage}
+\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}}}
+ \item[\textbf{2}] \textbf{Einführung in C}
+ \begin{itemize}
+ \vspace{-1.5\smallskipamount}
+ \item[\dots]
+ \item[2.5] Verzweigungen
+ \item[2.6] Schleifen
+ \color{medgreen}
+ \item[2.7] Strukturierte Programmierung
+ \item[2.8] Seiteneffekte
+ \item[2.9] Funktionen
+ \item[2.10] Zeiger
+ \color{orange}
+ \item[2.11] Arrays und Strings
+ \color{red}
+ \item[2.12] Strukturen
+ \item[2.13] Dateien und Fehlerbehandlung
+ \item[2.14] Parameter des Hauptprogramms
+ \item[2.15] String-Operationen
+ \end{itemize}
+ \color{gray}
+ \item[\textbf{3}] \textbf{Bibliotheken}
+ \vspace*{-\smallskipamount}
+ \item[\textbf{\dots}]
+% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+% \item[\textbf{5}] \textbf{Algorithmen}
+% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+% \begin{frame}[fragile]
+% \showsubsection
+%
+% \begin{lstlisting}
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char hello_world[] = "Hello, world!\n";
+% int i = 0;
+% while (hello_world[i] != 0)
+% printf ("%d", hello_world[i++]);
+% return 0;
+% }
+% \end{lstlisting}
+% \end{frame}
+
+% \begin{frame}[fragile]
+% \showsubsection
+%
+% \begin{lstlisting}
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char hello_world[] = "Hello, world!\n";
+% int i = 0;
+% while (hello_world[i])
+% printf ("%d", hello_world[i++]);
+% return 0;
+% }
+% \end{lstlisting}
+% \end{frame}
+
+% \begin{frame}[fragile]
+% \showsubsection
+%
+% \begin{lstlisting}
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char hello_world[] = "Hello, world!\n";
+% char *p = hello_world;
+% while (*p)
+% printf ("%c", *p++);
+% return 0;
+% }
+% \end{lstlisting}
+% \end{frame}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \begin{onlyenv}<1-6>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ char hello[] = "Hello, world!\n";
+ for (char *p = hello; *p; p++)
+ printf ("%d", *p);
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<7>
+ \begin{lstlisting}[gobble=6]
+ #include <stdio.h>
+
+ int main (void)
+ {
+ char hello[] = "Hello, world!\n";
+ for (char *p = hello; *p; p++)
+ printf ("%c", *p);
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+% \begin{onlyenv}<8>
+% \begin{lstlisting}[gobble=6]
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char hello[] = "Hello, world!\n";
+% printf ("%s", hello);
+% return 0;
+% }
+% ¡ ¿
+% \end{lstlisting}
+% \end{onlyenv}
+% \begin{onlyenv}<9>
+% \begin{lstlisting}[gobble=6]
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char *hello = "Hello, world!\n";
+% printf ("%s", hello);
+% return 0;
+% }
+% ¡ ¿
+% \end{lstlisting}
+% \end{onlyenv}
+% \begin{onlyenv}<10>
+% \begin{lstlisting}[gobble=6]
+% #include <stdio.h>
+%
+% int main (void)
+% {
+% char *hello = "Hello, world!\n";
+% while (*hello)
+% printf ("%c", *hello++);
+% return 0;
+% }
+% \end{lstlisting}
+% \end{onlyenv}
+
+ \vspace{-1.7cm}\hfill
+ \begin{minipage}{6.8cm}
+ \begin{itemize}
+ \pause[2]
+ \item
+ Ein \lstinline{char} ist eine kleinere \lstinline{int}.
+ \pause
+ \item
+ Ein "`String"' in C ist ein Array von \lstinline{char}s\only<4->{,\\
+ also ein Zeiger auf \lstinline{char}s}\only<5->{\\
+ also ein Zeiger auf (kleinere) Integer}.
+ \pause
+ \pause
+ \pause
+ \item
+ Der letzte \lstinline{char} muß 0 sein.\\
+ Er kennzeichnet das Ende des Strings.
+ \pause
+ \item
+ Die Formatspezifikation\\
+ entscheidet über die Ausgabe:\\[\smallskipamount]
+ \begin{tabular}{ll}
+ \lstinline|%d|\hspace*{0.5em}dezimal
+ & \lstinline|%c|\hspace*{0.5em}Zeichen\\
+ \lstinline|%x|\hspace*{0.5em}hexadezimal
+% \pause
+% & \lstinline|%s|\hspace*{0.5em}String
+ \end{tabular}
+ \vspace*{-1cm}
+ \end{itemize}
+ \end{minipage}
+\end{frame}
+
+\addtocounter{subsection}{-1}
+\subsection{Arrays und Strings \protect\color{gray}und Zeichen}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \emph{"`Alles ist Zahl."'\/} -- Schule der Pythagoreer, 6.\ Jh.\ v.\,Chr.
+
+ \medskip
+
+ \begin{center}
+ \renewcommand{\arraystretch}{1.5}
+ \begin{tabular}{r}
+ \lstinline|"Hello"|\\
+ \lstinline|'H'|\\
+ \lstinline|'a' + 4|
+ \end{tabular}
+ \renewcommand{\arraystretch}{1.0}
+ \begin{tabular}{c}
+ ist nur eine andere\\
+ Schreibweise für
+ \end{tabular}
+ \renewcommand{\arraystretch}{1.5}
+ \begin{tabular}{l}
+ \lstinline|{ 72, 101, 108, 108, 111, 0 }|\\
+ \lstinline|72|\\
+ \lstinline|'e'|
+ \end{tabular}
+ \renewcommand{\arraystretch}{1.0}
+ \end{center}
+
+ \begin{itemize}
+ \item
+ Welchen Zahlenwert hat \lstinline{'*'} im Zeichensatz?
+
+ \smallskip
+
+ \begin{lstlisting}[gobble=8]
+ printf ("%d\n", '*');
+ \end{lstlisting}
+
+ \smallskip
+
+ (normalerweise: ASCII)
+ \medskip
+ \item
+ Ist \lstinline{char ch} ein Großbuchstabe?
+
+ \smallskip
+
+ \begin{lstlisting}[gobble=8]
+ if (ch >= 'A' && ch <= 'Z')
+ ...
+ \end{lstlisting}
+ \medskip
+ \item
+ Groß- in Kleinbuchstaben umwandeln
+
+ \smallskip
+
+ \begin{lstlisting}[gobble=8]
+ ch += 'a' - 'A';
+ \end{lstlisting}
+ \end{itemize}
+\end{frame}
+
+\subsection{Strukturen}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ typedef struct
+ {
+ char day, month;
+ int year;
+ }
+ date;
+
+ int main (void)
+ {
+ date today = { 17, 10, 2022 };
+ printf ("%d.%d.%d\n", today.day, today.month, today.year);
+ return 0;
+ }
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \vspace*{0.9mm}
+ \begin{minipage}[b]{6cm}
+ \begin{lstlisting}[gobble=6]
+ ¡#include <stdio.h>
+
+ typedef struct
+ {
+ char day, month;
+ int year;
+ }
+ date;
+
+ void set_date (date *d)
+ {
+ (*d).day = 17;
+ (*d).month = 10;
+ (*d).year = 2022;
+ }¿
+ \end{lstlisting}
+ \end{minipage}%
+ \begin{minipage}[b]{6cm}
+ \begin{lstlisting}[gobble=6]
+ ¡int main (void)
+ {
+ date today;
+ set_date (&today);
+ printf ("%d.%d.%d\n", today.day,
+ today.month, today.year);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{minipage}
+\end{frame}
+
+\begin{frame}[fragile]
+ \showsubsection
+
+ \vspace*{0.9mm}
+ \begin{minipage}[b]{6cm}
+ \begin{lstlisting}[gobble=6]
+ ¡#include <stdio.h>
+
+ typedef struct
+ {
+ char day, month;
+ int year;
+ }
+ date;
+
+ void set_date (date *d)
+ {
+ d->day = 17;
+ d->month = 10;
+ d->year = 2022;
+ }¿
+ \end{lstlisting}
+ \end{minipage}%
+ \begin{minipage}[b]{6cm}
+ \hspace*{-1cm}%
+ \lstinline{foo->bar}
+ ist Abkürzung für
+ \lstinline{(*foo).bar}
+
+ \bigskip
+
+ \visible<2->{%
+ \hspace*{-1cm}%
+ Eine Funktion, die mit einem \lstinline{struct} arbeitet,\\
+ \hspace*{-1cm}%
+ kann man eine \newterm{Methode\/} des \lstinline{struct} nennen.}
+
+ \bigskip
+ \bigskip
+
+ \begin{lstlisting}[gobble=6]
+ ¡int main (void)
+ {
+ date today;
+ set_date (&today);
+ printf ("%d.%d.%d\n", today.day,
+ today.month, today.year);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{minipage}
+
+\end{frame}
+
+\subsection{Dateien und Fehlerbehandlung}
+
+\begin{frame}[fragile]
+ \showsubsection
+ \vspace*{-0.2925cm}
+ \begin{minipage}[t]{6cm}
+ \begin{onlyenv}<1>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <stdio.h>
+
+ int main (void)
+ {
+ FILE *f = fopen ("fhello.txt", "w");
+ fprintf (f, "Hello, world!\n");
+ fclose (f);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<2>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <stdio.h>
+
+ int main (void)
+ {
+ FILE *f = fopen ("fhello.txt", "w");
+ if (f)
+ {
+ fprintf (f, "Hello, world!\n");
+ fclose (f);
+ }
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<3>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <stdio.h>
+ #include <errno.h>
+
+ int main (void)
+ {
+ FILE *f = fopen ("fhello.txt", "w");
+ if (f)
+ {
+ fprintf (f, "Hello, world!\n");
+ fclose (f);
+ }
+ else
+ fprintf (stderr, "error #%d\n", errno);
+ return 0;
+ }¿
+ \end{lstlisting}
+ \end{onlyenv}
+ \begin{onlyenv}<4>
+ \begin{lstlisting}[gobble=8]
+ ¡#include <stdio.h>
+ #include <errno.h>
+ #include <string.h>
+
+ int main (void)
+ {
+ FILE *f = fopen ("fhello.txt", "w");
+ if (f)
+ {
+ fprintf (f, "Hello, world!\n");
+ fclose (f);
+ }
+ else
+ {
+ char *msg = strerror (errno);
+ fprintf (stderr, "%s\n", msg);
+ }
+ return 0;
+ }¿
+ \end{lstlisting}
+ \vspace*{-1cm}
+ \end{onlyenv}
+ \begin{onlyenv}<5->
+ \begin{lstlisting}[gobble=8]
+ ¡#include <stdio.h>
+ #include <errno.h>
+ #include <er¡ror.h>
+
+ int main (void)
+ {
+ FILE *f = fopen ("fhello.txt", "w");
+ if (!f)
+ error (errno, errno, "cannot open file");
+ fprintf (f, "Hello, world!\n");
+ fclose (f);
+ return 0;
+ }
+ \end{lstlisting}
+ \end{onlyenv}
+ \end{minipage}\pause\hspace*{-1.5cm}%
+ \begin{minipage}[t]{8.5cm}
+ \bigskip
+ \only<3->{\bigskip}
+ \begin{itemize}
+ \item
+ Wenn die Datei nicht geöffnet werden kann,\\
+ gibt \lstinline{fopen()} den Wert \lstinline{NULL} zurück.
+ \pause
+ \medskip
+ \item
+ \addtolength{\leftskip}{1cm}
+ Die globale Variable \lstinline{int errno}\\
+ enthält dann die Nummer des Fehlers.\\
+ Benötigt: \lstinline{#include <errno.h>}
+ \pause
+ \medskip
+ \only<5->{\bigskip}
+ \item
+ Die Funktion \lstinline{strerror()} wandelt \lstinline{errno}\\
+ in einen Fehlermeldungstext um.\\
+ Benötigt: \lstinline{#include <string.h>}
+ \pause
+ \medskip
+ \item
+ \addtolength{\leftskip}{-1.5cm}
+ Die Funktion \lstinline{error()} gibt eine Fehlermeldung aus\\
+ und beendet das Programm.\\
+ Benötigt: \lstinline{#include <er¡¿ror.h>}
+ \pause
+ \medskip
+ \item
+ \textbf{Niemals Fehler einfach ignorieren!}
+ \end{itemize}
+ \addtolength{\leftskip}{0.5cm}
+ \end{minipage}
+\end{frame}
+
+\subsection{Parameter des Hauptprogramms}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ int main (int argc, char **argv)
+ {
+ printf ("argc = %d\n", argc);
+ for (int i = 0; i < argc; i++)
+ printf ("argv[%d] = \"%s\"\n", i, argv[i]);
+ return 0;
+ }
+ \end{lstlisting}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+ \begin{lstlisting}
+ #include <stdio.h>
+
+ int main (int argc, char **argv)
+ {
+ printf ("argc = %d\n", argc);
+ for (int i = 0; *argv; i++, argv++)
+ printf ("argv[%d] = \"%s\"\n", i, *argv);
+ return 0;
+ }
+ \end{lstlisting}
+
+\end{frame}
+
+\subsection{String-Operationen}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+% \vspace*{-0.4cm}
+ \begin{lstlisting}
+ #include <stdio.h>
+ #include <string.h>
+
+ int main (void)
+ {
+ char hello[] = "Hello, world!\n";
+
+ printf ("%s\n", hello);
+ printf ("%zd\n", strlen (hello));
+
+ printf ("%s\n", hello + 7);
+ printf ("%zd\n", strlen (hello + 7));
+
+ hello[5] = 0;
+ printf ("%s\n", hello);
+ printf ("%zd\n", strlen (hello));
+
+ return 0;
+ }
+ \end{lstlisting}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+% \vspace*{-0.4cm}
+ \begin{lstlisting}
+ #include <stdio.h>
+ #include <string.h>
+
+ int main (void)
+ {
+ char *anton = "Anton";
+ char *zacharias = "Zacharias";
+
+ printf ("%d\n", strcmp (anton, zacharias));
+ printf ("%d\n", strcmp (zacharias, anton));
+ printf ("%d\n", strcmp (anton, anton));
+
+ char buffer[100] = "Huber ";
+ strcat (buffer, anton);
+ printf ("%s\n", buffer);
+
+ return 0;
+ }
+ \end{lstlisting}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+% \vspace*{-0.4cm}
+ \begin{lstlisting}
+ #include <stdio.h>
+ #include <string.h>
+
+ int main (void)
+ {
+ char buffer[100] = "";
+ sprintf (buffer, "Die Antwort lautet: %d", 42);
+ printf ("%s\n", buffer);
+
+ char *answer = strstr (buffer, "Antwort");
+ printf ("%s\n", answer);
+ printf ("found at: %zd\n", answer - buffer);
+
+ return 0;
+ }
+ \end{lstlisting}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}[fragile]
+
+ \showsubsection
+
+% \vspace*{-0.4cm}
+ \begin{lstlisting}
+ #include <stdio.h>
+ #include <string.h>
+
+ int main (void)
+ {
+ char buffer[100] = "";
+ snprintf (buffer, 100, "Die Antwort lautet: %d", 42);
+ printf ("%s\n", buffer);
+
+ char *answer = strstr (buffer, "Antwort");
+ printf ("%s\n", answer);
+ printf ("found at: %zd\n", answer - buffer);
+
+ return 0;
+ }
+ \end{lstlisting}
+
+\end{frame}
+
+\begin{frame}
+
+ \showsection
+
+ Sprachelemente weitgehend komplett
+
+ \bigskip
+ Es fehlen:
+ \begin{itemize}
+ \item
+ Ergänzungen (z.\,B.\ ternärer Operator, \lstinline{union}, \lstinline{unsigned}, \lstinline{volatile})
+ \item
+ Bibliotheksfunktionen (z.\,B.\ \lstinline{malloc()})
+ \arrowitem
+ werden eingeführt, wenn wir sie brauchen
+ \bigskip
+ \item
+ Konzepte (z.\,B.\ rekursive Datenstrukturen, Klassen selbst bauen)
+ \arrowitem
+ werden eingeführt, wenn wir sie brauchen, oder:
+ \arrowitem
+ Literatur\\[\smallskipamount]
+ (z.\,B.\ Wikibooks: C-Programmierung,\\
+ Dokumentation zu Compiler und Bibliotheken)
+ \bigskip
+ \item
+ Praxiserfahrung
+ \arrowitem
+ Übung und Praktikum: nur Einstieg
+ \arrowitem
+ selbständig arbeiten
+ \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}}}
+ \item[\textbf{2}] \textbf{Einführung in C}
+ \begin{itemize}
+ \vspace{-1.5\smallskipamount}
+ \item[\dots]
+ \item[2.5] Verzweigungen
+ \item[2.6] Schleifen
+ \item[2.7] Strukturierte Programmierung
+ \item[2.8] Seiteneffekte
+ \item[2.9] Funktionen
+ \item[2.10] Zeiger
+ \color{medgreen}
+ \item[2.11] Arrays und Strings
+ \item[2.12] Strukturen
+ \item[2.13] Dateien und Fehlerbehandlung
+ \item[2.14] Parameter des Hauptprogramms
+ \item[2.15] String-Operationen
+ \end{itemize}
+ \color{gray}
+ \item[\textbf{3}] \textbf{Bibliotheken}
+ \vspace*{-\smallskipamount}
+ \item[\textbf{\dots}]
+% \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+% \item[\textbf{5}] \textbf{Algorithmen}
+% \item[\textbf{6}] \textbf{Ergänzungen und Ausblicke}
+ \end{itemize}
+ \vspace*{-1cm}
+
+\end{frame}
+
+\end{document}
diff --git a/20231019/hp-musterloesung-20231019.pdf b/20231019/hp-musterloesung-20231019.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..e3e0e8179ec50b8ced0869b592c12228860be510
Binary files /dev/null and b/20231019/hp-musterloesung-20231019.pdf differ
diff --git a/20231019/hp-musterloesung-20231019.tex b/20231019/hp-musterloesung-20231019.tex
new file mode 100644
index 0000000000000000000000000000000000000000..b46ec8ed68215842807fe4e52b4ca8f6747b363d
--- /dev/null
+++ b/20231019/hp-musterloesung-20231019.tex
@@ -0,0 +1,523 @@
+% hp-musterloesung-20231019.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 -- 19.\ Oktober 2023}
+
+ \exercise{Seltsame Programme}
+
+ Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20221017}
+ finden Sie (unter anderem)\\
+ die Programme \gitfile{hp}{2023ws/20231019}{test-1.c},
+ \gitfile{hp}{2023ws/20231019}{test-2.c} und \gitfile{hp}{2023ws/20231019}{test-3.c}.
+
+ Was bewirken diese Programme, und warum verhalten sie sich so?
+
+ \solution
+
+ \begin{itemize}
+ \item
+ \gitfile{hp}{2023ws/20231019}{test-1.c}
+
+ Hinter \lstinline{return} steht ein Ausdruck mit dem
+ Komma-Operator. Dieser bewirkt, daß der Wert vor dem Komma
+ berechnet und ignoriert und danach der Wert nach dem Komma
+ zurückgegeben wird.
+
+ In diesem Fall wird vor dem Komma der Wert des
+ \lstinline{printf()}-Aufrufs berechnet und ignoriert.
+ Als Seiteneffekt gibt das Programm die Zeile
+ \lstinline[style=terminal]{Hello, world!} aus.
+ Anschließend wird der Wert \lstinline{0} an \lstinline{return}
+ übergeben und daher \lstinline{return 0} ausgeführt.
+
+ \item
+ \gitfile{hp}{2023ws/20231019}{test-2.c}
+
+ Das Programm gibt die Zeile
+ \lstinline[style=terminal]{Die Antwort lautet: 42} aus.
+
+ Die \lstinline{if}-Bedingung ist eine Zuweisung \lstinline{b = 42},
+ die den zugewiesenen Wert \lstinline{42} zurückgibt.
+ Weil dieser Wert ungleich Null ist, interpretiert
+ \lstinline{if} ihn als Wahrheitswert "`wahr"', führt also den
+ \lstinline{if}-Zweig aus und überspringt den
+ \lstinline{else}-Zweig.
+
+ \item
+ \gitfile{hp}{2023ws/20231019}{test-3.c}
+
+ Das Programm stürzt mit einer Fehlermeldung
+ "`Speicherzugriffsfehler"' oder "`Schutzverletzung"' ab.
+
+ Der Funktionsaufruf \lstinline{printf (42)} übergibt den
+ Zahlenwert \lstinline{42} als String, also als einen Zeiger
+ auf \lstinline{char}-Variable, an die Funktion
+ \lstinline{printf()}. Diese versucht, auf den Speicher ab
+ Adresse 42 zuzugreifen, wofür aber das Programm keine
+ Zugriffsrechte hat. Das Betriebssystem beendet daraufhin das
+ Programm mit der o.\,a.\ Fehlermeldung.
+
+ Der String \lstinline{"Die Antwort lautet: "} wird nicht
+ ausgegeben, weil Schreiboperationen aus Effizienzgründen
+ erst nach einer abgeschlossenen Zeile (\lstinline{"\n"})
+ durchgeführt werden.
+ \end{itemize}
+
+ \clearpage
+
+ \exercise{Kalender-Berechnung}
+
+ Am 3.\,1.\,2009 meldete \emph{heise online\/}:
+ \begin{quote}
+ Kunden des ersten mobilen Media-Players von Microsoft
+ erlebten zum Jahresende eine böse Überraschung:
+ Am 31.\ Dezember 2008 fielen weltweit alle Zune-Geräte der ersten Generation aus.
+ Ursache war ein interner Fehler bei der Handhabung von Schaltjahren.
+
+ \strut\hfill\url{http://heise.de/-193332},
+ \end{quote}
+ Der Artikel verweist auf ein Quelltextfragment (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-2.c}),
+ das für einen gegebenen Wert \lstinline{days}
+ das Jahr und den Tag innerhalb des Jahres
+ für den \lstinline{days}-ten Tag nach dem 1.\,1.\,1980 berechnen soll:
+ \begin{lstlisting}
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > 365)
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+ \end{lstlisting}
+ Dieses Quelltextfragment enthält schlechten Programmierstil,
+ nämlich mehrere Code-Verdopplungen:
+ \begin{itemize}
+ \item
+ Die Anweisung \lstinline{year += 1} taucht an zwei Stellen auf.
+ \item
+ Es gibt zwei unabhängige Abfragen \lstinline{days > 365} und \lstinline{days > 366}:\\
+ eine in einer \lstinline{while}- und die andere in einer \lstinline{if}-Bedingung.
+ \item
+ Die Länge eines Jahres wird nicht durch eine Funktion berechnet oder in einer Variablen gespeichert;
+ stattdessen werden an mehreren Stellen die expliziten numerischen Konstanten 365 und 366 verwendet.
+ \end{itemize}
+ Diese Probleme führten am 31.\ Dezember 2008 zu einer Endlosschleife.
+
+ Gut hingegen ist die Verwendung einer Konstanten \lstinline{ORIGINYEAR}
+ anstelle der Zahl 1980
+ sowie die Kapselung der Berechnung der Schaltjahr-Bedingung
+ in einer Funktion \lstinline{IsLeapYear()}.
+
+ \begin{itemize}
+ \item[(a)]
+ Erklären Sie das Zustandekommen der Endlosschleife.
+ \item[(b)]
+ Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
+ nicht mehr enthält.
+ \end{itemize}
+
+ \textbf{Hinweis 1:} Verwenden Sie Ihre eigene Funktion \lstinline{IsLeapYear()}.
+
+ \textbf{Hinweis 2}: Schreiben Sie zusätzlich eine Funktion \lstinline{DaysInYear()}.
+
+ \clearpage
+
+ \solution
+
+ \begin{itemize}
+ \item[(a)]
+ \textbf{Erklären Sie das Zustandekommen der Endlosschleife.}
+
+ Das Programm startet mit demjenigen Wert für \lstinline{days},
+ der der Anzahl der Tage vom 1.\,1.\,1980 bis zum
+ 31.\,12.\,2008 entspricht. Die \lstinline{while}-Schleife
+ läuft zunächst solange korrekt durch, bis \lstinline{year} den
+ Wert \lstinline{2008} und \lstinline{days} den Wert
+ \lstinline{366} hat. (Der 31.\,12.\ des Schaltjahres 2008 ist
+ der 366.\ Tag seines Jahres.)
+
+ Die Bedingung der \lstinline{while}-Schleife ist damit
+ weiterhin erfüllt; das Programm läuft weiter.
+
+ Da 2008 ein Schaltjahr ist, ist auch die Bedingung der äußeren
+ \lstinline{if}-Anweisung erfüllt.
+
+ Da \lstinline{days} den Wert 366 hat und dieser nicht größer
+ als 366 ist, ist die innere \lstinline{if}-Bedingung nicht
+ erfüllt. Somit wird innerhalb der \lstinline{while}-Schleife
+ kein weiterer Code ausgeführt, die \lstinline{while}-Bedingung
+ bleibt erfüllt, und das Programm führt eine Endlosschleife
+ aus.
+
+ \item[(b)]
+ \textbf{Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
+ nicht mehr enthält.}
+
+ Um das Programm zu testen, genügt es, das Datum auf den
+ 31.\,12.\,1980 zu stellen, also \lstinline{days} auf den Wert
+ 366 zu setzen. Darüberhinaus muß man die Funktion
+ \lstinline{IsLeapYear()} bereitstellen (vgl.\ Aufgabe 1 vom 11.\,10.\,2021).
+
+ Der Quelltext \gitfile{hp}{2023ws/20231019}{loesung-2-f1.c} ist eine lauffähige
+ Version des Programms, die den Fehler (Endlosschleife)
+ reproduziert.
+
+ \breath
+
+ Es liegt nahe, den Fehler in der \lstinline{while}-Bedingung
+ zu korrigieren, so daß diese Schaltjahre berücksichtigt. Der
+ Quelltext \gitfile{hp}{2023ws/20231019}{loesung-2-f2.c} behebt den Fehler auf diese
+ Weise mit Hilfe von Und- (\lstinline{&&}) und
+ Oder-Verknüpfungen (\lstinline{||}) in der
+ \lstinline{while}-Bedingung.
+
+ Der Quelltext \gitfile{hp}{2023ws/20231019}{loesung-2-f3.c} vermeidet die umständliche
+ Formulierung mit \lstinline{&&} und \lstinline{||} durch
+ Verwendung des ternären Operators \lstinline{?:}. Dieser
+ stellt eine "`\lstinline{if}-Anweisung für Ausdrücke"' bereit.
+ In diesem Fall liefert er für die rechte Seite des Vergleichs
+ \lstinline{days >} den Wert 366 im Falle eines Schaltjahrs
+ bzw.\ ansonsten den Wert 365.
+
+ Beide Lösungen \gitfile{hp}{2023ws/20231019}{loesung-2-f2.c} und \gitfile{hp}{2023ws/20231019}{loesung-2-f3.c}
+ sind jedoch im Sinne der Aufgabenstellung \textbf{falsch}.
+ Diese lautet: "`Schreiben Sie das Quelltextfragment so um,
+ daß es die beschriebenen Probleme nicht mehr enthält."'
+ Mit den beschriebenen Problemen sind die genannten drei
+ Code-Verdopplungen gemeint, und diese befinden sich weiterhin
+ im Quelltext. Damit ist der Fehler zwar "`korrigiert"', aber
+ das Programm ist eher noch unübersichtlicher geworden, so daß
+ nicht klar ist, ob es nicht noch weitere Fehler enthält.
+
+ \breath
+
+ Eine richtige Lösung liefert \gitfile{hp}{2023ws/20231019}{loesung-2-4.c}. Dieses
+ Programm speichert den Wert der Tage im Jahr in einer
+ Variablen \lstinline{DaysInYear}. Damit erübrigen sich die
+ \lstinline{if}-Anweisungen innerhalb der
+ \lstinline{while}-Schleife, und die damit verbundenen
+ Code-Verdopplungen verschwinden.
+
+ Etwas unschön ist hierbei die neu hinzugekommene
+ Code-Verdopplung bei der Berechnung von \lstinline{DaysInYear}.
+ Diese ist allerdings weniger kritisch als die vorherigen, da
+ sie nur einmal innerhalb der \lstinline{while}-Schleife
+ vorkommt und das andere Mal außerhalb derselben.
+
+ Um diese Code-Verdopplung loszuwerden, kann man das
+ \lstinline{if} durch den \lstinline{?:}-Operator ersetzen und
+ die Zuweisung innerhalb der \lstinline{while}-Bedingung
+ vornehmen -- siehe \gitfile{hp}{2023ws/20231019}{loesung-2-5.c}. Dies ist einer der
+ seltenen Fälle, in denen ein Programm \emph{übersichtlicher\/}
+ wird, wenn eine Zuweisung innerhalb einer Bedingung
+ stattfindet.
+
+ Alternativ kann \lstinline{DaysInYear()} auch eine Funktion
+ sein -- siehe \gitfile{hp}{2023ws/20231019}{loesung-2-6.c}. Diese Version ist
+ wahrscheinlich die übersichtlichste, hat jedoch den Nachteil,
+ daß die Berechnung von \lstinline{DaysInYear()} zweimal statt
+ nur einmal pro Schleifendurchlauf erfolgt, wodurch Rechenzeit
+ verschwendet wird.
+
+ \gitfile{hp}{2023ws/20231019}{loesung-2-7.c} und \gitfile{hp}{2023ws/20231019}{loesung-2-8.c} beseitigen
+ dieses Problem durch eine Zuweisung des Funktionsergebnisses
+ an eine Variable -- einmal innerhalb der
+ \lstinline{while}-Bedingung und einmal außerhalb.
+ Der zweimalige Aufruf der Funktion \lstinline{DaysInYear()} in
+ \gitfile{hp}{2023ws/20231019}{loesung-2-8.c} zählt nicht als Code-Verdopplung, denn
+ der Code ist ja in einer Funktion gekapselt. (Genau dazu sind
+ Funktionen ja da: daß man sie mehrfach aufrufen kann.)
+
+ \breath
+
+ Fazit: Wenn Sie sich beim Programmieren bei
+ Cut-And-Paste-Aktionen erwischen, sollten Sie die Struktur
+ Ihres Programms noch einmal überdenken.
+
+ Wahrscheinlich gibt es dann eine elegantere Lösung, deren
+ Korrektheit man auf den ersten Blick sieht.
+
+ \end{itemize}
+
+ \exercise{Strings}
+
+ Strings werden in der Programmiersprache C
+ durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+ Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-3.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.
+
+ Alternative Formulierung:
+ 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}{2023ws/20231019}{loesung-3.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}{2023ws/20231019}{aufgabe-4.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}{2023ws/20231019}{loesung-4.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}{2023ws/20231019}{loesung-4x.c}
+
+ \end{itemize}
+
+\end{document}
diff --git a/20231019/hp-uebung-20231019.pdf b/20231019/hp-uebung-20231019.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..802b54adb373a925f25e6e745496f663bd4e2269
Binary files /dev/null and b/20231019/hp-uebung-20231019.pdf differ
diff --git a/20231019/hp-uebung-20231019.tex b/20231019/hp-uebung-20231019.tex
new file mode 100644
index 0000000000000000000000000000000000000000..7ca234faa1788a56f217f6ea231f1928b47a6686
--- /dev/null
+++ b/20231019/hp-uebung-20231019.tex
@@ -0,0 +1,319 @@
+% hp-uebung-20231019.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: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+ \thispagestyle{empty}
+
+ \section*{Hardwarenahe Programmierung\\
+ Übungsaufgaben -- 19.\ Oktober 2023}
+
+ \exercise{Seltsame Programme}
+
+ Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20211017}
+ finden Sie (unter anderem)\\
+ die Programme \gitfile{hp}{2023ws/20231019}{test-1.c},
+ \gitfile{hp}{2023ws/20231019}{test-2.c} und \gitfile{hp}{2023ws/20231019}{test-3.c}.
+
+ Was bewirken diese Programme, und warum verhalten sie sich so?
+
+ \exercise{Kalender-Berechnung}
+
+ Am 3.\,1.\,2009 meldete \emph{heise online\/}:
+ \begin{quote}
+ Kunden des ersten mobilen Media-Players von Microsoft
+ erlebten zum Jahresende eine böse Überraschung:
+ Am 31.\ Dezember 2008 fielen weltweit alle Zune-Geräte der ersten Generation aus.
+ Ursache war ein interner Fehler bei der Handhabung von Schaltjahren.
+
+ \strut\hfill\url{http://heise.de/-193332},
+ \end{quote}
+ Der Artikel verweist auf ein Quelltextfragment (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-2.c}),
+ das für einen gegebenen Wert \lstinline{days}
+ das Jahr und den Tag innerhalb des Jahres
+ für den \lstinline{days}-ten Tag nach dem 1.\,1.\,1980 berechnen soll:
+ \begin{lstlisting}
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > 365)
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+ \end{lstlisting}
+ Dieses Quelltextfragment enthält schlechten Programmierstil,
+ nämlich mehrere Code-Verdopplungen:
+ \begin{itemize}
+ \item
+ Die Anweisung \lstinline{year += 1} taucht an zwei Stellen auf.
+ \item
+ Es gibt zwei unabhängige Abfragen \lstinline{days > 365} und \lstinline{days > 366}:\\
+ eine in einer \lstinline{while}- und die andere in einer \lstinline{if}-Bedingung.
+ \item
+ Die Länge eines Jahres wird nicht durch eine Funktion berechnet oder in einer Variablen gespeichert;
+ stattdessen werden an mehreren Stellen die expliziten numerischen Konstanten 365 und 366 verwendet.
+ \end{itemize}
+ Diese Probleme führten am 31.\ Dezember 2008 zu einer Endlosschleife.
+
+ Gut hingegen ist die Verwendung einer Konstanten \lstinline{ORIGINYEAR}
+ anstelle der Zahl 1980
+ sowie die Kapselung der Berechnung der Schaltjahr-Bedingung
+ in einer Funktion \lstinline{IsLeapYear()}.
+
+ \begin{itemize}
+ \item[(a)]
+ Erklären Sie das Zustandekommen der Endlosschleife.
+ \item[(b)]
+ Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
+ nicht mehr enthält.
+ \end{itemize}
+
+ \textbf{Hinweis 1:} Verwenden Sie für \lstinline{IsLeapYear()}
+ Ihre eigene Funktion aus Aufgabe 1 der letzten Übung.
+
+ \textbf{Hinweis 2}: Schreiben Sie zusätzlich eine Funktion \lstinline{DaysInYear()}.
+
+ \exercise{Strings}
+
+ Strings werden in der Programmiersprache C
+ durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+ Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-3.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}{2023ws/20231019}{aufgabe-4.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}
+
+\end{document}
+
+% README: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren
+
+\documentclass[a4paper]{article}
+
+\usepackage{pgscript}
+
+\begin{document}
+
+ \thispagestyle{empty}
+
+ \section*{Hardwarenahe Programmierung\\
+ Übungsaufgaben -- 17.\ Oktober 2022}
+
+ \exercise{Seltsame Programme}
+
+ Unter \url{https://gitlab.cvh-server.de/pgerwinski/hp/tree/2022ws/20211017}
+ finden Sie (unter anderem)\\
+ die Programme \gitfile{hp}{2023ws/20231019}{test-1.c},
+ \gitfile{hp}{2023ws/20231019}{test-2.c} und \gitfile{hp}{2023ws/20231019}{test-3.c}.
+
+ Was bewirken diese Programme, und warum verhalten sie sich so?
+
+ \exercise{Kalender-Berechnung}
+
+ Am 3.\,1.\,2009 meldete \emph{heise online\/}:
+ \begin{quote}
+ Kunden des ersten mobilen Media-Players von Microsoft
+ erlebten zum Jahresende eine böse Überraschung:
+ Am 31.\ Dezember 2008 fielen weltweit alle Zune-Geräte der ersten Generation aus.
+ Ursache war ein interner Fehler bei der Handhabung von Schaltjahren.
+
+ \strut\hfill\url{http://heise.de/-193332},
+ \end{quote}
+ Der Artikel verweist auf ein Quelltextfragment (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-2.c}),
+ das für einen gegebenen Wert \lstinline{days}
+ das Jahr und den Tag innerhalb des Jahres
+ für den \lstinline{days}-ten Tag nach dem 1.\,1.\,1980 berechnen soll:
+ \begin{lstlisting}
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > 365)
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+ \end{lstlisting}
+ Dieses Quelltextfragment enthält schlechten Programmierstil,
+ nämlich mehrere Code-Verdopplungen:
+ \begin{itemize}
+ \item
+ Die Anweisung \lstinline{year += 1} taucht an zwei Stellen auf.
+ \item
+ Es gibt zwei unabhängige Abfragen \lstinline{days > 365} und \lstinline{days > 366}:\\
+ eine in einer \lstinline{while}- und die andere in einer \lstinline{if}-Bedingung.
+ \item
+ Die Länge eines Jahres wird nicht durch eine Funktion berechnet oder in einer Variablen gespeichert;
+ stattdessen werden an mehreren Stellen die expliziten numerischen Konstanten 365 und 366 verwendet.
+ \end{itemize}
+ Diese Probleme führten am 31.\ Dezember 2008 zu einer Endlosschleife.
+
+ Gut hingegen ist die Verwendung einer Konstanten \lstinline{ORIGINYEAR}
+ anstelle der Zahl 1980
+ sowie die Kapselung der Berechnung der Schaltjahr-Bedingung
+ in einer Funktion \lstinline{IsLeapYear()}.
+
+ \begin{itemize}
+ \item[(a)]
+ Erklären Sie das Zustandekommen der Endlosschleife.
+ \item[(b)]
+ Schreiben Sie das Quelltextfragment so um, daß es die beschriebenen Probleme
+ nicht mehr enthält.
+ \end{itemize}
+
+ \textbf{Hinweis 1:} Verwenden Sie für \lstinline{IsLeapYear()}
+ Ihre eigene Funktion aus Aufgabe 1 der letzten Übung.
+
+ \textbf{Hinweis 2}: Schreiben Sie zusätzlich eine Funktion \lstinline{DaysInYear()}.
+
+ \exercise{Strings}
+
+ Strings werden in der Programmiersprache C
+ durch Zeiger auf \lstinline{char}-Variable realisiert.
+
+ Wir betrachten die folgende Funktion (Datei: \gitfile{hp}{2023ws/20231019}{aufgabe-3.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}{2023ws/20231019}{aufgabe-4.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}
+
+\end{document}
diff --git a/20231019/loesung-2-4.c b/20231019/loesung-2-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..d141e32582374a3b3e6955f5634191d15edb3709
--- /dev/null
+++ b/20231019/loesung-2-4.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ int DaysInYear;
+ if (IsLeapYear (year))
+ DaysInYear = 366;
+ else
+ DaysInYear = 365;
+
+ while (days > DaysInYear)
+ {
+ days -= DaysInYear;
+ year += 1;
+ if (IsLeapYear (year))
+ DaysInYear = 366;
+ else
+ DaysInYear = 365;
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-5.c b/20231019/loesung-2-5.c
new file mode 100644
index 0000000000000000000000000000000000000000..8a71934b7df24a28d11a6696e212aaccc430277f
--- /dev/null
+++ b/20231019/loesung-2-5.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ int DaysInYear;
+
+ while (days > (DaysInYear = IsLeapYear (year) ? 366 : 365))
+ {
+ days -= DaysInYear;
+ year += 1;
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-6.c b/20231019/loesung-2-6.c
new file mode 100644
index 0000000000000000000000000000000000000000..0605571480991d1ec73a8cec50395ddf68ae3135
--- /dev/null
+++ b/20231019/loesung-2-6.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int DaysInYear (int year)
+{
+ if (IsLeapYear (year))
+ return 366;
+ else
+ return 365;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > DaysInYear (year))
+ {
+ days -= DaysInYear (year);
+ year += 1;
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-7.c b/20231019/loesung-2-7.c
new file mode 100644
index 0000000000000000000000000000000000000000..5c98286730aae146cf587b5f3401eb6eadd17aa7
--- /dev/null
+++ b/20231019/loesung-2-7.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int DaysInYear (int year)
+{
+ if (IsLeapYear (year))
+ return 366;
+ else
+ return 365;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ int d;
+
+ while (days > (d = DaysInYear (year)))
+ {
+ days -= d;
+ year += 1;
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-8.c b/20231019/loesung-2-8.c
new file mode 100644
index 0000000000000000000000000000000000000000..e94dc80375b88fd5ff3245e8a99f76a5955b6bb8
--- /dev/null
+++ b/20231019/loesung-2-8.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int DaysInYear (int year)
+{
+ if (IsLeapYear (year))
+ return 366;
+ else
+ return 365;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ int d = DaysInYear (year);
+
+ while (days > d)
+ {
+ days -= d;
+ year += 1;
+ d = DaysInYear (year);
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-f1.c b/20231019/loesung-2-f1.c
new file mode 100644
index 0000000000000000000000000000000000000000..4d511c4fa7ee6a9dfb0bc2f69412eeb48745af56
--- /dev/null
+++ b/20231019/loesung-2-f1.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > 365)
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-f2.c b/20231019/loesung-2-f2.c
new file mode 100644
index 0000000000000000000000000000000000000000..a44edb09ffde3d3c77cfe673da862260368c33e3
--- /dev/null
+++ b/20231019/loesung-2-f2.c
@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ while ((IsLeapYear (year) && days > 366)
+ || (!IsLeapYear (year) && days > 365))
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-2-f3.c b/20231019/loesung-2-f3.c
new file mode 100644
index 0000000000000000000000000000000000000000..dbfe5040274953c3b90d6b2da194c0c8ae64f04f
--- /dev/null
+++ b/20231019/loesung-2-f3.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+
+int IsLeapYear (int year)
+{
+ if (year % 4)
+ return 0;
+ else if (year % 100)
+ return 1;
+ else if (year % 400)
+ return 0;
+ else
+ return 1;
+}
+
+int main (void)
+{
+ int ORIGINYEAR = 1980;
+ int days = 366;
+ int year;
+
+ year = ORIGINYEAR; /* = 1980 */
+
+ while (days > (IsLeapYear (year) ? 366 : 365))
+ {
+ if (IsLeapYear (year))
+ {
+ if (days > 366)
+ {
+ days -= 366;
+ year += 1;
+ }
+ }
+ else
+ {
+ days -= 365;
+ year += 1;
+ }
+ }
+
+ printf ("year = %d\ndays = %d\n", year, days);
+ return 0;
+}
diff --git a/20231019/loesung-3.c b/20231019/loesung-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..29a2b7f234ea5c31b06780e9dd461dff95dd33a3
--- /dev/null
+++ b/20231019/loesung-3.c
@@ -0,0 +1,67 @@
+#include <stdio.h>
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int main (void)
+{
+ char *s1 = "Apfel";
+ char *s2 = "Apfelkuchen";
+ if (fun_1 (s1, s2) && fun_2 (s1, s2) && fun_3 (s1, s2) && fun_4 (s1, s2))
+ printf ("OK\n");
+ else
+ printf ("failed\n");
+ s1 = "Apfelkuchen";
+ s2 = "Apfel";
+ if (fun_1 (s1, s2) && fun_2 (s1, s2) && fun_3 (s1, s2) && fun_4 (s1, s2))
+ printf ("OK\n");
+ else
+ printf ("failed\n");
+ s2 = "Birnenmarmelade";
+ if (fun_1 (s1, s2) || fun_2 (s1, s2) || fun_3 (s1, s2) || fun_4 (s1, s2))
+ printf ("failed\n");
+ else
+ printf ("OK\n");
+ s1 = s2;
+ s2 = "Apfelkuchen";
+ if (fun_1 (s1, s2) || fun_2 (s1, s2) || fun_3 (s1, s2) || fun_4 (s1, s2))
+ printf ("failed\n");
+ else
+ printf ("OK\n");
+ return 0;
+}
diff --git a/20231019/loesung-4.c b/20231019/loesung-4.c
new file mode 100644
index 0000000000000000000000000000000000000000..6346384a81d62e7e687f4db99be3ba8fe4020744
--- /dev/null
+++ b/20231019/loesung-4.c
@@ -0,0 +1 @@
+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;}
diff --git a/20231019/loesung-4x.c b/20231019/loesung-4x.c
new file mode 100644
index 0000000000000000000000000000000000000000..fcc65e153ddf009f55af118278774cd202f7c316
--- /dev/null
+++ b/20231019/loesung-4x.c
@@ -0,0 +1,2 @@
+#include<stdio.h>
+char*f="#include<stdio.h>%cchar*f=%c%s%c;int main(void){printf(f,10,34,f,34,10);return 0;}%c";int main(void){printf(f,10,34,f,34,10);return 0;}
diff --git a/20231019/logo-hochschule-bochum-cvh-text-v2.pdf b/20231019/logo-hochschule-bochum-cvh-text-v2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..4aa99b8f81061aca6dcaf43eed2d9efef40555f8
--- /dev/null
+++ b/20231019/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/20231019/logo-hochschule-bochum.pdf b/20231019/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20231019/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20231019/pgscript.sty b/20231019/pgscript.sty
new file mode 120000
index 0000000000000000000000000000000000000000..95c888478c99ea7fda0fd11ccf669ae91be7178b
--- /dev/null
+++ b/20231019/pgscript.sty
@@ -0,0 +1 @@
+../common/pgscript.sty
\ No newline at end of file
diff --git a/20231019/pgslides.sty b/20231019/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20231019/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file
diff --git a/20231019/test-1.c b/20231019/test-1.c
new file mode 100644
index 0000000000000000000000000000000000000000..9dcb8ff47664fe804b3c9973166afe0d28b53ade
--- /dev/null
+++ b/20231019/test-1.c
@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main (void)
+{
+ return
+ printf ("Hello, world!\n"),
+ 0;
+}
diff --git a/20231019/test-2.c b/20231019/test-2.c
new file mode 100644
index 0000000000000000000000000000000000000000..216c924cde653228187b133b1a899765eb865584
--- /dev/null
+++ b/20231019/test-2.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int main (void)
+{
+ int a = 137;
+ int b = 13 * a;
+ if (b = 42)
+ printf ("Die Antwort lautet: %d\n", b);
+ else
+ printf ("Die Antwort lautet: keine Ahnung\n");
+ return 0;
+}
diff --git a/20231019/test-3.c b/20231019/test-3.c
new file mode 100644
index 0000000000000000000000000000000000000000..b8964c8308aec57ed4de30acae8c3e3d31b9fa38
--- /dev/null
+++ b/20231019/test-3.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main (void)
+{
+ int a = 42;
+ printf ("Die Antwort lautet: ");
+ printf (a);
+ return 0;
+}
diff --git a/README.md b/README.md
index 2ace90665843143326fe32d0d9e0df95a38a549a..4033d36906f26587022f0fa14b9623efdfd40d1f 100644
--- a/README.md
+++ b/README.md
@@ -19,16 +19,19 @@ Vortragsfolien und Beispiele:
-----------------------------
* [05.10.2023: Einführung, Einführung in C (bis 2.7: Strukturierte Programmierung)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231005/hp-20231005.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231005/)
* [12.10.2023: Einführung in C (ab 2.8: Seiteneffekte)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231012/hp-20231012.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231012/)
+ * [19.10.2023: Einführung in C (ab 2.11: Arrays und Strings)](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-20231019.pdf) [**(Beispiele)**](https://gitlab.cvh-server.de/pgerwinski/hp/tree/2023ws/20231019/)
* [alle in 1 Datei](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/hp-slides-2023ws.pdf)
Übungsaufgaben:
---------------
* [05.10.2023: Hello-World-Programme, Schaltjahr ermitteln, Maximum berechnen](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231005/hp-uebung-20231005.pdf)
* [12.10.2023: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231012/hp-uebung-20231012.pdf)
+ * [19.10.2023: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-uebung-20231019.pdf)
Musterlösungen:
---------------
* [12.10.2023: Schaltjahr ermitteln, Multiplikationstabelle, Fibonacci-Zahlen, fehlerhaftes Programm](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231012/hp-musterloesung-20231012.pdf)
+ * [19.10.2023: Seltsame Programme, Kalender-Berechnung, Strings, Programm analysieren](https://gitlab.cvh-server.de/pgerwinski/hp/raw/2023ws/20231019/hp-musterloesung-20231019.pdf)
Praktikumsunterlagen:
---------------------
diff --git a/hp-slides-2023ws.pdf b/hp-slides-2023ws.pdf
index 4d5db7364d2cc82f44196bd6b647a252f14b182c..b1442153c8d1d391ed95209a412afd12f4768fd1 100644
Binary files a/hp-slides-2023ws.pdf and b/hp-slides-2023ws.pdf differ
diff --git a/hp-slides-2023ws.tex b/hp-slides-2023ws.tex
index 884af13404add23b3074b799135a477c7e4c6317..585323fb35ae2742d5b8fecd872cbfcb278e1c84 100644
--- a/hp-slides-2023ws.tex
+++ b/hp-slides-2023ws.tex
@@ -15,4 +15,6 @@
\includepdf[pages=-]{20231005/hp-20231005.pdf}
\pdfbookmark[1]{12.10.2023: Einführung in C (ab 2.8: Seiteneffekte)}{20231012}
\includepdf[pages=-]{20231012/hp-20231012.pdf}
+ \pdfbookmark[1]{19.10.2023: Einführung in C (ab 2.11: Arrays und Strings)}{20231019}
+ \includepdf[pages=-]{20231019/hp-20231019.pdf}
\end{document}