Ejemplo n.º 1
0
        /// <summary>
        /// Check is parentheses are balanced
        /// 
        /// ((())) is balanced
        /// )( is not balanced
        /// </summary>
        /// <param name="parantheses"></param>
        /// <returns></returns>
        public static bool BalancedParentheses(string parantheses)
        {
            Stack<char> tracker = new Stack<char>();

            foreach (char character in parantheses)
            {
                if (character == '(')
                {
                    tracker.Push(character);
                }
                else
                {
                    if (tracker.Count == 0)
                    {
                        return false;
                    }

                    char existingCharacter = tracker.Pop();

                    if (existingCharacter != '(')
                    {
                        return false;
                    }
                }
            }

            return true;
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Check is parentheses are balanced
        /// 
        /// Support (, {, [
        /// </summary>
        /// <param name="parantheses"></param>
        /// <returns></returns>
        public static bool BalancedParenthesesMultiple(string parantheses)
        {
            Dictionary<char, char> bracketMatch = new Dictionary<char, char> {
                {')', '('},
                {']', '['},
                {'}', '{'},
            };

            Stack<char> tracker = new Stack<char>();

            foreach (char character in parantheses)
            {
                if ((character == '(') || (character == '[') || (character == '{'))
                {
                    tracker.Push(character);
                }
                else
                {
                    if (tracker.Count == 0)
                    {
                        return false;
                    }

                    char existingCharacter = tracker.Pop();

                    if (existingCharacter != bracketMatch[character])
                    {
                        return false;
                    }
                }
            }

            return true;
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Given a histogram, find the area of largest rectangle that can be formed
        /// 
        ///             -----
        ///         ----|   |
        ///         |   |   |
        ///         |   |   |----
        ///         |   |   |   |
        ///         |   |   |   |
        ///         
        /// Using a stack, push any histogram of greater height. Once we encounter a short
        /// histogram, we will pop off any greater height ones and calculate the area
        /// If this area is greater than the max area, then replace max
        /// </summary>
        /// <param name="heights"></param>
        /// <returns></returns>
        public static long GetLargestRectangle(int[] heights)
        {
            long maxArea = 0;
            Stack<LargestStorage> storage = new Stack<LargestStorage>();

            int index = 0;
            foreach (int height in heights)
            {
                while ((storage.Count > 0) && (storage.Peek().Height > height))
                {
                    LargestStorage last = storage.Pop();
                    long area = (index - last.Index) * last.Height;
                    if (area > maxArea)
                    {
                        maxArea = area;
                    }
                }

                //need to put the current one for the future
                storage.Push(new LargestStorage { Index = index, Height = height });

                index++;
            }

            //need to pop stuff off the stack
            while (storage.Count > 0)
            {
                LargestStorage last = storage.Pop();
                long area = (index - last.Index) * last.Height;
                if (area > maxArea)
                {
                    maxArea = area;
                }
            }

            return maxArea;
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Valid operators are +, -, *, /. Each operand may be an integer or another expression.
        /// 
        /// ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
        /// ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6
        /// </summary>
        /// <param name="tokens"></param>
        /// <returns></returns>
        public static int EvalRPN(string[] tokens)
        {
            if (tokens == null)
            {
                throw new ArgumentException();
            }

            if (tokens.Length == 0)
            {
                return 0;
            }

            //looks like we only need to look back 2 when we encounter an operator
            //what if we push into stack, pop 2 if we encounter an operator, evaluate it
            //and push it back until we encounter another symbol
            //if we are done, just pop the final result from the stack

            //in case of an overflow
            Stack<long> stack = new Stack<long>();
            foreach (string token in tokens)
            {
                if ((token == "+") || (token == "-") || (token == "*") || (token == "/"))
                {
                    if (stack.Count < 2)
                    {
                        throw new ArgumentException();
                    }

                    long right = stack.Pop();
                    long left = stack.Pop();

                    long result = 0;
                    switch (token)
                    {
                        case "+":
                            result = left + right;
                            break;
                        case "-":
                            result = left - right;
                            break;
                        case "*":
                            result = left * right;
                            break;
                        case "/":
                            result = left / right;
                            break;
                    }
                    stack.Push(result);
                }
                else
                {
                    stack.Push(long.Parse(token));
                }
            }

            if (stack.Count == 1)
            {
                return (int)stack.Pop();
            }

            throw new ArgumentException();
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Use a variable s to denote the start of the valid pattern
        /// 
        /// when we encounter ) at index i, there are 3 cases:
        ///     1. stack is empty - no valid pattern, s = i + 1
        ///     2. stack has 1 element - we found the end of a pattern...calculate length as i - s + 1...and compare to max
        ///     3. stack has multiple elements - since all patterns from the top of the stack (only invalid is many ')'), meaning stack would be empty,
        ///        length is i - s.top...only if we push index into s
        /// </summary>
        /// <param name="parantheses"></param>
        /// <returns></returns>
        public static int LengthOfLongestBalancedParanthese(string parantheses)
        {
            int max = 0;
            int start = 0;
            Stack<int> tracker = new Stack<int>();

            for (int index = 0; index < parantheses.Length; index++)
            {
                char chr = parantheses[index];
                if (chr == '(')
                {
                    tracker.Push(index);
                }
                else
                {
                    if (tracker.Count == 0)
                    {
                        //invalid pattern...case 1
                        start = index + 1;
                    }
                    else
                    {
                        tracker.Pop();
                        if (tracker.Count == 0)
                        {
                            //case 2
                            max = System.Math.Max(max, index - start + 1);
                        }
                        else
                        {
                            //sub pattern...if everything afterward is invalid or we run out of closing brackets, this could be longest
                            //case 3
                            //(((()())
                            //   _)
                            //   ___)
                            //  _____)
                            max = System.Math.Max(max, index - tracker.Peek());
                        }
                    }
                }
            }

            return max;
        }