Change MethodLibrary from Console App to library

BasicProgramming.sln

@@ -1,24 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.5.2.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BasicProgramming", "BasicProgramming.csproj", "{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {70BA846D-5CEA-43BF-B1DC-D81A72AB1246}
-	EndGlobalSection
-EndGlobal

MethodDisplayer/MethodDisplayer.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../MethodLibrary/MethodLibrary.csproj" />
+  </ItemGroup>
+
+</Project>

MethodDisplayer/Program.cs

@@ -0,0 +1,24 @@
+using MethodLibrary;
+
+namespace MethodDisplayer
+{
+    public class Program
+    {
+        static void Main(string[] args)
+        {
+            var methodCollections = new List<IMethodCollection>
+            {
+                new Basic(),
+                new Statement(),
+                new Loops(),
+                new Strings()
+            };
+
+            foreach (var method in methodCollections)
+            {
+                Console.WriteLine($"====== {method.GetType().Name} ======");
+                method.DisplayAllMethods();
+            }
+        }
+    }
+}

MethodLibrary.sln

@@ -0,0 +1,36 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.2.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MethodLibrary", "MethodLibrary\MethodLibrary.csproj", "{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MethodLibraryTests", "MethodLibraryTests\MethodLibraryTests.csproj", "{427B1690-1D9B-4002-A6DE-435867230BAC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MethodDisplayer", "MethodDisplayer\MethodDisplayer.csproj", "{204AEF70-C8DC-4FB7-A2F6-D4BAEBBA20EB}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F852DB4D-952E-CFAF-DFC6-298FB48C8A28}.Release|Any CPU.Build.0 = Release|Any CPU
+		{427B1690-1D9B-4002-A6DE-435867230BAC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{427B1690-1D9B-4002-A6DE-435867230BAC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{427B1690-1D9B-4002-A6DE-435867230BAC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{427B1690-1D9B-4002-A6DE-435867230BAC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{204AEF70-C8DC-4FB7-A2F6-D4BAEBBA20EB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{204AEF70-C8DC-4FB7-A2F6-D4BAEBBA20EB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{204AEF70-C8DC-4FB7-A2F6-D4BAEBBA20EB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{204AEF70-C8DC-4FB7-A2F6-D4BAEBBA20EB}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {70BA846D-5CEA-43BF-B1DC-D81A72AB1246}
+	EndGlobalSection
+EndGlobal

MethodLibrary/Basic.cs

@@ -0,0 +1,65 @@
+namespace MethodLibrary
+{
+    public class Basic : IMethodCollection
+    {
+        public void DisplayAllMethods()
+        {
+            Console.WriteLine($"AddAndMultiply: {AddAndMultiply(2, 4, 5)}");
+            Console.WriteLine($"CToF(0): {CtoF(0)}");
+            Console.WriteLine($"CToF(100): {CtoF(100)}");
+            Console.WriteLine($"CToF(-300): {CtoF(-300)}");
+            Console.WriteLine($"ElementaryOperations(3, 8): {string.Join(", ", ElementaryOperations(3, 8))}");
+            Console.WriteLine($"IsResultTheSame(2+2, 2*2): {IsResultTheSame(2 + 2, 2 * 2)}");
+            Console.WriteLine($"IsResultTheSame(9/3, 16-1): {IsResultTheSame(9 / 3, 16 - 1)}");
+            Console.WriteLine($"ModuloOperations(8, 5, 2): {ModuloOperations(8, 5, 2)}");
+            Console.WriteLine($"CubeOf(2): {CubeOf(2)}");
+            Console.WriteLine($"CubeOf(-5.5): {CubeOf(-5.5)}");
+            Console.WriteLine($"SwapTwoNumbers(87, 45): {string.Join(", ", SwapTwoNumbers(87, 45))}");
+            Console.WriteLine($"SwapTwoNumbers(-13, 2): {string.Join(", ", SwapTwoNumbers(-13, 2))}");
+        }
+
+        public int AddAndMultiply(int a, int b, int c)
+        {
+            return (a + b) * c;
+        }
+
+        public string CtoF(int celcius)
+        {
+            if (celcius <= -271.15)
+                return "Temperature below absolute zero!";
+
+            double fahrenheit = (celcius * 1.8) + 32;
+
+            return $"T = {fahrenheit}F";
+        }
+
+        public List<double> ElementaryOperations(double a, double b)
+        {
+            List<double> retval = [a + b, a - b, a * b];
+            if (a > 0 && b > 0)
+                retval.Add(a / b);
+
+            return retval;
+        }
+        public bool IsResultTheSame(double a, double b)
+        {
+            return a == b;
+        }
+
+        public int ModuloOperations(int a, int b, int c)
+        {
+            return a % b % c;
+        }
+
+        public double CubeOf(double a)
+        {
+            return a * a * a;
+        }
+
+        public List<int> SwapTwoNumbers(int a, int b)
+        {
+            return [b, a];
+        }
+
+    }
+}

MethodLibrary/IMethodCollection.cs

@@ -0,0 +1,7 @@
+namespace MethodLibrary
+{
+    public interface IMethodCollection
+    {
+        public void DisplayAllMethods();
+    }
+}

MethodLibrary/Loops.cs

@@ -0,0 +1,207 @@
+using System.Text;
+using System.Text.Json;
+
+namespace MethodLibrary
+{
+    public class Loops : IMethodCollection
+    {
+        public void DisplayAllMethods()
+        {
+            Console.WriteLine($"MultiplicationTable(10, 10): {JsonSerializer.Serialize(MultiplicationTable(10, 10))}");
+            Console.WriteLine($"TheBiggestNumber([190, 291, 145, 209, 280, 200]): {TheBiggestNumber([190, 291, 145, 209, 280, 200])}");
+            Console.WriteLine($"TheBiggestNumber([-9, -2, -7, -8, -4]): {TheBiggestNumber([-9, -2, -7, -8, -4])}");
+            Console.WriteLine($"Two7sNextToEachOther([ 8, 2, 5, 7, 9, 0, 7, 7, 3, 1]): {Two7sNextToEachOther([8, 2, 5, 7, 9, 0, 7, 7, 3, 1])}");
+            Console.WriteLine($"Two7sNextToEachOther([ 9, 4, 5, 3, 7, 7, 7, 3, 2, 5, 7, 7 ]): {Two7sNextToEachOther([9, 4, 5, 3, 7, 7, 7, 3, 2, 5, 7, 7])}");
+            Console.WriteLine($"ThreeIncreasingAdjacent([45, 23, 44, 68, 65, 70, 80, 81, 82 ]): {ThreeIncreasingAdjacent([45, 23, 44, 68, 65, 70, 80, 81, 82])}");
+            Console.WriteLine($"ThreeIncreasingAdjacent([7, 3, 5, 8, 9, 3, 1, 4 ]): {ThreeIncreasingAdjacent([7, 3, 5, 8, 9, 3, 1, 4])}");
+            Console.WriteLine($"SieveOfEratosthenes(30): {JsonSerializer.Serialize(SieveOfEratosthenes(30))}");
+            Console.WriteLine($"ExtractString(\"##abc##def\"): {ExtractString("##abc##def")}");
+            Console.WriteLine($"ExtractString(\"12####78\"): {ExtractString("12####78")}");
+            Console.WriteLine($"ExtractString(\"gar##d#en\"): {ExtractString("gar##d#en")}");
+            Console.WriteLine($"ExtractString(\"++##--##++\"): {ExtractString("++##--##++")}");
+            Console.WriteLine($"FullSequenceOfLetters(\"ds\"): {FullSequenceOfLetters("ds")}");
+            Console.WriteLine($"FullSequenceOfLetters(\"or\"): {FullSequenceOfLetters("or")}");
+            Console.WriteLine($"SumAndAverage(11, 66): {SumAndAverage(11, 66)}");
+            Console.WriteLine($"SumAndAverage(-10, 0): {SumAndAverage(-10, 0)}");
+            Console.WriteLine($"DrawTriangle(10):\n{DrawTriangle(10)}");
+            Console.WriteLine($"ToThePowerOf(-2, 3): {ToThePowerOf(-2, 3)}");
+            Console.WriteLine($"ToThePowerOf(5, 5): {ToThePowerOf(5, 5)}");
+        }
+
+        public List<List<int>> MultiplicationTable(int x, int y)
+        {
+            var rows = new List<List<int>>();
+            for (int i = 0; i < y; i++)
+            {
+                var colums = new List<int>();
+
+                for (int b = 0; b < x; b++)
+                {
+                    colums.Add((i + 1) * (b + 1));
+                }
+                rows.Add(colums);
+            }
+
+            return rows;
+        }
+
+        public int TheBiggestNumber(List<int> numbers)
+        {
+            int biggestNumber = int.MinValue;
+
+            numbers.ForEach(x =>
+            {
+                if (biggestNumber < x)
+                    biggestNumber = x;
+            });
+
+            return biggestNumber;
+        }
+
+        public int Two7sNextToEachOther(List<int> numbers)
+        {
+            int count = 0;
+
+            for (int i = 0; i < (numbers.Count - 1); i++)
+            {
+                if (numbers[i] == 7 && numbers[i + 1] == 7)
+                {
+                    count++;
+                }
+            }
+
+            return count;
+        }
+
+        public bool ThreeIncreasingAdjacent(List<int> numbers)
+        {
+            for (int i = 0; i < (numbers.Count - 2); i++)
+            {
+                int currentNumber = numbers[i];
+
+                if ((numbers[i + 1] - 1).Equals(currentNumber) && (numbers[i + 2] - 2).Equals(currentNumber))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public List<int> SieveOfEratosthenes(int maxPrime)
+        {
+            List<int> primeList = new List<int>();
+
+            for (int i = 0; i < maxPrime; i++)
+            {
+                if (IsPrime(i))
+                {
+                    primeList.Add(i);
+                }
+            }
+
+            return primeList;
+        }
+
+        private bool IsPrime(int number)
+        {
+            if (number <= 1) return false;
+            if (number == 2) return true;
+            if (number % 2 == 0) return false;
+
+            var boundary = (int)Math.Floor(Math.Sqrt(number));
+
+            for (int i = 3; i <= boundary; i += 2)
+            {
+                if (number % i == 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public string ExtractString(string str)
+        {
+            if (str.Contains("##"))
+            {
+                var parts = str.Split("##");
+                if (parts.Count() > 2)
+                    return parts[1];
+            }
+
+            return string.Empty;
+        }
+
+        public string FullSequenceOfLetters(string str)
+        {
+            var retval = new StringBuilder();
+            var startLetter = str[0];
+            var endLetter = str[1];
+
+            retval.Append(startLetter);
+            char Lastchar = startLetter;
+            do
+            {
+                char nextChar = (char)((int)Lastchar + 1);
+                Lastchar = nextChar;
+                retval.Append(nextChar.ToString());
+            }
+            while (Lastchar != endLetter);
+
+            return retval.ToString();
+        }
+
+        public string SumAndAverage(int a, int b)
+        {
+            var sum = 0;
+            for (int i = a; i <= b; i++)
+            {
+                sum = sum + i;
+            }
+
+            double average = (double)sum / (b - a + 1);
+
+            return $"Sum: {sum}, Average: {average}";
+        }
+
+        public string DrawTriangle(int height)
+        {
+            var sb = new StringBuilder();
+            var layer = 0;
+
+            for (int i = 0; i < height; i++)
+            {
+                for (int y = 0; y < height - 1 - layer; y++)
+                {
+                    sb.Append(" ");
+                }
+                for (int y = 0; y < layer; y++)
+                {
+                    sb.Append("**");
+                }
+                sb.Append("*");
+                if (layer + 1 != height)
+                {
+                    sb.AppendLine();
+                }
+                layer++;
+            }
+
+            return sb.ToString();
+        }
+
+        public int ToThePowerOf(int a, int b)
+        {
+            var retval = a;
+
+            for (int i = 0; i < b - 1; i++)
+            {
+                retval = retval * a;
+            }
+
+            return retval;
+        }
+    }
+}

MethodLibrary/MethodLibrary.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
+    <OutputType>Library</OutputType>
     <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>

MethodLibrary/Statement.cs

@@ -1,25 +1,11 @@
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 
-namespace BasicProgramming
+namespace MethodLibrary
 {
-    internal class Program
+    public class Statement : IMethodCollection
     {
-        static void Main(string[] args)
+        public void DisplayAllMethods()
         {
-            Console.WriteLine("====== Basic Programming ======");
-            Console.WriteLine($"AddAndMultiply: {AddAndMultiply(2, 4, 5)}");
-            Console.WriteLine($"CToF(0): {CtoF(0)}");
-            Console.WriteLine($"CToF(100): {CtoF(100)}");
-            Console.WriteLine($"CToF(-300): {CtoF(-300)}");
-            Console.WriteLine($"ElementaryOperations(3, 8): {string.Join(", ", ElementaryOperations(3, 8))}");
-            Console.WriteLine($"IsResultTheSame(2+2, 2*2): {IsResultTheSame(2 + 2, 2 * 2)}");
-            Console.WriteLine($"IsResultTheSame(9/3, 16-1): {IsResultTheSame(9 / 3, 16 - 1)}");
-            Console.WriteLine($"ModuloOperations(8, 5, 2): {ModuloOperations(8, 5, 2)}");
-            Console.WriteLine($"CubeOf(2): {CubeOf(2)}");
-            Console.WriteLine($"CubeOf(-5.5): {CubeOf(-5.5)}");
-            Console.WriteLine($"SwapTwoNumbers(87, 45): {string.Join(", ", SwapTwoNumbers(87, 45))}");
-            Console.WriteLine($"SwapTwoNumbers(-13, 2): {string.Join(", ", SwapTwoNumbers(-13, 2))}");
-            Console.WriteLine("====== Conditional Statements ======");
             Console.WriteLine($"AbsoluteValue(6832): {AbsoluteValue(6832)}");
             Console.WriteLine($"AbsoluteValue(-392): {AbsoluteValue(-392)}");
             Console.WriteLine($"DivisibleBy2Or3(15, 30): {DivisibleBy2Or3(15, 30)}");
@@ -40,57 +26,12 @@ namespace BasicProgramming
             Console.WriteLine($"IfYearIsLeap(2016): {IfYearIsLeap(2016)}");
             Console.WriteLine($"IfYearIsLeap(2018): {IfYearIsLeap(2018)}");
         }
-
-        static int AddAndMultiply(int a, int b, int c)
-        {
-            return (a + b) * c;
-        }
-
-        static string CtoF(int celcius)
-        {
-            if (celcius <= -271.15)
-                return "Temperature below absolute zero!";
-
-            double fahrenheit = (celcius * 1.8) + 32;
-
-            return $"T = {fahrenheit}F";
-        }
-
-        static List<double> ElementaryOperations(double a, double b)
-        {
-            List<double> retval = [a + b, a - b, a * b];
-            if (a > 0 && b > 0)
-                retval.Add(a / b);
-
-            return retval;
-        }
-
-        static bool IsResultTheSame(double a, double b)
-        {
-            return a == b;
-        }
-
-        static int ModuloOperations(int a, int b, int c)
-        {
-            return (a % b) % c;
-        }
-
-        static double CubeOf(double a)
-        {
-            return a * a * a;
-        }
-
-        static List<int> SwapTwoNumbers(int a, int b)
-        {
-            return [b, a];
-        }
-
-        static int AbsoluteValue(int a)
+        public int AbsoluteValue(int a)
         {
             return Math.Abs(a);
         }
 
-        static int DivisibleBy2Or3(int a, int b)
+        public int DivisibleBy2Or3(int a, int b)
         {
             if (_DivisibleBy2Or3(a) && _DivisibleBy2Or3(b))
             {
@@ -98,7 +39,7 @@ namespace BasicProgramming
             }
 
 
-            static bool _DivisibleBy2Or3(int x)
+            bool _DivisibleBy2Or3(int x)
             {
                 return (x % 3) == 0 || (x % 2) == 0;
             }
@@ -106,12 +47,12 @@ namespace BasicProgramming
             return a + b;
         }
 
-        static bool IfConsistsOfUppercaseLetters(string str)
+        public bool IfConsistsOfUppercaseLetters(string str)
         {
             return str.Equals(Regex.Match(str, "[A-ZÆØÅ]+").Value);
         }
 
-        static bool IfGreaterThanThirdOne(List<int> ints)
+        public bool IfGreaterThanThirdOne(List<int> ints)
         {
             if (ints.Count < 3)
             {
@@ -121,12 +62,12 @@ namespace BasicProgramming
             return (ints[0] * ints[1]) > ints[2];
         }
 
-        static bool IfNumberIsEven(int a)
+        public bool IfNumberIsEven(int a)
         {
             return a % 2 == 0;
         }
 
-        static bool IfSortedAscending(List<int> ints)
+        public bool IfSortedAscending(List<int> ints)
         {
             int lastNumber = 0;
             bool retval = true;
@@ -146,7 +87,7 @@ namespace BasicProgramming
             return retval;
         }
 
-        static string PositiveNegativeOrZero(double a)
+        public string PositiveNegativeOrZero(double a)
         {
             switch (a)
             {
@@ -159,7 +100,7 @@ namespace BasicProgramming
             }
         }
 
-        static bool IfYearIsLeap(int year)
+        public bool IfYearIsLeap(int year)
         {
             return DateTime.IsLeapYear(year);
         }

MethodLibrary/Strings.cs

@@ -0,0 +1,106 @@
+using System.Text;
+using System.Text.Json;
+
+namespace MethodLibrary
+{
+    public class Strings : IMethodCollection
+    {
+        public void DisplayAllMethods()
+        {
+            Console.WriteLine($"AddSeparator(\"ABCD\", \"^\"): {AddSeparator("ABCD", "^")}");
+            Console.WriteLine($"AddSeparator(\"chocolate\", \"-\"): {AddSeparator("chocolate", "-")}");
+            Console.WriteLine($"IsPalindrome(\"eye\"): {IsPalindrome("eye")}");
+            Console.WriteLine($"IsPalindrome(\"home\"): {IsPalindrome("home")}");
+            Console.WriteLine($"LengthOfAString(\"computer\"): {LengthOfAString("computer")}");
+            Console.WriteLine($"LengthOfAString(\"ice cream\"): {LengthOfAString("ice cream")}");
+            Console.WriteLine($"StringInReverseOrder(\"qwerty\"): {StringInReverseOrder("qwerty")}");
+            Console.WriteLine($"StringInReverseOrder(\"oe93 kr\"): {StringInReverseOrder("oe93 kr")}");
+            Console.WriteLine($"NumberOfWords(\"This is sample sentence\"): {NumberOfWords("This is sample sentence")}");
+            Console.WriteLine($"NumberOfWords(\"OK\"): {NumberOfWords("OK")}");
+            Console.WriteLine($"RevertWordsOrder(\"John Doe.\"): {RevertWordsOrder("John Doe.")}");
+            Console.WriteLine($"RevertWordsOrder(\"A, B. C\"): {RevertWordsOrder("A, B. C")}");
+            Console.WriteLine($"HowManyOccurrences(\"do it now\", \"do\"): {HowManyOccurrences("do it now", "do")}");
+            Console.WriteLine($"HowManyOccurrences(\"empty\", \"d\"): {HowManyOccurrences("empty", "d")}");
+            Console.WriteLine($"SortCharactersDescending(\"onomatopoeia\"): {JsonSerializer.Serialize(SortCharactersDescending("onomatopoeia"))}");
+            Console.WriteLine($"SortCharactersDescending(\"fohjwf42os\"): {JsonSerializer.Serialize(SortCharactersDescending("fohjwf42os"))}");
+            Console.WriteLine($"CompressString(\"kkkktttrrrrrrrrrr\"): {CompressString("kkkktttrrrrrrrrrr")}");
+            Console.WriteLine($"CompressString(\"p555ppp7www\"): {CompressString("p555ppp7www")}");
+        }
+
+        public string AddSeparator(string str, string seperator)
+        {
+            return string.Join(seperator, str.ToList());
+        }
+
+        public bool IsPalindrome(string str)
+        {
+            bool isPalindrome = true;
+
+            var stringParts = str.ToList();
+
+            for (int i = 0; i < stringParts.Count - 1; i++)
+            {
+                if (!stringParts[i].Equals(stringParts[stringParts.Count - i - 1]))
+                    isPalindrome = false;
+            }
+
+            return isPalindrome;
+        }
+
+        public int LengthOfAString(string str)
+        {
+            return str.Count();
+        }
+
+        public string StringInReverseOrder(string str)
+        {
+            return string.Join("", str.Reverse());
+        }
+
+        public int NumberOfWords(string str)
+        {
+            return str.Split(" ").Count();
+        }
+
+        public string RevertWordsOrder(string str)
+        {
+            return string.Join(" ", str.Split(" ").Reverse());
+        }
+
+        public int HowManyOccurrences(string str, string strToCheck)
+        {
+            return str.Split(" ").Count(x => x.Equals(strToCheck));
+        }
+
+        public char[] SortCharactersDescending(string str)
+        {
+            return str.OrderBy(x => (char)x).Reverse().ToArray();
+        }
+
+        public string CompressString(string str)
+        {
+            StringBuilder retval = new StringBuilder();
+
+            int count = 1;
+
+            for (int i = 1; i < str.Length; i++)
+            {
+                if (str[i] == str[i - 1])
+                {
+                    count++;
+                }
+                else
+                {
+                    retval.Append(str[i - 1]);
+                    retval.Append(count);
+                    count = 1;
+                }
+            }
+
+            retval.Append(str[^1]);
+            retval.Append(count);
+            
+            return retval.ToString();
+        }
+    }
+}

MethodLibraryTests/BasicTests.cs

@@ -0,0 +1,64 @@
+using MethodLibrary;
+
+namespace BasicProgrammingTests;
+
+public class BasicTests
+{
+    private readonly Basic basic = new Basic();
+
+    [Theory]
+    [InlineData(30, 2, 4, 5)]
+    public void AddAndMultiply(int expected, int a, int b, int c)
+    {
+        Assert.Equal(expected, basic.AddAndMultiply(a, b, c));
+    }
+
+    [Theory]
+    [InlineData("T = 32F", 0)]
+    [InlineData("T = 212F", 100)]
+    [InlineData("Temperature below absolute zero!", -300)]
+    public void CToF(string expected, int input)
+    {
+        Assert.Equal(expected, basic.CtoF(input));
+    }
+
+    [Theory]
+    [InlineData(new double[] { 11.0, -5.0, 24.0, 0.375 }, 3, 8)]
+    public void ElementaryOperations(double[] expected, int a, int b)
+    {
+        var result = basic.ElementaryOperations(a, b);
+
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(true, 2 + 2, 2 * 2)]
+    [InlineData(false, 9 / 3, 16 - 1)]
+    public void IsResultTheSame(bool expected, int a, int b)
+    {
+        Assert.Equal(expected, basic.IsResultTheSame(a, b));
+    }
+
+    [Theory]
+    [InlineData(1, 8, 5, 2)]
+    public void ModuloOperations(int expected, int a, int b, int c)
+    {
+        Assert.Equal(expected, basic.ModuloOperations(a, b, c));
+    }
+
+    [Theory]
+    [InlineData(8, 2)]
+    [InlineData(-166.375, -5.5)]
+    public void CubeOf(double expected, double a)
+    {
+        Assert.Equal(expected, basic.CubeOf(a));
+    }
+
+    [Theory]
+    [InlineData(new int[] { 45, 87 }, 87, 45)]
+    [InlineData(new int[] {2, -13}, -13, 2)]
+    public void SwapTwoNumbers(int[] expected, int a, int b)
+    {
+        Assert.Equal(expected, basic.SwapTwoNumbers(a, b));
+    }
+}

MethodLibraryTests/LoopsTests.cs

@@ -0,0 +1,109 @@
+using MethodLibrary;
+
+namespace BasicProgrammingTests;
+
+public class LoopsTests
+{
+    Loops loops = new Loops();
+
+    [Fact]
+    public void MultiplicationTable()
+    {
+        var expected = new List<List<int>>
+        {
+            new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 },
+            new List<int> { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 },
+            new List<int> { 3, 6, 9, 12, 15, 18, 21, 24, 27, 30 },
+            new List<int> { 4, 8, 12, 16, 20, 24, 28, 32, 36, 40 },
+            new List<int> { 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 },
+            new List<int> { 6, 12, 18, 24, 30, 36, 42, 48, 54, 60 },
+            new List<int> { 7, 14, 21, 28, 35, 42, 49, 56, 63, 70 },
+            new List<int> { 8, 16, 24, 32, 40, 48, 56, 64, 72, 80 },
+            new List<int> { 9, 18, 27, 36, 45, 54, 63, 72, 81, 90 },
+            new List<int> { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }
+        };
+
+        Assert.Equal(expected, loops.MultiplicationTable(10, 10));
+    }
+
+    [Theory]
+    [InlineData(291, new int[] { 190, 291, 145, 209, 280, 200 })]
+    [InlineData(-2, new int[] { -9, -2, -7, -8, -4 })]
+    public void TheBiggestNumber(int expected, int[] a)
+    {
+        Assert.Equal(expected, loops.TheBiggestNumber(a.ToList()));
+    }
+
+    [Theory]
+    [InlineData(1, new int[] { 8, 2, 5, 7, 9, 0, 7, 7, 3, 1 })]
+    [InlineData(3, new int[] { 9, 4, 5, 3, 7, 7, 7, 3, 2, 5, 7, 7 })]
+    public void Two7sNextToEachOther(int expected, int[] a)
+    {
+        Assert.Equal(expected, loops.Two7sNextToEachOther(a.ToList()));
+    }
+
+    [Theory]
+    [InlineData(true, new int[] { 45, 23, 44, 68, 65, 70, 80, 81, 82 })]
+    [InlineData(false, new int[] { 7, 3, 5, 8, 9, 3, 1, 4 })]
+    public void ThreeIncreasingAdjacent(bool expected, int[] a)
+    {
+        Assert.Equal(expected, loops.ThreeIncreasingAdjacent(a.ToList()));
+    }
+
+    [Theory]
+    [InlineData(new int[] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}, 30)]
+    public void SieveOfEratosthenes(int[] expected, int a)
+    {
+        Assert.Equal(expected.ToList(), loops.SieveOfEratosthenes(a));
+    }
+
+    [Theory]
+    [InlineData("abc", "##abc##def")]
+    [InlineData("", "12####78")]
+    [InlineData("", "gar##d#en")]
+    [InlineData("--", "++##--##++")]
+    public void ExtractString(string expected, string a)
+    {
+        Assert.Equal(expected, loops.ExtractString(a));
+    }
+
+    [Theory]
+    [InlineData("defghijklmnopqrs", "ds")]
+    [InlineData("opqr", "or")]
+    public void FullSequenceOfLetters(string expected, string a)
+    {
+        Assert.Equal(expected, loops.FullSequenceOfLetters(a));
+    }
+
+    [Theory]
+    [InlineData("Sum: 2156, Average: 38,5", 11, 66)]
+    [InlineData("Sum: -55, Average: -5", -10, 0)]
+    public void SumAndAverage(string expected, int a, int b)
+    {
+        Assert.Equal(expected, loops.SumAndAverage(a, b));
+    }
+
+    [Fact]
+    public void DrawTriangle()
+    {
+        Assert.Equal(
+@"         *
+        ***
+       *****
+      *******
+     *********
+    ***********
+   *************
+  ***************
+ *****************
+*******************", loops.DrawTriangle(10));
+    }
+
+    [Theory]
+    [InlineData(-8, -2, 3)]
+    [InlineData(3125, 5, 5)]
+    public void ToThePowerOf(int expected, int a, int b)
+    {
+        Assert.Equal(expected, loops.ToThePowerOf(a, b));
+    }
+}

MethodLibraryTests/MethodLibraryTests.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../MethodLibrary/MethodLibrary.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

MethodLibraryTests/StatementTests.cs

@@ -0,0 +1,75 @@
+using MethodLibrary;
+
+namespace BasicProgrammingTests;
+
+public class StatementTests
+{
+    Statement statement = new Statement();
+
+    [Theory]
+    [InlineData(6832, 6832)]
+    [InlineData(392, -392)]
+    public void AbsoluteValue(int expected, int a)
+    {
+        Assert.Equal(expected, statement.AbsoluteValue(a));
+    }
+
+    [Theory]
+    [InlineData(450, 15, 30)]
+    [InlineData(180, 2, 90)]
+    [InlineData(19, 7, 12)]
+    public void DivisibleBy2Or3(int expected, int a, int b)
+    {
+        Assert.Equal(expected, statement.DivisibleBy2Or3(a, b));
+    }
+
+    [Theory]
+    [InlineData(false, "xyz")]
+    [InlineData(true, "DOG")]
+    [InlineData(false, "L9#")]
+    public void IfConsistsOfUppercaseLetters(bool expected, string a)
+    {
+        Assert.Equal(expected, statement.IfConsistsOfUppercaseLetters(a));
+    }
+
+    [Theory]
+    [InlineData(true, new int[] { 2, 7, 12 })]
+    [InlineData(false, new int[] {-5, -8, 50})]
+    public void IfGreaterThanThirdOne(bool expected, int[] a)
+    {
+        Assert.Equal(expected, statement.IfGreaterThanThirdOne(a.ToList()));
+    }
+
+    [Theory]
+    [InlineData(false, 721)]
+    [InlineData(true, 1248)]
+    public void IfNumberIsEven(bool expected, int a)
+    {
+        Assert.Equal(expected, statement.IfNumberIsEven(a));
+    }
+
+    [Theory]
+    [InlineData(true, new int[] { 3, 7, 10 })]
+    [InlineData(false, new int[] {74, 62, 99})]
+    public void IfSortedAscending(bool expected, int[] a)
+    {
+        Assert.Equal(expected, statement.IfSortedAscending(a.ToList()));
+    }
+
+    [Theory]
+    [InlineData("positive", 5.24)]
+    [InlineData("zero", 0)]
+    [InlineData("negative", -994.53)]
+    public void PositiveNegativeOrZero(string expected, double a)
+    {
+        Assert.Equal(expected, statement.PositiveNegativeOrZero(a));
+    }
+
+    [Theory]
+    [InlineData(true, 2016)]
+    [InlineData(false, 2018)]
+    public void IfYearIsLeap(bool expected, int a)
+    {
+        Assert.Equal(expected, statement.IfYearIsLeap(a));
+    }
+}

MethodLibraryTests/StringsTests.cs

@@ -0,0 +1,80 @@
+using MethodLibrary;
+
+namespace BasicProgrammingTests;
+
+public class StringsTests
+{
+    Strings strings = new Strings();
+
+    [Theory]
+    [InlineData("A^B^C^D", "ABCD", "^")]
+    [InlineData("c-h-o-c-o-l-a-t-e", "chocolate", "-")]
+    public void AddSeperator(string expected, string a, string b)
+    {
+        Assert.Equal(expected, strings.AddSeparator(a, b));
+    }
+
+    [Theory]
+    [InlineData(true, "eye")]
+    [InlineData(false, "home")]
+    public void IsPalindrome(bool expected, string a)
+    {
+        Assert.Equal(expected, strings.IsPalindrome(a));
+    }
+
+    [Theory]
+    [InlineData(8, "computer")]
+    [InlineData(9, "ice cream")]
+    public void LengthOfAString(int expected, string a)
+    {
+        Assert.Equal(expected, strings.LengthOfAString(a));
+    }
+
+    [Theory]
+    [InlineData("ytrewq", "qwerty")]
+    [InlineData("rk 39eo", "oe93 kr")]
+    public void StringInReverseOrder(string expected, string a)
+    {
+        Assert.Equal(expected, strings.StringInReverseOrder(a));
+    }
+
+    [Theory]
+    [InlineData(4, "This is sample sentence")]
+    [InlineData(1, "OK")]
+    public void NumberOfWords(int expected, string a)
+    {
+        Assert.Equal(expected, strings.NumberOfWords(a));
+    }
+
+    [Theory]
+    [InlineData("Doe. John", "John Doe.")]
+    [InlineData("A, B. C", "C B. A,")]
+    public void RevertWordsOrder(string expected, string a)
+    {
+        Assert.Equal(expected, strings.RevertWordsOrder(a));
+    }
+
+    [Theory]
+    [InlineData(1, "do it now", "do")]
+    [InlineData(0, "empty", "d")]
+    public void HowManyOccurrences(int expected, string a, string b)
+    {
+        Assert.Equal(expected, strings.HowManyOccurrences(a, b));
+    }
+
+    [Theory]
+    [InlineData(new char[] { 't', 'p', 'o', 'o', 'o', 'o', 'n', 'm', 'i', 'e', 'a', 'a' }, "onomatopoeia")]
+    [InlineData(new char[] { 'w', 's', 'o', 'o', 'j', 'h', 'f', 'f', '4', '2' }, "fohjwf42os")]
+    public void SortCharactersDescending(char[] expected, string a)
+    {
+        Assert.Equal(expected.ToList(), strings.SortCharactersDescending(a));
+    }
+
+    [Theory]
+    [InlineData("k4t3r10", "kkkktttrrrrrrrrrr")]
+    [InlineData("p153p371w3","p555ppp7www")]
+    public void CompressString(string expected, string a)
+    {
+        Assert.Equal(expected, strings.CompressString(a));
+    }
+}

Readme.md

@@ -0,0 +1,9 @@
+# Basic Programming
+
+Velkommen til projektet hvor jeg måske har overengineeret en smule meget.
+
+Det er et par skole opgaver, hvor man skulle skrive nogle metoder, og derefter lave unit tests.
+
+Jeg har måske kommet til at tage det skridtet videre.
+
+Der er blevet lavet en klasse til hver opgave, så Basic opgaven har klassen Basic osv. Herefter er der blevet implementeret et interface på alle klasserne som jeg kalder en Metode Collection, som sørger for at alle klasserne, har en metode som skriver alle test scenarier ud i konsollen. Dette kan listen i Program.cs bruge til at sørge for at alle Metoder bliver printet i konsolen.