每日一刷——0629——2023睿抗本科组省赛第二题

今天来刷2023年睿抗本科省赛比赛的第二题:出院,题目如下:

输入样例

5 6
Diet A
LowSugarTea B
Milk C
Coke D
Water A
DietCoke
Pepsi
Milk
CokeWater
GoodMilk
dietCoke
 

输出样例

AD
D
C
DA
D
D

首先先来看看我写的代码:

#include <bits/stdc++.h>
using namespace std;

//多种拆解方法    应该怎么办??? 
//为什么答案错误??? 
//我明明一模一样
 
string str[100];
char ch[100];

int main()
{
	int N,M,i; 
	cin>>N>>M;
	int k=0,m=0;
	string name="";
	string s;
	for(i=0;i<N;i++){
		cin>>str[i];
		cin>>ch[i];
	}
	while(M--){
		cin>>s;
		k=0;
		m=0;
		for(i=0;i<N;i++){
			if(s.find(str[i])>=0){
				name+=ch[i];
				k++;
			}
			if(s==str[i]){
				m=1;
			}	
		}
		if(k==0||(k==1&&m!=1)){
			name="D";
		}
		
		cout<<name<<endl;
		name.clear();
	}
}
 

错误分析:

1.为什么我的输出明明是一样的,但是交上去还是说我答案错误?

2.思维上还有哪些欠缺?

3.和其他人的差距在哪

4.提交上去后编译器里边说我的这一句s.find(str[i])>=0这句话有问题

分析过程

1.我的思路是在需要定级的饮料里边寻找已知到的饮料的名字,再通过黏合字符串把等级输出,但是由于题目是需要把它分解为两个串或者直接是已知的串,所以我这种找字符串的方式对于只有一个串的情况或者不能完全分为两个串的情况很难办,还要再改进一下

2.突然想到是不是可以先判断是不是和已知情况有相符合的,然后再来找子串?

3.不过看别人的题解可能分解子串会更简便一点,我先把第二点的思路改进一下

4.有编译警告的可以改成s.find(str[i])!=string::npos   用string里边的npos

5.又写了一遍,一分,气死我了

#include <bits/stdc++.h>
using namespace std;

//多种拆解方法    应该怎么办??? 
//为什么答案错误??? 
//我明明一模一样
 
string str[100];
char ch[100];

int main()
{
	int N,M,i; 
	cin>>N>>M;
	int k=0,flag=0;
	string name="";
	string s;
	for(i=0;i<N;i++){
		cin>>str[i];
		cin>>ch[i];
	}
	while(M--){
		cin>>s;
		k=0;
		flag=0;
		for(i=0;i<N;i++){
			if(s==str[i]){
				cout<<ch[i]<<endl;
				flag=1;
				break;
			}	
		} //首先判断是不是已知的串 
		if(flag==1){
			continue;
		}else{
			for(i=0;i<N;i++){
				if(s.find(str[i])!=string::npos){
					name+=ch[i];
					k++;
				}	
			}   //用来判断是不是可以分成两个串 
			if(k==2){
				cout<<name<<endl;
			}else{
				cout<<"D"<<endl;
			}
		}
		name.clear();
	}
}
 

好吧,我屈服了,来看看别人的代码,总结一下别人的代码思路

#include<bits/stdc++.h>
using namespace std;
 
 
int main() {
	int n, m;
	cin >> n >> m;
	map<string, string> mp;    //1.使用了map   理由:给定拥有等级的饮料的名字不会重复 
	
	for(int i = 1;i <= n; ++ i) {
		string s1, s2;
		cin >> s1 >> s2;
		mp[s1] = s2;          //字符串为键,等级为值 
	}
	
	while(m --) {
		string s;
		cin >> s;
		if(mp.count(s)) {      //2.map中的count函数 ,用来判断键是否存在,只会返回0和1两种结果 
			cout << mp[s] << '\n';
			continue;
		}
		
		int cnt = 0;
		string ans = "";
		for(int i = 1; i < (int)s.size(); ++ i) {
			string s1 = s.substr(0, i),    s2 = s.substr(i);    //3.用string里边的substr函数把字符串分解成两个子串 
			
			if(mp.count(s1) && mp.count(s2)) {                   
				++ cnt;                                         //4.cnt是用来判断是否存在多种分割方式的 
				ans = mp[s1] + mp[s2];
			}
			
		}
		
		if(ans.empty() || cnt > 1)	cout << "D\n";
		else	cout << ans << '\n';                           //5.对应了题目里边的第三句话 ,如果无法拆解或者有多种拆解方式 
	}
	
	return 0;
}

经验总结:

1.我通过改进以后的代码思路在顺序上有点类似,但是还是实现的不够细致,对于每一道题目的题干的理解还不够深入,有点太依照自己的想法去实现了,对题目研读不够细致,有点发散思维

待学习的知识的总结

1.map容器的应用,定义

map容器是含有键值对的容器,其中第一个代表键,且是唯一的,第二个代表值,其中这个题目说了两个东西是联系在一起的,而且有一个东西是唯一的,所以用map来存放数据再适合不过了

2.map容器的count函数的应用

返回值方面:只会返回0或者1,用来判断键是否存在

3.string里边的substr函数

左闭右开

学习思路的总结

1.分成两个子串,就可以用substr截两次,把它的每一种可能截出来的情况都比较出来,就能知道到底是否有多种分法

重写一遍这个题目放在明天,敬请看明天的每天一刷。

### 关于简易 JSX 解析器实现方法及解思路 #### 1. 理解目背景与需求 对于第十五届蓝桥杯职业院校第五中的简易 JSX 解析器,目标在于创建个可以将简单的 JSX 表达式转换为对应的 JavaScript 对象表示形式的程序。这类解析器通常会处理标签名、属性以及子节点等内容。 #### 2. 构建基础结构 为了构建这样个解析器,首先需要定义好输入输出格式。输入应为合法的 JSX 字符串;而输出则应该是按照特定规则形成的对象树形结构,类似于 `React.createElement` 的返回结果[^1]。 ```javascript // 输入例子:"div { className: 'container' } span Hello" // 输出应该像这样: { type: "div", props: { className: "container", children: [ { type: "span", props: {}, children: ["Hello"] } ] } } ``` #### 3. 处理基本元素 针对最简单的情况——即不带任何属性的单层HTML标签,可以通过正则表达式匹配来提取标签名称并初始化相应的对象实例: ```javascript function parseSimpleElement(str) { const match = str.match(/<(\w+)>/); if (!match) throw new Error('Invalid element'); return { type: match[1], props: {}, children: [] }; } ``` #### 4. 属性解析 当遇到带有属性的标签时,则需进步扩展上述逻辑以支持键值对的形式读取这些附加信息,并将其存储至 `props` 中: ```javascript const attrPattern = /([\w-]+)="([^"]*)"/g; function parseAttributes(attrsStr) { let attrs = {}; let matches; while ((matches = attrPattern.exec(attrsStr)) !== null) { attrs[matches[1]] = matches[2]; } return attrs; } function parseElementWithAttrs(str) { // 提取出标签部分和属性字符串 const parts = str.split(/\s+/).filter(Boolean); const tagName = parts.shift(); const attributesString = parts.join(' '); return { type: tagName, props: parseAttributes(attributesString), children: [] }; } ``` #### 5. 子节点嵌套 最后步是要考虑如何处理多级嵌套情况下的子节点关系。这可能涉及到递归调用当前函数本身或其他辅助方法来进行更深层次的内容解析。 ```javascript function tokenize(input) { var tokens = []; var currentToken = ''; function flushCurrent() { if (currentToken.trim()) tokens.push(currentToken.trim()); currentToken = ''; } for (var i = 0; i < input.length; ++i) { switch (input[i]) { case '<': flushCurrent(); break; case '>': flushCurrent(); continue; default: currentToken += input[i]; } if (input[i] === '>' || i === input.length - 1) { flushCurrent(); } } return tokens.filter(token => token !== ''); } function parseJSXExpression(expression) { const elementsStack = []; const resultElements = []; tokenize(expression).forEach((token, index, array) => { if (/^<\/\w+$/.test(token)) { const closingTagMatch = /^<\/(\w+)$/.exec(token)[1]; const lastOpenTagIndex = elementsStack.findIndex( ({type}) => type === closingTagMatch && !elementsStack.some(({parent}, idx) => parent?.type === closingTagMatch && idx > elementsStack.indexOf({type})) ); if(lastOpenTagIndex >= 0){ const closedElement = elementsStack.splice(lastOpenTagIndex); if(elementsStack.length){ elementsStack[elementsStack.length - 1].children.push(closedElement.pop().element); }else{ resultElements.push(...closedElement.map(e=>e.element)); } } else { console.error(`Unmatched close tag ${closingTagMatch}`); } } else if(/^<\w+(\s[\w\s="']*)?>$/.test(token)){ try { const parsedElm = parseElementWithAttrs(token.slice(1,-1)); elementsStack.push({ element :parsedElm , parent: elementsStack.at(-1)?.element ?? undefined }); } catch(error){ console.error(`Failed to parse element at position ${index}:`, error.message); } } else { if(elementsStack.length){ elementsStack[elementsStack.length - 1].element.children.push(token); } else { resultElements.push(token); } } }); return resultElements.length===1 ? resultElements[0]:resultElements ; } ``` 此代码片段展示了从原始字符串到最终DOM-like 结构的过程,其中包含了对开闭标签、自封闭标签的支持,同时也能够正确处理文本节点作为子项的存在。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值