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)
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 else32 {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[])
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[])
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
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}
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
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、 不考虑转换后整数超出范围情况，即测试用例中可能出现的最大整数不会超过unsignedint可处理的范围
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}
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
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、
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、
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 else14 {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、
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 else19 {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 else35 {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 else47 {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
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 “
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；
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 }
联系客服
