華為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;
}