added some new solved problems

Yariki · Yariki · commit ace857450d46 · 2020-06-08T01:07:53.000+03:00
diff --git a/LeetCode.sln b/LeetCode.sln
@@ -9,6 +9,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AddTwoNumbers", "AddTwoNumb
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LongestSubstringWithoutRepeating", "LongestSubstringWithoutRepeating\LongestSubstringWithoutRepeating.csproj", "{B69D75B1-D9E9-4292-97C2-60D46AFD87E8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RomanToInt", "RomanToInt\RomanToInt.csproj", "{8F1541CA-654D-44F6-8615-2B81566CAE44}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LeetcodeTasks", "LeetcodeTasks\LeetcodeTasks.csproj", "{074BA7FF-86C3-4BDC-981F-7A715A2A6B1F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -27,6 +31,14 @@ Global
 		{B69D75B1-D9E9-4292-97C2-60D46AFD87E8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B69D75B1-D9E9-4292-97C2-60D46AFD87E8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B69D75B1-D9E9-4292-97C2-60D46AFD87E8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8F1541CA-654D-44F6-8615-2B81566CAE44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8F1541CA-654D-44F6-8615-2B81566CAE44}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8F1541CA-654D-44F6-8615-2B81566CAE44}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8F1541CA-654D-44F6-8615-2B81566CAE44}.Release|Any CPU.Build.0 = Release|Any CPU
+		{074BA7FF-86C3-4BDC-981F-7A715A2A6B1F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{074BA7FF-86C3-4BDC-981F-7A715A2A6B1F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{074BA7FF-86C3-4BDC-981F-7A715A2A6B1F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{074BA7FF-86C3-4BDC-981F-7A715A2A6B1F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/LeetcodeTasks/LeetcodeTasks.csproj b/LeetcodeTasks/LeetcodeTasks.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.0</TargetFramework>
+
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="nunit" Version="3.12.0" />
+        <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    </ItemGroup>
+
+</Project>
diff --git a/LeetcodeTasks/MergeTwoSortedLinkedLists/ListNode.cs b/LeetcodeTasks/MergeTwoSortedLinkedLists/ListNode.cs
@@ -0,0 +1,13 @@
+namespace LeetcodeTasks.MergeTwoSortedLinkedLists
+{
+    public class ListNode
+    {
+        public int val;
+        public ListNode next;
+        public ListNode(int val=0, ListNode next=null) 
+        {
+             this.val = val;
+             this.next = next;
+        }
+    }
+}
diff --git a/LeetcodeTasks/MergeTwoSortedLinkedLists/MergeTwoSortedLinkedList.cs b/LeetcodeTasks/MergeTwoSortedLinkedLists/MergeTwoSortedLinkedList.cs
@@ -0,0 +1,81 @@
+namespace LeetcodeTasks.MergeTwoSortedLinkedLists
+{
+    public class MergeTwoSortedLinkedList
+    {
+        private readonly ListNode _first;
+        private readonly ListNode _second;
+
+        public MergeTwoSortedLinkedList(ListNode first, ListNode second)
+        {
+            _first = first;
+            _second = second;
+        }
+
+        public ListNode SolutionOne()
+        {
+            var left = _first;
+            var right = _second;
+            ListNode start = null;
+            ListNode current = null;
+
+            while (left != null && right != null)
+            {
+                if (left.val <= right.val)
+                {
+                    if (start == null)
+                    {
+                        current = start = left;
+                    }
+                    else
+                    {
+                        current = current.next = left;
+                    }
+                    left = left.next;
+                }
+                else
+                {
+                    if (start == null)
+                    {
+                        current = start = right;
+                    }
+                    else
+                    {
+                        current = current.next = right;
+                    }
+                    right = right.next;    
+                }
+            }
+
+            if (left != null)
+                while (left != null)
+                {
+                    if (start == null)
+                    {
+                        current = start = left;
+                    }
+                    else
+                    {
+                        current = current.next = left;
+                    }
+                    left = left.next;
+                }
+
+            if (right != null)
+                while (right != null)
+                {
+                    if (start == null)
+                    {
+                        current = start = right;
+                    }
+                    else
+                    {
+                        current = current.next = right;
+                    }
+                    right = right.next;
+                }
+
+            return start;
+        }
+        
+    }
+}
diff --git a/LeetcodeTasks/MergeTwoSortedLinkedLists/MergeTwoSortedLinkedListTest.cs b/LeetcodeTasks/MergeTwoSortedLinkedLists/MergeTwoSortedLinkedListTest.cs
@@ -0,0 +1,47 @@
+using NUnit.Framework;
+
+namespace LeetcodeTasks.MergeTwoSortedLinkedLists
+{
+    [TestFixture]
+    public class MergeTwoSortedLinkedListTest
+    {
+        [Test]
+        public void TwoSortedListWithSameCountButDifferentNumbers_ShouldSucceeded()
+        {
+            var l1 = new ListNode(1,new ListNode(3,new ListNode(5)));
+            var l2= new ListNode(2,new ListNode(4,new ListNode(6)));
+            
+            var solution = new Solution();
+            var result = solution.MergeTwoLists(l1, l2);
+            
+            Assert.NotNull(result);
+        }
+        
+        [Test]
+        public void TwoSortedListWithDiffCountAndDiffNumbers_ShouldSucceeded()
+        {
+            var l1 = new ListNode(1,new ListNode(1,new ListNode(5, new ListNode(10))));
+            var l2= new ListNode(2,new ListNode(4,new ListNode(6, new ListNode(9, new ListNode(20, new ListNode(21))))));
+            
+            var solution = new Solution();
+            var result = solution.MergeTwoLists(l1, l2);
+            
+            Assert.NotNull(result);
+        }
+        
+        [Test]
+        public void TwoSortedList_FirstNull_SecondWithOneElement_ShouldSucceeded()
+        {
+            ListNode l1 = null;
+            var l2= new ListNode(0);
+            
+            var solution = new Solution();
+            var result = solution.MergeTwoLists(l1, l2);
+            
+            Assert.NotNull(result);
+        }
+        
+        
+        
+    }
+}
diff --git a/LeetcodeTasks/MergeTwoSortedLinkedLists/Solution.cs b/LeetcodeTasks/MergeTwoSortedLinkedLists/Solution.cs
@@ -0,0 +1,11 @@
+namespace LeetcodeTasks.MergeTwoSortedLinkedLists
+{
+    public class Solution
+    {
+        public ListNode MergeTwoLists(ListNode l1, ListNode l2) 
+        {
+            var mergeTwoSorterLinkedList = new MergeTwoSortedLinkedList(l1, l2);
+            return mergeTwoSorterLinkedList.SolutionOne();
+        }
+    }
+}
diff --git a/LeetcodeTasks/RemoveDublicatesArray/RemoveDublicatesInArrayTest.cs b/LeetcodeTasks/RemoveDublicatesArray/RemoveDublicatesInArrayTest.cs
@@ -0,0 +1,54 @@
+using NUnit.Framework;
+
+namespace LeetcodeTasks.RemoveDublicatesArray
+{
+    public class RemoveDublicatesInArrayTest
+    {
+        [Test]
+        public void ArrayWithTwoRepeatedNumbers()
+        {
+            var arr = new int[] {1, 1, 2, 2};
+            var sol = new Solution();
+            
+            Assert.AreEqual(2,sol.RemoveDuplicates(arr));
+        }
+        
+        [Test]
+        public void ArrayWithTwoRepeatedAndOneNumbers()
+        {
+            var arr = new int[] {1, 1, 2, 2,10};
+            var sol = new Solution();
+            
+            Assert.AreEqual(3,sol.RemoveDuplicates(arr));
+        }
+        
+        [Test]
+        public void ArrayWithAllSameNumbers()
+        {
+            var arr = new int[] {1, 1, 1, 1,1};
+            var sol = new Solution();
+            
+            Assert.AreEqual(1,sol.RemoveDuplicates(arr));
+        }
+        
+        [Test]
+        public void ArrayWithNegativeAndPositiveNumbers()
+        {
+            var arr = new int[] {-1,0,0, 1, 1, 3,6,7,7};
+            var sol = new Solution();
+            
+            Assert.AreEqual(6,sol.RemoveDuplicates(arr));
+        }
+        
+        [Test]
+        public void EmtyArray()
+        {
+            var arr = new int[]{};
+            var sol = new Solution();
+            
+            Assert.AreEqual(0,sol.RemoveDuplicates(arr));
+        }
+        
+        
+    }
+}
diff --git a/LeetcodeTasks/RemoveDublicatesArray/RemoveDublicatesIsArray.cs b/LeetcodeTasks/RemoveDublicatesArray/RemoveDublicatesIsArray.cs
@@ -0,0 +1,40 @@
+using System;
+
+namespace LeetcodeTasks.RemoveDublicatesArray
+{
+    public class RemoveDublicatesIsArray
+    {
+        private int[] _array;
+        
+        public RemoveDublicatesIsArray(int[] arr)
+        {
+            _array = arr;
+        }
+
+        public int SolutionOne()
+        {
+            if (_array == null || _array.Length == 0)
+            {
+                return 0;
+            }
+            
+            if (_array.Length == 1)
+            {
+                return 1;
+            }
+
+            var i = 0;
+            var j = 0;
+            while (j < _array.Length)
+            {
+                if (_array[i] != _array[j])
+                {
+                    i++;
+                    _array[i] = _array[j];
+                }
+                j++;
+            }
+            return i + 1;
+        }
+    }
+}
diff --git a/LeetcodeTasks/RemoveDublicatesArray/Solution.cs b/LeetcodeTasks/RemoveDublicatesArray/Solution.cs
@@ -0,0 +1,11 @@
+namespace LeetcodeTasks.RemoveDublicatesArray
+{
+    public class Solution 
+    {
+        public int RemoveDuplicates(int[] nums) 
+        {
+            var removeDub = new RemoveDublicatesIsArray(nums);
+            return removeDub.SolutionOne();
+        }
+    }
+}
diff --git a/LeetcodeTasks/ValidParentheses/Solution.cs b/LeetcodeTasks/ValidParentheses/Solution.cs
@@ -0,0 +1,11 @@
+namespace LeetcodeTasks.ValidParentheses
+{
+    public class Solution 
+    {
+        public bool IsValid(string s)
+        {
+            var validParentheses = new ValidParentheses(s);
+            return validParentheses.SolutionOne();
+        }
+    }
+}
diff --git a/LeetcodeTasks/ValidParentheses/ValidParentheses.cs b/LeetcodeTasks/ValidParentheses/ValidParentheses.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace LeetcodeTasks.ValidParentheses
+{
+    public class ValidParentheses
+    {
+        private string _inputString = string.Empty;
+        
+        private readonly List<char> Parentheses = new List<char>()
+        {
+            '(',
+            '{',
+            '['
+        };
+        
+        private readonly Dictionary<char,char> ParenthesesBack = new Dictionary<char, char>()
+        {
+            {')','('},
+            {'}','{'},
+            {']','['},
+        };
+        
+        
+        public ValidParentheses(string inputString)
+        {
+            _inputString = inputString;
+        }
+
+        public bool SolutionOne()
+        {
+            if (string.IsNullOrEmpty(_inputString))
+                return true;
+            
+            if (_inputString.Length == 1)
+                return false;
+            
+            var stack = new Stack<char>();
+            foreach (var ch in _inputString)
+            {
+                
+                if(ParenthesesBack.ContainsKey(ch))
+                {
+                    if (stack.Count == 0) return false;
+                    
+                    var open = ParenthesesBack[ch];
+                    var prev = stack.Pop();
+                    if (prev != open)
+                        return false;
+                } 
+                else 
+                {
+                    stack.Push(ch);
+                }
+            }
+            return stack.Count == 0;
+        }
+    }
+}
diff --git a/LeetcodeTasks/ValidParentheses/ValidParenthesesTests.cs b/LeetcodeTasks/ValidParentheses/ValidParenthesesTests.cs
diff --git a/RomanToInt/Program.cs b/RomanToInt/Program.cs
diff --git a/RomanToInt/RomanToInt.csproj b/RomanToInt/RomanToInt.csproj
