2015年华为实习生机试样题（记票统计，计算麻将的番数，Word Maze(单词迷宫)）

转自：http://blog.csdn.net/zhoubin1992/article/details/46483169

这是华为今年实习生招聘给的样题，还是特别喜欢考字符串处理问题。

记票统计

描述:

模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用“A”、”B”、”C”、”D”表示，选举时开始计票, 若输入的不是“A”、”B”、”C”、”D”则视为无效票。选举结束后获取各个候选人的得票数以及无效票的个数，输出结果以添加候选人的顺序进行顺序输出,最后一行为无效的数量。同时getVoteResult命令为结束命令。

运行时间限制:

无限制

内存限制:

无限制

输入:

输入为多行形式输入，每一行为一条命令。输入的命令只会是有效命令不会有非法命令，但可能存在非法的投票，上面已经描述了。

添加候选人的命令如下：addCandidate为命令 xx1为候选人

addCandidate xx1

投票的命令如下：vote为命令 xx1为候选人的字符串

vote xx1

统计投票的命令如下：getVoteResult为命令

getVoteResult

输出:

输出结果以添加候选人的顺序进行顺序输出,最后一行为无效的数量。

样例输入:

addCandidate xx1

addCandidate xx2

addCandidate xx3

addCandidate xx4

addCandidate xx5

addCandidate xx6

vote xx1

vote xx3

vote xx4

vote xx1

vote xx2

vote xx7

vote xx4

vote xx5

vote xx3

vote xx2

vote xx1

vote xx7

getVoteResult

样例输出:

xx1 3

xx2 2

xx3 2

xx4 2

xx5 1

xx6 0

2

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /********************************* 
  2. ----------------------------------- 
  3. 2015年华为实习生机试样题—记票统计 
  4. 题目一：模拟n个人参加选举的过程，并输出选举结果：假设候选人有四人，分别用“A”、”B”、”C”、”D”表示，选举时开始计票,  
  5. 若输入的不是“A”、”B”、”C”、”D”则视为无效票。选举结束后获取各个候选人的得票数以及无效票的个数，输出结果以添加候选 
  6. 人的顺序进行顺序输出,最后一行为无效的数量。同时getVoteResult命令为结束命令。 
  7. 输入：输入为多行形式输入，每一行为一条命令。输入的命令只会是有效命令不会有非法命令，但可能存在非法的投票，上面已经描述了。 
  8.         添加候选人的命令如下：addCandidate为命令 xx1为候选人 
  9.         addCandidate xx1 
  10.         投票的命令如下：vote为命令 xx1为候选人的字符串 
  11.         vote xx1 
  12.         统计投票的命令如下：getVoteResult为命令 
  13.         getVoteResult 
  14. 输出：输出结果以添加候选人的顺序进行顺序输出,最后一行为无效的数量。 
  15. ----------------------------------- 
  16. 思路：看输出格式知道不宜用map（自动排序）。逐个字符串输入判断，建立字符串数组储存候选人，int数组储存得票数，通过下标定位候选人。 
  17. ----------------------------------- 
  18. Author:牧之丶  Date：2015年6月10日 
  19. Email:bzhou84@163.com 
  20. **********************************/  
  21. #include <iostream>  
  22. #include <string>  
  23. #include <vector>  
  24. #include <algorithm>  
  25. using namespace std;  
  26.   
  27. int main()  
  28. {  
  29.     string s,temp,c;  
  30.     vector<string> candidate; //候选人数组  
  31.     int voteNum[255]={0};       //得票数数组  
  32.     int i=0,invalid=0;          //invalid无效票  
  33.     while(cin>>s)  
  34.     {  
  35.         if (s.compare("addCandidate")==0)  
  36.         {  
  37.             cin>>c;  
  38.             candidate.push_back(c);  
  39.         }   
  40.         else if(s.compare("vote")==0)  
  41.         {  
  42.             int j;  
  43.             cin>>temp;  
  44.             for (j=0;j<candidate.size();j++)  
  45.             {  
  46.                 if (temp.compare(candidate[j])==0)  
  47.                 {  
  48.                     voteNum[j]++;  
  49.                     break;  
  50.                 }  
  51.             }  
  52.             if (j==candidate.size())  
  53.             {  
  54.                 invalid++;  
  55.             }  
  56.         }     
  57.         else if (s.compare("getVoteResult")==0)  
  58.         {  
  59.             break;  
  60.         }  
  61.     }  
  62.     //输出  
  63.     for (int k=0;k<candidate.size();k++)  
  64.     {  
  65.         cout<<candidate[k]<< " "<<voteNum[k]<<endl;  
  66.     }  
  67.     cout<<invalid<<endl;  
  68.     system("pause");  
  69.     return 0;  
  70. }  
描述:

计算麻将的番数

       麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。为简化题目，假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种，则这组牌为0番，每种番数是加的关系，例如一组牌既有卡2条又有四归一，则番数为3番。

1.卡2条为一番，即有一局牌是 1条2条3条；

2.四归一为两番，即有4张一样的牌(花色和数字都一样)；

3.巧七对为两番，即一组牌恰好是7对牌；

  一些约定：

1.一组已经和牌的麻将由多局牌组成，一局牌可以是一对牌、3张连续同样花色的牌、3张一样的牌、4张一样的牌。

2.一组已经和牌一般有14张牌，最多可以有18张牌(当有四归一的时候)。
运行时间限制: 无限制
内存限制: 无限制
输入:

       一字符串表示已经和牌的麻将(由输入者保证，编程人员无需考虑没有和牌)，如1T2T3T,4T5T6T,7T8T9T,1D2D3D,4D4D.

说明：

1.”1T”表示1条，T表示条子，前面跟数字几表示几条，数据范围1～9，输入者保证，编程无需考虑输入规范性;

        2.”4D”表示4筒，D表示筒子,前面跟数字几表示几筒，数据范围是1～9, 输入者保证，编程无需考虑输入规范性;

        3.每局牌之间由’,’隔开，输入者保证每局牌都是正确的且按照数字由小到大排序，编程人员无需判断每局牌的正确性；

        4.一组牌以’.’号结束，由输入者保证，编程人员无需考虑是否有”.”号。

        5.输入保证有番数的牌在一局中，编程人员无需考虑排序，即有番数的牌不会分散在多局牌中。

 
输出:

麻将的番数,整型类型。
样例输入: 
1T2T3T,4T5T6T,7T8T9T,1D2D3D,4D4D.
样例输出: 
1
答案提示:

只输出番数，且为整型。

思路分析：
这道题目太长。细细看懂题目是关键，其实就是简单的字符串匹配。
以", ."分割字符串，然后逐个分析字符，只有三种情况要匹配，对字符串长度进行判断并且判断三种情况中的一种：
卡2条：字符串长度等于6，同时判断与"1T2T3T"匹配；
四归一：字符串长度等于8，同时字符串分为四份两两相等；
巧七对：字符串长度等于28，同时分为七份，在每份内判断满足两两相等 。


[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /********************************* 
  2. ----------------------------------- 
  3. 2015年华为实习生机试样题—计算麻将的番数 
  4. 题目一： 麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。为简化题目， 
  5. 假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种，则这组牌为0番，每种番数是加 
  6. 的关系，例如一组牌既有卡2条又有四归一，则番数为3番。 
  7.     1.卡2条为一番，即有一局牌是 1条2条3条； 
  8.     2.四归一为两番，即有4张一样的牌(花色和数字都一样)； 
  9.     3.巧七对为两番，即一组牌恰好是7对牌； 
  10.     一些约定： 
  11.         1.一组已经和牌的麻将由多局牌组成，一局牌可以是一对牌、3张连续同样花色的牌、3张一样的牌、4张一样的牌。 
  12.         2.一组已经和牌一般有14张牌，最多可以有18张牌(当有四归一的时候)。 
  13. 输入： 一字符串表示已经和牌的麻将(由输入者保证，编程人员无需考虑没有和牌)，如1T2T3T,4T5T6T,7T8T9T,1D2D3D,4D4D. 
  14.         说明： 
  15.         1.”1T”表示1条，T表示条子，前面跟数字几表示几条，数据范围1～9，输入者保证，编程无需考虑输入规范性; 
  16.         2.”4D”表示4筒，D表示筒子,前面跟数字几表示几筒，数据范围是1～9, 输入者保证，编程无需考虑输入规范性; 
  17.         3.每局牌之间由’,’隔开，输入者保证每局牌都是正确的且按照数字由小到大排序，编程人员无需判断每局牌的正确性； 
  18.         4.一组牌以’.’号结束，由输入者保证，编程人员无需考虑是否有”.”号。 
  19.         5.输入保证有番数的牌在一局中，编程人员无需考虑排序，即有番数的牌不会分散在多局牌中。 
  20. 输出：麻将的番数,整型类型。 
  21. ----------------------------------- 
  22. 思路：以", ."分割字符串，然后逐个分析字符，只有三种情况要匹配，对字符串长度进行判断并且判断三种情况中的一种： 
  23. 卡2条：字符串长度等于6，同时判断与"1T2T3T"匹配； 
  24. 四归一：字符串长度等于8，同时字符串分为四份两两相等； 
  25. 巧七对：字符串长度等于28，同时分为七份，在每份内判断满足两两相等 。 
  26. ----------------------------------- 
  27. Author:牧之丶  Date：2015年6月10日 
  28. Email:bzhou84@163.com 
  29. **********************************/  
  30. #include <iostream>  
  31. #include <string>  
  32. #include <vector>  
  33. #include <algorithm>  
  34. using namespace std;  
  35. //判断有一局牌是 1T2T3T；   
  36. bool isKaErTiao(string s)  
  37. {  
  38.     if (s.compare("1T2T3T")==0)  
  39.     {  
  40.         return true;  
  41.     }  
  42.     else  
  43.         return false;  
  44. }  
  45. //判断有4张一样的牌(花色和数字都一样)；   
  46. bool isSiGuiYi(string s)  
  47. {  
  48.     string s1=s.substr(0, 2);//substr(0,i)获得字符串中从第0位开始的长度为i的字符串      
  49.     string s2=s.substr(2, 2);  
  50.     string s3=s.substr(4, 2);  
  51.     string s4=s.substr(6);  
  52.     if((s1.compare(s2)==0) &&(s1.compare(s3)==0) &&  (s1.compare(s4)==0)){    
  53.             return true;   
  54.     }    
  55.     else  
  56.         return false;  
  57. }  
  58. //判断一组牌恰好是7对牌；    
  59. bool isQiaoQiDui(string s)  
  60. {  
  61.     //分为七份，在每份内判断满足两两相等    
  62.     int i;  
  63.     for(i=0;i<s.length();i+=4){    
  64.         if((s[i]== s[i+2]) && (s[i+1] == s[i+3])){    
  65.             continue;  
  66.         }    
  67.         else  
  68.             break;  
  69.     }    
  70.     if (i==s.length())  
  71.     {  
  72.         return true;  
  73.     }  
  74.     else  
  75.         return false;  
  76. }  
  77. int main()  
  78. {  
  79.     string str;  
  80.     cin>>str;  
  81.     vector<string> v;  
  82.     int num=0;  
  83.     //以", ."分割字符串  
  84.     while (str!="")  
  85.     {  
  86.         for (int i=0;i<str.length();i++)  
  87.         {  
  88.             if (str[i]==','||str[i]=='.')  
  89.             {   //截取字符串  
  90.                 string t=str.substr(0,i);     //substr(0,i)获得字符串中从第0位开始的长度为i的字符串        
  91.                 string z=str.substr(i+1);     //一个参数，默认截取到字符串最后  
  92.                 if (t!="")  
  93.                 {  
  94.                     v.push_back(t);  
  95.                 }  
  96.                 str=z;      //后面字符串赋值给str  
  97.                 break;  
  98.             }  
  99.         }  
  100.     }  
  101.     for (int i=0;i<v.size();i++)  
  102.     {  
  103.         //分情况进行判断，其他情况不加分   
  104.         //若为卡2条，是则加1分  
  105.         if((6 == v[i].length()) && isKaErTiao(v[i])){    
  106.             num += 1;    
  107.         }    
  108.         //若为四归一，是则加2分    
  109.         if((8 == v[i].length()) && isSiGuiYi(v[i])){    
  110.             num += 2;    
  111.         }    
  112.   
  113.         //若为巧七对，是则加2分    
  114.         if((28 == v[i].length()) && isQiaoQiDui(v[i])){    
  115.             num += 2;    
  116.         }    
  117.     }  
  118.     cout<<num;  
  119.     system("pause");  
  120.     return 0;  
  121. }  
结果：



Word Maze(单词迷宫)

 

 

 

 

 

 

描述:

    Word Maze 是一个网络小游戏，你需要找到以字母标注的食物，但要求以给定单词字母的顺序吃掉。如上图，假设给定单词if，你必须先吃掉i然后才能吃掉f。


    但现在你的任务可没有这么简单，你现在处于一个迷宫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

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. #include <iostream>     
  2. #include <vector>     
  3. #include <string>     
  4. using namespace std;    
  5.   
  6. const int MAX = 30;    
  7. int N, M;    
  8. string sGoal;       // 待匹配字符串    
  9. struct Node    
  10. {    
  11.     int row;    
  12.     int col;    
  13. };    
  14.   
  15. char chess[MAX][MAX];  // 记录单词迷宫  
  16. bool visit[MAX][MAX];  // visit[i][j] = true表示[i][j]是否已经走过，  
  17. bool ava[MAX][MAX];     // ava[i][j] = true表示[i][j]在单词迷宫内  
  18. // ava[i][j] = false表示[i][j]已经越界  
  19. vector<Node> vec;     // 储存符合待匹配字符串起始字符的位置  
  20.   
  21. int r[] = {-1, 0, 1, 0};    
  22. int c[] = {0, -1, 0, 1};    
  23.   
  24. // row: 迷宫横坐标 col:迷宫纵坐标 index:已经搜索到符合要求的字符串长度 length:待匹配字符串长度  
  25. bool DFS(int row, int col, int index, int length)    
  26. {    
  27.     if(index == length) // 已经在迷宫内搜索到符合要求的字符串  
  28.     {    
  29.         return true;    
  30.     }    
  31.   
  32.     int i;    
  33.     for(i = 0; i < 4; i++)  // 0~3表示分别代表上，左，下，右四个方向进行搜索  
  34.     {    
  35.         int rt = row + r[i];        // 根据搜索方向更新坐标  
  36.         int ct = col + c[i];    
  37.         if(!visit[rt][ct] && ava[rt][ct] && chess[rt][ct] == sGoal[index])  // 判断更新后状态是否满足要求  
  38.         {    
  39.             visit[rt][ct] = true;    
  40.             if( DFS( rt, ct, index+1, length) )  // DFS  
  41.             {    
  42.                 return true;    
  43.             }    
  44.             visit[rt][ct] = false;    
  45.         }    
  46.     }    
  47.     return false;    
  48. }    
  49.   
  50. int main()    
  51. {    
  52.     cin >> N >> M;    
  53.     cin >> sGoal;    
  54.     int i,j;    
  55.     memset(visit, false, sizeof(visit));    // 初始化为false;  
  56.     memset(ava, false, sizeof(ava));    
  57.     for(i = 1; i <= N; i++)              // 输入单词迷宫  
  58.     {    
  59.         for(j = 1; j <= M; j++)    
  60.         {    
  61.             char cTemp;    
  62.             cin >> cTemp;    
  63.             chess[i][j] = cTemp;    
  64.             ava[i][j] = true;           // 单词迷宫内ava[i][j]=true  
  65.             if(cTemp == sGoal[0])       // 将待匹配字符串起始字母作为DFS搜索的起点，节省时间  
  66.             {    
  67.                 Node temp;    
  68.                 temp.row = i;    
  69.                 temp.col = j;    
  70.                 vec.push_back(temp);    
  71.             }    
  72.         }    
  73.     }    
  74.   
  75.     bool flag = false;          // flag = false表示在单词迷宫内没有搜索到待匹配字符  
  76.     for(i = 0 ; i < vec.size(); i++)    
  77.     {    
  78.         if( DFS(vec[i].row, vec[i].col, 1, sGoal.size()) )    
  79.         {    
  80.             cout << "YES" << endl;    
  81.             flag = true;    
  82.             break;    
  83.         }    
  84.     }    
  85.   
  86.     if(!flag)    
  87.     {    
  88.         cout << "NO" << endl;    
  89.     }    
  90.     system("pause");  
  91.     return 0;    

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/walccott/p/4957596.html