Number of Atoms - Practice Coding Problems

Number of Atoms - Problem

Imagine you're a chemist working with complex molecular formulas and need to count how many atoms of each element are present. Your task is to parse a chemical formula string and return the count of each atom type.

The formula follows these rules:

Atomic elements start with an uppercase letter, followed by zero or more lowercase letters (e.g., H, Mg, Ca)
Counts appear as digits after the element name. If no digits appear, the count is 1
Parentheses group elements together, and can have a multiplier after the closing parenthesis
Formulas can be concatenated: H2O2He3Mg4 is valid

Goal: Return a string with all elements in alphabetical order, followed by their counts (if > 1).

Examples:

"H2O" → "H2O"
"Mg(OH)2" → "H2MgO2"
"K4(ON(SO3)2)2" → "K4N2O14S4"

Input & Output

example_1.py — Simple Formula

$ Input: formula = "H2O"

› Output: "H2O"

💡 Note: The formula contains 2 hydrogen atoms and 1 oxygen atom. Since oxygen count is 1, it's omitted in the result.

example_2.py — Formula with Parentheses

$ Input: formula = "Mg(OH)2"

› Output: "H2MgO2"

💡 Note: The (OH) group is multiplied by 2, giving us 2 oxygen and 2 hydrogen atoms, plus 1 magnesium atom. Sorted alphabetically: H2MgO2.

example_3.py — Complex Nested Formula

$ Input: formula = "K4(ON(SO3)2)2"

› Output: "K4N2O14S4"

💡 Note: Breaking down: K4 + (ON(SO3)2)2. The inner (SO3)2 gives S2O6, then ON(S2O6) = ONS2O6, and finally (ONS2O6)2 = O2N2S4O12 = N2O14S4. Combined with K4 gives K4N2O14S4.

Constraints

1 ≤ formula.length ≤ 1000
formula consists of English letters, digits, '(', and ')'
formula is always valid
All atom names consist of lowercase letters, except the first character which is uppercase
The sum of all atoms will fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Initialize Base Kitchen

Start with main recipe book (hash map) on the counter

Collect Main Ingredients

Add direct ingredients like K4 to main recipe

Start Sub-Recipe

When encountering '(', open new recipe book for the sub-recipe

Collect Sub-Ingredients

Add ingredients like O, N to the sub-recipe book

Complete Sub-Recipe

When encountering ')2', multiply all sub-recipe ingredients by 2

Merge Back

Combine multiplied sub-recipe ingredients into main recipe book

Final Inventory

Sort all ingredients alphabetically and format the result

Key Takeaway

🎯 Key Insight: Use a stack to mirror the nested structure of parentheses - each opening creates a new scope, each closing multiplies and merges back to the parent scope, enabling efficient single-pass parsing of complex chemical formulas.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a stack-based approach to handle nested parentheses in chemical formulas. By maintaining a stack of hash maps (one per scope level), we can efficiently parse the formula in O(n) time and handle complex nested structures elegantly. When encountering opening parentheses, we push a new scope; when closing, we multiply counts and merge with the parent scope.

Common Approaches

Approach	Time	Space	Notes
✓ String Expansion Approach	O(n²)	O(n²)	Recursively expand all parentheses first, then count atoms
Stack-Based Parsing (Optimal)	O(n)	O(n)	Use stack to handle nested parentheses and parse in single pass

String Expansion Approach — Algorithm Steps

Find innermost parentheses groups
Expand each group by multiplying the contents
Replace the group with expanded form
Repeat until no parentheses remain
Parse the expanded string to count atoms
Sort and format the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Innermost Parentheses

Locate the innermost parenthetical group (OH) in Mg(OH)2

Extract Content and Multiplier

Extract 'OH' as content and '2' as multiplier

Expand Content

OH * 2 becomes O1H1 * 2 = O2H2

Replace in Formula

Replace (OH)2 with O2H2 to get MgO2H2

Count Atoms

Parse MgO2H2 to count: H=2, Mg=1, O=2

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct {
    char element[16];
    int count;
} AtomCount;

char* countOfAtoms(char* formula) {
    // This is a simplified version focusing on the core logic
    AtomCount atoms[1000];
    int atomCount = 0;
    
    int len = strlen(formula);
    int i = 0;
    
    while (i < len) {
        if (isupper(formula[i])) {
            // Extract element name
            int j = i + 1;
            while (j < len && islower(formula[j])) {
                j++;
            }
            
            char element[16];
            strncpy(element, formula + i, j - i);
            element[j - i] = '\0';
            
            // Extract count
            int k = j;
            while (k < len && isdigit(formula[k])) {
                k++;
            }
            
            int count = 1;
            if (k > j) {
                char numStr[16];
                strncpy(numStr, formula + j, k - j);
                numStr[k - j] = '\0';
                count = atoi(numStr);
            }
            
            // Find if element already exists
            int found = 0;
            for (int m = 0; m < atomCount; m++) {
                if (strcmp(atoms[m].element, element) == 0) {
                    atoms[m].count += count;
                    found = 1;
                    break;
                }
            }
            
            if (!found) {
                strcpy(atoms[atomCount].element, element);
                atoms[atomCount].count = count;
                atomCount++;
            }
            
            i = k;
        } else {
            i++;
        }
    }
    
    // Sort atoms alphabetically
    for (int i = 0; i < atomCount - 1; i++) {
        for (int j = i + 1; j < atomCount; j++) {
            if (strcmp(atoms[i].element, atoms[j].element) > 0) {
                AtomCount temp = atoms[i];
                atoms[i] = atoms[j];
                atoms[j] = temp;
            }
        }
    }
    
    // Build result string
    char* result = malloc(10000);
    result[0] = '\0';
    
    for (int i = 0; i < atomCount; i++) {
        strcat(result, atoms[i].element);
        if (atoms[i].count > 1) {
            char countStr[16];
            sprintf(countStr, "%d", atoms[i].count);
            strcat(result, countStr);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each expansion can create a string of length proportional to n, and we may need to do this multiple times

⚠ Quadratic Growth

Space Complexity

O(n²)

String expansions can create intermediate strings much larger than the input

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

String Expansion Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler