华为2012校园招聘 上机考试2

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
函数返回：3

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. 简单四则运算

问题描述：
输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注：
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 array_compare(int len1, int array1[], int len2, int array2[])
{
int len = len1 < len2 ? len1 : len2, result = 0;
for(int i = 0; i < len; i++)
{
if(array1[len1 - 1 - i] != array2[len2 - 1 - i])
result++;
}
return result;
}

2.void array_iterate(int len, int input_array[], int m, int out_array[])
{
//带头结点的单向循环链表
LNode *head = (LNode*)malloc(sizeof(LNode));
head->data = 0;
head->next = NULL;
LNode *p = head;
LNode *pre = NULL;
int i = 0, out = 0, count = 0;
for(i = 0; i < len; ++i)
{
LNode *node = (LNode*)malloc(sizeof(LNode));
node->data = input_array[i];
node->next = NULL;
p->next = node;
p = node;
}
p->next = head->next;//形成环
p = head->next;
while(p != p->next)
{
count = 0;
while(count < m%len-1)
{
pre = p;
p = p->next;
count++;
}
out_array[out++] = p->data;
m = p->data;
len--;
pre->next = p->next;
free(p);
p = pre->next;
}
head->next = p;
out_array[out++] = p->data;
free(p);
free(head);


}

3.int calculate(int len,char *expStr)
{
LNode *head = (LNode*)malloc(sizeof(LNode));
head->data = 0;
head->next = NULL;
LNode *pre = head;

int  result  = 0;

for(int i = 0; i < len; i++)
{
LNode *node = (LNode*)malloc(sizeof(LNode));
if(expStr[i] != '+' && expStr[i] != '-' && expStr[i] != '*' && expStr[i] != '/')
node->data = expStr[i] - '0';
else
node->data = expStr[i];
node->next = NULL;
pre->next = node;
pre = node;
}
pre = head;
LNode *p = head->next;
while(p)
{
if(p->data == '*')
{
pre->data = pre->data * p->next->data;
pre->next = p->next->next;
free(p->next);
free(p);
p = pre->next;
}
else if(p->data == '/')
{
pre->data = pre->data / p->next->data;
pre->next = p->next->next;
free(p->next);
free(p);
p = pre->next;
}
else
{
pre = p;
p = p->next;
}
}
pre = head;
p = head->next;
while(p)
{
if(p->data == '+')
{
pre->data = pre->data + p->next->data;
pre->next = p->next->next;
free(p->next);
free(p);
p = pre->next;
}
else if(p->data == '-')
{
pre->data = pre->data - p->next->data;
pre->next = p->next->next;
free(p->next);
free(p);
p = pre->next;
}
else
{
pre = p;
p = p->next;
}
}
result  =  head->next->data;

free(head->next);

free(head);

return result;
}