Programmieren in C# [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Programmieren in C# ======

++++Lernziele|

   * **Grundlagen C#**, alles im Dossier unten:
     * Variablen
     * Schleifen
     * Verzweigungen
     * Funktionen
     * Arrays
     * Listen
     * ...


++++

**Slides:**

   * {{ :ef_informatik:efif_jahr_a_01_ubersicht_ef_einfuehrung_csharp.pdf |}}
   * {{ :ef_informatik:efif_jahr_a_02_ganze_zahlen_debugging.pdf |}}
   * {{ :ef_informatik:efif_jahr_a_03_scope.pdf |}}
   * {{ :ef_informatik:efif_jahr_a_04_git_github.pdf |}}
   * {{ :ef_informatik:efif_jahr_a_05_strings.pdf |}}

{{:ef_informatik:imgoodatcsharp.jpg?300|}}

Ziel dieses Tutorials ist, die Grundlagen der Programmierung anhand der Programmiersprache C# (sprich: "C-sharp") zu lernen. 
Programmieren läuft immer wie folgt ab:
   - Man **schreibt** seinen Code ...
   - und **führt** diesen dann **aus**.
Am einfachsten geht dies mithilfe einer **IDE** (**Integrated Development Environment**). Dies ist ein Programm, in welchem man seinen Code schreiben kann und welches einem auf allfällige Fehler (Bugs) aufmerksam macht. Per Knopf- oder Tastendruck kann der Code dann ausgeführt werden.

===== - Einführung =====

==== - Installation & Hello World ====

Verwende eine der beiden Möglichkeiten, um C# zu programmieren:

   1. **Visual Studio** (Windows only)
   1. **Visual Studio Code** (Windows & Mac)


=== C# in Visual Studio ===

   - Lade die **Community Edition** (gratis) des **Visual Studios** von der Website https://visualstudio.microsoft.com/de/ herunter ...
   - ... und installiere sie.
   - Starte dann das VS und beginne ein neues C# **Konsolenprojekt** und gib ihm einen Namen.
   - Diese Projekt enthält bereits Code, der wie unten angezeigt aussehen sollte.
   - Dieses Programm ist das bekannteste Programm der Welt: **Hello World**. Alles was dieses Programm macht, ist die Nachricht ''Hello World!'' im Ausgabefenster, genannt **Konsole** oder **Terminal**, auszugeben. Drücke, um das Programm auszuführen auf den (grünen) Pfeil oder F5. 




=== C# in Visual Code ===

   1. .NET SDK installieren: [[https://dotnet.microsoft.com/en-us/download]]
   1. Check ob hat funktioniert: In Konsole: <WRAP><code>
dotnet --version
</code></WRAP>
   1. VSCode installieren
   1. C# Extension von Microsoft in VSCode installieren
   1. Neues C#-Projekt (ohne Top-Level Statements): <WRAP><code>
dotnet new console -n MyFirstApp --use-program-main
cd MyFirstApp
code .
</code></WRAP>
   1. Programm ausführen:<WRAP><code>
dotnet run
</code></WRAP>
Falls man Top-Level Statements verwenden möchte, lässt man einfach `--use-program-main` weg.



=== Top-Level Statements ===

Seit C# 9.0 werden standardmässig Top-Level Statements verwendet. Damit sieht ein einfaches "Hello World"-Programm wie folgt aus:
<code csharp>
Console.WriteLine("Hello World!");
</code>

In älteren Versionen sah das gleiche Programm wie folgt aus:
<code csharp>
using System;

namespace MyProject
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}
</code>

Doch was macht dieses Programm genau? Was die Zeilen wie ''using System;'' oder ''class MainClass'' bedeuten, besprechen wir später. Für den Moment ist nur folgendes wichtig: Sobald das Programm ausgeführt wird, wird der Code, der in der **Main-Methode** drin steht, ausgeführt - und zwar von oben nach unten. Dies ist der Code, der in den innersten geschwungenen Klammern steht. In diesem Beispiel ist dies nur genau eine Zeile: `Console.WriteLine("Hello World!");` Dies gibt den Befehl, den *String* (bedeutet Text in der Informatik) `Hello World!` in die Konsole zu schreiben.

==== - Tipps ====

   * Um eine gute Programmierer\*in zu werden benötigt es **Übung, Übung und nochmals Übung**!
   * Im **Interne**t findest du sehr viele Informationen zum Thema C#. Nutze dies! Zum Beispiel: schriftliche Tutorials, YouTube-Tutorials, Diskussionen in Foren, ...
   * Falls du *keine* Top-Level Statements verwendest: Verändere das vorgegebene **Gerüst** des Programms nicht. Lasse also z.B. Zeilen wie `class MainClass` unverändert.
   * **Projektnamen:** Benenne ein bestehendes Projekt nicht um, da dies zu Fehlern führen wird. Umgehe das Problem wie folgt: Erstelle ein neues Projekt mit dem richtigen Namen und copy-paste den von dir geschriebenen Code (und nicht das Gerüst darum herum) ins neue Projekt.
   * Lese **Fehlermeldungen**. Schreibst du Code, der nicht den vorgegebenen Regeln von C# entspricht, weigert sich VS, das Programm auszuführen. Du erhältst dann eine Fehlermeldung. Diese Meldungen sind oft sehr hilfreich und helfen dir, das Problem zu identifizieren und zu beheben.
   * Erhöhe deinen nerdigen **Coolness-Faktor**, in dem du ...
      * ... deinen Code komplett auf *Englisch* schreibst
      * ... möglichst wenig die Maus brauchst und alles mit der *Tastatur* mit *Shortcuts* erledigst!
   * In allen Programmiersprachen gibt es **Stil-Konventionen**, an die man sich halten sollte. In C# sollten Projektnamen, Variablennamen usw. folgende Regeln befolgen:
     * Verwende **CamelCase**. Nenne dein erstes Projekt zum Beipiel ''HelloWorld'' und nicht ''hello_world''.
     * Vermeide Leerschläge, also nicht: ''Hello World'' (in Strings sind Leerzeichen natürlich völlig ok)
     * Vermeide Umlaute, also nicht: ''HelloWörld''

{{youtube>HluANRwPyNo|What people think programming is vs. how it actually is}}

   * <color green>Weitere **Tipps** und **Shortcuts** werden in den unteren Kapiteln in grün angezeigt.</color>
   * <color magenta>Viele Personen machen ihre ersten Programmiererfahrungen in Python. Deshalb werden immer wieder Vergleiche zwischen Python und C# gezogen. Alle solche sind in der gleichen Farbe dargestellt.</color>

==== - Ausgabe in Konsole ====

Wie bereits oben gesehen, kann man mit `Console.WriteLine();` etwas in der **Konsole ausgeben**:
<code csharp>
Console.WriteLine(7); // Zahl ausgeben
Console.WriteLine("Hello World!"); // String ausgeben
Console.WriteLine("Die Zahl " + 7 + " ist eine Primzahl");
</code>
   * In Zeile 1 wird die Zahl `7` ausgegeben.
   * In Zeile 2 wird der Text `Hello World` ausgegeben. Beachte, dass man hier zwingend Anführungs- und Schlusszeichen anbringen muss. Eine Textzeile wird in der Informatik als **String** bezeichnet.
   * In Zeile 3 werden Strings und eine Zahl mit dem `+`-Symbol miteinander verknüpft.
   * Beachte, dass jede Linie mit einem **Semikolon** `;` beendet werden muss.
   * Mit zwei **Slashes** `//` kann man dem Code einen **Kommentar** hinzufügen. Ein solcher ist kein Programmcode und wird beim Ausführen ignoriert. Damit kann man seinem Code Anmerkungen anfügen, damit dieser besser verständlich wird.
   * <color green>**Shortcut:** Tippe nur `cw` + Tab und schon steht `Console.WriteLine();` da! Hurray!</color>
   * <color magenta>Das `Console.WriteLine();` entspricht dem `print()` in Python.</color>
   * <color magenta>**Kommentare** in C# schreibt man mit `//`, in Python mit `#`.</color>

===== - Variablen =====

Variablen geben einem die Möglichkeit, Information wie zum Beispiel Zahlen temporär zu speichern. Eine Variable hat immer einen **Datentyp**, von denen es eine grosse Anzahl gibt in C#. Möchte man Text ausgeben, so arbeitet man mit **Strings**. Möchte man eine Rechnung mit ganzen Zahlen (Zahlen ohne Nachkommastellen) ausführen, arbeitet man mit **int**s (von integer). Möchte man aber Nachkommastellen anzeigen können, verwendet man **double**s.

Beachte, dass C# eine **typensichere** Sprache ist. Möchtest du eine Variable mit Namen `a` haben, die eine ganze Zahl speichern soll, so musst du die Variable mit ihrem Typ *explizit deklarieren*:
<code csharp>
int a; // Deklaration der Variablen a vom Type int
a = 7; // Variable a wird der Wert 7 zugewiesen
Console.WriteLine(a);
</code>
   * In Zeile 1 wird die Variable deklariert. Diese soll vom Typ `int`, also ein Integer (ganze Zahl, also keine Kommazahl), sein. Dabei soll sie den Namen `a` tragen.
   * In Zeile 2 weisen wir der Variablen `a` den Wert `7` zu.
   * In Zeile 3 greifen wir auf diese Variable zurück und geben deren Wert in der Konsole aus. Es wird die Zahl `7` in der Konsole angezeigt.

Übrigens kann man die ersten beiden Zeilen auch in eine zusammenfassen:
<code csharp>
int a = 7; // Kombination von Deklaration und Wertzuweisung einer Variablen
</code>

Zusammengefasst hat eine Variable:
   * einen Namen (z.B. `a`)
   * einen Typ (z.B. `int`)
   * einen Wert (z.B. `7`)

C# ist eine **typensichere** Sprache. Dies bedeutet, dass wir einer Variablen ausschliesslich Werte zuordnen können, die ihrem Typ entsprechen. Betrachten wir folgenden Code:
<code csharp>
int a = 7;
a = 9; // erlaubt
a = 3.14; // nicht erlaubt, gibt einen Fehler
</code>

In Zeile 2 wird der Wert der Variablen geändert. Dies ist kein Problem, da `9` ein Integer ist. Zeile 3 ist aber problematisch, da man versucht, `a` eine Gleitkommazahl zuzuordnen. Dieser Code ist *nicht ausführbar* - versucht man es trotzdem, wird man eine Fehlermeldung erhalten.

Möchtest du eine Gleitkommazahl oder einen String in einer Variablen speichern, musst du dazu passende **Datentypen** wählen:
<code csharp>
double b = 3.14; // Gleitkommazahlen heissen Doubles in C#
string c = "Ich bin ein String!"; // Variable vom Typ String
</code>
Neben den hier erwähnten Datentypen int, double und string gibt es noch weitere. Einige davon wirst du im Verlaufe dieses Dossiers kennenlernen.

<color magenta>Python ist eine **nicht typensichere** Programmiersprache. Dort kann eine Variable beliebig ihren Typ ändern. Folgender Code würde in Python ohne Probleme funktionieren:</color>
<code python>
# Dies ist Python-Code, NICHT C#!
a = 42 # hier ist a ein int
a = 3.14159 # hier wird a zu einem float umdeklariert 
a = True # ... und hier zu einem Boolean
a = "And now I am a string!" # ... und hier zu einem String
a = [2,3,5,7,11,13] # ... und jetzt noch zu einer Liste
</code>
<color magenta>Solche Umdeklarationen sind in C# NICHT möglich! Ist `a` einmal ein int, so bleibt es ein solcher.</color>

In C# kann man auch rechnen. Hier ein Beispiel mit den gängigsten **Rechenoberationen**:
<code csharp>
int a = 7;
int b = 15;
Console.WriteLine(a + b); // Addition
Console.WriteLine(a - b); // Subtraktion
Console.WriteLine(a * b); // Multiplikation
Console.WriteLine(a / b); // Division

int result = a + b; // Addition, Resultat in neue Variable schreiben
Console.WriteLine(result); 
</code>

**Übersicht mathematische Operatoren:**
^Operator^Beschreibung^
|`+`|Additionsoperator (Summe `x + y`) oder Vorzeichenoperator (`+x`)|
|`-`|Subtraktionsoperator (Differenz `x - y`) oder Vorzeichenoperator (`-x`)|
|`*`|Multiplikationsoperator multipliziert zwei Operanden (`x * y`).|
|`/`|Divisionsoperator (`x/y`), Ganzzahldivision bei ints, mit Nachkommateil bei doubles|
|`%`|Restwertoperator (`x % y`), gibt Rest der Ganzzahldivision|
|`++`|Inkrementoperation (`x++` oder `++x`), erhöht Wert von `x` um 1|
|`--`|Dekrementoperation (`x--` oder `--x`), verringert Wert von `x` um 1|

==== - Aufgaben A ====

=== Aufgabe A1 ===

Welche der folgenden Namen sind zulässig für Variablen in C#? Begründe warum (nicht):
   - `iamavariable`
   - `42`
   - `g`
   - `IchPinEyneWariaple`
   - `secret number`
   - `_hans`
   - `!number`
   - `int`
   - `iAmAVariable`

=== Aufgabe A2 ===

Spiele mit den oben gelernten Datentypen. Deklariere Variablen, weise ihnen Werte zu, mache Rechnungen, gib Resultate in der Konsole aus ... Tobe dich aus und habe Spass!

=== Aufgabe A3 ===

Speichere die Zahl `1000000000` als int in einer Variablen.
   - Berechne nun das Doppelte, das Dreifache, Vierfache, ... dieser Variablen und gebe jeweils das Resultat aus. Was fällt dir auf? Begründe.
   - Nenne ein konkretes Beispiel für eine Aufgabe, bei der dies zu Problemen führen kann.
   - Was lernst du daraus für deine Programmierprojekte? Wie kann man das Problem umgehen?

=== Aufgabe A4 ===

Welchen Wert hat der grösste und welchen Wert der kleinste int, den man in C# darstellen kann? Woher kommt dies? Begründe ganz genau.

=== Aufgabe A5 ===

Mit `Console.WriteLine()` kann man etwas in der Konsole ausgeben. Ähnlich kann man mit `Console.ReadLine()` in der Konsole etwas eingeben und diesen Inhalt dann in einer Variablen speichern. Die Benutzer*In soll der Reihe nach aufgefordert werden, zuerst denn Vornamen, dann den Nachnamen und dann das Alter einzugeben. Alle Werte sollen dann in einer Variablen gespeichert werden. Danach soll ein Sätzli ausgegeben werden, welches alle eingegebenen Werte beinhaltet, zum Beispiel: //Hello Fritz Fischer. You are 42 years old!//

Achtung: Beim Eingeben des Alters wird ein Problem auftreten. Versuche mithilfe des Internets, selbst eine Lösung dafür zu finden!

=== Aufgabe A6 ===

Berechne oder bestimme mithilfe der Rechenoperatoren. Verwende ausschliesslich ints. Schreibe also `45` und //nicht// `45.0`:
   - Berechne die Ganzzahldivision $10023 / 45 = ?$, bestimme also Ganzzahlquotient und Rest.
   - Ist 1346 durch 17 teilbar?


===== - Logik =====

Beim Programmieren kommt man oft in die Situation, wo man **Entscheidungen** treffen muss. Zum Beispiel soll, je nach dem was der Benutzer eintippt, ein anderer Code ausgeführt werden.

==== - If-else Verzweigung ====

Am einfachsten ist die sogenannte **if**-Anweisung: Damit kann man überprüfen ob (also //if//) eine gewisse **Bedingung (condition)** erfüllt ist oder nicht. Dieser Befehl hat die Form
<code csharp>
if (CONDITION)
{
    // Codeblock in geschwungenen Klammern wird nur ausgeführt, wenn die BEDINGUNG erfüllt ist.
}
</code>

Damit können wir herausfinden, ob der Wert einer Variablen positiv ist:
<code csharp>
int x = 5;

if (x >= 0) // checks if x greater equal zero
{
    // code block gets executed ONLY if condition above is satisfied
    Console.WriteLine("x is greater equal zero!");
}
</code>

Falls der Wert von `x` auf eine negative Zahl gesetzt wird, wird in der Konsole nichts ausgegeben. Schön wäre aber, dass uns mitgeteilt würde, dass die Zahl negativ ist. Dies erreicht man mit einer **if-else**-Anweisung:
<code csharp>
int x = -5;

if (x >= 0) // checks if x greater equal zero
{
    // code block gets executed ONLY if condition above is satisfied
    Console.WriteLine("x is greater equal zero!");
}
else
{
    // code block gets executed ONLY if condition above is NOT satisfied
    Console.WriteLine("x is negative!");
}
</code>
Der Codeblock im else wird nur dann ausgeführt, wenn die Bedingung beim if //nicht// erfüllt wird.

Falls wir den Fall $x = 0$ separat behandeln möchten, verwenden wir eine **if-else if-else**-Anweisung:
<code csharp>
int x = 0;

if (x > 0) // checks if x greater zero
{
    Console.WriteLine("x is positive!");
}
else if (x == 0)  // checks if x equal zero but only if first condition is not satisfied
{
    Console.WriteLine("x is zero!");
}
else
{
    // gets executed if none of the above conditions are satisfied
    Console.WriteLine("x is negative!");
}
</code>

Beachte, dass man beliebig viele //else if// haben kann. Die allgemeine Form ist also:
<code csharp>
if (CONDITION 1)
{
    // code block if CONDITION 1 satisfied
}
else if (CONDITION 2)
{
    // code block if CONDITION 2 satisfied    
}
else if (CONDITION 3)
{
    // code block if CONDITION 3 satisfied    
}
...
else
{
    // code block if NONE of the above conditions are satisfied
}
</code>

==== - Vergleichsoperatoren ====

Für die Bedingungen stehen folgende **Vergleichsoperatoren** zur Verfügung:
^Operator^Beschreibung^
|`a == b`|(Vergleichsoperator) prüft, ob der Ausdruck a dem Ausdruck b entspricht, und gibt in diesem Fall `true` zurück.|
|`a != b`|Ergebnis der Operation ist `true`, wenn a ungleich b ist.|
|`a > b`|Ergebnis der Operation ist `true`, wenn a grösser b ist.|
|`a >= b`|Ergebnis der Operation ist `true`, wenn a grösser oder gleich b ist.|
|`a < b`|Ergebnis der Operation ist `true`, wenn a kleiner b ist.|
|`a <= b`|Ergebnis der Operation ist `true`, wenn a kleiner oder gleich b ist.|

**Bemerkungen**:
   * Eine Bedingung ist vom Datentyp **Boolean**, für den es genau zwei Möglichkeiten gibt: Er kann entweder erfüllt sein (`true`) oder nicht (`false`). Vergewissere dich selbst, dass zum Beispiel `Console.WriteLine(3 == 5);` den Wert `false` und `Console.WriteLine(3 < 5);` den Wert `true` ausgibt. Den Wert, der eine Bedingung annimmt, kann man auch wieder in einer Variablen speichern, z.B. `Boolean boo = (3 == 5);`
   * Beachte auch, dass **Verschachtelungen** gar kein Problem sein. Zum Beispiel kannst du im Codeblock von einem //else// ein neues //if-else if-else// haben.
   * Beachte den Unterschied zwischen dem **einfachen (`=`) und doppelten (`==`) Gleichheitszeichen**:
     * Das einfache Gleichheitszeichen ist ein //Zuweisungsoperator//: `x = 7` bedeutet, dass der Variablen auf der linken Seite der Wert auf der rechten Seite zugewiesen wird.
     * Das doppelte Gleichheitszeichen ist ein //Vergleichsoperator//: er überprüft, ob links und rechts das gleiche steht. Falls ja, nimmt die Bedingung den Wert `true`. Falls nicht, nimmt es den Wert `false` an. Das doppelte Gleichheitszeichen in der Informatik entspricht also in etwa dem normalen Gleichheitszeichen in der Mathe, zum Beispiel beim Lösen von Gleichungen.

<color magenta>In Python sieht das entsprechende if-else if-else-Statement wie folgt aus:</color>
<code python>
# Python Code!
if CONDITION 1:
    # code block if CONDITION 1 satisfied
elif CONDITION 2:
    # code block if CONDITION 2 satisfied
elif CONDITION 3:
    # code block if CONDITION 3 satisfied
...
else:
    #code block if NONE of the above conditions are satisfied
</code>
<color magenta>Beachte, dass in Python Codeblocks durch Einrückungen (Tab) festgelegt werden. In C# ist die Einrückung komplett egal, stattdessen werden geschwungene Klammern verwendet.</color>

<color green>**Shortcut:** Alles wieder schön einzurücken (rein visuell, hat keinen Einfluss auf Code): Ctrl + K, Ctrl + D</color>

==== - Logische Operatoren ====

Es können auch mehrere Vergleichsoperatoren miteinander verknüpft werden. Verknüpft man mehrere solche mit dem **AND-Operator**`&&` so ist die Bedingung genau dann true, wenn //sämtliche// Vergleichsoperatoren true sind.
Verwendet man den **OR-Operator** `||`, so ist die Bedingung true, wenn //mindestens ein// Vergleichsoperator true ist.

<color magenta>Die entsprechenden logischen Operatoren in Python sind `and` und `or`.</color>
==== Aufgaben B ====

=== Aufgaben B1 ===

Schreibe ein Programm, welches die Benutzer*In auffordert, eine ganze Zahl einzugeben. Die Zahl soll auf vier Fälle untersucht werden und eine entsprechende Nachricht soll ausgegeben werden. Die vier Fälle sind:
   * 42: The answer to the ultimate question of life, the universe and everything!
   * positive Zahlen (ausser 42)
   * Null
   * negative Zahlen

Falls du den 42-Joke nicht verstehst, bist du noch nicht nerdy genug und musst dringend //The Hitchhiker's Guide to the Galaxy// lesen oder schauen!

=== Aufgaben B2 ===
   - Schreibe für einen Online-Alkoholhändler ein einfaches Programm, bei dem die Kund\*In ihren Namen und ihr Alter eingeben muss und dann eine personalisierte Antwort darüber erhält, ob sie alt genug ist für einen Einkauf, je nachdem, welches Alter sie eingetippt hat, zum Beispiel: //"Liebe\(r) Ruthild, leider bist du nicht alt genug für einen Einkauf bei uns."// !
   - Erweitere dein Programm: Die Kund\*In wird auch nach dem Geschlecht gefragt. Je nach Eingabe soll dann die Anrede angepasst werden: //"Liebe Ruthild, leider bist du nicht alt genug für einen Einkauf bei uns."// oder //"Lieber Hans-Joseph, viel Spass beim Einkaufen!"//

===== - Debugging =====

Der **Debugger** erlaubt es einem, den Code eine Zeile nach der anderen auszuführen. Damit kann man einfach nachvollziehen, was der Code wo macht und welche Variable wann und wo welchen Wert annimmt. Dies ist besonders wertvoll, um Fehler (also Bugs) im Code zu finden - deshalb nennt man diesen Modus den Debugger!

Zuerst musst du einen oder mehrere **Breakpoints** setzen: Klicke dazu beim Code links von der Zeilennummer auf den Rand, dann erscheint ein roter Punkt, genannt Breakpoint. Führst du den Code nun im Debug-Modus aus, so pausiert die Ausführung des Codes beim ersten Breakpoint. Nun kannst du mit F10 den weiteren Code Zeile-für-Zeile ausführen. Mit F5 lässt du den Code wieder weiterlaufen bis er zu einem weiteren Breakpoint oder dem Ende gelangt.

Im Fenster **Lokale Variablen** siehst du, welche Variablen im Code vorkommen und welche Werte sie zum aktuellen Zeitpunkt gerade haben.

Studiere nun das **[[https://youtu.be/XPbZupyqrfI|"Der Visual Studio Debugger" von "Programmieren Starten"]]**. Stelle sicher, dass du die folgenden Dinge verstanden hast und anwenden kannst:
   * Breakpoints setzen
   * unterschiedliche Arten von Schritten, um Code durchzugehen.
   * lokale Variablen ansehen
   * Variable überwachen
   * Breakpoints mit Bedingungen

<color green>**Shortcuts:**</color>
   * <color green>**F5**: Code bis zum Ende/nächsten Breakpoint ausführen</color>
   * <color green>**F10**: Code Zeile-für-Zeile ausführen</color>


==== - Aufgaben C ====

=== Aufgabe C1 ===

Öffne eines deiner bisherigen Projekt mit möglichst viel Code.
   - Setze eine Breakpoint und führe den Code aus. Gehe dann mit F10 Schritt-für-Schritt durch den Code.
   - Setze mehrere Breakpoints und finde heraus, wie du mit F10 und F5 den Code ausführen kannst.

===== - Schleifen =====

Schleifen (loops) kommen dann zum Zug, wenn wir einen gewissen **Codeblock mehrfach hintereinander ausführen** wollen. Dabei gibt es zwei unterschiedliche Arten von Schleifen:
   * **While-Schleife:** wird solange ausgeführt, wie eine gegebene //Bedingung// erfüllt ist.
   * **For-Schleife:** wird eine fest //vorgegebene Anzahl-Mal ausgeführt//, praktisch, wenn man z.B. etwas hochzählen möchte

==== - While-Schleifen ====

Eine **while-Schleife** hat immer folgende Form:
<code csharp>
while (CONDITION)
{
    // code block that gets executed as long as CONDITION is satisfied
}
</code>
Der Codeblock in den geschwungenen Klammern wird solange wiederholt, wie die Bedingung (condition) erfüllt ist, solange also die Bedingung `true` ist.

Ein Fehler, der einem beim Programmieren gerne passiert, sind **Endlosschleifen (infinite loop)**. Dies sind while-Schleifen, deren Bedingung //immer erfüllt// ist, die Schleife wird also solange ausgeführt, bis die Benutzer*In den Code manuell abbricht. Ein Beispiel für eine Endlosschleife ist folgender Code:
<code csharp>
while (true)
{
    Console.WriteLine(42);
}
</code>

Für die Bedingung einer while-Schleife kann man die Gleicheng Bedingungen wie bei if-Anweisungen (siehe [[#vergleichsoperatoren|Vergleichsoperatoren]]) verwenden.

<color magenta>
Eine while-Schleife in Python sieht wie folgt aus:
</color>
<code python>
# PYTHON CODE
while true:
    # Code block in while-loop
</code>
<color magenta>
Beachte, dass in Python der Codeblock, der zur Schleife gehört, per Tab eingerückt wird. In C# wird der entsprechende Codeblock innerhalb der geschwungenen Klammern geschrieben.
</color>

<color green>**Shortcut:** Tippe //while// + 2xTab, um das Grundgerüst einer for-Schleife zu erzeugen. Passe es dann entsprechend an.</color>

While-Schleifen sind sehr praktisch, wenn man im Vorfeld //nicht genau weiss, wie oft der Codeblock in der Schleife wiederholt// werden soll. Zum Beispiel könnte man ein Quizspiel programmieren, in dem die Benutzer*In solange weiterspielen darf, bis sie einen Fehler macht. Dies kann bereits bei der ersten Frage sein, es kann aber auch erst bei Frage 42 sein - man weiss es nicht im Vorfeld. Weiss man hingegen bereits im Vorfeld, wie oft der Inhalt wiederholt werden soll, sind for-Schleifen sehr praktisch ...

==== - For-Schleifen ====

Eine **for-Schleife** führt einen Codeblock //eine fest vorgegebene Anzahl Mal durch// und hat folgenden Aufbau:
<code csharp>
for (VARIABLE WITH STARTING VALUE; VARIABLE WITH CONDITION; VARIABLE IN/DECREMENT)
{
    // Code block
}
</code>
Sie kommt also dann zur Anwendung, wenn man schon im Vorhinein //genau weiss, wie oft die Schleife ausgeführt werden soll//.

Folgender Code zum Beispiel gibt $7\times$ hintereinander die Zahl $42$ aus.
<code csharp>
for (int i = 0; i < 7; i++)
{
    Console.WriteLine("42");
}
</code>
Für die for-Schleife wird hier die Variable `i` (vom Typ int) mit Anfangswert $0$ festgelegt. Beim ersten Durchlauf der Schleife hat `i` also den Wert $0$. Beim zweiten Durchlauf hat `i` dann den Wert $1$, da wir mit `i++` vorgeben, dass `i` bei jedem durchlauf um $1$ erhöht wird. Dies geschieht solange, wie die Bedingung (hier: `i < 7`) erfüllt ist. Die Variable `i` kann man natürlich auch im Codeblock verwenden. Folgender Code gibt zum Beispiel alle Zahlen von $0$ bis und mit $6$ in der Konsole aus:
<code csharp>
for (int i = 0; i < 7; i++)
{
    Console.WriteLine(i);
}
</code>

<color magenta>
Der entsprechende Code in Python sieht wie folgt aus:
</color>
<code python>
# PYTHON CODE
for i in range(7):
    print(i)
</code>

<color green>**Shortcut:** Tippe //for// + 2xTab, um das Grundgerüst einer for-Schleife zu erzeugen. Passe die genauen Details dann entsprechend an.</color>

==== - Break & continue ====

Mithilfe von **break** und **continue** kann man jederzeit aus einer Schleife **ausbrechen**:
   * Die **break** Anweisung steht irgendwo im Codeblock der Schleife, meist in Verbindung mit einer if Abfrage. Läuft das Programm in sie hinein, bricht sie die Schleife ab und man springt zum Code nach der Schleife.
   * Die **continue** Anweisung bricht den //aktuellen Schleifendurchgang// ab und springt wieder zum Beginn der Schleife.


==== - Aufgaben D ====

=== Aufgabe D1 ===
   - Gib alle ganzen Zahlen von $10$ bis und mit $20$ aus ...
     - mithilfe einer for-Schleife
     - mithilfe einer while-Schleife
   - Gib alle geraden Zahlen von $2$ bis und mit $20$ aus ...
     - mithilfe einer for-Schleife
     - mithilfe einer while-Schleife
   - Gib alle ganzen Zahlen von $-1$ bis und mit $-10$ in absteigender Reihenfolge aus ...
     - mithilfe einer for-Schleife
     - mithilfe einer while-Schleife

=== Aufgabe D2 ===

Wandle in eine while-Schleife um:
<code csharp>
for (int k = 7; k < 13; k++)
{
    Console.WriteLine(2*k);
}
</code>

=== Aufgabe D3 ===

Betrachte folgenden Code:
<code csharp>
int x = 5;
while (x < 10)
{
    Console.WriteLine(x);
    x++;
}
</code>
   - Was macht der Code? Versuche es herauszufinden, ohne den Code auszuführen.
   - Schreibe nun den Code so um, dass die Schleife das unten angezeigte Grundgerüst hat. Verwende die **break** Anweisung, um aus der Schleife auszubrechen.
<code csharp>
...
while (true)
{
    ...
}
</code>

=== Aufgabe D4 ===
   - Die Benutzer\*In wird aufgefordert, eine positive ganze Zahl einzugeben. Dieses Spiel soll solange wiederholt werden, bis sie eine negative Zahl eingibt. Das Spiel wird dann abgebrochen.\\ \\
   - Beim Programmieren muss man immer damit rechnen, dass die Benutzer\*In nicht das macht, was sie sollte (manchmal aus Unwissenheit, manchmal aus Dummheit, manchmal aus purer Bosheit)! Hier zum Beispiel könnte die Benutzerin etwas eintippen, was //nicht in eine Zahl umgewandelt werden// kann. Aktuell würde dies wahrscheinlich dein Programm crashen. Dieses Problem kann man damit beheben, in dem man den **Fehler abfängt (exception handling)**, und zwar mit einer **try-catch**-Anweisung. Finde mithile einer Internetsuche heraus, wie dies funktioniert und schreibe dir einen kurzen Eintrag dazu in deine Unterlagen. Nutze dann dein neu erlangtes Wissen, um dein Programm aus dem vorherigen Punkt so anzupassen, dass es robust gegen renitente Benutzer\*Innen ist. 

=== Aufgabe D5 ===

Schreibe ein einfaches **Quiz-Game**, um deine Kopfrechenfähigkeiten zu trainieren. Die Benutzer\*In soll solange weiterspielen können, bis sie einen Fehler begeht, dann ist Game Over! Die Rechnungen sollen einfache Additionen von zwei ganzen Zahlen sein, wobei diese Zahlen per Zufall ausgewählt werden (siehe Codebeispiel unten). Der Benutzer\*In soll also die Rechnung präsentiert werden und dann das eingetippte Resultat mit dem tatsächlichen Resultat verglichen werden.

Folgender Code gibt einem $10$ **Zufallszahlen** im Bereich $1$ bis $5$ aus und dient als Beispiel dafür, wie man Zufallszahlen generiert:
<code csharp>
Random rand = new Random();
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(rand.Next(1, 6));
}
</code>

=== Aufgabe D6 ===

Mache eine Kopie von deinem Mathe-Quiz und erweitere es Schritt-für-Schritt:
   - Am Schluss soll der Spielstand ausgegeben werden.
   - Man soll solange spielen können, bis man drei Fehler gemacht hat.
   - Neben Aufgaben zur Addition sollen auch Aufgaben zur Subtraktion und Multiplikation, wenn du möchtest auch zur //Ganzzahldivision// vorkommen. Welche Operation in einer Aufgabe vorkommt, soll per Zufall bestimmt werden.
   - Gestalte das Spiel schön. Gib jeweils den Spielstand aus, bereinige die Konsole nach jedem Durchgang (`Console.Clear();`), ...

===== - Algorithmen =====

Ein **Algorithmus** ist eine //eindeutige Handlungsanweisung// für die Lösung von Problemen. Algorithmen bestehen aus //endlich vielen, wohldefinierten// Einzelschritten. 
Ein Algorithmus ist also ein Lösungsweg, eine Verarbeitungsvorschrift, die so präzise formuliert ist, dass sie einem Computer beigebracht (durch Programmieren) werden kann. Ein Algorithmus ist gewissermassen wie ein Rezept, welches aber vollständig klar formuliert und keinerlei Spielraum für Freiheiten lässt.

Gerade in der Mathematik sind Algorithmen sehr wichtig. Es gibt zum Beispiel Algorithmen für das Erkennen von Primzahlen oder das bestimmen des ggTs. In diesem Kapitel wollen wir einige solche Algorithmen anschauen und dabei unsere Programmierskills verbessern.


==== - Aufgaben E ====

=== Aufgabe E1 ===
Die berühmte **Fibonacci-Folge** besteht aus den Zahlen $$1,1,2,3,5,8,13,21,\ldots$$
Wie sehen die nächsten Folgenglieder aus? Schreibe ein Programm, welches die Folgenglieder der Fibonacci-Folge bestimmt.

=== Aufgabe E2 ===
   - **Primzahlen** sind positive ganze Zahlen, die nur durch sich selbst und $1$ teilbar sind, also $2,3,5,7,11,13,\ldots$. Schreibe ein Programm, in dem die Benutzer\*In eine ganze Zahl eingeben soll. Das Programm überprüft, ob es sich bei der Zahl um eine Primzahl handelt oder nicht und gibt eine entsprechende Rückmeldung. \\ \\
   - Mache eine Kopie deines Programms. Nun soll eine Zahl eingegeben werden und sämtliche Primzahlen kleiner gleich dieser Zahl ausgegeben werden.

=== Aufgabe E3 ===

Mithilfe des **Euklidschen Algorithmus** kann man den grössten gemeinsamen Teiler (ggT) von zwei natürlichen Zahlen  bestimmen.
   - Studiere, wie der Algorithmus funktioniert: https://www.lernhelfer.de/schuelerlexikon/mathematik/artikel/euklidischer-algorithmus.
   - Rechne von Hand auf (digitalem) Papier ein paar Beispiele durch.
   - Implementiere den Euklidschen Algorithmus.

=== Zusatzaufgaben ===

Auf der Website https://projecteuler.net gibt es viele interessante Aufgaben, die man programmiererisch lösen soll. Erstelle einen Account und logge dich ein. Studiere eine Aufgabe, schreibe ein Programm, um sie zu lösen und gib deine Lösung auf der Website ein. Du erhältst dann eine Rückmeldung darüber, ob dein Resultat korrekt ist oder nicht.


===== - Arrays & Listen =====

Bisher haben wir Zahlen nur in Variablen speichern können, die jeweils den Wert einer //einzelnen// Zahl speichern können. Als nächstes schauen wir deshalb **Arrays** und **Listen** an. Diese erlauben es uns //mehrere Werte in einer einzigen Variablen// zu speichern, anstatt für jeden Wert eine eigene Variable zu deklarieren.

Ein **Array** deklariert man wie folgt:
<code csharp>
int[] arr; // declare
arr = new int[3]; // initialize
</code>

In der ersten Zeile wird die Variable //deklariert//. Wir sagen dem Programm, dass die Variable mit Namen `arr` ein Array (wegen den eckigen Klammern `[]`) sein soll, welches ints beinhalten soll. In der zweiten Zeile wird die Variable //initialisiert//: Dazu verwenden wir das Keyword `new`. Wir sagen hier dem Programm, das das Array //genau 3// Elemente beinhalten soll. Der entsprechende Speicherplatz wird dann im RAM dafür bereitgestellt.

Die beiden Zeilen können auch in einem Schritt erledigt werden:
<code csharp>
int[] arr = new int[3]; // declare and initialize
</code>

Bei einem int-Array werden sämtliche Werte per Default auf $0$ gesetzt. Wir können aber auch gleich mit der Deklarierung und Initialisierung Werte zuweisen:
<code csharp>
int[] arr = new int[3] {7,13,42}; // declare, initialize and set values
</code>

Auf die Werte eines Arrays kann über eckige Klammern zugegriffen werden:
<code csharp>
arr[0] = 42; // set value of first element to 42
Console.WriteLine(arr[0]); // access first element of array and print in console
</code>

ACHTUNG: Beachte, dass man in C# und den meisten anderen Programmiersprachen **bei 0 zu zählen beginnt!** Das erste Element hat also den **Index** 0 usw. Dementsprechend folgender Joke:

{{:ef_informatik:programmerjoke.jpg?400|}}

Für Arrays muss bei der Initialisierung angegeben werden, wie viele Elemente es enthalten soll, damit der entsprechende Speicherplatz reserviert werden kann. Aus diesem Grund ist die **Grösse eines Arrays unveränderbar!** Dies ist oft aber unpraktisch, da man oft zu Beginn nicht weiss, wie viele Elemente man speichern möchte. Für solche sind Arrays wegen ihrer fixen Grösse unpraktisch. Stattdessen verwendet man dann **Listen**: 

<code csharp>
List<int> myList = new List<int>();
</code>
Beachte, dass du mit `using System.Collections.Generic;` den Namespace System.Collections.Generic einbinden musst, um Listen überhaupt verwenden zu können.
Listen können dann wie folgt manipuliert werden:
<code csharp>
myList.Add(7); // add element 7 at end of list, increases length of list by 1
myList.Insert(3, 19); // insert element 19 at index 3
myList.RemoveAt(3); // remove element at index 3, decreases length by 1
myList.Remove(42); // remove first occurrence of element 42
myList.RemoveAll(item => item == 42); // remove ALL occurrences of element 42
Console.WriteLine(myList.Count); // outputs length of list
</code>

Beachte, dass Listen deutlich langsamer sind als Arrays. Verwende also wann immer möglich Arrays.

Um sämtlichen Elemente eines Arrays oder einer Liste **in der Konsole auszugeben**, kann man die Liste mit einer for- oder foreach-Schleife durchgehen:
<code csharp>
// OPTION 1: for-loop
for (int i = 0; i < myList.Count; i++)
{
    Console.WriteLine(myList[i]);
}

// OPTION 2: foreach-loop
foreach (var item in myList)
{
    Console.WriteLine(item);
}
</code>

**Zusammengefasst:**
   * Verwende **Arrays** wenn die Grösse im Vorfeld bekannt ist ...
   * und **Listen** falls nicht.


==== - Aufgaben F ====

=== Aufgabe F1 ===

Erstelle jeweils ein Array mit dem vorgegebenen Namen, welches die ersten 20 Folgenglieder der angegebenen Zahlenfolge enthält. Befülle sämtlichen Arrays in einer //einzigen// Schleife:
   - Natürlichen Zahlen (`naturalNumbers`): $1,2,3,...,20$
   - Geraden Zahlen (`evenNumbers`): $2,4,6,...,40$
   - Quadratzahlen (`squareNumbers`): $1,4,9,16,25,...$

=== Aufgabe F2 ===

Erstelle jeweils ein Array mit dem vorgegebenen Namen, welches die ersten 20 Folgenglieder der angegebenen Zahlenfolge enthält. //Tipp:// Recycle deinen Code aus vorherigen Aufgaben.
   - Primzahlen (`primeNumbers`): $2,3,5,...$
   - Fibonacci-Zahlen (`fibonacciNumbers`): $1,1,2,3,5,...$

=== Aufgabe F3 ===

Die Benutzer*In wird aufgefordert, eine Zahl einzugeben. Sämtliche Zahlen der Fibonacci-Folge, die kleiner gleich dieser Zahl sind, sollen gespeichert werden. Macht es hier Sinn, ein Array oder eine Liste zu verwenden? Warum?

=== Zusatzaufgaben ===

Weiter an den Aufgaben von ProjectEuler.

===== - Funktionen =====

In Programmen muss oft an unterschiedlichen Stellen der gleiche Code ausgeführt werden. Anstelle von copy-paste bietet es sich an, diesen Code in eine **Funktion** zu verschieben. Ist eine Funktion einmal programmiert, so kann man sie beliebig oft aufrufen. In C# haben Funktionen folgende Form:

<code csharp>
static <data type output> MyFunction(<data type input> <variable name input>)
{
    # CODE
    return <output>;
}
</code>

Bemerkungen:
   * Der Datentyp des Outputs muss in der Deklaration der Funktion angegeben werden. Ein passendes **return-Statement** ist dann zwingend.
   * Funktionen, die **nichts zurückgeben** werden mit **void** gekennzeichnet.
   * Eine Funktion kann beliebig viele **Inputs** (auch **Argumente** genannt) haben.

Beispiele:
<code csharp>
SayHi("Jerry");

int sq = Square(3);
Console.WriteLine(sq);

static void SayHi(string name)
{
    // void-function: does something (print to console in this case)
    // but doesn't return anything
    Console.WriteLine("Hello, dear " + name + "!");
}

static int Square(int x)
{
    // takes one argument (x) of type int, does something with it
    // and returns result (another int)
    return x * x;
}
</code>

Beachte im Beispiel oben, dass **Funktionen *oberhalb* von ihrer Deklariert aufgerufen werden** können. Dies ist in Python nicht möglich!

++++Bemerkung zu Top-Level Statements|

Bis und mit der C#-Version 8, (also bis November 2020), eine einfache C#-Konsolenapp sah wie folgt aus:
<code csharp>
using System;
 
namespace MyProject
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}
</code>

Der Hauptcode wurde in eine spezielle Funktion, die **Main-Methode** (Methoden und Funktionen sind sehr ähnlich - mehr dazu zu einem späteren Zeitpunkt), geschrieben. Dies ist die Funktion, die beim Ausführen des Programms zuerst ausgeführt wurde.

Seit C# 9.0 kann man Top-Level Statements verwenden. Damit vereinfacht sich der "Hello World"-Code von oben zu:
<code csharp>
Console.WriteLine("Hello, World!");
</code>

Das Arbeiten *ohne* Top-Level Statements hat aber auch seine Vorteile: Zum Beispiel kann man dort Funktionen //parallel// zur Main-Methode und nicht innerhalb dieser deklariert werden. Dies erlaubt zum Beispiel das Überladen von Methoden (mehrere Funktionen mit identischen Namen aber unterschiedlichen Argument- und Rückgabetypen). Möchte man weiterhin ohne Top-Level Statements programmieren, so kann man beim Erstellen eines Projektes "Do not use top-level statements" anwählen.
++++

==== - Aufgaben G ====

=== Aufgabe G1 ===

In dieser ersten Aufgabe geht es darum, möglichst viele, kurze Funktionen zu schreiben. Rufe sämtliche programmierte Funktionen für verschiedene Inputs auf.
   - Schreibe eine Funktion `AnswerToEverything`, die keine Argumente entgegennimmt und nichts zurück gibt. Es soll nur die Zahl $42$ in die Konsole geschrieben werden.
   - Schreibe eine Funktion `Sum`, die zwei ints entgegennimmt und die Summe von diesen berechnet und zurückgibt.
   - Schreibe eine Funktion `isEven` vom Typ Boolean, die einen int entgegen nimmt. Falls dieser gerade (even) ist, wird `true` und ansonsten `false` zurückgegeben.

=== Aufgabe G2 ===

Schreibe zwei Funktionen `FahrenheitToCelsius` und `CelsiusToFahrenheit`, die eine Temperatur als Gleitkommazahl von zwischen Fahrenheit und Celsius umrechnen und zurückgeben.
Wieviel Grad sind 212 Fahrenheit?

Tipp: https://de.wikipedia.org/wiki/Grad_Fahrenheit#Umrechnung 

=== Aufgabe G3 ===

**Primzahlen immer wieder**
   - Schreibe eine Funktion `isPrime` vom Typ Boolean, die einen int entgegen nimmt. Die Funktion entscheidet dann darüber, ob die Zahl prim ist oder nicht und gibt einen entsprechenden Output heraus: `true` falls sie prim ist und ansonsten `false`.
   - Gehe nun in einer Schleife alle Zahlen von 2 bis 100 durch. Entscheide mithilfe der Funktion von oben für jede Zahl, ob sie prim ist oder nicht. Falls ja, gib die Zahl in der Konsole aus.

=== Aufgabe G4 ===

Die meisten Programmiersprachen kommen mit vielen vorprogrammierten Utility-Functions daher, die einem das Leben vereinfachen. Ziel dieser Aufgabe ist es, diese **Utility-Functions selbst zu programmieren**, und dabei nur die *rudimentärsten Befehle* wie Schleifen oder if-else zu verwenden. Vordefinierte String-Methoden wie Length, Split usw. dürfen natürlich nicht verwendet werden. Es sollen auch *keine Listen* sondern nur Arrays verwendet werden. Natürlich darfst du selbst programmierte Utility-Functions wiederverwenden dürfen. Beispiel: Nachdem du deine eigene `Length`-Funktion definiert hast, darfst du diese verwenden für die nächsten Funktionen.

   1. Funktion `Length`, die die Länge eines Strings bestimmt und zurück gibt. Programmiere dies ohne die Methode Length, die bei jedem String vorhanden ist. Verwende auch kein foreach (verwendet intern wohl auch Length).
   1. Funktion `NumberOfChar`, die überprüft, wie oft ein bestimmter Buchstabe (Typ: char) in einem String vorkommt, zB. \\ `int i = NumberOfChar("Nerds sind super cool", 'n')`
   1. Funktion `PositionsOfChar`, die in einem Array sämtliche Positionen eines Buchstaben in einem String angibt, zB. \\ `int[] i = PositionsOfChar("Nerds sind super cool", 'n')`
   1. Funktion `Split`, die einen String bei jedem Vorkommen eines bestimmten Zeichens auftrennt und die Teile in einem Array zurückgibt, zB. \\ `string[] a = Split("Ein Satz mit fünf Wörtern", ' ')`


===== - Lösungen =====

<nodisp 1>

++++Aufgaben A|

<code csharp>
// Aufgabe A1
// nicht zulaessig:
// 42 (weil Zahl)
// secret number (weil Leerschlag)
// !number (weil unerlaubtes Sonderzeichen)
</code>

<code csharp>
// Aufgabe A2
int x = 1000000000;             
int inc = 1000000000;           
Console.WriteLine(x);           // -> 1000000000
Console.WriteLine(x + inc);     // -> 2000000000
Console.WriteLine(x + 2 * inc); // -> - 1294967296
Console.WriteLine(x + 3 * inc); // -> - 294967296
Console.WriteLine(x + 4 * inc); // -> 705032704
</code>

<code csharp>
// Aufgabe A4
int b = 2147483647; // = 2^31 - 1
Console.WriteLine(b); // 2147483647
Console.WriteLine(b + 1); // - 2147483648
</code>

<code csharp>
// Aufgabe A5
Console.Write("Enter your first name: ");
String firstName = Console.ReadLine();
Console.Write("Enter your last name: ");
String lastName = Console.ReadLine();
Console.Write("Enter your age: ");
int age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Hello " + firstName + " " + lastName + " you are " + age + " years old!");
</code>

<code csharp>
// Aufgabe A6
Console.WriteLine("Quotient: " + 10023 / 45);
Console.WriteLine("Rest: " + 10023 % 45);
</code>

++++

++++Aufgaben B|

<code csharp>
// Aufgabe B1
Console.Write("Enter number: ");
int x = Convert.ToInt32(Console.ReadLine());

if (x == 42)
{
    Console.WriteLine("The answer to the ultimate question of life, the universe and everything!");
}
else if (x > 0)
{
    Console.WriteLine("positive number");
}
else if (x == 0)
{
    Console.WriteLine("zero!");
}
else
{
    Console.WriteLine("negative number");
}
</code>

<code csharp>
// Aufgabe B2
Console.Write("Gebe deinen Namen ein: ");
string name = Console.ReadLine();
Console.Write("Gebe dein Alter ein: ");
int age = Convert.ToInt32(Console.ReadLine());
Console.Write("Gebe dein Geschlecht (m,w) oder die gewuenschte Anrede ein: ");
string sex = Console.ReadLine();
string anrede = sex;

if (sex == "w")
{
    anrede = "Liebe";
}
else if (sex == "m")
{
    anrede = "Lieber";
}

if (age >= 18)
{
    Console.WriteLine(anrede + " " + name + ", viel Spass beim Einkaufen!");
}
else
{
    Console.WriteLine(anrede + " " + name + ", du bist leider nicht alt genug, um bei uns einzukaufen!");
}
</code>

++++

</nodisp>

<nodisp 1>

++++Aufgaben D|

<code csharp>
// Aufgabe D1 - 1
for (int i = 10; i <= 20; i++)
{
    Console.WriteLine(i);
}

Console.WriteLine();

int j;
j = 10;
while (j <= 20)
{
    Console.WriteLine(j);
    j++;
}
</code>

<code csharp>
// Aufgabe D1 - 2
for (int i = 2; i <= 20; i += 2)
{
    Console.WriteLine(i);
}

Console.WriteLine();

int j;
j = 2;
while (j <= 20)
{
    Console.WriteLine(j);
    j += 2;
}
</code>

<code csharp>
// Aufgabe D1 - 3
for (int i = -1; i >= -10; i -= 1)
{
    Console.WriteLine(i);
}

Console.WriteLine();

int j;
j = -1;
while (j >= -10)
{
    Console.WriteLine(j);
    j -= 1;
}
</code>

<code csharp>
// Aufgabe D2
int i = 7;
while (i < 13)
{
    Console.WriteLine(2 * i);
    i++;
}
</code>

<code csharp>
// Aufgabe D3
int x = 5;
while (true)
{
    if (x > 9) { break; }
    Console.WriteLine(x);
    x++;
}
</code>

<code csharp>
// Aufgabe D4
// Alternativ könnte man die if-Verzweigung auch ins try { ... } hineinnehmen. Dann wird das continue ueberfluessig. Generell ist es gut, nicht zu viele Einrueckungen zu haben -> Code leserlicher
int nr;
while (true)
{
    try
    {
        Console.Write("Gib eine positive Zahl ein: ");
        nr = Convert.ToInt32(Console.ReadLine());
    }
    catch (Exception ex)
    {
        Console.WriteLine("Du sollste eine Zahl eingeben! Und nochmals ...");
        continue;
    }

    if (nr > 0)
    {
        Console.WriteLine("Bravo, das ist eine positive Zahl. Gut gemacht!");
        break;
    }
    else
    {
        Console.WriteLine("Leider keine positive Zahl. Und nochmals ...");
    }
}
</code>

<code csharp>
// Aufgabe D5
Random rand = new Random();

int x, y, r;

while (true)
{
    x = rand.Next(1, 10);
    y = rand.Next(1, 10);
    Console.Write("Calculate: " + x + " + " + y + " = ");
    
    try
    {
        r = Convert.ToInt32(Console.ReadLine());
    }
    catch (Exception ex)
    {
        Console.WriteLine("Input NOT a number. Game over!");
        break;
    }

    if(r == x + y)
    {
        Console.WriteLine("Correct! Next calculation:");
    }
    else
    {
        Console.WriteLine("Unfortunately wrong. Game over!");
        break;
    }
}
</code>

<code csharp>
// Aufgabe D6
Random rand = new Random();

int x, y, resultPlayer, op;
int resultCorrect = 0;
int correct = 0;
int wrong = 0;
string symbol = "";

while (true)
{
    x = rand.Next(1, 10);
    y = rand.Next(1, 10);
    op = rand.Next(0, 3);

    if (op == 0)
    {
        resultCorrect = x + y;
        symbol = "+";
    }
    else if (op == 1)
    {
        resultCorrect = x - y;
        symbol = "-";
    }
    else if (op == 2)
    {
        resultCorrect = x * y;
        symbol = "*";
    }

    Console.Clear();
    Console.Write("Calculate: " + x + " " + symbol + " " + y + " = ");

    try
    {
        resultPlayer = Convert.ToInt32(Console.ReadLine());

        if (resultPlayer == resultCorrect)
        {
            correct++;
            Console.WriteLine("Correct! Your score is: Correct: " + correct + ", Wrong: " + wrong);
            Console.WriteLine("Press q to quit and any other key to continue");
            if(Console.ReadKey().Key == ConsoleKey.Q)
            {
                break;
            }
            continue;
        }
    }
    catch (Exception ex) { }

    // result or input wrong
    wrong++;

    Console.WriteLine("Wrong input. Correct result would have been: " + resultCorrect);
    if (wrong < 3)
    {
        Console.WriteLine("Your score is: Correct: " + correct + ", Wrong: " + wrong);
        Console.WriteLine("Press q to quit and any other key to continue");
        if (Console.ReadKey().Key == ConsoleKey.Q)
        {
            break;
        }
        continue;
    }
    else
    {
        Console.WriteLine("GAME OVER! Press any key.");
        Console.ReadKey();
        break;
    }
}

Console.Clear();
Console.WriteLine("Your final score is: Correct: " + correct + ", Wrong: " + wrong);
</code>
++++

++++Aufgaben E|

<code csharp>
// Aufgabe E1
int f1 = 1;
int f2 = 1;
int temp;

Console.WriteLine(f1);
Console.WriteLine(f2);

for (int i = 2; i < 20; i++)
{
    temp = f1 + f2;
    f1 = f2;
    f2 = temp;
    Console.WriteLine(f2);
}
</code>

<code csharp>
int z;
bool isPrime = true;

Console.Write("Enter a positive integer: ");

try
{
    z = Convert.ToInt32(Console.ReadLine());
}
catch (Exception ex)
{
    z = 0; // set it to a number that is NOT prime
}

if (z >= 2)
{
    for (int i = 2; i <= Math.Sqrt(z); i++)
    {
        if (z % i == 0)
        {
            isPrime = false;
            break;
        }
    }
}
else
{
    isPrime = false;
}

if (isPrime)
{
    Console.WriteLine("Number " + z + " IS a prime number.");
}
else
{
    if(z > 0)
    {
        Console.WriteLine("Number " + z + " is NOT a prime number.");
    }
    else
    {
        Console.WriteLine("Invalid input.");
    }
}
</code>

<code csharp>
// E3 (Euklidscher Algorithmus, ggT bestimmen)

int x = 391;
int y = 544;
int xOrg = x;
int yOrg = y;
int q, r;

while (true)
{
    r = x % y;
    if (r == 0)
    {
        break;
    }
    x = y;
    y = r;
}

Console.WriteLine("ggT von " + xOrg + " und " + yOrg + " ist: " + y);
</code>

++++

++++Aufgaben F|

<code csharp>
// F1
int[] naturalNumbers = new int[20];
int[] evenNumbers = new int[20];
int[] squareNumbers = new int[20];

for (int i = 1; i <= 20; i++)
{
    naturalNumbers[i-1] = i;
    evenNumbers[i-1] = 2*i;
    squareNumbers[i-1] = i*i;
}

WriteIntArray(naturalNumbers);
WriteIntArray(evenNumbers);
WriteIntArray(squareNumbers);

// F2
int[] primeNumbers = new int[20];
int[] fibonacciNumbers = new int[20];

{ // prime (in own scope to avoid problems with variables)
    int i = 0; // position in array
    int z = 2; // prime number candidate
    while (i < 20)
    {
        bool isPrime = true;
        for (int j = 2; j <= Math.Sqrt(z); j++)
        {
            if (z % j == 0)
            {
                isPrime = false;
                break;
            }
        }
        if (isPrime)
        {
            primeNumbers[i] = z;
            i++;
        }
        z++;
    }
}

{ // fibonacci
    int f1 = 1;
    int f2 = 1;
    int temp;

    for (int i = 0; i < 20; i++)
    {
        fibonacciNumbers[i] = f1;
        temp = f1 + f2;
        f1 = f2;
        f2 = temp;
    }
}

WriteIntArray(primeNumbers);
WriteIntArray(fibonacciNumbers);

// UTILITY FUNCTION
void WriteIntArray(int[] arr)
{
    if (arr.Length == 0) { return; }
    for (int i = 0; i < arr.Length - 1; i++)
    {
        Console.Write(arr[i] + ",");
    }
    Console.WriteLine(arr[arr.Length - 1]);
}
</code>

++++

++++Aufgaben G|

<code csharp>
// G1
AnswerToEverything();
Console.WriteLine(Sum(39, 3));
Console.WriteLine(isEven(42));

static void AnswerToEverything()
{
    Console.WriteLine(42);
}

static int Sum(int a, int b)
{
    return a + b;
}

static bool isEven(int x)
{
    if (x % 2 == 0)
    {
        return true;
    }
    return false;
}
</code>

<code csharp>
// G2
Console.WriteLine(FahrenheitToCelsius(212.0));

static double FahrenheitToCelsius(double fahrenheit)
{
    return (fahrenheit - 32.0) * 5.0/9.0;
}

static double CelsiusToFahrenheit(double celsius)
{
    return celsius * 9.0/5.0 + 32.0;
}
</code>

<code csharp>
// G3
for (int i = 2; i <= 100; i++)
{
    if (isPrime(i))
    {
        Console.Write(i + ",");
    }
}

static bool isPrime(int z)
{
    if (z < 2) { return false; }
    for (int j = 2; j <= Math.Sqrt(z); j++)
    {
        if (z % j == 0)
        {
            return false;
        }
    }
    return true;
}
</code>

<code csharp>
// G4
Console.WriteLine(Length(""));
Console.WriteLine(NumberOfChar("Nerds sind super cool", 'n'));
WriteIntArray(PositionsOfChar("Nerds sind super cool", 'n'));
WriteStringArray(Split("Nerds sind super cool", ' '));

static int Length(string s)
{
    int i = 0;
    while (true)
    {
        try
        {
            char c = s[i];
            i++;
        }
        catch (Exception ex)
        {
            return i;
        }
    }
}

static int NumberOfChar(string s, char c)
{
    int count = 0;
    for (int i = 0; i < Length(s); i++)
    {
        if (s[i] == c) { count++; }
    }
    return count;
}

static int[] PositionsOfChar(string s, char c)
{
    int count = NumberOfChar(s, c);
    int[] positions = new int[count];
    int j = 0;
    for (int i = 0; i < Length(s); i++)
    {
        if (s[i] == c) {
            positions[j] = i;
            j++;
        }
    }
    return positions;
}

static string[] Split(string s, char c)
{
    int count = NumberOfChar(s, c);
    string[] subStrings = new string[count + 1];
    string sub = "";
    int j = 0;
    for (int i = 0; i < Length(s); i++)
    {
        if (s[i] == c)
        {
            subStrings[j] = sub;
            sub = "";
            j++;
            continue;
        }
        sub += s[i];
    }
    subStrings[j] = sub;
    return subStrings;
}

// UTILITY FUNCTION
void WriteIntArray(int[] arr)
{
    if (arr.Length == 0) { return; }
    for (int i = 0; i < arr.Length - 1; i++)
    {
        Console.Write(arr[i] + ",");
    }
    Console.WriteLine(arr[arr.Length - 1]);
}

void WriteStringArray(string[] arr)
{
    if (arr.Length == 0) { return; }
    for (int i = 0; i < arr.Length - 1; i++)
    {
        Console.Write(arr[i] + ",");
    }
    Console.WriteLine(arr[arr.Length - 1]);
}
</code>

++++

</nodisp>