华为上机题汇总（六）

注：编译环境为Visual Studio 2012，答案仅供参考。

目录

第二十六题

26.一副牌中发五张扑克牌给你：让你判断数字的组成：
有以下几种情况：
1：四条：即四张一样数值的牌（牌均不论花色）2：三条带 一对
3：三条带两张不相同数值的牌
4：两对
5：顺子 包括 10，J，Q，K，A
6：什么都不是
7：只有一对

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

bool cmp(const int &a, const int &b){
    return a > b;
}

int judge(vector<int> v){
    sort(v.begin(),v.end());

    vector<int> flags(5,0);
    auto begin = v.begin();
    while (begin != v.end())
    {
        auto ahead = begin + 1;
        while (ahead != v.end() && *ahead == *begin)
        {
            ahead++;
        }
        int flag = ahead - begin;
        flags.push_back(flag);
        begin = ahead;
    }
    sort(flags.begin(),flags.end(),cmp);

    switch (flags[0])
    {
    case 4:
        return 1;
    case 3:
        switch (flags[1])
        {
        case 2:
            return 2;
        case 1:
            return 3;
        default:
            break;
        }
        break;
    case 2:
        switch (flags[1])
        {
        case 2:
            return 4;
        case 1:
            return 7;
        default:
            break;
        }
        break;
    default:
        break;
    }

    for (int i = 0; i < 4; i++)
    {
        if (v[i] != v[i+1]-1)
        {
            return 6;
        }
    }
    return 5;
}

int main()
{
    vector<int> v;
    string s;
    getline(cin,s);
    auto begin = s.begin();
    while (begin != s.end())
    {
        auto ahead = begin + 1;
        while (ahead != s.end() && *ahead != ‘ ‘ && *ahead != ‘,‘)
        {
            ahead++;
        }
        string tmp(begin,ahead);
        int num;
        if (tmp == "J")
        {
            num = 11;
        }
        else if (tmp == "Q")
        {
            num = 12;
        }
        else if (tmp == "K")
        {
            num = 13;
        }
        else if (tmp == "A")
        {
            num = 14;
        }
        else
        {
            num = stoi(tmp);
        }
        v.push_back(num);
        if (ahead == s.end()) break;
        begin = ++ahead;
    }
    cout << judge(v) << endl;

    return 0;
}

第二十七题

27.高精度整数加法
问题描述：
在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，
参与运算的操作数和结果必须在-2^31 ~ 2^31-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊
的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下：
9876543210 + 1234567890 = ?
让字符串 num1=”9876543210”，字符串 num2=”1234567890”，结果保存在字符串 result = “11111111100”。
-9876543210 + (-1234567890) = ?
让字符串 num1=”-9876543210”，字符串 num2=”-1234567890”，结果保存在字符串 result = “-11111111100”。
要求编程实现上述高精度的十进制加法。
要求实现函数：
void add (const char *num1, const char *num2, char *result)
【输入】num1：字符串形式操作数1，如果操作数为负，则num1[0]为符号位’-’
num2：字符串形式操作数2，如果操作数为负，则num2[0]为符号位’-’
【输出】result：保存加法计算结果字符串，如果结果为负，则result[0]为符号位。
注：
I、 当输入为正数时，’+’不会出现在输入字符串中；当输入为负数时，’-‘会出现在输入字符串中，且一定在输入字符串最左边位置；
II、 输入字符串所有位均代表有效数字，即不存在由’0’开始的输入字符串，比如”0012”, “-0012”不会出现；
III、 要求输出字符串所有位均为有效数字，结果为正或0时’+’不出现在输出字符串，结果为负时输出字符串最左边位置为’-‘。

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

//computeType 0：加法 1：减法。large 1：num1绝对值大于等于num2。resultType 0表示结果为正，1表示为负
void judge(string &num1, string &num2, bool &computeType, bool &large, bool &resultType){
    bool flag1 = num1[0] == ‘-‘ ? 1 : 0;
    bool flag2 = num2[0] == ‘-‘ ? 1 : 0;

    computeType = flag1 ^ flag2;
    if (flag1) num1.erase(num1.begin());
    if (flag2) num2.erase(num2.begin());

    if (num1.size() > num2.size()) large = 1;
    else if (num1.size() < num2.size()) large = 0;
    else
    {
        for (unsigned i = 0; i < num1.size(); i++)
        {
            if (num1[i] > num2[i]){
                large = 1;
                break;
            }
            else if (num1[i] < num2[i])
            {
                large = 0;
                break;
            }
        }
    }

    resultType = large ? flag1 : flag2;
}

string compute(const string &s1, const string &s2, bool computeType, bool resultType){
    string s3;
    int over = 0;

    auto b1 = s1.rbegin(), b2 = s2.rbegin();
    while (b1 != s1.rend() && b2 != s2.rend())
    {
        int value1 = (*b1++) - ‘0‘;
        int value2 = (*b2++) - ‘0‘;
        int result = computeType ?  value1-value2+over : value1+value2+over;
        if (result < 0)
        {
            over = -1;
            result += 10;
        }
        else
        {
            over = result/10;
            result %= 10;
        }
        s3.push_back(result + ‘0‘);
    }

    while (b1 != s1.rend())
    {
        int value1 = (*b1++) - ‘0‘;
        int result = computeType ?  value1+over : value1+over;
        if (result < 0)
        {
            over = -1;
            result += 10;
        }
        else
        {
            over = result/10;
            result %= 10;
        }
        s3.push_back(result + ‘0‘);
    }
    s3.push_back(over + ‘0‘);

    auto pos = s3.find_last_not_of("0");
    s3.erase(s3.begin()+pos+1,s3.end());

    for (unsigned i = 0; i < s3.size()/2; i++)
    {
        char tmp = s3[i];
        s3[i] = s3[s3.size()-i-1];
        s3[s3.size()-i-1] = tmp;
    }
    if (resultType) s3.insert(s3.begin(),‘-‘);
    return s3;
}

void add (const char *num1, const char *num2, char *result){
    string s1(num1, strlen(num1));
    string s2(num2, strlen(num2));

    bool computeType,resultType,large = 1;
    judge(s1,s2,computeType,large,resultType);
    string s3 = large ? compute(s1,s2,computeType,resultType) : compute(s2,s1,computeType,resultType);
    for (unsigned i = 0; i < s3.size(); i++)
    {
        result[i] = s3[i];
    }
    result[s3.size()] = ‘\0‘;
}

int main()
{
    char num1[255],num2[255],result[256];
    cin.getline(num1,255);
    cin.getline(num2,255);
    add(num1,num2,result);
    cout << result << endl;
    return 0;
}

第二十八题

28.单词迷宫
题目简介：
Word Maze 是一个网络小游戏，你需要找到以字母标注的食物，但要求以给定单词字母的顺序吃掉。如上图，假设给定单词if，你必须先吃掉i然后才能吃掉f。
但现在你的任务可没有这么简单，你现在处于一个mí宫Maze（n×m的矩阵）当中，里面到处都是以字母标注的食物，但你只能吃掉能连成给定单词W的食物。
如下图，指定W为“SOLO”，则在地图中红色标注了单词“SOLO”。
注意区分英文字母大小写,你只能上下左右行走。
运行时间限制: 无限制
内存限制: 无限制
输入:
输入第一行包含两个整数n、m(0<n, m<21)分别表示n行m列的矩阵，第二行是长度不超过100的单词W，从第3行到底n+3行是只包含大小写英文字母的长度为m的字符串。
输出:
如果能在地图中连成给定的单词，则输出“YES”，否则输出“NO”。注意：每个字母只能用一次。
样例输入:
5 5
SOLO
CPUCY
EKLQH
CRSOL
EKLQO
PGRBC
样例输出:yes

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

bool canVisit(int row, int col, int n, vector<int> hasVisited){
    int index = row * n + col;
    for(auto begin = hasVisited.begin();begin != hasVisited.end();begin++){
        if (index == *begin)
        {
            return false;
        }
    }
    return true;
}

bool hasWay(int row, int col, int n, int m, string::iterator word, vector<string> maze, vector<int> hasVisited, string &s){
    if (++word == s.end()) return true;
    bool flagUp = false, flagDown = false, flagLeft = false, flagRight = false;
    if (row > 0 && maze[row-1][col] == *word && canVisit(row-1,col,n,hasVisited))
    {
        hasVisited.push_back((row-1) * n + col);
        flagUp = hasWay(row-1,col,n,m,word,maze,hasVisited,s);
    }
    if (row < n-1 && maze[row+1][col] == *word && canVisit(row+1,col,n,hasVisited))
    {
        hasVisited.push_back((row+1) * n + col);
        flagDown = hasWay(row+1,col,n,m,word,maze,hasVisited,s);
    }
    if (col > 0 && maze[row][col-1] == *word && canVisit(row,col-1,n,hasVisited))
    {
        hasVisited.push_back(row * n + col-1);
        flagLeft = hasWay(row,col-1,n,m,word,maze,hasVisited,s);
    }
    if (row < m-1 && maze[row][col+1] == *word && canVisit(row,col+1,n,hasVisited))
    {
        hasVisited.push_back(row * n + col+1);
        flagRight = hasWay(row,col+1,n,m,word,maze,hasVisited,s);
    }
    return flagUp || flagDown || flagLeft || flagRight;
}

bool wordGame(int n, int m, string::iterator word, vector<string> maze, string &s){
    vector<int> hasVisited;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (maze[i][j] == *word)
            {
                hasVisited.push_back(i*n+j);
                bool flag = hasWay(i,j,n,m,word,maze,hasVisited,s);
                if (flag) return true;
            }
        }
    }
    return false;
}

int main()
{

    int n,m;
    cin >> n >> m;
    string s;
    cin >> s;
    vector<string> maze;
    for (int i = 0; i < n; i++)
    {
        string tmp;
        cin >> tmp;
        maze.push_back(tmp);
    }
    cout << (wordGame(n,m,s.begin(),maze,s) ? "yes" : "no") << endl;
    return 0;
}

第二十九题

29.10个学生考完期末考试评卷完成后，A老师需要划出及格线，要求如下：
(1) 及格线是10的倍数；
(2) 保证至少有60%的学生及格；
(3) 如果所有的学生都高于60分，则及格线为60分

#include <iostream>
using namespace std;

int countAboveScore(int nums[10], int score){
    int count = 0;
    for (int i = 0; i < 10; i++)
    {
        if (nums[i] >= score)
        {
            count++;
        }
    }
    return count;
}

int caculatePassline(int nums[10]){
    int line = 0;
    for (int i = 0; i <= 60; i += 10)
    {
        if (countAboveScore(nums, i) >= 6)
        {
            line = i;
        }
    }
    return line;
}

int main()
{
    int nums[10];
    for (int i = 0; i < 10; i++)
    {
        cin >> nums[i];
    }
    cout << caculatePassline(nums) << endl;
    return 0;
}

第三十题

30.
一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。开始，电灯全部关着。
有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。
注：电灯数和学生数一致。

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    //约数个数为奇数的灯亮着，为偶数的灯灭。只有平方数的约数为奇数！
    int result = sqrt((double)n);
    cout << "亮着的灯盏数为：" <<result << endl;
    cout << "亮着的灯号码为：";
    for (int i = 1; i <= result; i++)
    {
        cout << i*i << " ";
    }
    cout << endl;
    return 0;
}