华为机试真题练习汇总（31~40）

华为机试真题练习汇总（31~40）

题目来源：华为机试 - 牛客

标记 * 号的代表有难度的题目。

HJ31 单词倒排

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

说明：

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

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

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

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

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

输出描述：
输出句子的倒排结果

代码：

#include <cctype>
#include <iostream>
#include <ostream>
#include <sstream>
#include <vector>
using namespace std;

int main()
{
    string input;
    getline(cin, input);
    for (char& c : input)
        if (!isalpha(c))
            c = ' ';
    stringstream ss(input);
    string word;
    vector<string> words;
    while (ss >> word)
        words.push_back(word);
    for (int i = words.size() - 1; i > 0; i--)
        cout << words[i] << " ";
    cout << words[0] << endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

HJ32 密码截取

实质：最长回文子串

算法一：暴力

#include <iostream>
using namespace std;

bool isPalindrome(string& s) {
    return s == string(s.rbegin(), s.rend());
}

int main() {
    string s;
    cin >> s;

    int n = s.length(), maxLen = 0;
    for (int i = 0; i < n; i++)
        for (int len = 1; len <= n - i; len++) {
            string temp = s.substr(i, len);
            if (isPalindrome(temp) && temp.size() > maxLen)
                maxLen = temp.size();
        }
    cout << maxLen << endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

算法二：动态规划

代码：

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

int main() {
    string s;
    cin >> s;
    int n = s.size(), maxLen = 1, begin = 0;
    // 状态矩阵
    vector<vector<int>> dp(n, vector<int>(n, false));
    // dp[i][j] 表示 s[i...j] 是否是回文串
    // 初始化：所有长度为 1 的子串都是回文串
    for (int i = 0; i < n; i++)
        dp[i][i] = true;
    // 状态转移
    for (int len = 2; len <= n; len++) // 枚举子串长度
        for (int i = 0; i < n; i++) {  // 枚举左边界
            int j = i + len - 1; // 计算右边界
            if (j >= n)          // 右边界越界
                break;
            if (s[i] != s[j])
                dp[i][j] = false;
            else {
                if (j - i <= 2)
                    dp[i][j] = true;
                else
                    dp[i][j] = dp[i + 1][j - 1];
            }
            if (dp[i][j] == true && j - i + 1 > maxLen) {
                maxLen = j - i + 1;
                begin = i;
            }
        }
    cout<<maxLen<<endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

算法三：Manacher 算法

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

// 辅函数 - 以s [left...right] 为起点，计算回文半径（可拓展的步数）
int expand(string s, int left, int right) {
    while (left >= 0 && right < s.size() && s[left] == s[right]) {
        left--;
        right++;
    }
    // 由于while循环退出后left和right各多走了一步，所以在返回的总长度时要减去2
    return (right - left - 2) / 2;
}
// 辅函数 - 对原始字符串 s 进行预处理（添加分隔符）
string addBoundaries(string s, char divide) {
    if (s.empty())
        return "";
    string t;
    for (char& c : s) {
        t += divide;
        t += c;
    }
    t += divide;
    return t;
}
// Manacher 算法
string manacher(string s) {
    // 特判
    if (s.empty() || s.size() < 2)
        return s;
    // 对原始字符串 s 做处理，添加分隔符（例如：将 abc 变成 #a#b#c#）
    string str = addBoundaries(s, '#');
    int n = str.size();
    // right 表示目前计算出的最右端范围，right 和左边都是已探测过的
    int right = 0;
    // center 表示最右端位置的中心对称点
    int center = 0;
    int start = 0, maxLen = 0;
    // p 数组记录所有已探测过的回文半径，后面我们再计算 i 时，根据 p[i_mirror] 计算 i
    vector<int> p(n, 0);
    // 从左到右遍历处理过的字符串，求每个字符的回文半径
    for (int i = 0; i < n; ++i) {
        // 根据i和right的位置分为两种情况：
        // 1. i <= right，利用已知的信息来计算 i
        // 2. i > right，说明 i 的位置时未探测过的，只能用中心探测法
        if (right >= i) {
            // 这句是关键，不用再像中心探测那样，一点点的往左/右扩散，根据已知信息
            // 减少不必要的探测，必须选择两者中的较小者作为左右探测起点
            int minArmLen = min(right - i, p[2 * center - i]);
            p[i] = expand(str, i - minArmLen, i + minArmLen);
        } else {
            // i 落在 right 右边，是没被探测过的，只能用中心探测法
            p[i] = expand(str, i, i);
        }
        // 大于right，说明可以更新最右端范围了，同时更新 center
        if (i + p[i] > right) {
            center = i;
            right = i + p[i];
        }
        // 找到了一个更长的回文半径，更新原始字符串的 start 位置
        if (p[i] > maxLen) {
            maxLen = p[i];
            start = (i - p[i]) / 2;
        }
    }
    // 根据 start 和 maxLen ，从原始字符串中截取一段返回
    return s.substr(start, maxLen);
}


int main() {
    string s;
    cin >> s;
    cout << manacher(s).size() << endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

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>
using namespace std;

int main()
{
    long long a, b, c, d, num;
    scanf("%lld.%lld.%lld.%lld%lld", &a, &b, &c, &d, &num);
    cout << (a << 24) + (b << 16) + (c << 8) + d << endl;

    cout << (num >> 24) << ".";
    num -= (num >> 24 << 24);
    cout << (num >> 16) << ".";
    num -= (num >> 16 << 16);
    cout << (num >> 8) << ".";
    num -= (num >> 8 << 8);
    cout << num << endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

HJ34 图片整理

描述
Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过代码解决。
Lily使用的图片使用字符"A"到"Z"、“a"到"z”、"0"到"9"表示。

输入描述：
一行，一个字符串，字符串中的每个字符表示一张Lily使用的图片。

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

代码：

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

int main() {
    string s;
    cin >> s;
    sort(s.begin(), s.end());
    cout << s;
    return 0;
}
// 64 位输出请用 printf("%lld")

HJ35 蛇形矩阵

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

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

1 3 6 10 15

2 5 9 14

4 8 13

7 12

11

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

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

代码：

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

int main() {
    int n;
    cin >> n;

    int num = 1;
    vector<vector<int>> grid(n, vector<int>(n, 0));
    for (int i = 0; i < n; i++) {
        int j = i, k = 0;
        while (j >= 0) {
            grid[j][k] = num;
            num++;
            j--;
            k++;
        }
    }
    // 遍历
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            if (grid[i][j])
                cout << grid[i][j] << " ";
        cout << endl;
    }
    return 0;
}
// 64 位输出请用 printf("%lld")

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。

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

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

输出描述：
返回加密后的字符串

代码：

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

int main() {
    string key;
    cin >> key;
    set<char> keySet;
    vector<int> keyHash;
    for (char& c : key) {
        if (!keySet.count(c)) {
            keyHash.push_back(c - 'a');
            keySet.insert(c);
        }
    }
    for (int i = 0; i < 26; i++) {
        char ch = i + 'a';
        if (!keySet.count(ch))
            keyHash.push_back(i);
    }

    string input;
    cin >> input;
    string ans;
    for (char& c : input) {
        char out = keyHash[c - 'a'] + 'a';
        ans.push_back(out);
    }
    cout << ans << endl;
    return 0;
}
// 64 位输出请用 printf("%lld")

HJ37 统计每个月兔子的总数

描述
有一种兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子。
例子：假设一只兔子第3个月出生，那么它第5个月开始会每个月生一只兔子。
一月的时候有一只兔子，假如兔子都不死，问第n个月的兔子总数为多少？

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

输出描述：
输出对应的兔子总数

代码：

#include <iostream>
using namespace std;

int rabbit_sum(int n) {
    if (n == 1 || n == 2)
        return 1;
    return rabbit_sum(n - 1) + rabbit_sum(n - 2);
}

int main() {
    int n;
    cin >> n;
    cout << rabbit_sum(n) << endl;
    return 0;
}
// 64 位输出请用 printf("%lld")

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

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

输入描述：
输入起始高度，int型

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

代码：

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

int main() {
    int n;
    cin >> n;
    double sum = n;
    double height = n;
    for (int i = 1; i <= 4; i++) {
        height /= 2;
        sum += 2 * height;
    }
    printf("%.6lf\n%.6lf\n", sum, height / 2);
    return 0;
}
// 64 位输出请用 printf("%lld")

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）后的结果相同，则说明这两台主机在同一子网中。

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

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

代码：

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

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

bool is_mask(const string& ip) {
    stringstream ss(ip);
    string seg;
    unsigned int b = 0;
    while (getline(ss, seg, '.'))
        b = (b << 8) + stoi(seg);

    if (b == 0 || ~b == 0) {
        // 二进制下全是1或者全是0均为非法子网掩码
        return false;
    }
    b = ~b + 1;
    if ((b & (b - 1)) == 0)
        return true;
    return false;
}

vector<int> ipToVector(const string& ip) {
    stringstream ss(ip);
    string seg;
    vector<int> res;
    while (getline(ss, seg, '.'))
        res.push_back(stoi(seg));
    return res;
}

int subNetwork(const string& mask, const string& ip1, const string& ip2) {
    if (!judge_ip(mask) || !judge_ip(ip1) || !judge_ip(ip2) || !is_mask(mask))
        return 1;

    vector<int> maskVec = ipToVector(mask);
    vector<int> ip1Vec = ipToVector(ip1);
    vector<int> ip2Vec = ipToVector(ip2);
    for (int i = 0; i < 3; i++) {
        int f1 = maskVec[i] & ip1Vec[i];
        int f2 = maskVec[i] & ip2Vec[i];
        if (f1 != f2)
            return 2;
    }
    return 0;
}

int main()
{
    string mask, ip1, ip2;
    while (cin >> mask >> ip1 >> ip2)
        cout << subNetwork(mask, ip1, ip2) << endl;

    return 0;
}
// 64 位输出请用 printf("%lld")

HJ40 统计字符

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

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

输出描述：
统计其中英文字符，空格字符，数字字符，其他字符的个数

代码：

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

int main() {
    string input;
    getline(cin, input);
    int alpha = 0, space = 0, digit = 0, other = 0;
    for (char& c : input) {
        if (isalpha(c))
            alpha++;
        else if (isdigit(c))
            digit++;
        else if (c == ' ')
            space++;
        else other++;
    }
    cout << alpha << endl << space << endl << digit << endl << other << endl;
    return 0;
}
// 64 位输出请用 printf("%lld")