CodeWarsSolutions/src/main/java/ParseMolecule.java at master · dezik/CodeWarsSolutions · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ParseMolecule {
    static Map<Character, Character> brackets = new HashMap<>();

    static {
        brackets.put('{', '}');
        brackets.put('(', ')');
        brackets.put('[', ']');
    }

    public static Map<String, Integer> getAtoms(String formula) {
        Map<String, Integer> map = fillMapWithElements(formula);
        for (String s : map.keySet()) {
            map.put(s, map.get(s) + getElementCount(formula, s));
        }
        return map;
    }

    private static Map<String, Integer> fillMapWithElements(String str) {
        Map<String, Integer> map = new HashMap<>();
        Matcher matcher = Pattern.compile("[A-Z][a-z]|[A-Z]").matcher(str);
        while (matcher.find()) {
            map.put(matcher.group(), 0);
        }
        if (map.size() == 0) throw new IllegalArgumentException();
        return map;
    }

    private static int insideOfBrackets(String str, String element) {
        int startPosition = str.indexOf(element);
        int multiplicand = getInitialMultiplicand(str, startPosition);
        for (int i = startPosition - 1; i > 0; i--) {
            boolean valid = false;
            if (brackets.containsKey(str.charAt(i))) {
                for (int j = startPosition + 1; j < str.length(); j++) {
                    if (brackets.get(str.charAt(i)) == str.charAt(j)) {
                        valid = true;
                        if (j < str.length() - 1 && Character.isDigit(str.charAt(j + 1))) {
                            multiplicand *= Character.getNumericValue(str.charAt(j + 1));
                            break;
                        }
                    }
                }
                if (!valid) throw new IllegalArgumentException();
            }
        }
        return multiplicand;
    }

    private static int getInitialMultiplicand(String str, int startPosition) {
        String initialMultiplicand = "";
        for (int i = startPosition + 1; i < str.length(); i++) {
            if (Character.isDigit(str.charAt(i))) initialMultiplicand += str.charAt(i);
            else break;
        }
        return initialMultiplicand.length() == 0 ? 1 : Integer.parseInt(initialMultiplicand);
    }

    private static int getElementCount(String str, String element) {
        int out = 0;
        while (str.contains(element)) {
            out += insideOfBrackets(str, element);
            str = str.replaceFirst(element, "");
        }
        return out;
    }
}

//    public static Map<String, Integer> getAtoms(String formula) {
//        Map<String, Integer> map = fillMapWithElements(formula);
//        for (String s : map.keySet()) {
//            map.put(s, map.get(s) + getElementCount(formula, s));
//        }
//        return map;
//    }
//
//    private static Map<String, Integer> fillMapWithElements(String str) {
//        Map<String, Integer> map = new HashMap<>();
//        Matcher matcher = Pattern.compile("[A-Z][a-z]|[A-Z]").matcher(str);
//        while (matcher.find()) {
//            map.put(matcher.group(), 0);
//        }
//        if (map.size() == 0) throw new IllegalArgumentException();
//        return map;
//    }
//
//    private static boolean insideOfBrackets(String str, String element) {
//        List<Character> openBrackets = Arrays.asList('(', '{', '[');
//        for (int i = 0; i < str.indexOf(element); i++) {
//            if (openBrackets.contains(str.charAt(i))) return true;
//        }
//        return false;
//    }
//
//    private static int getElementCount(String str, String element) {
//        int count = 1;
//        if (insideOfBrackets(str, element)) {
//            List<Character> closeBrackets = Arrays.asList(')', '}', ']');
//            for (int i = str.indexOf(element); i < str.length(); i++) {
//                if (closeBrackets.contains(str.charAt(i))) {
//                    if (i < str.length() - 1 && Character.isDigit(str.charAt(i + 1))) count *= Character.getNumericValue(str.charAt(i + 1));
//                }
//            }
//        } else if (str.lastIndexOf(element) < str.length() - 1 ) {
//            char nextToElementChar = str.charAt(str.lastIndexOf(element) + 1);
//            if (Character.isDigit(nextToElementChar)) return Character.getNumericValue(nextToElementChar);
//        }
//        return count;
//    }