From 0628989d8290630e4d6f42cf483cbf9c6cb5008a Mon Sep 17 00:00:00 2001 From: Artem Date: Sat, 4 Mar 2023 16:59:32 +0300 Subject: [PATCH 01/10] +Stack --- stackCalculator/stackCalculator.sln | 25 +++++ stackCalculator/stackCalculator/Program.cs | 106 ++++++++++++++++++ .../stackCalculator/stackCalculator.csproj | 10 ++ 3 files changed, 141 insertions(+) create mode 100644 stackCalculator/stackCalculator.sln create mode 100644 stackCalculator/stackCalculator/Program.cs create mode 100644 stackCalculator/stackCalculator/stackCalculator.csproj diff --git a/stackCalculator/stackCalculator.sln b/stackCalculator/stackCalculator.sln new file mode 100644 index 0000000..304decd --- /dev/null +++ b/stackCalculator/stackCalculator.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33403.182 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "stackCalculator", "stackCalculator\stackCalculator.csproj", "{89A2482C-4A20-41A4-9A42-1623A4FA88C3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {89A2482C-4A20-41A4-9A42-1623A4FA88C3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {89A2482C-4A20-41A4-9A42-1623A4FA88C3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {89A2482C-4A20-41A4-9A42-1623A4FA88C3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {89A2482C-4A20-41A4-9A42-1623A4FA88C3}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {E6D50142-7CF4-466F-9F0D-9262A98C0B2C} + EndGlobalSection +EndGlobal diff --git a/stackCalculator/stackCalculator/Program.cs b/stackCalculator/stackCalculator/Program.cs new file mode 100644 index 0000000..fef1ea0 --- /dev/null +++ b/stackCalculator/stackCalculator/Program.cs @@ -0,0 +1,106 @@ +namespace Sort; + +using System; + +interface OperationsWithElementsStruct +{ + // Add element to struct + void AddElement(char value); + + // Remove element in struct and return deleted item + void RemoveElement(ref char item); + + // Print all elements + void PrintTheElements(); +} + +public class Stack : OperationsWithElementsStruct +{ + public Stack() + { + Head = null; + } + private StackElement Head; + + public void AddElement(char value) + { + StackElement item = new StackElement(value); + if (Head == null) + { + Head = item; + } + else + { + StackElement copy = Head; + Head = item; + Head.Next= copy; + } + } + + public void RemoveElement(ref char item) + { + if (Head == null) + { + return; + } + item = Head.Value; + StackElement copy = Head.Next; + Head = null; + Head = copy; + } + + public void PrintTheElements() + { + StackElement walker = Head; + while (walker != null) + { + Console.WriteLine(walker.Value); + walker = walker.Next; + } + } + + private class StackElement + { + public StackElement(char value) + { + Value = value; + Next = null; + } + public char Value { get; set; } + public StackElement Next { get; set; } + } +} + +public class StackCalculator +{ + // Receives the input string in which the expression is written in postfix form, finds the result + public int ConvertToAResponse(string stringWithExpression) + { + + return 0; + } +} + +public class Test +{ + // Test the program + public bool TestForProgram() + { + return true; + } +} + +class Program +{ + public void Main(string[] args) + { + Console.WriteLine("Enter an example in the postfix form"); + var stringWithExpression = Console.ReadLine(); + StackCalculator calculator = new StackCalculator(); + if (stringWithExpression == null) + { + return; + } + int result = calculator.ConvertToAResponse(stringWithExpression); + } +} diff --git a/stackCalculator/stackCalculator/stackCalculator.csproj b/stackCalculator/stackCalculator/stackCalculator.csproj new file mode 100644 index 0000000..f02677b --- /dev/null +++ b/stackCalculator/stackCalculator/stackCalculator.csproj @@ -0,0 +1,10 @@ + + + + Exe + net7.0 + enable + enable + + + From 52b35a68b5f1e32077e48d035318338e920eb48b Mon Sep 17 00:00:00 2001 From: Palezehvat <114094069+Palezehvat@users.noreply.github.com> Date: Sat, 4 Mar 2023 17:01:26 +0300 Subject: [PATCH 02/10] Delete BWT directory --- BWT/BWT.sln | 25 ------ BWT/BWT/BWT.csproj | 10 --- BWT/BWT/Program.cs | 208 --------------------------------------------- 3 files changed, 243 deletions(-) delete mode 100644 BWT/BWT.sln delete mode 100644 BWT/BWT/BWT.csproj delete mode 100644 BWT/BWT/Program.cs diff --git a/BWT/BWT.sln b/BWT/BWT.sln deleted file mode 100644 index db64427..0000000 --- a/BWT/BWT.sln +++ /dev/null @@ -1,25 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.4.33403.182 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BWT", "BWT\BWT.csproj", "{97F74F11-2F27-4B42-A5B1-8D88573DFB01}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {97F74F11-2F27-4B42-A5B1-8D88573DFB01}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {97F74F11-2F27-4B42-A5B1-8D88573DFB01}.Debug|Any CPU.Build.0 = Debug|Any CPU - {97F74F11-2F27-4B42-A5B1-8D88573DFB01}.Release|Any CPU.ActiveCfg = Release|Any CPU - {97F74F11-2F27-4B42-A5B1-8D88573DFB01}.Release|Any CPU.Build.0 = Release|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {65A6BC48-3287-4942-BACC-A033A3982A41} - EndGlobalSection -EndGlobal diff --git a/BWT/BWT/BWT.csproj b/BWT/BWT/BWT.csproj deleted file mode 100644 index f02677b..0000000 --- a/BWT/BWT/BWT.csproj +++ /dev/null @@ -1,10 +0,0 @@ - - - - Exe - net7.0 - enable - enable - - - diff --git a/BWT/BWT/Program.cs b/BWT/BWT/Program.cs deleted file mode 100644 index 11af52d..0000000 --- a/BWT/BWT/Program.cs +++ /dev/null @@ -1,208 +0,0 @@ -namespace Sort; - -using System; -using System.Text; - -enum WhichStringIsBigger -{ - First, - Second, - Same, - Error -} -class Program -{ - public const int NumberOfCharacters = 65536; - - // A method of comparing two rows using indexes indicating their beginning - public static WhichStringIsBigger CompareStrings(string stringToBWT, int positionFirst, int positionSecond) - { - int cyclicalFirstStringPosition = positionFirst; - int cyclicalSecondStringPosition = positionSecond; - int comparedSymbolsCount = 0; - while (comparedSymbolsCount < stringToBWT.Length) - { - if (stringToBWT[cyclicalFirstStringPosition % stringToBWT.Length] > stringToBWT[cyclicalSecondStringPosition % stringToBWT.Length]) - { - return WhichStringIsBigger.First; - } - else if (stringToBWT[cyclicalFirstStringPosition % stringToBWT.Length] < stringToBWT[cyclicalSecondStringPosition % stringToBWT.Length]) - { - return WhichStringIsBigger.Second; - } - - ++cyclicalFirstStringPosition; - ++cyclicalSecondStringPosition; - ++comparedSymbolsCount; - } - return WhichStringIsBigger.Same; - } - - // Sorting by inserts - public static void InsertSort(string stringToBWT, int[] arrayPositions, int startArray, int endArray) - { - for (int i = startArray + 1; i <= endArray; ++i) - { - int j = i; - while (j >= startArray + 1 && CompareStrings(stringToBWT, (arrayPositions[j - 1] + 1) % arrayPositions.Length, - (arrayPositions[j] + 1) % arrayPositions.Length) == WhichStringIsBigger.First) - { - (arrayPositions[j - 1], arrayPositions[j]) = (arrayPositions[j], arrayPositions[j - 1]); - - --j; - } - } - } - - // Finding a reference element - public static int Partition(string stringToBWT, int[] arrayPositions, int startArray, int endArray) - { - int pivot = arrayPositions[endArray]; - int i = startArray; - - for (int j = startArray; j < endArray; ++j) - { - WhichStringIsBigger result = CompareStrings(stringToBWT, (arrayPositions[j] + 1) % arrayPositions.Length, (pivot + 1) % arrayPositions.Length); - if (result == WhichStringIsBigger.Second || result == WhichStringIsBigger.Same) - { - (arrayPositions[j], arrayPositions[i]) = (arrayPositions[i], arrayPositions[j]); - - ++i; - } - } - (arrayPositions[i], arrayPositions[endArray]) = (arrayPositions[endArray], arrayPositions[i]); - return i; - } - - // Quick sort, which sorts an array of indexes by comparing rows obtained by cyclic permutations - public static void QSort(string stringToBWT, int[] arrayPositions, int startArray, int endArray) - { - if (endArray - startArray + 1 <= 10) - { - InsertSort(stringToBWT, arrayPositions,startArray, endArray); - return; - } - if (startArray < endArray) - { - int positionElement = Partition(stringToBWT, arrayPositions, startArray, endArray); - QSort(stringToBWT, arrayPositions, startArray, positionElement - 1); - QSort(stringToBWT, arrayPositions, positionElement + 1, endArray); - } - } - - // Shell for running quick sort - public static void QuickSort(string stringToBWT, int[] arrayPositions) - { - QSort(stringToBWT, arrayPositions, 0, arrayPositions.Length - 1); - } - - // String compression by the Burrows-Wheeler algorithm - public static (string result, int firstPosition) BwtConvert(string stringToBWT) - { - var arrayPositions = new int[stringToBWT.Length]; - for (int i = 0; i < stringToBWT.Length; ++i) - { - arrayPositions[i] = i; - } - - QuickSort(stringToBWT, arrayPositions); - - var stringAfterBWT = new StringBuilder(stringToBWT); - for (int i = 0; i < stringToBWT.Length; ++i) - { - stringAfterBWT[i] = stringToBWT[arrayPositions[i]]; - } - - int firstPosition = 0; - for (int i = 0; i < stringToBWT.Length; ++i) - { - if (arrayPositions[i] == stringToBWT.Length - 1) - { - firstPosition = i; - return (stringAfterBWT.ToString(), firstPosition); - } - } - return (stringAfterBWT.ToString(), firstPosition); - } - - // The function receives a string after the Burrows-Wheeler algorithm as input, returns a string before the Burrows-Wheeler algorithm - public static string BWTReverseСonvert(string stringAfterBWT, int firstPosition) - { - var arraySymbols = new int[NumberOfCharacters]; - var arrayPreCalculationTable = new int[stringAfterBWT.Length]; - - for (int i = 0; i < stringAfterBWT.Length; ++i) - { - ++arraySymbols[stringAfterBWT[i]]; - } - - int summary = 0; - for (int i = 0; i < NumberOfCharacters; i++) - { - summary = summary + arraySymbols[i]; - arraySymbols[i] = summary - arraySymbols[i]; - } - - for (int i = 0; i < stringAfterBWT.Length; ++i) - { - int j = i - 1; - while (j >= 0) - { - if (stringAfterBWT[i] == stringAfterBWT[j]) - { - arrayPreCalculationTable[i]++; - } - --j; - } - } - var stringBeforeBWT = new StringBuilder(stringAfterBWT); - int positionForNewChar = stringBeforeBWT.Length - 1; - stringBeforeBWT[positionForNewChar] = stringAfterBWT[firstPosition]; - --positionForNewChar; - int sum = arrayPreCalculationTable[firstPosition] + arraySymbols[stringAfterBWT[firstPosition]]; - while (positionForNewChar >= 0) - { - stringBeforeBWT[positionForNewChar] = stringAfterBWT[sum]; - sum = arrayPreCalculationTable[sum] + arraySymbols[stringAfterBWT[sum]]; - --positionForNewChar; - } - return stringBeforeBWT.ToString(); - } - - // Checking compression and unzipping by the Burrows-Wheeler algorithm - public static bool TestBWT() - { - string stringToTest = "ABACABA"; - (var stringAfterBWT, var firstPosition) = BwtConvert(stringToTest); - if (stringAfterBWT != "BCABAAA") - { - return false; - } - return BWTReverseСonvert(stringAfterBWT, firstPosition) == "ABACABA"; - } - - public static void Main(string[] args) - { - if (TestBWT()) - { - Console.WriteLine("All tests correct"); - } - else - { - Console.WriteLine("Some problems with tests..."); - return; - } - Console.WriteLine("Input string"); - var stringToBWT = Console.ReadLine(); - if (stringToBWT == null) - { - Console.WriteLine("You input null string or your input is not correct"); - return; - } - (var returnedStringFromBWT, var firstPosition) = BwtConvert(stringToBWT); - Console.WriteLine("String after BWT"); - Console.WriteLine(returnedStringFromBWT); - var stringBeforeBWT = BWTReverseСonvert(returnedStringFromBWT, firstPosition); - Console.WriteLine(stringBeforeBWT); - } -} \ No newline at end of file From 077d2515aebbac7db639e280c3c177ea6ede5949 Mon Sep 17 00:00:00 2001 From: Artem Date: Wed, 8 Mar 2023 21:04:05 +0300 Subject: [PATCH 03/10] =?UTF-8?q?+=D0=A2=D0=B5=D1=81=D1=82=D1=8B=20+=D0=B4?= =?UTF-8?q?=D0=B5=D0=BB=D1=8C=D1=82=D0=B0=20+2=20=D1=80=D0=B5=D0=B0=D0=BB?= =?UTF-8?q?=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D1=8F=20=D1=81=D1=82=D0=B5=D0=BA?= =?UTF-8?q?=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- stackCalculator/stackCalculator/Program.cs | 187 +++++++++++++++++++-- 1 file changed, 170 insertions(+), 17 deletions(-) diff --git a/stackCalculator/stackCalculator/Program.cs b/stackCalculator/stackCalculator/Program.cs index fef1ea0..d98c130 100644 --- a/stackCalculator/stackCalculator/Program.cs +++ b/stackCalculator/stackCalculator/Program.cs @@ -5,24 +5,83 @@ interface OperationsWithElementsStruct { // Add element to struct - void AddElement(char value); + void AddElement(double value); // Remove element in struct and return deleted item - void RemoveElement(ref char item); + (bool, double) RemoveElement(); // Print all elements void PrintTheElements(); + + // Checking that the structure is empty + bool IsEmpty(); } -public class Stack : OperationsWithElementsStruct +public class StackWithArray : OperationsWithElementsStruct { - public Stack() + private double[] stackArray; + private int numberOfElements; + private int sizeStack = 10; + + public StackWithArray() + { + stackArray = new double[sizeStack]; + } + + public bool ChangeStackSize(int size) + { + if (size < sizeStack) + { + return false; + } + Array.Resize(ref stackArray, size); + return true; + } + + public void AddElement(double value) + { + if (numberOfElements == sizeStack) + { + ChangeStackSize(sizeStack + sizeStack); + } + stackArray[numberOfElements] = value; + ++numberOfElements; + } + + public (bool, double) RemoveElement() + { + if (numberOfElements == 0) + { + return (false, 0); + } + double result = stackArray[numberOfElements - 1]; + --numberOfElements; + return (true, result); + } + + public void PrintTheElements() + { + for(int i = 0; i < numberOfElements; i++) + { + Console.WriteLine(stackArray[i]); + } + } + + public bool IsEmpty() + { + return numberOfElements == 0; + } +} + +public class StackList : OperationsWithElementsStruct +{ + public StackList() { Head = null; } private StackElement Head; - public void AddElement(char value) + public void AddElement(double value) { StackElement item = new StackElement(value); if (Head == null) @@ -37,16 +96,16 @@ public void AddElement(char value) } } - public void RemoveElement(ref char item) + public (bool, double) RemoveElement() { if (Head == null) { - return; + return(false, 0); } - item = Head.Value; + double item = Head.Value; StackElement copy = Head.Next; - Head = null; Head = copy; + return (true, item); } public void PrintTheElements() @@ -59,41 +118,129 @@ public void PrintTheElements() } } + public bool IsEmpty() + { + return Head == null; + } + private class StackElement { - public StackElement(char value) + public StackElement(double value) { Value = value; Next = null; } - public char Value { get; set; } + public double Value { get; set; } public StackElement Next { get; set; } } } public class StackCalculator { + private double delta = 0.0000000000001; // Receives the input string in which the expression is written in postfix form, finds the result - public int ConvertToAResponse(string stringWithExpression) + public (bool, double) ConvertToAResponse(string stringWithExpression) { + StackList stackExpression = new StackList(); + int i = 0; + while (i < stringWithExpression.Length) + { + if ((stringWithExpression[i] == '-' && i != stringWithExpression.Length - 1 && stringWithExpression[i + 1] != ' ') || (stringWithExpression[i] >= '0' && stringWithExpression[i] <= '9')) + { + bool isNeedMinus = stringWithExpression[i] == '-'; + if (isNeedMinus) + { + ++i; + } + int multiplier = 10; + int number = 0; + while (i < stringWithExpression.Length && stringWithExpression[i] >= '0' && stringWithExpression[i] <= '9') + { + number += stringWithExpression[i] - '0'; + number *= multiplier; + ++i; + } + number /= 10; + --i; + if (isNeedMinus) + { + number *= -1; + } + stackExpression.AddElement(number); + } + else if (stringWithExpression[i] != ' ') + { + double numberAfter = 0; + (var isCorrect, var firstNumber) = stackExpression.RemoveElement(); + (isCorrect, var secondNumber) = stackExpression.RemoveElement(); + + if (!isCorrect) + { + return (false, 0); + } - return 0; + switch (stringWithExpression[i]) + { + case '*': + numberAfter = firstNumber * secondNumber; + break; + case '+': + numberAfter = firstNumber + secondNumber; + break; + case '-': + numberAfter = secondNumber - firstNumber; + break; + case '/': + if (Math.Abs(firstNumber) < delta) + { + return (false, 0); + } + numberAfter = secondNumber / firstNumber; + break; + } + stackExpression.AddElement(numberAfter); + } + ++i; + } + (var isCorrectExpression, var result) = stackExpression.RemoveElement(); + if (!isCorrectExpression) + { + return (false, 0); + } + return true == stackExpression.IsEmpty() ? (true, result) : (false, 0); } } public class Test { - // Test the program + // Tests the program public bool TestForProgram() { - return true; + StackCalculator calculator = new StackCalculator(); + (var isCorrectWork, var result) = calculator.ConvertToAResponse("123 23 +"); + if (!isCorrectWork || result != 146) + { + return false; + } + (isCorrectWork, result) = calculator.ConvertToAResponse("123 23"); + return !isCorrectWork; } } class Program { - public void Main(string[] args) + public static void Main(string[] args) { + Test test = new Test(); + if (test.TestForProgram()) + { + Console.WriteLine("All tests correct"); + } + else + { + Console.WriteLine("Problems..."); + return; + } Console.WriteLine("Enter an example in the postfix form"); var stringWithExpression = Console.ReadLine(); StackCalculator calculator = new StackCalculator(); @@ -101,6 +248,12 @@ public void Main(string[] args) { return; } - int result = calculator.ConvertToAResponse(stringWithExpression); + (var isCorrectWork, var result) = calculator.ConvertToAResponse(stringWithExpression); + if (!isCorrectWork) + { + Console.WriteLine("Problems with expression or you tried to divide by zero"); + return; + } + Console.WriteLine(result); } } From 7c32bd2d889bfaea7df8f886e76511df8ec68eeb Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 10 Mar 2023 22:20:51 +0300 Subject: [PATCH 04/10] =?UTF-8?q?=D0=A0=D0=B0=D0=B7=D0=B1=D0=B8=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BD=D0=B0=20=D1=84=D0=B0=D0=B9=D0=BB?= =?UTF-8?q?=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../stackCalculator/InterfaceForStack.cs | 16 +++++ stackCalculator/stackCalculator/Stack.cs | 4 ++ .../stackCalculator/StackCalculator.cs | 71 +++++++++++++++++++ .../stackCalculator/StackWithList.cs | 58 +++++++++++++++ stackCalculator/stackCalculator/Tests.cs | 17 +++++ 5 files changed, 166 insertions(+) create mode 100644 stackCalculator/stackCalculator/InterfaceForStack.cs create mode 100644 stackCalculator/stackCalculator/Stack.cs create mode 100644 stackCalculator/stackCalculator/StackCalculator.cs create mode 100644 stackCalculator/stackCalculator/StackWithList.cs create mode 100644 stackCalculator/stackCalculator/Tests.cs diff --git a/stackCalculator/stackCalculator/InterfaceForStack.cs b/stackCalculator/stackCalculator/InterfaceForStack.cs new file mode 100644 index 0000000..2e4e88c --- /dev/null +++ b/stackCalculator/stackCalculator/InterfaceForStack.cs @@ -0,0 +1,16 @@ +namespace StackCalculator; + + interface IOperationsWithStack + { + // Add element to stack + void AddElement(double value); + + // Remove element in stack and return deleted item + (bool, double) RemoveElement(); + + // Print all elements + void PrintTheElements(); + + // Checking that the stack is empty + bool IsEmpty(); +} \ No newline at end of file diff --git a/stackCalculator/stackCalculator/Stack.cs b/stackCalculator/stackCalculator/Stack.cs new file mode 100644 index 0000000..45016c6 --- /dev/null +++ b/stackCalculator/stackCalculator/Stack.cs @@ -0,0 +1,4 @@ +namespace StackCalculator; + +//Standart stack +public class Stack : StackList{} \ No newline at end of file diff --git a/stackCalculator/stackCalculator/StackCalculator.cs b/stackCalculator/stackCalculator/StackCalculator.cs new file mode 100644 index 0000000..8dc99d7 --- /dev/null +++ b/stackCalculator/stackCalculator/StackCalculator.cs @@ -0,0 +1,71 @@ +namespace StackCalculator; + +public class StackCalculator +{ + private double delta = 0.0000000000001; + + // Receives the input string in which the expression is written in postfix form, finds the result + public (bool, double) ConvertToAResponse(string stringWithExpression) + { + Stack stackExpression = new(); + int i = 0; + string[] expressionArray = stringWithExpression.Split(' '); + while (i < expressionArray.Length) + { + var isCorrectNumber = Int32.TryParse(expressionArray[i], out var number); + if (isCorrectNumber) + { + stackExpression.AddElement(number); + } + else + { + if (expressionArray[i].Length != 1) + { + return (false, 0); + } + double numberAfter = 0; + (var isCorrect, var firstNumber) = stackExpression.RemoveElement(); + + if (!isCorrect) + { + return (false, 0); + } + + (isCorrect, var secondNumber) = stackExpression.RemoveElement(); + + if (!isCorrect) + { + return (false, 0); + } + + switch (expressionArray[i][0]) + { + case '*': + numberAfter = firstNumber * secondNumber; + break; + case '+': + numberAfter = firstNumber + secondNumber; + break; + case '-': + numberAfter = secondNumber - firstNumber; + break; + case '/': + if (Math.Abs(firstNumber) < delta) + { + return (false, 0); + } + numberAfter = secondNumber / firstNumber; + break; + } + stackExpression.AddElement(numberAfter); + } + ++i; + } + (var isCorrectExpression, var result) = stackExpression.RemoveElement(); + if (!isCorrectExpression) + { + return (false, 0); + } + return stackExpression.IsEmpty() ? (true, result) : (false, 0); + } +} diff --git a/stackCalculator/stackCalculator/StackWithList.cs b/stackCalculator/stackCalculator/StackWithList.cs new file mode 100644 index 0000000..9d09748 --- /dev/null +++ b/stackCalculator/stackCalculator/StackWithList.cs @@ -0,0 +1,58 @@ +namespace StackCalculator; + +// Stack implemented on list +public class StackList : IOperationsWithStack +{ + private StackElement headStack; + + public void AddElement(double value) + { + var item = new StackElement(value); + if (headStack == null) + { + headStack = item; + } + else + { + StackElement copy = headStack; + headStack = item; + headStack.next = copy; + } + } + + public (bool, double) RemoveElement() + { + if (headStack == null) + { + return (false, 0); + } + double item = headStack.valueStack; + StackElement copy = headStack.next; + headStack = copy; + return (true, item); + } + + public void PrintTheElements() + { + StackElement walker = headStack; + while (walker != null) + { + Console.WriteLine(walker.valueStack); + walker = walker.next; + } + } + + public bool IsEmpty() => headStack == null; + + private class StackElement + { + public StackElement(double value) + { + valueStack = value; + next = null; + } + + public double valueStack { get; set; } + public StackElement next { get; set; } + } +} \ No newline at end of file diff --git a/stackCalculator/stackCalculator/Tests.cs b/stackCalculator/stackCalculator/Tests.cs new file mode 100644 index 0000000..47d7fc7 --- /dev/null +++ b/stackCalculator/stackCalculator/Tests.cs @@ -0,0 +1,17 @@ +namespace StackCalculator; + +public class Test +{ + // Tests the program + public bool TestForProgram() + { + StackCalculator calculator = new StackCalculator(); + (var isCorrectWork, var result) = calculator.ConvertToAResponse("123 23 +"); + if (!isCorrectWork || result != 146) + { + return false; + } + (isCorrectWork, result) = calculator.ConvertToAResponse("123 23"); + return !isCorrectWork; + } +} From 5ebf52ef9b26eb6dccd4b8ceb7e4764b7b651e4a Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 10 Mar 2023 22:27:12 +0300 Subject: [PATCH 05/10] =?UTF-8?q?=D0=9F=D0=BE=D1=87=D0=B5=D0=BC=D1=83-?= =?UTF-8?q?=D1=82=D0=BE=20=D1=85=D0=BE=D1=82=D1=8C,=20=D1=8F=20=D0=B8=20?= =?UTF-8?q?=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B8=D0=BB=20=D0=BD=D0=B0=D0=B7?= =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F,=20=D1=81=D0=B4=D0=B5=D0=BB?= =?UTF-8?q?=D0=B0=D0=B2=20=D0=B8=D1=85=20=D1=81=20=D0=B1=D0=BE=D0=BB=D1=8C?= =?UTF-8?q?=D1=88=D0=BE=D0=B9=20=D0=B1=D1=83=D0=BA=D0=B2=D1=8B,=20=D0=B7?= =?UTF-8?q?=D0=B4=D0=B5=D1=81=D1=8C=20=D0=BE=D0=BD=D0=B8=20=D0=B8=D0=B4?= =?UTF-8?q?=D1=83=D1=82=20=D0=BE=D1=82=D0=B4=D0=B5=D0=BB=D1=8C=D0=BD=D0=BE?= =?UTF-8?q?=20=D1=81=20=D0=BC=D0=B0=D0=BB=D0=B5=D0=BD=D1=8C=D0=BA=D0=BE?= =?UTF-8?q?=D0=B9,=20=D0=BF=D1=80=D0=B8=20=D1=8D=D1=82=D0=BE=D0=BC=20?= =?UTF-8?q?=D0=B2=20=D0=BA=D0=B0=D1=82=D0=B0=D0=BB=D0=BE=D0=B3=D0=B5=20?= =?UTF-8?q?=D0=BE=D1=82=D0=BE=D0=B1=D1=80=D0=B0=D0=B6=D0=B0=D1=8E=D1=82?= =?UTF-8?q?=D1=81=D1=8F=20=D1=81=20=D0=B1=D0=BE=D0=BB=D1=8C=D1=88=D0=BE?= =?UTF-8?q?=D0=B9,=20=D0=B0=20=D0=BF=D1=80=D0=B8=20=D0=B4=D0=BE=D0=B1?= =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD=D0=B8=D0=B8=20=D1=81=20=D0=B1?= =?UTF-8?q?=D0=BE=D0=BB=D1=8C=D1=88=D0=BE=D0=B9=20git=20status=20=D0=B8?= =?UTF-8?q?=D1=85=20=D0=BD=D0=B5=20=D0=B2=D1=8B=D0=B4=D0=B5=D0=BB=D1=8F?= =?UTF-8?q?=D0=B5=D1=82,=20=D0=BF=D0=BE=D1=8D=D1=82=D0=BE=D0=BC=D1=83=20?= =?UTF-8?q?=D1=8D=D1=82=D0=BE=D1=82=20=D0=BA=D0=BE=D0=BC=D0=B8=D1=82=20?= =?UTF-8?q?=D0=B8=D1=85=20=D0=BE=D1=82=D0=B4=D0=B5=D0=BB=D1=8C=D0=BD=D0=BE?= =?UTF-8?q?=D0=B5=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5=D0=BD=D0=B8?= =?UTF-8?q?=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- stackCalculator/stackCalculator.sln | 2 +- stackCalculator/stackCalculator/Program.cs | 232 +-------------------- 2 files changed, 4 insertions(+), 230 deletions(-) diff --git a/stackCalculator/stackCalculator.sln b/stackCalculator/stackCalculator.sln index 304decd..bbded00 100644 --- a/stackCalculator/stackCalculator.sln +++ b/stackCalculator/stackCalculator.sln @@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.4.33403.182 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "stackCalculator", "stackCalculator\stackCalculator.csproj", "{89A2482C-4A20-41A4-9A42-1623A4FA88C3}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StackCalculator", "stackCalculator\StackCalculator.csproj", "{89A2482C-4A20-41A4-9A42-1623A4FA88C3}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution diff --git a/stackCalculator/stackCalculator/Program.cs b/stackCalculator/stackCalculator/Program.cs index d98c130..8b925d5 100644 --- a/stackCalculator/stackCalculator/Program.cs +++ b/stackCalculator/stackCalculator/Program.cs @@ -1,232 +1,6 @@ -namespace Sort; +namespace StackCalculator; using System; - -interface OperationsWithElementsStruct -{ - // Add element to struct - void AddElement(double value); - - // Remove element in struct and return deleted item - (bool, double) RemoveElement(); - - // Print all elements - void PrintTheElements(); - - // Checking that the structure is empty - bool IsEmpty(); -} - -public class StackWithArray : OperationsWithElementsStruct -{ - private double[] stackArray; - private int numberOfElements; - private int sizeStack = 10; - - public StackWithArray() - { - stackArray = new double[sizeStack]; - } - - public bool ChangeStackSize(int size) - { - if (size < sizeStack) - { - return false; - } - Array.Resize(ref stackArray, size); - return true; - } - - public void AddElement(double value) - { - if (numberOfElements == sizeStack) - { - ChangeStackSize(sizeStack + sizeStack); - } - stackArray[numberOfElements] = value; - ++numberOfElements; - } - - public (bool, double) RemoveElement() - { - if (numberOfElements == 0) - { - return (false, 0); - } - double result = stackArray[numberOfElements - 1]; - --numberOfElements; - return (true, result); - } - - public void PrintTheElements() - { - for(int i = 0; i < numberOfElements; i++) - { - Console.WriteLine(stackArray[i]); - } - } - - public bool IsEmpty() - { - return numberOfElements == 0; - } -} - -public class StackList : OperationsWithElementsStruct -{ - public StackList() - { - Head = null; - } - private StackElement Head; - - public void AddElement(double value) - { - StackElement item = new StackElement(value); - if (Head == null) - { - Head = item; - } - else - { - StackElement copy = Head; - Head = item; - Head.Next= copy; - } - } - - public (bool, double) RemoveElement() - { - if (Head == null) - { - return(false, 0); - } - double item = Head.Value; - StackElement copy = Head.Next; - Head = copy; - return (true, item); - } - - public void PrintTheElements() - { - StackElement walker = Head; - while (walker != null) - { - Console.WriteLine(walker.Value); - walker = walker.Next; - } - } - - public bool IsEmpty() - { - return Head == null; - } - - private class StackElement - { - public StackElement(double value) - { - Value = value; - Next = null; - } - public double Value { get; set; } - public StackElement Next { get; set; } - } -} - -public class StackCalculator -{ - private double delta = 0.0000000000001; - // Receives the input string in which the expression is written in postfix form, finds the result - public (bool, double) ConvertToAResponse(string stringWithExpression) - { - StackList stackExpression = new StackList(); - int i = 0; - while (i < stringWithExpression.Length) - { - if ((stringWithExpression[i] == '-' && i != stringWithExpression.Length - 1 && stringWithExpression[i + 1] != ' ') || (stringWithExpression[i] >= '0' && stringWithExpression[i] <= '9')) - { - bool isNeedMinus = stringWithExpression[i] == '-'; - if (isNeedMinus) - { - ++i; - } - int multiplier = 10; - int number = 0; - while (i < stringWithExpression.Length && stringWithExpression[i] >= '0' && stringWithExpression[i] <= '9') - { - number += stringWithExpression[i] - '0'; - number *= multiplier; - ++i; - } - number /= 10; - --i; - if (isNeedMinus) - { - number *= -1; - } - stackExpression.AddElement(number); - } - else if (stringWithExpression[i] != ' ') - { - double numberAfter = 0; - (var isCorrect, var firstNumber) = stackExpression.RemoveElement(); - (isCorrect, var secondNumber) = stackExpression.RemoveElement(); - - if (!isCorrect) - { - return (false, 0); - } - - switch (stringWithExpression[i]) - { - case '*': - numberAfter = firstNumber * secondNumber; - break; - case '+': - numberAfter = firstNumber + secondNumber; - break; - case '-': - numberAfter = secondNumber - firstNumber; - break; - case '/': - if (Math.Abs(firstNumber) < delta) - { - return (false, 0); - } - numberAfter = secondNumber / firstNumber; - break; - } - stackExpression.AddElement(numberAfter); - } - ++i; - } - (var isCorrectExpression, var result) = stackExpression.RemoveElement(); - if (!isCorrectExpression) - { - return (false, 0); - } - return true == stackExpression.IsEmpty() ? (true, result) : (false, 0); - } -} - -public class Test -{ - // Tests the program - public bool TestForProgram() - { - StackCalculator calculator = new StackCalculator(); - (var isCorrectWork, var result) = calculator.ConvertToAResponse("123 23 +"); - if (!isCorrectWork || result != 146) - { - return false; - } - (isCorrectWork, result) = calculator.ConvertToAResponse("123 23"); - return !isCorrectWork; - } -} - class Program { public static void Main(string[] args) @@ -243,7 +17,7 @@ public static void Main(string[] args) } Console.WriteLine("Enter an example in the postfix form"); var stringWithExpression = Console.ReadLine(); - StackCalculator calculator = new StackCalculator(); + StackCalculator calculator = new(); if (stringWithExpression == null) { return; @@ -256,4 +30,4 @@ public static void Main(string[] args) } Console.WriteLine(result); } -} +} \ No newline at end of file From b539f5494267b46233c10ed537cdd82dbbea98e5 Mon Sep 17 00:00:00 2001 From: Artem Date: Sun, 12 Mar 2023 21:05:02 +0300 Subject: [PATCH 06/10] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7?= =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20=D0=B1=D0=BE=D1=80=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Bor/Bor.sln | 25 +++++++ Bor/Bor/Bor.cs | 183 +++++++++++++++++++++++++++++++++++++++++++++ Bor/Bor/Program.cs | 27 +++++++ 3 files changed, 235 insertions(+) create mode 100644 Bor/Bor.sln create mode 100644 Bor/Bor/Bor.cs create mode 100644 Bor/Bor/Program.cs diff --git a/Bor/Bor.sln b/Bor/Bor.sln new file mode 100644 index 0000000..400f4cd --- /dev/null +++ b/Bor/Bor.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33403.182 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bor", "Bor\Bor.csproj", "{6EE251B3-0506-4E0D-9449-BB213BC99807}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6EE251B3-0506-4E0D-9449-BB213BC99807}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6EE251B3-0506-4E0D-9449-BB213BC99807}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6EE251B3-0506-4E0D-9449-BB213BC99807}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6EE251B3-0506-4E0D-9449-BB213BC99807}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {4DB4942C-BEEB-45EA-89ED-EFB220B46ECA} + EndGlobalSection +EndGlobal diff --git a/Bor/Bor/Bor.cs b/Bor/Bor/Bor.cs new file mode 100644 index 0000000..933556d --- /dev/null +++ b/Bor/Bor/Bor.cs @@ -0,0 +1,183 @@ +using System.ComponentModel.DataAnnotations; +using System.Text; +using System.Xml.Linq; +using static System.Net.Mime.MediaTypeNames; + +namespace Bor; + +// A container for storing strings, in the form of a suspended tree +public class Bor +{ + const int sizeAlphabet = 65536; + + private BorElement? root = new BorElement(); + + // Adding an element + public bool Add(string element) + { + if (element == null && !root.isTerminal) + { + root.howManyStringInDictionary++; + root.isTerminal= true; + } + if (element != null) + { + root.howManyStringInDictionary++; + } + var walker = root; + int i = 0; + while (i < element.Length) + { + int number = element[i]; + if (!walker.next.ContainsKey(number)) + { + walker.next.Add(number, new BorElement()); + walker.next[number].key = number; + ++walker.sizeDictionary; + } + ++walker.next[number].howManyStringInDictionary; + walker = walker.next[number]; + i++; + } + return walker.isTerminal == false ? walker.isTerminal = true && true : false; + } + + private bool RemoveHelp(BorElement walker, string element, int position, ref bool isDeleted) + { + if (position == element.Length) + { + if (walker.isTerminal == true) + { + walker.isTerminal = false; + return true; + } + return false; + } + + if (walker.next.ContainsKey(element[position])) + { + bool isCorrect = RemoveHelp(walker.next[element[position]], element, position + 1, ref isDeleted); + if (!isCorrect) + { + return false; + } + if (walker.next[element[position]].howManyStringInDictionary == 1) + { + walker.next.Remove(element[position]); + isDeleted = true; + return true; + } + if (isDeleted == true) + { + --walker.next[element[position]].sizeDictionary; + isDeleted = false; + } + --walker.next[element[position]].howManyStringInDictionary; + } + else + { + return false; + } + return true; + } + + // Deleting an element in the tree + public bool Remove(string element) + { + if (root == null) + { + if (element == null) + { + return true; + } + return false; + } + var walker = root; + bool flag = false; + if (RemoveHelp(walker, element, 0, ref flag)) + { + --root.howManyStringInDictionary; + return true; + } + return false; + } + + private int HowManyStartsWithPrefixHelp(BorElement walker, String prefix, int position) + { + if (position == prefix.Length) + { + return walker.howManyStringInDictionary; + } + + if (walker.next.ContainsKey(prefix[position])) + { + return HowManyStartsWithPrefixHelp(walker.next[prefix[position]], prefix, position + 1) ; + } + else + { + return 0; + } + } + + // Counts the number of rows with the same prefix + public int HowManyStartsWithPrefix(String prefix) + { + if (root == null) + { + if (prefix == null) + { + return 1; + } + return 0; + } + var walker = root; + return HowManyStartsWithPrefixHelp(walker, prefix, 0); + } + + private bool ContainsHelp(string element, BorElement walker, int position) + { + if (position == element.Length) + { + return true; + } + if (walker.next.ContainsKey(element[position])) + { + return ContainsHelp(element, walker.next[element[position]], position + 1); + } + return false; + } + + // Checks for the presence of a string + public bool Contains(string element) + { + if (root == null) + { + if (element == null) + { + return true; + } + return false; + } + var walker = root; + return ContainsHelp(element, walker, 0); + } + + private class BorElement + { + public int key { get; set; } + public Dictionary next { get; set; } + public bool isTerminal { get; set; } + + public int sizeDictionary { get; set; } + + public int howManyStringInDictionary { get; set; } + + public BorElement() + { + next = new Dictionary(); + isTerminal = false; + sizeDictionary = 0; + howManyStringInDictionary = 0; + } + } +} diff --git a/Bor/Bor/Program.cs b/Bor/Bor/Program.cs new file mode 100644 index 0000000..6a4983c --- /dev/null +++ b/Bor/Bor/Program.cs @@ -0,0 +1,27 @@ +namespace Bor; + +using System; + +class Program +{ + public static void Main(string[] args) + { + var bor = new Bor(); + + var string1 = "da"; + var string2 = "db"; + bool check = bor.Add(string1); + if (check == false) + { + Console.WriteLine("bad news"); + } + check = bor.Add(string2); + if (check == false) + { + Console.WriteLine("bad news"); + } + bor.Remove(string2); + Console.WriteLine(bor.HowManyStartsWithPrefix(string1)); + Console.WriteLine(bor.Contains("da")); + } +} \ No newline at end of file From a14870b299aa728a4048ca6ad824cd2f3a8bd57b Mon Sep 17 00:00:00 2001 From: Palezehvat <114094069+Palezehvat@users.noreply.github.com> Date: Sun, 12 Mar 2023 21:05:51 +0300 Subject: [PATCH 07/10] Delete Bor directory MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Другая ветка --- Bor/Bor.sln | 25 ------- Bor/Bor/Bor.cs | 183 --------------------------------------------- Bor/Bor/Program.cs | 27 ------- 3 files changed, 235 deletions(-) delete mode 100644 Bor/Bor.sln delete mode 100644 Bor/Bor/Bor.cs delete mode 100644 Bor/Bor/Program.cs diff --git a/Bor/Bor.sln b/Bor/Bor.sln deleted file mode 100644 index 400f4cd..0000000 --- a/Bor/Bor.sln +++ /dev/null @@ -1,25 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.4.33403.182 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bor", "Bor\Bor.csproj", "{6EE251B3-0506-4E0D-9449-BB213BC99807}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {6EE251B3-0506-4E0D-9449-BB213BC99807}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {6EE251B3-0506-4E0D-9449-BB213BC99807}.Debug|Any CPU.Build.0 = Debug|Any CPU - {6EE251B3-0506-4E0D-9449-BB213BC99807}.Release|Any CPU.ActiveCfg = Release|Any CPU - {6EE251B3-0506-4E0D-9449-BB213BC99807}.Release|Any CPU.Build.0 = Release|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {4DB4942C-BEEB-45EA-89ED-EFB220B46ECA} - EndGlobalSection -EndGlobal diff --git a/Bor/Bor/Bor.cs b/Bor/Bor/Bor.cs deleted file mode 100644 index 933556d..0000000 --- a/Bor/Bor/Bor.cs +++ /dev/null @@ -1,183 +0,0 @@ -using System.ComponentModel.DataAnnotations; -using System.Text; -using System.Xml.Linq; -using static System.Net.Mime.MediaTypeNames; - -namespace Bor; - -// A container for storing strings, in the form of a suspended tree -public class Bor -{ - const int sizeAlphabet = 65536; - - private BorElement? root = new BorElement(); - - // Adding an element - public bool Add(string element) - { - if (element == null && !root.isTerminal) - { - root.howManyStringInDictionary++; - root.isTerminal= true; - } - if (element != null) - { - root.howManyStringInDictionary++; - } - var walker = root; - int i = 0; - while (i < element.Length) - { - int number = element[i]; - if (!walker.next.ContainsKey(number)) - { - walker.next.Add(number, new BorElement()); - walker.next[number].key = number; - ++walker.sizeDictionary; - } - ++walker.next[number].howManyStringInDictionary; - walker = walker.next[number]; - i++; - } - return walker.isTerminal == false ? walker.isTerminal = true && true : false; - } - - private bool RemoveHelp(BorElement walker, string element, int position, ref bool isDeleted) - { - if (position == element.Length) - { - if (walker.isTerminal == true) - { - walker.isTerminal = false; - return true; - } - return false; - } - - if (walker.next.ContainsKey(element[position])) - { - bool isCorrect = RemoveHelp(walker.next[element[position]], element, position + 1, ref isDeleted); - if (!isCorrect) - { - return false; - } - if (walker.next[element[position]].howManyStringInDictionary == 1) - { - walker.next.Remove(element[position]); - isDeleted = true; - return true; - } - if (isDeleted == true) - { - --walker.next[element[position]].sizeDictionary; - isDeleted = false; - } - --walker.next[element[position]].howManyStringInDictionary; - } - else - { - return false; - } - return true; - } - - // Deleting an element in the tree - public bool Remove(string element) - { - if (root == null) - { - if (element == null) - { - return true; - } - return false; - } - var walker = root; - bool flag = false; - if (RemoveHelp(walker, element, 0, ref flag)) - { - --root.howManyStringInDictionary; - return true; - } - return false; - } - - private int HowManyStartsWithPrefixHelp(BorElement walker, String prefix, int position) - { - if (position == prefix.Length) - { - return walker.howManyStringInDictionary; - } - - if (walker.next.ContainsKey(prefix[position])) - { - return HowManyStartsWithPrefixHelp(walker.next[prefix[position]], prefix, position + 1) ; - } - else - { - return 0; - } - } - - // Counts the number of rows with the same prefix - public int HowManyStartsWithPrefix(String prefix) - { - if (root == null) - { - if (prefix == null) - { - return 1; - } - return 0; - } - var walker = root; - return HowManyStartsWithPrefixHelp(walker, prefix, 0); - } - - private bool ContainsHelp(string element, BorElement walker, int position) - { - if (position == element.Length) - { - return true; - } - if (walker.next.ContainsKey(element[position])) - { - return ContainsHelp(element, walker.next[element[position]], position + 1); - } - return false; - } - - // Checks for the presence of a string - public bool Contains(string element) - { - if (root == null) - { - if (element == null) - { - return true; - } - return false; - } - var walker = root; - return ContainsHelp(element, walker, 0); - } - - private class BorElement - { - public int key { get; set; } - public Dictionary next { get; set; } - public bool isTerminal { get; set; } - - public int sizeDictionary { get; set; } - - public int howManyStringInDictionary { get; set; } - - public BorElement() - { - next = new Dictionary(); - isTerminal = false; - sizeDictionary = 0; - howManyStringInDictionary = 0; - } - } -} diff --git a/Bor/Bor/Program.cs b/Bor/Bor/Program.cs deleted file mode 100644 index 6a4983c..0000000 --- a/Bor/Bor/Program.cs +++ /dev/null @@ -1,27 +0,0 @@ -namespace Bor; - -using System; - -class Program -{ - public static void Main(string[] args) - { - var bor = new Bor(); - - var string1 = "da"; - var string2 = "db"; - bool check = bor.Add(string1); - if (check == false) - { - Console.WriteLine("bad news"); - } - check = bor.Add(string2); - if (check == false) - { - Console.WriteLine("bad news"); - } - bor.Remove(string2); - Console.WriteLine(bor.HowManyStartsWithPrefix(string1)); - Console.WriteLine(bor.Contains("da")); - } -} \ No newline at end of file From 28f0687deebae3a1c3e7b98716365ef8704d4bfc Mon Sep 17 00:00:00 2001 From: Artem Date: Wed, 15 Mar 2023 15:33:04 +0300 Subject: [PATCH 08/10] =?UTF-8?q?=D0=A0=D0=B5=D0=B2=D1=8C=D1=8E2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../stackCalculator/InterfaceForStack.cs | 5 +- stackCalculator/stackCalculator/Program.cs | 60 +++++++++---------- stackCalculator/stackCalculator/Stack.cs | 15 ++++- .../stackCalculator/StackCalculator.cs | 10 ++-- .../stackCalculator/StackWIthArray.cs | 56 +++++++++++++++++ .../stackCalculator/StackWithList.cs | 28 ++++----- stackCalculator/stackCalculator/Tests.cs | 18 +++++- .../stackCalculator/stackCalculator.csproj | 4 ++ 8 files changed, 140 insertions(+), 56 deletions(-) create mode 100644 stackCalculator/stackCalculator/StackWIthArray.cs diff --git a/stackCalculator/stackCalculator/InterfaceForStack.cs b/stackCalculator/stackCalculator/InterfaceForStack.cs index 2e4e88c..3941104 100644 --- a/stackCalculator/stackCalculator/InterfaceForStack.cs +++ b/stackCalculator/stackCalculator/InterfaceForStack.cs @@ -1,7 +1,8 @@ namespace StackCalculator; - interface IOperationsWithStack - { +// Interface for the stack +interface IOperationsWithStack +{ // Add element to stack void AddElement(double value); diff --git a/stackCalculator/stackCalculator/Program.cs b/stackCalculator/stackCalculator/Program.cs index 8b925d5..d1d8e36 100644 --- a/stackCalculator/stackCalculator/Program.cs +++ b/stackCalculator/stackCalculator/Program.cs @@ -1,33 +1,31 @@ -namespace StackCalculator; +using System; +using StackCalculator; -using System; -class Program +Test test = new Test(); +if (test.TestForProgram()) { - public static void Main(string[] args) - { - Test test = new Test(); - if (test.TestForProgram()) - { - Console.WriteLine("All tests correct"); - } - else - { - Console.WriteLine("Problems..."); - return; - } - Console.WriteLine("Enter an example in the postfix form"); - var stringWithExpression = Console.ReadLine(); - StackCalculator calculator = new(); - if (stringWithExpression == null) - { - return; - } - (var isCorrectWork, var result) = calculator.ConvertToAResponse(stringWithExpression); - if (!isCorrectWork) - { - Console.WriteLine("Problems with expression or you tried to divide by zero"); - return; - } - Console.WriteLine(result); - } -} \ No newline at end of file + Console.WriteLine("All tests correct"); +} +else +{ + Console.WriteLine("Problems..."); + return; +} + +Console.WriteLine("Enter an example in the postfix form"); +var stringWithExpression = Console.ReadLine(); + +PostfixCalculator calculator = new PostfixCalculator(); +if (stringWithExpression == null) +{ + return; +} + +var stackList = new StackList(); +(bool isCorrectWork, double result) = calculator.ConvertToAResponse(stringWithExpression, stackList); +if (!isCorrectWork) +{ + Console.WriteLine("Problems with expression or you tried to divide by zero"); + return; +} +Console.WriteLine(result); \ No newline at end of file diff --git a/stackCalculator/stackCalculator/Stack.cs b/stackCalculator/stackCalculator/Stack.cs index 45016c6..ecb7f2f 100644 --- a/stackCalculator/stackCalculator/Stack.cs +++ b/stackCalculator/stackCalculator/Stack.cs @@ -1,4 +1,17 @@ namespace StackCalculator; //Standart stack -public class Stack : StackList{} \ No newline at end of file +abstract public class Stack : IOperationsWithStack +{ + // Add element to stack + virtual public void AddElement(double value) { } + + // Remove element in stack and return deleted item + virtual public (bool, double) RemoveElement() { return (false, 0); } + + // Print all elements + virtual public void PrintTheElements() { } + + // Checking that the stack is empty + virtual public bool IsEmpty() { return false; } +} \ No newline at end of file diff --git a/stackCalculator/stackCalculator/StackCalculator.cs b/stackCalculator/stackCalculator/StackCalculator.cs index 8dc99d7..51713ad 100644 --- a/stackCalculator/stackCalculator/StackCalculator.cs +++ b/stackCalculator/stackCalculator/StackCalculator.cs @@ -1,18 +1,18 @@ namespace StackCalculator; -public class StackCalculator +// Calculator that counts algebraic expressions in postfix form +public class PostfixCalculator { - private double delta = 0.0000000000001; + private const double delta = 0.0000000000001; // Receives the input string in which the expression is written in postfix form, finds the result - public (bool, double) ConvertToAResponse(string stringWithExpression) + public (bool, double) ConvertToAResponse(string stringWithExpression, Stack stackExpression) { - Stack stackExpression = new(); int i = 0; string[] expressionArray = stringWithExpression.Split(' '); while (i < expressionArray.Length) { - var isCorrectNumber = Int32.TryParse(expressionArray[i], out var number); + var isCorrectNumber = Int32.TryParse(expressionArray[i], out var number); if (isCorrectNumber) { stackExpression.AddElement(number); diff --git a/stackCalculator/stackCalculator/StackWIthArray.cs b/stackCalculator/stackCalculator/StackWIthArray.cs new file mode 100644 index 0000000..ffe5a4a --- /dev/null +++ b/stackCalculator/stackCalculator/StackWIthArray.cs @@ -0,0 +1,56 @@ +namespace StackCalculator; + +// Stack implemented on an array +public class StackWithArray : Stack +{ + private double[] stackArray; + private int numberOfElements; + private int sizeStack = 10; + + public StackWithArray() + { + stackArray = new double[sizeStack]; + } + + public bool ChangeStackSize(int size) + { + if (size < sizeStack) + { + return false; + } + Array.Resize(ref stackArray, size); + return true; + } + + public override void AddElement(double value) + { + if (numberOfElements == sizeStack) + { + ChangeStackSize(sizeStack * 2); + } + stackArray[numberOfElements] = value; + ++numberOfElements; + } + + public override (bool, double) RemoveElement() + { + if (numberOfElements == 0) + { + return (false, 0); + } + double result = stackArray[numberOfElements - 1]; + --numberOfElements; + return (true, result); + } + + public override void PrintTheElements() + { + for (int i = 0; i < numberOfElements; i++) + { + Console.WriteLine(stackArray[i]); + } + } + + public override bool IsEmpty() + => numberOfElements == 0; +} diff --git a/stackCalculator/stackCalculator/StackWithList.cs b/stackCalculator/stackCalculator/StackWithList.cs index 9d09748..844e0fc 100644 --- a/stackCalculator/stackCalculator/StackWithList.cs +++ b/stackCalculator/stackCalculator/StackWithList.cs @@ -1,11 +1,11 @@ namespace StackCalculator; // Stack implemented on list -public class StackList : IOperationsWithStack +public class StackList : Stack { private StackElement headStack; - public void AddElement(double value) + public override void AddElement(double value) { var item = new StackElement(value); if (headStack == null) @@ -16,43 +16,43 @@ public void AddElement(double value) { StackElement copy = headStack; headStack = item; - headStack.next = copy; + headStack.Next = copy; } } - public (bool, double) RemoveElement() + public override(bool, double) RemoveElement() { if (headStack == null) { return (false, 0); } - double item = headStack.valueStack; - StackElement copy = headStack.next; + double item = headStack.ValueStack; + StackElement copy = headStack.Next; headStack = copy; return (true, item); } - public void PrintTheElements() + public override void PrintTheElements() { StackElement walker = headStack; while (walker != null) { - Console.WriteLine(walker.valueStack); - walker = walker.next; + Console.WriteLine(walker.ValueStack); + walker = walker.Next; } } - public bool IsEmpty() => headStack == null; + public override bool IsEmpty() => headStack == null; private class StackElement { public StackElement(double value) { - valueStack = value; - next = null; + ValueStack = value; + Next = null; } - public double valueStack { get; set; } - public StackElement next { get; set; } + public double ValueStack { get; set; } + public StackElement Next { get; set; } } } \ No newline at end of file diff --git a/stackCalculator/stackCalculator/Tests.cs b/stackCalculator/stackCalculator/Tests.cs index 47d7fc7..0a3a872 100644 --- a/stackCalculator/stackCalculator/Tests.cs +++ b/stackCalculator/stackCalculator/Tests.cs @@ -5,13 +5,25 @@ public class Test // Tests the program public bool TestForProgram() { - StackCalculator calculator = new StackCalculator(); - (var isCorrectWork, var result) = calculator.ConvertToAResponse("123 23 +"); + var calculator = new PostfixCalculator(); + var stackList = new StackList(); + (var isCorrectWork, var result) = calculator.ConvertToAResponse("123 23 +", stackList); if (!isCorrectWork || result != 146) { return false; } - (isCorrectWork, result) = calculator.ConvertToAResponse("123 23"); + var stackArray = new StackWithArray(); + (isCorrectWork, result) = calculator.ConvertToAResponse("123 23 +", stackArray); + if (!isCorrectWork || result != 146) + { + return false; + } + (isCorrectWork, result) = calculator.ConvertToAResponse("123 23", stackList); + if (isCorrectWork) + { + return false; + } + (isCorrectWork, result) = calculator.ConvertToAResponse("123 23", stackArray); return !isCorrectWork; } } diff --git a/stackCalculator/stackCalculator/stackCalculator.csproj b/stackCalculator/stackCalculator/stackCalculator.csproj index f02677b..d4116cd 100644 --- a/stackCalculator/stackCalculator/stackCalculator.csproj +++ b/stackCalculator/stackCalculator/stackCalculator.csproj @@ -7,4 +7,8 @@ enable + + + + From fb95603746296fc5adada2f5cd9bd2334c91b6ea Mon Sep 17 00:00:00 2001 From: Artem Date: Wed, 15 Mar 2023 15:46:16 +0300 Subject: [PATCH 09/10] =?UTF-8?q?=D0=94=D0=BB=D1=8F=20BWT=20=D1=81=D0=BE?= =?UTF-8?q?=D0=B7=D0=B4=D0=B0=D0=BB=20=D0=BD=D0=BE=D0=B2=D1=83=D1=8E=20?= =?UTF-8?q?=D0=B2=D0=B5=D1=82=D0=BA=D1=83=20=D0=B8=20=D0=BF=D0=B5=D1=80?= =?UTF-8?q?=D0=B5=D0=BD=D1=91=D1=81=20=D0=B5=D0=B3=D0=BE=20=D1=82=D1=83?= =?UTF-8?q?=D0=B4=D0=B0,=20=D1=87=D1=82=D0=BE=D0=B1=D1=8B=20=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=B0=D1=82=D1=8B=20=D0=BD=D0=B5=20=D0=B4=D0=B5=D0=BB?= =?UTF-8?q?=D0=B0=D1=82=D1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- stackCalculator/stackCalculator/Program.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stackCalculator/stackCalculator/Program.cs b/stackCalculator/stackCalculator/Program.cs index d1d8e36..cb588b8 100644 --- a/stackCalculator/stackCalculator/Program.cs +++ b/stackCalculator/stackCalculator/Program.cs @@ -25,7 +25,7 @@ (bool isCorrectWork, double result) = calculator.ConvertToAResponse(stringWithExpression, stackList); if (!isCorrectWork) { - Console.WriteLine("Problems with expression or you tried to divide by zero"); + Console.WriteLine("Problems with expression or you tried to divide by zero!"); return; } Console.WriteLine(result); \ No newline at end of file From 07208f9db98af6c9e844e0beb674cf71ac2d36f7 Mon Sep 17 00:00:00 2001 From: Artem Date: Fri, 17 Mar 2023 21:51:42 +0300 Subject: [PATCH 10/10] =?UTF-8?q?=D0=9D=D0=B0=D1=88=D1=91=D0=BB=20=D0=BE?= =?UTF-8?q?=D1=88=D0=B8=D0=B1=D0=BA=D1=83=20=D0=BF=D0=BE=D0=BA=D0=B0=20?= =?UTF-8?q?=D0=BF=D0=B8=D1=81=D0=B0=D0=BB=20=D0=BC=D0=BE=D0=B4=D1=83=D0=BB?= =?UTF-8?q?=D1=8C=D0=BD=D1=8B=D0=B5=20=D1=82=D0=B5=D1=81=D1=82=D1=8B,=20?= =?UTF-8?q?=D0=B8=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=B8=D0=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- stackCalculator/stackCalculator/StackCalculator.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/stackCalculator/stackCalculator/StackCalculator.cs b/stackCalculator/stackCalculator/StackCalculator.cs index 51713ad..13ff6c7 100644 --- a/stackCalculator/stackCalculator/StackCalculator.cs +++ b/stackCalculator/stackCalculator/StackCalculator.cs @@ -56,6 +56,8 @@ public class PostfixCalculator } numberAfter = secondNumber / firstNumber; break; + default: + return (false, 0); } stackExpression.AddElement(numberAfter); }