Number of Atoms

class Solution {
public:
    string atomCounter(string expression) {
        // Regular expression to match components of the chemical formula
        regex expr("([A-Z][a-z]*)(\\d*)|(\\()|(\\))(\\d*)");
        sregex_iterator current(expression.begin(), expression.end(), expr);
        sregex_iterator end_iter;
        vector<tuple<string, string, string, string, string>> elements;
        while (current != end_iter) {
            elements.push_back(
                {(*current)[1], (*current)[2], (*current)[3], (*current)[4], (*current)[5]});
            current++;
        }
        reverse(elements.begin(), elements.end());
    
        // Hash map to count occurrences of each atom
        unordered_map<string, int> atomMap;
    
        // Stack to manage multiplication due to nesting
        stack<int> multipliers;
        multipliers.push(1);
    
        // Current multiplication factor
        int currentMult = 1;
    
        // Processing gathered elements
        for (auto& element : elements) {
            string atom = get<0>(element);
            string num = get<1>(element);
            string openBrace = get<2>(element);
            string closeBrace = get<3>(element);
            string factor = get<4>(element);
    
            // Process atoms
            if (!atom.empty()) {
                int atomicCount = num.empty() ? 1 : stoi(num);
                atomMap[atom] += atomicCount * currentMult;
            }
    
            // Adjust multipliers on encountering a close parenthesis
            else if (!closeBrace.empty()) {
                int multFactor = factor.empty() ? 1 : stoi(factor);
                currentMult *= multFactor;
                multipliers.push(multFactor);
            }
    
            // Reset multipliers on encountering an open parenthesis
            else if (!openBrace.empty()) {
                currentMult /= multipliers.top();
                multipliers.pop();
            }
        }
    
        // Sorting map entries to generate result
        map<string, int> sortedAtoms(atomMap.begin(), atomMap.end());
    
        // Composing the result string
        string result;
        for (auto& [atom, count] : sortedAtoms) {
            result += atom;
            if (count > 1) {
                result += to_string(count);
            }
        }
    
        return result;
    }
};

import java.util.regex.*;
    
class Solution {
    
    public String atomCounts(String formula) {
        // Creating a regex Matcher for formula processing.
        Matcher matcher = Pattern.compile(
            "([A-Z][a-z]*)(\\d*)|(\\()|(\\))(\\d*)"
        ).matcher(formula);
        List<String[]> elements = new ArrayList<>();
        while (matcher.find()) {
            elements.add(
                new String[] {
                    matcher.group(1),
                    matcher.group(2),
                    matcher.group(3),
                    matcher.group(4),
                    matcher.group(5),
                }
            );
        }
        Collections.reverse(elements);
    
        // Dictionary to maintain element counts
        Map<String, Integer> elementCounts = new HashMap<>();
    
        // Stack to manage multipliers for nested structures
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
    
        // Variable for current multiplier
        int currentMultiplier = 1;
    
        // Iterating over reversed element list
        for (String[] element : elements) {
            String el = element[0];
            String num = element[1];
            String openBrace = element[2];
            String closeBrace = element[3];
            String braceMultiplier = element[4];
    
            // Process each atom and compute counts
            if (el != null) {
                int qty = num.isEmpty() ? 1 : Integer.parseInt(num);
                elementCounts.put(
                    el,
                    elementCounts.getOrDefault(el, 0) + qty * currentMultiplier
                );
            }
            // Process closing parenthesis and adjust the multiplier
            else if (closeBrace != null) {
                int multiplier = braceMultiplier.isEmpty()
                    ? 1
                    : Integer.parseInt(braceMultiplier);
                currentMultiplier *= multiplier;
                stack.push(multiplier);
            }
            // Process opening parenthesis to reset current multiplier
            else if (openBrace != null) {
                currentMultiplier /= stack.pop();
            }
        }
    
        // Sorting the map to create the final string.
        TreeMap<String, Integer> sortedElements = new TreeMap<>(elementCounts);
    
        // Build the final atom count string.
        StringBuilder result = new StringBuilder();
        for (String el : sortedElements.keySet()) {
            result.append(el);
            if (sortedElements.get(el) > 1) {
                result.append(sortedElements.get(el));
            }
        }
    
        return result.toString();
    }
}

class Solution:
    def atomCount(self, formula_input: str) -> str:
        # Find all matching atoms, numbers, and parentheses
        extraction = re.findall(r"([A-Z][a-z]*)(\d*)|(\()|(\))(\d*)", formula_input)
        extraction.reverse()
    
        # Dictionary to store element counts
        atom_dict = defaultdict(int)
    
        # Stack for managing multipliers from nested parentheses
        mul_stack = [1]
    
        # Current multiplicative factor
        current_factor = 1
    
        # Processing each extracted element or group
        for element, num, open_br, close_br, group_multiplier in extraction:
            if element:
                num = int(num) if num else 1
                atom_dict[element] += num * current_factor
            elif close_br:
                group_multiplier = int(group_multiplier) if group_multiplier else 1
                current_factor *= group_multiplier
                mul_stack.append(group_multiplier)
            elif open_br:
                current_factor //= mul_stack.pop()
    
        # Sort dictionary by element names
        atom_dict = dict(sorted(atom_dict.items()))
    
        # Create output string
        result = ""
        for key in atom_dict:
            result += key
            if atom_dict[key] > 1:
                result += str(atom_dict[key])
    
        return result