201912 CSP认证 | 回收站选址 化学方程式

原创 已于 2025-05-22 18:24:31 修改 · 376 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#csp认证 #c++

于 2024-03-25 20:09:24 首次发布
文章讲述了作者在C++编程中解决回收站选址问题的过程，使用了STL集合和优化算法处理字符串，尤其是嵌套括号的计数，以及从80分到满分的思路转变。

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

回收站选址
这道题是第一次提交满分，之前是因为数值涉及太大，我不知道怎么存储以及判断会省时一些，就一直没做；这次做用到了STL，也算是做了这么多第三题回看第二题的一些简便吧
在这里插入图片描述

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
set<PII> se;
int res[10];
int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n; cin >> n;

    for(int i = 0;i < n;i ++){
        int x, y; cin >> x >> y;
        se.insert({x, y});
    }

    int idx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
    int idy[] = {0, 0, -1, 1, -1, 1, -1, 1};
    for(auto point : se){
        int x = point.first, y = point.second;
        bool flag = true;
        for(int i = 0;i < 4 && flag;i ++){   //看是否符合要求
            int dx = x + idx[i];
            int dy = y + idy[i];
            if(!se.count({dx, dy})) { flag = false; break; }
        }

        if(flag){   //符合要求的基础上，统计得分
            int cnt = 0;
            for(int i = 4;i < 8;i ++){
                int dx = x + idx[i];
                int dy = y + idy[i];
                if(se.count({dx, dy})) cnt ++;
            }
            res[cnt] ++;
        }
    }
    for(int i = 0;i <= 4;i ++){
        cout << res[i] << endl;
    }
    return 0;
}

化学方程式
第一把官网提交是80分，acwing通过的答案是 9 / 11；先贴出80分的初始代码：

#include<bits/stdc++.h>
#define key first
#define value second
using namespace std;
typedef pair<string, int> PSI;
int to_int(string str)
{
    stringstream ssin(str);
    int x;
    ssin >> x;
    return x;
}
bool upper(char ch)
{
    if(ch >= 'A' && ch <= 'Z') return true;
    return false;
}
bool lower(char ch)
{
    if(ch >= 'a' && ch <= 'z') return true;
    return false;
}
bool number(char ch)
{
    if(ch >= '0' && ch <= '9') return true;
    return false;
}

unordered_map<string, int> cal(string str)
{
    unordered_map<string, int> res;
    vector<string> expr;

    for(int i = 0, j = 0; i < str.size(); i = j + 1){  //将str用'+'分割开来
        j = str.find('+', i);  //从下标i开始找+号
        if(j == -1) j = str.size();
        expr.push_back(str.substr(i, j - i));
    }

    for(auto item : expr){    //对于每一个物质
        unordered_map<string, int> cnt;   //建立一个小的map为了处理好下标乘系数
        int coef = 1, pos = 0;
        if(number(item[0])){   //提取系数
            while(number(item[pos])) pos ++;
            coef = to_int(item.substr(0, pos));
        }
        while(pos < item.size()){
            if(upper(item[pos])){   //元素
                string ele = "";

                if(pos < item.size() - 1 && lower(item[pos + 1])) {   //大写＋小写的组合
                    ele = item[pos] + item[pos + 1];
                    pos += 2;
                }
                else { ele = item[pos]; pos ++; }
                if(pos < item.size() && number(item[pos])){   //如果元素后面跟了数字,则开始找下标
                    int l = pos;
                    while(pos < item.size() && number(item[pos])) pos ++;
                    int x = to_int(item.substr(l, pos));
                    //cout << "ele"<<ele<<"的下标是"<<x<<endl;
                    cnt[ele] += x;
                }
                else cnt[ele] ++;  //出现一次
            }

            else if(item[pos] == '('){  //开始处理括号
                stack<PSI> s;
                s.push({"(", 0}); pos ++;
                unordered_map<string, int> temp;  //是为了处理下标

                while(!s.empty() && pos < item.size()){
                    //跟遇到元素的处理方式其实相同
                    if(upper(item[pos])){   //元素
                        string ele;
                        if(pos < item.size() - 1 && lower(item[pos + 1])) {   //大写＋小写的组合
                            ele = item[pos] + item[pos + 1];
                            pos += 2;
                        }
                        else { ele = item[pos]; pos ++; }
                        int sub = 1;
                        if(pos < item.size() && number(item[pos])){   //元素后面跟了数字
                            int l = pos;
                            while(pos < item.size() && number(item[pos])) pos ++;
                            sub = to_int(item.substr(l, pos));
                        }
                        s.push({ele, sub});   //压入元素
                    }
                    else if(item[pos] == '(')   { s.push({"(", 0}); pos ++; }  //只是入栈不做操作 | 此时不可能是item的末尾,不涉及越界
                    else if(item[pos] == ')'){
                        pos ++; int sub = 1;  //先提取括号外的下标
                        if(pos < item.size() && number(item[pos])){
                            int l = pos;
                            while(pos < item.size() && number(item[pos])) pos ++;
                            sub = to_int(item.substr(l, pos));   //下标更新
                        }

                        //开始弹出,和当前反括号匹配的括号内的元素,都要乘下标
                        auto x = s.top(); s.pop();
                        while(x.key != "("){
                            temp[x.key] += (x.value * sub);
                            x = s.top(); s.pop();
                        }
                    }
                }
                //将temp里的并到cnt里去
                for(auto x : temp){
                    cnt[x.key] += x.value;
                }
            }
        }

        //所有个数都要乘以系数
        for(auto x : cnt){
            res[x.key] = res[x.key] + x.value * coef;
        }
    }
    return res;
}

bool judge(string expr)
{
    unordered_map<string, int> eleft, eright;  //等式左右两侧各一个map
    int i = 0;
    while(expr[i] != '=') i ++;
    string ex1 = expr.substr(0, i);
    string ex2 = expr.substr(i + 1);
    eleft = cal(ex1);
    eright = cal(ex2);
    if(eleft.size() != eright.size()) return false;
    for(auto x : eleft){
        if(eright[x.key] != x.value) return false;
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n; cin >> n;

    string line;
    while(n --){
        cin >> line;
        bool flag = judge(line);
        if(flag) cout << "Y\n";
        else cout << "N\n";
    }
    return 0;
}

做这么几次字符串的题目发现，字符串题目的思维难度其实不大，最大的难点就是很难将所有情况考虑全面，属于是有例子在，完全可以满分；但是会很容易忽略一些细节，导致搜索的过程中提前将答案也过滤掉了
所以这次修改也是基于ACWING的答案上；在比对时我发现了嵌套时出现了这样的问题：
在这里插入图片描述
我简化了左侧的表达式，使得问题更加清楚；K明显不止32个，我之前的做法遗漏了外层括号

在之前的做法中，每遇到一个回括号，我就开始弹出栈内的元素直到遇见（，也就是与之匹配的首部括号，然后根据下标更新括号内的元素数目。
这就是问题所在。栈顶元素按照逻辑是最内层的括号里的元素！它在所有括号的内部。而在上述做法中，这些元素被更新一次就被弹出了，而实际上这些元素应该被更新到最外层的括号截止，才算完成。所以在修改后的做法中，我设置了一个容器先暂存这些弹出的栈顶元素，如果栈非空的话，需要将这些元素弹回（在外层括号的下标还要做乘法）

最终修改得到满分答案，官网截图以及代码如下：
在这里插入图片描述

#include<bits/stdc++.h>
#define key first
#define value second
using namespace std;
typedef pair<string, int> PSI;
//将字串转化为整数
int to_int(string str)
{
    stringstream ssin(str);
    int x;
    ssin >> x;
    return x;
}
//判断是否为大写字母
bool upper(char ch)
{
    if(ch >= 'A' && ch <= 'Z') return true;
    return false;
}
//判断是否为小写字母
bool lower(char ch)
{
    if(ch >= 'a' && ch <= 'z') return true;
    return false;
}
//判断是否为数字
bool number(char ch)
{
    if(ch >= '0' && ch <= '9') return true;
    return false;
}
//计算一个fomular的所有元素及其个数
unordered_map<string, int> cal(string str)
{
    unordered_map<string, int> res;
    vector<string> expr;

    for(int i = 0, j = 0; i < str.size(); i = j + 1){  //将str用'+'分割开来
        j = str.find('+', i);  //从下标i开始找+号
        if(j == -1) j = str.size();
        expr.push_back(str.substr(i, j - i));
    }

    for(auto item : expr){    //对于每一个物质
        unordered_map<string, int> cnt;   //建立一个小的map为了处理好下标乘系数
        int coef = 1, pos = 0;
        if(number(item[0])){   //提取系数
            while(number(item[pos])) pos ++;
            coef = to_int(item.substr(0, pos));
        }
        while(pos < item.size()){   //分析物质
            if(upper(item[pos])){   //元素
                string ele = "";

                if(pos < item.size() - 1 && lower(item[pos + 1])) {   //大写＋小写的组合
                    ele = item[pos] + item[pos + 1];
                    pos += 2;
                }
                else { ele = item[pos]; pos ++; }
                if(pos < item.size() && number(item[pos])){   //如果元素后面跟了数字,则开始找下标
                    int l = pos;
                    while(pos < item.size() && number(item[pos])) pos ++;
                    int x = to_int(item.substr(l, pos));
                    cnt[ele] += x;
                }
                else cnt[ele] ++;  //出现一次
            }

            else if(item[pos] == '('){  //开始处理括号
                stack<PSI> s;    //s中压入括号，或者括号内的元素及其出现次数
                s.push({"(", 0}); pos ++;
                vector<PSI> temp;   //栈顶弹出元素暂存区

                while(!s.empty() && pos < item.size()){
                    //跟遇到元素的处理方式其实相同
                    if(upper(item[pos])){   //出现元素
                        string ele;
                        if(pos < item.size() - 1 && lower(item[pos + 1])) {   //大写＋小写的组合
                            ele = item[pos] + item[pos + 1];
                            pos += 2;
                        }
                        else { ele = item[pos]; pos ++; }
                        int sub = 1;
                        if(pos < item.size() && number(item[pos])){   //元素后面跟了数字
                            int l = pos;
                            while(pos < item.size() && number(item[pos])) pos ++;
                            sub = to_int(item.substr(l, pos));
                        }
                        s.push({ele, sub});   //压入元素及其个数
                    }
                    else if(item[pos] == '(')   { s.push({"(", 0}); pos ++; }  //只是入栈不做操作 | 此时不可能是item的末尾,不涉及越界
                    else if(item[pos] == ')'){
                        pos ++; int sub = 1;  //先提取括号外的下标
                        if(pos < item.size() && number(item[pos])){
                            int l = pos;
                            while(pos < item.size() && number(item[pos])) pos ++;
                            sub = to_int(item.substr(l, pos));   //下标更新
                        }

                        //开始弹出,和当前反括号匹配的括号内的元素,都要乘下标
                        auto x = s.top(); s.pop();
                        while(x.key != "("){
                            x.value *= sub;
                            temp.push_back(x);   //暂存到temp中去
                            x = s.top(); s.pop();
                        }
                        if(!s.empty()){   //还没到最大的括号(注意内层括号被包括在外层括号之中)
                            //暂存区中的元素需要弹回栈内
                            for(auto x : temp){
                                s.push(x);
                            }
                            temp.clear();
                        }
                    }
                }
                //将temp里的并到cnt里去
                for(auto x : temp){
                    cnt[x.key] += x.value;
                }
            }
        }

        //所有元素个数都要乘以物质个数（系数）
        for(auto x : cnt){
            res[x.key] = res[x.key] + x.value * coef;
        }
    }
    return res;
}

bool judge(string expr)
{
    unordered_map<string, int> eleft, eright;  //等式左右两侧各一个map
    int i = 0;
    while(expr[i] != '=') i ++;
    string ex1 = expr.substr(0, i);
    string ex2 = expr.substr(i + 1);
    eleft = cal(ex1);
    eright = cal(ex2);
    if(eleft.size() != eright.size()) return false;
    for(auto x : eleft){
        if(eright[x.key] != x.value) return false;
    }
    return true;
}

int main()
{
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n; cin >> n;

    string line;
    while(n --){
        cin >> line;
        bool flag = judge(line);
        if(flag) cout << "Y\n";
        else cout << "N\n";
    }
    return 0;
}

OVER，以前的第三题真是简单啊！！！尖叫！以及，可以修改得到满分真的特别有成就感！！

CCF-CSP 201912-2 回收站选址 C++满分题解
m0_73772116的博客
01-07 537
CCF-CSP 201912-2 回收站选址 C++满分题解
ccfcsp-2019-12-2回收站选址（c++满分题解）
qq_62942992的博客
03-29 659
该题就是考察点的保存以及索引的保存和遍历，看了他的用例说明，我原先以为暴力只能得50分，但是又没有想到别的优化方法，就写了一下暴力，发现居然AC。如果大家有更好的方法，欢迎评论区讨论。
CCF-CSP认证历年真题解
热门推荐
海岛Blog
01-28 34万+
CSP认证考什么怎么考？ CCF计算机职业资格认证的每一道试题都十分经典，覆盖现实世界中方方面面的问题。这个历年试题解主要使用C/C++语言编写，将逐步增加Python和Java的解题程序。程序中附有注释，力求解题思路清晰简洁，值得珍藏与模仿。 逐题改写过程中，富文本编辑器写的博客将全部用Markdown编辑器改写。改写的第一题，都增加了Python和Java的解题程序。 2021.04第22次： CCF202104-1 灰度直方图（100分）【计数】 CCF202104-2 邻域均值（100分.
新CCF-CSP认证历年真题解
海岛Blog
09-03 2万+
CSP认证考什么怎么考？ 　　 　　CCF计算机职业资格认证的每一道试题都十分经典，覆盖现实世界中方方面面的问题。这个历年试题解主要使用C/C++语言编写，将逐步增加Python和Java的解题程序。程序中附有注释，力求解题思路清晰简洁，值得珍藏与模仿。 　　逐题改写过程中，富文本编辑器写的博客将全部用Markdown编辑器改写。改写的第一题，都增加了Python和Java的解题程序。 　　本文本来只是一个索引链接，为了更加易于使用，格式做了调整，界面更加简洁。原来博文《CCF-CSP认证历年真题解》阅读量
CCF CSP认证考试201912题解（1,2,3,4）
雪的期许
03-04 1759
【缘起】 从acm退役十个月了，目前正在准备研究生复试，其中机试部分与CCF题目相仿，所以练习一下CCFSCP往届题目。记一下题解，一是加深印象，二是希望对其他考研人有所帮助。 【题目来源】 http://www.cspro.org/ 进入后点击报名入口，注册or登录，然后右上角有个模拟考试，点击去会看到95道往届CCFCSP认证真题。以下题解按考试日期编号。由于官网题面给的...
CCFCSP历年认证考试真题解答汇总（已解决20道，持续更新ing）
要像蜗牛一样一步一步往上爬！
01-19 3万+
以下为本人CCFCSP刷题记录，希望可以帮助到每一位想在这方面得到提升的码友们，也请各位对我写的不好的地方进行指正，大家一起进步。 2020年12月CCFCSP认证 试题编号 试题名称 202012-1 期末预测之安全指数 202012-2 期末预测之最佳阈值 202012-3 带配额的文件系统 202012-4 食材运输 202012-5 星际旅行 2020年9月CCFCSP认证 试题编号 试题名称 202009-1 称检测点查询 202009-2
第十八次CSP认证总结
aaHua_
12-17 1433
2019-12-15 青岛大学 题目一年比一年难… 前两个水题切了一个小时，之前的最多40分钟，把题目理解清楚就ok了。 第三题判断化学方程式是否配平（包括系数、化学元素（大小写）、括号、嵌套括号），读题的时候想的太少，没考虑清楚，导致最后写了2个半小时才发现没想全…再给我1小时差不多可以过6组样例的，下次再做大模拟的想明白了再下手，在纸上要写明白，要不写的时候容易掉了条件，我太难了… 第四题区块...
ccf-csp201912
一个努力练习代码的小菜鸟的博客
05-02 528
这次csp我拿的是100+100+60+80+10，其实代码可以再多加润色的，但我是以计时的方式写的，因此每一道题写的时候都是暴力优先，把代码发出来也是给大家一种新思路，暴力也可以拿很多分，区块链那题80分，在acwing上提交的时候是100可能有些数据acwing没有卡吧，但我的代码还蛮简单的，短短几十行拿了80也不错哈，化学方程式这道题就是来自于我的取舍吧，毕竟我是计时模拟写的，所以在看题时就取舍了一下决定只写前三种情况，其实后面的也比较好写，只要有耐心以及存储方式得当，下次考试前会去写。 1.报
CCF CSP认证考试题解目录
日沉云起的博客
09-26 8万+
CCF认证考试题解目录 编号 标题 题解 分类 备注 201809-1 卖菜 201809-2 买菜 201809-3 元素选择器 201809-4 再卖菜 201809-5 线性递推式 201803-1 跳一跳 C++ 简单模拟 201803-2 碰撞的小球 C++ 中级模拟 201803-3
CCF认证考试题解目录
01-07
针对历年考题，编写自己的解题程序，在官方网站上提交，了解得分。这个做法可以了解自己的编程水平，找出...化学方程式 201912-4 区块链 201912-5 魔数 201909-1 小明种苹果 C 201909-2 小明种苹果（续
C语言：函数变量作用域、指针入门
2301_77829391的博客
07-27 955
*概念：**变量在程序运行中的存在时间（内存申请到内存释放的时间）根据变量存在的时间不同，变量可分为静态存储方式和动态存储方式//写法1 数据类型 * 变量列表;//写法2 数据类型 * 变量列表;//普通变量int a;//指针变量int *p1;// 正确//正确int* p4;//正确int* p5,p6;//注意：p6被当作int变量，不是指针注意：指针变量的值只能是8（32位系统）| 12（64位系统）位的十六进制整数。① 虽然定义指针变量*a，是在变量名前加上。
【MediaTek】AN7563编译wlan_hwifi出现en_npu.c:42:10: fatal error:
wgl307293845的博客
07-24 56
问题日志。
《C++ list 完全指南：list的模拟实现》
铭哥不写bug的博客
07-27 796
本文介绍了C++ list 完全指南中0list的模拟实现，期待你的关注！
C++扩展 --- 并发支持库（下）
Small_entreprene的博客
07-24 1355
本文介绍了C++11并发支持库中三种重要的锁管理工具。lock_guard采用RAII机制自动管理互斥锁，在构造时加锁，析构时解锁，确保异常安全。unique_lock功能更丰富，支持延迟锁定、尝试锁定和移动语义，提供更灵活的锁管理。std::lock函数能原子性地锁定多个互斥锁，避免死锁问题。此外，文章还讲解了std::call_once的用法，保证多线程环境下某个函数只执行一次。这些工具能有效解决多线程编程中的资源管理、死锁预防等问题，提高代码的健壮性和安全性。
C++符合快速入门(有java和js基础的)
2302_77002233的博客
07-24 441
【代码】C++符合快速入门(有java和js基础的)
9.c语言常用算法
最新发布
chxii的专栏
07-28 344
从数组的第一个元素开始，逐个与目标值进行比较，直到找到目标值或查找完整个数组。
C++ 进程间共享内存同步的技术原理与实践
liulilittle的博客
07-27 1086
进程间共享内存同步机制深度解析与优化实践 本文系统剖析了进程间共享内存同步的核心技术原理与实现方案。通过对Windows和Linux两大平台的技术对比，揭示了原子操作、自旋锁、互斥锁等同步机制在不同系统环境下的实现差异与性能表现。重点内容包括：1）基于x86体系的内存映射与MESI缓存一致性协议；2）Windows平台cmpxchg汇编级原子锁实现；3）Linux下PTHREAD_PROCESS_SHARED属性的跨进程互斥锁；4）无锁环形队列的ABA问题解决方案；5）混合锁自适应算法等优化策略。测试数据显
C++ explicit 上下文相关转换
刘杰的博客
07-24 720
C++ 允许程序员为自己的类定义转换规则，主要有两种方式[3][4]转换构造函数 (Converting Constructor)：一个可以只用一个参数调用的构造函数（非explicit它定义了如何将参数类型转换为类类型。转换运算符 (Conversion Operator)：一种特殊的类成员函数，定义了如何将类类型转换为其他类型[5]。默认情况下，这些用户定义的转换可以是隐式的，即编译器可以在需要时自动调用它们，无需程序员显式指示[4]。explicit。
【C++】类和对象（上）
HuaiNAN417的博客
07-26 991
c++中数据和函数都放到了类里面，通过访问限定符进行了限制，不能再随意通过对象直接修改数据，这是C++封装的⼀种体现，这个是最重要的变化。这⾥的封装的本质是⼀种更严格规范的管理，避免出现乱访问修改的问题。C++中有⼀些相对方便的语法，比如Init给的缺省参数会方便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，方便了很多，使用类型不再需要typedef用类名就很方便。特殊的：没有成员变量的类的大小为1，来表示它“存在过”，如以下例题中的B和C。面向对象三大特性：封装，继承，多态。
CSP化学方程式
03-29
### CSP 认证考试中的化学方程式配平 CSP（Certified Software Professional）认证考试中，化学方程式的题目通常涉及通过编程方法来解决化学方程式的配平问题。这类问题的核心在于利用线性代数的方法求解未知变量的最小整数倍数，使得反应物和生成物中原子的数量保持平衡。 #### 输入与输出格式 输入数据由多行组成，每一行描述一个需要被配平的化学方程式。具体来说，每行包含一个正整数 \( m \)，表示方程式中有多少种物质参与反应，以及紧随其后的 \( m \) 个字符串，这些字符串代表了反应物和生成物的化学式[^1]。 输出则是一个经过配平的化学方程式，其中每个化学式的前缀系数满足原子守恒原则，并且所有系数均为非负整数[^2]。 #### 配平方程式的原理 化学方程式配平的本质是找到一组合适的系数，使反应物和生成物中各元素的原子数量完全一致。例如，在给定的例子中： \[ 2\text{H}_2 + \text{O}_2 = 2\text{H}_2\text{O} \] 左侧氢原子总数为 4，氧原子总数为 2；右侧同样有 4 个氢原子和 2 个氧原子，因此该方程式被认为是配平的[^3]。 为了实现这一目标，可以采用高斯消元法或其他数值计算技术，构建并求解相应的矩阵方程组。这种方法能够有效处理复杂的化学反应场景。 以下是基于 Python 的一种可能解决方案，用于自动完成化学方程式的配平操作： ```python from sympy import symbols, Eq, solve def parse_formula(formula): """解析单个化学式，返回字典形式的结果""" elements = {} i = 0 while i < len(formula): if formula[i].isupper(): elem_start = i i += 1 while i < len(formula) and formula[i].islower(): i += 1 element = formula[elem_start:i] count = 1 if i < len(formula) and formula[i].isdigit(): start_digit = i i += 1 while i < len(formula) and formula[i].isdigit(): i += 1 count = int(formula[start_digit:i]) if element not in elements: elements[element] = 0 elements[element] += count return elements def balance_equation(equation): reactants, products = equation.split('=') reactant_list = list(map(parse_formula, reactants.strip().split('+'))) product_list = list(map(parse_formula, products.strip().split('+'))) all_elements = set() for r in reactant_list: all_elements.update(r.keys()) for p in product_list: all_elements.update(p.keys()) variables = symbols(' '.join(f'x{i}' for i in range(len(reactant_list) + len(product_list)))) equations = [] for e in all_elements: lhs = sum(variables[i] * reactant_list[i].get(e, 0) for i in range(len(reactant_list))) rhs = sum(variables[len(reactant_list)+j] * product_list[j].get(e, 0) for j in range(len(product_list))) equations.append(Eq(lhs, rhs)) solution = solve(equations, variables) coefficients = [solution[var] for var in variables] lcm = abs(coefficients[0].as_numer_denom()[1]) for c in coefficients[1:]: lcm = lcm.lcm(c.as_numer_denom()[1]) normalized_coefficients = [int(lcm * c / c.as_numer_denom()[1]) for c in coefficients] min_index = normalized_coefficients.index(min(normalized_coefficients)) factor = normalized_coefficients[min_index] final_coeffs = [c // factor for c in normalized_coefficients] balanced_reactants = ' + '.join([f'{final_coeffs[i]} {list(equation.split("="))[0].strip().split("+")[i]}' for i in range(len(list(equation.split("="))[0].strip().split("+"))]) balanced_products = ' + '.join([f'{final_coeffs[i+len(reactant_list)]} {list(equation.split("="))[1].strip().split("+")[i]}' for i in range(len(list(equation.split("="))[1].strip().split("+"))]) return f"{balanced_reactants} = {balanced_products}" equation_input = input("请输入未配平的化学方程式 (e.g., H2 + O2 = H2O): ") print(balance_equation(equation_input)) ``` 此代码片段实现了对任意简单化学方程式的自动化配平功能[^4]。 #### 结论 综上所述，CSP 考试中的化学方程式配平问题是计算机科学与化学交叉领域的重要应用之一。它不仅考察考生对于基础算法的理解能力，还测试他们跨学科解决问题的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值