华为2011上机笔试题2+参考程序

最新推荐文章于 2023-04-22 19:30:19 发布

Maria21

最新推荐文章于 2023-04-22 19:30:19 发布

阅读量485

点赞数

分类专栏： interview

interview 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

编程题（共2题，第一题40分，第二题60分，共100分。请上机编写程序，按题目要求提交文件。[详见考试说明]

本试题采用自动测试用例进行评分，测试用例不对考生公开，凡不满足提交要求导致不能运行或用例不通过，不予评分）。

1. 识别字符串中的整数并转换为数字形式（40分）

问题描述：
识别输入字符串中所有的整数，统计整数个数并将这些字符串形式的整数转换为数字形式整数。

要求实现函数：
void take_num(const char *strIn, int *n, unsigned int *outArray)

【输入】 strIn：输入的字符串

【输出】 n：统计识别出来的整数个数

outArray：识别出来的整数值，其中outArray[0]是输入字符串中从左到右第一个整数，

outArray[1]是第二个整数，以此类推。数组地址已经分配，可以直接使用

【返回】无

注：

I、不考虑字符串中出现的正负号(+, -)，即所有转换结果为非负整数（包括0和正整数）

II、不考虑转换后整数超出范围情况，即测试用例中可能出现的最大整数不会超过unsigned int可处理的范围

III、需要考虑 '0' 开始的数字字符串情况，比如 "00035" ，应转换为整数35；

"000" 应转换为整数0；"00.0035" 应转换为整数0和35（忽略小数点：mmm.nnn当成两个数mmm和nnn来识别）

IV、输入字符串不会超过100 Bytes，请不用考虑超长字符串的情况。

示例
输入：strIn = "ab00cd+123fght456-25 3.005fgh"

输出：n = 6

outArray = {0, 123, 456, 25, 3, 5}

2. IP地址匹配（60分）

问题描述：
在路由器中，一般来说转发模块采用最大前缀匹配原则进行目的端口查找，具体如下：

IP地址和子网地址匹配：

IP地址和子网地址所带掩码做AND运算后，得到的值与子网地址相同，则该IP地址与该子网匹配。

比如：

IP地址：192.168.1.100

子网：192.168.1.0/255.255.255.0，其中192.168.1.0是子网地址，255.255.255.0是子网掩码。

192.168.1.100&255.255.255.0 = 192.168.1.0，则该IP和子网192.168.1.0匹配

IP地址：192.168.1.100

子网：192.168.1.128/255.255.255.192

192.168.1.100&255.255.255.192 = 192.168.1.64，则该IP和子网192.168.1.128不匹配

最大前缀匹配：

任何一个IPv4地址都可以看作一个32bit的二进制数，比如192.168.1.100可以表示为：11000000.10101000.00000001.01100100，

192.168.1.0可以表示为11000000.10101000.00000001.00000000

最大前缀匹配要求IP地址同子网地址匹配的基础上，二进制位从左到右完全匹配的位数尽量多（从左到右子网地址最长）。比如：

IP地址192.168.1.100，同时匹配子网192.168.1.0/255.255.255.0和子网192.168.1.64/255.255.255.192，

但对于子网192.168.1.64/255.255.255.192，匹配位数达到26位，多于子网192.168.1.0/255.255.255.0的24位，

因此192.168.1.100最大前缀匹配子网是192.168.1.64/255.255.255.192。

请编程实现上述最大前缀匹配算法。

要求实现函数：
void max_prefix_match(const char *ip_addr, const char *net_addr_array[], int *n)

【输入】ip_addr：IP地址字符串，严格保证是合法IPv4地址形式的字符串

net_addr_array：子网地址列表，每一个字符串代表一个子网，包括子网地址和掩码，

表现形式如上述，子网地址和子网掩码用’/’分开，严格保证是

合法形式的字符串；如果读到空字符串，表示子网地址列表结束

【输出】n：最大前缀匹配子网在*net_addr_array[]数组中对应的下标值。如果没有匹配返回-1

示例
输入：

ip_addr = "192.168.1.100"

net_addr_array[] =

{

"192.168.1.128/255.255.255.192",

"192.168.1.0/255.255.255.0",

"192.168.1.64/255.255.255.192",

"0.0.0.0/0.0.0.0",

}

输出：n = 2

参考程序（欢迎讨论）转载请注明来源http://www.cnblogs.com/jerry19880126/

  1 #include <iostream>
  2 using namespace std;
  3 
  4 
  5 // 编程题第一题
  6 // 识别输入字符串中所有的整数，统计整数个数并将这些字符串形式的整数转换为数字形式整数
  7 void take_num(const char *strIn, int *n, unsigned int *outArray)
  8 {
  9     unsigned int len = strlen(strIn);
 10     unsigned int outArrayIndex = 0;
 11     bool hasNumber = false; // temp 中已经存在有效数字
 12     unsigned int temp = 0;
 13     *n = 0;
 14     for(unsigned int i = 0; i < len; ++i)
 15     {
 16         if(strIn[i] >= '0' && strIn[i] <= '9')
 17         {
 18             if(hasNumber == false)
 19             {
 20                 // 间隔后第一次出现的数字
 21                 ++*n;            
 22             }
 23             else
 24             {
 25                 // 连续出现的数字
 26             }
 27             hasNumber = true;
 28             temp = temp * 10 + (strIn[i] - '0');
 29         }
 30         else
 31         {
 32             if(hasNumber)
 33             {
 34                 outArray[outArrayIndex++] = temp;
 35                 temp = 0;
 36                 hasNumber = false;
 37             }        
 38         }
 39     }
 40     if(hasNumber)
 41     {
 42         outArray[outArrayIndex++] = temp;
 43     }
 44 }
 45 
 46 
 47 // 编程题第二题
 48 // IP地址最长匹配问题，要求不仅是匹配，而且是最长匹配
 49 void max_prefix_match(const char *ip_addr, const char *net_addr_array[], int *n)
 50 {
 51     int arrayIndex = 0;
 52     *n = -1;
 53     const char* p = net_addr_array[arrayIndex];
 54     int maxLength = -1; //记录最长匹配串最远的1的位置
 55     int number = 0;// 用于转换字符串形式的点分十进制数至整数
 56     //先把IP址址转换成int型元素的数组
 57     int ipAddress[4];
 58     int netIndex = 0;
 59     int ipLen = strlen(ip_addr);
 60     for(int i = 0; i <= ipLen; ++i)
 61     {
 62         if(ip_addr[i] >= '0' && ip_addr[i] <= '9')
 63         {
 64             number = number * 10 + (ip_addr[i] - '0');
 65         }
 66         else
 67         {
 68             ipAddress[netIndex++] = number;
 69             number = 0;
 70         }
 71     }
 72     while(*p != '\0')
 73     {
 74         
 75         int netAddress[4];//子网地址
 76         int maskAddress[4];//子网掩码
 77         netIndex = 0;
 78         //将点分十进制转成4个int元素
 79         int len = strlen(p); // 本次 IP地址/子网掩码 字符串的长度
 80         number = 0; 
 81         int i;
 82         //先转换给定的子网地址
 83         for(i = 0; ; ++i)
 84         {
 85             if(p[i] >= '0' && p[i] <= '9')
 86             {
 87                 number = number * 10 + (p[i] - '0');
 88             }
 89             else
 90             {
 91                 netAddress[netIndex++] = number;
 92                 number = 0;
 93                 if(p[i] == '/')
 94                 {
 95                     netIndex = 0;
 96                     break;
 97                 }
 98             }
 99         }
100 
101         //再转换子网掩码
102         for(++i; i <= len; ++i)
103         {
104             if(p[i] >= '0' && p[i] <= '9')
105             {
106                 number = number * 10 + (p[i] - '0');
107             }
108             else
109             {
110                 maskAddress[netIndex++] = number;
111                 number = 0;
112             }
113         }
114         netIndex = 0;
115 
116         //判断IP地址和子网掩网的与 是否 和 子网地址相同
117         int j = 0;
118         for(;j < 4; ++j)
119         {
120             if((ipAddress[j] & maskAddress[j]) != netAddress[j])
121             {
122                 break;
123             }
124         }
125         if(j >= 4)
126         {
127             //匹配
128             //再比较长度，从最后往前数，记录下第一个出现1的位置
129             int currentLength = 0;
130             for(int k = 3; k >= 0; --k)
131             {
132                 if(netAddress[k] != 0)
133                 {
134                     currentLength = k * 8;
135                     // 将十进制转成二进制
136                     char binaryArray[8];
137                     int temp = netAddress[k];
138                     int index = 0;
139                     while(temp > 0)
140                     {
141                         if(temp % 2 == 0)
142                         {
143                             binaryArray[index++] = '0';
144                         }
145                         else
146                         {
147                             binaryArray[index++] = '1';
148                         }
149                         temp /= 2;
150                     }
151                     while(index <= 7)
152                     {
153                         binaryArray[index++] = '0';
154                     }
155                     for(int k = 0; k < 8; ++k)
156                     {
157                         if(binaryArray[k] == '1')
158                         {
159                             currentLength += (8 - k);
160                             break;
161                         }
162                     }
163                     break;
164                 }
165             }
166             if(currentLength > maxLength)
167             {
168                 maxLength = currentLength;
169                 *n = arrayIndex;
170             }
171         }
172         //输入下一个数组
173         ++arrayIndex;
174         p = net_addr_array[arrayIndex];
175     }
176 }
177 
178 
179 // 输出
180 void output(unsigned int* a, unsigned int len)
181 {
182     for(unsigned int i = 0; i < len; ++i)
183     {
184         cout << a[i] << " ";
185     }
186     cout << endl;
187 }
188 
189 int main()
190 {
191     cout << "第一题测试样例：" << endl;
192     char *strIn = "ab00cd+123fght456-25  3.005fgh";
193     unsigned int outArray[100];
194     int n;
195     take_num(strIn, &n, outArray);
196     output(outArray, n);
197 
198     cout << endl << "第二题测试样例：" << endl;
199     const char* ip_addr = "192.168.1.100";
200     const char *net_addr_array[] =
201     {
202         "192.168.1.128/255.255.255.192",
203         "192.168.1.0/255.255.255.0",
204         "192.168.1.64/255.255.255.192",
205         "0.0.0.0/0.0.0.0",
206         ""
207     };
208     max_prefix_match(ip_addr, net_addr_array, &n);
209     cout << n << endl;
210 }