hw2_Bor

hw2/BOR/BOR.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="BorTests\**" />
+    <EmbeddedResource Remove="BorTests\**" />
+    <None Remove="BorTests\**" />
+  </ItemGroup>
+
+</Project>

hw2/BOR/BOR.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.3.32825.248
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BOR", "BOR.csproj", "{BE1A97A4-739A-4A61-BC4A-1F10DED38B17}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BorTests", "BorTests\BorTests.csproj", "{7AD0402E-2599-43F3-BB95-4B81FBE278C1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{BE1A97A4-739A-4A61-BC4A-1F10DED38B17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BE1A97A4-739A-4A61-BC4A-1F10DED38B17}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BE1A97A4-739A-4A61-BC4A-1F10DED38B17}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BE1A97A4-739A-4A61-BC4A-1F10DED38B17}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7AD0402E-2599-43F3-BB95-4B81FBE278C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7AD0402E-2599-43F3-BB95-4B81FBE278C1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7AD0402E-2599-43F3-BB95-4B81FBE278C1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7AD0402E-2599-43F3-BB95-4B81FBE278C1}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {1EBD94A4-7C68-4EE5-9F63-D26F90FFEA6E}
+	EndGlobalSection
+EndGlobal

hw2/BOR/Bor.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Transactions;
+using System.Xml.Linq;
+
+namespace Bor
+{
+    public class Bor
+    {
+        private class BorNode
+        {
+            internal Dictionary<char, BorNode> nexts = new ();
+            internal bool isTerminate { get; set; }
+            internal int WordsWithSamePrefix { get; set; }
+            public BorNode()
+            {
+                isTerminate = false;
+                WordsWithSamePrefix = 0;
+            }
+        }
+        private BorNode root;
+        public int Size { get; private set; }
+        private bool IsEmptyStringContained;
+
+        public Bor()
+        {
+            IsEmptyStringContained = false;
+            root = new BorNode();
+            Size = 0;
+        }
+        /// <summary>
+        /// Добавляет строку в дерево. возвращает true, если такой строки ещё не было, работает за O(|element|)
+        /// </summary>
+        /// <param name="element"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public bool Add (string element)
+        {
+            if (element == null)
+            {
+                throw new ArgumentNullException();
+            }
+            if (element == "")
+            {
+                if (IsEmptyStringContained) return false;
+                else
+                {
+                    IsEmptyStringContained = true;
+                    Size++;
+                    return true;
+                }
+            }
+            if (Contains(element))
+            {
+                return false;
+            }
+            var CurrentNode = root;
+            for (int i = 0; i < element.Length; i++)
+            {
+                if (!CurrentNode.nexts.ContainsKey(element[i]))
+                {
+                    CurrentNode.nexts[element[i]] = new BorNode();
+                }
+                CurrentNode.WordsWithSamePrefix++;
+                CurrentNode = CurrentNode.nexts[element[i]];
+            }
+            CurrentNode.WordsWithSamePrefix++;
+            CurrentNode.isTerminate = true;
+            Size++;
+            return true;   
+        }
+        /// <summary>
+        /// Возвращает true, если элемент содержится в дереве. работает за O(|element|)
+        /// </summary>
+        /// <param name="element"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public bool Contains(string element)
+        {
+            if (element == null)
+            {
+                throw new ArgumentNullException();
+            }
+            if (element == "")
+            {
+                return IsEmptyStringContained;
+            }
+            var CurrentNode = root;
+            for (int i = 0; i < element.Length; i++)
+            {
+                if (!CurrentNode.nexts.ContainsKey(element[i]))
+                {
+                    return false;
+                }
+                CurrentNode = CurrentNode.nexts[element[i]];
+            }
+            if (CurrentNode.isTerminate == false) return false;
+            return true;
+        }
+        /// <summary>
+        /// Удаляет элемент из дерева.возвращает true, если элемент реально был в дереве, работает за O(|element|)
+        /// </summary>
+        /// <param name="element"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public bool Remove(string element)
+        {
+            if (element == null)
+            {
+                throw new ArgumentNullException();
+            }
+            if (element == "")
+            {
+                if (!IsEmptyStringContained) return false;
+                else
+                {
+                    IsEmptyStringContained = false;
+                    return true;
+                }
+            }
+            if (!Contains(element))
+            {
+                return false;
+            }
+            var CurrentNode = root;
+            for (int i = 0; i < element.Length; i++)
+            {
+                CurrentNode = CurrentNode.nexts[element[i]];
+                CurrentNode.WordsWithSamePrefix--;
+            }
+            CurrentNode.isTerminate = false;
+            Size--;
+            return true;
+        }
+        /// <summary>
+        /// Возвращает количество строк в дереве начинающихся с этого префикса. работает за O(|prefix|). если prefix == "" бросает исключение.
+        /// </summary>
+        /// <param name="prefix"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="Exception"></exception>
+        public int HowManyStartsWithPrefix(string prefix)
+        {
+            if (prefix == null)
+            {
+                throw new ArgumentNullException();
+            }
+            if (prefix == "")
+            {
+                throw new Exception();
+            }
+            var CurrentNode = root;
+            for (int i = 0; i < prefix.Length; i++)
+            {
+                if (!CurrentNode.nexts.ContainsKey(prefix[i]))
+                {
+                    return 0;
+                }
+                CurrentNode = CurrentNode.nexts[prefix[i]];
+            }
+            return CurrentNode.WordsWithSamePrefix;
+        }
+    }
+}

hw2/BOR/BorTests/BorTests.cs

@@ -0,0 +1,87 @@
+
+namespace Bor.Tests
+{
+    public class Tests
+    {
+        [Test]
+        public void AddUncontainedStringShouldAddAndReturnTrue()
+        {
+            Bor bor = new Bor();
+            Assert.IsTrue(bor.Add("NewString"));
+            Assert.IsTrue(bor.Add("NewStr"));
+            Assert.That(bor.Size, Is.EqualTo(2));
+        }
+        [Test]
+        public void AddContainedStringShouldReturnFalse()
+        {
+            Bor bor = new Bor();
+            Assert.IsTrue(bor.Add("NewString"));
+            Assert.IsFalse(bor.Add("NewString"));
+            Assert.That(bor.Size, Is.EqualTo(1));
+        }
+        [Test]
+        public void AddEmptyString()
+        {
+            var bor = new Bor();
+            Assert.IsTrue(bor.Add(""));
+            Assert.IsFalse(bor.Add(""));
+            Assert.That(bor.Size, Is.EqualTo(1));
+        }
+        [Test]
+        public void AddNullStringShouldThrowException()
+        {
+            Bor bor = new();
+            Assert.Catch<ArgumentNullException>(() => bor.Add(null));
+        }
+        [Test]
+        public void RemoveContainedStringShouldRemoveAndReturnTrue()
+        {
+            Bor bor = new Bor();
+            bor.Add("Element");
+            Assert.IsTrue(bor.Remove("Element"));
+            Assert.That(bor.Size, Is.EqualTo(0));
+        }
+        [Test]
+        public void RemoveUncontainedStringShouldReturnFalse()
+        {
+            var bor = new Bor();
+            bor.Add("NewElement");
+            Assert.IsFalse(bor.Remove("Element"));
+        }
+        [Test]
+        public void RemoveNullStringShouldThrowException()
+        {
+            Bor bor = new();
+            Assert.Catch<ArgumentNullException>(() => bor.Remove(null));
+        }
+        [Test]
+        public void Contains()
+        {
+            var bor = new Bor();
+            bor.Add("Str101");
+            Assert.IsTrue(bor.Contains("Str101"));
+            Assert.IsFalse(bor.Contains("Str"));
+        }
+        [Test]
+        public void ContainsNullShouldThrowException()
+        {
+            var bor = new Bor();
+            Assert.Catch<ArgumentNullException>(() => bor.Contains(null));
+        }
+        [Test]
+        public void HowManyStartsWithPrefix()
+        {
+            var bor = new Bor();
+            bor.Add("1");
+            bor.Add("12");
+            bor.Add("1234");
+            bor.Add("12345");
+            Assert.That(bor.HowManyStartsWithPrefix("1"), Is.EqualTo(4));
+            Assert.That(bor.HowManyStartsWithPrefix("12"), Is.EqualTo(3));
+            Assert.That(bor.HowManyStartsWithPrefix("123"), Is.EqualTo(2));
+            Assert.That(bor.HowManyStartsWithPrefix("12345"), Is.EqualTo(1));
+            Assert.That(bor.HowManyStartsWithPrefix("00"), Is.EqualTo(0));
+        }
+
+    }
+}

hw2/BOR/BorTests/BorTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.3.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BOR.csproj" />
+  </ItemGroup>
+
+</Project>

hw2/BOR/BorTests/Usings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

hw2/BOR/Program.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Program
+{
+    public class Program
+    {
+        public static void Main()
+        {
+
+        }
+    }
+}