Codility Lesson 5 Brackets 解答

Thinking:

This lesson is about two kinds of data structures -- queue and stack. After reading the question carefully, you can tell stack is a good choice. As it's a EASY-level question, there is neither a trick nor a math theory behind it. But, some traps still exist, which make the code a little bit long. Let's see my solution directly.

class Solution {
     public int solution(String S) {
        // empty string, return 1, notice: "".split("") return an array [""], neither null nor array []
        if (S == null || S.equals("")) {
            return 1;
        }
        
        String[] sArray = S.split("");
        int l = sArray.length;
        Stack<String> stackLeft = new Stack<String>();
        Stack<String> stackRight = new Stack<String>();
        System.out.println(S);
        // odd number, return 0
        if((l / 2) < (l - (l / 2))) {
            return 0;
        }
                
        for(int i = 0; i < l; i ++) {
            stackLeft.push(sArray[i]);
        }
        
        
        while(!stackLeft.empty()) {
            String next1;
            String next2;
            if (stackRight.empty()) {
                next1 = stackLeft.pop();
                if (!stackLeft.empty()) {
                    next2 = stackLeft.pop();
                } else {
                    return 0;
                }
            } else {
                next1 = stackRight.pop();
                next2 = stackLeft.pop();
            }
            
            // isn't couple
            if (!isCouple(next2, next1)) {
                stackRight.push(next1);
                stackRight.push(next2);
                continue;
            }
            
        }
        
        if (stackLeft.empty() && stackRight.empty()) {
            return 1;
        } else {
            return 0;
        }
    }
    
    public boolean isCouple(String left, String right) {
        if((left.equals("(") && right.equals(")"))
            || (left.equals("[") && right.equals("]"))
            || (left.equals("{") && right.equals("}"))) {
            return true;
        }
        return false;
    }
}

Task description:

A string S consisting of N characters is considered to be properly nested if any of the following conditions is true:

• S is empty;
• S has the form "(U)" or "[U]" or "{U}" where U is a properly nested string;
• S has the form "VW" where V and W are properly nested strings.

For example, the string "{[()()]}" is properly nested but "([)()]" is not.

Write a function:

class Solution { public int solution(String S); }

that, given a string S consisting of N characters, returns 1 if S is properly nested and 0 otherwise.

For example, given S = "{[()()]}", the function should return 1 and given S = "([)()]", the function should return 0, as explained above.

Assume that:

• N is an integer within the range [0..200,000];
• string S consists only of the following characters: "(", "{", "[", "]", "}" and/or ")".

Complexity:

• expected worst-case time complexity is O(N);
• expected worst-case space complexity is O(N) (not counting the storage required for input arguments).