CodeWars, Dog class

.github/workflows/dotnetcore.yml

@@ -8,12 +8,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        dotnet: [ '2.1', '5.0.x', '6.0.x' ]
+        dotnet: [ '7.0.x' ]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3
       with:
         dotnet-version: ${{ matrix.dotnet-version }}
         include-prerelease: true
@@ -24,4 +24,4 @@ jobs:
     - name: Run tests
       run: |
         cd CourseApp.Tests
-        dotnet test
+        dotnet test CourseApp.Tests.csproj

CourseApp.Tests/CodeWarsTests.UnitTest.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="xunit" Version="2.4.2"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="coverlet.collector" Version="3.2.0">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\CodeWarsTests\CodeWarsTests.csproj" />
+    </ItemGroup>
+
+</Project>

CourseApp.Tests/CodeWarsUnitTests/CamalCaseTest.cs

@@ -0,0 +1,13 @@
+namespace CodeWarsTests.UnitTest;
+
+using CodWearsTests;
+using Xunit;
+
+public class CamalCaseTest
+{
+    [Fact]
+    public void Test1()
+    {
+        Assert.Equal("theStealthWarrior", StrToCamelCase.ToCamelCase("the_stealth_warrior"));
+    }
+}

CourseApp.Tests/CodeWarsUnitTests/DuplicatesEncoderTest.cs

@@ -0,0 +1,43 @@
+namespace CodeWarsTests.UnitTest;
+
+using CodWearsTests;
+using Xunit;
+
+public class DuplicatesEncoderTest
+{
+    [Fact]
+    public void Test1()
+    {
+        // Act
+        var res = DuplicatesEncoder.DuplicateEncode("din");
+
+        Assert.Equal("(((", res);
+    }
+
+    [Fact]
+    public void Test2()
+    {
+        // Act
+        var res = DuplicatesEncoder.DuplicateEncode("recede");
+
+        Assert.Equal("()()()", res);
+    }
+
+    [Fact]
+    public void Test3()
+    {
+        // Act
+        var res = DuplicatesEncoder.DuplicateEncode("Success");
+
+        Assert.Equal(")())())", res);
+    }
+
+    [Fact]
+    public void Test4()
+    {
+        // Act
+        var res = DuplicatesEncoder.DuplicateEncode("(( @");
+
+        Assert.Equal("))((", res);
+    }
+}

CourseApp.Tests/CodeWarsUnitTests/FindMissingLetter.Test.cs

@@ -0,0 +1,19 @@
+namespace CodeWarsTests.UnitTest;
+
+using CodWearsTests;
+using Xunit;
+
+public class FindMissingLetter_Test
+{
+    [Fact]
+    public void Test1()
+    {
+        Assert.Equal('e', MissingLetter.FindMissingLetter(new[] { 'a', 'b', 'c', 'd', 'f' }));
+    }
+
+    [Fact]
+    public void Test2()
+    {
+        Assert.Equal('P', MissingLetter.FindMissingLetter(new[] { 'O', 'Q', 'R', 'S' }));
+    }
+}

CourseApp.Tests/CodeWarsUnitTests/Merge.Tests.cs

@@ -0,0 +1,13 @@
+namespace CodeWarsTests.UnitTest;
+
+using CodWearsTests;
+using Xunit;
+
+public class Merge_Tests
+{
+    [Fact]
+    public void Test1()
+    {
+        Assert.Equal(new string[] { "a", "1", "b", "2", "c", "3", "d", "e" }, Merge.MergeArrays(new string[] { "a", "b", "c", "d", "e" }, new string[] { "1", "2", "3" }));
+    }
+}

CourseApp.Tests/CodeWarsUnitTests/SumOfDigigts.cs

@@ -0,0 +1,9 @@
+namespace CodeWarsTests.UnitTest;
+
+public class SumOfDigigts
+{
+    public int DigitalRoot(long n)
+    {
+        return 0;
+    }
+}

CourseApp.Tests/CodeWarsUnitTests/TowerTest.cs

@@ -0,0 +1,27 @@
+namespace CodeWarsTests.UnitTest;
+
+using CodWearsTests;
+using Xunit;
+
+public class TowerTest
+{
+    [Fact]
+    public void Test1()
+    {
+        Assert.Equal(string.Join(",", new[] { "*" }), string.Join(",", Towerbuild.TowerBuilder(1)));
+    }
+
+    [Fact]
+    public void Test2()
+    {
+        Assert.Equal(string.Join(",", new[] { " * ", "***" }), string.Join(",", Towerbuild.TowerBuilder(2)));
+    }
+
+    [Fact]
+    public void Test3()
+    {
+        Assert.Equal(
+            string.Join(",", new[] { "  *  ", " *** ", "*****" }),
+            string.Join(",", Towerbuild.TowerBuilder(3)));
+    }
+}

CourseApp.Tests/CourseApp.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -29,4 +29,5 @@
     <AdditionalFiles Include="../_stylecop/stylecop.json" />
   </ItemGroup>
 
+
 </Project>

CourseApp/CodeWars/DigitalRootClass.cs

@@ -0,0 +1,9 @@
+namespace CodWearsTests;
+
+public class DigitalRootClass
+{
+    public static int DigitalRoot(long n)
+    {
+        return 0;
+    }
+}

CourseApp/CodeWars/DuplicatesEncoder.cs

@@ -0,0 +1,19 @@
+namespace CodWearsTests;
+
+using System.Linq;
+using System.Collections.Generic;
+
+public class DuplicatesEncoder
+{
+    public static string DuplicateEncode(string word)
+    {
+        var mass = new List<string>();
+        word = word.ToLower();
+        foreach (var sym in word)
+        {
+            mass.Add(word.Count(x => x == sym) != 1 ? ")" : "(");
+        }
+
+        return string.Join(string.Empty, mass);
+    }
+}

CourseApp/CodeWars/FibNums.cs

@@ -0,0 +1,19 @@
+namespace CodWearsTests;
+
+public class FibNums
+{
+    public static ulong[] ProductFib(ulong prod)
+    {
+        ulong a = 0;
+        ulong b = 1;
+
+        while (a * b < prod)
+        {
+            ulong temp = a;
+            a = b;
+            b = temp + b;
+        }
+
+        return new ulong[] { a, b, (ulong)(a * b == prod ? 1 : 0) };
+    }
+}

CourseApp/CodeWars/Merge.cs

@@ -0,0 +1,37 @@
+namespace CodWearsTests;
+
+using System.Collections.Generic;
+
+public class Merge
+{
+    public static string[] MergeArrays(string[] arr1, string[] arr2)
+    {
+        var res = new List<string>();
+        var length = arr1.Length > arr2.Length ? arr2.Length : arr1.Length;
+        var index = 0;
+
+        while (index < length)
+        {
+            res.Add(arr1[index]);
+            res.Add(arr2[index]);
+            index++;
+        }
+
+        if (arr1.Length > arr2.Length)
+        {
+            for (; index < arr1.Length; index++)
+            {
+                res.Add(arr1[index]);
+            }
+        }
+        else
+        {
+            for (; index < arr2.Length; index++)
+            {
+                res.Add(arr2[index]);
+            }
+        }
+
+        return res.ToArray();
+    }
+}

CourseApp/CodeWars/MissingLetter.cs

@@ -0,0 +1,24 @@
+namespace CodWearsTests;
+
+public class MissingLetter
+{
+    public static char FindMissingLetter(char[] chars)
+    {
+        var alphabet = "abcdefghijklmnopqrstuvwxyz";
+        chars.ToString();
+
+        if (char.IsUpper(chars[0]))
+        {
+            alphabet = alphabet.ToUpper();
+        }
+
+        var index = alphabet.IndexOf(chars[0]);
+
+        for (int i = 0; chars[i] == alphabet[index]; i++)
+        {
+            index++;
+        }
+
+        return alphabet[index];
+    }
+}

CourseApp/CodeWars/StrToCamelCase.cs

@@ -0,0 +1,25 @@
+namespace CodWearsTests;
+
+public class StrToCamelCase
+{
+    public static string ToCamelCase(string str)
+    {
+        var res = string.Empty;
+
+        str.ToCharArray();
+        for (int i = 0; i < str.Length; i++)
+        {
+            if (str[i] != '_' && str[i] != '-')
+            {
+                res += str[i].ToString();
+            }
+            else
+            {
+                res += str[i + 1].ToString().ToUpper();
+                i += 1;
+            }
+        }
+
+        return res;
+    }
+}

CourseApp/CodeWars/TicTakToe.cs

@@ -0,0 +1,36 @@
+namespace CodWearsTests;
+
+public class TicTacToe
+{
+    public int IsSolved(int[,] board)
+    {
+        for (int i = 0; i < 2; i++)
+        {
+            if (board[i, 0] == board[i, 1] && (board[i, 1] == board[i, 2]) && board[i, 1] != 0)
+            {
+                return board[i, 0];
+            }
+            else if (board[0, i] == board[1, i] && board[1, i] == board[2, i] && board[1, i] != 0)
+            {
+                return board[i, 0];
+            }
+            else if ((board[0, 0] == board[1, 1] && board[1, 1] == board[2, 2] && board[1, 1] != 0) ||
+                     (board[2, 0] == board[1, 1] && board[1, 1] == board[0, 2] && board[1, 1] != 0))
+            {
+                return board[1, 1];
+            }
+            else
+            {
+                for (int k = 0; k < 2; k++)
+                {
+                    if (board[i, k] == 0)
+                    {
+                        return -1;
+                    }
+                }
+            }
+        }
+
+        return 0;
+    }
+}