public void ParantheseTest_False(String s)
        {
            var  p = new ValidParentheses();
            bool b = p.IsValidParantheses(s);

            Assert.IsFalse(b);
        }
        public void DoesntTryToPopAnEmptyStack()
        {
            var vp = new ValidParentheses();

            // Assert.False(vp.IsValid("]"));
            Assert.False(vp.IsValid("){"));
        }
        public void IsValid(string input, bool expected)
        {
            var sut    = new ValidParentheses();
            var actual = sut.IsValid(input);

            Assert.AreEqual(expected, actual);
        }
Exemple #4
0
        public void TestValidParenEmptyString()
        {
            ValidParentheses validParentheses = new ValidParentheses();
            bool             isValid          = validParentheses.IsParenthesesValid("");

            Assert.IsTrue(isValid);
        }
        public void MinRemoveToMakeValid(string input, string expected)
        {
            var sut    = new ValidParentheses();
            var actual = sut.MinRemoveToMakeValid(input);

            Assert.AreEqual(expected, actual);
        }
Exemple #6
0
        public void IsValidTest()
        {
            var c = new ValidParentheses();

            // example1
            var target = "()";
            var result = c.IsValid(target);

            Assert.IsTrue(result);

            // example2
            target = "()[]{}";
            result = c.IsValid(target);
            Assert.IsTrue(result);

            //example3
            target = "(]";
            result = c.IsValid(target);
            Assert.IsFalse(result);

            //example4
            target = "([)]";
            result = c.IsValid(target);
            Assert.IsFalse(result);

            //example5
            target = "{[]}";
            result = c.IsValid(target);
            Assert.IsTrue(result);
        }
Exemple #7
0
        private static void LeetCodeCases()
        {
            int option = 4;

            switch (option)
            {
            case 1:
                LongestPalindromeString.Tests();
                break;

            case 2:
                SudokuSolver.Tests();
                break;

            case 3:
                Test3DArray();
                break;

            case 4:
                ValidParentheses.Tests();
                break;

            default:
                break;
            }
        }
Exemple #8
0
        public void TestValidParen()
        {
            ValidParentheses validParentheses = new ValidParentheses();
            bool             isValid          = validParentheses.IsParenthesesValid("{}[](test)");

            Assert.IsTrue(isValid);
        }
Exemple #9
0
        public void ValidParenthesesTest(string input, bool expected)
        {
            var target = new ValidParentheses();

            var actual = target.IsValid(input);

            Assert.Equal(expected, actual);
        }
        public void Complex_But_Incorrect()
        {
            var input = "([)]";

            var result = new ValidParentheses().FirstTry(input);

            Assert.False(result);
        }
        public void Only_With_Parentheses()
        {
            var input = "()";

            var result = new ValidParentheses().FirstTry(input);

            Assert.True(result);
        }
        public void Using_The_Three_Different_Forms()
        {
            var input = "()[]{}";

            var result = new ValidParentheses().FirstTry(input);

            Assert.True(result);
        }
        public void Only_One_Char()
        {
            var input = "(";

            var result = new ValidParentheses().FirstTry(input);

            Assert.False(result);
        }
        public void Complete()
        {
            var input = "{[()]}";

            var result = new ValidParentheses().FirstTry(input);

            Assert.True(result);
        }
Exemple #15
0
        public void TestNoGenerics(string s, bool expected)
        {
            var func = new ValidParentheses();

            var actual = func.IsValidNoGenerics(s);

            Assert.Equal(expected, actual);
        }
Exemple #16
0
        public void TestAlgorithm(string s, bool expected)
        {
            var func = new ValidParentheses();

            var actual = func.IsValid(s);

            Assert.Equal(expected, actual);
        }
        public void Complex_And_Correct()
        {
            var input = "{[]}";

            var result = new ValidParentheses().FirstTry(input);

            Assert.True(result);
        }
Exemple #18
0
        public void TestInValidParenString()
        {
            ValidParentheses validParentheses = new ValidParentheses();
            bool             isValid          = validParentheses.IsParenthesesValid("{");

            Assert.IsFalse(isValid);

            isValid = validParentheses.IsParenthesesValid("{}]");
            Assert.IsFalse(isValid);
        }
        public void TestMethod1(string s, bool expected)
        {
            // Arrange
            ValidParentheses question = new ValidParentheses();

            // Act
            bool actual = question.IsValid(s);

            // Assert
            Assert.AreEqual(expected, actual);
        }
Exemple #20
0
        static void Main(string[] args)
        {
            //IProblem problem = new StringReverse();
            //IProblem problem = new RemoveCosecutiveLetters();
            //IProblem problem = new StringRotation();
            //IProblem problem = new MissingNumber();
            //IProblem problem = new MissingNumbers();
            IProblem problem = new ValidParentheses();

            problem.Solve();
        }
        public void TestDifferentTypeValidParentheses()
        {
            //Given
            string input    = "[()()]";
            bool   expected = true;

            //When
            ValidParentheses valid  = new ValidParentheses();
            bool             actual = valid.IsInputValid(input);

            //Then
            Assert.AreEqual(expected, actual);
        }
        public void TestInvalidParentheses()
        {
            //Given
            string input    = "[({)}()]";
            bool   expected = false;

            //When
            ValidParentheses valid  = new ValidParentheses();
            bool             actual = valid.IsInputValid(input);

            //Then
            Assert.AreEqual(expected, actual);
        }
        public void IsValidParentheses()
        {
            ValidParentheses isValidParentheses = new ValidParentheses();
            string           sample             = "((";

            Assert.AreEqual(isValidParentheses.IsValid(sample), false);
            sample = "(())";
            Assert.AreEqual(isValidParentheses.IsValid(sample), true);
            sample = "((])";
            Assert.AreEqual(isValidParentheses.IsValid(sample), false);
            sample = "([)]";
            Assert.AreEqual(isValidParentheses.IsValid(sample), false);
        }
        public void IsValidParentheses()
        {
            ValidParentheses l = new ValidParentheses();

            Assert.IsTrue(l.IsValid("()[]"));
            Assert.IsTrue(l.IsValid("[({})]"));
            Assert.IsTrue(l.IsValid("[({})]{}"));
            Assert.IsTrue(l.IsValid(""));

            Assert.IsFalse(l.IsValid("[[({})]"));
            Assert.IsFalse(l.IsValid("([)[]"));
            Assert.IsFalse(l.IsValid("([)]"));
            Assert.IsFalse(l.IsValid("{[{]]}{}[]"));
        }
Exemple #25
0
        public void Test()
        {
            var s1 = "{{{{{{";
            var s2 = "(([]}))}";
            var s3 = "(())[]{}";
            var s4 = "(({[))]}";

            var valid = new ValidParentheses();

            Assert.False(valid.IsValid(s1));
            Assert.False(valid.IsValid(s2));
            Assert.True(valid.IsValid(s3));
            Assert.False(valid.IsValid(s4));
        }
            public void Execute(string s, int startingPos)
            {
                int parenthesesCounter = 0;

                Valid = true;
                for (int i = startingPos; i < s.Length && Valid; i++)
                {
                    if (s[i] == OpeningChar)
                    {
                        parenthesesCounter++;
                    }
                    else if (s[i] == ClosingChar)
                    {
                        parenthesesCounter--;
                        if (parenthesesCounter < 0)
                        {
                            Valid = false;
                        }
                    }
                    else
                    {
                        if (parenthesesCounter == 0)
                        {
                            return;
                        }
                        else if (!ClosingParenthesisDict.ContainsKey(s[i]))
                        {
                            Valid = false;
                        }
                        else
                        {
                            ValidParentheses subProblem = new ValidParentheses
                            {
                                OpeningChar = s[i],
                                ClosingChar = ClosingParenthesisDict[s[i]]
                            };
                            subProblem.Execute(s, i);
                            Valid = subProblem.Valid;
                            i     = subProblem.LastPosition;
                        }
                    }
                    LastPosition = i;
                }
                if (parenthesesCounter > 0)
                {
                    Valid = false;
                }
            }
        public void TestValidParentheses()
        {
            Assert.True(ValidParentheses.FindValidParentheses(""));
            Assert.True(ValidParentheses.FindValidParentheses("()"));
            Assert.True(ValidParentheses.FindValidParentheses("(())((()())())"));
            Assert.True(ValidParentheses.FindValidParentheses("(((()()())))"));
            Assert.True(ValidParentheses.FindValidParentheses("<><><>>>>><<<>>>"));
            Assert.True(ValidParentheses.FindValidParentheses("()()([{)"));

            Assert.False(ValidParentheses.FindValidParentheses("())()()()()()(()"));
            Assert.False(ValidParentheses.FindValidParentheses(")(()))"));
            Assert.False(ValidParentheses.FindValidParentheses("("));
            Assert.False(ValidParentheses.FindValidParentheses(")"));
            Assert.False(ValidParentheses.FindValidParentheses("()()()()()()()(()"));
            Assert.False(ValidParentheses.FindValidParentheses("()()(()"));
            Assert.False(ValidParentheses.FindValidParentheses("[{<("));
        }
Exemple #28
0
        public void TestValidParentheses()
        {
            var r = ValidParentheses.Valid("()");

            Assert.AreEqual(r, true);

            r = ValidParentheses.Valid("()[]{}");
            Assert.AreEqual(r, true);

            r = ValidParentheses.Valid("(]");
            Assert.AreEqual(r, false);

            r = ValidParentheses.Valid("([)]");
            Assert.AreEqual(r, false);

            r = ValidParentheses.Valid("{[]}");
            Assert.AreEqual(r, true);
        }
Exemple #29
0
        private static void ValidParenthesesTest()
        {
            Console.WriteLine("\n3 Valid Parentheses question:");

            ValidParentheses validParentheses = new ValidParentheses();

            IList <string> testStrings = new List <string> {
                "()",
                "()[]{}",
                "(]",
                "([)]",
                "{[]}"
            };

            foreach (string testString in testStrings)
            {
                Console.WriteLine("{0} -> {1}", testString, validParentheses.IsValid(testString));
            }
        }
        public bool IsValid(string s)
        {
            if (s.Equals(string.Empty))
            {
                return(true);
            }

            if (!ClosingParenthesisDict.ContainsKey(s[0]))
            {
                return(false);
            }

            ValidParentheses problem = new ValidParentheses
            {
                OpeningChar = s[0],
                ClosingChar = ClosingParenthesisDict[s[0]],
            };

            problem.Execute(s, 0);
            if (!problem.Valid)
            {
                return(false);
            }
            while (problem.LastPosition != s.Length - 1)
            {
                int pos = problem.LastPosition + 1;
                if (!ClosingParenthesisDict.ContainsKey(s[pos]))
                {
                    return(false);
                }
                problem = new ValidParentheses
                {
                    OpeningChar = s[pos],
                    ClosingChar = ClosingParenthesisDict[s[pos]],
                };
                problem.Execute(s, pos);
                if (!problem.Valid)
                {
                    return(false);
                }
            }
            return(true);
        }