2012华为上机试题汇总及参考程序

另外更新的2012华为题库地址链接如下： 

1.  2012华为机试排序题目
2.  2012华为2011年9月17日上机题目之最长回文
3. 2012华为2011年9月17日上机题目之约瑟夫环模拟法实现程序
4. 2012中兴南京笔试试题大题汇总及参考程序

地区一：

1. 编写函数string deletestring（string str,string sub_str）从str中查找匹配的字符串sub_str，采用最左匹配，且输出形式为str+"_"+匹配的次数

 题目一的意思应该是求解字符串str中子字符串sub_str的个数，同时输出形式采用原字符串+"_"匹配次数

相信大家第一反应应该是采用kmp，那么下面给出常规优化kmp程序如下（采用字符串数组形式）：

#include<string.h>
using namespace std;

int next[100];
void getnext(char b[])
{
    int i=1,j=0; //ij
    next[1]=0;
    while(i<=strlen(b))
    {
        if(j==0||b[i-1]==b[j-1])
        {
            i++;
            j++;
            next[i]=j;
        }
        else j=next[j]; //
    }
}


int kmp(char a[],char b[])
{
    int i=1,j=1; //i j
    while(i<=strlen(a)&&j<=strlen(b))
    {
        if(j==0||a[i-1]==b[j-1])
        {
            i++;
            j++;
        }
        else j=next[j];
    }
    if(j>strlen(b))
        return i-strlen(b);
    else return 0;
}

2. 高精度数相加，string addBigInt(string num1,string num2) 需要考虑正负数相加

这道题是高精度计算中的最最简单的一题：

目的是模拟人手工运算的过程，进而进行结果的现实；

参考代码（编译环境：Visual Studio 6）： 

 

地区四：

第一题【20分】：鉴定回文数组

给定一个数组判断是否是回文，这题没什么好说明，直接看代码：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 bool isHuiWen(string s)
 5 {
 6     int length_s=s.length();
 7     int i=0;
 8     for(i=0;i<(length_s>>1);i++)
 9     {
10         if(s.at(i)!=s.at(length_s-1-i))
11             return false;
12     }
13     return true;
14 }
15 
16 int main()
17 {
18     string ss="iloveevolis";
19     if(isHuiWen(ss))
20     {
21         cout<<"Huiwen"<<endl;
22     }
23     else
24     {
25         cout<<"No"<<endl;
26     }
27     return 1;

 } 

第二题【30分】：求两个整型数组的异集，即A+B-(A与B的交集)。

这里只是提供我的一个思路：

这个问题的求解可以简化为统计数组A B中任何字符的个数，A+B-(A与B的交集)的结果就是统计仅仅出现过一次的数字：

但是题目中没有限制是字符，而是整形，数据量太大，这里借用了map操作，进行简化内存：

针对这个思路程序如下：

 

 1 #include <iostream>
 2 #include <map>
 3 using namespace std;
 4 
 5 map<int,int> mi;
 6 map<int,int>::iterator mit;
 7 int A[10]={1,2,3,4,5,6,3,2,8,9};
 8 int B[10]={8,7,6,5,9,0,3,4,8,40};
 9 int R[20];
10 int RC=0;
11 
12 
13 void getAB(int* a,int na,int* b,int nb)
14 {
15     string re;
16     mi.clear();
17     for(int i=0;i<na;i++)
18     {
19         mit=mi.find(a[i]);
20         if(mit!=mi.end())
21         {
22             mit->second++;
23         }
24         else
25         {
26             mi.insert(make_pair(a[i],1));
27         }
28     }
29 
30     for(i=0;i<nb;i++)
31     {
32         mit=mi.find(b[i]);
33         if(mit!=mi.end())
34         {
35             mit->second++;
36         }
37         else
38         {
39             mi.insert(make_pair(b[i],1));
40         }
41     }
42 
43     for(mit=mi.begin(),i=0;mit!=mi.end();mit++)
44     {
45         if(mit->second==1)
46         {
47             R[i++]=mit->first;
48         }
49     }
50     RC=i;
51 }
52 
53 int main()
54 {
55     getAB(A,10,B,10);
56     for(int i=0;i<RC;i++)
57     {
58         cout<<R[i]<<" ";
59     }
60     return 1;
61 }

第三题【50分】：判定德州扑克的牌型。给5张牌，返回它的牌型，4个的，3个+对子，顺子，3个+2个单张，2对，1对，其他。

德州扑克我还是很喜欢玩的，其中牌型牌型可以有近10中结果，题目仅仅让我们判断七种。但是这七种结果不具有继承性，所以我们设计一个好的程序。

那么就要统一他们的表现形式，下面是我的思路：

1. 排序
2. 判断跳变次数
3. 进行筛选结果

这样可以较为统一的处理各种结果，参考程序如下：

 

  1 #include <iostream>
  2 #include <algorithm>
  3 using namespace std;
  4 
  5 struct Node{
  6     char type;//0 1 2 3四种花色，可以考虑用enum类型
  7     int v;//面值
  8 };
  9 
 10 Node N[5]={
 11         {0,5},
 12         {0,9},
 13         {0,2},
 14         {0,9},
 15         {0,9},
 16 };
 17 
 18 int n_of_v[5]={0,0,0,0,0};
 19 
 20 bool myCMP(Node& a,Node& b)
 21 {
 22     return a.v>b.v;
 23 }
 24 
 25 bool myNCMP(int a,int b)
 26 {
 27     return a>b;
 28 }
 29 
 30 //获取每个的个数
 31 int getN(Node* Nv)
 32 {
 33     int i=0;
 34     int j=0;
 35     int n=1;
 36     for(i=0;i<4;i++)
 37     {
 38         if(Nv[i].v==Nv[i+1].v)
 39         {
 40             n++;
 41         }
 42         else
 43         {
 44             n_of_v[j++]=n;
 45             n=1;
 46         }
 47     }
 48     n_of_v[j++]=n;
 49     return j;
 50 }
 51 
 52 void showResult()
 53 {
 54     if(n_of_v[0]==4)
 55     {
 56         cout<<"4+1"<<endl;
 57     }
 58     else if(n_of_v[0]==3&&n_of_v[1]==2)
 59     {
 60         cout<<"3+2"<<endl;
 61     }
 62     else if(n_of_v[0]==3&&n_of_v[1]==1)
 63     {
 64         cout<<"3+1+1"<<endl;
 65     }
 66     else if(n_of_v[0]==2&&n_of_v[1]==2)
 67     {
 68         cout<<"2+2+1"<<endl;
 69     }
 70     else if(n_of_v[0]==2&&n_of_v[1]==1)
 71     {
 72         cout<<"2+1+1+1"<<endl;
 73     }
 74     else if(n_of_v[0]==1)
 75     {
 76         //可能是顺子
 77         if(N[0].v==N[1].v+1
 78             &&N[1].v==N[2].v+1
 79             &&N[2].v==N[3].v+1
 80             &&N[3].v==N[4].v+1)
 81         {
 82             cout<<"不好意思，出了个顺子"<<endl;
 83         }
 84         else
 85             cout<<"五张单牌"<<endl;
 86     }
 87 }
 88 
 89 //传入大小为5的结构体数组
 90 //进行判断
 91 int getType(Node* Nv)
 92 {
 93     //首先排序
 94     sort(N,N+5,myCMP);
 95     //提取个数
 96     getN(Nv);
 97     sort(n_of_v,n_of_v+5,myNCMP);
 98 
 99     //根据n_数组进行判断
100 
101     if(n_of_v[0]==4)
102     {
103         cout<<"四个一样的哦"<<endl;
104     }
105     
106     return 1;
107 }
108 int main()
109 {
110     getType(N);
111     showResult();
112     return 1;
113 }

 

 

后续机试题目不断更新中~