diff --git a/exercises/Aufgaben.tex b/exercises/Aufgaben.tex
new file mode 100644
index 0000000..3a04722
--- /dev/null
+++ b/exercises/Aufgaben.tex
@@ -0,0 +1,131 @@
+%%& -job-name=Aufgaben1_16WS_v1
+\documentclass[accentcolor=tud3c,colorbacktitle,12pt]{tudexercise}
+\usepackage[T1]{fontenc}
+%\usepackage[utf8]{inputenc}
+%\usepackage[ngerman]{babel}
+\input{../shared/globalCommon}
+\usepackage{hyperref}
+\usepackage{ifthen}
+\usepackage{listings}
+%\usepackage{graphicx}
+\usepackage{multicol}
+\usepackage{multirow}
+
+
+\definecolor{darkblue}{rgb}{0,0,.5}
+\hypersetup{colorlinks=true, breaklinks=true, linkcolor=darkblue, menucolor=darkblue, urlcolor=darkblue}
+
+% configuration
+\makeatletter
+\@ifundefined{c@ex}{
+  \newcounter{ex}\setcounter{ex}{1}
+}{}
+\makeatother
+\newboolean{sln}\setboolean{sln}{false}
+\newboolean{SoSe}\setboolean{SoSe}{false}
+\newcounter{nextyear}\setcounter{nextyear}{\year+1}
+%
+
+\newcommand{\ext}{py}
+\newcommand{\sln}[1]{\ifthenelse{\boolean{sln}}{\subsubsection*{Antwort}{\itshape #1}}{}}
+\newcommand{\slnformat}[1]{\ifthenelse{\boolean{sln}}{#1}{}}
+\newcommand{\taskformat}[1]{\ifthenelse{\boolean{sln}}{}{#1}}
+\newcommand{\task}[1]{\input{task/#1}\IfFileExists{./sln/#1.tex}{\sln{\input{sln/#1}}}{\IfFileExists{./sln/#1.\ext}{\sln{\pythonfile{sln/#1.\ext}}}{\ClassError{Vorkurs-TeX}{No solution specified for task #1}{Add solution file #1.tex or #1.\ext}}}}
+\newcommand{\mccmd}{Kreuze zu jeder Antwort an, ob sie zutrifft (\textbf{w}) oder nicht (\textbf{f}).}
+\newcommand{\mchead}{\item[\textbf{w} \textbf{f} ]}
+\newcommand{\mcitem}[1]{\item[$\square\ \square$] #1}
+\newcommand{\mcitemt}[1]{\item[$\ifthenelse{\boolean{sln}}{\blacksquare}{\square}\ \square$] #1}
+\newcommand{\mcitemf}[1]{\item[$\square\ \ifthenelse{\boolean{sln}}{\blacksquare}{\square}$] #1}
+\newcommand{\ptitle}{\ifthenelse{\boolean{SoSe}}{Sommersemester \the\year}{Wintersemester \the\year/\thenextyear}}
+
+\newcommand{\lstinlinenoit}[1]{\upshape{\lstinline|#1|}\itshape}
+\lstset{language=Python, basicstyle=\ttfamily\small, keywordstyle=\color{blue!80!black}, identifierstyle=, commentstyle=\color{green!50!black}, stringstyle=\ttfamily,
+ tabsize=4, breaklines=true, numbers=left, numberstyle=\small, frame=single, backgroundcolor=\color{blue!3}}
+\author{Fachschaft Informatik}
+
+
+\newcommand{\stage}[1]{(\ifcase#1\or{Einstieg}\or{Vertiefung}\or{Herausforderung}\else\fi)}
+\newcommand{\bonus}[1]{\textit{BonusFact: }#1}
+
+\begin{document}
+\title{Aufgaben Programmiervorkurs\\Übungsblatt \theex}
+\subtitle{von der Fachschaft Informatik\hfill\ptitle}
+\maketitle
+
+\ifcase\value{ex}
+\or%ex1
+    \section{Einleitung \stage1}
+        \task{1-intro}
+        \task{1-mc-interpreter}\taskformat{\clearpage}
+    \section{Ausdrücke \stage1}
+        \task{1-interactive}
+        \task{1-operations}\taskformat{\clearpage}\slnformat{\clearpage}
+    \section{Konvertierung \stage2}
+        \task{1-conversion}
+        \task{1-conv-challenge}\slnformat{\clearpage}
+	\section{Fehler}
+        \task{1-error}
+		\task{1-warmup-error}
+    \section{Challenge}
+        \task{1-modulo}
+\or%ex2
+        \task{2-pyfile}
+	\section{Zum Aufwärmen \stage1}\mccmd
+		\task{2-mc-if}
+	\section{Variablen \stage1}
+		\task{2-var-case}\slnformat{\clearpage}
+		\task{2-var-id}\taskformat{\clearpage}
+		\task{2-var-assign}\slnformat{\clearpage}
+	\section{Logische Operationen \stage1}
+		\task{2-stm-ops}\taskformat{\clearpage}
+	\section{Eingabe/Ausgabe \stage2}
+		\task{2-var-io}
+		\task{2-stm-calc}\taskformat{\clearpage}\slnformat{\clearpage}
+	\section{Zum Weiterdenken \stage3}
+		\task{2-cooking}\taskformat{\clearpage}\slnformat{\clearpage}
+		\task{2-var-processor}
+\or%ex3
+    \section{Schleifen}
+		\task{3-loop-gauss}
+        \task{3-loop-fac}
+        \task{3-loop-fizz}\taskformat{\clearpage}\slnformat{\clearpage}
+        \task{3-loop-prime}\slnformat{\clearpage}
+	\section{Listige Listen}
+		\task{3-list-basic}
+        \task{3-list-len}
+	\section{Fortgeschrittenes Lesen}
+        \task{3-slicing}
+        \task{3-slicing-examples}\slnformat{\clearpage}
+	\section{Listenverarbeitung}
+        \task{3-iterable}
+        \task{3-text-slicing}\slnformat{\clearpage}
+        \task{3-accumulator}
+	\section{Challenge}
+		\task{3-challenge}
+\or%ex4
+	\section{Funktionen}
+		\task{4-fnc-calcr}\slnformat{\clearpage}
+		\task{4-fnc-calcr2}\slnformat{\clearpage}
+	\section{Schriftliches Dividieren}
+		\task{4-fnc-divide-theory}\slnformat{\clearpage}
+		\task{4-fnc-divide-basic}\slnformat{\clearpage}
+		\task{4-fnc-divide-advanced}\slnformat{\clearpage}
+	\section{Listen und Funktionen}
+		\task{4-list-fnc}\slnformat{\clearpage}
+	\section{Rekursion}
+		\task{4-rec-fac}
+		\task{4-rec-pascal}\slnformat{\clearpage}
+		\task{4-rec-fib}\slnformat{\clearpage}
+		\task{4-rec-oddeven}\slnformat{\clearpage}
+		\task{4-rec-calcu}\taskformat{\clearpage}
+		\task{4-rec-calcu2}
+	\section{Zusatz}
+		Wenn du die Aufgaben erledigt hast, kannst du dich gerne noch an den Schleifen-Varianten der gegebenen Algorithmen versuchen oder für Aufgaben der vergangenen Tage eine rekursive Lösung suchen. Die Tutoren stehen dir dabei gerne bei, allerdings werden wir dafür keine Lösungen bereit stellen. Du kannst die jeweiligen Versionen der Algorithmen in den Lösungen als Kontrolle für deine Versuche nutzen.
+\or%ex5 - nicht veröffentlicht
+	\section{Pool}
+	\section{Sichtbarkeit}
+	\section{Ausdrücke evaluieren}
+\else\fi
+\end{document}
+\grid
+\grid
diff --git a/exercises/Makefile b/exercises/Makefile
new file mode 100755
index 0000000..310d06a
--- /dev/null
+++ b/exercises/Makefile
@@ -0,0 +1,28 @@
+IN = Aufgaben.tex
+SHIPDIR = _build
+POST = $(shell /bin/bash -c 'if which pplatex > /dev/null; then echo "| pplatex -i -"; else echo "> /dev/null"; fi')
+PDFLATEX = pdflatex -interaction=nonstopmode
+
+all:	 $(shell /bin/bash -c 'echo Aufgabe_{1,2,3,4}_{sol,nosol}.pdf') ship clean
+
+Aufgabe_%: Aufgabe_%_sol.pdf Aufgabe_%_nosol.pdf
+
+Aufgabe_%_nosol.pdf: Aufgaben_nosol.tex
+	$(PDFLATEX) -jobname="Übung_$*" -shell-escape "\newcounter{ex} \setcounter{ex}{$*} \input{Aufgaben_nosol.tex}" $(POST)
+
+Aufgabe_%_sol.pdf: Aufgaben_sol.tex
+	$(PDFLATEX) -jobname="Lösung_$*" -shell-escape "\newcounter{ex} \setcounter{ex}{$*} \input{Aufgaben_sol.tex}" $(POST)
+
+Aufgaben_nosol.tex: Aufgaben.tex
+	sed -r s/'\\setboolean\{sln\}\{(true|false)\}'/"\\\\setboolean{sln}{false}"/ $(IN) > Aufgaben_nosol.tex
+
+Aufgaben_sol.tex: Aufgaben.tex
+	sed -r s/'\\setboolean\{sln\}\{(true|false)\}'/"\\\\setboolean{sln}{true}"/ $(IN) > Aufgaben_sol.tex
+
+ship:
+	mkdir -p $(SHIPDIR)
+	mv *.pdf $(SHIPDIR)
+
+clean:
+	rm -f *.aux *.log *.out Aufgaben_*sol.tex *.pdf
+	rm -rf _minted*
diff --git a/exercises/sln/1-conv-challenge.tex b/exercises/sln/1-conv-challenge.tex
new file mode 100644
index 0000000..c3c0807
--- /dev/null
+++ b/exercises/sln/1-conv-challenge.tex
@@ -0,0 +1,5 @@
+\begin{lstlisting}
+>>> int(str(int('1') + int('1') + int('1')) + str(0) + str(0) + str(0))
+3000
+\end{lstlisting}
+Es gibt natürlich auch noch andere Möglichkeiten.
diff --git a/exercises/sln/1-conversion.tex b/exercises/sln/1-conversion.tex
new file mode 100644
index 0000000..3b6d0ff
--- /dev/null
+++ b/exercises/sln/1-conversion.tex
@@ -0,0 +1,14 @@
+\begin{multicols}{3}
+\begin{enumerate}
+    \item \pythoninline{100}
+    \item \pythoninline{1.3}
+    \item \pythoninline{nan}
+    \item \pythoninline{'234'}
+    \item \textbf{ValueError}
+    \item \pythoninline{'25'}
+    \item \pythoninline{'7'}
+    \item \pythoninline{5.0}
+    \item \pythoninline{5}
+    \item \textbf{ValueError}
+\end{enumerate}
+\end{multicols}
diff --git a/exercises/sln/1-error.tex b/exercises/sln/1-error.tex
new file mode 100644
index 0000000..631a837
--- /dev/null
+++ b/exercises/sln/1-error.tex
@@ -0,0 +1,9 @@
+\begin{enumerate}
+    \item \pythoninline{true} ist ein falsch geschriebenes Schlüsselwort und
+        somit ein \\ lexikalischer Fehler (\textbf{NameError}, \dots)
+    \item \pythoninline{4 +* 5} sind Operatoren, denen ein Parameter dazwischen
+        fehlt, somit ein
+        \\ syntaktischer Fehler (\textbf{SyntaxError}, \textbf{IndentationError}, \dots)
+    \item \pythoninline{2 / 0} ist eine undefinierte Rechnung, also ein
+        \\ semantischer Fehler (\textbf{ZeroDivisionError}, \textbf{ValueError}, \dots)
+\end{enumerate}
diff --git a/exercises/sln/1-interactive.tex b/exercises/sln/1-interactive.tex
new file mode 100644
index 0000000..df55bbe
--- /dev/null
+++ b/exercises/sln/1-interactive.tex
@@ -0,0 +1,5 @@
+Zahlen ohne Anführungszeichen ergeben die Zahl. Rationale Zahlen brauchen einen
+Dezimal\textbf{punkt}. Anführungszeichen (\texttt{'}, \texttt{"}) ergeben Strings,
+der Prefix \texttt{0x} erwartet hexadezimales Format, der Prefix \texttt{0b}
+binäres Format. Wahrheitswerte müssen groß geschrieben werden (\texttt{True},
+\texttt{False})
diff --git a/exercises/sln/1-intro.tex b/exercises/sln/1-intro.tex
new file mode 100644
index 0000000..b553427
--- /dev/null
+++ b/exercises/sln/1-intro.tex
@@ -0,0 +1,4 @@
+Python ist installiert und dem Pfad hinzugefügt. Der Befehl
+\texttt{python ----version} gibt eine Versionsnummer von mindestens \textit{3.4.0}
+aus, oder der Befehl \texttt{python3} wird verwendet. Der Python Interpreter
+wurde gestartet.
diff --git a/exercises/sln/1-mc-interpreter.tex b/exercises/sln/1-mc-interpreter.tex
new file mode 100755
index 0000000..f7fa208
--- /dev/null
+++ b/exercises/sln/1-mc-interpreter.tex
@@ -0,0 +1 @@
+Die zutreffenden Antworten sind die Aussagen 1 und 3.
diff --git a/exercises/sln/1-modulo.tex b/exercises/sln/1-modulo.tex
new file mode 100644
index 0000000..fc886ec
--- /dev/null
+++ b/exercises/sln/1-modulo.tex
@@ -0,0 +1,13 @@
+Ein Beispiel wäre die folgende Rechnung:
+\begin{lstlisting}
+>>> (13 ** 3) % 33
+19
+>>> (19 ** 7) % 33
+13
+\end{lstlisting}
+
+Um Strings damit zu verschlüsseln/entschlüsseln, könnte man diese Funktionen verwenden:
+\begin{lstlisting}
+>>> enc = lambda x: [(ord(c) - ord('a')) ** 3 % 33 for c in x if ord('a') <= ord(c) and ord(c) <= ord('z')]
+>>> dec = lambda x: "".join([chr((v ** 7 % 33) + ord('a')) for v in x if 0 <= v and v < 33])
+\end{lstlisting}
diff --git a/exercises/sln/1-operations.tex b/exercises/sln/1-operations.tex
new file mode 100644
index 0000000..acc8217
--- /dev/null
+++ b/exercises/sln/1-operations.tex
@@ -0,0 +1,5 @@
+Das Ergebnis ist meistens eine Variante von 42. Wichtig ist, dass hier
+Punkt- vor Strichrechnung gilt. Der \texttt{**} Operator potenziert.
+String mal Zahl ergibt eine Wiederholung des Strings. Die letzte Aufgabe
+betont, dass manche Operationen auf Kommazahlen keine genauen Ergebnisse
+liefern.
diff --git a/exercises/sln/1-warmup-error.tex b/exercises/sln/1-warmup-error.tex
new file mode 100755
index 0000000..fcc12c6
--- /dev/null
+++ b/exercises/sln/1-warmup-error.tex
@@ -0,0 +1,10 @@
+\begin{enumerate}
+	\item \texttt{NameError: name 'prinnt' is not defined}: Ein \textcolor{red}{Lexikalischer Fehler}, da es keine Funktion mit dem angegebenen Namen
+		\texttt	{prinnt} gibt. Gültig wäre \texttt{print}. Ein klassische Tippfehler.
+	\item \texttt{SyntaxError: invalid syntax}: Ein \textcolor{red}{Syntaktischer Fehler}, da Strings immer in einfachen oder doppelten Anführungszeichen
+		stehen müssen.
+	\item \texttt{TypeError: must be str, not int}: Ein \textcolor{red}{Semantischer Fehler}, da Texte und Zahlen nicht eindeutig addierbar sind.
+		\textbf{Bonus Fact}: Um irgendeinen Wert in einen String zu verwandeln gibt es die Funktion \texttt{str(...)}
+	\item \texttt{SyntaxError: EOL while scanning string literal}: Ein \textcolor{red}{Syntaktischer Fehler}, da der Rest der Zeile nun auch als String
+		gelesen wird, der aber nie endet.
+\end{enumerate}
diff --git a/exercises/sln/2-cooking.py b/exercises/sln/2-cooking.py
new file mode 100644
index 0000000..d9ed6cf
--- /dev/null
+++ b/exercises/sln/2-cooking.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+Mehl = 450
+Wasser = 250
+Salz = 1
+Oliven = 4
+Backpulver = 2
+Tomaten = 400
+Oregano = 1
+Knoblauch = 1
+z = input("Zutat eingeben: ")
+m = float(input("Menge eingeben (ohne Einheit): "))
+Zutatenliste = "Zutatenliste: \n Mehl: {0} g \n Wasser: {1} ml \n Salz: {2} TL, gestrichen \n Olivenöl: {3} EL \n Backpulver: {4} TL \n passierte Tomaten: {5} g \n Oregano {6} EL \n Knoblauch {7} Zehe(n)"
+if z == "Mehl":
+    factor = m / Mehl
+    print(Zutatenliste.format(m, factor * Wasser, factor * Salz, factor * Oliven, factor * Backpulver, factor * Tomaten, factor * Oregano, factor * Knoblauch))
+elif z == "Wasser":
+    factor = m / Wasser
+    print(Zutatenliste.format(factor * Mehl, m, factor * Salz, factor * Oliven, factor * Backpulver, factor * Tomaten, factor * Oregano, factor * Knoblauch))
+elif z == "Salz":
+    factor = m / Salz
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, m, factor * Oliven, factor * Backpulver, factor * Tomaten, factor * Oregano, factor * Knoblauch))
+elif z == "Olivenöl":
+    factor = m / Oliven
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, factor * Salz, m, factor * Backpulver, factor * Tomaten, factor * Oregano, factor * Knoblauch))
+elif z == "Backpulver":
+    factor = m / Backpulver
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, factor * Salz, factor * Oliven, m, factor * Tomaten, factor * Oregano, factor * Knoblauch))
+elif z == "Tomaten":
+    factor = m / Tomaten
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, factor * Salz, factor * Oliven, factor * Backpulver, m, factor * Oregano, factor * Knoblauch))
+elif z == "Oregano":
+    factor = m / Oregano
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, factor * Salz, factor * Oliven, factor * Backpulver, factor * Tomaten, m, factor * Knoblauch))
+elif z == "Knoblauch":
+    factor = m / Knoblauch
+    print(Zutatenliste.format(factor * Mehl, factor * Wasser, factor * Salz, factor * Oliven, factor * Backpulver, factor * Tomaten, factor * Oregano, m))
+else:
+    print("Eingabe nicht erkannt")
diff --git a/exercises/sln/2-mc-if.tex b/exercises/sln/2-mc-if.tex
new file mode 100644
index 0000000..c5a6d63
--- /dev/null
+++ b/exercises/sln/2-mc-if.tex
@@ -0,0 +1 @@
+Die erste und dritte Aussage treffen zu.
\ No newline at end of file
diff --git a/exercises/sln/2-pyfile.tex b/exercises/sln/2-pyfile.tex
new file mode 100644
index 0000000..032a99b
--- /dev/null
+++ b/exercises/sln/2-pyfile.tex
@@ -0,0 +1 @@
+Eine Python Datei kann erstellt und ausgeführt werden.
diff --git a/exercises/sln/2-stm-calc.py b/exercises/sln/2-stm-calc.py
new file mode 100644
index 0000000..55b27ec
--- /dev/null
+++ b/exercises/sln/2-stm-calc.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+op1 = int(input("Wie lautet der erste Operand: "))
+op2 = int(input("Wie lautet der zweite Operand: "))
+op = input("Wie lautet der Operator: ")
+
+if op == "+":
+	print("Das Ergebnis lautet:", op1 + op2)
+elif op == "-":
+	print("Das Ergebnis lautet:", op1 - op2)
+elif op == "*":
+	print("Das Ergebnis lautet:", op1 * op2)
+elif op == "/":
+	print("Das Ergebnis lautet:", op1 / op2)
+else:
+	print("Keine gültige Eingabe!")
diff --git a/exercises/sln/2-stm-ops.tex b/exercises/sln/2-stm-ops.tex
new file mode 100644
index 0000000..b09c5f2
--- /dev/null
+++ b/exercises/sln/2-stm-ops.tex
@@ -0,0 +1,10 @@
+\begin{multicols}{3}
+\begin{enumerate}
+	\item \lstinline{b == True}
+	\item \lstinline{b == False}
+	\item \lstinline{b == True}
+	\item \lstinline{b == True}
+	\item \lstinline{b == False}
+	\item \lstinline{b == True}
+\end{enumerate}
+\end{multicols}
\ No newline at end of file
diff --git a/exercises/sln/2-var-assign.tex b/exercises/sln/2-var-assign.tex
new file mode 100644
index 0000000..33a25fa
--- /dev/null
+++ b/exercises/sln/2-var-assign.tex
@@ -0,0 +1,6 @@
+Zuweisung 1: variable1 = 2 \\
+Zuweisung 2: variable3 = 1 \\
+Zuweisung 3: variable1 = 'b' \\
+Zuweisung 4: variable3 = 'a' \\
+Zuweisung 5: variable1 = 11 \\
+Es gibt natürlich auch noch andere Möglichkeiten
\ No newline at end of file
diff --git a/exercises/sln/2-var-case.tex b/exercises/sln/2-var-case.tex
new file mode 100644
index 0000000..1820bb9
--- /dev/null
+++ b/exercises/sln/2-var-case.tex
@@ -0,0 +1 @@
+Die Variable in Zeile 2 müsste \textbf{m}einAlter heißen und nicht \textbf{M}einAlter.
\ No newline at end of file
diff --git a/exercises/sln/2-var-id.tex b/exercises/sln/2-var-id.tex
new file mode 100644
index 0000000..14120cf
--- /dev/null
+++ b/exercises/sln/2-var-id.tex
@@ -0,0 +1 @@
+Die Antworten c), e) und i) sind nicht gültig.\\Gültig sind somit: Matrikelnummer, ÄhmKeineAhnung, {\_}meinAlter, {\_}2Euro, Variable2, noch$\_$besser
\ No newline at end of file
diff --git a/exercises/sln/2-var-io.py b/exercises/sln/2-var-io.py
new file mode 100644
index 0000000..a1df2dd
--- /dev/null
+++ b/exercises/sln/2-var-io.py
@@ -0,0 +1,7 @@
+#!/usr/bin/python3
+name = input("Bitte gib deinen Namen ein: ")
+tag = int(input("Gib den Tag deiner Geburt ein: "))
+monat = int(input("Gib den Monat deiner Geburt ein: "))
+jahr = int(input("Gib das Jahr deiner Geburt ein: "))
+
+print("{0} hat am {1}.{2}.{3} Geburtstag.".format(name, tag, monat, jahr))
\ No newline at end of file
diff --git a/exercises/sln/2-var-processor.py b/exercises/sln/2-var-processor.py
new file mode 100644
index 0000000..5739fe1
--- /dev/null
+++ b/exercises/sln/2-var-processor.py
@@ -0,0 +1,25 @@
+a = int(input("Zahl a einlesen: "))
+b = int(input("Zahl b einlesen: "))
+c = int(input("Zahl c einlesen: "))
+d = 2 * a
+a = d + 3
+d = int(input("Zahl d einlesen: "))
+print(b)
+print(c)
+c = a > d
+if c:
+    d = a
+c = a < d
+if c:
+    c = d - a
+b = a * a
+a = b
+b = c * d
+c = a + b
+a = c
+b = a + d
+c = b + d
+print(a)
+print(b)
+print(c)
+print(d)
diff --git a/exercises/sln/3-accumulator.py b/exercises/sln/3-accumulator.py
new file mode 100644
index 0000000..50e3580
--- /dev/null
+++ b/exercises/sln/3-accumulator.py
@@ -0,0 +1,15 @@
+lst = [1,2,3,4,5,6,7]
+
+sum = 0
+product = 1
+quadrate = []
+
+for l in lst:
+    sum += l
+    product *= l
+    quadrate.append(l * l)
+
+print(sum)
+print(product)
+print(sum / len(list) if lst else "Leere Liste!")
+print(quadrate)
diff --git a/exercises/sln/3-challenge.tex b/exercises/sln/3-challenge.tex
new file mode 100755
index 0000000..e69de29
diff --git a/exercises/sln/3-iterable.py b/exercises/sln/3-iterable.py
new file mode 100644
index 0000000..f360a65
--- /dev/null
+++ b/exercises/sln/3-iterable.py
@@ -0,0 +1,4 @@
+print(list(range(1,8)))
+print(list(range(5)))
+print(list(range(4,11,2)))
+print(list(range(9,0,-3)))
diff --git a/exercises/sln/3-list-basic.py b/exercises/sln/3-list-basic.py
new file mode 100644
index 0000000..a4e8372
--- /dev/null
+++ b/exercises/sln/3-list-basic.py
@@ -0,0 +1,4 @@
+# lst = ...
+print(lst[1] + lst[2] + lst[7])
+print(lst[1] * lst[3] * lst[5] * lst[7])
+print(lst[0] * 300)
diff --git a/exercises/sln/3-list-len.py b/exercises/sln/3-list-len.py
new file mode 100644
index 0000000..d75bf85
--- /dev/null
+++ b/exercises/sln/3-list-len.py
@@ -0,0 +1,10 @@
+list = [1,2,3,4,5]
+# Da die Indices bei 0 anfangen ist len(list) - 1 der letzte gültige Index.
+# ------------------------
+index = 0
+while index < len(list):
+    print(list[index])
+    index += 1
+# ------------------------
+for i in range(len(list)):
+    print(list[i])
diff --git a/exercises/sln/3-loop-fac.py b/exercises/sln/3-loop-fac.py
new file mode 100755
index 0000000..17ed60a
--- /dev/null
+++ b/exercises/sln/3-loop-fac.py
@@ -0,0 +1,7 @@
+fak = int(input("Welche Fakultaet soll berechnet werden: "))
+erg = 1;
+
+for i in range(1,fak+1):
+	erg *= i;
+
+print("Die {0}. Fakultaet ist {1}".format(fak, erg))
diff --git a/exercises/sln/3-loop-fizz.py b/exercises/sln/3-loop-fizz.py
new file mode 100755
index 0000000..dc7c67e
--- /dev/null
+++ b/exercises/sln/3-loop-fizz.py
@@ -0,0 +1,9 @@
+for i in range(1,101):
+	if i % 3 == 0 and i % 5 == 0:
+		print("FizzBuzz")
+	elif(i % 3 == 0):
+		print("Fizz")
+	elif(i % 5 == 0):
+		print("Buzz")
+	else:
+		print(i)
diff --git a/exercises/sln/3-loop-gauss.py b/exercises/sln/3-loop-gauss.py
new file mode 100755
index 0000000..9b8ff33
--- /dev/null
+++ b/exercises/sln/3-loop-gauss.py
@@ -0,0 +1,6 @@
+sum = 0
+
+for i in range(1,101):
+	sum += i
+
+print("Die Summe der ersten 100 Zahlen ist {0}".format(sum))
diff --git a/exercises/sln/3-loop-prime.py b/exercises/sln/3-loop-prime.py
new file mode 100755
index 0000000..9980259
--- /dev/null
+++ b/exercises/sln/3-loop-prime.py
@@ -0,0 +1,12 @@
+prim = int(input("Gib bitte eine Zahl ein: "))
+isPrim = True
+
+for i in range(2, prim)
+	if(prim % i == 0):
+		isPrim = false
+		break
+
+if isPrim:
+	print("{0} ist eine Primzahl!".format(prim))
+else:
+	print("{0} ist keine Primzahl!".format(prim))
diff --git a/exercises/sln/3-slicing-examples.py b/exercises/sln/3-slicing-examples.py
new file mode 100644
index 0000000..a7f16f9
--- /dev/null
+++ b/exercises/sln/3-slicing-examples.py
@@ -0,0 +1,7 @@
+lst = [1,2,3,4,5,6,7,8,9]
+print(lst[:])      # [1, 2, 3, 4, 5, 6, 7, 8, 9]
+print(lst[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1]
+print(lst[1::2])   # [2, 4, 6, 8]
+print(lst[:7:3])   # [1, 4, 7]
+print(lst[6:2:-1]) # [7, 6, 5, 4]
+print(lst[0:1])    # [1]
diff --git a/exercises/sln/3-slicing.tex b/exercises/sln/3-slicing.tex
new file mode 100644
index 0000000..2150562
--- /dev/null
+++ b/exercises/sln/3-slicing.tex
@@ -0,0 +1,2 @@
+Es werden \pythoninline{a=0}, \pythoninline{b=len(lst)} und \pythoninline{c=1}
+verwendet.
diff --git a/exercises/sln/3-text-slicing.py b/exercises/sln/3-text-slicing.py
new file mode 100644
index 0000000..64b5d0e
--- /dev/null
+++ b/exercises/sln/3-text-slicing.py
@@ -0,0 +1,12 @@
+# effiziente Lösung (minimale vergleiche)
+voll = len(test)
+halb = int(voll/2)
+if test[:halb] == test[voll:voll-halb-1:-1]:
+    print("Palindrom")
+else:
+    print("Kein Palindrom")
+# Kurze Lösung
+if test == test[::-1]:
+    print("Palindrom")
+else:
+    print("Kein Palindrom")
diff --git a/exercises/sln/4-fnc-calcr.tex b/exercises/sln/4-fnc-calcr.tex
new file mode 100644
index 0000000..edfe4f1
--- /dev/null
+++ b/exercises/sln/4-fnc-calcr.tex
@@ -0,0 +1 @@
+siehe nächste Teilaufgabe
\ No newline at end of file
diff --git a/exercises/sln/4-fnc-calcr2.py b/exercises/sln/4-fnc-calcr2.py
new file mode 100644
index 0000000..fd83d99
--- /dev/null
+++ b/exercises/sln/4-fnc-calcr2.py
@@ -0,0 +1,36 @@
+
+def plus(op1, op2):
+    return op1 + op2
+
+
+def minus(op1, op2):
+    return op1 - op2
+
+
+def mal(op1, op2):
+    return op1 * op2
+
+
+def teilen(op1, op2):
+    return op1 / op2
+
+
+def potenz(op1, op2):
+    return op1 ** op2
+
+
+op1 = float(input("Wie lautet der erste Operand: "))
+op2 = float(input("Wie lautet der zweite Operand: "))
+op = input("Wie lautet der Operator: ")
+if op == "+":
+    print("Das Ergebnis lautet: " + str(plus(op1, op2)))
+elif op == "-":
+    print("Das Ergebnis lautet: " + str(minus(op1, op2)))
+elif op == "*":
+    print("Das Ergebnis lautet: " + str(mal(op1, op2)))
+elif op == "/":
+    print("Das Ergebnis lautet: " + str(teilen(op1, op2)))
+elif op == "^":
+    print("Das Ergebnis lautet: " + str(potenz(op1, op2)))
+else:
+    print("Keine gueltige Eingabe!")
diff --git a/exercises/sln/4-fnc-divide-advanced.py b/exercises/sln/4-fnc-divide-advanced.py
new file mode 100644
index 0000000..8331d4c
--- /dev/null
+++ b/exercises/sln/4-fnc-divide-advanced.py
@@ -0,0 +1,30 @@
+
+def stepwiseDivision(dividend, divisor):
+    quotient = str(dividend // divisor)
+    remainder = dividend % divisor
+    if remainder == 0:
+        return quotient
+
+    decimals = ""
+    position = 0
+    remainders = [0] * divisor
+    isPeriodic = False
+    while remainder != 0 and not isPeriodic:
+        position += 1
+        if remainders[remainder] == 0:
+            remainders[remainder] = position
+            decimals += str(remainder * 10 // divisor)
+            remainder = remainder * 10 % divisor
+        else:
+            isPeriodic = True
+            position = remainders[remainder] - 1
+            decimals = "{0}({1})".format(
+                decimals[0:position], decimals[position:])
+    return "{0},{1}".format(quotient, decimals)
+
+
+dividend = int(input("Dividend: "))
+divisor = int(input("Divisor: "))
+
+quotient = stepwiseDivision(dividend, divisor)
+print("Quotient: " + quotient)
diff --git a/exercises/sln/4-fnc-divide-basic.py b/exercises/sln/4-fnc-divide-basic.py
new file mode 100644
index 0000000..7cc3158
--- /dev/null
+++ b/exercises/sln/4-fnc-divide-basic.py
@@ -0,0 +1,21 @@
+
+def stepwiseDivision(dividend, divisor):
+    quotient = str(dividend // divisor)
+    remainder = dividend % divisor
+    if remainder == 0:
+        return quotient
+
+    decimals = ""
+    position = 0
+    while remainder != 0:
+        decimals += str(remainder * 10 // divisor)
+        remainder = remainder * 10 % divisor
+        position += 1
+    return "{0},{1}".format(quotient, decimals)
+
+
+dividend = int(input("Dividend: "))
+divisor = int(input("Divisor: "))
+
+quotient = stepwiseDivision(dividend, divisor)
+print("Quotient: " + quotient)
diff --git a/exercises/sln/4-fnc-divide-theory.tex b/exercises/sln/4-fnc-divide-theory.tex
new file mode 100644
index 0000000..cb11c45
--- /dev/null
+++ b/exercises/sln/4-fnc-divide-theory.tex
@@ -0,0 +1,2 @@
+Bei Gleitkommazahlen werden oft nicht die angegebene Zahlen gespeichert sondern eine Approximation, eine Annäherung. Das hängt unter anderem mit der Art der Speicherung einer Gleitkommazahl zusammen. Während im Dezimalsystem eine 0,1 ganz einfach darzustellen ist, arbeitet der Rechner im Binärsystem (also auf Zweierbasis) und im Binärsystem ist die Dezimalzahl 0,1 periodisch ($0.1_2$=0,00011001100110011...). Da der Speicher einer Gleitkommazahl beschränkt ist, schneidet der Rechner nach einer bestimmten Länge einfach ab.
+\\Eine andere Fehlerquelle birgt die Verrechnung - hier beispielhaft die Addition - von sehr großen mit sehr kleinen Zahlen. Um ein konkretes Beispiel zu geben: Wenn man die beiden floats 100.000.000 und 0,000000001 addiert erhält man als Ergebnis 100.000.000. Auch hier reicht die Art der Speicherung für float-Zahlen nicht aus, um eine 100.000.000,000000001 zu speichern. Die genaue Erklärung ersparen wir uns hier, da sie zu technisch wäre.
\ No newline at end of file
diff --git a/exercises/sln/4-list-fnc.py b/exercises/sln/4-list-fnc.py
new file mode 100644
index 0000000..82f0207
--- /dev/null
+++ b/exercises/sln/4-list-fnc.py
@@ -0,0 +1,15 @@
+
+def summe(werte):
+    summe = 0
+    for n in werte:
+        summe += n
+    return summe
+
+
+def durchschnitt(werte):
+    return summe(werte) / len(werte)
+
+
+werte = [2, 4, 6, 8, 10, 12, 14, 16, 18]
+print(summe(werte))
+print(durchschnitt(werte))
diff --git a/exercises/sln/4-rec-calcu.tex b/exercises/sln/4-rec-calcu.tex
new file mode 100644
index 0000000..edfe4f1
--- /dev/null
+++ b/exercises/sln/4-rec-calcu.tex
@@ -0,0 +1 @@
+siehe nächste Teilaufgabe
\ No newline at end of file
diff --git a/exercises/sln/4-rec-calcu2.py b/exercises/sln/4-rec-calcu2.py
new file mode 100644
index 0000000..4a3c3bd
--- /dev/null
+++ b/exercises/sln/4-rec-calcu2.py
@@ -0,0 +1,97 @@
+
+def plus(op1, op2):
+    if op1 == 0:
+        return op2
+    elif op2 == 0:
+        return op1
+    else:
+        return plus(op1 + 1, op2 - 1)
+
+
+def minus(op1, op2):
+    if op2 == 0:
+        return op1
+    else:
+        return minus(op1 - 1, op2 - 1)
+
+
+def mal(op1, op2):
+    if op1 == 0 or op2 == 0:
+        return 0
+    else:
+        return plus(mal(op1, minus(op2, 1)), op1)
+
+
+def teilen(op1, op2):
+    if op2 == 0:
+        return -1
+    elif op1 < op2:
+        return 0
+    else:
+        return plus(teilen(minus(op1, op2), op2), 1)
+
+
+def modulo(op1, op2):
+    if op2 == 0:
+        return -1
+    elif op1 < op2:
+        return op1
+    else:
+        return modulo(minus(op1, op2), op2)
+
+
+def potenz(op1, op2):
+    if op2 == 0:
+        return 1
+    else:
+        return mal(potenz(op1, minus(op2, 1)), op1)
+
+
+def ggT(op1, op2):
+    if op1 == 0:
+        return op2
+    elif op2 == 0:
+        return op1
+    else:
+        return ggT(op2, modulo(op1, op2))
+
+
+def min(op1, op2):
+    if op1 == 0 or op2 == 0:
+        return 0
+    else:
+        return plus(min(minus(op1, 1), minus(op2, 1)), 1)
+
+
+def max(op1, op2):
+    if op1 == 0:
+        return op2
+    elif op2 == 0:
+        return op1
+    else:
+        return plus(max(minus(op1, 1), minus(op2, 1)), 1)
+
+
+op1 = int(input("Wie lautet der erste Operand: "))
+op2 = int(input("Wie lautet der zweite Operand: "))
+op = input("Wie lautet der Operator: ")
+if op == "+":
+    print("Das Ergebnis lautet: {}".format(plus(op1, op2)))
+elif op == "-":
+    print("Das Ergebnis lautet: {}".format(minus(op1, op2)))
+elif op == "*":
+    print("Das Ergebnis lautet: {}".format(mal(op1, op2)))
+elif op == "/":
+    print("Das Ergebnis lautet: {}".format(teilen(op1, op2)))
+elif op == "%":
+    print("Das Ergebnis lautet: {}".format(modulo(op1, op2)))
+elif op == "^":
+    print("Das Ergebnis lautet: {}".format(potenz(op1, op2)))
+elif op == "T":
+    print("Das Ergebnis lautet: {}".format(ggT(op1, op2)))
+elif op == "_":
+    print("Das Ergebnis lautet: {}".format(min(op1, op2)))
+elif op == "|":
+    print("Das Ergebnis lautet: {}".format(max(op1, op2)))
+else:
+    print("Keine gültige Eingabe!")
diff --git a/exercises/sln/4-rec-fac.py b/exercises/sln/4-rec-fac.py
new file mode 100644
index 0000000..92a3bfe
--- /dev/null
+++ b/exercises/sln/4-rec-fac.py
@@ -0,0 +1,8 @@
+def fac(n):
+    if n <= 0:
+        return 1
+    else:
+        return fac(n - 1) * n
+
+
+print(fac(15))
diff --git a/exercises/sln/4-rec-fib.py b/exercises/sln/4-rec-fib.py
new file mode 100644
index 0000000..14b0776
--- /dev/null
+++ b/exercises/sln/4-rec-fib.py
@@ -0,0 +1,14 @@
+def fib(n):
+    n = int(n)
+    if n <= 0:
+        return 0
+    elif n == 1:
+        return 1
+    else:
+        return fib(n - 1) + fib(n - 2)
+
+
+i = 1
+while(i <= 20):
+    print(fib(i))
+    i += 1
diff --git a/exercises/sln/4-rec-oddeven.py b/exercises/sln/4-rec-oddeven.py
new file mode 100644
index 0000000..fb0b436
--- /dev/null
+++ b/exercises/sln/4-rec-oddeven.py
@@ -0,0 +1,20 @@
+def even(n):
+    n = int(n)
+    if n == 0:
+        return True
+    else:
+        return odd(n - 1)
+
+
+def odd(n):
+    n = int(n)
+    if n == 0:
+        return False
+    else:
+        return even(n - 1)
+
+
+print("even(42)= {}".format(even(42)))
+print("odd(42)= {}".format(odd(42)))
+print("even(23)= {}".format(even(23)))
+print("odd(23)= {}".format(odd(23)))
diff --git a/exercises/sln/4-rec-pascal.py b/exercises/sln/4-rec-pascal.py
new file mode 100644
index 0000000..e82e0a4
--- /dev/null
+++ b/exercises/sln/4-rec-pascal.py
@@ -0,0 +1,12 @@
+
+def pascal(row, column):
+    if row < 0 or column > row:
+        return -1
+    if column == 0 or column == row:
+        return 1
+    return pascal(row - 1, column - 1) + pascal(row - 1, column)
+
+
+zeile = int(input("Zeile: "))
+spalte = int(input("Spalte: "))
+print(pascal(zeile, spalte))
diff --git a/exercises/sln/arith-gauss.py b/exercises/sln/arith-gauss.py
new file mode 100755
index 0000000..c5a6690
--- /dev/null
+++ b/exercises/sln/arith-gauss.py
@@ -0,0 +1,3 @@
+#!/usr/bin/python3
+sum = 100 * (100 + 1) // 2
+print("Die Summe der ersten 100 Zahlen ist", sum)
\ No newline at end of file
diff --git a/exercises/sln/arith-pq.py b/exercises/sln/arith-pq.py
new file mode 100755
index 0000000..c9662b0
--- /dev/null
+++ b/exercises/sln/arith-pq.py
@@ -0,0 +1,16 @@
+#!/usr/bin/python3
+from math import sqrt
+
+# a)
+sq = sqrt(pow(-6 / 2, 2) -5)
+ph = -(-6 / 2)
+f1 = ph + sq
+f2 = ph - sq
+print("{0},{1}".format(f1,f2))
+
+# b)
+sq = sqrt(pow(-2 / 2, 2) + 3)
+ph = -(-2 / 2)
+g1 = ph + sq
+g2 = ph - sq
+print("{0},{1}".format(g1,g2));
\ No newline at end of file
diff --git a/exercises/task/1-conv-challenge.tex b/exercises/task/1-conv-challenge.tex
new file mode 100644
index 0000000..97e40f7
--- /dev/null
+++ b/exercises/task/1-conv-challenge.tex
@@ -0,0 +1,7 @@
+\subsection{Verrückte Eingabe \stage3}
+
+Versuche eine Ausdruck zu finden, der nur \pythoninline{'1'}, \pythoninline{0},
+\pythoninline{int(...)}, \pythoninline{str(...)} und Operationen verwendet, der
+insgesamt zu \pythoninline{3000} auswertet. Beachtet, dass solche Ausdrücke
+wie ihr hier schreiben sollt, so \textbf{niemals} in echtem Code auftauchen
+sollten.
diff --git a/exercises/task/1-conversion.tex b/exercises/task/1-conversion.tex
new file mode 100644
index 0000000..2660ff6
--- /dev/null
+++ b/exercises/task/1-conversion.tex
@@ -0,0 +1,25 @@
+\subsection{Konvertierung}
+
+Nehmen wir mal an, ihr habt den Text \texttt{"1000"} zur Verfügung. Vielleicht
+errechnet; vielleicht aus einer API? Es kommt immer wieder vor, dass eure Daten
+noch den falschen Typ haben, wenn ihr sie bekommt. In Python schreibt ihr dafür
+den Typ hin, den ihr erhalten wollt, sowie den Ausdruck in Klammern dahinter.
+Python versucht, den am Besten passenden Wert des gewünschten Typs zu finden.
+
+Gebt die folgenden Ausdrücke ein, und findet das Ergebnis heraus. es kann sein,
+dass einige Konvertierungen fehlschlagen.
+
+\begin{multicols}{3}
+\begin{enumerate}
+    \item \pythoninline{int("100")}
+    \item \pythoninline{float("1.3")}
+    \item \pythoninline{float("NaN")}
+    \item \pythoninline{str(234)}
+    \item \pythoninline{int("0x11")}
+    \item \pythoninline{str(2) + '5'}
+    \item \pythoninline{str(2 + 5)}
+    \item \pythoninline{float(5)}
+    \item \pythoninline{int(5.5)}
+    \item \pythoninline{int("4.2")}
+\end{enumerate}
+\end{multicols}
diff --git a/exercises/task/1-error.tex b/exercises/task/1-error.tex
new file mode 100644
index 0000000..5f73784
--- /dev/null
+++ b/exercises/task/1-error.tex
@@ -0,0 +1,20 @@
+\subsection{Fehlertypen \stage1}
+
+Ordne die folgenden drei Fehlertypen den folgenden Ausdrücken zu.
+\begin{multicols}{3}
+    \begin{itemize}
+        \item[] \textbf{SyntaxError}
+        \item[] \textbf{ZeroDivisionError}
+        \item[] \textbf{NameError}
+    \end{itemize}
+    \begin{itemize}
+        \item[] \pythoninline{true}
+        \item[] \pythoninline{4 +* 5}
+        \item[] \pythoninline{2 / 0}
+    \end{itemize}
+    \begin{itemize}
+        \item[] \textit{Syntaktischer Fehler}
+        \item[] \textit{Lexikalischer Fehler}
+        \item[] \textit{Semantischer Fehler}
+    \end{itemize}
+\end{multicols}
diff --git a/exercises/task/1-interactive.tex b/exercises/task/1-interactive.tex
new file mode 100644
index 0000000..779efce
--- /dev/null
+++ b/exercises/task/1-interactive.tex
@@ -0,0 +1,26 @@
+\subsection{Frage \& Antwort}
+
+Gib nacheinander die folgenden Ausdrücke in den Interpreter ein. Drücke nach
+jedem Eintrag \textit{ENTER}, um den Ausdruck auszuwerten. Was passiert?
+Kannst du dir erklären warum? Probiert auch noch weitere Ausdrücke, die euch
+einfallen.
+
+\begin{multicols}{3}
+\begin{itemize}
+    \item \texttt{2}
+    \item \texttt{10.0}
+    \item \texttt{"1"}
+    \item \texttt{'1'}
+    \item \texttt{Test}
+    \item \texttt{"Test"}
+    \item \texttt{0x11}
+    \item \texttt{0b11}
+    \item \texttt{true}
+    \item \texttt{True}
+    \item \texttt{false}
+    \item \texttt{False}
+\end{itemize}
+\end{multicols}
+
+\bonus{Wenn ihr den Typ herausfinden wollt, den ein Ausdruck ergibt,
+könnt ihr das machen, indem ihr ihn mit \texttt{type(...)} umschließt.}
diff --git a/exercises/task/1-intro.tex b/exercises/task/1-intro.tex
new file mode 100644
index 0000000..865db55
--- /dev/null
+++ b/exercises/task/1-intro.tex
@@ -0,0 +1,20 @@
+\subsection{Python Installieren}
+Hey, willkommen bei den Übungen zum Programmiervorkurs im \ptitle. Wie in der
+Vorlesung verwenden wir für die Übungen die Programmiersprache Python. \\\\
+%
+Auf den Poolrechnern und auf den meisten Linux-Distributionen sollte die
+benötigte Version 3 schon installiert sein. Prüft das, indem ihr (etwa mit
+Rechtsklick -> \textit{Terminal öffnen}) auf dem Desktop) ein Terminal öffnet,
+und führt den Befehl \texttt{python3 ----version} aus. Dieser sollte so etwas wie
+\textit{Python 3.5.3} ausgeben.
+
+Sollte das nicht funktionieren, installiert Python 3 über einen Paketmanager
+eurer Wahl (etwa mit \texttt{apt install python}). \\\\
+%
+Für Windows oder MacOS müsst ihr Python von der offiziellen Seite
+\url{https://python.org/downloads} herunterladen. Klickt dort einfach die
+Schaltfläche \textit{Download Python 3.7.0} (höhere Versionsnummer möglich) an.
+Öffnet nun auch hier ein Terminal (Win+R -> \texttt{cmd}). \\\\
+%
+Führt nun den Befehl \texttt{python} oder \texttt{python3} aus um eine
+interaktive Eingabezeile zu starten.
diff --git a/exercises/task/1-mc-interpreter.tex b/exercises/task/1-mc-interpreter.tex
new file mode 100755
index 0000000..0f228dd
--- /dev/null
+++ b/exercises/task/1-mc-interpreter.tex
@@ -0,0 +1,8 @@
+\subsection{Theoriefragen}
+\begin{itemize}
+	\mchead
+	\mcitemt{Programmcode steht üblicherweise in Textdateien}
+	\mcitemf{Ein Prozessor kann Python direkt ausführen}
+	\mcitemt{Um Python-Code auszuführen kann ein Interpreter verwendet werden}
+	\mcitemf{Es ist niemals sinnvoll seinen Code mit Kommentaren zu überladen}
+\end{itemize}
diff --git a/exercises/task/1-modulo.tex b/exercises/task/1-modulo.tex
new file mode 100644
index 0000000..c6ba327
--- /dev/null
+++ b/exercises/task/1-modulo.tex
@@ -0,0 +1,28 @@
+\subsection{Wir rechnen Modulo \stage3}
+
+\newcommand{\mod}{\mathop{mod}}
+
+Für eine RSA-Verschlüsselung werden zwei Primzahlen $p,q$ benötigt.
+Deren Produkt definiert einen Ring $\mathbb Z_n$ mit $n = p * q$.
+Das heißt, nach jeder Operation wir das Ergebnis mittels \textbf{Modulo}
+in das Intervall $[0,n)$ gebracht. \\\\
+%
+In Python wird das mit dem \texttt{\%} Operator dargestellt. So gilt
+\pythoninline{20 % 10 == 0}, \pythoninline{15 % 9 == 6}, \dots \\\\
+%
+Wenn wir nun etwas verschlüsseln/entschlüsseln wollen, benötigen wir zunächst
+$N = \phi(n) = (p-1) * (q-1)$ und ausserdem ein $0 < e < N$ mit $ggT(e,N) = 1$,
+sowie ein $0 < d < N$ mit $ed \mod N = 1$. \\\\
+%
+Da das hier keine Krypto-Vorlesung ist, haben wir für euch die Werte: \\
+$p=3$, $q=11$, $n=33$, $N=20$, $e=3$, $d=7$ berechnet. Eine Nachricht $m$ wird
+nun als $m^e \mod n$ verschlüsselt, ein Chiffretext $c$ als $c^d \mod n$
+entschlüsselt.\\\\
+%
+Verschlüsselt mit den vorgegebenen (oder eigenen) Werten nun ein
+paar Zahlen ($0 <= x < n$), und probiert ob ihr sie wieder entschlüsseln könnt.
+Ihr könnt diese auch an eure Sitznachbarn weitergeben!
+
+% Bonus
+% enc = lambda x: [(ord(c) - ord('a')) ** 3 % 33 for c in x if ord('a') <= ord(c) and ord(c) <= ord('z')]
+% dec = lambda x: "".join([chr((v ** 7 % 33) + ord('a')) for v in x if 0 <= v and v < 33])
diff --git a/exercises/task/1-operations.tex b/exercises/task/1-operations.tex
new file mode 100644
index 0000000..1b8baf0
--- /dev/null
+++ b/exercises/task/1-operations.tex
@@ -0,0 +1,21 @@
+\subsection{Mathe 0 für Informatiker*innen}
+Wenn euch das Programm aber nur das zurückgeben könnte, was ihr hinschreibt,
+dann wäre das ja noch lange kein \textit{Computer}. Darum rechnen wir nun etwas.
+Überlegt euch was die folgenden Ausdrücke ergeben, und was die verwendeten
+Symbole für Operationen bezeichnen. Beachtet dabei, die Operatorenpräzedenz.
+
+\begin{multicols}{3}
+\begin{itemize}
+    \item \texttt{16 + 26}
+    \item \texttt{13.75 + 28.67}
+    \item \texttt{2 * 3 + 6 * 6}
+    \item \texttt{'4' + '2'}
+    \item \texttt{4 ** 3 - 11 * 2}
+    \item \texttt{12 * 133 / 28 - 15}
+    \item \texttt{12 * 'a'}
+    \item \texttt{1.3 * 5.6}
+\end{itemize}
+\end{multicols}
+
+\bonus{Mit \texttt{ord(...)} könnt ihr den Codepunkt eines Zeichens
+herausfinden, mit \texttt{chr(...)} das Zeichen zu einem Codepunkt.}
diff --git a/exercises/task/1-warmup-error.tex b/exercises/task/1-warmup-error.tex
new file mode 100755
index 0000000..0c16c87
--- /dev/null
+++ b/exercises/task/1-warmup-error.tex
@@ -0,0 +1,8 @@
+\subsection{Finde den Fehler \stage2}
+Gegeben sind die folgenden Listings. Führe die Programme aus und beschreibe warum jeweils ein Fehler auftritt.
+\begin{lstlisting}
+>>> prinnt("Hello World!") # a)
+>>> print(Hello World!)    # b)
+>>> print("Alter: " + 18)  # c)
+>>> print("Hello World!)   # d)
+\end{lstlisting}
diff --git a/exercises/task/2-cooking.tex b/exercises/task/2-cooking.tex
new file mode 100644
index 0000000..379dcd8
--- /dev/null
+++ b/exercises/task/2-cooking.tex
@@ -0,0 +1,18 @@
+\subsection{Kochrezept}
+In dieser Aufgabe soll ein Rezeptgenerator geschrieben werden, der anhand der Menge einer vorhandenen Zutat bestimmt, wie viel von den restlichen Zutaten für eine Pizza gebraucht wird. (natürlich könnt ihr euch noch viele weitere Wahlmöglichkeiten überlegen, beispielsweise den Belag) \\
+\\
+Hier ein Pizzarezept: \\
+\begin{multicols}{2}
+	\begin{itemize}
+	    \item \texttt{450g Mehl}
+	    \item \texttt{250 ml warmes Wasser}
+	    \item \texttt{1 TL getrischen Salz}
+	    \item \texttt{2 EL Olivenöl}
+	    \item \texttt{2 TL Backpulver}
+	    \item \texttt{400g passierte Tomaten (Sauce)}
+	    \item \texttt{1 TL Oregano (Sauce)}
+	    \item \texttt{2 EL Olivenöl (Sauce)}
+	    \item \texttt{1 Knoblauchzehe (Sauce)}
+	    \item \texttt{Belag}
+	\end{itemize}
+\end{multicols}
\ No newline at end of file
diff --git a/exercises/task/2-mc-if.tex b/exercises/task/2-mc-if.tex
new file mode 100644
index 0000000..7a37872
--- /dev/null
+++ b/exercises/task/2-mc-if.tex
@@ -0,0 +1,7 @@
+\subsection{Anweisungen}
+\begin{itemize}
+	\mchead
+	\mcitemt{Eine if-Anweisung beeinflusst den Programmablauf.}
+	\mcitemf{Eine if-Anweisung benötigt eine else-Klausel.}
+	\mcitemt{Ein \lstinline{if 4:} führt immer den eingeschlossenen Codeblock aus.}
+\end{itemize}
\ No newline at end of file
diff --git a/exercises/task/2-pyfile.tex b/exercises/task/2-pyfile.tex
new file mode 100644
index 0000000..dc8d283
--- /dev/null
+++ b/exercises/task/2-pyfile.tex
@@ -0,0 +1,17 @@
+Für die folgenden Aufgaben solltet ihr jeweils eine Python-Programmdatei
+anlegen. Öffnet dazu einen beliebigen Ordner in eurem Dateiexplorer. Öffnet
+dann ein Terminal im selben Verzeichnis.
+
+\begin{itemize}
+\item Unter Linux \& Mac (u.a. den Poolrechnern): Rechtsklick -> In Terminal öffnen
+\item Unter Windows: Shift+Rechtsklick -> Befehlseingabe hier öffnen
+\item Oder auch: Shift+Rechtsklick -> Powershell hier öffnen
+\end{itemize}
+
+Öffnet dann einen Texteditor eurer Wahl. Unter Linux ist das etwa gedit, unter
+Windows kann Notepad verwendet werden. Erstellt eine Datei mit eurem Programm
+und speichert sie mit der Endung \texttt{.py}, beispielsweise \texttt{datei.py}
+in dem vorher ausgewählten Ordner.
+
+Du kannst diese Datei dann starten, indem du \texttt{python3 datei.py} (Linux, Mac)
+bzw. \texttt{python datei.py} (Windows) in dem geöffneten Terminal ausführst.
diff --git a/exercises/task/2-stm-calc.tex b/exercises/task/2-stm-calc.tex
new file mode 100644
index 0000000..49a533e
--- /dev/null
+++ b/exercises/task/2-stm-calc.tex
@@ -0,0 +1,2 @@
+\subsection{Taschenrechner}
+In dieser Aufgabe soll ein sehr einfacher Taschenrechner implementiert werden, wobei wir uns dabei auf die Grundrechenarten beschränken wollen. Dein Programm soll nacheinander drei Eingaben entgegennehmen, zwei Operanden (\textbf{ganze Zahlen}) und einen Operator (\textbf{+, -, *, /}). Schließlich soll der Taschenrechner eine Ausgabe mit dem entsprechenden Ergebnis liefern. Vergiss nicht, dein Programm zu testen.
diff --git a/exercises/task/2-stm-ops.tex b/exercises/task/2-stm-ops.tex
new file mode 100644
index 0000000..8636fc9
--- /dev/null
+++ b/exercises/task/2-stm-ops.tex
@@ -0,0 +1,17 @@
+\subsection{Operatoren}
+Es seien die folgenden Variablen deklariert und initialisiert:
+\begin{lstlisting}
+x = 6
+y = 7
+z = 0
+a = False
+\end{lstlisting}
+Welchen Wert enthält die Variable b jeweils nach Ausführung der folgenden Anweisungen?
+\begin{enumerate}
+\item \lstinline{b = x > 5 or y < 7 and z != 0}
+\item \lstinline{b = x * y != y * x and x / z == 0}
+\item \lstinline{b = not x == y and z <= 0}
+\item \lstinline{b = x >= 11 or x < 9 and not y == 2 and x + y * z > 0 or a}
+\item \lstinline{b = z != z or not a and x - y * z <= 0}
+\item \lstinline{b = not a and z < y - x}
+\end{enumerate}
\ No newline at end of file
diff --git a/exercises/task/2-var-assign.tex b/exercises/task/2-var-assign.tex
new file mode 100644
index 0000000..7d68816
--- /dev/null
+++ b/exercises/task/2-var-assign.tex
@@ -0,0 +1,21 @@
+\subsection{Assignment}
+Ergänze im folgenden Listing die fehlenden Variablenzuweisungen, so dass keine Fehler auftreten und am Ende \texttt{variable1} zu \texttt{True}, \texttt{variable2} zu \texttt{5} und \texttt{variable3} zu \texttt{'abc'} auswertet.
+\begin{lstlisting}
+variable1 = # hier Zuweisung 1 einsetzen
+variable2 = 3
+variable3 = # hier Zuweisung 2 einsetzen
+variable2 += variable1
+if variable3 > 5:
+	variable2 = 0
+else:
+	variable2 *= variable3
+variable1 = # hier Zuweisung 3 einsetzen
+variable3 = # hier Zuweisung 4 einsetzen
+variable3 += variable1
+variable1 = # hier Zuweisung 5 einsetzen
+variable1 = variable1 > variable2 * 2
+variable3 += "c"
+print(variable1)
+print(variable2)
+print(variable3)
+\end{lstlisting}
\ No newline at end of file
diff --git a/exercises/task/2-var-case.tex b/exercises/task/2-var-case.tex
new file mode 100644
index 0000000..165ad0b
--- /dev/null
+++ b/exercises/task/2-var-case.tex
@@ -0,0 +1,8 @@
+\subsection{Fehlersuche}
+Gegeben ist folgendes Listing:
+\begin{lstlisting}
+meinAlter = 21
+MeinAlter = MeinAlter + 1
+print(meinAlter)
+\end{lstlisting}
+Beim Ausführen der zweiten Zeile wirft Python einen Fehler. Warum? Verbessere das Listing.
diff --git a/exercises/task/2-var-id.tex b/exercises/task/2-var-id.tex
new file mode 100644
index 0000000..06387d4
--- /dev/null
+++ b/exercises/task/2-var-id.tex
@@ -0,0 +1,15 @@
+\subsection{Namenskonvention}
+Welches sind \textbf{gültige} Variablennamen?
+\begin{multicols}{3}
+\begin{enumerate}
+	\item Matrikelnummer
+	\item ÄhmKeineAhnung
+	\item 2fancy4python
+	\item {\_}meinAlter
+	\item richtig\&gut
+	\item {\_}2Euro
+	\item Variable2
+	\item noch$\_$besser
+	\item \#Falsch
+\end{enumerate}
+\end{multicols}
\ No newline at end of file
diff --git a/exercises/task/2-var-io.tex b/exercises/task/2-var-io.tex
new file mode 100644
index 0000000..5f844b4
--- /dev/null
+++ b/exercises/task/2-var-io.tex
@@ -0,0 +1,10 @@
+\subsection{Variablen einlesen}
+Im Rahmen der Vorlesung hast du die Funktion \texttt{input} kennengelernt, welche es dir erlaubt, auf einfache Art und Weise Benutzereingaben von der Konsole einzulesen. Schreibe jetzt ein Programm, welches mit Hilfe dieser Funktion nacheinander folgende Eingaben einließt und in Variablen speichert. 
+\begin{itemize}
+	\item deinen Namen als Zeichenkette
+	\item dein Geburtsdatum als drei ganze Zahlen: Tag, Monat, Jahr
+\end {itemize}
+Insgesamt sollen also vier Eingaben verarbeiten werden. Achte dabei darauf, dass dein Programm die erwarteten Eingaben textuell klar strukturiert (Stichwort: Bedienerfreundlichkeit).\\Nachdem die letzte Eingabe verarbeitet ist, soll folgende Zeichenkette ausgegeben werden (wobei natürlich die Platzhalter zu ersetzen sind):\\Ausgabe: {\ttfamily{\dq}}<dein Name> hat am <tt.mm.jjjj> Geburtstag.{\ttfamily{\dq}}
+\\\textit{Hinweis: Die Verarbeitung von Eingaben wird im Foliensatz 'Variablen.pdf' erläutert.}
+\\\textit{Hinweis: Variablen sollten in Strings nicht mit '+' eingefügt werden, stattdessen an die entsprechenden Stellen im String \{0\}, \{1\}, ... einsetzen und dahinter .format(variable0, variable1, ...) eintragen. \\
+Beispiel: "\{0\} ist kleiner \{1\}".format(4, 42) ergibt "4 ist kleiner 42"}
diff --git a/exercises/task/2-var-processor.tex b/exercises/task/2-var-processor.tex
new file mode 100644
index 0000000..36ab8d3
--- /dev/null
+++ b/exercises/task/2-var-processor.tex
@@ -0,0 +1,19 @@
+\subsection{Ein einfacher Prozessor}
+Prozessoren bestehen im allgemeinen aus einer kleinen Anzahl von Registern, mit denen die eigentlichen Berechnungen durchgeführt werden. Im Folgenden wollen wir das Verhalten eines kleinen Prozessors in Python simulieren. \\
+Der Prozessor soll aus 4 Registern bestehen, die beliebige Werte speichern können (Diese könnt ihr als Variablen modellieren). Außerdem kann der Prozessor grundlegende Berechnungen (+, -, *, /, \%) auf seinen Registern durchführen und Werte in Registern vergleichen (\textbf{Achtung:} Ihr müsst also nach jeder einzelnen Rechung oder einem Vergleich das Ergebnis in eines der Register speichern, und dürft nicht mehrere Rechnungen nacheinander ausführen (Also statt \pythoninline{a = 2 + 3 * 4} müsstet ihr \pythoninline{b = 3 * 4} gefolgt von \pythoninline{a = 2 + b} schreiben. If-Abfragen sind auf diese Art möglich: \pythoninline{if a:})) \\
+In den Berechnungen dürf ihr außer den Registern auch Zahlenwerte verwenden, jedoch nicht das Register in das das Ergebnis geschrieben wird.\\
+Erstelle nun mit diesen Randbedinungen ein Programm, dass das folgende tut: \\
+\begin{lstlisting}
+lese eine Ganzzahl a ein
+lese eine Ganzzahl b ein
+lese eine Ganzzahl c ein
+verdoppele a und addiere 3 hinzu
+lese eine Ganzzahl d ein
+gib b und c aus
+wenn a > d gilt, setze d = a
+wenn a < d gilt, speichere Wert c = d - a, sonst speichere Wert c = 0
+setze a = c * d + a * a
+setze Wert b = a + d
+setze c = b + d
+gib a,b,c und d aus
+\end{lstlisting}
\ No newline at end of file
diff --git a/exercises/task/3-accumulator.tex b/exercises/task/3-accumulator.tex
new file mode 100644
index 0000000..4417fb9
--- /dev/null
+++ b/exercises/task/3-accumulator.tex
@@ -0,0 +1,15 @@
+\subsection{Akkumulator \stage2}
+
+Häufig gibt es in Programmen eine Variable in der das Ergebnis langsam aufgebaut
+wird. Beispielsweise ist diese für eine Summe zu Anfang $0$. Danach wird diese
+in einer Schleife für jeden Eintrag verändert. Schreibe in Programm, was die
+für die Liste \pythoninline{[1,2,3,4,5,6,7]} die folgenden Werte berechnet:
+
+\begin{enumerate}
+    \item Die Summe aller Elemente
+    \item Das Produkt aller Elemente
+    \item Der Durchschnitt aller Elemente
+    \item Eine Liste der Quadrate der Elemente
+\end{enumerate}
+
+Was müsst ihr bei der Berechnung des Durchschnitts beachten?
diff --git a/exercises/task/3-challenge.tex b/exercises/task/3-challenge.tex
new file mode 100755
index 0000000..fa62029
--- /dev/null
+++ b/exercises/task/3-challenge.tex
@@ -0,0 +1 @@
+\large \textbf{Hinweis:} Nun ist Zeit für die Programmierchallenge! Viel Erfolg! :-)
diff --git a/exercises/task/3-iterable.tex b/exercises/task/3-iterable.tex
new file mode 100644
index 0000000..462787d
--- /dev/null
+++ b/exercises/task/3-iterable.tex
@@ -0,0 +1,14 @@
+\subsection{Zahlenlisten \stage2}
+
+In der Vorlesung wurde \pythoninline{range(...)} vorgestellt. Wenn ihr diesen
+Ausdruck in den Interpreter eingebt, wird euch nur ein Audruck angezeigt der
+dieselbe Zahlenreihe meint. Mit \pythoninline{list(...)} könnt ihr diesen
+Ausdruck in eine Liste umwandeln und euch anzeigen lassen. \\\\
+\textit{Welche range-Ausdrücke ergeben die folgenden Listen?}
+
+\begin{enumerate}
+    \item \pythoninline{[1,2,3,4,5,6,7]}
+    \item \pythoninline{[0,1,2,3,4]}
+    \item \pythoninline{[4,6,8,10]}
+    \item \pythoninline{[9,6,3]}
+\end{enumerate}
diff --git a/exercises/task/3-list-basic.tex b/exercises/task/3-list-basic.tex
new file mode 100644
index 0000000..05441b2
--- /dev/null
+++ b/exercises/task/3-list-basic.tex
@@ -0,0 +1,20 @@
+\subsection{Definition und Indices \stage1}
+
+Beginne ein neues Programm, und gehe dabei davon aus, dass die Liste
+\pythoninline{list} genau $8$ Elemente enthält. Dein Programm soll
+nun die Ergebnisse der folgenden Rechnungen ausgeben:
+
+\begin{enumerate}
+    \item Die Summe der Zahlen an Index $1$, $2$ und $7$.
+    \item Das Produkt jeder zweiten Zahl.
+    \item Die erste Zahl mal 300.
+\end{enumerate}
+
+Für diese Aufgabe musst du weder Schleifen noch Slicing verwenden. Probiere
+dein Programm aus, indem du die folgenden Listen einsetzt und die Ausgaben
+mit denen von deinem Programm vergleichst.
+
+\begin{itemize}
+    \item Für \pythoninline{lst = [1,1,2,3,5,8,13,21]} ist das $24$, $504$ und $300$
+    \item Für \pythoninline{lst = [-1,1,-1,1,-1,1,-1,1]} ist das $1$, $1$ und $-300$
+\end{itemize}
diff --git a/exercises/task/3-list-len.tex b/exercises/task/3-list-len.tex
new file mode 100644
index 0000000..a2b2adc
--- /dev/null
+++ b/exercises/task/3-list-len.tex
@@ -0,0 +1,8 @@
+\subsection{Listenlänge \stage1}
+
+In der Vorlesung wurde \pythoninline{len(...)} eingeführt um die Länge einer
+List zu bestimmen. Überlege dir warum der Ausdruck \pythoninline{list[len(list)]}
+immer zu einem Fehler führt.
+
+Schreibe nun ein Programm, dass für beliebige Listen alle Elemente der Reihe
+nach ausgibt. Du kannst dafür eine \pythoninline{while}-Schleife verwenden.
diff --git a/exercises/task/3-loop-fac.tex b/exercises/task/3-loop-fac.tex
new file mode 100755
index 0000000..6e282dc
--- /dev/null
+++ b/exercises/task/3-loop-fac.tex
@@ -0,0 +1,5 @@
+\subsection{Fakultät \stage1}
+\begin{enumerate}
+	\item Schreibe ein Programm, das den Wert des Ausdrucks $1 * 2 * 3 * \ldots * 15 = 15!$ (Fakultät von 15) berechnet, und das Ergebnis auf der Konsole ausgibt.
+	\item Erweitere dein Programm so, dass es von beliebigen Eingaben in der Konsole die Fakultät berechnet.
+\end{enumerate}
diff --git a/exercises/task/3-loop-fizz.tex b/exercises/task/3-loop-fizz.tex
new file mode 100755
index 0000000..f1549aa
--- /dev/null
+++ b/exercises/task/3-loop-fizz.tex
@@ -0,0 +1,2 @@
+\subsection{FizzBuzz \stage3}
+FizzBuzz ist ein bekanntes \href{https://en.wikipedia.org/wiki/Fizz_buzz}{Lernspiel}. Schreibe ein Programm, das (zeilenweise) die Zahlen von 1 bis 100 ausgibt, aber für jedes Vielfache von 3 das Wort \textbf{Fizz} und für jedes Vielfache von 5 das Wort \textbf{Buzz} anstelle der Zahl ausgibt. Für Zahlen, die Vielfache von 3 und 5 sind, soll \textbf{FizzBuzz} ausgegeben werden.
diff --git a/exercises/task/3-loop-gauss.tex b/exercises/task/3-loop-gauss.tex
new file mode 100755
index 0000000..001f905
--- /dev/null
+++ b/exercises/task/3-loop-gauss.tex
@@ -0,0 +1,4 @@
+\subsection{Gaußsche Summenformel Reloaded \stage1}
+Erinnert euch an die Gaußsche Summenformel aus Übungsblatt 1:
+$$1+2+3+\ldots+n = \sum_{k=1}^nk=\frac{n\cdot(n+1)}{2}$$
+Nun soll die Summe nicht mit Hilfe der geschlossenen Darstellung der Reihe berechnet werden, sondern unter Verwendung einer \textbf{for-Schleife}.
diff --git a/exercises/task/3-loop-prime.py b/exercises/task/3-loop-prime.py
new file mode 100644
index 0000000..c8cc282
--- /dev/null
+++ b/exercises/task/3-loop-prime.py
@@ -0,0 +1,7 @@
+prim = ...
+isPrim = True
+# Hier Code einfügen
+if isPrim:
+	# Hier Code einfügen
+else:
+	# Hier Code einfügen
diff --git a/exercises/task/3-loop-prime.tex b/exercises/task/3-loop-prime.tex
new file mode 100755
index 0000000..8248bda
--- /dev/null
+++ b/exercises/task/3-loop-prime.tex
@@ -0,0 +1,7 @@
+\subsection{Primzahl \stage3}
+Gegeben ist folgendes Listing:
+\pythonfile{task/3-loop-prime.py}
+\begin{enumerate}
+	\item Ergänze das Programm. Es soll erkennen, ob es sich bei der Variable \textbf{prim} um eine Primzahl\footnote{\href{https://de.wikipedia.org/wiki/Primzahl}{Jede natürliche Zahl, die nur durch sich selbst und 1 teilbar ist.}} handelt. Teste dein Programm mit verschiedenen Werten.
+	\item Erweitere das Programm um eine manuelle Eingabe der Primzahl. Nutze dazu die Input-Klasse.
+\end{enumerate}
diff --git a/exercises/task/3-slicing-examples.tex b/exercises/task/3-slicing-examples.tex
new file mode 100644
index 0000000..82c9f26
--- /dev/null
+++ b/exercises/task/3-slicing-examples.tex
@@ -0,0 +1,12 @@
+\subsection{Slicing-Beispiele \stage2}
+
+Finde Slicing Ausdrücke für die folgenden Fragen zur Liste \pythoninline{lst}:
+
+\begin{enumerate}
+    \item Die gesamte Liste
+    \item Die Liste rückwärts
+    \item Jedes zweite Element
+    \item Das erste Element und jedes dritte danach mit Indices kleiner $7$
+    \item Elemente an Index $6$, $5$, $4$ und $3$
+    \item Nur das erste Element
+\end{enumerate}
diff --git a/exercises/task/3-slicing.tex b/exercises/task/3-slicing.tex
new file mode 100644
index 0000000..977df7d
--- /dev/null
+++ b/exercises/task/3-slicing.tex
@@ -0,0 +1,7 @@
+\subsection{Einer für alle und alle für einen! \stage2}
+
+Slicing ermöglicht es, nur einen Teil einer Liste zu verwenden.
+So gilt etwa \\\pythoninline{[1,2,3,4][1:3] == [2,3]}. Ein Slicing-Ausdruck
+besteht aus drei Komponenten \pythoninline{[a:b:c]}, die auch weg- oderleer
+gelassen werden können. Welche Werte werden für die einzelnen Komponenten
+verwendet, wenn diese leer gelassen werden?
diff --git a/exercises/task/3-text-slicing.tex b/exercises/task/3-text-slicing.tex
new file mode 100644
index 0000000..4714b81
--- /dev/null
+++ b/exercises/task/3-text-slicing.tex
@@ -0,0 +1,7 @@
+\subsection{Text-Slicing \stage3}
+
+Slicing funktioniert auch mit Text. Dabei wird der Text wie eine Liste von
+Buchstaben behandelt. \pythoninline{"Hallo Welt!"[:5]} ergibt beispielsweise den
+String \pythoninline{"Hallo"}. Findet ihr einen Ausdruck mittels Slicing ein
+Palindrom erkennt? \textit{Ein Palindrom ist ein Wort, das vorwärts und rückwärts
+identisch ist}.
diff --git a/exercises/task/4-fnc-calcr.tex b/exercises/task/4-fnc-calcr.tex
new file mode 100644
index 0000000..339465e
--- /dev/null
+++ b/exercises/task/4-fnc-calcr.tex
@@ -0,0 +1,3 @@
+\subsection{Taschenrechner Reloaded \stage1}
+In der vorigen Übung sollte ein simpler Taschenrechner programmiert werden. Nun wollen wir diesen Taschenrechner erweitern. Schreibe zuerst jeweils eine Funktion für jede der angebotenen Grundrechenarten (\lstinline[language=python]{def plus(3, 5):} soll beispielsweise 8 liefern).
+\\Im Anschluss sollen die Rechenanweisungen in der if-Struktur durch Funktionsaufrufe ersetzt werden. Vergiss nicht, das Ergebnis auszugeben.
diff --git a/exercises/task/4-fnc-calcr2.tex b/exercises/task/4-fnc-calcr2.tex
new file mode 100644
index 0000000..3b0dc1d
--- /dev/null
+++ b/exercises/task/4-fnc-calcr2.tex
@@ -0,0 +1,2 @@
+\subsection{Taschenrechner Reloaded II \stage1}
+Erweitere den Taschenrechner nun noch um einen weiteren Operator. Dabei soll auch das Potenzieren möglich sein. Dabei gilt $a^n=a\cdot a\cdot a \cdot\ldots\cdot a$ (d.h. a wird n-mal mit sich selbst malgenommen). Zum Aufruf der Potenzier-Funktion soll der Benutzer \^{} (das kleine "`Dach"' links oben auf der Tastatur) eingeben.
\ No newline at end of file
diff --git a/exercises/task/4-fnc-divide-advanced.tex b/exercises/task/4-fnc-divide-advanced.tex
new file mode 100644
index 0000000..0eb6768
--- /dev/null
+++ b/exercises/task/4-fnc-divide-advanced.tex
@@ -0,0 +1,8 @@
+\subsection{Schriftliches Dividieren Reloaded \stage3}
+Da viele Divisionen nicht aufgehen, wollen wir die definierte Funktion dahingehend überarbeiten, damit wir im Anschluss jedes (positive) Ganzzahlenpaar dividieren können. Dafür musst du zuerst überlegen, woran periodische Ergebnisse während der Division erkannt werden können und eine entsprechende Detektion in deine Funktion einbauen. Außerdem soll dein Programm ein periodisches Ergebnis auch korrekt ausgeben. Es gibt international verschiedene Schreibweisen für periodische Zahlen, am einfachsten für uns ist, wenn wir die wiederkehrenden Ziffern einfach einklammern:
+\begin{lstlisting}
+1/3 = 0,(3)
+40/3 = 13,(3)
+17/130 = 0,1(307692)
+35/24 = 1,458(3)
+\end{lstlisting}
\ No newline at end of file
diff --git a/exercises/task/4-fnc-divide-basic.tex b/exercises/task/4-fnc-divide-basic.tex
new file mode 100644
index 0000000..785d124
--- /dev/null
+++ b/exercises/task/4-fnc-divide-basic.tex
@@ -0,0 +1,2 @@
+\subsection{Schriftliches Dividieren \stage2}
+Um das Problem der ungenauen Gleitkommadivision zumindest zum Teil zu lösen, ist deine Aufgabe, eine Funktion zu schreiben, die zwei (positive) Ganzzahlen dividiert und das Ergebnis als String zurück gibt. Das Ergebnis soll anschließend (in der main-Funktion) auf der Konsole ausgegeben werden. Dabei wollen wir uns das Vorgehen des schriftliches Dividierens zunutze machen. Den ganzzahligen Anteil des Ergebnisses darfst du direkt berechnen und brauchst das Vorgehen erst zur Berechnung der Nachkommastellen anwenden. Wenn die Division nicht aufgeht, also eine periodische Zahl liefern würde (zum Beispiel 1/3), braucht dein Programm nicht zu terminieren, es muss also kein Ergebnis liefern und darf endlos vor sich hin rechnen.
diff --git a/exercises/task/4-fnc-divide-theory.tex b/exercises/task/4-fnc-divide-theory.tex
new file mode 100644
index 0000000..e6bc24b
--- /dev/null
+++ b/exercises/task/4-fnc-divide-theory.tex
@@ -0,0 +1,9 @@
+\subsection{Schriftliches Dividieren - Theorie \stage2}
+Gleitkommaberechnungen sind in Python, sowie in den meisten anderen Programmiersprachen, nicht exakt. Kannst du dir denken wieso?
+\\Du kannst dir das Problem an dem folgenden Beispiel betrachten.
+\begin{lstlisting}
+a = 5.6
+b = 5.8
+c = a + b
+print("{0} + {1} = {2}".format(a,b,c))
+\end{lstlisting}
diff --git a/exercises/task/4-fnc-perm.tex b/exercises/task/4-fnc-perm.tex
new file mode 100644
index 0000000..f982602
--- /dev/null
+++ b/exercises/task/4-fnc-perm.tex
@@ -0,0 +1,7 @@
+\subsection{Permutationen (Level 3)}
+Schreibt eine Methode, die alle $n!$ Permutationen eines n Elemente großen
+int-Arrays ausgibt. Als Permutation bezeichnet man alle unterschiedlichen
+Möglichkeiten, die einzelnen Elemente des Arrays anzuordnen.
+\\Beispiel: Die Permutationen des drei-elementigen Arrays (1, 2, 3) sind (1, 2, 3),
+(1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2) und (3, 2, 1).
+\\Hinweis: Vielleicht findest du es einfacher, wenn das Array zu Beginn sortiert ist.
diff --git a/exercises/task/4-fnc-tabular.tex b/exercises/task/4-fnc-tabular.tex
new file mode 100644
index 0000000..de52772
--- /dev/null
+++ b/exercises/task/4-fnc-tabular.tex
@@ -0,0 +1,15 @@
+\subsection{Tabellen Ausgabe (Stufe 2)}
+Schreibt ein Programm, welches eine Tabelle von Potenzen ausgibt.
+\\\begin{tabular}{|c|c|c|c}\cline{1-3}
+n & $n^2$ & $n^3$ & \multirow{4}{*}{$\cdots$} \\\cline{1-3}
+1 & 1 & 1 & \\\cline{1-3}
+2 & 4 & 8 & \\\cline{1-3}
+3 & 9 & 27 & \\\cline{1-3}
+\multicolumn{3}{c}{\vdots}
+\end{tabular}
+\\Dabei soll die Größe (also die höchste Potenz und die höchste Basis) variabel,
+also von einer Benutzereingabe abhängig, sein. Zum Potenzieren kann die Funktion
+des Taschenrechners wiederverwendet werden. Wenn beide Klassen im selben Ordner
+liegen, kann die Potenz-Funktion ähnlich der Input-Funktionen direkt aus dem
+neuen Tabellen-Programm genutzt werden. Je nach vergebenen Namen kann der
+Funktionsaufruf etwa \lstinline{Taschenrechner.potenz(basis, exponent)} lauten.
diff --git a/exercises/task/4-list-fnc.tex b/exercises/task/4-list-fnc.tex
new file mode 100644
index 0000000..1263838
--- /dev/null
+++ b/exercises/task/4-list-fnc.tex
@@ -0,0 +1,13 @@
+\subsection{Summe und Durchschnitt einer Liste \stage1}
+Ergänze im folgende Code die fehlenden Codestellen, damit die beiden Funktionen die Summe und den Durchschnitt errechnen.
+\begin{lstlisting}
+def summe(werte):
+# to do: Rechne die Summe der Listenwerte aus
+	
+def durchschnitt(werte):
+# to do: Berechne den Durchschnitt mit Hilfe der Funktion "summe"
+
+werte = [2,4,6,8,10,12,14,16,18]
+print(summe(werte))
+print(durchschnitt(werte))
+\end{lstlisting}
diff --git a/exercises/task/4-rec-calcu.tex b/exercises/task/4-rec-calcu.tex
new file mode 100644
index 0000000..4c45fc9
--- /dev/null
+++ b/exercises/task/4-rec-calcu.tex
@@ -0,0 +1,21 @@
+\subsection{Ultimate Taschenrechner \stage3}
+Wir wollen den Taschenrechner nun auf Rekursion umstellen. Du kannst zur Vereinfachung
+davon ausgehen, dass beide Operanden positiv und ganze Zahlen sind (für Testeingaben
+musst du dich selbst dann aber auch daran halten).
+\\Im Folgenden werden an die verschiedenen Operatoren Bedingungen gestellt (die
+Funktionsnamen sind so gewählt wie in der Musterlösung von Tag 3, wenn deine
+Addierfunktion beispielsweise "`add"' heißt, musst du das \texttt{plus} in der Aufgabenstellung duch \texttt{add} ersetzen):
+\begin{itemize}
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{plus:}} verwende "`+1"', "`-1"' und plus
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{minus:}} verwende "`+1"', "`-1"' und minus
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{mal:}} verwende plus, minus und mal
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{teilen:}} verwende plus, minus und teilen (schreibe nur die Ganzzahldivision)
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{potenz:}} verwende plus, minus, mal, teilen und potenz
+\end{itemize}
+Du darfst nur die genannten Funktionen (wenn plus erlaubt ist, darfst du "`plus(x,y)"' aufrufen),
+konstante Zahlen, die Variablen zahl1 und zahl2 (also die Parameter) und das Prinzip
+der Rekursion verwenden. Du darfst keine Schleifen und keine arithmetischen Operatoren
+(+, -, *, /, ... ; nur +1 und -1) verwenden. Du darf die if-Anweisung verwenden.
+Wenn du einen Operator nicht umsetzen kannst, dann versuch dich an einem anderen.
+Du kannst beispielsweise die Multiplikation rekursiv umschreiben, ohne eine rekursive
+Addition zu schreiben; nutze dann einfach die bestehende Additionsfunktion.
diff --git a/exercises/task/4-rec-calcu2.tex b/exercises/task/4-rec-calcu2.tex
new file mode 100644
index 0000000..24fd90e
--- /dev/null
+++ b/exercises/task/4-rec-calcu2.tex
@@ -0,0 +1,10 @@
+\subsection{Ultimate Taschenrechner II \stage3}
+Erweitere den Taschenrechner im selben Stil noch um weitere Funktionen (in Klammern ist angegeben, wie die Funktion aufgerufen werden sollte):
+\begin{itemize}
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{modulo (\%):}} verwende plus, minus und modulo
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{ggT (T):}} verwende plus, minus, modulo und ggT
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{min ( \underline{\ \ } ):}} verwende plus, minus und min
+	\item \textbf{\textcolor[rgb]{0,0.5,1}{max (|):}} verwende plus, minus und max
+\end{itemize}
+Für den ggT (größten gemeinsamen Teiler) gilt:
+$$ggT(a,b)=\left\{\begin{tabular}{cc}b&wenn a=0,\\a&wenn b=0,\\ggt(b, a \% b)&sonst\end{tabular}\right.$$
\ No newline at end of file
diff --git a/exercises/task/4-rec-fac.tex b/exercises/task/4-rec-fac.tex
new file mode 100644
index 0000000..72b02f7
--- /dev/null
+++ b/exercises/task/4-rec-fac.tex
@@ -0,0 +1,7 @@
+\subsection{Fakultät rekursiv \stage1}
+Einnert euch an die Fakultät, diese ist wie folgt definiert:
+$n! =\left\{\begin{array}{cl} 1, & \mbox{falls }  n = 0 \\ n \cdot(n-1)!, & \mbox{sonst} \end{array}\right.$
+\begin{enumerate}
+	\item Berechne diese nun mitmilfe einer rekusiven Funktion.
+	\item Vergleiche das Ergebnis \textbf{15!} mit dem gestern berechneten Wert.
+\end{enumerate}
diff --git a/exercises/task/4-rec-fib.tex b/exercises/task/4-rec-fib.tex
new file mode 100644
index 0000000..4dadfb9
--- /dev/null
+++ b/exercises/task/4-rec-fib.tex
@@ -0,0 +1,6 @@
+\subsection{Fibonacci-Folge \stage2}
+Die Fibonacci-Folge ist eine Folge von Zahlen die nach einer festen Regel berechnet werden.
+Die ersten beiden Fibonacci-Zahlen sind definiert mit 0 und 1. Jede weitere Fibonacci-Zahl
+ist die Summe der beiden "`Vorgänger"'-Fibonacci-Zahlen. Der Anfang der Folge ist also 0,1,1,2,3,5,8,13,...
+\\Schreibe eine Funktion, die jeweils die n-te Fibonacci-Zahl mittels Rekursion berechnet.
+Gib anschließend die ersten 20 Fibonacci-Zahlen aus.
diff --git a/exercises/task/4-rec-oddeven.tex b/exercises/task/4-rec-oddeven.tex
new file mode 100644
index 0000000..82ce086
--- /dev/null
+++ b/exercises/task/4-rec-oddeven.tex
@@ -0,0 +1,4 @@
+\subsection{Gerade oder Ungerade \stage2}
+Schreibe zwei Funktionen \texttt{even} und \texttt{odd}, welche jeweils eine Zahl
+als Parameter entgegennehmen und ein boolean zurückgeben, wenn bei even die Zahl
+gerade und bei odd die Zahl ungerade ist. Für diese Funktionen dürft ihr weder den \%-Operator noch den /-Operator nutzen.
diff --git a/exercises/task/4-rec-pascal.tex b/exercises/task/4-rec-pascal.tex
new file mode 100644
index 0000000..aa611ed
--- /dev/null
+++ b/exercises/task/4-rec-pascal.tex
@@ -0,0 +1,7 @@
+\subsection{Pascalsches Dreieck \stage2}
+Schreibe eine Funktion, die eine Zahl im \href{https://de.wikipedia.org/wiki/Pascalsches_Dreieck}{Pascalschen Dreieck}
+berechnet. Deine Funktion bekommt zwei Parameter, wobei der erste die Zeile und
+der zweite die Position in der Zeile repräsentiert. Zur Berechnung soll die
+Summe zweier Zellen in der darüberliegenden Zeile gebildet werden (Animation
+auf der Wikipedia-Seite). Zeile 0 soll dabei die oberste Zeile sein. Sei n die
+Zeile, dann soll der zweite Parameter die Zahlen 0 bis n annehmen können.
diff --git a/exercises/task/4-theory-signature.tex b/exercises/task/4-theory-signature.tex
new file mode 100644
index 0000000..4127833
--- /dev/null
+++ b/exercises/task/4-theory-signature.tex
@@ -0,0 +1,12 @@
+\subsection{Funktionsköpfe (Stufe 1)}
+Welche der folgende Funktionsköpfe sind gültig.
+\begin{multicols}{2}
+\begin{enumerate}\small
+	\item public static void f1()
+	\item public static f2()
+	\item public static boolean f3(x, y)
+	\item public static int f4(int a, int b)
+	\item public static String f5(String, int)
+	\item public static String[] f6(String r, String[] c)
+\end{enumerate}
+\end{multicols}
\ No newline at end of file