ccf--201912-3化学方程式--python

╰半夏微凉° 2023-07-11 11:25 3阅读 0赞

### 答题情况 ###

这道题只拿了70分，剩余的30分提示错误，但我也没琢磨明白什么情况没有考虑到。

### 思路 ###

首先从"=“两边分开，以左边的为例，再从”+"分开，逐个分析化学式，左右两边各用一个字典来存储元素个数，最后比较字典是否相同。  
以这个为例：Ca(OH(CH)2)2A3=CaA3O2H6C5  
主要使用到正则表达式，首先字符串为Ca(OH(CH)2)2A3，取最前面的系数，没有则为1，这里确实没有系数，字符串不变，然后依次检查左括号，右括号，单字母元素，双字母元素，这里匹配到了Ca，而且他前面没有括号，后边没有数字(匹配括号和元素都会匹配后面的数字)，所以就直接在字典里存储dict\[‘Ca’\]+=最前面系数\*元素后面的系数，这里均为1，然后游标加上匹配到的长度，字符串变为(OH(CH)2)2A3，接下来会匹配到’(’,这时左括号数量加1，如果左括号后边有数字的话，也会保存在一个列表里，继续进行匹配，直到匹配到CH)2)2A3，匹配到C这个元素时，因为他前面有两个括号，我们不能把他放入字典中，把他的信息放入一个列表里，(元素名称，元素后面的系数，左括号数量-右括号数量)，比如C这个元素，前面有两个左括号，没有右括号，所以应该与前面两个右括号里的数字相乘，这里我们也保存了右括号里的数字。等到字符串遍历完，就可以去处理括号里的元素了。右边的化学式也是这样处理。  
代码写的比较啰嗦，没有用函数封装，只需要看左边如何处理就行，右边的是copy左边的，只是换了一下字典。等有时间，优化一下代码，思考剩下三十分如何回事。有什么问题，欢迎大佬敬请指出。

### 代码 ###

import re
    from collections import defaultdict
    from functools import reduce
    
    num = int(input())
    
    coeff_num_pattern = re.compile('\d*')
    left_bracket_pattern = re.compile('(\()(\d*)')
    right_bracket_num_pattern = re.compile('(\))(\d*)')
    single_ele_num_pattern = re.compile('([A-Z])(?![a-z])(\d*)')
    double_ele_num_pattern = re.compile('([A-Z][a-z])(\d*)')
    
    for j in range(num):
        s = input()
        dic_l = defaultdict(lambda: 0)
        dic_r = defaultdict(lambda: 0)
        s_l, s_r = s.split('=')
        s_l = s_l.split('+')
        s_r = s_r.split('+')
        for ele in s_l:
            coeff_num = coeff_num_pattern.match(ele)
            cur = 0
            left_bracket_cnt = 0
            right_bracket_cnt = 0
            left_bracket_num_lst = []
            right_bracket_num_lst = []
            ele_bracket_lst = []
            if((coeff_num.span()[1] - coeff_num.span()[0]) != 0):
                cur += coeff_num.span()[1]
                coeff_num = int(coeff_num.group())
            else:
                coeff_num = 1
            while(ele[cur:] != ''):
                if(left_bracket_pattern.match(ele[cur:])):
                    left_bracket_cnt += 1
                    temp = left_bracket_pattern.match(ele[cur:])
                    if(temp.group(2)):
                        left_bracket_num_lst.append(int(temp.group(2)))
                    else:
                        left_bracket_num_lst.append(1)
                    cur += temp.span()[1]
                elif(right_bracket_num_pattern.match(ele[cur:])):
                    right_bracket_cnt += 1
                    temp = right_bracket_num_pattern.match(ele[cur:])
                    if(temp.group(2)):
                        right_bracket_num_lst.append(int(temp.group(2)))
                    else:
                        right_bracket_num_lst.append(1)
                    cur += temp.span()[1]
                elif(single_ele_num_pattern.match(ele[cur:])):
                    temp = single_ele_num_pattern.match(ele[cur:])
                    single_ele = temp.group(1)
                    if(temp.group(2)):
                        single_ele_num = int(temp.group(2))
                    else:
                        single_ele_num = 1
                    cur += temp.span()[1]
                    if(left_bracket_cnt > right_bracket_cnt):
                        ele_bracket_lst.append([single_ele,single_ele_num,left_bracket_cnt-right_bracket_cnt])
                    else:
                        dic_l[single_ele] += coeff_num*single_ele_num
                elif(double_ele_num_pattern.match(ele[cur:])):
                    temp = double_ele_num_pattern.match(ele[cur:])
                    double_ele = temp.group(1)
                    if(temp.group(2)):
                        double_ele_num = int(temp.group(2))
                    else:
                        double_ele_num = 1
                    cur += temp.span()[1]
                    if(left_bracket_cnt > right_bracket_cnt):
                        ele_bracket_lst.append([double_ele,double_ele_num,left_bracket_cnt-right_bracket_cnt])
                    else:
                        dic_l[double_ele] += coeff_num*double_ele_num
            for k in ele_bracket_lst:
                dic_l[k[0]] += coeff_num * k[1] * reduce(lambda x,y:x*y,right_bracket_num_lst[::-1][:k[2]]) * reduce(lambda x,y:x*y,left_bracket_num_lst[::-1][:k[2]])
        for ele in s_r:
            coeff_num = coeff_num_pattern.match(ele)
            cur = 0
            left_bracket_cnt = 0
            right_bracket_cnt = 0
            right_bracket_num_lst = []
            ele_bracket_lst = []
            if ((coeff_num.span()[1] - coeff_num.span()[0]) != 0):
                cur += coeff_num.span()[1]
                coeff_num = int(coeff_num.group())
            else:
                coeff_num = 1
            while (ele[cur:] != ''):
                if (left_bracket_pattern.match(ele[cur:])):
                    left_bracket_cnt += 1
                    temp = left_bracket_pattern.match(ele[cur:])
                    if (temp.group(2)):
                        left_bracket_num_lst.append(int(temp.group(2)))
                    else:
                        left_bracket_num_lst.append(1)
                    cur += temp.span()[1]
                elif (right_bracket_num_pattern.match(ele[cur:])):
                    right_bracket_cnt += 1
                    temp = right_bracket_num_pattern.match(ele[cur:])
                    if (temp.group(2)):
                        right_bracket_num_lst.append(int(temp.group(2)))
                    else:
                        right_bracket_num_lst.append(1)
                    cur += temp.span()[1]
                elif (single_ele_num_pattern.match(ele[cur:])):
                    temp = single_ele_num_pattern.match(ele[cur:])
                    single_ele = temp.group(1)
                    if (temp.group(2)):
                        single_ele_num = int(temp.group(2))
                    else:
                        single_ele_num = 1
                    cur += temp.span()[1]
                    if (left_bracket_cnt > right_bracket_cnt):
                        ele_bracket_lst.append([single_ele, single_ele_num, left_bracket_cnt - right_bracket_cnt])
                    else:
                        dic_r[single_ele] += coeff_num * single_ele_num
                elif (double_ele_num_pattern.match(ele[cur:])):
                    temp = double_ele_num_pattern.match(ele[cur:])
                    double_ele = temp.group(1)
                    if (temp.group(2)):
                        double_ele_num = int(temp.group(2))
                    else:
                        double_ele_num = 1
                    cur += temp.span()[1]
                    if (left_bracket_cnt > right_bracket_cnt):
                        ele_bracket_lst.append([double_ele, double_ele_num, left_bracket_cnt - right_bracket_cnt])
                    else:
                        dic_r[double_ele] += coeff_num * double_ele_num
            for k in ele_bracket_lst:
                dic_r[k[0]] += coeff_num * k[1] * reduce(lambda x,y:x*y,right_bracket_num_lst[::-1][:k[2]]) * reduce(lambda x,y:x*y,left_bracket_num_lst[::-1][:k[2]])
        worng_flag = 0
        if (len(dic_l) != len(dic_r)):
            print('N')
            worng_flag = 1
        else:
            for i in dic_l:
                if (i not in dic_r):
                    print('N')
                    worng_flag = 1
                    break
                else:
                    if (dic_l[i] != dic_r[i]):
                        print('N')
                        worng_flag = 1
                        break
        if (worng_flag == 0):
            print('Y')

欢迎关注公众号，一起交流

![公众号二维码.jpg][.jpg]

[.jpg]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3MS5zaW5haW1nLmNuL2xhcmdlLzAwNkNVNmxSbHkxZ2NqMjNzcHJ2MWozMDc2MDc2ZGdiLmpwZw?x-oss-process=image/format,png#pic_center