E20 Ex12

Exercises/E20_Lists/Exercise_10.cs

@@ -18,8 +18,15 @@ namespace Exercises_C_Sharp.E20_Lists
         static List<string> Meth()
         {
             /*Code START*/
+            List<string> stringList = [];
 
-            return new List<string>();
+            Console.WriteLine("Bitte geben Sie Werte ein und bestätigen Sie diese mit 'Enter'. Bei einer leeren Eingabe bricht das System ab:");
+            while(true)
+            {
+                string? temp = Console.ReadLine();
+                if(string.IsNullOrWhiteSpace(temp)) return stringList;
+                stringList.Add(temp);
+            }
             /*Code ENDE*/
         }
     }

Exercises/E20_Lists/Exercise_11.cs

@@ -18,8 +18,18 @@ namespace Exercises_C_Sharp.E20_Lists
         static List<int> Meth()
         {
             /*Code START*/
+            List<int> intList = [];
 
-            return new List<int>();
+            Console.WriteLine("Bitte geben Sie eine Zahl ein. Eine leere Eingabe führt zum Abbruch");
+            while(true)
+            {
+                string? tempString = Console.ReadLine();
+
+                if(string.IsNullOrWhiteSpace(tempString))return intList;
+
+                if(int.TryParse(tempString, out int tempInt)) intList.Add(tempInt);
+
+            }
             /*Code ENDE*/
         }
     }

Exercises/E20_Lists/Exercise_12.cs

@@ -22,12 +22,17 @@ namespace Exercises_C_Sharp.E20_Lists
         }
 
         //In der folgenden Methode bekommen Sie eine Liste von Strings und einen Character. Sie sollen nun aus der Liste alle Wörter entfernen, die diesen Character beinhalten.
-        static List<string> Meth(List<string> lis, char c)
+        static List<string> Meth(List<string> lis, char variableFürEinenChar)
         {
             /*Code START*/
+            List<string> tempList = [];
+            foreach(var element in lis)
+                if(!element.Contains(variableFürEinenChar))
+                    tempList.Add(element);
 
-            return new List<string>();
+            return tempList;
             /*Code ENDE*/
         }
+        static List<string> MethEasy(List<string> lis, char c) => lis.Where(k => !k.Contains(c)).ToList();
     }
 }

Exercises/E20_Lists/Exercise_6.cs

@@ -13,6 +13,15 @@ namespace Exercises_C_Sharp.E20_Lists
 
             
             /*Code START*/
+            
+
+            intList.Sort();
+            for (int i = 0; i < intList.Count; i++)
+            {
+                Console.WriteLine("[{0}] {1}", i, intList[i]);
+            }
+            int mitte = intList.Count / 2;
+            Console.WriteLine(intList[mitte]);
 
 
             /*Code ENDE*/

Exercises/E20_Lists/Exercise_7.cs

@@ -25,13 +25,36 @@ namespace Exercises_C_Sharp.E20_Lists
         {
             /*Code START*/
 
-            return intList;
+            List<int> tempList = [];
+            foreach(var element in intList)
+                if(element % 2 == 0)
+                    tempList.Add(element);
+
+            return tempList;
             /*Code ENDE*/
         }
+
+        static List<int>RemoveOddsEasy(List<int> intList) => intList.Where(k => k % 2 == 0).ToList();
+
         static List<int> RemoveEvens(List<int> intList)
         {
             /*Code START*/
 
+            for(int i = 0; i < intList.Count; i++)
+                if(intList[i] % 2 == 0)
+                {
+                    intList.RemoveAt(i);
+                    i--;
+                }
+
+            //ODER:
+            for(int k = intList.Count - 1; k >= 0; k--)
+                if(intList[k] % 2 == 0)
+                    intList.RemoveAt(k);
+
+            //ODER:
+            intList.RemoveAll(k => k % 2 == 0);
+
             return intList;
             /*Code ENDE*/
         }

Exercises/E20_Lists/Exercise_8.cs

@@ -17,11 +17,14 @@ namespace Exercises_C_Sharp.E20_Lists
             
         }
 
-        //Schreiben Sie eine Methode, die eine Liste von Doubles bekommt. Zusätzlich soll noch ein Wert übergeben werden, der die neue Größe der Liste angibt. Nehmen Sie solange Werte aus der Liste, bis diese übergebene Anzahl erreicht ist. Streichen Sie dabei immer die kleinsten Werte heraus. Änder Sie nicht die Ordnung der übergebenen Liste:
+        //Schreiben Sie eine Methode, die eine Liste von Doubles bekommt. Zusätzlich soll noch ein Wert übergeben werden, der die neue Größe der Liste angibt. Nehmen Sie solange Werte aus der Liste, bis diese übergebene Anzahl erreicht ist. Streichen Sie dabei immer den kleinsten Werte heraus. Ändern Sie nicht die Ordnung der übergebenen Liste:
         static List<double> Meth(List<double> doubleList, int i)
         {
             /*Code START*/
 
+            while(doubleList.Count > i)
+                doubleList.Remove(doubleList.Min());
+
             return doubleList;
             /*Code ENDE*/
         }

Exercises/E20_Lists/Exercise_9.cs

@@ -20,6 +20,45 @@ namespace Exercises_C_Sharp.E20_Lists
         static void Meth(List<int> intList)
         {
             /*Code START*/
+            List<string> EinerList = ["Null", "Ein", "Zwei", "Drei", "Vier", "Fünf", "Sechs", "Sieben", "Acht", "Neun"];
+            List<string> ZehnerList = ["NULL", "Zehn", "Zwanzig", "Dreißig", "Vierzig", "Fünfzig", "Sechzig", "Siebzig", "Achtzig", "Neunzig"];
+
+            foreach(var element in intList)
+            {
+                int number = element;
+                string result = string.Empty;
+
+                if(number < 0)
+                {
+                    result = "Minus ";
+                    number = Math.Abs(number);
+                }
+                int einer = number % 10;
+                int zehner = number / 10;
+
+                if(number == 1)
+                    result += "Eins";
+                else if(number == 11)
+                    result += "Elf";
+                else if(number == 12)
+                    result += "Zwölf";
+                else if(number == 16)
+                    result += "Sechzehn";
+                else if(number == 17)
+                    result += "Siebzehn";
+                else if(number > 12 && number < 20)
+                    result += EinerList[einer] + ZehnerList[zehner].ToLower();
+                else if(zehner == 0)
+                    result += EinerList[einer];
+                else if(einer == 0)
+                    result += ZehnerList[zehner];
+                else
+                    result += EinerList[einer] + "und" + ZehnerList[zehner].ToLower();
+
+
+                Console.WriteLine(result);
+
+            }
 
             /*Code ENDE*/
         }

lastPoint

@@ -1,2 +1,2 @@
-4
-17
+8
+19