碼上歡樂
相關內容    簡體    繁體

華為機試題

本文轉載自   查看原文   2012-10-01 22:11   9369 

1、選秀節目打分，分為專家評委和大眾評委，score[] 數組里面存儲每個評委打的分數，judge_type[] 里存儲與 score[] 數組對應的評委類別，judge_type[i] == 1，表示專家評委，judge_type[i] == 2，表示大眾評委，n表示評委總數。打分規則如下：專家評委和大眾評委的分數先分別取一個平均分（平均分取整），然后，總分 = 專家評委平均分 * 0.6 + 大眾評委 * 0.4，總分取整。如果沒有大眾評委，則 總分 = 專家評委平均分，總分取整。函數最終返回選手得分。

函數接口 int cal_score(int score[], int judge_type[], int n)

View Code 
 1 int cal_score(int score[],int judge_type[],int n)
 2 {
 3     if (score==NULL || judge_type==NULL || n<=0)
 4     {
 5         return 0;
 6     }
 7     int iDazhong=0,iFenshu1=0;
 8     int iZhuanjia=0,iFenshu2=0;
 9     int iZongFen;
10     for (int i=0;i<n;i++)
11     {
12         if (judge_type[i]==1)
13         {
14             iFenshu2+=score[i];
15             iZhuanjia++;
16         }
17         else if (judge_type[i]==2)
18         {
19             iFenshu1+=score[i];
20             iDazhong++;
21         }
22     }
23     
24     
25 
26     if (iFenshu1==0)
27     {
28         iFenshu2/=iZhuanjia;
29         iZongFen=iFenshu2;//無大眾
30     }
31     else
32     {
33         iFenshu2/=iZhuanjia;
34         iFenshu1/=iDazhong;
35         iZongFen=(int)(0.6*iFenshu2+0.4*iFenshu1);
36     }
37 
38     return iZongFen;
39 
40 }

2、給定一個數組input[] ，如果數組長度n為奇數，則將數組中最大的元素放到 output[] 數組最中間的位置，如果數組長度n為偶數，則將數組中最大的元素放到 output[] 數組中間兩個位置偏右的那個位置上，然后再按從大到小的順序，依次在第一個位置的兩邊，按照一左一右的順序，依次存放剩下的數。

例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6, 1}; input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3}

函數接口 void sort(int input[], int n, int output[])

View Code 
 1 void InsertSort(int data[],int n)
 2 {
 3     if (data==NULL || n<=0)
 4     {
 5         return;
 6     }
 7     int temp;
 8     int j;
 9     for (int i=1;i<n;i++)
10     {
11         temp=data[i];
12         j=i-1;
13         while(j>=0 && data[j]>temp)
14         {
15             data[j+1]=data[j];
16             j--;
17         }
18 
19         data[++j]=temp;
20     }
21 }
22 
23 void PaiLie(int input[],int output[],int n)
24 {
25     if (input==NULL || output==NULL || n<=0)
26     {
27         return;
28     }
29 
30     InsertSort(input,n);
31 
32     int center=n/2;
33     output[center]=input[n-1];
34 
35     int offset=1;
36     int i=n-2;
37     while(i>=0)
38     {
39         output[center-offset]=input[i--];
40         if (i<0)
41         {
42             break;
43         }
44         output[center+offset]=input[i--];
45 
46         offset++;
47     }
48 }

3、操作系統任務調度問題。操作系統任務分為系統任務和用戶任務兩種。其中，系統任務的優先級 < 50，用戶任務的優先級 >= 50且 <= 255。優先級大於255的為非法任務，應予以剔除。現有一任務隊列task[]，長度為n，task中的元素值表示任務的優先級，數值越小，優先級越 高。函數scheduler實現如下功能，將task[] 中的任務按照系統任務、用戶任務依次存放到 system_task[] 數組和 user_task[] 數組中（數組中元素的值是任務在task[] 數組中的下標），並且優先級高的任務排在前面，數組元素為-1表示結束。

例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99} system_task[] = {0, 3, 1, 7, -1} user_task[] = {4, 8, 2, 6, -1}

函數接口 void scheduler(int task[], int n, int system_task[], int user_task[])

View Code 
 1 void scheduler(int task[],int n,int system_task[],int user_task[])
 2 {
 3     int i;
 4     int iSystemIndex=0,iUserIndex=0;
 5 
 6     for (i=0;i<n;i++)
 7     {
 8         if (task[i]<50)
 9         {
10             system_task[iSystemIndex++]=i;
11         }
12         else if (task[i]>=50 && task[i]<=255)
13         {
14             user_task[iUserIndex++]=i;
15         }
16         
17     }
18 
19     int iMax;
20     int iMaxIndex1;
21     int j;
22 
23     for (i=iSystemIndex-1;i>0;i--)
24     {
25         iMax=task[system_task[0]];
26         iMaxIndex1=0;
27         for (j=0;j<=i;j++)
28         {
29             if (task[system_task[j]]>iMax)
30             {
31                 iMax=task[system_task[j]];
32                 iMaxIndex1=j;
33             }
34         }
35         swap(system_task[iMaxIndex1],system_task[i]);
36     }
37 
38 
39     int iMaxIndex2;
40     for (i=iUserIndex-1;i>0;i--)
41     {
42         iMax=task[user_task[0]];
43         iMaxIndex2=0;
44         for (j=0;j<=i;j++)
45         {
46             if (task[user_task[j]]>iMax)
47             {
48                 iMax=task[user_task[j]];
49                 iMaxIndex2=j;
50             }
51         }
52         swap(user_task[iMaxIndex2],user_task[i]);
53     }
54 
55     system_task[iSystemIndex]=-1;
56     user_task[iUserIndex]=-1;
57 
58 }

4、數組比較（20分）

 

比較兩個數組，要求從數組最后一個元素開始逐個元素向前比較，如果2個數組長度不等，則只比較較短長度數組個數元素。請編程實現上述比較，並返回比較中發現的不相等元素的個數

 

比如：

數組{1,3,5}和數組{77,21,1,3,5}按題述要求比較，不相等元素個數為0

數組{1,3,5}和數組{77,21,1,3,5,7}按題述要求比較，不相等元素個數為3

 

要求實現函數：

int array_compare(int len1, int array1[], int len2, int array2[])

 

【輸入】 int len1：輸入被比較數組1的元素個數；

int array1[]：輸入被比較數組1；

int len2：輸入被比較數組2的元素個數；

int array2[]：輸入被比較數組2；

 

【輸出】 無

 

【返回】 不相等元素的個數，類型為int

 

示例:

1） 輸入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5

函數返回：0

2） 輸入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6

函數返回：3

View Code 
 1 int array_compare(int len1,int array1[],int len2,int array2[])
 2 {
 3     assert(len1>0 &&len2>0);
 4     assert(array1!=NULL && array2!=NULL);
 5 
 6     int iLen=(len1>len2)? len2:len1;
 7     int count=0;
 8 
 9     for (int i=iLen-1;i>=0;i--)
10     {
11         if (array1[i]!=array2[i])
12         {
13             count++;
14         }
15     }
16 
17     return count;
18 }

 

5. 約瑟夫問題

 

輸入一個由隨機數組成的數列（數列中每個數均是大於0的整數，長度已知），和初始計數值m。從數列首位置開始計數，計數到m后，將數列該位置數值替 換計數值m，並將數列該位置數值出列，然后從下一位置從新開始計數，直到數列所有數值出列為止。如果計數到達數列尾段，則返回數列首位置繼續計數。請編程 實現上述計數過程，同時輸出數值出列的順序

 

比如：輸入的隨機數列為：3,1,2,4，初始計數值m=7，從數列首位置開始計數（數值3所在位置）

第一輪計數出列數字為2，計數值更新m=2，出列后數列為3,1,4，從數值4所在位置從新開始計數

第二輪計數出列數字為3，計數值更新m=3，出列后數列為1,4，從數值1所在位置開始計數

第三輪計數出列數字為1，計數值更新m=1，出列后數列為4，從數值4所在位置開始計數

最后一輪計數出列數字為4，計數過程完成。

輸出數值出列順序為：2,3,1,4。

 

要求實現函數：

void array_iterate(int len, int input_array[], int m, int output_array[])

 

【輸入】 int len：輸入數列的長度；

int intput_array[]：輸入的初始數列

int m：初始計數值

 

【輸出】 int output_array[]：輸出的數值出列順序

 

【返回】 無

 

示例:

輸入：int input_array[] = {3,1,2,4}，int len = 4， m=7

輸出：output_array[] = {2,3,1,4}

View Code 
 1 void array_iterate(int len,int input_array[],int m,int output_array[])
 2 {
 3     assert(len>=0 && input_array!=NULL && m>0 && output_array!=NULL);
 4     int iChooseIndex=0;
 5     int iStartIndex=0;
 6     int i=0;
 7 
 8     while(len>0)
 9     {
10         iStartIndex=iChooseIndex;
11         iChooseIndex=(iStartIndex+(m-1)%len)%len;
12         m=input_array[iChooseIndex];
13         output_array[i++]=m;
14         for (int j=iChooseIndex;j<len-1;j++)
15         {
16             input_array[j]=input_array[j+1];
17         }
18 
19         len--;
20         
21     }
22 }

 

 

6. 簡單四則運算

 

問題描述：

輸入一個只包含個位數字的簡單四則運算表達式字符串，計算該表達式的值

注：

3.1、表達式只含 +, -, *, / 四則運算符，不含括號

3.2、表達式數值只包含個位整數(0-9)，且不會出現0作為除數的情況

3.3、要考慮加減乘除按通常四則運算規定的計算優先級

3.4、除法用整數除法，即僅保留除法運算結果的整數部分。比如8/3=2。輸入表達式保證無0作為除數情況發生

3.5、輸入字符串一定是符合題意合法的表達式，其中只包括數字字符和四則運算符字符，除此之外不含其它任何字符，不會出現計算溢出情況

要求實現函數：

int calculate(int len, char *expStr)

 

【輸入】 int len: 字符串長度；

char *expStr: 表達式字符串；

 

【輸出】 無

 

【返回】 計算結果

 

示例:

1）輸入：char *expStr = “1+4*5-8/3”

函數返回：19

2）輸入：char *expStr = “8/3*3”

函數返回：6

View Code 
  1 int calculate(int len,char *expStr)
  2 {
  3     stack<int> OperateNum;
  4     stack<char> OperateSymbol;
  5     bool bFlag=false;
  6 
  7     for (int i=0;i<len;i++)
  8     {
  9         char c=expStr[i];
 10         if (c>='0' && c<='9')
 11         {
 12             int iNumber=c-'0';
 13             OperateNum.push(iNumber);
 14             continue;
 15         }
 16 
 17         else if (c=='*' || c=='/')
 18         {
 19             if (OperateSymbol.size()>0 && (OperateSymbol.top()=='*' || OperateSymbol.top()=='/'))
 20             {
 21                 bFlag=true;
 22             }
 23             else
 24             {
 25                 bFlag=false;
 26             }
 27         }
 28 
 29         else if (c=='+' || c=='-')
 30         {
 31             if (OperateSymbol.size()==0)
 32             {
 33                 bFlag=false;
 34             }
 35             else
 36             {
 37                 bFlag=true;
 38             }
 39         }
 40 
 41         if (bFlag)
 42         {
 43             int iOperand1=OperateNum.top();
 44             OperateNum.pop();
 45             int iOperand2=OperateNum.top();
 46             OperateNum.pop();
 47 
 48             char cOperSymbol=OperateSymbol.top();
 49             OperateSymbol.pop();
 50 
 51             int iTemp;
 52             switch (cOperSymbol)
 53             {
 54             case '+':
 55                     iTemp=iOperand2+iOperand1;
 56                     OperateNum.push(iTemp);
 57                 break;
 58             case '-':
 59                     iTemp=iOperand2-iOperand1;
 60                     OperateNum.push(iTemp);
 61                 break;
 62             case '*':
 63                     iTemp=iOperand2*iOperand1;
 64                     OperateNum.push(iTemp);
 65                 break;
 66             case '/':
 67                     iTemp=iOperand2/iOperand1;
 68                     OperateNum.push(iTemp);
 69                 break;
 70                     
 71             }
 72 
 73             
 74         }
 75         
 76         OperateSymbol.push(c);
 77     }
 78 
 79     while(OperateSymbol.size()>0)
 80     {
 81         int iOperand1=OperateNum.top();
 82         OperateNum.pop();
 83         int iOperand2=OperateNum.top();
 84         OperateNum.pop();
 85 
 86         char cOperateSymbol=OperateSymbol.top();
 87         OperateSymbol.pop();
 88 
 89         int iTemp;
 90         switch(cOperateSymbol)
 91         {
 92         case '+':
 93                 iTemp=iOperand2+iOperand1;
 94                 OperateNum.push(iTemp);
 95                 break;
 96         case '-':
 97                 iTemp=iOperand2-iOperand1;
 98                 OperateNum.push(iTemp);
 99                 break;
100         case '*':
101                 iTemp=iOperand2*iOperand1;
102                 OperateNum.push(iTemp);
103                 break;
104         case '/':
105                 iTemp=iOperand2/iOperand1;
106                 OperateNum.push(iTemp);
107                 break;
108         }
109     }
110     
111     return OperateNum.top();
112 }

 

7、 識別字符串中的整數並轉換為數字形式（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}

View Code 
 1 void take_num(const char *strIn,int *n,unsigned int *outArray)
 2 {
 3     assert(strIn!=NULL);
 4     *n=0;
 5     int iLen=strlen(strIn);
 6     int iOutArrayIndex=0;
 7     unsigned int iNumber=0;
 8     bool bFlag=false;
 9 
10     for (int i=0;i<iLen;i++)
11     {
12         if (strIn[i]>='0' && strIn[i]<='9')
13         {
14             iNumber=iNumber*10+(strIn[i]-'0');
15             if (bFlag==false)
16             {
17                 bFlag=true;
18             }
19         }
20         else 
21         {
22             if (bFlag==true)
23             {
24                 outArray[iOutArrayIndex++]=iNumber;
25                 (*n)++;
26                 iNumber=0;
27                 bFlag=false;
28             }
29         }
30     }
31 
32     if (strIn[iLen-1]>='0' && strIn[iLen-1]<='9')
33     {
34         outArray[iOutArrayIndex]=iNumber;
35         (*n)++;
36     }
37 }

 

8、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

 

View Code 
  1 void make_prefix_match(const char *ip_addr,const char *net_addr_array[],int *n)
  2 {
  3     int iArrayIndex=0;
  4     *n=-1;
  5     const char *p=net_addr_array[iArrayIndex];
  6     int iMaxLength=-1;
  7     int number=0;
  8 
  9     int iIpAddress[4];
 10     int iIpIndex=0;
 11     int iIpLen=strlen(ip_addr);
 12     int i;
 13     for (i=0;i<iIpLen;i++)
 14     {
 15         if (ip_addr[i]>='0' && ip_addr[i]<='9')
 16         {
 17             number=number*10+(ip_addr[i]-'0');
 18         }
 19         else if (ip_addr[i]=='.')
 20         {
 21             iIpAddress[iIpIndex++]=number;
 22             number=0;
 23                 
 24         }
 25         else
 26         {
 27             return;
 28         }
 29 
 30     }
 31     iIpAddress[iIpIndex]=number;
 32 
 33     int iNetMask[4];
 34     int iNet[4];
 35     
 36 
 37     while(*p!='\0')
 38     {
 39         number=0;
 40         int iNetMaskIndex=0,iNetIndex=0;
 41         int iNetLen=strlen(p);
 42         for (i=0;;i++)
 43         {
 44             if (p[i]>='0' && p[i]<='9')
 45             {
 46                 number=number*10+(p[i]-'0');
 47             }
 48             else if (p[i]=='.')
 49             {
 50                 iNet[iNetIndex++]=number;
 51                 number=0;
 52             }
 53             else if (p[i]=='/')
 54             {
 55                 iNet[iNetIndex]=number;
 56                 number=0;
 57                 break;
 58             }
 59             else
 60             {
 61                 return;
 62             }
 63         }
 64         
 65         for (++i;i<iNetLen;i++)
 66         {
 67             if (p[i]>='0' && p[i]<='9')
 68             {
 69                 number=number*10+(p[i]-'0');
 70             }
 71             else if (p[i]=='.')
 72             {
 73                 iNetMask[iNetMaskIndex++]=number;
 74                 number=0;
 75             }
 76             else
 77             {
 78                 return;
 79             }
 80         }
 81         iNetMask[iNetMaskIndex]=number;
 82 
 83         for (i=0;i<4;i++)
 84         {
 85             if ((iIpAddress[i]&iNetMask[i])!=iNet[i])
 86             {
 87                 break;
 88             }
 89         }
 90 
 91         if (i==4)
 92         {
 93             int iCurrentlen=0;
 94             for (int k=3;k>=0;k--)
 95             {
 96                 if (iNet[k]!=0)
 97                 {
 98                     iCurrentlen=k*8;
 99                     bitset<32> b=iNet[k];
100                     int j;
101                     for (j=0;j<32;j++)
102                     {
103                         if (b[j]==1)
104                         {
105                             break;
106                         }
107                     }
108                     iCurrentlen+=(8-j);
109                     break;
110                 }
111             }
112             if (iCurrentlen>iMaxLength)
113             {
114                 iMaxLength=iCurrentlen;
115                 *n=iMaxLength;
116             }
117         }
118 
119 
120         ++iArrayIndex;
121         p=net_addr_array[iArrayIndex];
122 
123     }
124 
125 }

 

9、

通過鍵盤輸入一串小寫字母(a~z)組成的字符串。請編寫一個字符串過濾程序，若字符串中出現多個相同的字符，將非首次出現的字符過濾掉。
比如字符串“abacacde”過濾結果為“abcde”。
 
要求實現函數： 
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
 
【輸入】 pInputStr：  輸入字符串
         lInputLen：  輸入字符串長度         
【輸出】 pOutputStr： 輸出字符串，空間已經開辟好，與輸入字符串等長；
 
【注意】只需要完成該函數功能算法，中間不需要有任何IO的輸入輸出
 
示例 
輸入：“deefd”        輸出：“def”
輸入：“afafafaf”     輸出：“af”
輸入：“pppppppp”     輸出：“p”
 
View Code 
 1 void stringFilter(const char *pInputStr,long lInputLen,char *pOutputStr)
 2 {
 3     assert(pInputStr!=NULL && pOutputStr!=NULL && lInputLen>0);
 4     
 5     bool bFlag[26]={false};
 6     long j=0;
 7     for (long i=0;i<lInputLen;i++)
 8     {
 9         if (bFlag[pInputStr[i]-'a']==false)
10         {
11             bFlag[pInputStr[i]-'a']=true;
12             pOutputStr[j++]=pInputStr[i];
13         }
14     }
15     pOutputStr[j]='\0';
16 }

 

10、

通過鍵盤輸入一串小寫字母(a~z)組成的字符串。請編寫一個字符串壓縮程序，將字符串中連續出席的重復字母進行壓縮，並輸出壓縮后的字符串。
壓縮規則：
1. 僅壓縮連續重復出現的字符。比如字符串"abcbc"由於無連續重復字符，壓縮后的字符串還是"abcbc".
2. 壓縮字段的格式為"字符重復的次數+字符"。例如：字符串"xxxyyyyyyz"壓縮后就成為"3x6yz"
 
要求實現函數： 
void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);
 
【輸入】 pInputStr：  輸入字符串
         lInputLen：  輸入字符串長度         
【輸出】 pOutputStr： 輸出字符串，空間已經開辟好，與輸入字符串等長；
 
【注意】只需要完成該函數功能算法，中間不需要有任何IO的輸入輸出
 
示例 
輸入：“cccddecc”   輸出：“3c2de2c”
輸入：“adef”     輸出：“adef”
輸入：“pppppppp” 輸出：“8p”
 
View Code 
 1 void stringZip(const char *pInputStr,long lInputLen,char *pOutputStr)
 2 {
 3     assert(pInputStr!=NULL && pOutputStr!=NULL && lInputLen>0);
 4     
 5     long iRepeat=1;
 6     long k=0;
 7     for (long i=0;i<lInputLen;i++)
 8     {
 9         if (i+1<lInputLen && pInputStr[i]==pInputStr[i+1])
10         {
11             iRepeat++;
12         }
13         else
14         {
15             if (iRepeat!=1)
16             {
17                 char cTemp[100];
18                 itoa(iRepeat,cTemp,10);
19                 long j=0;
20                 while(cTemp[j])
21                 {
22                     pOutputStr[k++]=cTemp[j++];
23                 }
24             }
25             pOutputStr[k++]=pInputStr[i];
26             iRepeat=1;
27         }
28     }
29 
30     pOutputStr[k]='\0';
31 }

 

11、

通過鍵盤輸入100以內正整數的加、減運算式，請編寫一個程序輸出運算結果字符串。
輸入字符串的格式為：“操作數1 運算符 操作數2”，“操作數”與“運算符”之間以一個空格隔開。
 
補充說明：
1. 操作數為正整數，不需要考慮計算結果溢出的情況。
2. 若輸入算式格式錯誤，輸出結果為“0”。
 
要求實現函數： 
void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);
 
【輸入】 pInputStr：  輸入字符串
         lInputLen：  輸入字符串長度         
【輸出】 pOutputStr： 輸出字符串，空間已經開辟好，與輸入字符串等長；
 
【注意】只需要完成該函數功能算法，中間不需要有任何IO的輸入輸出
 
示例 
輸入：“4 + 7”  輸出：“11”
輸入：“4 - 7”  輸出：“-3”
輸入：“9 ++ 7”  輸出：“0” 注：格式錯誤
 
View Code 
 1 void arithmetic(const char *pInputStr,long lInputLen,char *pOutputStr)
 2 {
 3     assert(pInputStr!=NULL && pOutputStr!=NULL && lInputLen>0);
 4     int iOperand1=0;
 5     int iOperand2=0;
 6     char cSymbol;
 7     long i;
 8     for (i=0;;i++)
 9     {
10         if (pInputStr[i]>='0' && pInputStr[i]<='9')
11         {
12             iOperand1=iOperand1*10+(pInputStr[i]-'0');
13         }
14         else if (pInputStr[i]==' ')
15         {
16             break;
17         }
18         else
19         {
20             return;
21         }
22     }
23 
24     for (++i;;i++)
25     {
26         if (pInputStr[i]=='+' || pInputStr[i]=='-')
27         {
28             cSymbol=pInputStr[i];
29         }
30         else if (pInputStr[i]==' ')
31         {
32             break;
33         }
34         else
35         {
36             return;
37         }
38     }
39 
40     for (++i;i<lInputLen;i++)
41     {
42         if (pInputStr[i]>='0' && pInputStr[i]<='9')
43         {
44             iOperand2=iOperand2*10+(pInputStr[i]-'0');
45         }
46         else
47         {
48             break;
49         }
50     }
51     int iTemp;
52     switch(cSymbol)
53     {
54     case '+':
55         iTemp=iOperand1+iOperand2;
56         break;
57     case '-':
58         iTemp=iOperand1-iOperand2;
59         break;
60     default:
61         break;
62     }
63 
64     int k=0;
65     if (iTemp<0)
66     {
67         iTemp=-iTemp;
68         pOutputStr[0]='-';
69         k++;
70     }
71 
72     char cTemp[10];
73     itoa(iTemp,cTemp,10);
74     int j=0;
75     while(cTemp[j])
76     {
77         pOutputStr[k++]=cTemp[j++];
78     }
79 
80     pOutputStr[k]='\0';
81 
82 }

 

 

12、手機號碼合法性判斷（20分）

問題描述：

我國大陸運營商的手機號碼標准格式為：國家碼+手機號碼，例如：8613912345678。特點如下：

 

1、  長度13位；

2、  以86的國家碼打頭；

3、  手機號碼的每一位都是數字。

 

請實現手機號碼合法性判斷的函數（注：考生無需關注手機號碼的真實性，也就是說諸如86123123456789這樣的手機號碼，我們也認為是合法的），要求：

1）  如果手機號碼合法，返回0；

2）  如果手機號碼長度不合法，返回1

3）  如果手機號碼中包含非數字的字符，返回2；

4）  如果手機號碼不是以86打頭的，返回3；

【注】除成功的情況外，以上其他合法性判斷的優先級依次降低。也就是說，如果判斷出長度不合法，直接返回1即可，不需要再做其他合法性判斷。

要求實現函數：

int verifyMsisdn(char* inMsisdn)

【輸入】 char* inMsisdn，表示輸入的手機號碼字符串。

【輸出】  無

【返回】  判斷的結果，類型為int。

示例

輸入：  inMsisdn = “869123456789“

輸出：  無

返回：  1

輸入：  inMsisdn = “88139123456789“

輸出：  無

返回：  3

輸入：  inMsisdn = “86139123456789“

輸出：  無

返回：  0

View Code 
 1 int verifyMsisdn(char *inMsisdn)
 2 {
 3     assert(inMsisdn!=NULL);
 4 
 5     int iLen=strlen(inMsisdn);
 6     if (iLen!=13)
 7     {
 8         return 1;
 9     }
10 
11     for (int i=0;i<iLen;i++)
12     {
13         if (inMsisdn[i]<'0' || inMsisdn[i]>'9')
14         {
15             return 2;
16         }
17     }
18 
19     if (inMsisdn[0]!='8' || inMsisdn[1]!='6')
20     {
21         return 3;
22     }
23 
24     return 0;
25 
26 }

 

13、將一個字符串的元音字母復制到另一個字符串，並排序（30分）

問題描述：

有一字符串，里面可能包含英文字母（大寫、小寫）、數字、特殊字符，現在需要實現一函數，將此字符串中的元音字母挑選出來，存入另一個字符串中，並對字符串中的字母進行從小到大的排序（小寫的元音字母在前，大寫的元音字母在后，依次有序）。

 

說明：

1、  元音字母是a,e,i,o,u,A,E,I,O,U。

2、  篩選出來的元音字母，不需要剔重(chong)；

 

最終輸出的字符串，小寫元音字母排在前面，大寫元音字母排在后面，依次有序。

 

要求實現函數：

void sortVowel (char* input, char* output);

【輸入】  char* input，表示輸入的字符串

【輸出】  char* output，排好序之后的元音字符串。

【返回】  無

 

示例

輸入：char *input = “Abort!May Be Some Errors In Out System. “

輸出：char *output =“aeeeooouAEIO “

View Code 
 1 void sortVowel(char *pInput,char *pOutput)
 2 {
 3     assert(pInput!=NULL && pOutput!=NULL);
 4 
 5     int iLen=strlen(pInput);
 6     char *pSmall=new char[iLen+1];
 7     char *pLarge=new char[iLen+1];
 8 
 9     int iSmallCount=0;
10     int iLargeCount=0;
11 
12     for (int i=0;i<iLen;i++)
13     {
14         if (pInput[i]=='a' || pInput[i]=='e' || pInput[i]=='i' || pInput[i]=='o' || pInput[i]=='u')
15         {
16             pSmall[iSmallCount++]=pInput[i];
17 
18         }
19         else if (pInput[i]=='A' || pInput[i]=='E' || pInput[i]=='I' || pInput[i]=='O' || pInput[i]=='U')
20         {
21             pLarge[iLargeCount++]=pInput[i];
22         }
23     }
24 
25     sort(pSmall,pSmall+iSmallCount);
26     sort(pLarge,pLarge+iLargeCount);
27 
28     int j,k=0;
29     for (j=0;j<iSmallCount;j++)
30     {
31         pOutput[k++]=pSmall[j];
32     }
33     for (j=0;j<iLargeCount;j++)
34     {
35         pOutput[k++]=pLarge[j];
36     }
37 
38     pOutput[k]='\0';
39 
40     delete []pSmall;
41     delete []pLarge;
42 }

 

14、我國公民的身份證號碼特點如下：

1、     長度為18位；

2、     第1～17位只能為數字；

3、     第18位可以是數字或者小寫英文字母x。

4、     身份證號碼的第7~14位表示持有人生日的年、月、日信息。

例如：511002198808080111或51100219880808011x。

 

請實現身份證號碼合法性判斷的函數。除滿足以上要求外，需要對持有人生日的年、月、日信息進行校驗。年份大於等於1900年，小於等於2100年。 需要考慮閏年、大小月的情況。所謂閏年，能被4整除且不能被100整除 或 能被400整除的年份，閏年的2月份為29天，非閏年的2月份為28天。其他情況的合法性校驗，考生不用考慮。

函數返回值：

1）  如果身份證號合法，返回0；

2）  如果身份證號長度不合法，返回1；

3）  如果身份證號第1~17位含有非數字的字符，返回2；

4）  如果身份證號第18位既不是數字也不是英文小寫字母x，返回3；

5）  如果身份證號的年信息非法，返回4；

6）  如果身份證號的月信息非法，返回5；

7）  如果身份證號的日信息非法，返回6（請注意閏年的情況）；

【注】除成功的情況外，以上其他合法性判斷的優先級依次降低。也就是說，如果判斷出長度不合法，直接返回1即可，不需要再做其他合法性判斷。

 

 

要求實現函數：

int verifyIDCard(char* input)

【輸入】  char* input，表示輸入的身份證號碼字符串

【輸出】  無

【返回】  判斷的結果，類型為int

 

示例

1） 輸入：”511002111222”，函數返回值：1；

2） 輸入：”511002abc123456789”，函數返回值：2；

3） 輸入：”51100219880808123a”，函數返回值：3；

4） 輸入：”511002188808081234”，函數返回值：4；

5） 輸入：”511002198813081234”，函數返回值：5；

6） 輸入：”511002198808321234”，函數返回值：6；

7） 輸入：”511002198902291234”，函數返回值：6；

8） 輸入：”511002198808081234”，函數返回值：0；

View Code 
  1 int verifyIDCard(char *input)
  2 {
  3     assert(input!=NULL);
  4 
  5     int iLen=strlen(input);
  6     if (iLen!=18)
  7     {
  8         return 1;
  9     }
 10     
 11     int i;
 12     for (i=0;i<17;i++)
 13     {
 14         if (input[i]<'0' || input[i]>'9')
 15         {
 16             return 2;
 17         }
 18     }
 19 
 20     if ((input[17]<'0' || input[17]>'9') && input[17]!='x')
 21     {
 22         return 3;
 23     }
 24 
 25     int iYear=0;
 26     for (i=6;i<10;i++)
 27     {
 28         iYear=iYear*10+(input[i]-'0');
 29     }
 30     if (iYear<1900 || iYear>2100)
 31     {
 32         return 4;
 33     }
 34 
 35     int iMonth=0;
 36     for (i=10;i<12;i++)
 37     {
 38         iMonth=iMonth*10+(input[i]-'0');
 39     }
 40     if (iMonth<1 || iMonth>12)
 41     {
 42         return 5;
 43     }
 44     
 45     int iDay=0;
 46     for (i=12;i<14;i++)
 47     {
 48         iDay=iDay*10+(input[i]-'0');
 49     }
 50 
 51     if ((iYear%4==0) || (iYear%100!=0 && iYear%400==0))
 52     {
 53         if (iMonth==2)
 54         {
 55             if (iDay<1 || iDay>29)
 56             {
 57                 return 6;
 58             }
 59         }
 60         else if (iMonth==1 || iMonth==3 || iMonth==5 || iMonth==7 || iMonth==8 ||iMonth==10 || iMonth==12)
 61         {
 62             if (iDay<1 || iDay>31)
 63             {
 64                 return 6;
 65             }
 66         }
 67         else
 68         {
 69             if (iDay<1 || iDay>30)
 70             {
 71                 return 6;
 72             }
 73         }
 74     }
 75     else
 76     {
 77         
 78         if (iMonth==2)
 79         {
 80             if (iDay<1 || iDay>28)
 81             {
 82                 return 6;
 83             }
 84         }
 85         else if (iMonth==1 || iMonth==3 || iMonth==5 || iMonth==7 || iMonth==8 ||iMonth==10 || iMonth==12)
 86         {
 87             if (iDay<1 || iDay>31)
 88             {
 89                 return 6;
 90             }
 91         }
 92         else
 93         {
 94             if (iDay<1 || iDay>30)
 95             {
 96                 return 6;
 97             }
 98         }
 99     }
100 
101     return 0;
102 
103 }

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 華為OD機試題 華為機試題 華為機試題:仿LISP 華為2012.09.03浙大機試題 華為往年機試題目（三） 華為機試題-簡單密碼python 實現 華為機試題目：刪除重復字符 華為機試題刷題總結 2022.1.22 華為OD-機試題 華為機試題-輸出句子的重量
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM