华为机考108题（c++）（31-40）

南叔先生

已于 2022-04-03 14:28:04 修改

阅读量1k

点赞数

分类专栏： C++ 文章标签： C++

于 2022-04-03 14:27:53 首次发布

本文链接：https://blog.csdn.net/seek97/article/details/123936839

版权

C++ 专栏收录该内容

40 篇文章 22 订阅

订阅专栏

HJ31 单词倒排

描述

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

说明：

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

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

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

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

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

输入描述：

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

输出描述：

输出句子的倒排结果

方法一：正向统计，逆序输出

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

int main(){
    string s;
    while(getline(cin, s)){
        vector<string> output;
        output.clear();
        string temp = "";
        for(int i = 0; i < s.length(); i++){
            if(s[i] >= 'a' && s[i] <= 'z' || s[i] >= 'A' && s[i] <= 'Z') //字母
                temp += s[i]; //单词拼接
            else{ //非字母，如果有单词才加入数组，没有说明前面是多个其他符号，忽略
                if(temp.length() > 0){ //前面是记录了单词的
                    output.push_back(temp);  //单词加入数组
                    temp = ""; //置空，重新添加字母
                }
            }
        }
        if(temp.length() > 0)
            output.push_back(temp); //最后一个单词
        for(int i = output.size() - 1; i >= 0; i--) //逆序输出
            cout << output[i] << " ";
    }
    return 0;
}

方法二：正则表达式分割

import java.util.*;
public class Main {

    public Main() {
    }
    
    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { //连续输入
            String str = in.nextLine();  
            System.out.println(solution.reverse(str)); //经过倒排得到输出
        }
    } 
    
    public String reverse(String str) { 
        String[] words = str.split("[^A-Za-z]"); // 匹配非字母的字符进行分割
        StringBuilder res = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) // 逆序添加分割完的单词并加入空格分隔
            res.append(words[i]).append(" ");
        return res.toString().trim();
    }
}

方法三：模拟

import java.util.*;
public class Main {

    public Main() {
    }
    
    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { //连续输入
            String str = in.nextLine();  
            System.out.println(solution.reverse(str)); //经过倒排得到输出
        }
    } 
    
    public String reverse(String str) { 
        String[] words = str.split("[^A-Za-z]"); // 匹配非字母的字符进行分割
        StringBuilder res = new StringBuilder();
        for (int i = words.length - 1; i >= 0; i--) // 逆序添加分割完的单词并加入空格分隔
            res.append(words[i]).append(" ");
        return res.toString().trim();
    }
}

HJ32 密码截取

描述

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

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

输入描述：

输入一个字符串（字符串的长度不超过2500）

输出描述：

返回有效密码串的最大长度

方法一：中心扩散法

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s;
    while(cin >> s){
        int maxlen = 0;
        for(int i = 1; i < s.length(); i++){ //每个点都可以为中心
            //计算以i-1和i为中心的偶数长度的回文子串长度
            int low = i - 1, high = i;
            while(low >= 0 && high < s.length() && s[low] == s[high]){ //中心两边必须都相同
                low--;
                high++;
            }
            maxlen = max(maxlen, high - low - 1); 
            //计算以i为中心的奇数长度的回文子串长度
            low = i - 1, high = i + 1;
            while(low >= 0 && high < s.length() && s[low] == s[high]){ //中心两边必须都相同
                low--;
                high++;
            }
            maxlen = max(maxlen, high - low - 1);
        }
        cout << maxlen << endl;
    }
    return 0;
}

方法二：动态规划

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

int main(){
    string s;
    while(cin >> s){
        int n = s.length();
        vector<vector<bool> > dp(n, vector<bool>(n, false)); //dp[j][i]=1表示从j到i是回文子串
        int maxlen = 1; //初始为1
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= i; j++){
                if(i == j) //奇数长度子串
                    dp[j][i] = true;
                else if(i - j == 1) //偶数长度子串
                    dp[j][i] = (s[i] == s[j]);
                else
                    dp[j][i] = (s[i] == s[j] && dp[j + 1][i - 1]); //这两个字符相等，同时中间缩也要相等
                if(dp[j][i] && i - j + 1 > maxlen) //取最大
                    maxlen = i - j + 1;
            }
        }
        cout << maxlen << endl;
    }
    return 0;
}

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地址

方法一：逐位分割，逐位计算

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

void toNum(string ip){
    long num[4] = {0, 0, 0, 0};
    int point = 0; //记录点出现的次数
    for(int i = 0; i < ip.length(); i++){ //遍历ip字符串
        if(ip[i] != '.'){ //通过.分割
            num[point] = num[point] * 10 + ip[i] - '0';
        }else{
            point++; //点数增加
        }
    }
   long output = num[0] << 24 | num[1] << 16 | num[2] << 8 | num[3]; //位运算组装
   cout << output << endl;
}

void toIP(long num){
    string output = "";
    output += to_string((num >> 24) & 0xff); //取第一个八位二进制转换成字符
    output += ".";
    output += to_string((num >> 16) & 0xff); //取第二个八位二进制转换成字符
    output += ".";
    output += to_string((num >> 8) & 0xff); //取第三个八位二进制转换成字符
    output += ".";
    output += to_string(num & 0xff); //取第四个八位二进制转换成字符
    cout << output << endl;
}

int main(){
    string ip;
    long num;
    while(cin >> ip >> num){ //默认第一个是IP地址第二个是整数
        toNum(ip);
        toIP(num);
    }
    return 0;
}

方法二：正则表达式+字符串流输入输出

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

int main(){
    string s;
    while(cin >> s){
        if(s.find_first_of('.') != string::npos){ //查找到有.的就是IP地址
            long num[4];
            stringstream(regex_replace(s, regex("\\."), " ")) >> num[0] >> num[1] >> num[2] >> num[3]; //用正则表达式分割后输入数组
            long output = num[0] << 24 | num[1] << 16 | num[2] << 8 | num[3]; //位运算组装
            cout << output << endl;
        }else{ //否则是整数
            long num;
            stringstream(s) >> num; //流输入转数字
            stringstream output;
            output << ((num >> 24) & 0xff) << "." << ((num >> 16) & 0xff) << "." << ((num >> 8) & 0xff) << "." << (num & 0xff); //流输出格式
            cout << output.str() << endl; //转字符串输出
        }
    }
    return 0;
}

HJ34 图片整理

描述

Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。

Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。

数据范围：每组输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000

输入描述：

一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。

输出描述：

Lily的所有图片按照从小到大的顺序输出

方法一：sort函数快排

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int main(){
    string s;
    while(cin >> s){
        sort(s.begin(), s.end()); //sort函数直接排序
        cout << s << endl;
    }
    return 0;
}

方法二：桶排序思想

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

int main(){
    string s;
    while(cin >> s){
        vector<int> table(123, 0); //统计123个ASCⅡ码出现次数
        for(int i = 0; i < s.length(); i++){ //遍历字符串
            table[s[i]]++; //相应ASCⅡ出现次数加1
        }
        for(int i = 0; i < table.size(); i++){ //遍历桶
            while(table[i] > 0){ //依次输出所有桶中大于1的所有字符
                cout << char(i);
                table[i]--; //如果有多个要输出多次
            }
        }
        cout << endl;
    }
    return 0;
}

HJ35 蛇形矩阵

描述

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。

例如，当输入5时，应该输出的三角形为：

1 3 6 10 15

2 5 9 14

4 8 13

7 12

输入描述：

输入正整数N（N不大于100）

输出描述：

输出一个N行的蛇形矩阵。

方法一：顺序填表

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

int main(){
    int n; 
    while(cin >> n){
        vector<vector<int> > matrix(n, vector<int>(n, 0)); //定义一个n*n的矩阵
        int num = 1;
        for(int i = 0; i < n; i++){
            int j = i, k = 0;
            while(j >= 0){
                matrix[j][k] = num; //录入数字
                num++;
                j--; //往右上方移
                k++;
            }
        }
        for(int i = 0; i < n; i++){ //遍历数组每一行
            int j = 0;
            while(matrix[i][j] != 0 && j < n){ //每行只输出前面非零部分
                cout << matrix[i][j] << " ";
                j++;
            }
            cout << endl; //换行
        }
    }
    return 0;
}

方法二：数学规律

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

int main(){
    int n; 
    while(cin >> n){
        int k = 1; //起始元素为1
        for(int i = 1; i <= n; i++){ //遍历每一行
            cout << k << " ";  //输出每行首
            int temp = k;
            for(int j = i + 1; j <= n; j++){ //遍历本行的数
                temp += j; //每个数相差为j
                cout << temp << " ";
            }
            cout << endl;
            k += i; //下一行的首为这行首加上这行行号
        }
    }
    return 0;
}

方法三:

#include <bits/stdc++.h>

using namespace std;
int a[105][105];

int main(){
    int n;
    while(cin >> n){
        int num=1;
        for(int i=0;i<n;i++){//下标总和
            for(int j=0;j<=i;j++){//列下标
                a[i-j][j]=num++;//行下标=下标总和-列下标
            }
        }
        for(int i=0;i<n;i++){//遍历输出
            for(int j=0;j<n-i;j++){
                cout << a[i][j] << " ";
            }
            cout << 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和要加密的字符串

输出描述：

返回加密后的字符串

方法一：暴力解法

#include<iostream>
#include<string>
#include<cctype>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
    string key, words;
    while(cin >> key >> words){
        vector<char> v;
        for(int i = 0; i < key.length(); i++){ //遍历字符串key
            key[i] = toupper(key[i]); //全部转大写
            auto it = find(v.begin(), v.end(), key[i]); //查找是否加入过了
            if(it == v.end()) //非重复加入
                v.push_back(key[i]);
        }
        for(char c = 'A'; c <= 'Z'; c++){ //从A遍历到Z
            auto it = find(v.begin(), v.end(), c); //没有出现过
            if(it == v.end()) 
                v.push_back(c); //才加入
        }
        string output = "";
        for(int i = 0; i < words.length(); i++){ //遍历要加密的字符串
            if(islower(words[i])) //遇到小写字符
                output += v[words[i] - 'a'] + 32; //需要在转出来的大写字母基础上加32
            else
                output += v[words[i] - 'A']; //大写字母直接替换
        }
        cout << output << endl;
    }
    return 0;
}

方法二：哈希方式优化

#include<iostream>
#include<string>
#include<cctype>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
    string key, words;
    while(cin >> key >> words){
        vector<char> v;
        vector<bool> flag(26, true);
        for(int i = 0; i < key.length(); i++){ //遍历字符串key
            key[i] = toupper(key[i]); //全部转大写
            if(flag[key[i] - 'A']){ //没有在密钥中出现过
                flag[key[i] - 'A'] = false; //设置为该字母出现过了
                v.push_back(key[i]); //加入密钥
            }
        }
        for(char c = 'A'; c <= 'Z'; c++){ //从A遍历到Z
           if(flag[c - 'A']){  //没有在密钥中出现过
               flag[c - 'A'] = false; //设置为该字母出现过了
               v.push_back(c); //加入密钥
           }
        }
        string output = "";
        for(int i = 0; i < words.length(); i++){ //遍历要加密的字符串
            if(islower(words[i])) //遇到小写字符
                output += v[words[i] - 'a'] + 32; //需要在转出来的大写字母基础上加32
            else
                output += v[words[i] - 'A']; //大写字母直接替换
        }
        cout << output << endl;
    }
    return 0;
}

方法三：简洁写法

#include<iostream>
#include<string>
#include<cctype>
#include<vector>
#include<algorithm>
using namespace std;

int main(){
    string key, words;
    while(cin >> key >> words){
        vector<char> v;
        vector<bool> flag(26, true);
        for(int i = 0; i < key.length(); i++){ //遍历字符串key
            key[i] = toupper(key[i]); //全部转大写
            if(flag[key[i] - 'A']){ //没有在密钥中出现过
                flag[key[i] - 'A'] = false; //设置为该字母出现过了
                v.push_back(key[i]); //加入密钥
            }
        }
        for(char c = 'A'; c <= 'Z'; c++){ //从A遍历到Z
           if(flag[c - 'A']){  //没有在密钥中出现过
               flag[c - 'A'] = false; //设置为该字母出现过了
               v.push_back(c); //加入密钥
           }
        }
        string output = "";
        for(int i = 0; i < words.length(); i++){ //遍历要加密的字符串
            if(islower(words[i])) //遇到小写字符
                output += v[words[i] - 'a'] + 32; //需要在转出来的大写字母基础上加32
            else
                output += v[words[i] - 'A']; //大写字母直接替换
        }
        cout << output << endl;
    }
    return 0;
}

HJ37 统计每个月兔子的总数

描述

有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。

例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。

假如兔子都不死，问第n个月的兔子总数为多少？

数据范围：输入满足 1≤n≤31

输入描述：

输入一个int型整数表示第n个月

输出描述：

输出对应的兔子总数

方法一：递归

#include<iostream>
using namespace std;

int getSum(int n) { //求每个月兔子数
    if(n == 1 || n == 2) //n=1或2跳出递归
        return 1;
    return getSum(n - 1) + getSum(n - 2); //返回前两个月相加
}

int main(){
    int n;
    while(cin >> n){ //每次输入n
        cout << getSum(n) << endl; 
    }
    return 0;
}

方法二：动态规划

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

int main(){
    int n;
    while(cin >> n){ //每次输入n
        vector<int> dp(n + 1);
        dp[1] = 1; //初始第一个月
        dp[2] = 1; //第二个月
        for(int i = 3; i <= n; i++) //后面的每个月由前面的累加
            dp[i] = dp[i - 1] + dp[i - 2];
        cout << dp[n] << endl;
    }
    return 0;
}

方法三：迭代

#include<iostream>
using namespace std;

int main(){
    int n;
    while(cin >> n){ //每次输入n
        if(n <= 2) //前两个月直接输出
            cout << 1 << endl;
        else{
            int dpi_2 = 1; //初始化第1个月
            int dpi_1 = 1; //初始化第2个月
            int output = 0;
            for(int i = 3; i <= n; i++){
                output = dpi_1 + dpi_2; //公式相加
                dpi_2 = dpi_1; //变量更新
                dpi_1 = output;
            }
            cout << output << endl;
        }
    }
    return 0;
}

HJ38 求小球落地5次后所经历的路程和第5次反弹的高度

描述

假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？

数据范围：输入的小球初始高度满足 1≤n≤1000 ，且保证是一个整数

输入描述：

输入起始高度，int型

输出描述：

分别输出第5次落地时，共经过多少米以及第5次反弹多高。
注意：你可以认为你输出保留六位或以上小数的结果可以通过此题。

方法一：过程模拟

#include <iostream>
#include <iomanip>
using namespace std;
 
int main() {
    double h;
    int n = 5;
    cin >> h;
    double dis = 0;
    for(int i = 0; i < n; i++){
        dis += h; //每次加上落下来的距离
        h /= 2; //弹起距离缩短一半
        if(i == n - 1)
            cout << setprecision(6) << dis << endl << setprecision(6) << h << endl;
        dis += h; //弹上去走的距离
    }
    return 0;
}

方法二：直接计算

#include <iostream>
#include <iomanip>
using namespace std;
 
int main() {
    double h;
    cin >> h;
    cout << setprecision(6) << 2.875 * h << endl << setprecision(6) << 0.03125 * h << endl;
    return 0;
}

HJ39 判断两个IP是否属于同一子网

描述

IP地址是由4个0-255之间的整数构成的，用"."符号相连。

二进制的IP地址格式有32位，例如：10000011，01101011，00000011，00011000;每八位用十进制表示就是131.107.3.24

子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。

子网掩码与IP地址结构相同，是32位二进制数，由1和0组成，且1和0分别连续，其中网络号部分全为“1”和主机号部分全为“0”。

你可以简单的认为子网掩码是一串连续的1和一串连续的0拼接而成的32位二进制数，左边部分都是1，右边部分都是0。

利用子网掩码可以判断两台主机是否中同一子网中。

若两台主机的IP地址分别与它们的子网掩码进行逻辑“与”运算（按位与/AND）后的结果相同，则说明这两台主机在同一子网中。

示例：
I P 地址　 192.168.0.1
子网掩码　 255.255.255.0

转化为二进制进行运算：

I P 地址　 11000000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000

AND运算 11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

I P 地址　 192.168.0.254
子网掩码　 255.255.255.0
转化为二进制进行运算：

I P 地址　11000000.10101000.00000000.11111110
子网掩码 11111111.11111111.11111111.00000000

AND运算 11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

输入一个子网掩码以及两个ip地址，判断这两个ip地址是否是一个子网络。

若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2。

注:

有效掩码与IP的性质为：
1. 掩码与IP每一段在 0 - 255 之间
2. 掩码的二进制字符串前缀为网络号，都由‘1’组成；后缀为主机号，都由'0'组成

输入描述：

3行输入，第1行是输入子网掩码、第2，3行是输入两个ip地址
题目的示例中给出了三组数据，但是在实际提交时，你的程序可以只处理一组数据（3行）。

输出描述：

若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2

方法一：

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    vector<int> mask(4,0);
    vector<int> ip1(4,0);
    vector<int> ip2(4,0);
    char c;
    while (cin>>mask[0]>>c>>mask[1]>>c>>mask[2]>>c>>mask[3])//输入掩码
    {
        int flag = -1;//结果
        cin>>ip1[0]>>c>>ip1[1]>>c>>ip1[2]>>c>>ip1[3];//第一个ip地址
        cin>>ip2[0]>>c>>ip2[1]>>c>>ip2[2]>>c>>ip2[3];//第二个ip地址
        for(int i=0;i<4;i++)//两个ip地址和掩码每一段都要在0-255之间
        {
            if(mask[i]<0 || mask[i]>255 || ip1[i]<0 || ip1[i]>255 ||ip2[i]<0 || ip2[i]>255)
            {
                flag = 1;//格式非法
                break;
            }
        }
        for(int i=0;i<3;i++)//掩码的网络号全为1，主机号全为0
        {
            if(mask[i]<255 && mask[i+1]>0)
            {
                flag = 1;
                break;
            }
        }
        if(flag==1)//格式非法，输出1
        {
            cout<<flag<<endl;
        }else{
            for(int i=0;i<4;i++)
            {
                if((mask[i]&ip1[i])!=(mask[i]&ip2[i]))//两个ip地址和掩码做AND操作
                {
                    flag = 2;
                    break;
                }else{//AND操作结果不相同
                    flag = 0;
                }
            }
            cout<<flag<<endl;
        }
    }
    return 0;
}

方法二：正则表达式

#include<iostream>
#include<vector>
#include<string>
#include<regex>

using namespace std;

int main()
{
    vector<int> mask(4,0);
    vector<int> ip1(4,0);
    vector<int> ip2(4,0);
    regex pattern("((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)\.){4}");//匹配0.0.0.0.-255.255.255.255.的正则表达式
    char c;
    while (cin>>mask[0]>>c>>mask[1]>>c>>mask[2]>>c>>mask[3])//输入掩码
    {
        int flag = -1;//结果
        cin>>ip1[0]>>c>>ip1[1]>>c>>ip1[2]>>c>>ip1[3];//第一个ip地址
        cin>>ip2[0]>>c>>ip2[1]>>c>>ip2[2]>>c>>ip2[3];//第二个ip地址
        string str_mask,str_ip1,str_ip2;
        for(int i=0;i<4;i++){
            str_mask+=to_string(mask[i])+'.';
            str_ip1+=to_string(ip1[i])+'.';
            str_ip2+=to_string(ip2[i])+'.';
        }
        if((regex_match(str_mask,pattern)&&regex_match(str_ip1,pattern)&&regex_match(str_ip2,pattern))==false)
        {
            flag=1;
        }
        for(int i=0;i<3;i++)//掩码的网络号全为1，主机号全为0
        {
            if(mask[i]<255 && mask[i+1]>0)
            {
                flag = 1;
                break;
            }
        }
        if(flag==1)//格式非法，输出1
        {
            cout<<flag<<endl;
        }else{
            for(int i=0;i<4;i++)
            {
                if((mask[i]&ip1[i])!=(mask[i]&ip2[i]))//两个ip地址和掩码做AND操作
                {
                    flag = 2;
                    break;
                }else{//AND操作结果相同
                    flag = 0;
                }
            }
            cout<<flag<<endl;
        }
    }
    return 0;
}

HJ40 统计字符

描述

输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。

数据范围：输入的字符串长度满足 ≤n≤1000

输入描述：

输入一行字符串，可以有空格

输出描述：

统计其中英文字符，空格字符，数字字符，其他字符的个数

方法一：ASCII码统计

#include<iostream>
#include<string>

using namespace std;

int main(){
    string str;
    int num_e,num_w,num_n,num_o;//英文字母、空格、数字、其他字符的数量
    num_e=num_w=num_n=num_o=0;
    while(getline(cin,str))//逐行统计
    {
        num_e=num_w=num_n=num_o=0;//每从新的一行开始统计的时候都要清零
        for(int i=0;i<str.size();i++){
            if(str[i]>='0'&&str[i]<='9'){//数字
                num_n++;
            }else if((str[i]>='a'&&str[i]<='z')||(str[i]>='A'&&str[i]<='Z')){//英文字母
                num_e++;
            }else if(str[i]==' '){//空格
                num_w++;
            }else num_o++;//其他字符
        }
        cout<<num_e<<endl<<num_w<<endl<<num_n<<endl<<num_o<<endl;
    }
    return 0;
}

方法二：isspace()

除了比较ASCⅡ码，我们还可以调用字符串string类中的内置函数，一些内置函数如下：

字符判断函数	作用
isalpha()	判断字符是否是字母（'a'-'z' 'A'-'Z'）
isdigit()	判断字符是否是数字
isspace()	判断字符是否是空格、制表符、换行等标准空白
isalnum()	判断字符是否是字母或者数字
ispunct()	判断字符是标点符号
islower()	判断字符是否是小写字母（'a'-'z'）
isupper()	判断字符是否是大写字母（'A'-'Z'）

#include<iostream>
#include<string>

using namespace std;

int main(){
    string str;
    int num_e,num_w,num_n,num_o;//英文字母、空格、数字、其他字符的数量
    num_e=num_w=num_n=num_o=0;
    while(getline(cin,str))//逐行统计
    {
        num_e=num_w=num_n=num_o=0;//每从新的一行开始统计的时候都要清零
        for(int i=0;i<str.size();i++){
            if(isdigit(str[i])){//数字
                num_n++;
            }else if(isalpha(str[i])){//英文字母
                num_e++;
            }else if(isspace(str[i])){//空格
                num_w++;
            }else num_o++;//其他字符
        }
        cout<<num_e<<endl<<num_w<<endl<<num_n<<endl<<num_o<<endl;
    }
    return 0;
}

南叔先生

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
华为机考108题（c++）（31-40）

HJ31单词倒排描述对字符串中的所有单词进行倒排。说明：1、构成单词的字符只有26个大写或小写英文字母；2、非构成单词的字符均视为单词间隔符；3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；4、每个单词最长20个字母；数据范围：字符串长度满足1≤n≤10000输入描述：输入一行，表示用来倒排的句子输出描述：输出句子的倒排结果方法一：正向统计，逆序输出#include<...
复制链接

扫一扫