华为面试 编程题.docx

华为面试 编程题.docx

《华为面试 编程题.docx》由会员分享，可在线阅读，更多相关《华为面试 编程题.docx（17页珍藏版）》请在冰豆网上搜索。

华为面试编程题

2010年华为软件校园招聘编程测验

类别：

软件C语言

编程题（共2题，第一题40分，第二题60分，共100分。

请上机编写程序，按题目要求提交文件。

[详见考试说明]

本试题采用自动测试用例进行评分，测试用例不对考生公开，凡不满足提交要求导致不能运行或用例不通过，不予评分）。

1.删除字符串中所有给定的子串（40分）

问题描述：

在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。

要求实现函数：

intdelete_sub_str（constchar*str,constchar*sub_str,char*result_str）

【输入】str：

输入的被操作字符串

sub_str：

需要查找并删除的特定子字符串

【输出】result_str：

在str字符串中删除所有sub_str子字符串后的结果

【返回】删除的子字符串的个数

注：

I、子串匹配只考虑最左匹配情况，即只需要从左到右进行字串匹配的情况。

比如：

在字符串"abababab"中，采用最左匹配子串"aba",可以匹配2个"aba"字串。

如果

匹配出从左到右位置2开始的"aba"，则不是最左匹配，且只能匹配出1个"aba"字串。

II、输入字符串不会超过100Bytes，请不用考虑超长字符串的情况。

示例

输入：

str="abcde123abcd123"

sub_str="123"

输出：

result_str="abcdeabcd"

返回：

2

输入：

str="abcde123abcd123"

sub_str="1234"

输出：

result_str="abcde123abcd123"

返回：

0

viewplaincopytoclipboardprint?

01.#include

02.#include

03.#include

04.

05./*删除字串函数，在src中删除sub子串，并将结果保存在result字符串中*/

06.intdelSubStr（char*src,char*sub,char*result）

07.{

08.char*src_p=src;

09.char*sub_p=sub;

10.char*res_p=result;

11.intcount=0;//记录包含子串的个数

12.intsub_len=strlen（sub）;//记录子串的长度

13.char*temp;//临时保存子串的副本

14.temp=（char*）malloc（sub_len+1）;

15.memset（temp,'\0',sub_len+1）;

16.while（*src_p）

17.{

18.memcpy（temp,src_p,sub_len）;

19.

20./*原串中包含与sub完全匹配的子串*/

21.if（!

strcmp（temp,sub））

22.{

23.count++;

24.src_p+=sub_len;

25.}

26.else

27.*res_p++=*src_p++;

28.*res_p='\0';

29.free（temp）;

30.returncount;//返回包含子串的个数

31.}

32.

33.voidmain（）

34.{

35.charresult[100];

36.intcount=delSubStr（"abcdefgde","de",result）;

37.printf（"Thenewstringis:

"）;

38.printf（"%s\n",result）;

39.printf（"countis:

"）;

40.printf（"%d\n",count）;

41.}

2.高精度整数加法（60分）

问题描述：

在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，

参与运算的操作数和结果必须在-231~231-1之间。

如果需要进行更大范围的十进制整数加法，需要使用特殊

的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。

如下：

9876543210+1234567890=?

让字符串num1="9876543210"，字符串num2="1234567890"，结果保存在字符串result="11111111100"。

-9876543210+（-1234567890）=?

让字符串num1="-9876543210"，字符串num2="-1234567890"，结果保存在字符串result="-11111111100"。

要求编程实现上述高精度的十进制加法。

要求实现函数：

voidadd（constchar*num1,constchar*num2,char*result）

【输入】num1：

字符串形式操作数1，如果操作数为负，则num1[0]为符号位'-'

num2：

字符串形式操作数2，如果操作数为负，则num2[0]为符号位'-'

【输出】result：

保存加法计算结果字符串，如果结果为负，则result[0]为符号位。

注：

I、当输入为正数时，'+'不会出现在输入字符串中；当输入为负数时，'-'会出现在输入字符串中，且一定在输入字符串最左边位置；

II、输入字符串所有位均代表有效数字，即不存在由'0'开始的输入字符串，比如"0012","-0012"不会出现；

III、要求输出字符串所有位均为有效数字，结果为正或0时'+'不出现在输出字符串，结果为负时输出字符串最左边位置为'-'。

示例

输入：

num1="580"

num2="-50"

输出：

result="530"

输入：

num1="580"

num2="-600"

输出：

result="-20"

程序代码（C语言）：

01.#include

02.#include

03.

04./*判断字符串整数是否合法，合法返回'1'，否则返回'0'*/

05.intisLegalNum（constchar*num）

06.{

07.constchar*num_p=num;

08.intnum_len;//记录整数长度（不包含符号位和结束符'\0'）

09.

10./*字符串指针为空，不是合法的整数，返回'0'*/

11.if（num_p==NULL）

12.return0;

13.if（*num_p=='-'）

14.num_p++;

15.num_len=strlen（num）;

16.

17./*不合法整数，返回'0'*/

18.if（*num_p<=48||*num_p>57）

19.return0;

20.inti;

21.for（i=0;i

22.{

23./*不合法整数，返回'0'*/

24.if（*num_p>57||*num_p<48）

25.return0;

26.}

27.return1;

28.}

29.

30./*将字符串逆序*/

31.voidreverseStr（char*result）

32.{

33.inti;

34.chartemp;

35.intres_len=strlen（result）;

36.for（i=0;i

37.{

38.temp=result[i];

39.result[i]=result[res_len-i-1];

40.result[res_len-i-1]=temp;

41.}

42.}

43.

44./*加法函数，用于将两个字符串形式的整数相加，结果保存在char*result中*/

45.voidadd（constchar*num1,constchar*num2,char*result）

46.{

47./*判断两个字符串整数num1和num2是否合法，如果不合法则要求用户重新输入*/

48.if（!

（isLegalNum（num1）&&isLegalNum（num2）））

49.{

50.strcpy（result,"对不起，您输入的字符串整数不是合法的十进制整数，请您检查后重新输入，谢谢合作!

"）;

51.return;

52.}

53.intcount=0;//记录进位或借位

54.constchar*num1_p;//记录第一个数的字符串起始地址

55.constchar*num2_p;//记录第二个数的字符串起始地址

56.char*res_p=result;//记录结果字符串起始地址

57.intnum1_len=strlen（num1）;//第一个数的长度

58.intnum2_len=strlen（num2）;//第二个数的长度

59.num1_p=num1+num1_len-1;//num1_p指向第一个数的最后一位

60.num2_p=num2+num2_len-1;//num2_p指向第二个数的最后一位

61.

62./*加法运算，此时两个数的符号相同*/

63.if（（*num1!

='-'&&*num2!

='-'）||（*num1=='-'&&*num2=='-'））

64.{

65./*两个负数相加*/

66.if（*num1=='-'&&*num2=='-'）

67.{

68.num1_len--;

69.num2_len--;

70.inti;

71.for（i=0;i<（num2_len>num1_len?

num1_len:

num2_len）;i++）

72.{

73.*res_p++=（*num1_p-'0'+*num2_p-'0'+count）%10+'0';

74.count=（*num1_p-'0'+*num2_p-'0'+count）/10;

75.num1_p--;

76.num2_p--;

77.}

78.

79./*如果第一个数的长度大于第二个数*/

80.if（num1_len>num2_len）

81.{

82.for（i=0;i

83.{

84.*res_p++=（*num1_p-'0'+count）%10+'0';

85.count=（*num1_p-'0'+count）/10;

86.num1_p--;

87.}

88.}

89.

90./*如果第一个数的长度小于第二个数*/

91.elseif（num1_len

92.{

93.for（i=0;i

94.{

95.*res_p++=（*num2_p-'0'+count）%10+'0';

96.count=（*num2_p-'0'+count）/10;

97.num2_p--;

98.}

99.}

100.

101./*向最高位进一位*/

102.if（count==1）

103.*res_p++='1';

104.*res_p++='-';

105.*res_p='\0';

106.reverseStr（result）;

107.}

108.

109./*两个正数相加*/

110.if（*num1!

='-'&&*num2!

='-'）

111.{

112.inti;

113.for（i=0;i<（num2_len>num1_len?

num1_len:

num2_len）;i++）

114.{

115.*res_p++=（*num1_p-'0'+*num2_p-'0'+count）%10+'0';

116.count=（*num1_p-'0'+*num2_p-'0'+count）/10;

117.num1_p--;

118.num2_p--;

119.}

120.

121./*如果第一个数的长度大于第二个数*/

122.if（num1_len>num2_len）

123.{

124.for（i=0;i

125.{

126.*res_p++=（*num1_p-'0'+count）%10+'0';

127.count=（*num1_p-'0'+count）/10;

128.num1_p--;

129.}

130.}

131.

132./*如果第一个数的长度小于第二个数*/

133.elseif（num1_len

134.{

135.for（i=0;i

136.{

137.*res_p++=（*num2_p-'0'+count）%10+'0';

138.count=（*num2_p-'0'+count）/10;

139.num2_p--;

140.

141.}

142.}

143.

144./*向最高位进一位*/

145.if（count==1）

146.*res_p++='1';

147.*res_p='\0';

148.reverseStr（result）;

149.}

150.}

151.

152./*减法运算，此时两个数的符号不同*/

153.else

154.{

155.inttemp=1;//记录num1和num2哪一个是负数，默认认为num1为负数

156.

157./*num1为负数*/

158.if（*num1=='-'）

159.{

160.num1++;

161.num1_len--;

162.}

163.

164./*num2为负数*/

165.else

166.{

167.temp=2;

168.num2++;

169.num2_len--;

170.}

171.

172./*num1绝对值大*/

173.if（num1_len>num2_len||num1_len==num2_len&&strcmp（num1,num2）>0）

174.{

175.inti;

176.for（i=0;i

177.{

178./*不借位*/

179.if（*num1_p-count>=*num2_p）

180.{

181.*res_p++=（*num1_p-*num2_p-count）%10+'0';

182.count=0;

183.}

184.

185./*借位*/

186.elseif（*num1_p-count<*num2_p）

187.{

188.*res_p++=（*num1_p+10-*num2_p-count）%10+'0';

189.count=1;

190.}

191.num1_p--;

192.num2_p--;

193.}

194.for（i=0;i

195.{

196./*不借位*/

197.if（*num1_p-'0'-count>=0）

198.{

199.*res_p++=（*num1_p-'0'-count）%10+'0';

200.count=0;

201.}

202.

203./*借位*/

204.elseif（*num1_p-'0'-count<0）

205.{

206.*res_p++=（*num1_p+10-'0'-count）%10+'0';

207.count=1;

208.}

209.num1_p--;

210.}

211.do

212.{

213.res_p--;

214.}

215.while（*res_p=='0'）;

216.

217./*num1是负数且绝对值大，所以此时结果为负数*/

218.if（temp==1）

219.{

220.res_p++;

221.*res_p++='-';

222.*res_p='\0';

223.reverseStr（result）;

224.}

225.

226./*num1是正数且绝对值大，所以此时结果为正数*/

227.elseif（temp==2）

228.{

229.res_p++;

230.*res_p='\0';

231.reverseStr（result）;

232.}

233.}

234.

235./*num2绝对值大*/

236.elseif（num1_len

237.{

238.inti;

239.for（i=0;i

240.{

241./*不借位*/

242.if（*num2_p-count>=*num1_p）

243.{

244.*res_p++=（*num2_p-*num1_p-count）%10+'0';

245.count=0;

246.}

247./*借位*/

248.elseif（*num2_p-count<*num1_p）

249.{

250.*res_p++=（*num2_p+10-*num1_p-count）%10+'0';

251.count=1;

252.}

253.num1_p--;

254.num2_p--;

255.}

256.for（i=0;i

257.{

258./*不借位*/

259.if（*num2_p-'0'-count>=0）

260.{

261.*res_p++=（*num2_p-'0'-count）%10+'0';

262.count=0;

263.}

264.

265./*借位*/

266.elseif（*num2_p-'0'-count<0）

267.{

268.*res_p++=（*num2_p+10-'0'-count）%10+'0';

269.count=1;

270.}

271.num2_p--;

272.}

273.do

274.{

275.res_p--;

276.}

277.while（*res_p=='0'）;

278.

279./*num1是负数且绝对值小，所以此时结果为正数*/

280.if（temp==1）

281.{

282.res_p++;

283.*res_p='\0';

284.reverseStr（result）;

285.}

286.

287./*num1是正数且绝对值小，所以此时结果为负数*/

288.elseif（temp==2）

289.{

290.res_p++;

291.*res_p++='-';

292.*res_p='\0';

293.reverseStr（result）;

294.}

295.}

296./*num1和num2绝对值相等且异号，所以结果为'0'*/

297.else

298.{

299.*res_p++='0';

300.*res_p='\0';

301.}

302.}

303.}

304.

305.voidmain（）

306.{

307.charresult[100];//保存结果的字符串

308.charnum1[100];

309.charnum2[100];

310.printf（"请输入两个整数（整数之间用空格作为间隔符）:

"）;

311.scanf（"%s%s",num1,num2）;

312.add（num1,num2,result）;

313.printf（"Theresultis:

"）;

314.printf（"%s\n",result）;

315.}