全国软件大赛决赛题目附答案Word文档下载推荐.docx

全国软件大赛决赛题目附答案Word文档下载推荐.docx

《全国软件大赛决赛题目附答案Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《全国软件大赛决赛题目附答案Word文档下载推荐.docx（20页珍藏版）》请在冰豆网上搜索。

aaabc"

;

stringcomString[]={"

a"

"

aa"

"

bc"

};

vector<

comStr（comString+0,comString+3）;

resultStr（1,"

begin"

）;

string:

iteratorsou_sIt=souStr.begin（）;

iteratorresult_sIt=resultStr.begin（）;

searchAll（souStr,comStr,resultStr,sou_sIt,result_sIt）;

return0;

}

/*******************************功能函数部分********************************/

v）

iteratorsIt=str.begin（）;

v.clear（）;

while（sIt!

=str.end（））

{

v.push_back（*（sIt++））;

}

resultStr,\

result_sIt）

if（sou_sIt==souStr.end（））

intsumPower=0;

for（vector<

iteratorresult_begin_sIt=resultStr.begin（）;

\

result_begin_sIt<

result_sIt;

result_begin_sIt++）

{

cout<

<

*result_begin_sIt<

"

"

if（*result_begin_sIt=="

）

sumPower+=5;

elseif（*result_begin_sIt=="

sumPower+=12;

sumPower+=9;

bcd"

sumPower+=21;

cd"

sumPower+=15;

}

cout<

sumPower<

endl;

return;

for（vector<

iteratorcom_begin_sIt=comStr.begin（）;

com_begin_sIt<

comStr.end（）;

com_begin_sIt++）

intcomStringLenth=（*（com_begin_sIt））.size（）;

intsouStringLastLenth=souStr.end（）-sou_sIt;

if（comStringLenth>

souStringLastLenth）break;

intbitSouString=souStr.size（）-souStringLastLenth;

stringpartSouString=souStr.substr（bitSouString,comStringLenth）;

if（partSouString==*com_begin_sIt）

intk;

if（result_sIt==resultStr.end（））

{

result_sIt=resultStr.insert（result_sIt,*com_begin_sIt）;

}

else

*result_sIt=*com_begin_sIt;

for（k=comStringLenth;

k>

0;

k--）

sou_sIt++;

searchAll（souStr,comStr,resultStr,sou_sIt,++result_sIt）;

sou_sIt--;

result_sIt--;

}

题2，中分值题（21分）

数字黑洞问题：

任意一个五位数，调整其各位数字，分别组成一个最大数字和一个最小数字；

将其差值再作为新的数（如果不足5位，则前边补0），再次进行上一操作，直到出现循环。

例如41679，首次得差值82962，继续进行，则产生75933，63954，61974。

由此构成一个循环数。

例如本题：

输入：

41679

输出：

[82962，75933，63954，61974]

请编程实现，输出所有五位数的循环圈。

#include<

stdio.h>

stdlib.h>

queue>

cmath>

///冒泡排序法

voidsortBullet（intarry[],intn）

intflag;

for（intj=1;

j<

n;

j++）

flag=0;

for（inti=1;

i<

i++）

if（arry[i-1]>

arry[i]）

inttmp=arry[i];

arry[i]=arry[i-1];

arry[i-1]=tmp;

flag++;

if（flag==0）break;

longgetMax（intarry[]）

longMax=0;

for（inti=4;

i>

=0;

i--）

Max+=arry[i]*pow（10,i）;

returnMax;

longgetMin（intarry[]）

for（inti=0;

=4;

Max+=arry[i]*pow（10,4-i）;

voidlongToIntArry（longnum,intarry[]）

i<

5;

arry[i]=0;

queue<

int>

numqueue;

while

（1）

intn=num%10;

numqueue.push（n）;

if（num<

10）break;

num=num/10;

intj=4;

while（!

numqueue.empty（））

intelem;

elem=numqueue.front（）;

numqueue.pop（）;

arry[j]=elem;

j--;

intcompareArry（longnum1,longnum2）

intArry1[5],Arry2[5];

longToIntArry（num1,Arry1）;

longToIntArry（num2,Arry2）;

sortBullet（Arry1,5）;

sortBullet（Arry2,5）;

for（inti=0;

if（Arry1[i]!

=Arry2[i]）return0;

return1;

intjudgeBreak（vector<

long>

numArry,longnumDiffer）

iteratorsIt=numArry.begin（）;

while（sIt!

=numArry.end（））

if（compareArry（*sIt,numDiffer））return1;

sIt++;

}

///////////////////////////////////主函数部分

//longnumber;

//=41679;

numMery;

for（longnumber=10000;

number<

=99999;

number++）

intnumArry[5];

number<

:

longToIntArry（number,numArry）;

/*for（intI=0;

I<

I++）

numArry[I];

}*/

inttest=0;

longnumMax,numMin;

numMery.clear（）;

numMery.push_back（number）;

while

（1）

sortBullet（numArry,5）;

numMax=getMax（numArry）;

numMin=getMin（numArry）;

//cout<

numMax<

numMin;

longnumDiffer=numMax-numMin;

numDiffer<

if（judgeBreak（numMery,numDiffer））break;

numMery.push_back（numDiffer）;

longToIntArry（numDiffer,numArry）;

//if（test>

3）

//break;

//test++;

题3，中分值题（15分）

某单位将要组织一次旅游，已知各成员及其目的地（见“人员信息.txt”），要求根据人员信息，将各地的成员信息统一列出，以供统筹安排，并将结果输出到文件“人员信息2.txt”中。

注：

题中不要求城市，或人员信息的顺序。

//人员信息.txt的内容如下（应为一个单独的文本文件）：

赵一，北京

钱二，上海

孙三，南京

李四，北京

周小五，西安

吴天，南京

郑小七，上海

赵八，北京

王心凌，天津

刀郎，北京

例本题的输出应为：

北京

4

刀郎

李四

赵八

赵一

上海

2

钱二

郑小七

南京

孙三

吴天

西安

1

周小五

天津

王心凌

fstream>

voidcharToString（constchar*pt,vector<

strV）

strV.clear（）;

stringstr（pt）;

for（intn=0;

n<

str.size（）;

）

stringcharStr=str.substr（n,2）;

strV.push_back（charStr）;

n=n+2;

classCity

public:

City（）:

num（0）{}

intnum;

stringclientName[7][3];

CityBeijing;

CityShanghai;

CityNanjing;

CityTianjing;

CityXi_an;

ifstreamfile（"

人员信息.txt"

ofstreamfile2（"

人员信息2.txt"

strV;

charbuffer[20];

file.eof（））

file.getline（buffer,16）;

charToString（buffer,strV）;

intj;

for（inti=0;

3;

if（strV[i]=="

，"

）break;

if（"

北京"

==strV[i+1]+strV[i+2]）

for（j=0;

i;

Beijing.clientName[Beijing.num][j]=strV[j];

Beijing.num++;

}

elseif（"

上海"

Shanghai.clientName[Shanghai.num][j]=strV[j];

Shanghai.num++;

南京"

Nanjing.clientName[Nanjing.num][j]=strV[j];

Nanjing.num++;

天津"

Tianjing.clientName[Tianjing.num][j]=strV[j];

Tianjing.num++;

西安"

Xi_an.clientName[Xi_an.num][j]=strV[j];

Xi_an.num++;

intNUM;

intnamecounter;

file2<

\n"

Beijing.num<

for（NUM=0;

NUM<

Beijing.num;

NUM++）

for（namecounter=0;

namecounter<

namecounter++）

file2<

Beijing.clientName[NUM][namecounter];

file2<

Shanghai.num<

Shanghai.num;

Shanghai.clientName[NUM][namecounter];

Nanjing.num<

Nanjing.num;

Nanjing.clientName[NUM][namecounter];

Tianjing.num<

Tianjing.num;

Tianjing.clientName[NUM][namecounter];

Xi_an.num<

Xi_an.num;

Xi_an.clientName[NUM][namecounter];

题4，中分值题（9分）

日常生活中，人们往往被要求输入银行步号，例如：

卡号：

313456789876505201（红色标识为奇数位）

如此长的一串数字，让计算机来直接检验其是否合法，也是很不方便的，因而常采用“lnr”算法，它做如下规定：

（1）将其奇数位数字相加求和；

（2）将其偶数位数字乘以2，若为两位数，则减去9，累加求和；

（3）将上述两累加和相加，若能被10整除，则表明合法。

例如对于本题：

奇数位和为：

36

偶数位和为：

34

总和为：

34+36=70，可被10整除。

现要求，输入一个卡号，按如上算法，若通过，输出“成功”，反之，输出“失败”。

conio.h>

intcharToInt（chara）

returna-'

0'

cardNum;

chara;

while（（a=getch（））!

='

\r'

if（a>

&

a<

9'

cardNum.push_back（charToInt（a））;

a;

intchooseBrench=0;

intsum1=0;

intsum2=0;

iteratorsIt=cardNum.begin（）;

if（sIt==cardNum.end（））break;

if（chooseBrench%2）

sum1+=*sIt;

chooseBrench--;

sIt++;

else

if（（*sIt）*2>

=10）

sum2+=（（*sIt）*2-9）;

sum2+=（（*sIt）*2）;

chooseBrench++;

cout<

if（（sum1+sum2）%10）

失败"

else

成功"

题5，低分值题（5分）

日常生活中，人们打电话时，常按分，秒计时，

例如接通时为12：

33，挂机时为14：

05，则实际通话为92秒。

不考虑跨小时的情况，也不考虑用户输入错误的情况。

请根据输入的两时间，计算相应的通话时间。

int