【 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

提示

无

地区

成都研究所

---

 

注意几点：

1. 对于复数平均值的题目，要注意数据类型，在代码中有详细的说明；
2. 注意输入非法的检查；
3. 注意边界条件的测试。

 

---

 

代码：

#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
请按任意键继续. . .