LeetCode--To Lower Case && Remove Outermost Parentheses (Easy)

709. To Lower Case（Easy）#

Implement function ToLowerCase() that has a string parameter str, and returns the same string in lowercase.

Example 1:

Input: "Hello"
Output: "hello"
Example 2:

Input: "here"
Output: "here"
Example 3:

Input: "LOVELY"
Output: "lovely"

Note:
there are many other characters,such as '&".

solution##

class Solution {
    public String toLowerCase(String str) {
        StringBuilder s  = new StringBuilder();
        for (int i=0; i<str.length(); i++)
        {
            if ('a' <= str.charAt(i) && str.charAt(i) <='z')
                s.append(str.charAt(i));
            else if ('A' <= str.charAt(i) && str.charAt(i) <='Z')
                s.append((char)(str.charAt(i) - 'A' + 'a'));
            else
                s.append(str.charAt(i));
        }
        return s.toString();
    }
}

总结##

此题思路很简单，遍历给定字符串，如果字母为大写字母，则变为小写字母后用一个字符串变量存起来，否则直接将小写字母或其他字符存起来。
Notes：
1.用StringBuilder类更省空间；
2.两个字符相加减得到的结果为int型数值，要转为字符必须用(char)强制转换，比如char c = (char)97，得到的结果为c=a;
3.字符拼接一般用StringBuilder类的append()方法;

1021. Remove Outermost Parentheses (Easy)#

A valid parentheses string is either empty (""), "(" + A + ")", or A + B, where A and B are valid parentheses strings, and + represents string concatenation.  For example, "", "()", "(())()", and "(()(()))" are all valid parentheses strings.

A valid parentheses string S is primitive if it is nonempty, and there does not exist a way to split it into S = A+B, with A and B nonempty valid parentheses strings.

Given a valid parentheses string S, consider its primitive decomposition: S = P_1 + P_2 + ... + P_k, where P_i are primitive valid parentheses strings.

Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.

 
Example 1:

Input: "(()())(())"
Output: "()()()"
Explanation: 
The input string is "(()())(())", with primitive decomposition "(()())" + "(())".
After removing outer parentheses of each part, this is "()()" + "()" = "()()()".
Example 2:

Input: "(()())(())(()(()))"
Output: "()()()()(())"
Explanation: 
The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))".
After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".
Example 3:

Input: "()()"
Output: ""
Explanation: 
The input string is "()()", with primitive decomposition "()" + "()".
After removing outer parentheses of each part, this is "" + "" = "".
 
Note:

S.length <= 10000
S[i] is "(" or ")"
S is a valid parentheses string

solution##

class Solution {
    public String removeOuterParentheses(String S) {
        StringBuilder s = new StringBuilder();
        int k = 0;
        for (int i=0; i<S.length(); i++)
        {
            if (S.charAt(i) == '(')
            {
                if (k > 0)
                    s.append('(');
                k++;
            }
            if (S.charAt(i) == ')')
            {
                k--;
                if (k > 0)
                    s.append(')');
            }
        }
        return s.toString();  //return a string
    }
}

总结##

此题我最初的想法是用栈，后来发现只需要用栈的思想就够了，只需用一个计数器k和一个字符串变量s。当遇到左括号时，先判断k>0是否成立，如果成立，则将左括号存入字符串s，否则什么都不做，随后计数器k++；当遇到右括号时，先计数器k--，再判断k>0是否成立，如果成立，则将右括号存入字符串s，否则什么都不做。

Notes：
1.此题又是用StringBuilder类进行字符连接，返回值需要用toString()方法转为字符串。