【 2013华为杯编程大赛成都第三组前两题试题及答案】

2013-09-12 16:41:24

题目描述

某省会城市街道纵横交错，为了监控路灯的运行状况，每条街道使用一个数字字符串标识该街道上所有路灯的运行状况。
假设路灯只有如下3种状态（分别用数字0, 1, 2标识，一盏路灯只对应其中一种状态）：
0 标识路灯熄灭；
1 标识路灯开启；
2 标识路灯故障；
请根据输入的字符串，找出该街道上连续的处于相同状态的路灯的最大个数。若两种状态的路灯数量相同，则返回最先出现的路灯状态。

输入

街道上连续的路灯组成的状态字符串。字符串中只包含数字，每个路灯的状态为0，1，2中的一种状态。如“1101”代表4盏路灯，第3盏路灯为熄灭状态，其它3盏为开启状态。

输出

连续为相同状态的路灯的最大数量；

上述路灯的状态；

要求：先输出数量，再输出状态，两个整数间采用一个空格间隔。如输出：

53 2

样例输入

112200111

样例输出

3 1

提示

OK

地区

成都研究所

题目描述

由实部和虚部组成，形如(a,bi)这样的数，称为复数。通信系统中，通常用32bit数来表示复数（高16bit表示实部，低16bit表示虚部），如整数524295（16进制为0x00080007）所代表的复数，实部为0x0008，虚部为0x0007。
有别于实数运算，复数加、减、乘、除运算定义如下：
复数加公式：(a,bi) + (c,di) = (a + c),(b + d)i
复数减公式：(a,bi) + (c,di) = (a - c),(b - d)i
复数乘公式：(a,bi) * (c,di) = (ac - bd),(ad + bc)i
复数除公式：(a,bi) / N = (a/N),(b/N)i
题目要求，输入N个复数，计算这个N个复数的平均值，复数Avg = (复数1*复数2 + 复数3*复数4 + … + 复数N-1*复数N) / N。
复数加、复数减、复数乘、复数除的结果仍然为复数，实部和虚部均为16bit有符号数，计算过程中，当结果大于32767（0x7fff）时，输出32767；当计算结果小于-32768（0x8000）时，输出-32768。

输入

输入共计两行

有别于实数运算，复数加减乘除运算定义如下第一行包含1个整数，表示输入复数个数N（N为偶数，N不大于1000）

第一行包含1个整数，表示输入复数个数N（N为偶数，N不大于1000）

输出

经计算得到的复数的平均值。

样例输入

4
262149,393223,524297,655371

262149 = 0x40005,393223 = 0x6007,524297 = 0x8009,655371 = 0xA00B

[(4+5i)*(6+7i) + (8+9i)*(10+11i)]/4 = (-28+236i)/4 = -7+59i

-7对应的16位有符号数为65529，59对应的16位有符号数为59，对应的32位有符号数为int（（-7+65536）*65536 + 59 ） = -458693

4，

-196613，393223，-458761，655371

[(-4-5i)*(6+7i) + (-8-9i)*(10+11i)]/4 = (28-236i)/4 = 7-59i，对应的32位有符号数为：

int（7*65536 + （65536-59 ） = 524229

对应的4个数为：-196613，393223，-458761，655371

样例输出

-458693

提示

无

地区

成都研究所

注意几点：

对于复数平均值的题目，要注意数据类型，在代码中有详细的说明；

注意输入非法的检查；

注意边界条件的测试。

代码：

#include <iostream>
#include <cassert>
using namespace std;

const size_t SIZE = 1000;

void CheckValidInput(const char *pStrState)
{
assert(pStrState != NULL);
char *pCur = (char *)pStrState;

while (*pCur)
{
assert(*pCur >= '0' && *pCur <= '2');
++pCur;
}
}

void CountLamp(const char *pStrState,char &state,size_t &count)
{
CheckValidInput(pStrState);

count = 0;
state = '\0';

char *pCur = (char *)pStrState;
char curChar = '\0';
size_t curTimes = 0;

while (*pCur)   //对非法状态的处理？？？
{
curTimes = 0;
curChar = *pCur;

while (*pCur && *pCur == curChar)
{
++curTimes;
++pCur;
}

if (curTimes > count)
{
state = curChar;
count = curTimes;
}
}
}

const size_t BitWidth = 16;
const int Max = 65535;
const int MaxPositiveNum = 32767;  //2^15 - 1,是2与15异或的结果减1
const int MinNegativeNum = -32768;

//需要溢出处理，直接定义为short类型不能按照
//当结果大于32767（0x7fff）时，输出32767；当计算结果小于-32768（0x8000）时，输出-32768
//的方式处理
short HandleOverFlow(int num)  //返回值类型
{
if (num < MinNegativeNum)
{
return MinNegativeNum;
}
else if (num > MaxPositiveNum)
{
return MaxPositiveNum;
}

return num;
}

int ComplexAdd(const int compNum1,const int compNum2)
{
short ar = compNum1 >> BitWidth;
short ai = compNum1 & Max;
short br = compNum2 >> BitWidth;
short bi = compNum2 & Max;

cout<<"("<<ar<<" + j*"<<ai<<") + ("<<br<<" + j*"<<bi<<") = ";

int sumr = ar + br;   //需定义为int类型，保证溢出处理时按要求的
int sumi = ai + bi;

sumr = HandleOverFlow(sumr);  //HandleOverFlow返回即为short类型的
sumi = HandleOverFlow(sumi);

cout<<sumr<<" + j* "<<sumi<<endl;
return ((sumr << BitWidth) | (sumi & Max) );
}

int ComplexMult(const int compNum1,const int compNum2)
{
short ar = compNum1 >> BitWidth;   //定义为short类型即可
short ai = compNum1 & Max;
short br = compNum2 >> BitWidth;
short bi = compNum2 & Max;

cout<<"("<<ar<<" + j*"<<ai<<") * ("<<br<<" + j*"<<bi<<") = ";

int multr = ar * br - ai * bi;  //要定义为int类型，而非short类型，否则在溢出时，不能按照要求的溢出处理输出
int multi = ar * bi + ai * br;

multr = HandleOverFlow(multr);
multi = HandleOverFlow(multi);

cout<<multr<<" + j* "<<multi<<endl;

return ((multr << BitWidth) | (multi & Max) );
}

int  ComplexDivideN(const int  compNum1,const int N)
{
short ar = compNum1 >> BitWidth;
short ai = compNum1 & Max;

cout<<"("<<ar<<" + j*"<<ai<<") / "<<N<<" = ";

int divider =  (short)ar / N;   //divider、dividei定义为int、short都可
int dividei =  (short)ai / N;

cout<<"("<<divider<<" + j* "<<dividei<<")"<<endl;

return ( (divider << BitWidth) | (dividei & Max) );
}

int ComplexMultAddDivide(const int *compArray,const int n)
{
assert(compArray != NULL);
assert(n > 0 && n <= 1000 && (n % 2 == 0));

int index;
long long sum = 0;

for (index = 0;index < n;index += 2)
{
sum = ComplexAdd( sum,ComplexMult(compArray[index],compArray[index + 1]) );
}

return ComplexDivideN(sum,n);
}

void TestDriver()
{
//char *pStrState = "112200111";
//char *pStrState = "112200";
//char *pStrState = "12200";
//char *pStrState = "1200";
/*char *pStrState = "";
char state = '\0';
size_t count = 0;
CountLamp(pStrState,state,count);

cout<<"the state appears most is : "<<state<<endl;
cout<<"the times is : "<<count<<endl;*/

//int compArray[SIZE] = {1,0xff00ff};
int compArray[SIZE] = { 262149,393223,524297,655371 };
//int compArray[SIZE] = { -196613,393223,-458761,655371 };
//int compArray[SIZE] = { 32767,32767,-32767,32767 };  //溢出测试
//int compArray[SIZE] = {524297,655371};
int n = 4;
int average = 0;
average = ComplexMultAddDivide(compArray,n);

cout<<"the average is : "<<average<<endl;
}

int main()
{
TestDriver();
return 0;
}

运行结果：

(4 + j*5) * (6 + j*7) = -11 + j* 58
(0 + j*0) + (-11 + j*58) = -11 + j* 58
(8 + j*9) * (10 + j*11) = -19 + j* 178
(-11 + j*58) + (-19 + j*178) = -30 + j* 236
(-30 + j*236) / 4 = (-7 + j* 59)
the average is : -458693
请按任意键继续. . .