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);

	

}