How Many Atoms?

Question

Your task is when given a chemical formula as input, output the total number of atoms in the formula.

Input

A chemical formula in any reasonable format. Each chemical formula has the following:

• A leading coefficient, which is a number \$N > 1\$.
• At least 0 groupings of elements surrounded by parentheses.
  • Groupings can have both elements and groupings inside of them.
• At least 1 element.
  • Elements match the regex [A-Z][a-z]*.
• Each grouping and element can have an optional subscript, which is an _ followed by a number \$N > 1\$

Output

The total number of atoms in the formula. Rules for counting are as follows:

• A coefficient before the formula multiplies the total count that many times.
• A subscript multiples the group or atom it follows that many times.
• An element with no coefficient or subscript represents 1 atom.

Testcases

In -> Out (Notes)
H_2O -> 3
CO_2 -> 3
Co_2 -> 2 (2 cobalts)
3 C_2H -> 9
EeeEeuEetUue -> 4
3 (C_21H_30O_2)_3 -> 477 (= 3 * (53) * 3)
32H -> 32
C_10H_16N_5O_13P_3 -> 47
(Ga(U(Y_2)_3)_4)_5 -> 145 (= (1 + (1 + (2 * 3)) * 4) * 5)
Ti(Ca_2(HSO_4)_2)_2 -> 29 (= 1 + (2 + (1 + 1 + 4) * 2) * 2))

This is code-golf, so shortest code wins!

Answer 1

JavaScript (ES6), 87 bytes

s=>eval(s.replace(/[A-Z][a-z]*|_|^\d+|\(/g,s=>+s?`n=${s};n*=`:s>{}?"*":"+"+(s>"0"||s)))

Try it online!

How?

Matched patterns and replacements are summarized in the following table.

 pattern     | replacement
-------------+-------------------------------------------
 [A-Z][a-z]* | "+true"
 _           | "*"
 ^\d+        | "n=N;n*=" (where N is the matched number)
 \(          | "+("

For instance, "3 (C_21H_30O_2)_3" is turned into:

"n=3;n*= +(+true*21+true*30+true*2)*3"

This string is simply evaluated as JS code.

Answer 2

Retina 0.8.2, 81 79 bytes

\d+
$*
(1+) (.+)
($2)_$1
[A-Z][a-z]*(_|())
$#2$*
+1`(\((1+)\)_)1|\(1+\)_
$2$1
1

Try it online! Link includes test cases. Explanation:

\d+
$*

Convert the numbers to unary.

(1+) (.+)
($2)_$1

Turn any coefficient into a group.

[A-Z][a-z]*(_|())
$#2$*

Delete all elements with suffixes, but if an element did not have a suffix, then replace it with 1.

+1`(\((1+)\)_)1|\(1+\)_
$2$1

Multiply out all of the groupings. (These have to be done one at a time to be able to collect the results correctly.)

1

Convert to decimal.

Answer 3

Perl 5 -p, 57 bytes

y/_a-z/*/d;s/^\d+\K.*/*($&)/;s/\pL/+1/g;s/\(/+(/g;$_=eval

Try it online!

Answer 4

Ruby, 88 bytes

A port of Arnauld's answer in Ruby!

p eval gsub(/_|\(/,?_=>?*,?(=>'+(').gsub(/[A-Z][a-z]*/,'+1').gsub /^\d+/,"k=#{'\&'};k*="

Try it online!

Answer 5

PHP, 111 bytes

eval('$n='.preg_replace(["/^(\d+)/","/[A-Z][a-z]*/","/_/","/\(/"],['$1;$n*=',"+1","*","+("],$argn).';');echo$n;

Try it online!

Just a port of Arnauld's clever trick with eval and some adaptations:

• in PHP it was shorter to use a list of regexes instead of using preg_replace_callback (what a long function name)
• the evaled string has to be valid php prefixed with $n= and ended by ; (in PHP eval does not return the result), example with "Ti(Ca_2(HSO_4)_2)_2": $n=+1+(+1*2+(+1+1+1*4)*2)*2;
• output of $n has to be explicit

Longer than what I thought, but "c'est de bonne guerre ma bonne dame", it's our good old PHP after all

Answer 6

PowerShell, 92 bytes

I think there's definitely some room for optimization here; A lot of the bytes are just there to handle the cases with the leading "\d "

$t=1;-split$args|%{$t*=$_-replace'\(','+('-creplace'[A-Z][a-z]*','+1'-replace'_','*'|iex};$t

Try it online!

Honorary Mention, PowerShell, 99 92 bytes

This was my first solution, and I really liked it. Including it here because I think it's fun.

$o="'-creplace'";"'$args$o^(\d)(.*)','`$1*(`$2)$o\(','+($o[A-Z][a-z]*','+1$o`_','*'"|iex|iex

Try it online!

Answer 7

PowerShell, 84 83 88 bytes

inspired by Honorary Mentioned Solution by Zaelin Goodman

-1 byte thanks to Zaelin Goodman

+5 bytes the 32H test case added

$o="'-creplace'"
"'$args$o^\d+','`$0*($'')#$o\(','+($o[A-Z][a-z]*','+1$o`_','*'"|iex|iex

Try it online!

Powershell expands the formula 32H to:

'32H'-creplace'^\d+','$0*($'')#'-creplace'\(','+('-creplace'[A-Z][a-z]*','+1'-creplace'_','*'

The first iex calculates this expression to:

32*+(+1)#+1

The second iex calculates the expression before the comment to 32.

---

Another example. Powershell expands the formula 3 (C_21H_30O_2)_3 to:

'3 (C_21H_30O_2)_3'-creplace'^\d+','$0*($'')#'-creplace'\(','+('-creplace'[A-Z][a-z]*','+1'-creplace'_','*'

The first iex calculates this expression to:

3*+( +(+1*21+1*30+1*2)*3)# +(+1*21+1*30+1*2)*3

The second iex calculates the expression before the comment to 477.

Answer 8

05AB1E, 39 37 bytes

AмAuS„+1:'_'*:'(„+(.:.γd}ćDdi'*«}šJ.E

Similar approach as the other answers, except without regex. Especially the ^\d+ to N* therefore costs quite a few bytes (16 to be exact: .γd}ćDdi'*«}šJ).

Try it online or verify all test cases.

Explanation:

Aм           # Remove all lowercase letters from the (implicit) input-string
AuS„+1:      # Replace all uppercase letters with "+1"
'_'*:        # Replace all "_" with "*"
'(„+(.:     '# Replace all "(" with "+("
.γ }         # Adjacent group the string by:
  d          #  Whether it's a digit
    ć        # Extract head; pop and push the remainder-list and first item
             # separated to the stack
     D       # Duplicate this first item
      di     # Pop, and if it's a (non-negative) integer:
        '*« '#  Append "*" to it
       }     # After the if-statement:
        š    # Prepend the potentially modified first item back to the list
         J   # Join everything together again
.E           # And evaluate and execute it as Python code
             # (after which the result is output implicitly)

Verify all test cases without the .E.