字符串训练

已于 2022-04-20 18:06:21 修改
阅读量897 收藏
点赞数
分类专栏： learning 文章标签： c++
于 2022-04-20 16:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a13352912632/article/details/124277866
版权

文章目录

处理输入的技巧

针对类型转化

// 字符串转数字
stoi(str); // toint
stod(str); // todouble
​
// 数字转字符串
to_string(type); //type可以是一系列数字类型

针对复杂字符串解析

1.按空格解析成字符串数组，直接使用stringstream

// 解析成array类型
// 按照空格分隔字符串并且转换成array类型
#include <string>
// stringstream需要该头文件
#include <sstream>
using namespace std;
​
string input;
getline(cin, input);
// 流式处理，背一下就好
stringstream ss;
ss << input;
string p;
while(ss >> p)
    cout << p << endl;
  1. 按任意字符解析成字符串数组split

最强做法：字符流配合getline函数

string input;
	
while (cin >> input) {
	stringstream is(input);
	string add;
	vector<string> v;
	while (getline(is, add, '~')) 
		v.push_back(add);

}

​// 按照指定字符分隔字符串

//法一：
void split(const string& s, vector<string>& tokens, const string& delimiters = " "){
    string::size_type lastPos = s.find_first_not_of(delimiters, 0);
    string::size_type pos = s.find_first_of(delimiters, lastPos);
    while(pos != string::npos || lastPos != string::npos){
        tokens.push_back(s.substr(lastPos, pos - lastPos));
        lastPos = s.find_first_not_of(delimiters, pos);
        pos = s.find_first_of(delimiters, lastPos);
    }
}

//法二：
vector<std::string> split(std::string str, std::string pattern)
{
	int pos;
	vector<std::string> result;
	str += pattern;//结尾扩展字符串以方便操作 ,最后有目标字符，才能find到结尾终止循环
	int size = str.size();
	for (int i = 0; i < size; i++)
	{
		pos = str.find(pattern, i); // pos <--- str.find("substr", i)从下标0开始找substr子串，返回下标
		if (pos < size)
		{
			string s = str.substr(i, pos - i);
			result.push_back(s);
			i = pos + pattern.size() - 1;
		}
	}
	return result;
}
  1. 按一定格式将一整行输入解析成map

一个例子，假设给定的输入是这样的 a:123 b:123 c:132 需要解析成的类型为

//map<string,int>，做法如下：

string input;
getline(cin, input);
map<string, int> hash;
stringstream ss;
ss << input;
string tp;
while(ss >> tp){
    vector<string> p;
    // split就是上述函数split
    split(tp, p, ":");
    hash[p[0]] = stoi(p[1]);
}

例题

密码截取

Catcher是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214　。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？

数据范围：字符串长度满足 1 \le n \le 2500 \1≤n≤2500
输入描述：
输入一个字符串（字符串的长度不超过2500）

输出描述：
返回有效密码串的最大长度

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

// 依题意， 找最长的回文子串
bool dp[2510][2510];
int main() {
	string s;
	cin >> s;

	for (int i = 0; i < 1010; i++)
		for (int j = 0; j < 1010; j++)
			dp[i][j] = true;


	int len = s.size();
	//if(len < 2) ;
	int L, j;
	for (int L = 2; L <= len; L++) {
		for (int i = 0; i < len; i++) {
			j = L + i - 1;

			if (j >= len) break;
			if (s[i] != s[j]) dp[i][j] = false;
			else {
				if (j - i < 3) dp[i][j] = true;
				else dp[i][j] = dp[i + 1][j - 1];
			}
		}

	}
	int res = INT_MIN;
	
	for (int i = 0; i < len; i++)
		for (int j = 0; j < len; j++) {
			if (dp[i][j]) {
				res  = max(res, (j - i + 1));
			}
		}
    
    cout << res; 
	return 0;
}

日志排序

题目描述：
有一个网络日志，记录了网络中计算任务的执行情况，每个计算任务对应一条如下形式的日志记录：
“hs_10000_p”是计算任务的名称，
“2007-01-17 19:22:53,315”是计算任务开始执行的时间“年-月-日 时：分：秒，毫秒”，
“253.035(s)”是计算任务消耗的时间(以秒计)
hs_10000_p 2007-01-17 19:22:53,315 253.035(s)
请你写一个程序，对日志中记录计算任务进行排序。
时间消耗少的计算任务排在前面，时间消耗多的计算任务排在后面。
如果两个计算任务消耗的时间相同，则将开始执行时间早的计算任务排在前面。

输入：
日志中每个记录是一个字符串，每个字符串占一行。最后一行为空行，表示日志结束。日志中最多可能有

10000条记录。计算任务名称的长度不超过10，开始执行时间的格式是YYYY-MM-DD HH:MM:SS,MMM，

消耗时间小数点后有三位数字。
计算任务名称与任务开始时间、消耗时间之间以一个或多个空格隔开，行首和行尾可能有多余的空格。

输出：
排序好的日志记录。每个记录的字符串各占一行。
输入的格式与输入保持一致，输入包括几个空格，你的输出中也应该包含同样多的空格。

样例输入：
hs_10000_p 2007-01-17 19:22:53,315 253.035(s)
hs_10001_p 2007-01-17 19:22:53,315 253.846(s)
hs_10002_m 2007-01-17 19:22:53,315 129.574(s)
hs_10002_p 2007-01-17 19:22:53,315 262.531(s)
hs_10003_m 2007-01-17 19:22:53,318 126.622(s)
hs_10003_p 2007-01-17 19:22:53,318 136.962(s)
hs_10005_m 2007-01-17 19:22:53,318 130.487(s)
hs_10005_p 2007-01-17 19:22:53,318 253.035(s)
hs_10006_m 2007-01-17 19:22:53,318 248.548(s)
hs_10006_p 2007-01-17 19:25:23,367 3146.827(s)
样例输出：
hs_10003_m 2007-01-17 19:22:53,318 126.622(s)
hs_10002_m 2007-01-17 19:22:53,315 129.574(s)
hs_10005_m 2007-01-17 19:22:53,318 130.487(s)
hs_10003_p 2007-01-17 19:22:53,318 136.962(s)
hs_10006_m 2007-01-17 19:22:53,318 248.548(s)
hs_10000_p 2007-01-17 19:22:53,315 253.035(s)
hs_10005_p 2007-01-17 19:22:53,318 253.035(s)
hs_10001_p 2007-01-17 19:22:53,315 253.846(s)
hs_10002_p 2007-01-17 19:22:53,315 262.531(s)
hs_10006_p 2007-01-17 19:25:23,367 3146.827(s)

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<sstream>
using namespace std;
struct node
{
    string src;
    string name;
    string time[3];
};
int cmp(node x,node y)
{
    if(x.time[2].size()!=y.time[2].size()) return x.time[2].size()<y.time[2].size();
    if(x.time[2]==y.time[2])
    {
        if(x.time[0]==y.time[0]) return x.time[1]<y.time[1];
        else return x.time[0]<y.time[0];
    }
    return x.time[2]<y.time[2];
}
int main()
{
    int k=0;
    string s;
    node a[10005];
    while(getline(cin,s))
    {
        a[k].src=s;
        istringstream is(s);
        is>>a[k].name>>a[k].time[0]>>a[k].time[1]>>a[k].time[2];
        k++;
        //if(k==10) break;
        //cout<<a[k].src<<endl;
        //cout<<a[k].name<<" "<<a[k].time[0]<<" "<<a[k].time[1]<<" "<<a[k].time[2]<<endl;
     }
     sort(a,a+k,cmp);
    for(int i=0;i<k;i++) cout<<a[i].src<<endl;
    return 0;
}

错误记录

描述
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。

处理：

1、 记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是“相同”的错误记录。
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。也就是说，哪怕不同路径下的文件，如果它们的名字的后16个字符相同，也被视为相同的错误记录
4、循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准

数据范围：错误记录数量满足 1 \le n \le 100 \1≤n≤100 ，每条记录长度满足 1 \le len \le 100 \1≤len≤100
输入描述：
每组只包含一个测试用例。一个测试用例包含一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。

输出描述：
将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开，如：

示例1
输入：
D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645
E:\je\rzuwnjvnuz 633
C:\km\tgjwpb\gy\atl 637
F:\weioj\hadd\connsh\rwyfvzsopsuiqjnr 647
E:\ns\mfwj\wqkoki\eez 648
D:\cfmwafhhgeyawnool 649
E:\czt\opwip\osnll\c 637
G:\nt\f 633
F:\fop\ywzqaop 631
F:\yay\jc\ywzqaop 631
D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645
复制
输出：
rzuwnjvnuz 633 1
atl 637 1
rwyfvzsopsuiqjnr 647 1
eez 648 1
fmwafhhgeyawnool 649 1
c 637 1
f 633 1
ywzqaop 631 2
复制
说明：
由于D:\cfmwafhhgeyawnool 649的文件名长度超过了16个字符，达到了17，所以第一个字符’c’应该被忽略。
记录F:\fop\ywzqaop 631和F:\yay\jc\ywzqaop 631由于文件名和行号相同，因此被视为同一个错误记录，哪怕它们的路径是不同的。
由于循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准，所以D:\zwtymj\xccb\ljj\cqzlyaszjvlsjmkwoqijggmybr 645不会被记录。

#include <iostream>
#include <string>
#include <deque>
#include <map>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::map;
using std::deque;

int main() {
    string str;
    map<string, int> result;
    deque<string> deq;
    while (getline(cin, str)) {
        str = str.substr(str.find_last_of('\\') + 1);
        int pos = str.find_last_of(' ');
        if ( pos > 16) {
            str = str.substr(pos - 16);
        }

        if (result.find(str) == result.end()) deq.push_back(str);
        ++result[str];
        if (deq.size() > 8) deq.pop_front();
    }
    for (auto x : deq) {
        cout << x << " " << result[x] << endl;
    }
    return 0;
}

识别有效ip与掩码

请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址从1.0.0.0到126.255.255.255;

B类地址从128.0.0.0到191.255.255.255;

C类地址从192.0.0.0到223.255.255.255;

D类地址从224.0.0.0到239.255.255.255；

E类地址从240.0.0.0到255.255.255.255

私网IP范围是：

从10.0.0.0到10.255.255.255

从172.16.0.0到172.31.255.255

从192.168.0.0到192.168.255.255

子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
（注意二进制下全是1或者全是0均为非法子网掩码）

注意：

  1. 类似于【0...】和【127...】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略
  2. 私有IP地址和A,B,C,D,E类地址是不冲突的

输入描述：
多行字符串。每行一个IP地址和掩码，用~隔开。

请参考帖子https://www.nowcoder.com/discuss/276处理循环输入的问题。
输出描述：
统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

示例1
输入：
10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19…0.~255.255.255.0
复制
输出：
1 0 1 0 0 2 1
复制
说明：
10.70.44.68255.254.255.0的子网掩码非法，19…0.255.255.255.0的IP地址非法，所以错误IP地址或错误掩码的计数为2；
1.0.0.1~255.0.0.0是无误的A类地址；
192.168.0.2~255.255.255.0是无误的C类地址且是私有IP；
所以最终的结果为1 0 1 0 0 2 1
示例2
输入：
0.201.56.50~255.255.111.255
127.201.56.50~255.255.111.255
复制
输出：
0 0 0 0 0 0 0
复制
说明：
类似于【0...】和【127...】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略

#include<iostream>
#include<string>
#include<sstream>
#include<vector>
using namespace std;

bool judge_ip(string ip){
    int j = 0;
    istringstream iss(ip);
    string seg;
    while(getline(iss,seg,'.'))
        if(++j > 4 || seg.empty() || stoi(seg) > 255)
            return false;
    return j == 4;
}

bool is_private(string ip){
    istringstream iss(ip);
    string seg;
    vector<int> v;
    while(getline(iss,seg,'.')) v.push_back(stoi(seg));
    if(v[0] == 10) return true;
    if(v[0] == 172 && (v[1] >= 16 && v[1] <= 31)) return true;
    if(v[0] == 192 && v[1] == 168) return true;
    return false;
}

bool is_mask(string ip){
    istringstream iss(ip);
    string seg;
    unsigned b = 0;
    while(getline(iss,seg,'.')) b = (b << 8) + stoi(seg);
    if(!b) return false;
    b = ~b + 1;
    if(b == 1) return false;
    if((b & (b-1)) == 0) return true;
    return false;
}

int main(){
    string input;
    int a = 0,b = 0,c = 0,d = 0,e = 0,err = 0,p = 0;
    while(cin >> input){
        istringstream is(input);
        string add;
        vector<string> v;
        while(getline(is,add,'~')) v.push_back(add);
        if(!judge_ip(v[1]) || !is_mask(v[1])) err++;
        else{
            if(!judge_ip(v[0])) err++;
            else{
                int first = stoi(v[0].substr(0,v[0].find_first_of('.')));
                if(is_private(v[0])) p++;
                if(first > 0 && first <127) a++;
                else if(first > 127 && first <192) b++;
                else if(first > 191 && first <224) c++;
                else if(first > 223 && first <240) d++;
                else if(first > 239 && first <256) e++;
            }
        }
    }
    cout << a << " " << b << " " << c << " " << d << " " << e << " " << err << " " << p << endl;
    return 0;
}
fang0jun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符训练集
04-04
包含字母，数字，数量也够，足够进行神经网络的训练
字符串训练的.pdf文件
06-23
里面是字符串训练的题目，个人感觉比较有用，可以下载下来学习一下呀！
Training4:字符串训练
qq_45792897的博客
02-04 184
1.题目: 请编写一个C函数,该函数将一个字符串逆序 #include <stdio.h> #include <string.h> void exc(char *str) { int n; int temp; int len = strlen(str); for (n = 0; n < len / 2; n++) { temp = *(str + n); *(str + n) = *(str + le
字符串专项训练
weixin_59179454的博客
09-08 503
选项C：指针p和q分别为字符串s和t的工作指针，当执行完while循环之后，指针p和q分别指向了字符串s和t对应不相等字符位，对指向该字符位的指针取值后作差即可比较大小，正确。从while里面的返回结果可知，返回0的时候是两个字符串相等的时候，因此while循环外面的返回值则是比较两个字符串不相等的时候，即比较字符串对应位字符的ASCII值。而strcmp函数的功能是，若字符串s对应位上的ASCII字符值大于、等于、小于字符串t对应位上的ASCII字符值，则分别返回正整数、0、负整数。
Java实现 蓝桥杯 算法训练 字符串合并
12-22
试题 算法训练 字符串合并 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　输入两个字符串，将其合并为一个字符串后输出。 输入格式 　输入两个字符串 输出格式 　输出合并后的字符串 样例输入 一个满足题目...
比较字符串1
08-08
算法训练 比较字符串 时间限制：1.0s 内存限制：512.0MB 编程实现两个字符串s1和s2的字典序比较。若它们不相等，则指出其第一个不同字
头歌数据结构数据结构—字符串
05-18
头歌数据结构数据结构—字符串 第1关子串插入 第2关子串删除 第3关子串定位 第4关子串替换 稳过 ... 通过本实践项目的训练，大家可以掌握字符串的四个基础操作——子串的插入、删除、替换和查找。
C语言训练程序_自定义字符串连接函数
04-13
C语言自定义字符串连接函数 在计算机编程中，字符串连接是指将两个或多个字符串连接成一个新的字符串的过程。在C语言中，标准库函数 strcat() 可以实现字符串连接。然而，在实际编程中，我们有时需要根据具体情况...
车牌识别字符训练样本
03-09
用于车牌字符识别的样本，每个字符样本为100个，共计6000多个样本，大小为16*32。用于车牌字符识别的训练和测试
车牌字符识别字符训练样本（字符模板）
07-10
分割好的16*32黑底白字的车牌字符340个（A~Z,0~9共34类字符，每类10个）
数字和字母训练数据集
09-18
10个数字和26个字母不同打印字体训练集，每一个含一千多种字符
字符是识别---10--源数据20*20--训练样本0~A----基于TensorFlow+CNN实现
u011473714的专栏
06-26 261
#coding=utf-8 import os #图像读取库 from PIL import Image #矩阵运算库 import numpy as np import tensorflow as tf # 训练还是测试 train = False #True False # 数据文件夹 if train: data_dir = "data" else: data_di...
字符串练习题
qizhichao110的专栏
12-19 2908
#region 练习一             //课上练习1：接收用户输入的字符串，将其中的字符以与输入相反的顺序输出。"abc"→"cba"             string str = "abcefg";             //思路：先将这个字符串转换成数组             char[] chs = str.ToCharArray();             /
【专项训练】----字符串
m0_61801103的博客
10-13 288
每日一题
字符串一些常见的练习操作
qq_21058391的博客
09-15 1531
1.寻找所有子串的位置 function substrPosition (str, substr) { /* find all the substr position */ var position_arr = []; var index = str.indexOf(substr); while(index != -1) { position_arr.push(index);
字符识别之字符训练部分
weixin_43710577的博客
04-07 154
【代码】字符识别之字符训练部分。
头歌实践教学 python字符串训练
最新发布
11-05
在头歌实践教学中，我们可以运用这种方法来进行Python字符串训练。 Python字符串是一种常用的数据类型，用于存储和操作文本信息。在字符串训练中，我们可以通过头歌实践教学来帮助学生更好地掌握字符串的操作方法和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值