First Commit

Tag 1/Aufgaben/Lösungen/Lösung_1.txt

@@ -0,0 +1,26 @@
+/*
+ * Schreiben Sie ein Programm das kontrolliert, ob eine Zahl gerade oder ungerade ist und dann einen String ausgibt der sagt "Die Zahl ist ungerade" oder
+ * "Die Zahl ist gerade".
+ * Hinweis: Zur Vergleichsberechnung bietet sich der Modulo-Operator % an.
+ */
+
+using System;
+
+namespace Lösungen
+{
+    class Program
+    {
+        public static void Main(string[] args)
+        {
+            if (IstGerade(5))
+                Console.WriteLine("Gerade");
+            else
+                Console.WriteLine("Ungerade");
+        }
+
+        public static bool IstGerade(int zahl)
+        {
+            return zahl % 2 == 0;
+        }
+    }
+}

Tag 1/Aufgaben/Lösungen/Lösung_2.txt

@@ -0,0 +1,28 @@
+/*
+ * Schreiben Sie eine statische Funktion, die die Quersumme einer Zahl berechnet.
+ * Übergabewert (Parameter): int zahl
+ * Rückgabewert: Die berechnete Quersumme.
+ * Hinweis: Zur Berechnung bietet sich der Modulo-Operator % an.
+ */
+
+using System;
+
+namespace Lösungen
+{
+    class Program
+    {
+        public static void Main(string[] args)
+        {
+            Console.WriteLine(Quersumme(12345));
+        }
+
+        public static int Quersumme(int zahl)
+        {
+            if (zahl == 0)
+            {
+                return 0;
+            }
+            return zahl % 10 + Quersumme(zahl / 10);
+        }
+    }
+}

Tag 1/Aufgaben/Lösungen/Lösung_3.txt

@@ -0,0 +1,49 @@
+/* Schreiben Sie ein Programm, das...
+ * eine Zufallszahl von 1 bis inklusive 99 auswürfelt
+ * und den Benutzer in einer Schleife über eine Eingabe die Zahl erraten lässt.
+ * Dabei wird die eingegebene Zahl in einen Integer geparst. Bei falscher Eingabe soll wiederholt werden.
+ * Das Programm teilt nun dem Benutzer mit, ob die Schätzung kleiner oder größer als die gewürfelte Zahl war.
+ * Die Schleife endet, wenn die gewürfelte Zahl getroffen wurde.
+ * Dem Benutzer wird die Anzahl der Versuche ausgegeben.
+
+ * Recherchieren Sie die Klasse "Random".
+ */
+
+using System;
+
+namespace Lösungen
+{
+    class Program
+    {
+        private static readonly Random random = new Random();
+
+        public static void Main(string[] args)
+        {
+            int zahl = random.Next(99) + 1;
+            int rate;
+            int anzahl = 0;
+
+            while (true)
+            {
+                Console.WriteLine("DEBUG " + zahl);
+                Console.Write("Rate die Zahl! > ");
+
+                while (!Int32.TryParse(Console.ReadLine(), out rate));
+
+                anzahl++;
+                if (rate > zahl)
+                    Console.WriteLine("Zu groß!");
+                else if (rate < zahl)
+                    Console.WriteLine("Zu klein!");
+                else
+                {
+                    Console.WriteLine($"Getroffen! Du hast {anzahl} Versuche gebraucht.");
+                    break;
+                }
+
+            }
+
+        }
+
+    }
+}

Tag 1/Aufgaben/Lösungen/Lösung_4.txt

@@ -0,0 +1,45 @@
+/*
+ * In ihrem Unternehmen werden neue Artikelnummern vergeben. Sie bestehen aus 5 Zahlen und einer Prüfziffer.
+ * Sie sollen ein Programm entwerfen, dass 5 einstellige Zahlen einliest und daraus die Prüfziffer errechnet und sie auf der Console ausgibt. Wie Sie mit Fehleingaben umgehen, bleibt Ihnen überlassen.
+ * Folgende Informationen erhalten Sie für die Berechnung der Prüfziffer:
+ * - die geraden Zahlen werden addiert, die ungeraden Zahlen werden mit 3 multipliziert und anschließend addiert.
+ * - die Prüfziffer ergibt sich aus der letzten Stelle der Summe.
+ * Beispiel:    27493 => 2+4 = 6;
+ *              7*3+9*3+3*3 = 57;
+ *              6 + 57 = 63 => Prüfziffer 3
+ *              Artikelnummer = 27493-3
+ */
+
+using System;
+
+namespace Lösungen
+{
+    class Program
+    {
+        public static void Main(string[] args)
+        {
+            Console.WriteLine(new Program().GetPrüfziffer(27493));
+
+        }
+
+        public int GetPrüfziffer(int zahl)
+        {
+            int summe = 0;
+            while (zahl != 0)
+            {
+                int temp = zahl % 10;
+                if (temp % 2 == 0)
+                    summe += temp;
+                else
+                    summe += (temp * 3);
+
+                zahl = zahl / 10;
+
+            }
+            int prüfziffer = summe % 10;
+
+            return prüfziffer;
+        }
+
+    }
+}

Tag 1/Aufgaben/Lösungen/Lösung_5.txt

@@ -0,0 +1,85 @@
+/*
+    AUFGABENSTELLUNG ("große Straße" beim Kniffel-Spiel)
+
+        - Führen Sie bitte zunächst im Main ein Integer-Array der Länge 5 ein
+        - Schreiben Sie anschließend bitte die beiden folgenden Methoden:
+            a) Funktionsname: FülleWürfelArray
+               Übergabewerte: 1 Integer-Array 'arr' 
+                              2 Integer 'min' und 'max'
+               Funktion:      Die Methode füllt das Array arr mit Zufallszahlen zwischen (beiderseits einschließlich) min und max
+                              (HINWEIS: Länge des Arrays = arr.Length)
+               Rückgabewert:  Keiner
+
+            b) Funktionsname: AusgabeWürfelArray
+               Übergabewerte: 1 Integer-Array 'arr'
+               Funktion:      Ausgabe aller Arrayfeld-Werte (also für alle Indices zwischen 0 und arr.Length) auf der Konsole
+               Rückgabewert:  Keiner
+
+       Verwenden Sie bitte die beiden obigen Methoden in folgendem C#-Programm - für dieses Programm soll gelten:
+            - Das Programm startet eine Schleife, pro Durchlauf ...
+                + wird ein Array der Länge 5 mit Zufalls-Würfelzahlen gefüllt
+                + wird das gefüllte Array (numerisch) sortiert
+                + wird überprüft, ob es sich um eine "große Straße" handelt (1,2,3,4,5) oder (2,3,4,5,6)
+            - Die Schleife endet, falls eine "große Straße" gewürfelt wurde
+            - Das Programm endet mit der Ausgabe der Anzahl der Schleifen-Durchläufe, die nötig waren, um die "große Straße" zu erreichen
+*/
+
+using System;
+
+namespace Lösungen
+{
+    class Program
+    {
+        private static readonly Random random = new Random();
+        public static void FülleWürfelArray(int[] arr, int min, int max)
+        {
+            for (int i = 0; i < arr.Length; i++)
+            {
+                arr[i] = random.Next(min, max + 1);
+            }
+        }
+
+        public static void AusgabeWürfelArray(int[] arr)
+        {
+            foreach (int zahl in arr)
+                Console.Write(zahl + " ");
+            Console.WriteLine();
+        }
+
+        // Es handelt sich um eine Zahlenfolge, wenn die Differenz zur nächsten Zahl genau 1 beträgt.
+        public static bool PrüfeGroßeStraße(int[] zahlen)
+        {
+            for (int i = 0; i < zahlen.Length - 1; i++)
+            {
+                // Sobald die Differenz nicht genau 1 ist, ist es keine Zahlenfolge und es kann false zurückgegeben werden
+                if (zahlen[i + 1] - zahlen[i] != 1)
+                    return false;
+            }
+            return true;
+        }
+
+        public static void Main(String[] args)
+        {
+            int i = 1;
+
+            do //Variante 2
+            {
+                int[] zahlen = new int[5];
+                FülleWürfelArray(zahlen, 1, 6);
+                Array.Sort(zahlen);
+
+                // In PrüfeGroßeStraße wird die Differenz zu jeder nächsten Zahl errechnet.
+                // Ist die Differenz ungleich 1, handelt es sich nicht um eine Zahlenfolge.
+                if (PrüfeGroßeStraße(zahlen))
+                {
+                    AusgabeWürfelArray(zahlen);
+                    Console.WriteLine(" - Große Straße! Versuche: " + i);
+
+                    break;
+                }
+                i++;
+            } while (true);
+        }
+
+    }
+}