数据结构-字符串

字符串分割的几种方式

数组和字符串是华为机试经常的考点。字符串的分割又是字符串常用方式。

空格作为分隔符分割字符串

头文件

#include <sstream>

使用方法-使用istringstream分割string默认以空格作为分隔符

#include <iostream>

#include <string>

#include <sstream>

using namespace std;

int main()

{

string str = "1 2 3 4 5";

istringstream tmp(str);//

while (tmp >> str)

{

cout << str << endl;

}

}

以其他符号分割字符串

#include <iostream>

#include <string>

#include <sstream>

using namespace std;

int main()

{

string str = "1 ; 2 ;3; 4 ; 5";

istringstream iss(str);

string buffer;

//使用“/” 对iss进行分割 为终结符号

//遇到其则进行停止操作 并将其之前的结果存储到buffer之中

while(getline(iss,buffer,';')){

cout << buffer << endl;

}

}

/*

1

2

3

4

5

*/

不用函数分割字符串

#include <bits/stdc++.h>

using namespace std;

int main()

{

string str;

getline(cin,str);//"1 ; 2 ;3; 4 ; 5"

int len = str.size();

vector <string> vec;

int left = 0;

for (int i = 0; i <= len; i++) {//按 ';' 分割

if (str[i] == ';'||str[i]==0) {

if (i > left){

vec.push_back(str.substr(left, i - left));

}

left = i+1;

}

}

for (auto i:vec)cout << i << endl;

}

/*

1

2

3

4

5

*/

HJ1 字符串最后一个单词的长度

描述

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）

输入描述：

输入一行，代表要计算的字符串，非空，长度小于5000。

输出描述：

输出一个整数，表示输入字符串最后一个单词的长度。

示例1

输入：

hello nowcoder

复制

输出：

8

复制

说明：

最后一个单词为nowcoder，长度为8

#include <iostream>

using namespace std;

int main() {

string s;

while(cin >> s);

cout << s.size();

return 0;

}

HJ4 字符串分隔

描述

•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；

•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

输入描述：

连续输入字符串(每个字符串长度小于等于100)

输出描述：

依次输出所有分割后的长度为8的新字符串

示例1

输入：

abc

输出：

abc00000

#include<iostream>

#include<string>

using namespace std;

int main() {

string s;

while (cin >> s) {

int len = s.size();

//先8个一组输出字符

int j = 0;

for (; j + 8 <= len; j += 8) {

cout << s.substr(j, 8) << endl;

}

//如果还有剩余就在末尾加“0”

if (j < len) {

string tmp;

tmp = s.substr(j, len);

for (int i = len - j; i < 8; i++) tmp += "0";

cout << tmp << endl;

}

}

return 0;

}

HJ18 识别有效的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.68~255.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<bits/stdc++.h>

using namespace std;

int main()

{

vector<int> arr(7, 0);

string s;

while(cin >>s)

{

int n = s.length(),num=0;

vector<int> ips; //记录ip地址的数字

bool isnum = false;

for(int i = 0; i < n; i++)

{

if(isdigit(s[i]))

{

isnum = true;

num = num * 10 + s[i] - '0';

}

else if(s[i] == '.' || s[i] == '~')

{

if(isnum)

{

ips.push_back(num);

isnum = false;

num = 0;

}

else

{

arr[5]++;//没有数字,非法

//bad = true;

break;

}

}

else//非法

{

arr[5]++;

isnum = false;

//bad = true;

break;

}

}

if(ips.empty() || ips[0] == 0 || ips[0] == 127 ||!isnum)

{

continue; //忽略0、127 开头

}

ips.push_back(num); //最后一个数字

int mask = 4; //检查掩码后缀0

for(;mask < 8 && ips[mask] == 255;mask++); //到第一个非全1

if(mask == 4||mask == 8)

{

arr[5]++;

continue;

}

//检查掩码 前缀1，后缀0

if(ips[mask] == 254 || ips[mask] == 252 || ips[mask] == 248 || ips[mask] == 240 || ips[mask] == 224 || ips[mask] == 191 || ips[mask] == 128) mask++;

for(;mask < 8 && ips[mask] == 0;mask++);//全0

if(mask != 8)

{

arr[5]++;

continue;

}

//统计

if(ips[0] >= 1 && ips[0] <= 126)arr[0]++; //A类地址

else if(ips[0] >= 128 && ips[0] <= 191)arr[1]++; //B类地址

else if(ips[0] <= 223)arr[2]++; //C类地址

else if(ips[0] <= 239)arr[3]++; //D类地址

else if(ips[0] <= 255)arr[4]++; //E类地址

if(ips[0]==10 || ips[0]==172&&ips[1]>=16&&ips[1]<=31 || ips[0]==192&&ips[1]==168)arr[6]++; //私网地址

}

for(int i = 0; i < 7; i++)

{

cout<<arr[i]<<" ";

}

cout<<endl;

}

HJ33 整数与IP地址间的转换

原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成

一个长整数。

举例：一个ip地址为10.0.3.193

每段数字 相对应的二进制数

10 00001010

0 00000000

3 00000011

193 11000001

组合起来即为：00001010 00000000 00000011 11000001,转换为10进制数就是：167773121，即该IP地址转换后的数字就是它了。

数据范围：保证输入的是合法的 IP 序列

输入描述：

输入

1 输入IP地址

2 输入10进制型的IP地址

输出描述：

输出

1 输出转换成10进制的IP地址

2 输出转换后的IP地址

示例1

输入：

10.0.3.193

167969729

输出：

167773121

10.3.3.193

#include <iostream>

using namespace std;

int main()

{

long long int a,b,c,d;

long long int num;

while(scanf("%lld.%lld.%lld.%lld",&a,&b,&c,&d)!=EOF){

cout<<(a<<24)+(b<<16)+(c<<8)+d<<endl;//字符串转成10进制

cin>>num;

//10进制转字符串

a = num>>24;

num = num-(a<<24);

b = num>>16;

num = num-(b<<16);

c = num>>8;

d = num-(c<<8);

cout<<a<<"."<<b<<"."<<c<<"."<<d<<endl;

}

}

HJ31 单词倒排

描述

对字符串中的所有单词进行倒排。

说明：

1、构成单词的字符只有26个大写或小写英文字母；

2、非构成单词的字符均视为单词间隔符；

3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；

4、每个单词最长20个字母；

数据范围：字符串长度满足 1≤n≤10000

输入描述：

输入一行，表示用来倒排的句子

输出描述：

输出句子的倒排结果

示例1

输入：

I am a student

输出：

student a am I

示例2

输入：

$bo*y gi!r#l

输出：

l r gi y bo

简单方式

#include <string>

#include <iostream>

#include <vector>

#include <sstream>

using namespace std;

int main() {

string s;

getline(cin, s, '\n');

string tmp;

for (auto i:s)

{

if ((i >= 'a' &&i <= 'z') || (i >= 'A' &&i <= 'Z'))

{

tmp += i;

}

else

{

tmp += " ";

}

}

stringstream ss(tmp);

vector<string> res;

string t;

while(getline(ss, t, ' ')) {

res.push_back(t);

}

for(int i = res.size() - 1; i >= 0; i--) cout << res[i] << " ";

return 0;

}

HJ50 四则运算

描述

输入一个表达式（用字符串表示），求这个表达式的值。

保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

数据范围：表达式计算结果和过程中满足 ∣val∣≤1000 ，字符串长度满足 1≤n≤1000

输入描述：

输入一个算术表达式

输出描述：

得到计算结果

示例1

输入：

3+2*{1+2*[-4/(8-6)+7]}

复制

输出：

25

#include <iostream>

#include <bits/stdc++.h>

using namespace std;

int cal(string& s, int& start) {

stack<int> stk;

char sign = '+';

int num = 0;

for (; start <= s.size(); start++) {

if (s[start] == '(' || s[start] == '{' || s[start] == '[') {

start++;

num = cal(s, start);

start++;

}

if (isdigit(s[start])) {

num = 10 * num + (s[start] - '0');

}

else if (s[start] != ' ' || start == s.size()) {//数字结束

int pre;

switch (sign) {

case '+' :

stk.push(num);

break;

case '-' :

stk.push(-num);

break;

case '*' :

pre = stk.top();

stk.pop();

stk.push(pre * num);

break;

case '/' :

pre = stk.top();

stk.pop();

stk.push(pre / num);

break;

}

if (s[start] == ')' || s[start] == '}' || s[start] == ']')

break;

sign = s[start];//准备后面

num = 0;

}

}

int res = 0;

while (!stk.empty()) {

res += stk.top();

stk.pop();

}

return res;

}

int main() {

string s;

getline(cin, s);

int start = 0;

cout << cal(s, start) << endl;

return 0;

}

HJ36 字符串加密

描述

有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，将所得结果作为新字母表开头，并将新建立的字母表中未出现的字母按照正常字母表顺序加入新字母表。如下所示：

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

T R A I L B Z E S C D F G H J K M N O P Q U V W X Y (实际需建立小写字母的字母表，此字母表仅为方便演示）

上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙， Attack AT DAWN (黎明时攻击)就会被加密为Tpptad TP ITVH。

请实现下述接口，通过指定的密匙和明文得到密文。

数据范围：

1≤n≤100 ，保证输入的字符串中仅包含小写字母

输入描述：

先输入key和要加密的字符串

输出描述：

返回加密后的字符串

示例1

输入：

nihao

ni

输出：

le

#include <bits/stdc++.h>

using namespace std;

int main() {

string info, key;

while (cin >> key >> info) {

string table = "";//新字母表

for (int i :key) {//key去重

if (table.find(i) == -1) {

table.push_back(i);

}

}

for (char i = 'a'; i <= 'z'; i++) {

if (table.find(i) == -1) {

table.push_back(i);//其余字母放后面

}

}

string result;

for (int i = 0; i < info.size(); i++) {//新字母表加密info

result.push_back(table[info[i] - 'a']);

}

cout << result << endl;

}

}

HJ52 计算字符串的编辑距离

描述

Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。

例如：

字符串A: abcdefg

字符串B: abcdef

通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。

要求：

给定任意两个字符串，写出一个算法计算它们的编辑距离。

数据范围：给定的字符串长度满足 ≤1000

1≤len(str)≤1000

输入描述：

每组用例一共2行，为输入的两个字符串

输出描述：

每组用例输出一行，代表字符串的距离

示例1

输入：

abcdefg

abcdef

输出：

1

#include <bits/stdc++.h>

using namespace std;

int main() {

string word1, word2;

while (cin >> word1 >> word2) {

int size1 = word1.size(), size2 = word2.size();

vector<vector<int>> dp(size1 + 1, vector<int>(size2 + 1, 0));//两串的距离

for (int i = 0; i <= size1; i++) dp[i][0] = i;

for (int j = 0; j <= size2; j++) dp[0][j] = j;

for (int i = 1; i <= size1; i++) {

for (int j = 1; j <= size2; j++) {

int same_rep = word1[i - 1] == word2[j - 1] ? dp[i - 1][j - 1] :dp[i - 1][j - 1] + 1;

int ins_del = min(dp[i][j - 1] + 1, dp[i - 1][j] + 1);

dp[i][j] = min(same_rep, ins_del);

}

}

cout << dp[size1][size2] << endl;

}

}

HJ46 截取字符串

描述

输入一个字符串和一个整数 k ，截取字符串的前k个字符并输出

数据范围：字符串长度满足 1≤n≤1000

1≤k≤n

输入描述：

1.输入待截取的字符串

2.输入一个正整数k，代表截取的长度

输出描述：

截取后的字符串

示例1

输入：

abABCcDEF

6

输出：

abABCc

示例2

输入：

bdxPKBhih

6

输出：

bdxPKB

#include <iostream>

using namespace std;

int main() {

string s;

int k;

while (cin >> s >> k) {

cout << s.substr(0,k) << endl;

}

}

HJ71 字符串通配符

描述

问题描述：在计算机中，通配符一种特殊语法，广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。

要求：

实现如下2个通配符：

*：匹配0个或以上的字符（注：能被*和?匹配的字符仅由英文字母和数字0到9组成，下同）

？：匹配1个字符

注意：匹配时不区分大小写。

输入：

通配符表达式；

一组字符串。

输出：

返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false

数据范围：字符串长度：1≤s≤100

进阶：时间复杂度： O(n 2 ) ，空间复杂度：O(n)

输入描述：

先输入一个带有通配符的字符串，再输入一个需要匹配的字符串

输出描述：

返回不区分大小写的匹配结果，匹配成功输出true，匹配失败输出false

示例1

输入：

te?t*.*

txt12.xls

输出：

false

示例2

输入：

z

zz

输出：

false

示例3

输入：

pq

pppq

输出：

false

示例4

输入：

**Z

0QZz

输出：

true

示例5

输入：

?*Bc*?

abcd

输出：

true

示例6

输入：

h*?*a

h#a

输出：

false

说明：

根据题目描述可知能被*和?匹配的字符仅由英文字母和数字0到9组成，所以?不能匹配#，故输出false

示例7

输入：

p*p*qp**pq*p**p***ppq

pppppppqppqqppqppppqqqppqppqpqqqppqpqpppqpppqpqqqpqqp

输出：

false

#include<bits/stdc++.h>

using namespace std;

bool match(const char* s, const char* p) {

//两个字符串同时结束,返回true

if ((*p == '\0') && (*s == '\0')) {

return true;

}

//两个字符串中有一个先结束，返回false

if ((*p == '\0') || (*s == '\0')) {

return false;

}

if (*p == '?') { //通配符为？时

if (!isdigit(*s) && !isalpha(*s)) { //只能匹配数字或字母

return false;

}

//匹配一个字符，从下一个位置开始继续匹配

return match(s + 1, p + 1);

} else if (*p == '*') { //通配符为！时

while (*p == '*') { //多个*和一个*效果相同

p++;

}

p--;

if (!isdigit(*s) && !isalpha(*s)) { //只能匹配数字或字母

return false;

}

//遇到*号，匹配0个（p+1,s不用动），匹配1个（s和p都往前移动1位），匹配多个（p不用动，s+1）

return match(s, p + 1) || match(s + 1, p + 1) || match(s + 1, p);

} else if (tolower(*p) == tolower(*s)) { //不区分大小写

//当前两字符相等，则进行下一个字符的匹配

return match(s + 1, p + 1);

}

return false;//不满足上述三种情况，不匹配

}

int main() {

string p, s;

while (cin >> p >> s) {

bool res = match(s.c_str(), p.c_str());

if (res) {

cout << "true" << endl;

} else {

cout << "false" << endl;

}

}

return 0;

}