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

编程题（共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/

#include <iostream>
using namespace std;


// 编程题第一题
// 识别输入字符串中所有的整数，统计整数个数并将这些字符串形式的整数转换为数字形式整数
void take_num(const char *strIn, int *n, unsigned int *outArray)
{
    unsigned int len = strlen(strIn);
    unsigned int outArrayIndex = 0;
    bool hasNumber = false; // temp 中已经存在有效数字
    unsigned int temp = 0;
    *n = 0;
    for(unsigned int i = 0; i < len; ++i)
    {
        if(strIn[i] >= '0' && strIn[i] <= '9')
        {
            if(hasNumber == false)
            {
                // 间隔后第一次出现的数字
                ++*n;            
            }
            else
            {
                // 连续出现的数字
            }
            hasNumber = true;
            temp = temp * 10 + (strIn[i] - '0');
        }
        else
        {
            if(hasNumber)
            {
                outArray[outArrayIndex++] = temp;
                temp = 0;
                hasNumber = false;
            }        
        }
    }
    if(hasNumber)
    {
        outArray[outArrayIndex++] = temp;
    }
}


// 编程题第二题
// IP地址最长匹配问题，要求不仅是匹配，而且是最长匹配
void max_prefix_match(const char *ip_addr, const char *net_addr_array[], int *n)
{
    int arrayIndex = 0;
    *n = -1;
    const char* p = net_addr_array[arrayIndex];
    int maxLength = -1; //记录最长匹配串最远的1的位置
    int number = 0;// 用于转换字符串形式的点分十进制数至整数
    //先把IP址址转换成int型元素的数组
    int ipAddress[4];
    int netIndex = 0;
    int ipLen = strlen(ip_addr);
    for(int i = 0; i <= ipLen; ++i)
    {
        if(ip_addr[i] >= '0' && ip_addr[i] <= '9')
        {
            number = number * 10 + (ip_addr[i] - '0');
        }
        else
        {
            ipAddress[netIndex++] = number;
            number = 0;
        }
    }
    while(*p != '\0')
    {
        
        int netAddress[4];//子网地址
        int maskAddress[4];//子网掩码
        netIndex = 0;
        //将点分十进制转成4个int元素
        int len = strlen(p); // 本次 IP地址/子网掩码 字符串的长度
        number = 0; 
        int i;
        //先转换给定的子网地址
        for(i = 0; ; ++i)
        {
            if(p[i] >= '0' && p[i] <= '9')
            {
                number = number * 10 + (p[i] - '0');
            }
            else
            {
                netAddress[netIndex++] = number;
                number = 0;
                if(p[i] == '/')
                {
                    netIndex = 0;
                    break;
                }
            }
        }

        //再转换子网掩码
        for(++i; i <= len; ++i)
        {
            if(p[i] >= '0' && p[i] <= '9')
            {
                number = number * 10 + (p[i] - '0');
            }
            else
            {
                maskAddress[netIndex++] = number;
                number = 0;
            }
        }
        netIndex = 0;

        //判断IP地址和子网掩网的与 是否 和 子网地址相同
        int j = 0;
        for(;j < 4; ++j)
        {
            if((ipAddress[j] & maskAddress[j]) != netAddress[j])
            {
                break;
            }
        }
        if(j >= 4)
        {
            //匹配
            //再比较长度，从最后往前数，记录下第一个出现1的位置
            int currentLength = 0;
            for(int k = 3; k >= 0; --k)
            {
                if(netAddress[k] != 0)
                {
                    currentLength = k * 8;
                    // 将十进制转成二进制
                    char binaryArray[8];
                    int temp = netAddress[k];
                    int index = 0;
                    while(temp > 0)
                    {
                        if(temp % 2 == 0)
                        {
                            binaryArray[index++] = '0';
                        }
                        else
                        {
                            binaryArray[index++] = '1';
                        }
                        temp /= 2;
                    }
                    while(index <= 7)
                    {
                        binaryArray[index++] = '0';
                    }
                    for(int k = 0; k < 8; ++k)
                    {
                        if(binaryArray[k] == '1')
                        {
                            currentLength += (8 - k);
                            break;
                        }
                    }
                    break;
                }
            }
            if(currentLength > maxLength)
            {
                maxLength = currentLength;
                *n = arrayIndex;
            }
        }
        //输入下一个数组
        ++arrayIndex;
        p = net_addr_array[arrayIndex];
    }
}


// 输出
void output(unsigned int* a, unsigned int len)
{
    for(unsigned int i = 0; i < len; ++i)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main()
{
    cout << "第一题测试样例：" << endl;
    char *strIn = "ab00cd+123fght456-25  3.005fgh";
    unsigned int outArray[100];
    int n;
    take_num(strIn, &n, outArray);
    output(outArray, n);

    cout << endl << "第二题测试样例：" << endl;
    const char* ip_addr = "192.168.1.100";
    const char *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",
        ""
    };
    max_prefix_match(ip_addr, net_addr_array, &n);
    cout << n << endl;
}