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;

28 } 

第二题【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  }

 

 

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