程序员经验分享-hwhale

字符串训练

2023-05-16

文章目录

  • 处理输入的技巧
    • 针对类型转化
    • 针对复杂字符串解析
  • 例题
    • 密码截取
    • 日志排序
    • 错误记录
    • 识别有效ip与掩码

处理输入的技巧

针对类型转化

// 字符串转数字
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;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

字符串训练 的相关文章

  • golang网站错误处理

    我们的Web应用一旦上线之后 xff0c 那么各种错误出现的概率都有 xff0c Web应用日常运行中可能出现多种错误 xff0c 具体如下所示 xff1a 数据库错误 xff1a 指与访问数据库服务器或数据相关的错误 例如 xff0c 以

  • golang应用部署

    程序开发完毕之后 xff0c 我们现在要部署Web应用程序了 xff0c 但是我们如何来部署这些应用程序呢 xff1f 因为Go程序编译之后是一个可执行文件 xff0c 编写过C程序的读者一定知道采用daemon就可以完美的实现程序后台持续

  • golang备份和恢复

    我们经常会遇到生产服务器的网络断了 硬盘坏了 操作系统崩溃 或者数据库不可用了等各种异常情况 xff0c 所以维护人员需要对生产服务器上的应用和数据做好异地灾备 xff0c 冷备热备的准备 在接下来的介绍中 xff0c 讲解了如何备份应用

  • golang自定义路由器设计

    HTTP路由组件负责将HTTP请求交到对应的函数处理 或者是一个struct的方法 xff0c 如前面小节所描述的结构图 xff0c 路由在框架中相当于一个事件处理器 xff0c 而这个事件包括 xff1a 用户请求的路径 path 例如

  • golang中的Session支持

    session集成 beego中主要有以下的全局变量来控制session处理 xff1a related to session SessionOn bool 是否开启session模块 xff0c 默认不开启 SessionProvider

  • golang表单及验证支持

    在Web开发中对于这样的一个流程可能很眼熟 xff1a 打开一个网页显示出表单 用户填写并提交了表单 如果用户提交了一些无效的信息 xff0c 或者可能漏掉了一个必填项 xff0c 表单将会连同用户的数据和错误问题的描述信息返回 用户再次填

  • sublime搭建C/C++编译环境

    代码一 xff1a 34 cmd 34 34 g 43 43 34 34 file 34 34 std 61 c 43 43 11 34 34 o 34 34 file path file base name 34 34 amp 34 34

  • golang用户认证

    在开发Web应用过程中 xff0c 用户认证是开发者经常遇到的问题 xff0c 用户登录 注册 登出等操作 xff0c 而一般认证也分为三个方面的认证 HTTP Basic和 HTTP Digest认证第三方集成认证 xff1a QQ 微博

  • golang多语言支持

    专注后台开发相关技术 xff0c 广度深度并存 xff0c 干货情怀同在 微信搜索 盼盼编程 关注这个不一样的程序员 强烈推荐人工智能学习网站 beego中设置全局变量如下 xff1a Translation i18n IL Lang st

  • golang中的pprof支持

    专注后台开发相关技术 xff0c 广度深度并存 xff0c 干货情怀同在 微信搜索 盼盼编程 关注这个不一样的程序员 强烈推荐人工智能学习网站 Go语言有一个非常棒的设计就是标准库里面带有代码的性能监控工具 xff0c 在两个地方有包 xf

  • 大厂动态规划面试汇总，提升内功

    注 xff1a 本文是BAT真题收录很值得大家花心思看完 xff0c 看完会有收获 前言 算法是面试大公司必考的项目 xff0c 所以面试前准备好算法至关重要 xff0c 今天整理的常见的动态规划题目 xff0c 希望可以帮到大家 要想学习

  • 进程知识点，只需这一篇

    前言 你的进程 xff0c 为啥挂了 xff1f 进程挂了 xff0c 这个问题大家并不陌生 学完这篇 xff0c 你会对进程有一定了解 后面碰到进程挂的情况 xff0c 你很快能找到对应解决思路 进程在操作系统中 xff0c 是一个很重要

  • 算法：多数元素，多种解法

    前言 xff1a 以前做数学题的时候 xff0c 老师说 xff1a 你们学习多种解题方法 遇到类似不同的问题 xff0c 你都会了 xff0c 这样能提高解题能力 如果你写出多种解法 xff0c 面试官会对你刮目相看 下面一题 xff0c

  • 栈和队列互相实现，一文弄懂它们的关系

    前言 栈和队列是比较基础的数据结构 无论在工作中 xff0c 还是在面试中 xff0c 栈和队列都用的比较多 在计算机的世界 xff0c 你会看到队列和栈 xff0c 无处不在 栈 xff1a 一个先进后出的数据结构 队列 xff1a 一个

  • linux下调试core dump方式汇总，工作必备技能

    缘起 调试 xff0c 是开发流程中一个非常重要的环节 每个程序员都应 xff0c 具备调试代码的能力 xff0c 尤其对于从事 Linux 下的开发的读者 从事 linux 下后台开发 xff0c 有时候会遇到程序突然崩溃的情况 xff0

  • TCP 连接的前世今生

    前言 大家好 xff01 我是盼盼 xff01 之前写了几篇关于算法和 linux 命令的文章 xff0c 今天来学习下 xff0c 网络协议相关的知识 不管你是客户端 xff0c 还是服务端开发 xff0c 网络协议这块都是要学习和了解的

  • 反向传播算法推导过程（看一篇就够了）

    反向传播BackPropagation算法简称BP xff0c 算是神经网络的基础了 在神经网络中 xff0c 正向传播用于模型的训练 xff0c 模型中的参数不一定达到最佳效果 xff0c 需要进行 反向传播 进行权重等参数的修正 此外

  • 2021-08-21

    Snapper for Mac是一款强大的音频文件编辑软件 Snapper mac版会跟随您在Finder中选择的文件 选择音频文件后 xff0c 它会立即显示波形 并支持50 多种声音文件格式 还等什么 xff0c 快来下载吧 xff01

  • MAC系统如何连接Windows共享文件？MAC系统连接Win共享文件的方法

    MAC系统如何连接Windows共享文件 xff1f MAC系统和Windows是两个不同的系统 xff0c 有时候我们想要MAC系统访问Windows共享文件 xff0c 那么有什么方法呢 xff0c 下面小编就为大家介绍一下 MAC系统

  • mac恢复文件的方法，在Mac上使用时间机器恢复文件

    如果您使用时间机器对 Mac 上的文件进行备份 xff0c 则可以轻松恢复丢失的项目 xff0c 或者恢复文件的较早版本 您可以在很多 App 中使用时间机器 1 在 Mac 上 xff0c 打开想要恢复项目的窗口 例如 xff0c 若要恢

随机推荐

热门标签