2014年华为上机题及代码

http://blog.csdn.net/han_jiang_xue/article/details/11751041

http://blog.csdn.net/dalianmaoblog/article/details/11477997

题目来源于http://blog.csdn.net/hackbuteer1/article/details/11132567。

后面的代码是今天早上才写的，C++好长时间不写了，一些简单的函数都是上网查的用法，如果要我现场写，估计很悬。

华为2014校园招聘的机试题目和2013年的完全一样。
一、题目描述（60分）：
通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
比如字符串“abacacde”过滤结果为“abcde”。

要求实现函数：void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr：  输入字符串
            lInputLen：  输入字符串长度         
【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长； 

【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出

示例 
输入：“deefd”        输出：“def”
输入：“afafafaf”     输出：“af”
输入：“pppppppp”     输出：“p”

main函数已经隐藏，这里保留给用户的测试入口，在这里测试你的实现函数，可以调用printf打印输出
当前你可以使用其他方法测试，只要保证最终程序能正确执行即可，该函数实现可以任意修改，但是不要改变函数原型。一定要保证编译运行不受影响。

[cpp]  view plain copy print ?

1. void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr){  
2.    map<char,int> charMap;  
3.    int k=0;  
4.    for(int i=0;i<lInputLen;i++){  
5.       if(charMap.find(*(pInputStr+i))==charMap.end()){  
6.           *(pOutputStr+k++)=*(pInputStr+i);  
7.           charMap.insert(pair<char,int>(*(pInputStr+i),1));  
8.       }  
9.    }  
10.    *(pOutputStr+k++)='\n';  
11. }  

二、题目描述（40分）：
通过键盘输入一串小写字母(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”

[cpp]  view plain copy print ?

1. void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr){  
2.        int k=0;  
3.        for(int i=0;i<lInputLen;i++){  
4.           int num=1;  
5.           int j=i+1;  
6.           for(;j<lInputLen;j++){  
7.             if(pInputStr[j]==pInputStr[i]){  
8.                 num++;  
9.             }else{  
10.                 break;  
11.             }  
12.           }  
13.           if(num!=1){  
14.               char str[100];  
15.               sprintf(str,"%d",num);  
16.               strcpy(pOutputStr+k,str);  
17.               k = k+strlen(str);  
18.           }  
19.           *(pOutputStr+k++)=*(pInputStr+i);  
20.           i = j-1;  
21.        }  
22.        *(pOutputStr+k++)='\n';  
23. }  

三、题目描述（50分）： 
通过键盘输入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” 注：格式错误

[cpp]  view plain copy print ?

1. bool isOperater(char* c){  
2.       char f[]="+-*/";  
3.       if(c==NULL||strlen(c)!=1){  
4.          return false;  
5.       }  
6.       for(int i=0;i<strlen(f);i++){  
7.           if(f[i]==*c)  
8.               return true;  
9.       }  
10.       return false;  
11. }  
12.   
13. bool isNumber(char* c,int& num){  
14.       if(c==NULL||strlen(c)<=0){  
15.          return false;  
16.       }  
17.   
18.       for(int i=0;i<strlen(c);i++){  
19.           if(c[i]>'9'||c[i]<'0')  
20.               return false;  
21.       }  
22.       num = atoi(c);  
23.       return true;  
24. }  
25.   
26. struct data{  
27. public:  
28.    bool isNum;  
29.    union{  
30.        char operater;  
31.        int number;  
32.    }u;  
33. };  
34.   
35. void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr){  
36.     stack<data> Stack;  
37.     const char *d = " ";  
38.     char s[256];  
39.     strcpy(s,pInputStr);  
40.     char *p;  
41.     int num;  
42.     p = strtok(s,d);  
43.     while(p){  
44.        if(isOperater(p)){ //是操作符  
45.             if(Stack.size()<1){  
46.                 strcpy(pOutputStr,"0"); //格式错误  
47.                 return;  
48.             }else{  
49.                 data data1= Stack.top();  
50.                 if(data1.isNum){ //栈顶元素是数字  
51.                     data data2;  
52.                     data2.isNum = false;  
53.                     data2.u.operater=*p;  
54.                     Stack.push(data2);  
55.                 }else{//栈顶元素是操作符  
56.                     strcpy(pOutputStr,"0"); //格式错误  
57.                     return;  
58.                 }  
59.             }  
60.        }else if(isNumber(p,num)){ //是数字  
61.            if(Stack.size()<1){  
62.                 data data1;  
63.                 data1.isNum = true;  
64.                 data1.u.number=num;  
65.                 Stack.push(data1);  
66.            }else{  
67.                 data data1= Stack.top();  
68.                 if(data1.isNum){ //栈顶元素是数字  
69.                     strcpy(pOutputStr,"0"); //格式错误  
70.                     return;  
71.                 }else{//栈顶元素是操作符  
72.                     Stack.pop();  
73.                     data data2 = Stack.top();  
74.                     Stack.pop();  
75.                     if(!data2.isNum){  
76.                         strcpy(pOutputStr,"0"); //格式错误  
77.                         return;  
78.                     }  
79.                     int num2 = data2.u.number;  
80.                     int num3 = 0;  
81.                      switch(data1.u.operater){  
82.                        case '+':  
83.                            num3=num2+num;  
84.                            break;  
85.                        case '-':  
86.                            num3=num2-num;  
87.                            break;  
88.                        case '*':  
89.                            num3=num2*num;  
90.                            break;  
91.                        case '/':  
92.                            num3=num2/num;  
93.                            break;  
94.                        default:  
95.                            strcpy(pOutputStr,"0"); //格式错误  
96.                            return;  
97.                        }  
98.                      data data3;  
99.                      data3.isNum=true;  
100.                      data3.u.number=num3;  
101.                      Stack.push(data3);  
102.                 }  
103.            }  
104.        }else{  
105.            strcpy(pOutputStr,"0"); //格式错误  
106.            return;  
107.        }  
108.        p=strtok(NULL,d);  
109.     }  
110.     if(Stack.size()==1){  
111.         data d = Stack.top();  
112.         if(d.isNum){  
113.             sprintf(pOutputStr,"%d",d.u.number);  
114.             return;  
115.         }  
116.     }  
117.    strcpy(pOutputStr,"0"); //格式错误  
118.    return;  
119. }  

整个源码：

[cpp]  view plain copy print ?

1. //============================================================================  
2. // Name        : huaweijishi.cpp  
3. // Author      :   
4. // Version     :  
5. // Copyright   : Your copyright notice  
6. // Description : Hello World in C++, Ansi-style  
7. //============================================================================  
8.   
9. #include <iostream>  
10. #include <map>  
11. #include <string.h>  
12. #include <stdlib.h>  
13. #include <stdio.h>  
14. #include <stack>  
15.   
16. using namespace std;  
17.   
18. void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr){  
19.    map<char,int> charMap;  
20.    int k=0;  
21.    for(int i=0;i<lInputLen;i++){  
22.       if(charMap.find(*(pInputStr+i))==charMap.end()){  
23.           *(pOutputStr+k++)=*(pInputStr+i);  
24.           charMap.insert(pair<char,int>(*(pInputStr+i),1));  
25.       }  
26.    }  
27.    *(pOutputStr+k++)='\n';  
28. }  
29.   
30. void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr){  
31.        int k=0;  
32.        for(int i=0;i<lInputLen;i++){  
33.           int num=1;  
34.           int j=i+1;  
35.           for(;j<lInputLen;j++){  
36.             if(pInputStr[j]==pInputStr[i]){  
37.                 num++;  
38.             }else{  
39.                 break;  
40.             }  
41.           }  
42.           if(num!=1){  
43.               char str[100];  
44.               sprintf(str,"%d",num);  
45.               strcpy(pOutputStr+k,str);  
46.               k = k+strlen(str);  
47.           }  
48.           *(pOutputStr+k++)=*(pInputStr+i);  
49.           i = j-1;  
50.        }  
51.        *(pOutputStr+k++)='\n';  
52. }  
53.   
54.   
55.   
56. bool isOperater(char* c){  
57.       char f[]="+-*/";  
58.       if(c==NULL||strlen(c)!=1){  
59.          return false;  
60.       }  
61.       for(int i=0;i<strlen(f);i++){  
62.           if(f[i]==*c)  
63.               return true;  
64.       }  
65.       return false;  
66. }  
67.   
68. bool isNumber(char* c,int& num){  
69.       if(c==NULL||strlen(c)<=0){  
70.          return false;  
71.       }  
72.   
73.       for(int i=0;i<strlen(c);i++){  
74.           if(c[i]>'9'||c[i]<'0')  
75.               return false;  
76.       }  
77.       num = atoi(c);  
78.       return true;  
79. }  
80.   
81. struct data{  
82. public:  
83.    bool isNum;  
84.    union{  
85.        char operater;  
86.        int number;  
87.    }u;  
88. };  
89.   
90. void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr){  
91.     stack<data> Stack;  
92.     const char *d = " ";  
93.     char s[256];  
94.     strcpy(s,pInputStr);  
95.     char *p;  
96.     int num;  
97.     p = strtok(s,d);  
98.     while(p){  
99.        if(isOperater(p)){ //是操作符  
100.             if(Stack.size()<1){  
101.                 strcpy(pOutputStr,"0"); //格式错误  
102.                 return;  
103.             }else{  
104.                 data data1= Stack.top();  
105.                 if(data1.isNum){ //栈顶元素是数字  
106.                     data data2;  
107.                     data2.isNum = false;  
108.                     data2.u.operater=*p;  
109.                     Stack.push(data2);  
110.                 }else{//栈顶元素是操作符  
111.                     strcpy(pOutputStr,"0"); //格式错误  
112.                     return;  
113.                 }  
114.             }  
115.        }else if(isNumber(p,num)){ //是数字  
116.            if(Stack.size()<1){  
117.                 data data1;  
118.                 data1.isNum = true;  
119.                 data1.u.number=num;  
120.                 Stack.push(data1);  
121.            }else{  
122.                 data data1= Stack.top();  
123.                 if(data1.isNum){ //栈顶元素是数字  
124.                     strcpy(pOutputStr,"0"); //格式错误  
125.                     return;  
126.                 }else{//栈顶元素是操作符  
127.                     Stack.pop();  
128.                     data data2 = Stack.top();  
129.                     Stack.pop();  
130.                     if(!data2.isNum){  
131.                         strcpy(pOutputStr,"0"); //格式错误  
132.                         return;  
133.                     }  
134.                     int num2 = data2.u.number;  
135.                     int num3 = 0;  
136.                      switch(data1.u.operater){  
137.                        case '+':  
138.                            num3=num2+num;  
139.                            break;  
140.                        case '-':  
141.                            num3=num2-num;  
142.                            break;  
143.                        case '*':  
144.                            num3=num2*num;  
145.                            break;  
146.                        case '/':  
147.                            num3=num2/num;  
148.                            break;  
149.                        default:  
150.                            strcpy(pOutputStr,"0"); //格式错误  
151.                            return;  
152.                        }  
153.                      data data3;  
154.                      data3.isNum=true;  
155.                      data3.u.number=num3;  
156.                      Stack.push(data3);  
157.                 }  
158.            }  
159.        }else{  
160.            strcpy(pOutputStr,"0"); //格式错误  
161.            return;  
162.        }  
163.        p=strtok(NULL,d);  
164.     }  
165.     if(Stack.size()==1){  
166.         data d = Stack.top();  
167.         if(d.isNum){  
168.             sprintf(pOutputStr,"%d",d.u.number);  
169.             return;  
170.         }  
171.     }  
172.    strcpy(pOutputStr,"0"); //格式错误  
173.    return;  
174. }  
175.   
176.   
177.   
178. int main() {  
179.   
180.     char r[256];  
181.     int a = atoi("a");  
182.     char* p="abcddcae";  
183.     stringFilter(p,strlen(p),r);  
184.     cout<<"原字符串:"<<p<<endl;  
185.     cout<<"转换后的字符串:"<<r<<endl;  
186.   
187.     p = "aaabbbcceffggh";  
188.     stringZip(p,strlen(p),r);  
189.     cout<<"原字符串:"<<p<<endl;  
190.     cout<<"转换后的字符串:"<<r<<endl;  
191.   
192.     p = "1 + 2";  
193.     arithmetic(p,strlen(p),r);  
194.     cout<<"原字符串:"<<p<<endl;  
195.     cout<<"转换后的字符串:"<<r<<endl;  
196.   
197.     p = "1a + 2";  
198.     arithmetic(p,strlen(p),r);  
199.     cout<<"原字符串:"<<p<<endl;  
200.     cout<<"转换后的字符串:"<<r<<endl;  
201.   
202.     p = "1 + 2 * 3";  
203.     arithmetic(p,strlen(p),r);  
204.     cout<<"原字符串:"<<p<<endl;  
205.     cout<<"转换后的字符串:"<<r<<endl;  
206.     return 0;  
207. }