726. Number of Atoms FetchNum从字符串中Parse数

最新推荐文章于 2024-06-28 20:15:27 发布

taoqick

最新推荐文章于 2024-06-28 20:15:27 发布

阅读量239

点赞数

CC 4.0 BY-SA版权

分类专栏：算法 python3 leetcode

本文链接：https://blog.youkuaiyun.com/taoqick/article/details/106967783

算法同时被 3 个专栏收录

475 篇文章

订阅专栏

leetcode

231 篇文章

订阅专栏

python3

120 篇文章

订阅专栏

本文介绍了一种使用Python实现的化学公式解析算法，该算法能够准确地解析化学公式并计算出每种原子的数量。通过使用栈和递归的思想，算法能够处理复杂的嵌套括号和原子计数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a chemical formula (given as a string), return the count of each atom.

An atomic element always starts with an uppercase character, then zero or more lowercase letters, representing the name.

1 or more digits representing the count of that element may follow if the count is greater than 1. If the count is 1, no digits will follow. For example, H2O and H2O2 are possible, but H1O2 is impossible.

Two formulas concatenated together produce another formula. For example, H2O2He3Mg4 is also a formula.

A formula placed in parentheses, and a count (optionally added) is also a formula. For example, (H2O2) and (H2O2)3 are formulas.

Given a formula, output the count of all elements as a string in the following form: the first name (in sorted order), followed by its count (if that count is more than 1), followed by the second name (in sorted order), followed by its count (if that count is more than 1), and so on.

Example 1:

Input: 
formula = "H2O"
Output: "H2O"
Explanation: 
The count of elements are {'H': 2, 'O': 1}.

Example 2:

Input: 
formula = "Mg(OH)2"
Output: "H2MgO2"
Explanation: 
The count of elements are {'H': 2, 'Mg': 1, 'O': 2}.

Example 3:

Input: 
formula = "K4(ON(SO3)2)2"
Output: "K4N2O14S4"
Explanation: 
The count of elements are {'K': 4, 'N': 2, 'O': 14, 'S': 4}.

Note:

All atom names consist of lowercase letters, except for the first character which is uppercase.
The length of formula will be in the range [1, 1000].
formula will only consist of letters, digits, and round parentheses, and is a valid formula as defined in the problem.

-------------------------------------------------------------

用栈或者递归的思路很容易想到，这种问题的坑就是在于从字符串里parse数或者atom，简单起见可以先写主函数，麻烦操作用个函数，后面再补：

from collections import defaultdict
class Solution:
    def countOfAtoms(self, formula: str) -> str:
        l,sta,i = len(formula),[defaultdict(int)],0
        def fetch_num(off):
            nonlocal l,formula
            i,res = off,""
            while (i < l):
                if ("0"<=formula[i]<="9"):
                    res += formula[i]
                else:
                    break
                i += 1
            return (int(res),i) if res else (1,i)

        def fetch_atom(off):
            nonlocal l,formula
            i,res = off+1,formula[off]
            while (i < l):
                if ("a"<=formula[i]<="z"):
                    res += formula[i]
                else:
                    break
                i += 1
            return res,i

        while (i < l):
            if (formula[i] == '('):
                sta.append(defaultdict(int))
                i += 1
            elif (formula[i] == ')'):
                num,i = fetch_num(i+1)
                for k in sta[-1].keys():
                    sta[-1][k] *= num
                if (len(sta) >= 2):
                    top = sta.pop()
                    for k in top.keys():
                        sta[-1][k] += top[k]
            elif ("A"<=formula[i]<="Z"):
                atom,i = fetch_atom(i)
                num,i = fetch_num(i)
                sta[-1][atom] += num
        res = ""
        for key in sorted(sta[-1].keys()):
            val = sta[-1][key]
            pair = key if val == 1 else "{0}{1}".format(key,val)
            res += pair
        return res

s = Solution()
print(s.countOfAtoms("H2O"))

后来发现讨论区有大哥逆序搞，虽然代码短了，但是这种思路并不提倡，容易乱：

class Solution:
    def countOfAtoms(self, formula):
        dic, coeff, stack, elem, cnt, i = collections.defaultdict(int), 1, [], "", 0, 0  
        for c in formula[::-1]:
            if c.isdigit():
                cnt += int(c) * (10 ** i)
                i += 1
            elif c == ")":
                stack.append(cnt)
                coeff *= cnt
                i = cnt = 0
            elif c == "(":
                coeff //= stack.pop()
                i = cnt = 0
            elif c.isupper():
                elem += c
                dic[elem[::-1]] += (cnt or 1) * coeff
                elem = ""
                i = cnt = 0
            elif c.islower():
                elem += c
        return "".join(k + str(v > 1 and v or "") for k, v in sorted(dic.items()))