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 }