package com.fishercoder.solutions;

import java.util.ArrayList;
import java.util.List;

/**1021. Remove Outermost Parentheses
 *
 * 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
 * */
public class _1021 {
    public static class Solution1 {
        public String removeOuterParentheses(String S) {
            List<String> primitives = new ArrayList<>();
            for (int i = 1; i < S.length(); i++) {
                int initialI = i - 1;
                int left = 1;
                while (i < S.length() && left > 0) {
                    if (S.charAt(i) == '(') {
                        left++;
                    } else {
                        left--;
                    }
                    i++;
                }
                primitives.add(S.substring(initialI, i));
            }
            StringBuilder sb = new StringBuilder();
            for (String primitive : primitives) {
                sb.append(primitive.substring(1, primitive.length() - 1));
            }
            return sb.toString();
        }
    }
}

@@ -85,1597 +85,8 @@
 t;%0A%0A
-/**1021. Remove Outermost Parentheses%0A *%0A * A valid parentheses string is either empty (%22%22), %22(%22 + A + %22)%22, or A + B, where A and B are valid parentheses strings, and + represents string concatenation.  For example, %22%22, %22()%22, %22(())()%22, and %22(()(()))%22 are all valid parentheses strings.%0A *%0A * 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.%0A *%0A * 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.%0A *%0A * Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.%0A *%0A *%0A * Example 1:%0A * Input: %22(()())(())%22%0A * Output: %22()()()%22%0A * Explanation:%0A * The input string is %22(()())(())%22, with primitive decomposition %22(()())%22 + %22(())%22.%0A * After removing outer parentheses of each part, this is %22()()%22 + %22()%22 = %22()()()%22.%0A *%0A * Example 2:%0A * Input: %22(()())(())(()(()))%22%0A * Output: %22()()()()(())%22%0A * Explanation:%0A * The input string is %22(()())(())(()(()))%22, with primitive decomposition %22(()())%22 + %22(())%22 + %22(()(()))%22.%0A * After removing outer parentheses of each part, this is %22()()%22 + %22()%22 + %22()(())%22 = %22()()()()(())%22.%0A *%0A * Example 3:%0A * Input: %22()()%22%0A * Output: %22%22%0A * Explanation:%0A * The input string is %22()()%22, with primitive decomposition %22()%22 + %22()%22.%0A * After removing outer parentheses of each part, this is %22%22 + %22%22 = %22%22.%0A *%0A * Note:%0A *%0A * S.length %3C= 10000%0A * S%5Bi%5D is %22(%22 or %22)%22%0A * S is a valid parentheses string%0A * */%0A
 publ

refactor 1021