Initial content commit

c_and_computergraphics/Einfuehrung_CG_8/Matrix_Aufgabe/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

c_and_computergraphics/Einfuehrung_CG_8/Matrix_Aufgabe/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.21)
+project(Matrix_Aufgabe C)
+
+set(CMAKE_C_STANDARD 17)
+
+add_executable(Matrix_Aufgabe main.c matrix/matrix.h matrix/matrix.c)

c_and_computergraphics/Einfuehrung_CG_8/Matrix_Aufgabe/main.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+
+#include "matrix/matrix.h"
+
+void print_matrix(matrix *m);
+
+void add_matrix();
+void multiply_matrix_with_scalar();
+void multiply_matrices();
+
+int main()
+{
+    add_matrix();
+    printf("\n");
+    multiply_matrix_with_scalar();
+    printf("\n");
+    multiply_matrices();
+
+    return 0;
+}
+
+void add_matrix()
+{
+    m_type type = {2, 2};
+    float v[2][2] = {
+            {1, 2},
+            {3, 4}
+    };
+    matrix *m1 = new_matrix_with_values(type, v);
+    matrix *m2 = new_matrix_with_values(type, v);
+
+    matrix *m = add(m1, m2);
+
+    print_matrix(m);
+
+    free_matrix(m1);
+    free_matrix(m2);
+    free_matrix(m);
+}
+
+void multiply_matrix_with_scalar()
+{
+    m_type type = {2, 2};
+    float v[2][2] = {
+            {1, 2},
+            {3, 4}
+    };
+    matrix *m = new_matrix_with_values(type, v);
+
+    m = multiply_with_scalar(0.5f, m);
+
+    print_matrix(m);
+
+    free_matrix(m);
+}
+
+void multiply_matrices()
+{
+    m_type type = {2, 2};
+    float v[2][2] = {
+            {1, 2},
+            {3, 4}
+    };
+    matrix *m1 = new_matrix_with_values(type, v);
+    matrix *m2 = new_matrix_with_values(type, v);
+
+    matrix *m = multiply(m1, m2);
+
+    print_matrix(m);
+
+    free_matrix(m1);
+    free_matrix(m2);
+    free_matrix(m);
+}
+
+void print_matrix(matrix *m)
+{
+    for (int i = 0; i < m->type.n; i++)
+    {
+        printf("[");
+        for (int j = 0; j < m->type.m; j++)
+        {
+            printf(" %6.3f ", m->values[i][j]);
+        }
+        printf("]\n");
+    }
+}

c_and_computergraphics/Einfuehrung_CG_8/Matrix_Aufgabe/matrix/matrix.c

@@ -0,0 +1,100 @@
+#include "matrix.h"
+#include <stdio.h>
+
+matrix *new_matrix(m_type type)
+{
+    matrix *m = malloc(sizeof(matrix));
+
+    m->type = type;
+    m->values = malloc(sizeof(float *) * type.n);
+
+    for (int i = 0; i < m->type.n; i++)
+    {
+        (m->values)[i] = malloc(sizeof(float) * type.m);
+    }
+
+    for (int i = 0; i < m->type.n; i++)
+    {
+        for (int j = 0; j < m->type.m; j++)
+        {
+            m->values[i][j] = 0;
+        }
+    }
+
+    return m;
+}
+
+matrix *new_matrix_with_values(m_type type, float v[type.n][type.m])
+{
+    matrix *m = new_matrix(type);
+
+    for (int i = 0; i < m->type.n; i++)
+    {
+        for (int j = 0; j < m->type.m; j++)
+        {
+            m->values[i][j] = v[i][j];
+        }
+    }
+
+    return m;
+}
+
+void free_matrix(matrix *m)
+{
+    for (int i = 0; i < m->type.n; i++)
+    {
+        free((m->values)[i]);
+    }
+
+    free(m->values);
+    free(m);
+}
+
+matrix *add(matrix *m1, matrix *m2)
+{
+    matrix *m = new_matrix(m1->type);
+
+    for (int i = 0; i < m->type.n; i++)
+    {
+        for (int j = 0; j < m->type.m; j++)
+        {
+            m->values[i][j] = m1->values[i][j] + m2->values[i][j];
+        }
+    }
+
+    return m;
+}
+
+matrix *multiply_with_scalar(float c, matrix *m)
+{
+    for (int i = 0; i < m->type.n; i++)
+    {
+        for (int j = 0; j < m->type.m; j++)
+        {
+            m->values[i][j] = c * m->values[i][j] ;
+        }
+    }
+
+    return m;
+}
+
+matrix *multiply(matrix *m1, matrix *m2)
+{
+    if (m1->type.m != m2->type.n) return NULL;
+
+    m_type type = {m1->type.n, m2->type.m};
+    matrix *m = new_matrix(type);
+
+    for (int i = 0; i < type.n; i++)
+    {
+        for (int j = 0; j < type.m; j++)
+        {
+            for (int k = 0; k < m1->type.m; k++)
+            {
+                m->values[i][j] += m1->values[i][k] * m2->values[k][j];
+            }
+        }
+    }
+
+    return m;
+}

c_and_computergraphics/Einfuehrung_CG_8/Matrix_Aufgabe/matrix/matrix.h

@@ -0,0 +1,21 @@
+#include <stdlib.h>
+
+typedef struct m_type {
+    int n, m;
+} m_type;
+
+typedef struct matrix {
+    m_type type;
+    float **values;
+} matrix;
+
+matrix *new_matrix(m_type type);
+matrix *new_matrix_with_values(m_type type, float v[type.n][type.m]);
+
+void free_matrix(matrix *m);
+
+matrix *add(matrix *m1, matrix *m2);
+
+matrix *multiply_with_scalar(float c, matrix *m);
+
+matrix *multiply(matrix *m1, matrix *m2);

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/Cargo.lock

@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "matrix"
+version = "0.1.0"
+
+[[package]]
+name = "matrix_aufgabe_rust"
+version = "0.1.0"
+dependencies = [
+ "matrix",
+]

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "matrix_aufgabe_rust"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies.matrix]
+path = "./src/matrix"

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/src/main.rs

@@ -0,0 +1,10 @@
+use matrix::Matrix;
+
+fn main() {
+    let m1 = Matrix::new_from_values(vec![vec![1f32, 2f32, 3f32], vec![4f32, 5f32, 6f32]]);
+    let m2 = Matrix::new_from_values(vec![vec![1f32, 2f32], vec![3f32, 4f32], vec![5f32, 6f32]]);
+
+    let m = m1 * m2;
+
+    println!("{}", m);
+}

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/src/matrix/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "matrix"
+version = "0.1.0"

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/src/matrix/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "matrix"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

c_and_computergraphics/Einfuehrung_CG_8/matrix_aufgabe_rust/src/matrix/src/lib.rs

@@ -0,0 +1,188 @@
+use std::fmt::{Display, Formatter};
+use std::ops::{Add, Mul};
+
+pub struct Matrix {
+    m_type: (usize, usize),
+    values: Vec<Vec<f32>>
+}
+
+impl Matrix {
+    pub fn new((m, n): (usize, usize)) -> Self {
+        let mut m_values = Vec::new();
+
+        for _i in 0..m {
+            m_values.push(vec![0f32; n]);
+        }
+
+        Self {
+            m_type: (m, n),
+            values: m_values
+        }
+    }
+
+    pub fn new_from_values(m_values: Vec<Vec<f32>>) -> Self {
+        Self {
+            m_type: (m_values.len(), m_values.get(0).unwrap().len()),
+            values: m_values
+        }
+    }
+
+    fn add_matrices(&self, m: &Self) -> Self {
+        let mut values = Vec::new();
+
+        for i in 0..self.m_type.0 {
+            let mut row = vec![];
+
+            for j in 0..self.m_type.1 {
+                let a = self.values.get(i).unwrap().get(j).unwrap();
+                let b = m.values.get(i).unwrap().get(j).unwrap();
+
+                row.push(a + b);
+            }
+
+            values.push(row);
+        }
+
+        Self::new_from_values(values)
+    }
+
+    pub fn multiply_with_scalar(&self, c: f32) -> Self {
+        let mut values = Vec::new();
+
+        for i in 0..self.m_type.0 {
+            let mut row = vec![];
+
+            for j in 0..self.m_type.1 {
+                let a = self.values.get(i).unwrap().get(j).unwrap();
+
+                row.push(c * a);
+            }
+
+            values.push(row);
+        }
+
+        Self::new_from_values(values)
+    }
+
+    fn multiply(&self, m: &Self) -> Self {
+        let mut values = Vec::new();
+
+        for i in 0..self.m_type.0 {
+            let mut row = vec![];
+
+            for j in 0..m.m_type.1 {
+                let mut c = 0f32;
+
+                for k in 0..self.m_type.1 {
+                    let a = self.values.get(i).unwrap().get(k).unwrap();
+                    let b = m.values.get(k).unwrap().get(j).unwrap();
+
+                    c += a * b;
+                }
+
+                row.push(c);
+            }
+
+            values.push(row);
+        }
+
+        Self::new_from_values(values)
+    }
+}
+
+impl Add for Matrix {
+    type Output = Matrix;
+
+    fn add(self, m2: Self) -> Self::Output {
+        self.add_matrices(&m2)
+    }
+}
+
+impl Mul for Matrix {
+    type Output = Matrix;
+
+    fn mul(self, m2: Self) -> Self::Output {
+        self.multiply(&m2)
+    }
+}
+
+impl Display for Matrix {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.values)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Matrix;
+
+    #[test]
+    fn should_return_2_2_matrix_with_zeros() {
+        let matrix = Matrix::new((2, 2));
+
+        assert_eq!(matrix.m_type, (2, 2));
+        assert_eq!(matrix.values, vec![vec![0f32, 0f32], vec![0f32, 0f32]]);
+    }
+
+    #[test]
+    fn should_return_2_2_matrix_with_values() {
+        let matrix = Matrix::new_from_values(vec![vec![0f32, 1f32], vec![2f32, 3f32]]);
+
+        assert_eq!(matrix.m_type, (2, 2));
+        assert_eq!(matrix.values, vec![vec![0f32, 1f32], vec![2f32, 3f32]]);
+    }
+
+    #[test]
+    fn should_add_two_matrices() {
+        let m1 = Matrix::new_from_values(vec![vec![0f32, 1f32], vec![2f32, 3f32]]);
+        let m2 = Matrix::new_from_values(vec![vec![4f32, 5f32], vec![6f32, 7f32]]);
+
+        let m3 = m1.add_matrices(&m2);
+
+        assert_eq!(m3.m_type, (2, 2));
+        assert_eq!(m3.values, vec![vec![4f32, 6f32], vec![8f32, 10f32]]);
+    }
+
+    #[test]
+    fn should_add_two_matrices_with_op() {
+        let m1 = Matrix::new_from_values(vec![vec![0f32, 1f32], vec![2f32, 3f32]]);
+        let m2 = Matrix::new_from_values(vec![vec![4f32, 5f32], vec![6f32, 7f32]]);
+
+        let m3 = m1 + m2;
+
+        assert_eq!(m3.m_type, (2, 2));
+        assert_eq!(m3.values, vec![vec![4f32, 6f32], vec![8f32, 10f32]]);
+    }
+
+    #[test]
+    fn should_multiply_matrix_with_2() {
+        let m1 = Matrix::new_from_values(vec![vec![0f32, 1f32], vec![2f32, 3f32]]);
+
+        let m = m1.multiply_with_scalar(2f32);
+
+        assert_eq!(m.m_type, (2, 2));
+        assert_eq!(m.values, vec![vec![0f32, 2f32], vec![4f32, 6f32]]);
+    }
+
+    #[test]
+    fn should_multiply_matrices() {
+        let m1 = Matrix::new_from_values(vec![vec![1f32, 2f32, 3f32], vec![4f32, 5f32, 6f32]]);
+        let m2 = Matrix::new_from_values(vec![vec![1f32, 2f32], vec![3f32, 4f32], vec![5f32, 6f32]]);
+
+        let m = m1.multiply(&m2);
+
+        assert_eq!(m.m_type, (2, 2));
+        assert_eq!(m.values, vec![vec![22f32, 28f32], vec![49f32, 64f32]]);
+    }
+
+    #[test]
+    fn should_multiply_matrices_with_op() {
+        let m1 = Matrix::new_from_values(vec![vec![1f32, 2f32, 3f32], vec![4f32, 5f32, 6f32]]);
+        let m2 = Matrix::new_from_values(vec![vec![1f32, 2f32], vec![3f32, 4f32], vec![5f32, 6f32]]);
+
+        let m = m1 * m2;
+
+        assert_eq!(m.m_type, (2, 2));
+        assert_eq!(m.values, vec![vec![22f32, 28f32], vec![49f32, 64f32]]);
+    }
+}

java/Uebung/Uebung_1/Uebungsaufgaben_1.tex

@@ -0,0 +1,68 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 1}
+\subtitle{Zahlensysteme}
+\date{}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Bekanntlich heißen Zahlensysteme ja auch Stellenwertsysteme. Begründe warum.
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Das Dezimalsystem ist das System, mit dem wir hauptsächlich im Alltag umgehen und in dem auch gerechnet wird. Schreibe folgende Zahlen im Dezimalsystem ausführlich, also als Summe, hin:
+	\begin{itemize}
+		\item[a)] $5_{10}$
+		\item[b)] $46_{10}$
+		\item[c)] $198_{10}$
+		\item[d)] $10359_{10}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 3}\mbox{}\\	
+	Das Binärsystem ist in der Informatik, Informationstechnik und andere eng verwandte Wissenschaften und Technologiebereichen weit verbreitet, da moderne Rechensysteme (z.B. Computer) im Grunde ausschließlich damit arbeiten. Daher kann es öfter mal vorkommen, dass Binär- in Dezimalzahlen umgerechnet werden müssen. Rechne um: 
+	\begin{itemize}
+		\item[a)] $10_{2}$
+		\item[b)] $110_{2}$
+		\item[c)] $11001_{2}$
+		\item[d)] $100011110_{2}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Auch die Rückrichtung ist relevant! Rechne die Dezimalzahlen aus 2) ins Binärsystem um.
+	
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Das Oktalsystem kommt zwar seltener vor, aber es ist eine gute Übung. Rechne folgende Oktalzahlen in Dezimalzahlen um:
+	\begin{itemize}
+		\item[a)] $5_{8}$
+		\item[b)] $46_{8}$
+		\item[c)] $175_{8}$
+		\item[d)] $10354_{8}$
+	\end{itemize}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Rechne die Dezimalzahlen aus 2) in Oktalzahlen um.
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Das hexadezimale Zahlensystem ist neben dem Binärsystem enorm wichtig in Informatik und Co. Daher rechne bitte folgende Hexadezimalzahlen ins Dezimalsystem um:
+	\begin{itemize}
+		\item[a)] $5_{16}$
+		\item[b)] $FF_{16}$
+		\item[c)] $A6E_{16}$
+		\item[d)] $7B9F3C_{16}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Ihr kennt das Spiel: Die Dezimalzahlen aus 2) in Hexadezimalzahlen umrechnen.
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Das schöne zwischen Binär- und Hexadezimalzahlen ist, dass man sie ganz leicht ineinander umrechnen kann. Vier Binärstellen entsprechen einer Hexadezimalstelle. Ähnlich ist das bei Binär zu Oktal auch: Drei Binärziffern entsprechen einer Oktalziffer. Im Folgenden rechne also bitte die angegebene Binärzahl sowohl in Hexadezimal, als auch Oktalzahl um (Zur Vereinfachung, habe ich bereits die Hexadezimalzahl zu je Vierer- bzw. Dreiergruppen hingeschrieben):
+	\begin{itemize}
+		\item[] $1110\ 1001\ 0011\ 1100\ 1101\ 1111\ 0011\ 0011\ 0011_{2}$
+		\item[] $111\ 010\ 010\ 011\ 110\ 011\ 011\ 111\ 001\ 100\ 110\ 011_{2}$
+	\end{itemize}
+\end{document}

java/Uebung/Uebung_1/Uebungsaufgaben_1_Loesung.tex

@@ -0,0 +1,258 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+ \usepackage{amsfonts,amssymb,amsmath}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 1 - Lösung}
+\subtitle{Zahlensysteme}
+\date{}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Bekanntlich heißen Zahlensysteme ja auch Stellenwertsysteme. Begründe warum.
+	
+	\subparagraph{Lösung:} \emph{Die Stellen, an denen Ziffern stehen haben eine Stellenwertigkeit.}\\ Für interessierte Lesende, hier mehr Infos: Eine Zahl sieht im allgemeinen wie folgt aus (Nennt sich $b$-adische Form): $a_B := z_nz_{n-1}z_{n-2} \dots z_0$ mit $z \in \Sigma$ und $n \in \mathbb{N}_0$. $\Sigma$ ist hierbei als ein Alphabet zu betrachten, aus dem die Zahl also zusammen gesetzt werden kann. Für das Binärsystem wäre $\Sigma = \{0,1\}$, für das Dezimalsystem $\Sigma = \{0,1,2,3,4,5,6,7,8,9\}$. Die Basis eines Zahlensystems ist außerdem nichts anderes als die Anzahl der Elemente im Alphabet $\Sigma$, also $B = |\Sigma|$. Die Stellenwertigkeit ergibt sich nun aus der Formel $B^n$, wobei $n$ der Stellenindex ist (siehe oben $a$). Die Stelle mit der Ziffer $z_5$ Stelle hat also die Stellenwertigkeit $B^5$. Mit diesen Erkenntnissen lässt sich nun auch die Zahl $a$ ausführlich mit den Stellenwertigkeiten darstellen: \\
+	$a = z_n \cdot B^n + z_{n-1} \cdot B^{n-1} + z_{n-2} \cdot B^{n-2} + \dots + z_0 \cdot B^0
+	= \sum_{k=0}^{n} z_k \cdot B^k$.\\
+	An dieser Stelle möchte ich noch drei Dinge anmerken:
+	\begin{itemize}
+		\item[1)] Wir rechnen eigentlich immer im Dezimalsystem, weil uns das einfach sehr gut liegt. Aber nehmen wir mal das Beispiel $A_{H}$. Ausführlich wäre das ja $A_{H} = A \cdot 16^0$, da $A$ ja die Ziffer an der Stelle mit der Stellenwertigkeit $16^0$ ist. Aber wie rechnen wir bitte $A \cdot 16^0$? Nun, ich habe bisher verschwiegen, dass wir eigentlich nicht die Ziffer selbst multiplizieren (wie die Formel ja sagt), sondern eigentlich den Ziffernwert. Der Ziffernwert ist einfach eine natürliche Zahl und das Bild der Abbildung $f(z_n) = \begin{cases}
+			\Sigma \rightarrow \mathbb{N}_0\\
+			z_n \rightarrow n
+		\end{cases}$.\\
+		Beispiel mit $\Sigma = \{0_0,\dots,9_9,A_{10},B_{11},\dots,F_{15}\}: f(A_{10}) = 10$, also jeder Ziffer wird die Position zugeordnet und die Position in der Menge ist also der Ziffernwert (Achtung: $\Sigma$ muss eine geordnete Menge sein: $(\Sigma, \le)$). Unser Beispiel $A_H$ wäre also eigentlich $A_{H} = f(A) \cdot 16^0 = 10 \cdot 16^0$. Und das können wir wieder gut rechnen, da das im Dezimalsystem ist.
+		
+		\item[2)] Genau genommen sind Zahlensysteme und Stellenwertsysteme nicht das gleiche, sondern ein Stellenwertsystem ist ein positionelles Zahlensystem. Es gibt noch andere Arten von Zahlensystemen.
+		
+		\item[3)] Ich habe oben den Begriff Alphabet verwendet. Tatsächlich sind wir hier in der theoretischen Informatik, genauer den formalen Sprachen. Die Zahl $a$ ist nichts anderes als ein Wort, das mit Elementen aus dem Alphabet $\Sigma$ gebildet wurde. Die Menge aller möglichen Kombinationen mit den Elementen eines Alphabets $\Sigma$ nennt sich Kleenesche Hülle und wird mit $\Sigma^*$ bezeichnet. Also die Kleenesche Hülle von $\Sigma = \{0,1\}$ ist $\Sigma^* = \{0,1,10,11,100,101,\dots\}$ und das sieht doch irgendwie nach der Menge aller Binärzahlen aus, oder? Die Zahl $a \in \Sigma^*$ kann also auch als Wort einer formalen Sprache aufgefasst werden. Hier ist die formale Sprache sogar eine sogenannte reguläre Sprache. Aber genug theoretische Informatik.
+	\end{itemize}
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Das Dezimalsystem ist da System, mit dem wir hauptsächlich im Alltag umgehen und auch gerechnet wird. Schreibe folgende Zahlen im Dezimalsystem ausführlich, also als Summe, hin:
+	\begin{itemize}
+		\item[a)] $5_{10}$
+		\item[b)] $46_{10}$
+		\item[c)] $198_{10}$
+		\item[d)] $10359_{10}$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 5 \cdot 10^0$
+		\item[b)] $46_{10} = 4 \cdot 10^1 + 6 \cdot 10^0$
+		\item[c)] $198_{10} = 1 \cdot 10^2 + 9 \cdot 10^1 + 8 \cdot 10^0$
+		\item[d)] $10359_{10} = 1 \cdot 10^4 + 0 \cdot 10^3 + 3 \cdot 10^2 + 5 \cdot 10^1 + 9 \cdot 10^0$
+	\end{itemize}
+		
+	\paragraph{Aufgabe 3}\mbox{}\\	
+		Das Binärsystem ist in der Informatik, Informationstechnik und andere eng verwandte Wissenschaften und Technologiebereichen weit verbreitet, da moderne Rechensysteme (z.B. Computer) im Grunde ausschließlich damit arbeiten. Daher kann es öfter mal vorkommen, dass Binär- in Dezimalzahlen umgerechnet werden müssen. Rechne um: 
+	\begin{itemize}
+		\item[a)] $10_{2}$
+		\item[b)] $110_{2}$
+		\item[c)] $11001_{2}$
+		\item[d)] $100011110_{2}$
+	\end{itemize}
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $10_{2} = 1 \cdot 2^1 = 2_{10}$
+		\item[b)] $110_{2} = 1 \cdot 2^2 + 1 \cdot 2^1 = 6_{10}$
+		\item[c)] $11001_{2} = 1 \cdot 2^4 + 1 \cdot 2^3 + 1 \cdot 2^0 = 25_{10}$
+		\item[d)] $100011110_{2} 
+		           = 1 \cdot 2^8 + 1 \cdot 2^4 + 1 \cdot 2^3 + 1 \cdot 2^2 +  1 \cdot 2^1
+		           = 286_{10}$
+	\end{itemize}
+
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Auch die Rückrichtung ist relevant! Rechne die Dezimalzahlen aus 2) ins Binärsystem um.
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 101_2$
+	  	\begin{alignat*}{3}
+		  	5 / 2 &= 2 && \quad R\ 1\\
+		  	2 / 2 &= 1 && \quad R\ 0\\
+		  	1 / 2 &= 0 && \quad R\ 1
+	  	\end{alignat*}
+	  	
+		\item[b)] $46_{10} = 10\ 1110_2$
+		\begin{alignat*}{3}
+			46 / 2 &= 23 && \quad R\ 0\\
+			23 / 2 &= 11 && \quad R\ 1\\
+			11 / 2 &= 5 && \quad R\ 1\\
+			5 / 2 &= 2 && \quad R\ 1\\
+			2 / 2 &= 1 && \quad R\ 0\\
+			1 / 2 &= 0 && \quad R\ 1
+		\end{alignat*}
+		
+		
+		\item[c)] $198_{10} = 1100\ 0110_2$
+		\begin{alignat*}{3}
+			198 / 2 &= 99 && \quad R\ 0\\
+			99 / 2 &= 49 && \quad R\ 1\\
+			49 / 2 &= 24 && \quad R\ 1\\
+			24 / 2 &= 12 && \quad R\ 0\\
+			12 / 2 &= 6 && \quad R\ 0\\
+			6 / 2 &= 3 && \quad R\ 0\\
+			3 / 2 &= 1 && \quad R\ 1\\
+			1 / 2 &= 0 && \quad R\ 1
+		\end{alignat*}
+		
+		
+		\item[d)] $10359_{10} = 10\ 1000\ 0111\ 0111_2$
+		\begin{alignat*}{3}
+			10359 / 2 &= 5179 && \quad R\ 1\\
+			5179 / 2 &= 2589 && \quad R\ 1\\
+			2589 / 2 &= 1294 && \quad R\ 1\\
+			1294 / 2 &= 647 && \quad R\ 0\\
+			647 / 2 &= 323 && \quad R\ 1\\
+			323 / 2 &= 161 && \quad R\ 1\\
+			161 / 2 &= 80 && \quad R\ 1\\
+			80 / 2 &= 40 && \quad R\ 0\\
+			40 / 2 &= 20 && \quad R\ 0\\
+			20 / 2 &= 10 && \quad R\ 0\\
+			10 / 2 &= 5 && \quad R\ 0\\
+			5 / 2 &= 2 && \quad R\ 1\\
+			2 / 2 &= 1 && \quad R\ 0\\
+			1 / 2 &= 0 && \quad R\ 1
+		\end{alignat*}
+	\end{itemize}
+	
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Das Oktalsystem kommt zwar seltener vor, aber es ist eine gute Übung. Rechne folgende Oktalzahlen in Dezimalzahlen um:
+	\begin{itemize}
+		\item[a)] $5_{8}$
+		\item[b)] $46_{8}$
+		\item[c)] $175_{8}$
+		\item[d)] $10354_{8}$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{8} = 5 \cdot 8^0 = 5_{10}$
+		\item[b)] $46_{8} = 4 \cdot 8^1 + 6 \cdot 8^0 = 38_{10}$
+		\item[c)] $175_{8} = 1 \cdot 8^2 + 7 \cdot 8^1 + 5 \cdot 8^0 = 125_{10}$
+		\item[d)] $10354_{8} = 1 \cdot 8^4 + 3 \cdot 8^2 + 5 \cdot 8^1 + 4 \cdot 8^0 = 4332_{10}$
+	\end{itemize}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Rechne die Dezimalzahlen aus 2) in Oktalzahlen um.
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 5_8$
+		\begin{alignat*}{3}
+		5 / 8 &= 0 && \quad R\ 5
+		\end{alignat*}
+		
+		\item[b)] $46_{10} = 56_8$
+		\begin{alignat*}{3}
+		46 / 8 &= 5 && \quad R\ 6\\
+		5 / 8 &= 0 && \quad R\ 5
+		\end{alignat*}
+		
+		
+		\item[c)] $198_{10} = 306_8$
+		\begin{alignat*}{3}
+		198 / 8 &= 24 && \quad R\ 6\\
+		24 / 8 &= 3 && \quad R\ 0\\
+		3 / 8 &= 0 && \quad R\ 3
+		\end{alignat*}
+		
+		
+		\item[d)] $10359_{10} = 24167_8$
+		\begin{alignat*}{3}
+		10359 / 8 &= 1294 && \quad R\ 7\\
+		1294 / 8 &= 161 && \quad R\ 6\\
+		161 / 8 &= 20 && \quad R\ 1\\
+		20 / 8 &= 2 && \quad R\ 4\\
+		2 / 8 &= 0 && \quad R\ 2
+		\end{alignat*}
+	\end{itemize}
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Das hexadezimale Zahlensystem ist neben dem Binärsystem enorm wichtig in Informatik und Co. Daher rechne bitte folgende Hexadezimalzahlen ins Dezimalsystem um:
+	\begin{itemize}
+		\item[a)] $5_{16}$
+		\item[b)] $FF_{16}$
+		\item[c)] $A6E_{16}$
+		\item[d)] $7B9F3C_{16}$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{16} = 5 \cdot 16^0 = 5_{10}$
+		\item[b)] $FF_{16} = 15 \cdot 16^1 + 15 \cdot 16^0 = 255_{10}$
+		\item[c)] $A6E_{16} = 10 \cdot 16^2 + 6 \cdot 16^1 + 14 \cdot 16^0 = 2670_{10}$
+		\item[d)] $7B9F3C_{16} = 7 \cdot 16^5 + 11 \cdot 16^4 + 9 \cdot 16^3 + 15 \cdot 16^2 + 3 \cdot 16^1 + 12 \cdot 16^0 = 8101692_{10} $
+	\end{itemize}
+
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Ihr kennt das Spiel: Die Dezimalzahlen aus 2) in Hexadezimalzahlen umrechnen.
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 5_{16}$
+		\begin{alignat*}{3}
+		5 / 16 &= 0 && \quad R\ 5
+		\end{alignat*}
+		
+		\item[b)] $46_{10} = 2E_{16}$
+		\begin{alignat*}{3}
+		46 / 16 &= 2 && \quad R\ 14\\
+		2 / 16 &= 0 && \quad R\ 2
+		\end{alignat*}
+		
+		
+		\item[c)] $198_{10} = C6_{16}$
+		\begin{alignat*}{3}
+		198 / 16 &= 12 && \quad R\ 6\\
+		12 / 16 &= 0 && \quad R\ 12
+		\end{alignat*}
+		
+		
+		\item[d)] $10359_{10} = 2877_{16}$
+		\begin{alignat*}{3}
+		10359 / 16 &= 647 && \quad R\ 7\\
+		647 / 16 &= 40 && \quad R\ 7\\
+		40 / 16 &= 2 && \quad R\ 8\\
+		2 / 16 &= 0 && \quad R\ 2
+		\end{alignat*}
+	\end{itemize}
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Das schöne zwischen Binär- und Hexadezimalzahlen ist, dass man sie ganz leicht ineinander umrechnen kann. Vier Binärstellen entsprechen einer Hexadezimalstelle. Ähnlich ist das bei Binär zu Oktal auch: Drei Binärziffern entsprechen einer Oktalziffer. Im Folgenden rechne also bitte die angegebene Binärzahl sowohl in Hexadezimal, als auch Oktalzahl um (Zur Vereinfachung, habe ich bereits die Hexadezimalzahl zu je Vierer- bzw. Dreiergruppen hingeschrieben):
+	\begin{itemize}
+		\item[] $1110\ 1001\ 0011\ 1100\ 1101\ 1111\ 0011\ 0011\ 0011_{2}$
+		\item[] $111\ 010\ 010\ 011\ 110\ 011\ 011\ 111\ 001\ 100\ 110\ 011_{2}$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[] $\underbrace{1110}_{E}\ 
+		\underbrace{1001}_{9}\ 
+		\underbrace{0011}_{3}\ 
+		\underbrace{1100}_{C}\ 
+		\underbrace{1101}_{D}\ 
+		\underbrace{1111}_{F}\ 
+		\underbrace{0011}_{3}\ 
+		\underbrace{0011}_{3}\ 
+		\underbrace{0011_{2}}_{3_{16}}$
+		\item[] $\underbrace{111}_{7}\ 
+		\underbrace{010}_{2}\ 
+		\underbrace{010}_{2}\ 
+		\underbrace{011}_{3}\ 
+		\underbrace{110}_{6}\ 
+		\underbrace{011}_{3}\ 
+		\underbrace{011}_{3}\ 
+		\underbrace{111}_{7}\ 
+		\underbrace{001}_{1}\ 
+		\underbrace{100}_{4}\ 
+		\underbrace{110}_{6}\ 
+		\underbrace{011_{2}}_{3_8}$
+	\end{itemize}
+
+\end{document}

java/Uebung/Uebung_2/Uebungsaufgaben_2.tex

@@ -0,0 +1,140 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 2}
+\subtitle{Aussagenlogik}
+\date{}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Was ist eine Aussage?
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Welche der folgenden sind Aussagen und wie lautet die negierte Aussage?
+	\begin{itemize}
+		\item[a)] Die Sonne scheint.
+		\item[b)] Der Fernseher ist aus.
+		\item[c)] Kleiner Otter.
+		\item[d)] $y < x$
+		\item[e)] $x - z$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 3}\mbox{}\\	
+	In der Aussagenlogik geht es ja u.a. darum, Aussagen zu verknüpfen und den Wahrheitswert der verknüpften Aussage zu ermitteln. Für die Verknüpfung von Aussagen stehen verschiedene Logik-Operatoren, auch Junktoren genannt, bereit. Wie heißen diese, wie schreibt man sie in der Mathematik und wie sieht die Wertetabelle aus?
+	
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Mathematiker führen ja v.a. beweise durch. Dabei sind Beweise logische Schlussfolgerungen. Man nimmt also eine Aussage her und aus dieser schlussfolgert man solange mit wahren Aussagen, bis man das zu Beweisende hergeleitet hat. Dadurch, dass nur wahre Aussagen verwendet werden ist die Mathematik korrekt (so ziemlich als einzige Wissenschaft [neben der Informatik]). Die Schlussfolgerungen fußen dabei auf der sogenannten \emph{(materiale) Implikation}. Die Implikation lässt sich folgendermaßen in Worte fassen ''Wenn ..., dann ...''. Die Implikation soll uns an anderer Stelle nochmal etwas genauer begegnen. Doch hier wollen wir einfach mal einen sehr kleinen Beweis führen. Beweise folgende Aussage:
+	\begin{itemize}
+		\item[] Das Quadrat einer geraden natürlichen Zahl, ist wieder gerade.
+	\end{itemize}
+	
+	\paragraph{Aufgabe 5 - Zusatz}\mbox{}\\
+	Aufgabe 4 ist eigentlich gar nicht schwer - aber sehr kurz. Der Beweis hier ist immer noch kurz, aber etwas länger, als der aus Aufgabe 4. Deshalb ist es Zusatz.
+	Beweise folgende Aussage:
+	\begin{itemize}
+		\item[] $\sqrt{2}$ ist irrational
+	\end{itemize}
+	\emph{Hinweis: Das Resultat aus Aufgabe 4 wird hier benötigt.}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Kommen wir zur Implikation zurück. Die Implikation ist erfahrungsgemäß am Anfang nicht so leicht, denn es gibt eine Zeile in der Wahrheitstabelle, die vielen erst mal Kopfschmerzen bereitet.
+	Das Zeichen für die Implikation ist $\Rightarrow$. Nehmen wir uns mal ein Beispiel her und leiten uns die Wahrheitstabelle für die Implikation her:
+	\begin{itemize}
+		\item[] $A = $ Das Wetter ist gut.
+		\item[] $B = $ Ich gehe ins Freibad.
+	\end{itemize}
+	In Worten ist $A \Rightarrow B$: Wenn das Wetter gut ist, dann gehe ich ins Freibad.\\
+	Jetzt nehmen wir an, das Wetter ist gut und ihr seht mich im Freibad. Dann habe ich offensichtlich nicht gelogen. Wenn schlechtes Wetter ist und ihr seht mich nicht im Freibad, dann ist ja auch irgendwie alles gut. Wenn schlechtes Wetter ist, aber ihr seht mich dieses Mal im Freibad, dann fragt ihr euch vielleicht, warum  zur Hölle man bei schlechtem Wetter schwimmen geht, aber gelogen hab ich nicht. Ich gabe ja nur gesagt, was ich mache, wenn gutes Wetter ist, nicht aber wenn schlechtes Wetter ist! Lediglich, wenn gutes Wetter ist, ich aber nicht im Freibad bin, dann hab ich gelogen! So ein Drecksack, was?\\
+	Zusammengefasst ergibt sich folgende allgemeine Wahrheitstabelle:\\
+	$\begin{array}{cc|c}
+		A & B & A \Rightarrow B\\
+		\hline
+		0 & 0 & 1\\
+		0 & 1 & 1\\
+		1 & 0 & 0\\
+		1 & 1 & 1
+	\end{array}$\\
+	In Worten heißt das, dass wenn ihr aus wahren Aussagen falsche Aussagen folgert, dann ist das einfach falsch! Also wenn ihr folgert $1+2=3 \Rightarrow 1=3$ dann stimmt das wohl offensichtlich nicht, weil $1 \ne 3$ gilt! Wenn ihr aber $4 \text{ ist prim} \Rightarrow 2 \cdot 5 = 10$ habt, dann stimmt das doch. $4 \text{ ist prim}$ ist offensichtlich falsch, aber $2 \cdot 5 = 10$ ist wahr, also ist die Aussage wahr. Achso übrigens, die Umkehrung gilt im Allgemeinen nicht! Also $A \Rightarrow B$ ist nicht unbedingt das Gleiche, wie $B \Rightarrow A$ (siehe nächste Aufgabe)!
+	Naja, also lassen wir das. Hier mal ein paar konkrete Implikationen, für die ihr den eindeutigen Wahrheitswert ermitteln könnt:
+	\begin{itemize}
+		\item[a)] Die Sonne ist der nächste Planet zur Erde $\Rightarrow$ Pluto ist kein Planet
+		\item[b)] Eine Flasche ist nach dem Trinken voller als davor $\Rightarrow$ Kreuzberg liegt neben Schönefeld
+		\item[c)] $2^2 = 4 \Rightarrow 3^2 = 5$
+		\item[d)] $34 \ne 35 \Rightarrow 18-1=17$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Nun, es gibt Aussagen, die zu keiner Zeit stimmen, und es gibt Aussagen, die immer stimmen. Ersteres nennt man \emph{unerfüllbar} und letzteres ist \emph{allgmeingültig}. Allgemeingültige Aussagen nennt man auch \emph{Tautologie}. Alles dazwischen heißt schlicht und einfach \emph{erfüllbar}. Eine Tautologie ist also immer wahr? JA! Das bringt uns mal etwas weiter und wir kommen zur \emph{Äquivalenz}, als Zeichen $\Leftrightarrow$. In Worten sagt man ''$A$ ist äquivalent zu $B$'' oder, v.a. in der Mathematik zu finden: ''$A$ genau dann, wenn $B$''. Vielleicht erinnert ihr euch noch an das \emph{XOR}, das auch \emph{Antivalenz} heißt. Warum das so ist, werden wir jetzt sehen.\\
+	Bei der Antivalenz ist die Gesamtaussage nur dann wahr, wenn ausschließlich eine der beiden Aussagen wahr ist, also mit Wahrheitstabelle ausgedrückt:\\
+	$\begin{array}{cc|c}
+		A & B & A \oplus B\\
+		\hline
+		0 & 0 & 0\\
+		0 & 1 & 1\\
+		1 & 0 & 1\\
+		1 & 1 & 0
+	\end{array}$\\
+	Der Äquivalenz-Operator ist dazu Gegensätzlich:\\
+	$\begin{array}{cc|c}
+		A & B & A \Leftrightarrow B\\
+		\hline
+		0 & 0 & 1\\
+		0 & 1 & 0\\
+		1 & 0 & 0\\
+		1 & 1 & 1
+	\end{array}$\\
+	Und das gilt immer! Wie war das? Wenn etwas immer gilt, dann ist das eine Tautologie? Können wir das mit einer Wertetabelle mal zeigen? JA! Wir können mit einer Wahrheitstabelle beweise führen! Übrigens ein Teil der Künstlichen Intelligenz beschäftigt sich mit automatischen Beweisern. Die machen dann im Grunde nichts anderes, als Logik und mit Wertetabellen Beweise führen. Nun aber zur Wahrheitstabelle. Zu zeigen ist folgende Aussage: $(\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)$. Dazu werden wir die Aussagen einzeln aufschreiben und dann zusammen setzen:\\
+	$\begin{array}{cc|c|c|c|c}
+		A & B & A \oplus B & \overline{A \oplus B} & A \Leftrightarrow B & (\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)\\
+		\hline
+		0 & 0 & 0 & 1 & 1 & 1\\
+		0 & 1 & 1 & 0 & 0 & 1\\
+		1 & 0 & 1 & 0 & 0 & 1\\
+		1 & 1 & 0 & 1 & 1 & 1
+	\end{array}$\\
+	Das gilt also immer! Streng genommen sind $\overline{A \oplus B}$ und $A \Leftrightarrow B$ Formeln für sich. Wenn wir in der Aussagenlogik Aussagen über Formeln machen (Metalogik), dann wäre die korrekte Schreibweise $(\overline{A \oplus B}) \equiv (A \Leftrightarrow B)$. Aber das $\equiv$ bedeutet gerade, dass die beiden Formeln genau dieselben Modelle haben, also unter den gleichen Interpretationen wahr sind (siehe Aufgabe 9). Und das ist genau dann der Fall, wenn $(\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)$ eine Tautologie ist. Deshalb ist das hier in Ordnung für uns.\\
+	Führt nach obigem Schema mit folgenden Aufgaben durch und zeigt diese Tautologien:
+	\begin{itemize}
+		\item[a)] $(A \Rightarrow B) \Leftrightarrow (\overline{A} \vee B)$
+		\item[b)] $(A \Rightarrow B) \Leftrightarrow (\overline{B} \Rightarrow \overline{A})$
+		\item[c)] $((A \Rightarrow B) \wedge (B \Rightarrow A) \Leftrightarrow (A \Leftrightarrow B)$
+		\item[d)] $(A \vee (A \wedge B)) \Leftrightarrow A$
+	\end{itemize}
+	Übrigens diese vier Tautologien sind wichtig. a) ist die Implikation mit den ''Grundoperatoren'' ausgedrückt (Mit den Operatoren $\wedge,\ \vee$ und \emph{NOT}, kann man in der Aussagenlogik alle Aussagen verknüpfen, d.h. es ist ein vollständiges Set Operatoren für die Aussagenlogik). c) zeigt die Beziehung zwischen Implikation und Äquivalenz. Etwas ist Äquivalent, wenn es in beide Richtung impliziert werden, also wenn B aus A und A aus B folgt. c) heißt Kontraposition und ist das Grundprinzip für den \emph{indirekten Beweis}, eine Beweismethode der Mathematik. d) nennt sich Absorption.
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Tautologien müssen nicht zwangsläufig durch Äquivalenzen entstehen. Zeige, dass folgende Aussage auch eine Tautologie ist:
+	\begin{itemize}
+		\item[] $((\overline{A} \Rightarrow B) \wedge \overline{B}) \Rightarrow A$
+	\end{itemize}
+	Diese Tautologie nennt sich Widerspruch und ist Grundlage des Widerspruchsbeweis (Aufgabe 5 ist ein Widerspruchsbeweis, sofern man den Beweis wie Euklid geführt hat).
+	\\\\
+	\emph{(Anmerkung, sowohl die Kontraposition, als auch der Widerspruch führen zu einem Widerspruch! Beides sind also Widerspruchsbweise, es gilt also quasi Widerspruchsbeweis = indirekter Beweis! Es sind also nur zwei Arten, wie man einen Widerspruchsbeweis angehen kann.)}
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Wir haben jetzt ganz schön viel Handwerkszeug, um aus zusammengesetzten Aussagen Wahrheitswerte zu ermitteln. Wir nehmen nun noch eine Variable mit hinzu. Übrigens: Eine Zeile einer Wahrheitstabelle wird Interpretation genannt. Die Wahrheitstabelle ist also eigentlich nichts anderes, als alle möglichen Kombinationen der Wahrheitswerte der Variablen (alle Interpretationen) aufgelistet. Eine Wahrheitstabelle für zwei Variablen sieht also irgendwie so aus:\\
+	$\begin{array}{cc|c}
+	A & B & Y\\
+	\hline
+	0 & 0 & \mbox{ }\\
+	0 & 1 & \mbox{ }\\
+	1 & 0 & \mbox{ }\\
+	1 & 1 & \mbox{ }
+	\end{array}$\\
+	Wie sieht aber eine Wahrheitstabelle aus, die 3 (A, B und C) oder 4 (A, B, C und D) Variablen hat? Konstruiere diese mal.
+	
+	\paragraph{Aufgabe 10}\mbox{}\\
+	Nachfolgend sind noch ein paar Aussagen, deren Wahrheitstabelle ermittelt werden soll. Achte dabei auf die Rechenregeln: ''UND vor ODER'' und ''ODER vor Implikation''. Aber Klammern natürlich vor Allem!
+	\begin{itemize}
+		\item[a)] $A \wedge B \vee C$
+		\item[b)] $A \vee (B \wedge C) \Rightarrow C$
+		\item[c)] $C \Leftrightarrow B \wedge B \vee A$
+		\item[d)] $A \vee B \overline{A} \wedge C \Rightarrow B \wedge A$
+	\end{itemize}
+	
+\end{document}

java/Uebung/Uebung_2/Uebungsaufgaben_2_Loesung.tex

@@ -0,0 +1,363 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 2 - Lösung}
+\subtitle{Aussagenlogik}
+\date{}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Was ist eine Aussage?
+	
+	\subparagraph{Lösung:} Eine Aussage ist ein sprachliches Gebilde, dem ein eindeutiger Wahrheitswert zugeordnet werden kann. Als sprachliches Gebilde kann hierzu auch die Mathematik dienen.
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Welche der folgenden sind Aussagen und wie lautet die negierte Aussage?
+	\begin{itemize}
+		\item[a)] Die Sonne scheint.
+		\item[b)] Der Fernseher ist aus.
+		\item[c)] Kleiner Otter.
+		\item[d)] $y < x$
+		\item[e)] $x - z$
+	\end{itemize}
+	
+	\subparagraph{Lösung: }
+	\begin{itemize}
+		\item[a)] Aussage; ''Die Sonne scheint nicht.''
+		\item[b)] Aussage; ''Der Fernseher ist an.''
+		\item[c)] keine Aussage.
+		\item[d)] Keine Aussage. Es wird erst zu einer, wenn für $x$ und $y$ konkrete Werte vorliegen. Nur für $y < x$ kann kein Wahrheitswert ermittelt werden.
+		\item[e)] Keine Aussage.
+	\end{itemize}
+
+	\paragraph{Aufgabe 3}\mbox{}\\	
+	In der Aussagenlogik geht es ja u.a. darum, Aussagen zu verknüpfen und den Wahrheitswert der verknüpften Aussage zu ermitteln. Für die Verknüpfung von Aussagen stehen verschiedene Logik-Operatoren, auch Junktoren genannt, bereit. Wie heißen diese, wie schreibt man sie in der Mathematik und wie sieht die Wertetabelle aus?
+	
+	\subparagraph{Lösung: }
+	Hierbei sind nur die aus den Folien. Weiter unten in den Aufgaben sind noch zwei zusätzliche Junktoren eingeführt worden.
+	\begin{itemize}
+		\item[1)] NICHT / NOT / Negation; $\overline{A}$ oder $\neg$\\
+		$\begin{array}{c|c}
+			A & Y\\
+			\hline
+			0 & 1\\
+			1 & 0 
+		\end{array}$
+		\item[2)] UND / AND / Konjunktion; $\wedge$\\
+		$\begin{array}{cc|c}
+			A & B & Y\\
+			\hline
+			0 & 0 & 0\\
+			0 & 1 & 0\\
+			1 & 0 & 0\\
+			1 & 1 & 1
+		\end{array}$
+		\item[3)] ODER / OR / Disjunktion; $\vee$\\
+		$\begin{array}{cc|c}
+			A & B & Y\\
+			\hline
+			0 & 0 & 0\\
+			0 & 1 & 1\\
+			1 & 0 & 1\\
+			1 & 1 & 1
+		\end{array}$
+		\item[4)] XODER / XOR / Antivalenz; $\oplus$\\
+		$\begin{array}{cc|c}
+			A & B & Y\\
+			\hline
+			0 & 0 & 0\\
+			0 & 1 & 1\\
+			1 & 0 & 1\\
+			1 & 1 & 0
+		\end{array}$
+		
+	\end{itemize}
+	
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Mathematiker führen ja v.a. beweise durch. Dabei sind Beweise logische Schlussfolgerungen. Man nimmt also eine Aussage her und aus dieser schlussfolgert man solange mit wahren Aussagen, bis man das zu Beweisende hergeleitet hat. Dadurch, dass nur wahre Aussagen verwendet werden ist die Mathematik korrekt (so ziemlich als einzige Wissenschaft [neben der Informatik]). Die Schlussfolgerungen fußen dabei auf der sogenannten \emph{(materiale) Implikation}. Die Implikation lässt sich folgendermaßen in Worte fassen ''Wenn ..., dann ...''. Die Implikation soll uns an anderer Stelle nochmal etwas genauer begegnen. Doch hier wollen wir einfach mal einen sehr kleinen Beweis führen. Beweise folgende Aussage:
+	\begin{itemize}
+		\item[] Das Quadrat einer geraden natürlichen Zahl, ist wieder gerade (und umgekehrt).
+	\end{itemize}
+	
+	\subparagraph{Lösung:} Mathematisch ausgedrückt: $n$ gerade $\Rightarrow n^2$ gerade.
+	\begin{itemize}
+		\item[] $n \text{ gerade} 
+		\Leftrightarrow n = 2s 
+		\Rightarrow n^2 = (2s)^2 
+		\Leftrightarrow n^2 = 4s^2 = 2 \cdot (2s^2)
+		\Leftrightarrow n^2 \text{ gerade}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 5 - Zusatz}\mbox{}\\
+	Aufgabe 4 ist eigentlich gar nicht schwer - aber sehr kurz. Der Beweis hier ist immer noch kurz, aber etwas länger, als der aus Aufgabe 4. Deshalb ist es Zusatz.
+	Beweise folgende Aussage:
+	\begin{itemize}
+		\item[] $\sqrt{2}$ ist irrational
+	\end{itemize}
+	\emph{Hinweis: Das umgekehrte Resultat aus Aufgabe 4 wird hier benötigt.}
+
+	\subparagraph{Lösung:} Nehmen wir an, $\sqrt{2}$ wäre rational, dann existiert ein Bruch $\frac{p}{q} \in \mathbb{Q}$ mit $p$ und $q$ teilerfremd.
+	\begin{align*}
+		\sqrt{2} = \frac{p}{q}
+		&\Rightarrow 2 = \frac{p^2}{q^2}\\
+		&\Rightarrow p^2 = 2q^2\\
+		&\overset{A4}{\Rightarrow} p \text{ gerade}\\
+		&\Rightarrow p = 2s\\
+		&\Rightarrow p^2 = (2s)^2 = 4s^2\\
+		&\Rightarrow 4s^2 = 2q^2\\
+		&\Rightarrow q^2 = 2s^2\\
+		&\overset{A4}{\Rightarrow} q \text{ gerade}
+	\end{align*}
+	Wenn aber $q$ und $p$ gerade sind, dann sind die nicht teilerfremd, wie vorausgesetzt. Also muss das Gegenteil gelten und $\sqrt{2}$ ist irrational (Siehe Aufgabe 8).
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Kommen wir zur Implikation zurück. Die Implikation ist erfahrungsgemäß am Anfang nicht so leicht, denn es gibt eine Zeile in der Wahrheitstabelle, die vielen erst mal Kopfschmerzen bereitet.
+	Das Zeichen für die Implikation ist $\Rightarrow$. Nehmen wir uns mal ein Beispiel her und leiten uns die Wahrheitstabelle für die Implikation her:
+	\begin{itemize}
+		\item[] $A = $ Das Wetter ist gut.
+		\item[] $B = $ Ich gehe ins Freibad.
+	\end{itemize}
+	In Worten ist $A \Rightarrow B$: Wenn das Wetter gut ist, dann gehe ich ins Freibad.\\
+	Jetzt nehmen wir an, das Wetter ist gut und ihr seht mich im Freibad. Dann habe ich offensichtlich nicht gelogen. Wenn schlechtes Wetter ist und ihr seht mich nicht im Freibad, dann ist ja auch irgendwie alles gut. Wenn schlechtes Wetter ist, aber ihr seht mich dieses Mal im Freibad, dann fragt ihr euch vielleicht, warum  zur Hölle man bei schlechtem Wetter schwimmen geht, aber gelogen hab ich nicht. Ich gabe ja nur gesagt, was ich mache, wenn gutes Wetter ist, nicht aber wenn schlechtes Wetter ist! Lediglich, wenn gutes Wetter ist, ich aber nicht im Freibad bin, dann hab ich gelogen! So ein Drecksack, was?\\
+	Zusammengefasst ergibt sich folgende allgemeine Wahrheitstabelle:\\
+	$\begin{array}{cc|c}
+		A & B & A \Rightarrow B\\
+		\hline
+		0 & 0 & 1\\
+		0 & 1 & 1\\
+		1 & 0 & 0\\
+		1 & 1 & 1
+	\end{array}$\\
+	In Worten heißt das, dass wenn ihr aus wahren Aussagen falsche Aussagen folgert, dann ist das einfach falsch! Also wenn ihr folgert $1+2=3 \Rightarrow 1=3$ dann stimmt das wohl offensichtlich nicht, weil $1 \ne 3$ gilt! Wenn ihr aber $4 \text{ ist prim} \Rightarrow 2 \cdot 5 = 10$ habt, dann stimmt das doch. $4 \text{ ist prim}$ ist offensichtlich falsch, aber $2 \cdot 5 = 10$ ist wahr, also ist die Aussage wahr. Achso übrigens, die Umkehrung gilt im Allgemeinen nicht! Also $A \Rightarrow B$ ist nicht unbedingt das Gleiche, wie $B \Rightarrow A$ (siehe nächste Aufgabe)!
+	Naja, also lassen wir das. Hier mal ein paar konkrete Implikationen, für die ihr den eindeutigen Wahrheitswert ermitteln könnt:
+	\begin{itemize}
+		\item[a)] Die Sonne ist der nächste Planet zur Erde $\Rightarrow$ Pluto ist kein Planet
+		\item[b)] Eine Flasche ist nach dem Trinken voller als davor $\Rightarrow$ Kreuzberg liegt neben Schönefeld
+		\item[c)] $2^2 = 4 \Rightarrow 3^2 = 5$
+		\item[d)] $34 \ne 35 \Rightarrow 18-1=17$
+	\end{itemize}
+
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] wahr
+		\item[b)] wahr
+		\item[c)] falsch
+		\item[d)] wahr
+	\end{itemize}
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Nun, es gibt Aussagen, die zu keiner Zeit stimmen, und es gibt Aussagen, die immer stimmen. Ersteres nennt man \emph{unerfüllbar} und letzteres ist \emph{allgmeingültig}. Allgemeingültige Aussagen nennt man auch \emph{Tautologie}. Alles dazwischen heißt schlicht und einfach \emph{erfüllbar}. Eine Tautologie ist also immer wahr? JA! Das bringt uns mal etwas weiter und wir kommen zur \emph{Äquivalenz}, als Zeichen $\Leftrightarrow$. In Worten sagt man ''$A$ ist äquivalent zu $B$'' oder, v.a. in der Mathematik zu finden: ''$A$ genau dann, wenn $B$''. Vielleicht erinnert ihr euch noch an das \emph{XOR}, das auch \emph{Antivalenz} heißt. Warum das so ist, werden wir jetzt sehen.\\
+	Bei der Antivalenz ist die Gesamtaussage nur dann wahr, wenn ausschließlich eine der beiden Aussagen wahr ist, also mit Wahrheitstabelle ausgedrückt:\\
+	$\begin{array}{cc|c}
+	A & B & A \oplus B\\
+	\hline
+	0 & 0 & 0\\
+	0 & 1 & 1\\
+	1 & 0 & 1\\
+	1 & 1 & 0
+	\end{array}$\\
+	Der Äquivalenz-Operator ist dazu Gegensätzlich:\\
+	$\begin{array}{cc|c}
+	A & B & A \Leftrightarrow B\\
+	\hline
+	0 & 0 & 1\\
+	0 & 1 & 0\\
+	1 & 0 & 0\\
+	1 & 1 & 1
+	\end{array}$\\
+	Und das gilt immer! Wie war das? Wenn etwas immer gilt, dann ist das eine Tautologie? Können wir das mit einer Wertetabelle mal zeigen? JA! Wir können mit einer Wahrheitstabelle beweise führen! Übrigens ein Teil der Künstlichen Intelligenz beschäftigt sich mit automatischen Beweisern. Die machen dann im Grunde nichts anderes, als Logik und mit Wertetabellen Beweise führen. Nun aber zur Wahrheitstabelle. Zu zeigen ist folgende Aussage: $(\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)$. Dazu werden wir die Aussagen einzeln aufschreiben und dann zusammen setzen:\\
+	$\begin{array}{cc|c|c|c|c}
+		A & B & A \oplus B & \overline{A \oplus B} & A \Leftrightarrow B & (\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)\\
+		\hline
+		0 & 0 & 0 & 1 & 1 & 1\\
+		0 & 1 & 1 & 0 & 0 & 1\\
+		1 & 0 & 1 & 0 & 0 & 1\\
+		1 & 1 & 0 & 1 & 1 & 1
+	\end{array}$\\
+	Das gilt also immer! Streng genommen sind $\overline{A \oplus B}$ und $A \Leftrightarrow B$ Formeln für sich. Wenn wir in der Aussagenlogik Aussagen über Formeln machen (Metalogik), dann wäre die korrekte Schreibweise $(\overline{A \oplus B}) \equiv (A \Leftrightarrow B)$. Aber das $\equiv$ bedeutet gerade, dass die beiden Formeln genau dieselben Modelle haben, also unter den gleichen Interpretationen wahr sind (siehe Aufgabe 9). Und das ist genau dann der Fall, wenn $(\overline{A \oplus B}) \Leftrightarrow (A \Leftrightarrow B)$ eine Tautologie ist. Deshalb ist das hier in Ordnung für uns.\\
+	Führt nach obigem Schema mit folgenden Aufgaben durch und zeigt diese Tautologien:
+	\begin{itemize}
+		\item[a)] $(A \Rightarrow B) \Leftrightarrow (\overline{A} \vee B)$
+		\item[b)] $(A \Rightarrow B) \Leftrightarrow (\overline{B} \Rightarrow \overline{A})$
+		\item[c)] $((A \Rightarrow B) \wedge (B \Rightarrow A) \Leftrightarrow (A \Leftrightarrow B)$
+		\item[d)] $(A \vee (A \wedge B)) \Leftrightarrow A$
+	\end{itemize}
+	Übrigens diese vier Tautologien sind wichtig. a) ist die Implikation mit den ''Grundoperatoren'' ausgedrückt (Mit den Operatoren $\wedge,\ \vee$ und \emph{NOT}, kann man in der Aussagenlogik alle Aussagen verknüpfen, d.h. es ist ein vollständiges Set Operatoren für die Aussagenlogik). c) zeigt die Beziehung zwischen Implikation und Äquivalenz. Etwas ist Äquivalent, wenn es in beide Richtung impliziert werden, also wenn B aus A und A aus B folgt. c) heißt Kontraposition und ist das Grundprinzip für den \emph{indirekten Beweis}, eine Beweismethode der Mathematik. d) nennt sich Absorption.
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] $\begin{array}{cc|c|c|c}
+			A & B & A \Rightarrow B & \overline{A} \vee B & (A \Rightarrow B) \Leftrightarrow (\overline{A} \vee B)\\
+			\hline
+			0 & 0 & 1 & 1 & 1\\
+			0 & 1 & 1 & 1 & 1\\
+			1 & 0 & 0 & 0 & 1\\
+			1 & 1 & 1 & 1 & 1
+		\end{array}$
+		
+		\item[b)] $\begin{array}{cc|c|c|c}
+			A & B & A \Rightarrow B & \overline{B} \Rightarrow \overline{A} & (A \Rightarrow B) \Leftrightarrow (\overline{B} \Rightarrow \overline{A})\\
+			\hline
+			0 & 0 & 1 & 1 & 1\\
+			0 & 1 & 1 & 1 & 1\\
+			1 & 0 & 0 & 0 & 1\\
+			1 & 1 & 1 & 1 & 1
+		\end{array}$
+		
+		\item[c)]  $\begin{array}{cc|c|c|c|c|c}
+			A & B & A \Rightarrow B & B \Rightarrow A & (A \Rightarrow B) \wedge (B \Rightarrow A) & (A \Leftrightarrow B) & ((A \Rightarrow B) \wedge (B \Rightarrow A) \Leftrightarrow (A \Leftrightarrow B)\\
+			\hline
+			0 & 0 & 1 & 1 & 1 & 1 & 1\\
+			0 & 1 & 1 & 0 & 0 & 0 & 1\\
+			1 & 0 & 0 & 1 & 0 & 0 & 1\\
+			1 & 1 & 1 & 1 & 1 & 1 & 1
+		\end{array}$
+		
+		\item[d)] $\begin{array}{cc|c|c|c}
+			A & B & A \wedge B & A \vee (A \wedge B) & (A \vee (A \wedge B)) \Leftrightarrow A\\
+			\hline
+			0 & 0 & 0 & 0 & 1 \\
+			0 & 1 & 0 & 0 & 1 \\
+			1 & 0 & 0 & 1 & 1 \\
+			1 & 1 & 1 & 1 & 1 
+		\end{array}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Tautologien müssen nicht zwangsläufig durch Äquivalenzen entstehen. Zeige, dass folgende Aussage auch eine Tautologie ist:
+	\begin{itemize}
+		\item[] $((\overline{A} \Rightarrow B) \wedge \overline{B}) \Rightarrow A$
+	\end{itemize}
+	Diese Tautologie nennt sich Widerspruch und ist Grundlage des Widerspruchsbeweis (Aufgabe 5 ist ein Widerspruchsbeweis, sofern man den Beweis wie Euklid geführt hat).
+	\\\\
+	\emph{(Anmerkung: Sowohl die Kontraposition, als auch der Widerspruch führen zu einem Widerspruch! Beides sind also Widerspruchsbweise, es gilt also quasi Widerspruchsbeweis = indirekter Beweis! Es sind also nur zwei Arten, wie man einen Widerspruchsbeweis angehen kann.)}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[] $\begin{array}{cc|c|c|c}
+			A & B & \overline{A} \Rightarrow B & (\overline{A} \Rightarrow B) \wedge \overline{B}) & ((\overline{A} \Rightarrow B) \wedge \overline{B}) \Rightarrow A\\
+			\hline
+			0 & 0 & 0 & 0 & 1\\
+			0 & 1 & 1 & 0 & 1\\
+			1 & 0 & 1 & 1 & 1\\
+			1 & 1 & 1 & 0 & 1
+		\end{array}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Wir haben jetzt ganz schön viel Handwerkszeug, um aus zusammengesetzten Aussagen Wahrheitswerte zu ermitteln. Wir nehmen nun noch eine Variable mit hinzu. Übrigens: Eine Zeile einer Wahrheitstabelle wird Interpretation genannt. Die Wahrheitstabelle ist also eigentlich nichts anderes, als alle möglichen Kombinationen der Wahrheitswerte der Variablen (alle Interpretationen) aufgelistet. Eine Wahrheitstabelle für zwei Variablen sieht also irgendwie so aus:\\
+	$\begin{array}{cc|c}
+	A & B & Y\\
+	\hline
+	0 & 0 & \mbox{ }\\
+	0 & 1 & \mbox{ }\\
+	1 & 0 & \mbox{ }\\
+	1 & 1 & \mbox{ }
+	\end{array}$\\
+	Wie sieht aber eine Wahrheitstabelle aus, die 3 (A, B und C) oder 4 (A, B, C und D) Variablen hat? Konstruiere diese mal.
+	
+	\subparagraph{Lösung:}
+	\begin{alignat*}{2}
+		a) \begin{array}{ccc|c}
+			A & B  & C & Y\\
+			\hline
+			0 & 0 & 0 & \mbox{ }\\
+			0 & 0 & 1 & \mbox{ }\\
+			0 & 1 & 0 & \mbox{ }\\
+			0 & 1 & 1 & \mbox{ }\\
+			1 & 0 & 0 & \mbox{ }\\
+			1 & 0 & 1 & \mbox{ }\\
+			1 & 1 & 0 & \mbox{ }\\
+			1 & 1 & 1 & \mbox{ }
+		\end{array}
+		\qquad & \qquad
+		b) \begin{array}{cccc|c}
+			A & B  & C  & D & Y\\
+			\hline
+			0 & 0 & 0 & 0 & \mbox{ }\\
+			0 & 0 & 0 & 1 & \mbox{ }\\
+			0 & 0 & 1 & 0 & \mbox{ }\\
+			0 & 0 & 1 & 1 & \mbox{ }\\
+			0 & 1 & 0 & 0 & \mbox{ }\\
+			0 & 1 & 0 & 1 & \mbox{ }\\
+			0 & 1 & 1 & 0 & \mbox{ }\\
+			0 & 1 & 1 & 1 & \mbox{ }\\
+			1 & 0 & 0 & 0 & \mbox{ }\\
+			1 & 0 & 0 & 1 & \mbox{ }\\
+			1 & 0 & 1 & 0 & \mbox{ }\\
+			1 & 0 & 1 & 1 & \mbox{ }\\
+			1 & 1 & 0 & 0 & \mbox{ }\\
+			1 & 1 & 0 & 1 & \mbox{ }\\
+			1 & 1 & 1 & 0 & \mbox{ }\\
+			1 & 1 & 1 & 1 & \mbox{ }
+		\end{array}
+	\end{alignat*}
+	
+	\paragraph{Aufgabe 10}\mbox{}\\
+	Nachfolgend sind noch ein paar Aussagen, deren Wahrheitstabelle ermittelt werden soll. Achte dabei auf die Rechenregeln: ''UND vor ODER'' und ''ODER vor Implikation''. Aber Klammern natürlich vor Allem!
+	\begin{itemize}
+		\item[a)] $A \wedge B \vee C$
+		\item[b)] $A \vee (B \wedge C) \Rightarrow C$
+		\item[c)] $C \Leftrightarrow B \wedge B \vee A$
+		\item[d)] $A \vee B \vee \overline{A} \wedge C \Rightarrow B \wedge A$
+	\end{itemize}
+	\subparagraph{Lösung:}
+	\begin{alignat*}{3}
+		&a) \begin{array}{ccc|c}
+			A & B  & C & A \wedge B \vee C\\
+			\hline
+			0 & 0 & 0 & 0\\
+			0 & 0 & 1 & 1\\
+			0 & 1 & 0 & 0\\
+			0 & 1 & 1 & 1\\
+			1 & 0 & 0 & 0\\
+			1 & 0 & 1 & 1\\
+			1 & 1 & 0 & 1\\
+			1 & 1 & 1 & 1
+		\end{array}
+		\qquad && \qquad
+		b) \begin{array}{ccc|c}
+			A & B  & C & A \vee (B \wedge C) \Rightarrow C\\
+			\hline
+			0 & 0 & 0 & 1\\
+			0 & 0 & 1 & 1\\
+			0 & 1 & 0 & 1\\
+			0 & 1 & 1 & 1\\
+			1 & 0 & 0 & 0\\
+			1 & 0 & 1 & 1\\
+			1 & 1 & 0 & 0\\
+			1 & 1 & 1 & 1
+		\end{array}\\
+		&c) \begin{array}{ccc|c}
+			A & B  & C & C \Leftrightarrow B \wedge B \vee A\\
+			\hline
+			0 & 0 & 0 & 1\\
+			0 & 0 & 1 & 0\\
+			0 & 1 & 0 & 0\\
+			0 & 1 & 1 & 1\\
+			1 & 0 & 0 & 0\\
+			1 & 0 & 1 & 1\\
+			1 & 1 & 0 & 0\\
+			1 & 1 & 1 & 1
+		\end{array}
+		\qquad && \qquad
+		d) \begin{array}{ccc|c}
+			A & B  & C & A \vee B \vee \overline{A} \wedge C \Rightarrow B \wedge A\\
+			\hline
+			0 & 0 & 0 & 1\\
+			0 & 0 & 1 & 0\\
+			0 & 1 & 0 & 0\\
+			0 & 1 & 1 & 0\\
+			1 & 0 & 0 & 0\\
+			1 & 0 & 1 & 0\\
+			1 & 1 & 0 & 1\\
+			1 & 1 & 1 & 1
+		\end{array}
+	\end{alignat*}
+	
+\end{document}

java/Uebung/Uebung_3/Uebungsaufgaben_3.tex

@@ -0,0 +1,157 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath,listings,color}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 3}
+\subtitle{Komplemente und Kontrollstrukturen}
+\date{}
+
+\definecolor{pblue}{rgb}{0.13,0.13,1}
+\definecolor{pgreen}{rgb}{0,0.5,0}
+\definecolor{pred}{rgb}{0.9,0,0}
+\definecolor{pgrey}{rgb}{0.46,0.45,0.48}
+
+\lstset{language=Java,
+	showspaces=false,
+	showtabs=false,
+	breaklines=true,
+	showstringspaces=false,
+	breakatwhitespace=true,
+	commentstyle=\color{pgreen},
+	keywordstyle=\color{pblue},
+	stringstyle=\color{pred},
+	basicstyle=\ttfamily,
+	tabsize=4,
+	moredelim=[il][\textcolor{pgrey}]{$$},
+	moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
+}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Führe für folgende Binärzahlen die bitweise Negation durch:
+	\begin{itemize}
+		\item[a)] $0_2$
+		\item[b)] $0000_2$
+		\item[c)] $1111_2$
+		\item[d)] $1010_2$
+		\item[e)] $1100\ 0011\ 1001\ 1011\ 0111_2$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Wie lautet das Einskomplement folgender Zahlen bei 8 Bit (Man gebe zudem die Dezimalzahlen der unten stehenden Binärzahlen und ihres Einskomplements an):
+	\begin{itemize}
+		\item[a)] $0000\ 0101_2$
+		\item[b)] $0000\ 1111_2$
+		\item[c)] $0010\ 0000_2$
+		\item[d)] $0111\ 1111_2$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 3}\mbox{}\\	
+	Man gebe die Dezimalzahl zu den unten stehenden Einskomplementen an (8 Bit):
+	\begin{itemize}
+		\item[a)] $1000\ 0101_2$
+		\item[b)] $1000\ 1111_2$
+		\item[c)] $1010\ 0000_2$
+		\item[d)] $1111\ 1111_2$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Was stört bei der Einskomplement-Darstellung?
+	
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Ermittelt zu folgenden Zahlen die Zweikomplement-Darstellung bei 8 Bit (Binärzahlen und Dezimalzahlen angeben).
+	\begin{itemize}
+		\item[a)] $5$
+		\item[b)] $15$
+		\item[c)] $32$
+		\item[d)] $127$
+	\end{itemize}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Rechnet folgende Ausdrücke aus. Die Zahlen sind dabei alle in der Zweikomplement-Darstellung gegeben (8 Bit).
+	\begin{itemize}
+		\item[a)] $5 + (-21)$
+		\item[b)] $15 + (-5)$
+		\item[c)] $32 + 4$
+		\item[d)] $127 + (-127)$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Rechnet folgende Ausdrücke aus. Die Zahlen sind dabei alle \emph{nicht} in der Zweikomplement-Darstellung gegeben, d.h. die Zahlen (die nach dem Minus) sind umzurechnen (8 Bit).
+	\begin{itemize}
+		\item[a)] $19 - 28$
+		\item[b)] $56 - 9$
+		\item[c)] $1 - 2$
+		\item[d)] $3 - 127$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Schreibe ein einfaches Java-Programm, welches einem Monat vom Benutzer einliest (mithilfe des „java.util.Scanner“).
+	Verwende dafür die Zahlen 1 bis 12 (1 = Januar, 2 = Februar, ..., 12 = Dezember). Für jeden Monat soll nun die Anzahl der Tage ausgegeben werden.
+	Nutze hierzu die \emph{einfache Verzweigung}.
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Schreibe ein einfaches Java-Programm, welches einem Monat vom Benutzer einliest (mithilfe des „java.util.Scanner“).
+	Verwende dafür die Zahlen 1 bis 12 (1 = Januar, 2 = Februar, ..., 12 = Dezember). Für jeden Monat soll nun die Anzahl der Tage ausgegeben werden.
+	Nutze hierzu die \emph{Mehrfachverzweigung}.
+	
+	\paragraph{Aufgabe 10}\mbox{}\\
+	Kann Aufgabe 8 mit 3 oder weniger If-Statements gelöst werden? Wenn ja wie? Wenn nein warum nicht?
+	
+	\paragraph{Aufgabe 11}\mbox{}\\
+	Wie oft wird die folgende Schleife ausgeführt und warum?
+	\begin{lstlisting}
+	int i = 10;
+	do { 
+		i = i - 3;
+	} while (i  > 5);
+	\end{lstlisting}
+	
+	\paragraph{Aufgabe 12}\mbox{}\\
+	Welche Zahlen werden bei diesen Schleifen ausgegeben? Und wie oft werden diese Ausgeführt?
+	\\\\
+	a) \begin{lstlisting}
+	for( int i=1; i <= 10; i++ ){
+		System.out.println( i );
+	} 
+	\end{lstlisting}
+	b) \begin{lstlisting}
+	for( int i=1; i <= 10; i = i+2 ){
+		System.out.println( i );
+	}  
+	\end{lstlisting}
+	c) \begin{lstlisting}
+	for( int i=1; i <= 10; i = i*2 ){
+		System.out.println( i );
+	} 
+	\end{lstlisting}
+	d) \begin{lstlisting}
+	for( int i=1; i < 10; i = i+2 ){
+		if (i >= 5) {
+			System.out.println( i );
+			i--;
+		} else {
+			System.out.println( i );
+		} 
+	} 
+	\end{lstlisting}
+	\newpage
+	e) \begin{lstlisting}
+	int i = 0;
+	do { 
+		if (i < 4) {
+			System.out.println( i );
+		}
+		if (i > 4) {
+			System.out.println( i );
+		} else {
+			i--;
+		} 
+		i = i+2;
+	} while (i  < 10);  
+	\end{lstlisting}
+\end{document}

java/Uebung/Uebung_3/Uebungsaufgaben_3_Loesung.tex

@@ -0,0 +1,410 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath,listings,color}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 3}
+\subtitle{Komplemente und Kontrollstrukturen - Lösung}
+\date{}
+
+\definecolor{pblue}{rgb}{0.13,0.13,1}
+\definecolor{pgreen}{rgb}{0,0.5,0}
+\definecolor{pred}{rgb}{0.9,0,0}
+\definecolor{pgrey}{rgb}{0.46,0.45,0.48}
+
+\lstset{language=Java,
+	showspaces=false,
+	showtabs=false,
+	breaklines=true,
+	showstringspaces=false,
+	breakatwhitespace=true,
+	commentstyle=\color{pgreen},
+	keywordstyle=\color{pblue},
+	stringstyle=\color{pred},
+	basicstyle=\ttfamily,
+	tabsize=4,
+	moredelim=[il][\textcolor{pgrey}]{$$},
+	moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
+}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Führe für folgende Binärzahlen die bitweise Negation durch:
+	\begin{itemize}
+		\item[a)] $0_2$
+		\item[b)] $0000_2$
+		\item[c)] $1111_2$
+		\item[d)] $1010_2$
+		\item[e)] $1100\ 0011\ 1001\ 1011\ 0111_2$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $\sim 0_2 = 1_2$
+		\item[b)] $\sim 0000_2 = 1111_2$
+		\item[c)] $\sim 1111_2 = 0000_2$
+		\item[d)] $\sim 1010_2 = 0101_2$
+		\item[e)] $\sim 1100\ 0011\ 1001\ 1011\ 0111_2 = 0011\ 1100\ 0110\ 0100\ 1000_2$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Wie lautet das Einskomplement folgender Zahlen bei 8 Bit (Man gebe zudem die Dezimalzahlen der unten stehenden Binärzahlen und ihres Einskomplements an):
+	\begin{itemize}
+		\item[a)] $0000\ 0101_2$
+		\item[b)] $0000\ 1111_2$
+		\item[c)] $0010\ 0000_2$
+		\item[d)] $0111\ 1111_2$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $\sim 5_{10} = \sim 0000\ 0101_2 = 1111\ 1010_2 = -5_{10}$
+		\item[b)] $\sim 15_{10} = \sim 0000\ 1111_2 = 1111\ 0000_2 = -15_{10}$
+		\item[c)] $\sim 32_{10} = \sim 0010\ 0000_2 = 1101\ 1111_2 = -32_{10}$
+		\item[d)] $\sim 127_{10} = \sim 0111\ 1111_2 = 1000\ 0000_2 = -127_{10}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 3}\mbox{}\\	
+	Man gebe die Dezimalzahl zu den unten stehenden Einskomplementen an (8 Bit):
+	\begin{itemize}
+		\item[a)] $1000\ 0101_2$
+		\item[b)] $1000\ 1111_2$
+		\item[c)] $1010\ 0000_2$
+		\item[d)] $1111\ 1111_2$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $1000\ 0101_2 = -122_{10}$
+		\item[b)] $1000\ 1111_2 = -112_{10}$
+		\item[c)] $1010\ 0000_2 = -95_{10}$
+		\item[d)] $1111\ 1111_2 = -0_{10}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 4}\mbox{}\\	
+	Was stört bei der Einskomplement-Darstellung?
+	
+	\subparagraph{Lösung:} Für die $0$ gibt es eine doppelte Darstellung, nämlich $00 \dots 00_2 = +0_{10}$ und $11 \dots 11_2 = -0_{10}$. Außerdem ist der Wertebereich um eins verkleinert.
+	
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Ermittelt zu folgenden Zahlen die Zweikomplement-Darstellung bei 8 Bit (Binärzahlen und Dezimalzahlen angeben).
+	\begin{itemize}
+		\item[a)] $5$
+		\item[b)] $15$
+		\item[c)] $32$
+		\item[d)] $127$
+	\end{itemize}
+
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 0000\ 0101_2\\
+			\Rightarrow \sim 0000\ 0101_2 + 1_2 = 1111\ 1010_2 + 1_2 = 1111\ 1011_2 = -5_{10}$
+		\item[b)] $15_{10} = 0000\ 1111_2\\
+			\Rightarrow \sim 0000\ 1111_2 + 1_2 = 1111\ 0000_2 + 1_2 = 1111\ 0001_2 = -15_{10}$
+		\item[c)] $32_{10} = 0010\ 0000_2\\
+			\Rightarrow \sim 0010\ 0000_2 + 1_2 = 1101\ 1111_2 + 1_2 = 1110\ 0000_2 = -32_{10}$
+		\item[d)] $127_{10} = 0111\ 1111_2\\
+			\Rightarrow \sim 0111\ 1111_2 + 1_2 = 1000\ 0000_2 + 1_2 = 1000\ 0001_2 = -127_{10}$
+	\end{itemize}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Rechnet folgende Ausdrücke aus. Die Zahlen sind dabei alle in der Zweikomplement-Darstellung gegeben (8 Bit).
+	\begin{itemize}
+		\item[a)] $5 + (-21)$
+		\item[b)] $15 + (-5)$
+		\item[c)] $32 + 4$
+		\item[d)] $127 + -(127)$
+	\end{itemize}
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $5_{10} = 0000\ 0101_2,\ -21_{10} = 1110\ 1011_2\\
+			\Rightarrow 0000\ 0101_2 + 1110\ 1011_2 = 1111\ 0000_2 = -16_{10}$
+		\item[b)] $15_{10} = 0000\ 1111_2,\ -5_{10} = 1111\ 1011_2\\
+			\Rightarrow 0000\ 1111_2 + 1111\ 1011_2 = 0000\ 1010_2 = 10_{10}$
+		\item[c)] $32_{10} = 0010\ 0000_2,\ 4_{10} = 0000\ 0100_2\\
+			\Rightarrow 0010\ 0000_2 + 0000\ 0100_2 = 0010\ 0100_2 = 36_{10}$
+		\item[d)] $127_{10} = 0111\ 1111_2,\ -127_{10} = 1000\ 0001_2\\
+			\Rightarrow 0111\ 1111_2 + 1000\ 0001_2 = 0000\ 0000_2 = 0_{10}$
+	\end{itemize}
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Rechnet folgende Ausdrücke aus. Die Zahlen sind dabei alle \emph{nicht} in der Zweikomplement-Darstellung gegeben, d.h. die Zahlen (die nach dem Minus) sind umzurechnen (8 Bit).
+	\begin{itemize}
+		\item[a)] $19 - 28$
+		\item[b)] $56 - 9$
+		\item[c)] $1 - 2$
+		\item[d)] $3 - 127$
+	\end{itemize}
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[a)] $19_{10} = 0001\ 0011_2,\ 28_{10} = 0001\ 1100_2\\
+			\Rightarrow \sim 0001\ 1100_2 + 1_2 = 1110\ 0011_2 + 1_2 = 1110\ 0100_2 = -28_{10}\\
+			\Rightarrow 19_{10} + (-28_{10}) = 0001\ 0011_2 + 1110\ 0100_2 = 1111\ 0111 = -9_{10}$
+		\item[b)] $56_{10} = 0011\ 1000_2,\ 9_{10} = 0000\ 1001_2\\
+			\Rightarrow \sim 0000\ 1001_2 + 1_2 = 1111\ 0110_2 + 1_2 = 1111\ 0111_2 = -9_{10}\\
+			\Rightarrow 56_{10} + (-9_{10}) = 0011\ 1000_2 + 1111\ 0111_2 = 0010\ 1111_2 = 47_{10}$
+		\item[c)] $1_{10} = 0000\ 0001_2,\ 2_{10} = 0000\ 0010_2\\
+			\Rightarrow \sim 0000\ 0010_2 + 1_2 = 1111\ 1101_2 + 1_2 = 1111\ 1110_2 = -2_{10}\\
+			\Rightarrow 1_{10} + (-2_{10}) = 0000\ 0001_2 + 1111\ 1110_2 = 1111\ 1111_2 = -1_{10}$
+		\item[d)] $3_{10} = 0000\ 0011_2,\ 127_{10} = 01111\ 1111_2\\
+			\Rightarrow \sim 0111\ 1111_2 + 1_2 = 1000\ 0000_2 + 1_2 = 1000\ 0001_2 = -127_{10}\\
+			\Rightarrow 3_{10} + (-127_{10}) = 0000\ 0011_2 + 1000\ 0001_2 = 1000\ 0100_2 = -124_{10}$
+	\end{itemize}
+
+	\newpage
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Schreibe ein einfaches Java-Programm, welches einem Monat vom Benutzer einliest (mithilfe des „java.util.Scanner“).
+	Verwende dafür die Zahlen 1 bis 12 (1 = Januar, 2 = Februar, ..., 12 = Dezember). Für jeden Monat soll nun die Anzahl der Tage ausgegeben werden.
+	Nutze hierzu die \emph{einfache Verzweigung}.
+	
+	\subparagraph{Lösung:} 
+	Eine mögliche Lösung:
+	\begin{lstlisting}
+	import java.util.Scanner;
+	public class Nr8 
+	{
+		public static void main(String [] args) 
+		{
+			Scanner scanner = new Scanner(System.in);
+			System.out.println("Enter a month (Number between 1 and 12) an I tell you the number of days");
+			int month = scanner.nextInt();
+			
+			if (month == 2) 
+			{
+				System.out.println("28 Tage");
+			} 
+			
+			if ((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 9) || (month == 11)) 
+			{
+				System.out.println("31 Tage");
+			}
+			
+			if ((month == 4) || (month == 6) || (month == 8) || (month == 10) || (month == 12)) 
+			{
+				System.out.println("30 Tage");
+			}
+		}
+	}
+	\end{lstlisting}
+	
+	\newpage
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Schreibe ein einfaches Java-Programm, welches einem Monat vom Benutzer einliest (mithilfe des „java.util.Scanner“).
+	Verwende dafür die Zahlen 1 bis 12 (1 = Januar, 2 = Februar, ..., 12 = Dezember). Für jeden Monat soll nun die Anzahl der Tage ausgegeben werden.
+	Nutze hierzu die \emph{Mehrfachverzweigung}.
+	
+	\subparagraph{Lösung:} 
+	Eine mögliche Lösung:
+	\begin{lstlisting}
+	import java.util.Scanner;
+	public class Nr9 
+	{	
+		public static void main(String [] args) 
+		{
+			Scanner scanner = new Scanner(System.in);
+			System.out.println("Enter a month (Number between 1 and 12) an I tell you the number of days");
+			int month = scanner.nextInt();
+			
+			switch(month)
+			{
+				case 1:
+					System.out.println("31 Tage");
+					break;
+				case 2:
+					System.out.println("28 Tage");
+					break;
+				case 3:
+					System.out.println("31 Tage");
+					break;
+				case 4:
+					System.out.println("30 Tage");
+					break;
+				case 5:
+					System.out.println("31 Tage");
+					break;
+				case 6:
+					System.out.println("30 Tage");
+					break;
+				case 7:
+					System.out.println("31 Tage");
+					break;
+				case 8:
+					System.out.println("30 Tage");
+					break;
+				case 9:
+					System.out.println("31 Tage");
+					break;
+				case 10:
+					System.out.println("30 Tage");
+					break;
+				case 11:
+					System.out.println("31 Tage");
+					break;
+				case 12:
+					System.out.println("30 Tage");
+					break;
+				default:
+					System.out.println("Please enter a viable number between 1 and 12 (Your number: " + month + ")");
+			}	
+		}
+	}
+	\end{lstlisting}
+	
+	\newpage
+	
+	\paragraph{Aufgabe 10}\mbox{}\\
+	Kann Aufgabe 8 mit 3 oder weniger If-Statements gelöst werden? Wenn ja wie? Wenn nein warum nicht?
+	
+	\subparagraph{Lösung:} 
+	Ja.
+	\begin{lstlisting}
+	import java.util.Scanner;
+	public class Nr10
+	{
+		public static void main(String [] args)
+		{
+			Scanner scanner = new Scanner(System.in);
+			System.out.println("Enter a month (Number between 1 and 12) an I tell you the number of days");
+			int month = scanner.nextInt();
+			
+			if(month == 2)
+			{
+				System.out.println("28 Tage");
+				
+				if((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 9) || (month == 11))
+				{
+					System.out.println("31 Tage");
+				}
+				
+				if((month == 4) || (month == 6) || (month == 8) || (month == 10) || (month == 12))
+				{
+					System.out.println("30 Tage");
+				}
+			}
+		}
+	}
+	\end{lstlisting}
+	
+	\newpage
+	
+	\paragraph{Aufgabe 11}\mbox{}\\
+	Wie oft wird die folgende Schleife ausgeführt und warum?
+	\begin{lstlisting}
+	int i = 10;
+	do { 
+		i = i - 3;
+	} while (i  > 5);
+	\end{lstlisting}
+	
+	\subparagraph{Lösung:}
+	Zwei mal, da danach die Bedingung am Ende des zweiten Durchlaufes "4 > 5" lautet und somit die Schleife beendet wird. 
+	
+	
+	\paragraph{Aufgabe 12}\mbox{}\\
+	Welche Zahlen werden bei diesen Schleifen ausgegeben? Und wie oft werden diese Ausgeführt?
+	\\\\
+	a) \begin{lstlisting}
+	for( int i=1; i <= 10; i++ ){
+		System.out.println( i );
+	} 
+	\end{lstlisting}
+	b) \begin{lstlisting}
+	for( int i=1; i <= 10; i = i+2 ){
+		System.out.println( i );
+	}  
+	\end{lstlisting}
+	c) \begin{lstlisting}
+	for( int i=1; i <= 10; i = i*2 ){
+		System.out.println( i );
+	} 
+	\end{lstlisting}
+	d) \begin{lstlisting}
+	for( int i=1; i < 10; i = i+2 ){
+		if (i >= 5) {
+			System.out.println( i );
+			i--;
+		} else {
+			System.out.println( i );
+		} 
+	} 
+	\end{lstlisting}
+	\newpage
+	e) \begin{lstlisting}
+	int i = 0;
+	do { 
+		if (i < 4) {
+			System.out.println( i );
+		}
+		if (i > 4) {
+			System.out.println( i );
+		} else {
+			i--;
+		} 
+		i = i+2;
+	} while (i  < 10);  
+	\end{lstlisting}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] $\begin{array}{c|c}
+				\text{Durchlauf} & \text{Ausgabe}\\
+				\hline
+				1 & 1\\
+				2 & 2\\
+				3 & 3\\
+				4 & 4\\
+				5 & 5\\
+				6 & 6\\
+				7 & 7\\
+				8 & 8\\
+				9 & 9\\
+				10 & 10\\
+			\end{array}$
+		\item[b)] $\begin{array}{c|c}
+				\text{Durchlauf} & \text{Ausgabe}\\
+				\hline
+				1 & 1\\
+				2 & 3\\
+				3 & 5\\
+				4 & 7\\
+				5 & 9
+			\end{array}$
+		\item[c)] $\begin{array}{c|c}
+				\text{Durchlauf} & \text{Ausgabe}\\
+				\hline
+				1 & 1\\
+				2 & 2\\
+				3 & 4\\
+				4 & 8
+			\end{array}$
+		\item[d)] $\begin{array}{c|c}
+				\text{Durchlauf} & \text{Ausgabe}\\
+				\hline
+				1 & 1\\
+				2 & 3\\
+				3 & 5\\
+				4 & 6\\
+				5 & 7\\
+				6 & 8\\
+				7 & 9
+			\end{array}$
+		\item[e)] $\begin{array}{c|c}
+				\text{Durchlauf} & \text{Ausgabe}\\
+				\hline
+				1 & 0\\
+				2 & 1\\
+				3 & 2\\
+				4 & 3\\
+				5 & 5\\
+				6 & 7\\
+				7 & 9
+			\end{array}$
+	\end{itemize}
+\end{document}

java/Uebung/Uebung_4/Uebungsaufgaben_4.tex

@@ -0,0 +1,99 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath,listings,color}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 4}
+\subtitle{Arrays}
+\date{}
+
+\definecolor{pblue}{rgb}{0.13,0.13,1}
+\definecolor{pgreen}{rgb}{0,0.5,0}
+\definecolor{pred}{rgb}{0.9,0,0}
+\definecolor{pgrey}{rgb}{0.46,0.45,0.48}
+
+\lstset{language=Java,
+	showspaces=false,
+	showtabs=false,
+	breaklines=true,
+	showstringspaces=false,
+	breakatwhitespace=true,
+	commentstyle=\color{pgreen},
+	keywordstyle=\color{pblue},
+	stringstyle=\color{pred},
+	basicstyle=\ttfamily,
+	tabsize=4,
+	moredelim=[il][\textcolor{pgrey}]{$$},
+	moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
+}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Gegeben sind verschiedene Längen bzw. Größen von Arrays. Gebe die jeweiligen Start- und Endindizes an.
+	
+	\begin{itemize}
+		\item[a)] 1
+		\item[b)] 42
+		\item[c)] 13
+		\item[d)] 101
+		\item[e)] 3141592
+		\item[f)] 0 $\qquad$ (Achtung fies!)
+	\end{itemize}
+
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Gegeben sei ein Array der Länge 100. Welchen Index haben die folgenden "Plätze".
+
+	\begin{itemize}
+		\item[a)] 1
+		\item[b)] 42
+		\item[c)] 13
+		\item[d)] 101
+	\end{itemize}
+
+	\paragraph{Aufgabe 3}\mbox{}\\
+	Gegeben sei ein Array der Länge $n$. Ganz allgemein, welchen Index hat die Stelle $k$, wobei $k \le n$?
+
+	\paragraph{Aufgabe 4}\mbox{}\\
+	Erstelle für folgende Angaben die Arrays in Java-Code.
+
+	\begin{itemize}
+		\item[a)] Datentyp: \emph{int}; Länge: \emph{18}
+		\item[b)] Datentyp: \emph{String}; Länge: \emph{23}
+		\item[c)] Kommazahlen, Länge: 5001
+		\item[d)] Datentyp: \emph{char}; Länge: \emph{7}
+	\end{itemize}
+
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Erstelle folgende Arrays in Java, die als Inhalt die dastehenden Werte haben. Wir haben zwei Varianten kennen gelernt. Versuche beide zu verwenden.
+	
+	\begin{itemize}
+		\item[a)] Datentyp: \emph{int}; Werte: \emph{0, 9, 2, 8, 3, 7, 4, 6, 5}
+		\item[b)] Datentyp: \emph{long}; Werte: \emph{-100, 100, -50, 50, 123456789}
+		\item[c)] Datentyp: \emph{String}; Werte: \emph{''Ich'', ''liebe'', ''Josh''}
+		\item[d)] Datentyp: \emph{double}; Werte: \emph{3.141, 0.0005926, 5358.9793, Math.pi}
+	\end{itemize}
+
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Erstelle ein Programm, das das Array \emph{\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9\}} in umgekehrter Reihenfolge ausgibt.
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Schreibe ein Programm, das von der Kommandozeile zwei Zahlen einliest. Diese Zahlen sollen als Start- und Endwert für Zufallszahlen dienen. In ein Array der Länge 10 lässt du dann 10 Zufallszahlen, die zwischen dem Start- und Endwert liegen, reinschreiben und gibst das Array aus.
+	Für die Zufallszahlen kannst du folgendes verwenden:
+	
+	\begin{lstlisting}
+	Random rand = new Random();
+	
+	nextInt(int bound)
+	// Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.
+	\end{lstlisting}
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Du hast ein Array mit der Länge 5 und mit folgendem Inhalt: \emph{\{0, 1, 2, 3, 4\}}. Du möchtest nun zusätzlich die Zahlen 7 und 8 abspeichern. Welche Möglichkeiten gibt es, das zu tun?
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Schreibe deine Ideen auf, für was man 2D-Arrays verwenden könnte.
+
+\end{document}

java/Uebung/Uebung_4/Uebungsaufgaben_4_Loesung.tex

@@ -0,0 +1,214 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath,listings,color}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 4}
+\subtitle{Arrays - Lösung}
+\date{}
+
+\definecolor{pblue}{rgb}{0.13,0.13,1}
+\definecolor{pgreen}{rgb}{0,0.5,0}
+\definecolor{pred}{rgb}{0.9,0,0}
+\definecolor{pgrey}{rgb}{0.46,0.45,0.48}
+
+\lstset{language=Java,
+	showspaces=false,
+	showtabs=false,
+	breaklines=true,
+	showstringspaces=false,
+	breakatwhitespace=true,
+	commentstyle=\color{pgreen},
+	keywordstyle=\color{pblue},
+	stringstyle=\color{pred},
+	basicstyle=\ttfamily,
+	tabsize=4,
+	moredelim=[il][\textcolor{pgrey}]{$$},
+	moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
+}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}\\
+	Gegeben sind verschiedene Längen bzw. Größen von Arrays. Gebe die jeweiligen Start- und Endindizes an.
+	
+	\begin{itemize}
+		\item[a)] 1
+		\item[b)] 42
+		\item[c)] 13
+		\item[d)] 101
+		\item[e)] 3141592
+		\item[f)] 0 $\qquad$ (Achtung fies!)
+	\end{itemize}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] Startindex: 0; Endindex: 0
+		\item[b)] Startindex: 0; Endindex: 41
+		\item[c)] Startindex: 0; Endindex: 12
+		\item[d)] Startindex: 0; Endindex: 100
+		\item[e)] Startindex: 0; Endindex: 3141591
+		\item[f)] Hat keinen Start- und Endindex
+	\end{itemize}
+	
+	\paragraph{Aufgabe 2}\mbox{}\\
+	Gegeben sei ein Array der Länge 100. Welchen Index haben die folgenden "Plätze".
+	
+	\begin{itemize}
+		\item[a)] 1
+		\item[b)] 42
+		\item[c)] 13
+		\item[d)] 101
+	\end{itemize}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] Index: 0
+		\item[b)] Index: 41
+		\item[c)] Index: 12
+		\item[d)] Außerhalb des Arrays
+	\end{itemize}
+	
+	\paragraph{Aufgabe 3}\mbox{}\\
+	Gegeben sei ein Array der Länge $n$. Ganz allgemein, welchen Index hat die Stelle $k$, wobei $k \le n$?
+	
+	\subparagraph{Lösung:}
+	$k-1$
+	
+	\paragraph{Aufgabe 4}\mbox{}\\
+	Erstelle für folgende Angaben die Arrays in Java-Code.
+	
+	\begin{itemize}
+		\item[a)] Datentyp: \emph{int}; Länge: \emph{18}
+		\item[b)] Datentyp: \emph{String}; Länge: \emph{23}
+		\item[c)] Kommazahlen, Länge: 5001
+		\item[d)] Datentyp: \emph{char}; Länge: \emph{7}
+	\end{itemize}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] \begin{lstlisting}
+		int[] arr = new int[18];
+		\end{lstlisting}
+		
+		\item[b)] \begin{lstlisting}
+		String[] arr = new String[23];
+		\end{lstlisting}
+		
+		\item[c)] \begin{lstlisting}
+		float[] arr = new float[5001];
+		double[] arr = new double[5001];
+		\end{lstlisting}
+		
+		\item[d)] \begin{lstlisting}
+		char[] arr = new char[7];
+		\end{lstlisting}
+	\end{itemize}
+	
+	\paragraph{Aufgabe 5}\mbox{}\\
+	Erstelle folgende Arrays in Java, die als Inhalt die dastehenden Werte haben. Wir haben zwei Varianten kennen gelernt. Versuche beide zu verwenden.
+	
+	\begin{itemize}
+		\item[a)] Datentyp: \emph{int}; Werte: \emph{0, 9, 2, 8, 3, 7, 4, 6, 5}
+		\item[b)] Datentyp: \emph{long}; Werte: \emph{-100, 100, -50, 50, 123456789}
+		\item[c)] Datentyp: \emph{String}; Werte: \emph{''Ich'', ''liebe'', ''Josh''}
+		\item[d)] Datentyp: \emph{double}; Werte: \emph{3.141, 0.0005926, 5358.9793, Math.pi}
+	\end{itemize}
+	
+	\subparagraph{Lösung:}
+	\begin{itemize}
+		\item[a)] \begin{lstlisting}
+		int[] arr = new int[] {
+			0, 9, 2, 8, 3, 7, 4, 6, 5
+		};
+		\end{lstlisting}
+		
+		\item[b)] \begin{lstlisting}
+		long[] arr = new long[] {
+			-100, 100, -50, 50, 123456789
+		};
+		\end{lstlisting}
+		
+		\item[c)] \begin{lstlisting}
+		String arr = new String[3];
+		arr[0] = "Ich";
+		arr[1] = "liebe";
+		arr[2] = "Josh";
+		\end{lstlisting}
+		
+		\item[d)] \begin{lstlisting}
+		double[] arr = new double[] {
+			3.141, 0.0005926, 5358.9793, Math.pi
+		};
+		\end{lstlisting}
+	\end{itemize}
+	
+	\paragraph{Aufgabe 6}\mbox{}\\
+	Erstelle ein Programm, das das Array \emph{\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9\}} in umgekehrter Reihenfolge ausgibt.
+	
+	\subparagraph{Lösung:}\mbox{}
+	\begin{lstlisting}
+	int[] arr = int[] {
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+	};
+	
+	for (int i = arr.length - 1; i >= 0; i--)
+	{
+		System.out.println(arr[i]);
+	}
+	\end{lstlisting}
+	
+	\newpage
+	
+	\paragraph{Aufgabe 7}\mbox{}\\
+	Schreibe ein Programm, das von der Kommandozeile zwei Zahlen einliest. Diese Zahlen sollen als Start- und Endwert für Zufallszahlen dienen. In ein Array der Länge 10 lässt du dann 10 Zufallszahlen, die zwischen dem Start- und Endwert liegen, reinschreiben und gibst das Array aus.
+	Für die Zufallszahlen kannst du folgendes verwenden:
+	
+	\begin{lstlisting}
+	Random rand = new Random();
+	
+	nextInt(int bound)
+	// Returns a pseudorandom, uniformly distributed int value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence.
+	\end{lstlisting}
+	
+	\subparagraph{Lösung:}\mbox{}
+	\begin{lstlisting}
+	int rand = new Random();
+	int scan = new Scanner(System.in);
+	int arr = new int[10];
+	
+	System.out.println("Startwert: ");
+	int start = scan.nextInt();
+	System.out.println("Endwert: ");
+	int end = scan.nextInt();
+	
+	for (int i = 0; i < arr.length; i++)
+	{
+		arr[i] = rand.nextInt(end - start + 1) + start;
+	}
+	
+	for (int i = 0; i < arr.length; i++)
+	{
+		System.out.println(value);
+	}
+	\end{lstlisting}
+	
+	\paragraph{Aufgabe 8}\mbox{}\\
+	Du hast ein Array mit der Länge 5 und mit folgendem Inhalt: \emph{\{0, 1, 2, 3, 4\}}. Du möchtest nun zusätzlich die Zahlen 7 und 8 abspeichern. Welche Möglichkeiten gibt es, das zu tun?
+	
+	\subparagraph{Lösung:}
+	Man kann ein neues größeres Array anlegen und die Zahlen des alten Arrays kopieren und die neuen Zahlen hinzufügen.
+	
+	\paragraph{Aufgabe 9}\mbox{}\\
+	Schreibe deine Ideen auf, für was man 2D-Arrays verwenden könnte.
+	
+	\subparagraph{Lösung:} 
+	\begin{itemize}
+		\item[-] Spielbrett (Schachbrett, TicTacToe, etc.)
+		\item[-] Andere Arten von Tabellen
+		\item[-] etc.
+	\end{itemize}
+
+\end{document}

java/Uebung/Uebung_6/Uebungsaufgaben_6.tex

@@ -0,0 +1,38 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath}
+\usepackage{hyperref}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 6}
+\subtitle{OOP und Klassen}
+\date{}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}
+	\label{A1}
+	Modelliere das Objekt ''Katze'' als Java-Code, also schreibe eine Klasse, mithilfe der nachfolgenden Beschreibung.
+	\begin{itemize}
+		\item[] Eine Katze \emph{hat} eine Anzahl an Pfoten, Augen, Ohren und ein Gewicht. 	
+				Katzen haben von Geburt an Fellfarben.
+				Außerdem gibt es entweder den Zustand \emph{tod} oder \emph{lebendig}.
+		
+		\item[]	Die Katze \emph{kann} laufen und fressen.\\
+				Beim Fressen kann ihr eine bestimmte Menge an Futter übergeben werden, wodurch sie schwerer wird.
+	\end{itemize}
+	
+	\paragraph{Aufgabe 2}\mbox{}
+	Erweitere die Katze aus \hyperref[A1]{Aufgabe 1}:\\
+	Eine Katze verliert Gewicht, je nachdem wie weit sie gelaufen ist.
+	Falls die Katze schwerer als 10 kg ist, stirbt sie an den Folgen des Übergewichts (Beachte: Eine tote Katze kann nicht mehr fressen, ...).
+	
+	\paragraph{Aufgabe 3}\mbox{}
+	Modelliere das Objekt ''Person'' als Java Klasse vollständig, d.h. versuche dabei alle möglichen Member und Methoden zu finden.
+	
+	\paragraph{Aufgabe 4}\mbox{}
+	Modelliere die Member und Methoden des Objekts ''Bankautomat'' als Text. Als Hilfe kannst du die Begriffe \emph{hat} und \emph{kann} verwenden. Danach programmierst du das.
+
+\end{document}

java/Uebung/Uebung_6/Uebungsaufgaben_6_Loseung.tex

@@ -0,0 +1,228 @@
+\documentclass[12pt,a4paper,ngerman]{scrartcl}
+\usepackage[ngerman]{babel}
+\usepackage{amsfonts,amssymb,amsmath,listings,color}
+\usepackage{hyperref}
+\pagestyle{plain}
+
+\subject{\vspace{-3cm}The GAME}
+\title{Übungsaufgaben 6}
+\subtitle{OOP und Klassen}
+\date{}
+
+\definecolor{pblue}{rgb}{0.13,0.13,1}
+\definecolor{pgreen}{rgb}{0,0.5,0}
+\definecolor{pred}{rgb}{0.9,0,0}
+\definecolor{pgrey}{rgb}{0.46,0.45,0.48}
+
+\lstset{language=Java,
+	showspaces=false,
+	showtabs=false,
+	breaklines=true,
+	showstringspaces=false,
+	breakatwhitespace=true,
+	commentstyle=\color{pgreen},
+	keywordstyle=\color{pblue},
+	stringstyle=\color{pred},
+	basicstyle=\ttfamily,
+	tabsize=4,
+	moredelim=[il][\textcolor{pgrey}]{$$},
+	moredelim=[is][\textcolor{pgrey}]{\%\%}{\%\%}
+}
+
+\begin{document}
+	\maketitle
+	
+	\paragraph{Aufgabe 1}\mbox{}
+	\label{A1}
+	Modelliere das Objekt ''Katze'' als Java-Code, also schreibe eine Klasse, mithilfe der nachfolgenden Beschreibung.
+	\begin{itemize}
+		\item[] Eine Katze \emph{hat} eine Anzahl an Pfoten, Augen, Ohren und ein Gewicht. 	
+				Katzen haben von Geburt an Fellfarben.
+				Außerdem gibt es entweder den Zustand \emph{tod} oder \emph{lebendig}.
+		
+		\item[]	Die Katze \emph{kann} laufen und fressen.\\
+				Beim Fressen kann ihr eine bestimmte Menge an Futter übergeben werden, wodurch sie schwerer wird.
+	\end{itemize}
+
+	\subparagraph{Lösung:}
+	\begin{lstlisting}
+	public class Katze
+	{
+		public int amountPaws;
+		public int amountEyes;
+		public int amountEars;
+		
+		public double weight;
+		
+		public String[] furColours;
+		
+		public boolean isAlive;
+		
+		public Katze()
+		{
+			this(4, 2, 2, 5.0, new String[] {"black", "white"}, true);
+		}
+		
+		public Katze(int amountPaws, int amountEyes, int amountEars, double weight, String[] furColours, boolean isAlive)
+		{
+			this.amountPaws = amountPaws;
+			this.amountEyes = amountEyes;
+			this.amountEars = amountEars;
+			this.weight = weight;
+			this.furColours = furColours;
+			this.isAlive = isAlive;
+		}
+		
+		public void move()
+		{
+		}
+		
+		public void eat(double amountFood)
+		{
+			this.weight += amountFood;
+		}
+	}
+	\end{lstlisting}
+	\newpage
+	\paragraph{Aufgabe 2}\mbox{}
+	Erweitere die Katze aus \hyperref[A1]{Aufgabe 1}:\\
+	Eine Katze verliert Gewicht, je nachdem wie weit sie gelaufen ist.
+	Falls die Katze schwerer als 10 kg ist, stirbt sie an den Folgen des Übergewichts (Beachte: Eine tote Katze kann nicht mehr fressen, ...).
+	
+	\subparagraph{Lösung:}
+	\begin{lstlisting}
+	public class Katze
+	{
+		public int amountPaws;
+		public int amountEyes;
+		public int amountEars;
+		
+		public double weight;
+		
+		public String[] furColours;
+		
+		public boolean isAlive;
+		
+		public Katze()
+		{
+			this(4, 2, 2, 5.0, new String[] {"black", "white"}, true);
+		}
+		
+		public Katze(int amountPaws, int amountEyes, int amountEars, double weight, String[] furColours, boolean isAlive)
+		{
+			this.amountPaws = amountPaws;
+			this.amountEyes = amountEyes;
+			this.amountEars = amountEars;
+			this.weight = weight;
+			this.furColours = furColours;
+			
+			if (weight <= 10.0)
+			{
+				this.isAlive = isAlive;
+			}
+		}
+		
+		public void move(double distance)
+		{
+			if (isAlive)
+			{
+				this.weight -= distance / 3;
+			}
+		}
+		
+		public void eat(double amountFood)
+		{
+			if (isAlive)
+			{
+				this.weight += amountFood;
+				
+				if (this.weight > 10.0)
+				{
+					this.isAlive = false;
+				}
+			}
+		}
+	}
+	\end{lstlisting}
+	\newpage
+	\paragraph{Aufgabe 3}\mbox{}
+	Modelliere das Objekt ''Person'' als Java Klasse vollständig, d.h. versuche dabei alle möglichen Member und Methoden zu finden.
+	
+	\subparagraph{Lösung:}
+	Hier gibt es viel Freiheiten, daher ist unten nur ein Lösungsvorschlag einer Teillösung.
+	\begin{lstlisting}
+	public class Person
+	{
+		public String name;
+		public String address;
+		
+		public String sex;
+		
+		public int age;
+		
+		public Head head;
+		public Arm[] arms;
+		public Leg[] legs;
+		
+		// ...
+		
+		public void moveArm(int index, double... angle)
+		{
+		}
+		
+		public void moveLeg(int index, double... angle)
+		{
+		}
+		
+		// ...
+		
+		public void fart(double loudness)
+		{
+		}
+		
+		// ...
+	}
+	\end{lstlisting}
+	\newpage
+	\paragraph{Aufgabe 4}\mbox{}
+	Modelliere die Member und Methoden des Objekts ''Bankautomat'' als Text. Als Hilfe kannst du die Begriffe \emph{hat} und \emph{kann} verwenden. Danach programmierst du das.
+
+	\subparagraph{Lösung:}
+	Ein ''Bankautomat'' \emph{hat} Display, Eingabebereich, Kartenschlitz, Ausgabeschlitz, Tresor, $\dots$\\
+	Ein ''Bankautomat'' \emph{kann} Karte einziehen und ausgeben, Geld ausgeben, Eingaben entgegennehmen, Ausgaben auf Display machen, $\dots$
+	\begin{lstlisting}
+	public class Bankautomat
+	{
+		public Display display;
+		public InputDevice inputDevice;
+		public Cardholder cardholder;
+		public MoneyOutput moneyOutput;
+		public Safe safe;
+		
+		// ...
+		
+		public void putCardIn()
+		{
+		}
+		
+		public void putCardOut()
+		{
+		}
+		
+		public void outputMoney(double amountOfMoney)
+		{
+		}
+		
+		public void handleInput()
+		{
+		}
+		
+		public void print(String text)
+		{
+		}
+		
+		// ...
+	}
+	\end{lstlisting}
+
+\end{document}