蓝桥杯练习题库 3算法训练题DOC.docx

蓝桥杯练习题库 3算法训练题DOC.docx

《蓝桥杯练习题库 3算法训练题DOC.docx》由会员分享，可在线阅读，更多相关《蓝桥杯练习题库 3算法训练题DOC.docx（71页珍藏版）》请在冰点文库上搜索。

蓝桥杯练习题库3算法训练题DOC

算法训练图形显示 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）：

　　*****

　　****

　　***

　　**

　　*

#include

intmain（）

{inti,j,a[100][100],n;

while（scanf（"%d",&n）!

=EOF）

{for（i=0;i

for（j=0;j

{

printf（"*"）;

if（j!

=n-i-1）

printf（""）;

if（j==n-1-i）

printf（"\n"）;

}

}

}

 算法训练排序 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。

　　输入格式：

输入只有一行，即三个整数，中间用空格隔开。

　　输出格式：

输出只有一行，即排序后的结果。

　　输入输出样例

样例输入

9230

样例输出

3092

#include

#include

#definenum100

intmain（void）

{

inti,j,t,a[3]={0};

for（i=0;i<3;i++）

{scanf（"%d",&a[i]）;

}

for（i=0;i<3;i++）

for（j=i;j<3;j++）

if（a[i]<=a[j]）{t=a[i];a[i]=a[j];a[j]=t;}

for（i=0;i<3;i++）

{printf（"%d",a[i]）;

if（i!

=2）printf（""）;

}

printf（"\n"）;

return0;

}

 算法训练2的次幂表示 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　任何一个正整数都可以用2进制表示，例如：

137的2进制表示为10001001。

　　将这种2进制表示写成2的次幂的和的形式，令次幂高的排在前面，可得到如下表达式：

137=2^7+2^3+2^0

　　现在约定幂次用括号来表示，即a^b表示为a（b）

　　此时，137可表示为：

2（7）+2（3）+2（0）

　　进一步：

7=2^2+2+2^0（2^1用2表示）

　　3=2+2^0

　　所以最后137可表示为：

2（2

（2）+2+2（0））+2（2+2（0））+2（0）

　　又如：

1315=2^10+2^8+2^5+2+1

　　所以1315最后可表示为：

　　2（2（2+2（0））+2）+2（2（2+2（0）））+2（2

（2）+2（0））+2+2（0）

输入格式

　　正整数（1<=n<=20000）

输出格式

　　符合约定的n的0，2表示（在表示中不能有空格）

样例输入

137

样例输出

2（2

（2）+2+2（0））+2（2+2（0））+2（0）

样例输入

1315

样例输出

2（2（2+2（0））+2）+2（2（2+2（0）））+2（2

（2）+2（0））+2+2（0）

提示

用递归实现会比较简单，可以一边递归一边输出

#include

intl=0;

chartemp[1000]={0};

voidshow（intn）

{

if（n==0）{temp[l]='0';l++;return;}

if（n==2）{temp[l]='2',l++;return;}

inta[15]={0},i=0,j;

while（n!

=0）

{

a[i]=n%2;

n/=2;

i++;

}

for（j=i-1;j>=0;j--）

if（a[j]==1）

{

if（j==1）

{

if（temp[l-1]=='）'||temp[l-1]=='2'）{temp[l]='+';l++;}

temp[l]='2';l++;

}

else

{

if（temp[l-1]=='）'||temp[l-1]=='2'）{temp[l]='+';l++;}

temp[l]='2';l++;

temp[l]='（';l++;

show（j）;

temp[l]='）';l++;

}

}

}

intmain（）

{

intn;

scanf（"%d",&n）;

show（n）;

printf（"%s",temp）;

return0;

}

算法训练前缀表达式 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。

输入格式为：

“运算符对象1对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除法），运算对象为不超过10的整数，它们之间用一个空格隔开。

要求：

对于加、减、乘、除这四种运算，分别设计相应的函数来实现。

　　输入格式：

输入只有一行，即一个前缀表达式字符串。

　　输出格式：

输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果为整数）。

　　输入输出样例

样例输入

+52

样例输出

7

#include

intmain（）

{inta[2];

inti,j;

charc=getchar（）;

for（i=0;i<2;i++）

scanf（"%d",&a[i]）;

if（c=='+'）

j=a[0]+a[1];

elseif（c=='-'）

j=a[0]-a[1];

elseif（c=='*'）

j=a[0]*a[1];

elseif（c=='/'）

j=a[0]/a[1];

printf（"%d",j）;

return0;

}

算法训练Anagrams问题 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　Anagrams指的是具有如下特性的两个单词：

在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。

例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。

编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。

每一个单词的长度不会超过80个字符，而且是大小写无关的。

　　输入格式：

输入有两行，分别为两个单词。

　　输出格式：

输出只有一个字母Y或N，分别表示Yes和No。

　　输入输出样例

样例输入

Unclear

Nuclear

样例输出

Y

#include

voidsort（chara[],intlen）

{

inti,j,max;

for（i=0;i

{

max=i;

for（j=i+1;j

if（a[j]>a[max]）max=j;

j=a[i];a[i]=a[max];a[max]=j;

}

}

voidstrtoupper（chara[],intlen）

{

inti;

for（i=0;i

if（a[i]>='a'&&a[i]<='z'）a[i]-=32;

}

intmystrcmp（chara[],intl1,charb[],intl2）

{

if（l1!

=l2）return0;

inti;

for（i=0;i

if（a[i]!

=b[i]）return0;

return1;

}

intmystrlen（char*p）

{

intl=0;

while（*p++!

=0）

l++;

returnl;

}

intmain（）

{

chars1[1000]={0},s2[1000]={0};

intl1,l2;

scanf（"%s%s",s1,s2）;

l1=mystrlen（s1）;

l2=mystrlen（s2）;

strtoupper（s1,l1）;

strtoupper（s2,l2）;

sort（s1,l1）;

sort（s2,l2）;

if（mystrcmp（s1,l1,s2,l2））printf（"Y"）;

elseprintf（"N"）;

return0;

}

算法训练出现次数最多的整数 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

　　问题描述

　　编写一个程序，读入一组整数，这组整数是按照从小到大的顺序排列的，它们的个数N也是由用户输入的，最多不会超过20。

然后程序将对这个数组进行统计，把出现次数最多的那个数组元素值打印出来。

如果有两个元素值出现的次数相同，即并列第一，那么只打印比较小的那个值。

　　输入格式：

第一行是一个整数N，N£20；接下来有N行，每一行表示一个整数，并且按照从小到大的顺序排列。

　　输出格式：

输出只有一行，即出现次数最多的那个元素值。

　　输入输出样例

样例输入

5

100

150

150

200

250

样例输出

150

#include

intmain（）

{

intn,i,j,t,max=1,num=0;

scanf（"%d",&n）;

if（n>0）

{

inta[n];

for（i=0;i

scanf（"%d",a+i）;

j=num=a[0];

t=1;

for（i=1;i

if（a[i]==j）

{

++t;

if（t>max）

{

max=t;num=a[i];

}

}

else

{

t=1;

j=a[i];

}

printf（"%d",num）;

}

return0;

}

 算法训练字串统计 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　给定一个长度为n的字符串S，还有一个数字L，统计长度大于等于L的出现次数最多的子串（不同的出现可以相交），如果有多个，输出最长的，如果仍然有多个，输出第一次出现最早的。

输入格式

　　第一行一个数字L。

　　第二行是字符串S。

　　L大于0，且不超过S的长度。

输出格式

　　一行，题目要求的字符串。

　　输入样例1：

　　4

　　bbaabbaaaaa

　　输出样例1：

　　bbaa

　　输入样例2：

　　2

　　bbaabbaaaaa

　　输出样例2：

　　aa

数据规模和约定

　　n<=60

　　S中所有字符都是小写英文字母。

　　提示

　　枚举所有可能的子串，统计出现次数，找出符合条件的那个

#include

#include

intmain（）{

charS[1000],str[1000][1000],temp[100],out[100];

intL,i=0,s,otongji=0,ttongji,a,b,c;

scanf（"%d%c%c",&L,&S[0],&S[0]）;

while（S[i]!

='\n'）{

scanf（"%c",&S[i+1]）;

i++;

}

S[i]='\0';

for（s=i+1;L<=s;L++）{

for（a=0;a

for（b=0;b

str[a][b]=S[a+b];

}

str[a][b]='\0';

}

for（i=0;i

for（b=0;b

if（str[b][0]!

='\0'）{

for（c=0;c

temp[c]=str[b][c];

}

temp[c]='\0';

ttongji=1;

i++;

str[b][0]='\0';

break;

}

}

for（b++;b

if（!

strcmp（str[b],temp））{

ttongji++;

i++;

str[b][0]='\0';

}

}

if（ttongji>otongji||（ttongji==otongji&&strlen（temp）>strlen（out）））{

strcpy（out,temp）;

otongji=ttongji;

}

}

}

i=0;

while（out[i]!

='\0'）{

printf（"%c",out[i]）;

i++;

}

getchar（）;

return0;

}

算法训练矩阵乘法 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　输入两个矩阵，分别是m*s，s*n大小。

输出两个矩阵相乘的结果。

输入格式

　　第一行，空格隔开的三个正整数m,s,n（均不超过200）。

　　接下来m行，每行s个空格隔开的整数，表示矩阵A（i，j）。

　　接下来s行，每行n个空格隔开的整数，表示矩阵B（i，j）。

输出格式

　　m行，每行n个空格隔开的整数，输出相乘後的矩阵C（i，j）的值。

样例输入

232

10-1

11-3

03

12

31

样例输出

-32

-82

提示

矩阵C应该是m行n列，其中C（i,j）等于矩阵A第i行行向量与矩阵B第j列列向量的内积。

例如样例中C（1,1）=（1,0,-1）*（0,1,3）=1*0+0*1+（-1）*3=-3

#include

intmain（）{

intm,s,n,i,j,k,a[200][200],b[200][200],c[200][200];

scanf（"%d%d%d",&m,&s,&n）;

for（i=1;i<=m;i++）{

for（j=1;j<=s;j++）

scanf（"%d",&a[i][j]）;

}

for（i=1;i<=s;i++）{

for（j=1;j<=n;j++）

scanf（"%d",&b[i][j]）;

}

for（i=1;i<=m;i++）{

for（j=1;j<=n;j++）

c[i][j]=0;

}

for（i=1;i<=m;i++）{

for（j=1;j<=n;j++）{

for（k=1;k<=s;k++）{

c[i][j]=c[i][j]+a[i][k]*b[k][j];

}

}

}

for（i=1;i<=m;i++）{

for（j=1;j<=n;j++）

printf（"%d",c[i][j]）;

printf（"\n"）;

}

return0;

}

算法训练大小写转换 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　编写一个程序，输入一个字符串（长度不超过20），然后把这个字符串内的每一个字符进行大小写变换，即将大写字母变成小写，小写字母变成大写，然后把这个新的字符串输出。

　　输入格式：

输入一个字符串，而且这个字符串当中只包含英文字母，不包含其他类型的字符，也没有空格。

　　输出格式：

输出经过转换后的字符串。

　　输入输出样例

样例输入

AeDb

样例输出

aEdB

#include

intmain（）

{

inti;

charch[100];

gets（ch）;

i=0;

while（ch[i]!

='\0'）

{

if（ch[i]<='z'&&ch[i]>='a'）

ch[i]-=32;

elsech[i]+=32;

i++;

}

puts（ch）;

return0;

}

算法训练动态数组使用 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

　　从键盘读入n个整数，使用动态数组存储所读入的整数，并计算它们的和与平均值分别输出。

要求尽可能使用函数实现程序代码。

平均值为小数的只保留其整数部分。

样例输入

5

34002

样例输出

91

样例输入

7

3275291

样例输出

294

#include

intmain（）

{

inti,n,a[100],b[100],sum=0,avg=0;

scanf（"%d",&n）;

for（i=0;i

{

scanf（"%d",&b[i]）;

a[i]=b[i];

sum=sum+a[i];

}

avg=sum/n;

printf（"%d%d\n",sum,avg）;

return0;

}

算法训练删除数组零元素 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

　　从键盘读入n个整数放入数组中，编写函数CompactIntegers，删除数组中所有值为0的元素，其后元素向数组首端移动。

注意，CompactIntegers函数需要接受数组及其元素个数作为参数，函数返回值应为删除操作执行后数组的新元素个数。

输出删除后数组中元素的个数并依次输出数组元素。

　　样例输入:

（输入格式说明：

5为输入数据的个数，34002是以空格隔开的5个整数）

　　5

　　34002

　　样例输出:

（输出格式说明：

3为非零数据的个数，342是以空格隔开的3个非零整数）

　　3

　　342

样例输入

7

0070090

样例输出

2

79

样例输入

3

000

样例输出

0

算法训练最小乘积（基本型） 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　给两组数，各n个。

　　请调整每组数的排列顺序，使得两组数据相同下标元素对应相乘，然后相加的和最小。

要求程序输出这个最小值。

　　例如两组数分别为:

13　　-5和-241

　　那么对应乘积取和的最小值应为：

　　（-5）*4+3*（-2）+1*1=-25

输入格式

　　第一个行一个数T表示数据组数。

后面每组数据，先读入一个n，接下来两行每行n个数，每个数的绝对值小于等于1000。

　　n<=8,T<=1000

输出格式

　　一个数表示答案。

样例输入

2313-5-24151234510101

样例输出

-256

#include

voidsort1（int*a,intn）

{

inti,j;

inttmp;

for（i=0;i

for（j=0;j

if（a[j]>a[j+1]）

{

tmp=a[j];

a[j]=a[j+1];

a[j+1]=tmp;

}

}

voidsort2（int*a,intn）

{

inti,j;

inttmp;

for（i=0;i

for（j=0;j

if（a[j]

{

tmp=a[j];

a[j]=a[j+1];

a[j+1]=tmp;

}

}

intmain（void）

{

intT;

intn,i;

inttotal;

inta[8],b[8],c[8];

scanf（"%d",&T）;

while（T）

{

total=0;

scanf（"%d",&n）;

for（i=0;i

scanf（"%d",&a[i]）;

for（i=0;i

scanf（"%d",&b[i]）;

sort1（a,n）;

sort2（b,n）;

for（i=0;i

c[i]=a[i]*b[i];

for（i=0;i

total+=c[i];

printf（"%d\n",total）;

T--;

}

return0;

}

算法训练Torry的困惑（基本型） 

时间限制：

1.0s 内存限制：

512.0MB

   查看参考代码

锦囊1

锦囊2

锦囊3

问题描述

　　Torry从小喜爱数学。

一天，老师告诉他，像2、3、5、7……这样的数叫做质数。

Torry突然想到一个问题，前10、100、1000、10000……个质数的乘积是多少呢？

他把这个问题告诉老师。

老师愣住了，一时回答不出来。

于是Torry求助于会编程的你，请你算出前n个质数的乘积。

不过，考虑到你才接触编程不久，Torry只要你算出这个数模上50000的值。

输入格式

　　仅包含一个正整数n，其中n<=100000。

输出格式

　　输出一行，即前n个质数的乘积模50000的值。

样例输入

1

样例输出

2

#include

intpr[100010];

inttop;

intisPrime（intn）

{

inti;

for（i=0;i

{

if（n%pr[i]==0）

{

return0;

}

}

return1;

}

intfindNextPrime（void）

{

intn=pr[top-1]+1;

while（!

isPrime（n））

{