1.6编程基础之一维数组

---

01:与指定数字相同的数的个数

总时间限制: 1000ms 内存限制: 65536kB

描述
输出一个整数序列中与指定数字相同的数的个数。

输入
输入包含三行：第一行为N，表示整数序列的长度(N <= 100)；第二行为N个整数，整数之间以一个空格分开；第三行包含一个整数，为指定的整数m。

输出
输出为N个数中与m相同的数的个数。

样例输入

3
2 3 2
2

样例输出

2

参考代码

#include
using namespace std;

int main(){
	int n, c=0, num;
	cin >> n;
	int m[n];// 定义数组
	for(int i=0;i<n;i++){// 将输入保存到数组中。
		cin >> m[i];
	}
	cin >> num;
	for(int i=0;i<n;i++){//循环遍历数组
		if(m[i]==num)c++;//如果相同 计数
	}
	cout << c <<endl;
	return 0;
} 

02:陶陶摘苹果

总时间限制: 1000ms 内存限制: 65536kB

描述
陶陶家的院子里有一棵苹果树，每到秋天树上就会结出10个苹果。苹果成熟的时候，陶陶就会跑去摘苹果。陶陶有个30厘米高的板凳，当她不能直接用手摘到苹果的时候，就会踩到板凳上再试试。现在已知10个苹果到地面的高度，以及陶陶把手伸直的时候能够达到的最大高度，请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果，苹果就会掉下来。

输入
包括两行数据。第一行包含10个100到200之间（包括100和200）的整数（以厘米为单位）分别表示10个苹果到地面的高度，两个相邻的整数之间用一个空格隔开。第二行只包括一个100到120之间（包含100和120）的整数（以厘米为单位），表示陶陶把手伸直的时候能够达到的最大高度。

输出
包括一行，这一行只包含一个整数，表示陶陶能够摘到的苹果的数目。

样例输入

100 200 150 140 129 134 167 198 200 111
110

样例输出

5

参考代码

#include
using namespace std;

int main(){
	const int b=30;//板凳高度
	int a[10], h, count=0;
	for(int i=0;i<10;i++){
		cin >> a[i];//将输入保存到数组中
	}
	cin >> h;
	for(int i=0;i<10;i++){//循环遍历数据，根据条件进行计数
		if(h+b>=a[i])count++;
	}
	cout << count << endl;
	return 0;
} 

03:计算书费

总时间限制: 1000ms 内存限制: 65536kB

描述
下面是一个图书的单价表：
计算概论 28.9 元/本
数据结构与算法 32.7 元/本
数字逻辑 45.6元/本
C++程序设计教程 78 元/本
人工智能 35 元/本
计算机体系结构 86.2 元/本
编译原理 27.8元/本
操作系统 43 元/本
计算机网络 56 元/本
JAVA程序设计 65 元/本
给定每种图书购买的数量，编程计算应付的总费用。

输入
输入一行，包含10个整数(大于等于0，小于等于100)，分别表示购买的《计算概论》、《数据结构与算法》、《数字逻辑》、《C++程序设计教程》、《人工智能》、《计算机体系结构》、《编译原理》、《操作系统》、《计算机网络》、《JAVA程序设计》的数量（以本为单位）。每两个整数用一个空格分开。

输出
输出一行，包含一个浮点数f，表示应付的总费用。精确到小数点后一位。

样例输入

1 5 8 10 5 1 1 2 3 4

样例输出

2140.2

参考代码

#include
#include
using namespace std;

int main(){
	float b[10]={28.9, 32.7, 45.6, 78, 35, 86.2, 27.8, 43, 56, 65},s=0;//数组中保存书的价格
	int c;
	for(int i=0;i<10;i++){
		cin >> c;//输入数量
		s+=b[i]*c;//计算总价
	}
	cout << fixed << setprecision(1) << s << endl;
	return 0;
} 

04:数组逆序重放

总时间限制: 1000ms 内存限制: 65536kB

描述
将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。

输入
输入为两行：第一行数组中元素的个数n（1

输出
输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。

样例输入

5
8 6 5 4 1

样例输出

1 4 5 6 8

参考代码

#include
#include
using namespace std;

int main(){
	int n, m[100];
	cin >> n;
	for(int i=0;i<n;i++){//将输入保存到数组中，索引值从0到n-1
		cin >> m[i];
	}
	for(int i=n-1;i>=0;i--){//遍历数组，从索引值n-1到0.实现逆序输出
		cout << m[i] << ' ';		
	}
	return 0;
} 

05:年龄与疾病

总时间限制: 1000ms 内存限制: 65536kB

描述
某医院想统计一下某项疾病的获得与否与年龄是否有关，需要对以前的诊断记录进行整理，按照0-18、19-35、36-60、61以上（含61）四个年龄段统计的患病人数占总患病人数的比例。

输入
共2行，第一行为过往病人的数目n（0 < n <= 100)，第二行为每个病人患病时的年龄。

输出
按照0-18、19-35、36-60、61以上（含61）四个年龄段输出该段患病人数占总患病人数的比例，以百分比的形式输出，精确到小数点后两位。每个年龄段占一行，共四行。

样例输入

10
1 11 21 31 41 51 61 71 81 91

样例输出

20.00%
20.00%
20.00%
40.00%

参考代码

#include
#include
using namespace std;

int main(){
	int a, n, r[4]={0};
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> a;
		if(a>=61){
			r[3]+=1;
		}else if(a>=36){
			r[2]+=1;
		}else if(a>=19){
			r[1]+=1;
		}else if(a>=0){
			r[0]+=1;
		}
	}
	for(int i=0;i<4;i++){
		cout << fixed << setprecision(2) << r[i]*100.0/n << '%' << endl;
	}
	return 0;
} 

06:校门外的树

总时间限制: 1000ms 内存限制: 65536kB

描述
某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。

输入
第一行有两个整数L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点和终止点的坐标。对于20%的数据，区域之间没有重合的部分；对于其它的数据，区域之间有重合的情况。

输出
包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。

样例输入

500 3
150 300
100 200
470 471

样例输出

298

参考代码

#include
using namespace std;

int s[10000];//全局变量（编译器会将全局、静态变量放入BSS段（这是全零的内存段），所以会被默认初始化为0）
int l,m,count;
int main(){
	cin >> l >> m;
	for(int i=0;i<m;i++){
		int a,b;//占用的区间
		cin >> a >> b;
		for(int j=a;j<=b;j++){//将这个区间所有值变为1，代表树木被移走了。
			s[j]=1;
		}
	}
	for(int i=0;i<=l;i++){//循环遍历，注意范围0到l，包含l
		if(s[i]==0)count++;//如果是0，代表还有树木，计数。
	}
	cout << count;
	return 0;
} 

07:有趣的跳跃

总时间限制: 1000ms 内存限制: 65536kB

描述
一个长度为n（n>0）的序列中存在“有趣的跳跃”当前仅当相邻元素的差的绝对值经过排序后正好是从1到(n-1)。例如，1 4 2 3存在“有趣的跳跃”，因为差的绝对值分别为3,2,1。当然，任何只包含单个元素的序列一定存在“有趣的跳跃”。你需要写一个程序判定给定序列是否存在“有趣的跳跃”。

输入
一行，第一个数是n（0 < n < 3000），为序列长度，接下来有n个整数，依次为序列中各元素，各元素的绝对值均不超过1,000,000,000。

输出
一行，若该序列存在“有趣的跳跃”，输出"Jolly"，否则输出"Not jolly"。

样例输入

4 1 4 2 3

样例输出

Jolly

参考代码

#include
#include
using namespace std;

const int maxn=3000;
int n, m, a[maxn], b[maxn];
bool flag=true;
int main(){
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> a[i];
	}
	for(int j=1;j<n;j++){
		int d = abs(a[j]-a[j-1]);//计算绝对值
		if(d>0&&d<n){//需要在1到n-1的范围内
			b[d]++;//记录差值d出现的次数
			if(b[d]>1){//出现次数大于1，不存在有趣跳跃
				flag=false;
				break;	
			}
		}else{//如果绝对值不在1到n-1的范围，结束循环。不存在有趣的跳跃
			flag=false;
			break;
		}
	}
	if(n==1||flag){//单个元素，或者flag为true。则存在有趣跳跃
		cout << "Jolly";
	}else{
		cout << "Not jolly";
	}
	return 0;
}

08:石头剪刀布

总时间限制: 1000ms 内存限制: 65536kB

描述
石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。请问，小A和小B比了N轮之后，谁赢的轮数多？

输入
输入包含三行。第一行包含三个整数：N，NA，NB，分别表示比了N轮，小A出拳的周期长度，小B出拳的周期长度。0 < N,NA,NB < 100。第二行包含NA个整数，表示小A出拳的规律。第三行包含NB个整数，表示小B出拳的规律。其中，0表示“石头”，2表示“剪刀”，5表示“布”。相邻两个整数之间用单个空格隔开。

输出
输出一行，如果小A赢的轮数多，输出A；如果小B赢的轮数多，输出B；如果两人打平，输出draw。

样例输入

10 3 4
0 2 5
0 5 0 2

样例输出

A

提示
对于测试数据，猜拳过程为：A：0 2 5 0 2 5 0 2 5 0B：0 5 0 2 0 5 0 2 0 5A赢了4轮，B赢了2轮，双方打平4轮，所以A赢的轮数多。

参考代码

#include
#include
using namespace std;

const int maxn=110;
int n, na, nb, wa, wb;//wa,wb分别记录a和b胜利次数
int a[maxn], b[maxn];
int main(){
	cin>>n>>na>>nb;
	for(int i=1;i<=na;i++){//记录a的规律
		cin >> a[i];
	}
	for(int i=1;i<=nb;i++){//记录b的规律
		cin >> b[i];
	}
	for(int j=1;j<=n;j++){
		int ai=j%na==0?na:j%na;//通过求余数取出对应轮次a的出拳索引值
		int bi=j%nb==0?nb:j%nb;//通过求余数取出对应轮次b的出拳索引值
		if(a[ai]!=b[bi]){//如果出拳不同再判断，相同为平局没有统计必要
			if(a[ai]+b[bi]==5){//如果和为5，即一个除了石头一个出了布
				if(a[ai]==0)wb++;//出布的胜利
				else wa++;
			}else{//否则哪个数字小哪个胜利
				if(a[ai]>b[bi])wb++;
				else wa++;
			}
		}	
	}
	if(wa>wb)cout<<'A';
	else if(wa<wb)cout<<'B';
	else cout<<"draw"; 
	return 0;
}

09:向量点积计算

总时间限制: 1000ms 内存限制: 65536kB

描述
在线性代数、计算几何中，向量点积是一种十分重要的运算。给定两个n维向量a=(a1,a2,…,an)和b=(b1,b2,…,bn)，求点积a·b=a1b1+a2b2+…+anbn。

输入
第一行是一个整数n。1 <= n <= 1000。第二行包含n个整数a1,a2,…,an。第三行包含n个整数b1,b2,…,bn。相邻整数之间用单个空格隔开。每个整数的绝对值都不超过1000。

输出
一个整数，即两个向量的点积结果。

样例输入

3
1 4 6
2 1 5

样例输出

36

参考代码

#include
#include
using namespace std;

const int maxn=1010;
int n, a[maxn], b, s;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){//记录a1...an
		cin>>a[i];
	}
	for(int j=1;j<=n;j++){//输入b1...bn,并计算乘积和
		cin>>b;
		s+=a[j]*b;
	}
	cout<<s<<endl;
	return 0;
}

10:大整数加法

总时间限制: 1000ms 内存限制: 65536kB

描述
求两个不超过200位的非负整数的和。

输入
有两行，每行是一个不超过200位的非负整数，可能有多余的前导0。

输出
一行，即相加后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。

样例输入

22222222222222222222
33333333333333333333

样例输出

55555555555555555555

参考代码

#include
#include
using namespace std;

const int maxn=210;
char a[maxn], b[maxn];
int n1[maxn], n2[maxn];
int main(){
	cin>>a>>b;
	int al=strlen(a);
	int bl=strlen(b);
	int i;
	for(i=1;i<=al;i++)n1[i]=a[al-i]-48;//遍历字符数组，将字符串组放到整数数组中，并反转便于计算
	for(i=1;i<=bl;i++)n2[i]=b[bl-i]-48;
	for(i=1;i<=al||i<=bl;i++){//遍历两个数组，求和
		n1[i]+=n2[i];//将和保存到n1中
		if(n1[i]>9){//如果产生了进位
			n1[i]%=10;//这一位保留个位
			n1[i+1]++;//下一位i+1位 进位
		}
	}
	while(n1[i]==0&&i>1)i--;//避免0输出
	while(i)cout<<n1[i--];//输出剩下的所有数字
	return 0;
}

11:大整数减法

总时间限制: 1000ms 内存限制: 65536kB

描述
求两个大的正整数相减的差。

输入
共2行，第1行是被减数a，第2行是减数b(a > b)。每个大整数不超过200位，不会有多余的前导零。

输出
一行，即所求的差。

样例输入

9999999999999999999999999999999999999
9999999999999

样例输出

9999999999999999999999990000000000000

参考代码

#include
#include
using namespace std;

const int maxn=210;
char a[maxn], b[maxn];
int n1[maxn], n2[maxn];
int main(){
	cin>>a>>b;
	int al=strlen(a);
	int bl=strlen(b);
	int i;
	for(i=1;i<=al;i++)n1[i]=a[al-i]-48;//遍历字符数组，将字符串组放到整数数组中，并反转便于计算
	for(i=1;i<=bl;i++)n2[i]=b[bl-i]-48;
	for(i=1;i<=al||i<=bl;i++){//遍历两个数组，求差
		if(n1[i]<n2[i]){//如果被减数该位的数字<减数该位的数字
			n1[i+1]--;//向前借一位
			n1[i]=10+n1[i]-n2[i];//借位后再做减法	
		}else{//否则整除相减
			n1[i]-=n2[i];
		}
	}
	while(n1[i]==0&&i>1)i--;//避免多余的0输出
	while(i)cout<<n1[i--];
		
	return 0;
}

12:计算2的N次方

总时间限制: 1000ms 内存限制: 65536kB

描述
任意给定一个正整数N(N<=100)，计算2的n次方的值。

输入
输入一个正整数N。

输出
输出2的N次方的值。

样例输入

5

样例输出

32

提示
高精度计算

参考代码

#include
#include
using namespace std;

const int maxn=35;
int ans[maxn]={0}, n, temp;
int main(){
	cin>>n;
	int w=1,i=0,k=0;
	ans[0]=2;
	if(n==0){//如果是0次方，结果为1
		cout<<1;
		return 0;
	}else if(n==1){//如果是1次方，结果是2
		cout<<ans[0];
		return 0;
	}
	while(n-1){
		for(i=0;i<35;i++){
			ans[i]=ans[i]*2+temp;//temp记录进位, 第i位的结果是，ans[i]*2 再加上进位
			if(ans[i]>9){//如果大于9代表产生了进位
				ans[i]-=10;//该为减10
				temp=1;//进位1
			}else{//否则没有产生进位
				temp=0;//进位置为0
			}	
		}
		n--;
	}
	i--;
	while(!ans[i])i--;//去掉0
	while(i>=0){//输出剩下的所有位即为结果
		cout<<ans[i];
		i--;
	}
	return 0;
}

13:大整数的因子

总时间限制: 1000ms 内存限制: 65536kB

描述
已知正整数k满足2<=k<=9，现给出长度最大为30位的十进制非负整数c，求所有能整除c的k。

输入
一个非负整数c，c的位数<=30。

输出
若存在满足 c%k == 0 的k，从小到大输出所有这样的k，相邻两个数之间用单个空格隔开；若没有这样的k，则输出"none"。

样例输入

30

样例输出

2 3 5 6

参考代码

#include
#include
using namespace std;

const int maxn=35;
char ans[maxn];
int main(){
	cin>>ans;
	int len=strlen(ans);//获取位数
	bool flag=false;
	for(int i=2;i<10;i++){
		int temp=0;//记录每一位的余数
		for(int j=0;j<len;j++){
			temp=(temp*10+int(ans[j]-48))%i;//（上一位的余数乘10+这一位的数）%i   比如31除以2，首先3除以2余数是1,(1*10+1)%2=1，余数不是0代表不能被整除。
		}
		if(temp==0){//判断最终的余数，如果是0，代表能被整除，输出这个数字。
			cout<<i<<' ';	
			flag=true;
		}
	}
	if(!flag)cout<<"none";
	return 0;
}

14:求10000以内n的阶乘

总时间限制: 1000ms 内存限制: 65536kB

描述
求10000以内n的阶乘。

输入
只有一行输入，整数n（0<=n<=10000）。

输出
一行，即n!的值。

样例输入

100

样例输出

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

参考代码

#include 
#include 
using namespace std;
int main()
{
	int a[100000]={1};//a[0]=1
	int n, l=1, t=0;
	cin>>n;
	for(int i=2;i<=n;i++){//从2乘到n
		for(int j=0;j<l;j++){
			a[j]=a[j]*i+t;//每一位乘以数字i，再加上进位
			if(a[j]>9){//如果结果大于9，代表存在进位
				t=a[j]/10;//计算进位值
				a[j]%=10;//保留个位
			}else{
				t=0;//不存在进位，将进位设为0
			}
		}
		while(t){//每乘一次数字，将进位计算完，变为数组的每一位
			a[l]=t%10;//新的一位
			t/=10;//将进位的个位去除
			l++;//将数字长度增加
		}	
	}
	for(int i=l-1;i>=0;i--){//根据数字长度，倒叙输出所有数字
		cout << a[i];		
	}
	return 0;
}

15:阶乘和

总时间限制: 1000ms 内存限制: 65536kB

描述
用高精度计算出S=1!+2!+3!+…+n!（n≤50）其中“!”表示阶乘，例如：5!=54321。输入正整数N，输出计算结果S。

输入
一个正整数N。

输出
计算结果S。

样例输入

5

样例输出

153

参考代码

#include 
using namespace std;
int main()
{
	// 将每个数的阶乘保存到一个数组中，将和保存到一个数组中
	int a[100000]={1}, s[100000]={1};
	int n, al=1, sl=1, t=0;
	cin>>n; 
	for(int i=2;i<=n;i++){
		for(int j=0;j<al;j++){//计算阶乘
			a[j]=a[j]*i+t;//t为进位
			if(a[j]>9){//存在进位
				t=a[j]/10;
				a[j]%=10;
				if(j+1>al)al=j+1;	//计算阶乘数组的长度	
			}else{//不存在进位
				t=0;
			}		
		}
		while(t){//计算结束，计算进位
			a[al]=t%10;
			t/=10;
			al++;
		}
		for(int k=0;k<al||k<sl;k++){//计算和
			s[k]+=a[k];
			if(s[k]>9){//存在进位
				s[k+1]++;//后一位+1
				s[k]%=10;//本位保留个位数
			}
			if(k+1>sl)sl=k+1;//计算和数组的长度
		}
	}
	for(int i=sl-1;i>=0;i--){
		cout<<s[i];
	}
	return 0;
}