2012年华为校园招聘上机试题（重庆地区）及答案解析

1. 数组比较（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

函数返回：３

2. 约瑟夫问题

问题描述：

输入一个由随机数组成的数列（数列中每个数均是大于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}

3. 简单四则运算

问题描述：

输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 1、表达式只含 +, -, *, / 四则运算符，不含括号
2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
3、要考虑加减乘除按通常四则运算规定的计算优先级
4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
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

#include <stdio.h>

/*
* author by wanww
* time: 2011-09-07
*/
using namespace std;

int array_compare(int len1, int array1[], int len2, int array2[])
{
if(len1 == len2) {
int count = 0;
for (int i=0;i<len1;i++)
{
if(array1[i]!=array2[i]) count++;
}
return count;
} else if(len1<len2) {
return array_compare(len1, array1,len1,array2+len2-len1);

} else {
return array_compare(len2,array1+len1-len2,len2,array2);
}
}

void array_iterate(int len, int input_array[], int m,int output_array[])
{
int * flag = new int[len];
memset(flag,0,len*4);
int hasout=0;  //已经出列的数字个数
int start = 0; //开始的下标号
int j=0;	      //当前以报到的数字

while(true)
{
if(flag[start] == 0)	//当前元素还没出列
{
j++;
if(j==m)	//已经计数到m,当前start下标的元素出列
{
output_array[hasout] = input_array[start];
flag[start] = 1;	//标记当前元素已经出列

hasout ++;
if(hasout == len) break; //所有的元素都已经出列，结束程序

//初始化下一轮的数字
j = 0;
m = input_array[start];
}

}

start ++;
if(start==len) start = 0;

}

delete [] flag;

}

int calculate(int len,char *expStr)
{
struct  {
char opdata[200];
int top;
}opstack;
//定义操作符栈

opstack.top = -1;

int i=0;//遍历字符串的下标
int t=0;//当前后缀表达式的长度

char ch = expStr[i];

while (ch!='\0')
{
switch (ch)
{
case '+':
case '-':
while (opstack.top != -1)
{
expStr[t] = opstack.opdata[opstack.top];
opstack.top--;
t++;
}
opstack.top++;
opstack.opdata[opstack.top] = ch;
break;
case '*':
case '/':
while (opstack.top != -1 && (opstack.opdata[opstack.top] =='*' || opstack.opdata[opstack.top] =='/') )
{
expStr[t] = opstack.opdata[opstack.top];
opstack.top--;
t++;
}
opstack.top++;
opstack.opdata[opstack.top] = ch;
break;
default:
expStr[t] = ch;
t++;
break;
}
i++;
ch = expStr[i];
}

while (opstack.top != -1)//将栈中所有的剩余的运算符出栈
{
expStr[t] = opstack.opdata[opstack.top];
opstack.top--;
t++;
}

expStr[t]='\0';

struct 	{
int numeric[200];
int top;
}data;

data.top = -1;

i=0;
ch = expStr[i];

while (ch!='\0')
{
if (ch>='0' && ch <= '9' )
{
data.top++;
data.numeric[data.top] = ch-'0';
}
else if('+' == ch)
{
int tmp = data.numeric[data.top-1]  + data.numeric[data.top];
data.top--;
data.numeric[data.top] = tmp;
}
else if('-' == ch)
{
int tmp = data.numeric[data.top-1]  - data.numeric[data.top];
data.top--;
data.numeric[data.top] = tmp;
}
else if('*' == ch)
{
int tmp = data.numeric[data.top-1]  * data.numeric[data.top];
data.top--;
data.numeric[data.top] = tmp;
}
else if('/' == ch)
{
if(data.numeric[data.top] == 0)
{
printf("cannot be zero of the divide\n");
exit(1);
}
int tmp = data.numeric[data.top-1] / data.numeric[data.top];
data.top--;
data.numeric[data.top] = tmp;
}
i++;
ch = expStr[i];
}

return data.numeric[data.top];
}

void main()
{

int array1[] = {1,3,5};
int len1 = 3;
int array2[] = {77,21,1,3,5,7};
int len2 = 6;
int count =	array_compare(sizeof(array1)/sizeof(int),array1,sizeof(array2)/sizeof(int),array2);
printf("%d\n",count);

printf("*****************************************************\n");

int input_array[] = {3,1,2,4};
int len = 4;
int m=7;

int * output_array = new int[sizeof(input_array)/sizeof(int)];

array_iterate(4,input_array,7,output_array);

for (int i=0;i<sizeof(input_array)/sizeof(int);i++)
{
printf("%d ",output_array[i]);
}

delete [] output_array;

printf("\n*****************************************************\n");

char expStr[] = "8/3*3";

int result = calculate(strlen(expStr),expStr);

printf("%s\n",expStr);
printf("%d\n",result);

}