C++数据结构

最新推荐文章于 2024-06-14 14:44:45 发布

念去去~

最新推荐文章于 2024-06-14 14:44:45 发布

阅读量8.5k

点赞数 26

分类专栏： C++程序设计题

C++程序设计题专栏收录该内容

7 篇文章 57 订阅

订阅专栏

销售波动统计

任务描述

本关任务：假定有一组数据记录着卖场每天（不超过30天）的销售额（假设都是整数），要求你统计并输出销售的波动情况，即计算每天相对于前一天的销售额的增减情况（即后项减前项的差值）。

例如连续5天的销售额分别是：23 56 12 76 43，则销售波动情况的输出为：33 -44 64 -33。

其中：33 = 56 - 23，-44 = 12 - 56，以此类推。

编程要求

在右侧编辑器中的Begin-End之间补充代码，程序给出计算几天的销售额分并给出这些天的额分（数据由平台提供，已获取，直接使用即可），统计并输出销售的波动情况，即计算每天相对于前一天的销售额的增减情况（即后项减前项的差值）。

温馨提示：这里要求输出的每个数字之间用一个空格隔开，最后一个数字后面没有空格。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：8 34 56 234 87 43 98 109 234（第一个数据表示有 8 天的销售额分，剩下的数据为具体额分）
预期输出：22 178 -147 -44 55 11 125

测试输入：4 0 89 190 289
预期输出：89 101 99

#include <stdio.h>
#include <iostream>
using namespace std;

int main()
{
    int n, a[30], i;     // 定义变量及数组，n-销售额个数，a-销售额
    cin >> n;     // 输入销售额数量，n <= 30
    // 输入n个销售额，分别存入a[0]到a[n-1]
    for(i = 0; i < n; i++)
        cin >> a[i];
    // 请在此添加代码，计算并输出销售额的波动情况
    /********** Begin *********/
	for(int j= 0;j<n-1;j++)
        cout <<  a[j+1]-a[j]<<" ";
    cout << endl;
    
    /********** End **********/
    return 0;
}

最大销售增幅

任务描述

本关任务：编写函数 maxIncrease，用于计算一个销售额序列中的最大销售增幅并返回。这里的销售额都是非负整数。

对于给定的销售额序列 A，假设序列 A 的长度为 n（ n >= 2 ），最大销售额增幅是指满足0 <= x <= y < n的A[y] - A[x]的最大值。

例如，销售额序列11,3,5,7,9,2,4,6,8,10的最大增幅为8（在 x=5 ， y=9 时）。

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算一个销售额序列中的最大销售增幅并返回。具体要求如下：

1.如对于销售额序列 A ，假设序列 A 的长度为 n（ n >= 2 ），最大销售额增幅是指满足 0<=x<=y<n 的A[y] - A[x]的最大值；

2.函数 maxIncrease 需要将数组作为参数传入，在该数组中计算最大销售额增幅并返回。

测试说明
平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：6 12 34 78 45 10 23（第一个数据表示有6天的销售额分，剩下的数据为具体额分）
预期输出：最大销售增幅为：66

测试输入：9 90 2 80 3 70 6 50 7 40
预期输出：最大销售增幅为：78

#include <iostream>
using namespace std;

// 函数maxIncrease：计算销售额增幅
// 参数：s-销售额数组，n-销售额数组长度，n>1
// 返回值：销售额最大增幅
int maxIncrease(int s[], int n);

int main()
{
    int n, a[30], i;     // 定义变量及数组，n-销售额个数，a-销售额数组
    cin >> n;      // 输入销售额数量，n>1
    // 输入n个销售额，分别存入a[0]到a[n-1]
    for(i = 0; i < n; i++)
        cin >> a[i];
    i = maxIncrease(a,n);
    cout << "最大销售增幅为：" << i << endl;
    return 0;
}

int maxIncrease(int s[], int n)
{
    //请在此添加代码，实现函数maxIncrease
    /********** Begin *********/
    int num =0;
    for(int i = 0;i<n;i++)
    {
        int j =i+1;
        for(j;j<n;j++)
        {
            num = (num>(s[j]-s[i]))? num:(s[j]-s[i]);
        }
    }
    return num;
    
    /********** End **********/
}

猴子选大王

任务描述

本关任务：编写一个函数 king，实现猴子选大王的功能。

新猴王的选择方法是：让 N 只候选猴子围成一圈（最多100只猴子），从某位置起顺序编号为 1 ~ N 号。从第1号开始报数，每轮从1报到3，凡报到3的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数。如此不断循环，最后剩下的一只猴子就选为猴王。

编程要求

在右侧编辑器中的Begin-End之间补充代码，输出 N（数据由平台提供，已获取，直接使用即可）只猴子中谁是猴子大王的。具体要求如下：

让 N 只候选猴子围成一圈（最多100只猴子），从某位置起顺序编号为 1 ~ N 号；

从第 1 号开始报数，每轮从 1 报到 3 ，凡报到 3 的猴子即退出圈子，接着又从紧邻的下一只猴子开始同样的报数；

如此不断循环，最后剩下的一只猴子就选为猴王。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：5
预期输出：4号猴子是大王。

测试输入：18
预期输出：14号猴子是大王。

#include <iostream>
using namespace std;

// 函数king：猴子选大王
// 参数：a-猴子数组n-1个猴子分别占据下标为~n-1的位置，n-数组长度
// 返回值：新猴王的下标序号
int king(int a[], int n);

int main()
{
    int n, a[1000], i;     // 定义变量及数组，n-猴子数量，a-猴子数组
    cin >> n;     // 输入猴子数量，n>0

    // 初始化猴子数组,n 个猴子分别占据 n 个位置
    a[0] = 0; // 0号位置没有猴子
    for(i = 1;i <= n; i++)
        a[i] = i;

    // 选大王啦
    i = king(a, n );
    cout << i << "号猴子是大王。" << endl;
    return 0;
}

int king(int a[], int n)
{
    // 请在此添加代码，实现函数king
    /********** Begin *********/
    int i,j,k,h,nx=1;  
    for(j=1;j<n;j++)
    {
    	
    	for(k=1;k<4;k++)
        {
    	
            for(;a[nx]==0;nx++)
    	    {
    		    if(nx==n&&a[nx]==0)
		        {
    	            nx=0;
    	        }
		    }
    	if(k==3)
    	{
    		a[nx]=0;
    		
		}		
    	nx++;
    	
    	if(nx == n+1)
    		nx=1;	
    	}
	}
for(h=1;h<n;h++)
{

	if(a[h]>0)
	    i=a[h];	
	}
return i;
}

犯二的程度

任务描述

本关任务：编写函数 silly，计算整数（不多于100位）犯二的程度并返回。

数字也可以“犯二”，一个整数“犯二的程度”定义为：该数字中包含2的个数与其位数的比值，如果这个整数是负数，则程度增加0.5倍，如果还是个偶数，则再增加1倍。

例如，数字−56782223456是个11位数，其中有3个2，是负数，也是偶数，则它的犯二程度为：3/11×1.5×2，约为0.818182。

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算整数（不多于100位，数据由平台提供）犯二的程度并返回。具体“犯二的程度”定义如下：

该数字中包含 2 的个数与其位数的比值；

如果整数是负数，则程度增加 0.5 倍；

如果整数是偶数，则再增加 1 倍。

提示：对于本关要求计算不超过100位的整数，很显然不能使用 int 类型，但可以把输入的一串数字当做字符串处理，使用字符数组来接收输入的整数。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：-13142223336
预期输出：0.818182

测试输入：122335468912334612
预期输出：0.444444

#include <iostream>
using namespace std;

// 函数silly：计算数值有多二
// 参数：a-存储数值的字符数组，以'\0'结束，所以不需要另一个参数告诉函数数组有多长
// 返回值：数值犯二的程度
double silly(char a[]);

int main()
{
    char s[102];     // 定义存储数值的数组
    cin >> s;     // 输入不超过位的整数
    double sy = silly(s);     // 计算犯二的程度
    cout << sy << endl;     // 输出犯二的程度
    return 0;
}

double silly(char *a)
{
    // 请在此添加代码，实现函数silly
    /********** Begin *********/
    int i,len,count_2=0,judge_np,judge_even;
	double result;

	i=0;
	while(a[i]!='\0')i++;
	len = i;

    for(i=0;i<len;i++){
		if(a[i]=='2'){
			count_2++;
		}
	}

    if(a[0]=='-'){
		judge_np=1;
	}else{
		judge_np=0;
	}

	if(a[len-1]%2==0){
		judge_even=1;
	}else{
		judge_even=0;
	}

	if(judge_np)
        len--;
	result = 1.0*count_2/len;
	if(judge_np)
        result*=1.5;
	if(judge_even)
        result*=2;
	return result;
    /********** End **********/
}

队列变换

任务描述

本关任务：编写函数 rotateLeft，该函数实现对一个n×n方阵中的每个元素循环向左移m个位置（0<m<n），即将第0、1、…… 、n−1列变换为第n−m、n−m+1、…… 、n−1、0、1、…… 、n−m−1列。

编程要求

在右侧编辑器中的Begin-End之间补充代码，实现队列变换的功能。具体要求如下：

队列为 n×n；

每个元素循环向左移m个位置（0<m<n），即将第0、1、…… 、n−1列变换为第n−m、n−m+1、…… 、n−1、0、1、…… 、n−m−1列。

提示：存储n×n的方阵需要使用二维数组。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：

3 1
1 2 3
4 5 6
7 8 9
预期输出：

2 3 1
5 6 4
8 9 7
测试输入：

4 2
1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7
预期输出：

3 4 1 2
4 5 2 3
5 6 3 4
6 7 4 5

#include <iostream>
using namespace std;

// 函数rotateLeft：矩阵循环左移
// 参数：a-100*100的二维数组，用来存储n行n列的数组（n<100)，存储在其~n-1行和~n-1列，
// m-循环左移的位数(0<m<n)
// 返回值：无，循环左移的结果写入原二维数组中
// 说明：传递多维数组时，形式参数中，除了第一维外，其它维的大小必须给出
// 方便编译器计算每个数组元素的地址
void rotateLeft(int a[][100],int n,int m);

int main()
{
    int a[100][100];     // 定义存储二维数组的空间
    int n, m;
    cin >> n >> m;     // 输入n和m

    // 输入n*n的矩阵，存储在数组a的~n-1行和~n-1列
    int i, j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            cin >> a[i][j];

    // 循环左移
    // 说明：传递多维数组时，实在参数只需要给出数组名就可以了
    rotateLeft(a,n,m);

    // 输出循环右移的结果
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            cout << " " << a[i][j];
        cout << endl;
    }
    return 0;
}

void rotateLeft(int a[][100],int n,int m)
{
    // 请在此添加代码，实现函数rotateLeft
    /********** Begin *********/
    int i,j,k,t;
    for(k=0;k<m;k++)
	{
    	for(i=0;i<n;i++)
	    {
			t=a[i][0];
	        for(j=0;j<n;j++)
	        {
	            a[i][j]=a[i][j+1];
	        }
	        a[i][j-1]=t;
	    }
	}

    
    
    /********** End **********/
}

朋友圈点赞

任务描述

朋友圈有一个点赞功能，你可以为你喜欢的文章点赞表示支持。每篇文章都可以根据其内容给出一些标签，这些标签用数字表示（如：1 代表心灵鸡汤、2 代表政治、3 代表经济、…），你点赞的文章的类型，也间接反应了你的喜好。

本关任务：编写一个完整的程序，通过统计一个人点赞的纪录，分析这个人的喜好。

编程要求

程序的输入格式为：

4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123
输出结果为：233 3

上述示例中出现最多次（3次）的标签有233和2，存在并列时，输出最大的那个标签233，然后输出其出现的次数3。

测试说明
平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：

4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123
预期输出：233 3

#include<iostream>
using namespace std;
int a[1001]={0};
int main()
{
 int n,m,x,mnum=0,num;//mnum用来计数记录最大值 
 //读取数据 
 cin>>n;
 while(n--)
 {
  cin>>m;
  for(int i=0;i<m;i++)
  {
   cin>>x;
   a[x]++;
  }
 }
 for(int i=0;i<=1000;i++)
 {
  if(a[i]>=mnum)
  {
   mnum=a[i]; 
   num=i;
  }
  } 
 cout<<num<<" "<<mnum;
 return 0;
}

去掉字符串首尾空格

任务描述

本关任务：文本匹配的时候经常会因为空格个数的不同而匹配失败，现在要求你编写程序对输入的字符串进行处理，去掉首尾的空格。

例如：输入的字符串是“__abcd ”，去掉首尾空格后字符串变为“abcd”。

编程要求

在右侧编辑器中的Begin-End之间补充代码，以实现去掉字符串（字符串由平台提供，且已在主函数中获取）首尾空格的功能。具体要求如下：

对于输入的字符串，去掉该字符串首尾的空格后输出；

字符串的存储使用一维字符数组，但本关要求使用指针操作。写完程序后，你也会发现使用指针实现会容易得多。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

为了方便显示空格，下面给出的测试输入使用下划线 ‘_’ 表示空格。

测试输入：_____asd
预期输出：asd

测试输入：_a_b_c_d
预期输出：a_b_c_d

#include <iostream>
using namespace std;


char * trim(char * str);

int main()
{
    char s[1024];     // 定义存储字符串的一维字符数组
    // 输入一行字符，可以包含空格
    // 输入的字符串存入s中，最多读取个字符，后面自动加上'\0'
    cin.getline(s,1024);
    cout << trim(s) << endl;     // 输出去掉首尾空格后的字符串
    return 0;
}

// 函数trim：去掉字符串首尾空格
// 参数：str-字符指针，指向输入的字符串
// 返回值：字符指针，指向去掉首尾空格后的字符串（首地址）
// 提示：可以直接在字符串str中操作
char * trim(char * str)
{
    // 请在此添加代码，实现函数trim
    /********** Begin *********/
    char* point = str;//
    while (*point != '\0')
    {
        point++;
    }
    point--;
    while (point >= str && *point == ' ')
    {
        *point = '\0';
        point--;
    }
    point = str;
    while (*point == ' ')
    {
        point++;
    }
    return point;
    
    /********** End **********/
}

用指针实现pswap函数

任务描述

本关任务：使用指针实现两个整数值的交换。

选出串中的数字

任务描述

本关任务：在一串隐藏着一个或多个数值的字符中，选出字符串中的所有数字字符，并将选出的数字字符重新组成新字符串。如果在第一个数字字符之前有负号，则保留该负号，有多个负号时只保留一个。

例如：输入的字符串为“a-1-2-4sd5 s6”，抽取数字后得到的新字符串为“-12456”。

提示

如果有字符指针 p 和 q，则下面的程序可以实现：当 q 指向的字符是数字时，将 q 指向的数字拷贝到 p 指向的存储单元：

if(*q >= ‘0’ && *q <= ‘9’)
{
*p = *q;
}

#include <iostream>
using namespace std;

void extractNum(char * str);

int main()
{
    char s[1024];
    cin.getline(s,1024);     // 输入一行字符
    extractNum(s);     // 调用extractNum函数，选出数字
    cout<<s<<endl;     // 输出选出的数字
    return 0;
}

// 函数extractNum：选出str指向的字符串中的数字，并写回str
// 参数：str-指向字符串
void extractNum(char * str)
{
    // 请在此添加代码，实现函数extractNum
    /********** Begin *********/
    char *p=str,*q=str;//s的首地址
 	int f=1;
 	while(*q!='\0')
 	{
  		if(*q=='-'&&f)
  		{
   			*p++=*q++;
   			f=0;
  		}
  		else if(*q>='0'&&*q<='9')
  		{
   			f=0;
   			*p++=*q++;
  		}
  		else
  		{
   			q++;
  		}
 	}
 	*p='\0';
    /********** End **********/
}

大写字母好看

任务描述

本关任务：将一个字符串中的所有小写字母变成对应的大写字母，其它字母不变。

例如：对字符串“abc12! ef”执行函数后输出结果为“ABC12! EF”。

提示

在 ASCII 码表中，大写字母‘A’到‘Z’是连续编码的，小写字母‘a’到‘z’也是连续编码的。也就是说‘A’和‘a’的 ASCII 码的差与‘Z’和‘z’的 ASCII 码的差是一样的。

所以如果字符变量 ch 中存放的是小写字母，则下面的语句可以将其变成对应的大写字母：

ch = ch + ‘A’-‘a’;

#include <iostream>
using namespace std;

void toUp(char * str);

int main()
{
    char s[1024];
    cin.getline(s,1024);     // 输入一行字符
    toUp(s);     // 调用toUp函数，转换成大写字母
    cout<<s<<endl;     // 输出变更后的新字符串
    return 0;
}

// 函数toUp：将str指向的字符串中的小写字母变成对应的大写字母
// 参数：str-指向字符串
void toUp(char * str)
{
    // 请在此添加代码，实现函数toUp
    /********** Begin *********/
    char *q = str,*p = str;
    while(*q!='\n')
    {
        if(*q<='z'&&*q>='a')
        {
            *p = *p +'A'-'a';
            p++;
            q++;
        }
        else
        {p++;
        q++;}
    }
    
    
    /********** End **********/
}

子串出现的次数

任务描述

本关任务：计算一个字符串（子串）在另一个字符串（长串）中出现的次数。

函数原型	函数功能
char * strcpy(char dest,const char src)	将字符串 src 复制到 dest
char * strcat(char dest,const char src)	将字符串 src 添加到 dest 末尾
char * strchr(const char *s,int c)	检索并返回字符 c 在字符串 s 中第一次出现的位置
int strcmp(const char s1,const char s2)	比较字符串 s1 与 s2 的大小，若 s1 串大于 s2 串则返回一个大于 0 的值；若 s1 串等于 s2 串则返回值为 0；若 s1 串小于 s2 串则返回一个小于 0 的值。
size_t strlen(const char *s)	返回字符串 s 的长度
char * strncat(char dest,const char src,size_t n)	将字符串 src 中最多 n 个字符复制到字符串 dest 中
int strncmp(const char s1,const char s2,size_t n)	比较字符串 s1 与 s2 中前 n 个字符
char * strncpy(char dest,const char src,zise_t n)	复制 src 中的前 n 个字符到 dest 中
char * strstr(const char s1,const char s2)	扫描字符串 s1，并返回第一次出现 s2 的位置
char * strtok(char s1,const char s2)	检索字符串 s1，该字符串 s1 是由字符串 s2 中定义的定界符所分隔

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算一个字符串（子串）在另一个字符串（长串）中出现的次数。

提示

一个子串在另一个长串中出现的次数是指长串中可以同时截取出多少个子串。例如：子串 “aaa” 在 “aaaaaaa” 中出现的次数为 2 次。

// 包含字符串函数库
#include <string.h>
#include <iostream>
using namespace std;

int frequency(char * substr, char * str);

int main()
{
    char sub[128],str[1024];
    cin.getline(sub,128);     // 输入子串
    cin.getline(str,1024);     // 输入长串
    int n = frequency(sub,str);     // 调用frequency函数，计算子串在长串中出现的次数
    cout<<n<<endl;     // 输出次数
    return 0;
}

// 函数frequency：计算子串在长串中出现的次数
// 参数：substr-指向子串，str-指向长串
// 返回值：出现的次数
int frequency(char * substr, char * str)
{
    // 请在此添加代码，实现函数frequency
    /********** Begin *********/
    int num =0;
    char* p =str;
    
    
    while(strstr(p, substr)!= NULL)
    {
        num++;
        p =strstr(p, substr);
        p = p+ strlen(substr);
    }
    return num;

    
    /********** End **********/
}

字符串的部分复制

任务描述

本关任务：实现字符串的部分复制。

提示

函数 strmncpy 的原型为：

void strmncpy(char *s, int m, int n, char *t);

参数 s 指向源字符串，t 指向字符串复制的目标单元，函数功能为将 s 指向字符串从第 m 个（从0开始编号）字符开始的连续 n 个字符复制到 t 指向的存储单元；

如果第 m 个字符后面的字符数不足 n 个，则复制到 ‘\0’为止；

如果 s 的长度不到 m，则复制空串。

例如：

char *s = "abcdefghijklmn";
char t[20];
strmncpy(s,4,6,t);
cout << t << endl;

输出结果为：efghij

#include <iostream>
#include <string.h>
using namespace std;

void strmncpy(char *s, int m, int n, char *t);

int main()
{
    char s[128],t[128];
    int m,n;
    cin>>s;     // 输入源串
    cin>>m>>n;     // 输入m和n
    strmncpy(s, m, n, t);     // 字符串复制
    cout << t <<endl;     // 输出复制结果
    return 0;
}

// 函数strmncpy：字符串的部分复制，将s指向字符串从第m个字符开始的n个字符复制的t中
// 参数：s-指向源字符串，t-指向目标字符串，m-起始位置，n-字符个数
// 返回值：无
void strmncpy(char *s, int m, int n, char *t)
{
    // 请在此添加代码，实现函数strmncpy
    /********** Begin *********/
    char* p = s;//这个用来跑
    char* q = t;//这个用来存
    int a = 0;//用于执行循环的次数
    p = p + m;//直接把地址改到目标数组的目标位置上去，最简单
    while (a < n)
    {
        *q++ = *p++;//把符合的值赋到用来存的指针这边
        a++;
    }
    *q = '\0';//结束，输出*q

    /********** End **********/
}

有理数化简

任务描述

本关任务：化简有理数。

编程要求

在右侧编辑器中的Begin-End之间补充代码，对输入的有理数（数据由平台提供，已在主函数中获取）进行化简。

#include <iostream>
using namespace std;

struct rationalNumber{
    int fenzi; // 分子
    int fenmu; // 分母
};

// 函数reduction：有理数化简，对传入的有理数n进行化简
// 参数：n-有理数
// 返回值：无化简后的有理数
rationalNumber reduction(rationalNumber n);

int main()
{
    char c;
    rationalNumber x, y;
    cin >> x.fenzi >> c >> x.fenmu;   // 输入有理数，首先读入分子，然后是/，最后是分母
    y = reduction(x);   // 有理数化简
    // 输出化简的结果
    if(y.fenmu == 1)
        cout << y.fenzi << endl;
    else
        cout << y.fenzi << "/" << y.fenmu << endl;
    return 0;
}

rationalNumber reduction(rationalNumber n)
{
    // 请在这里补充代码，实现函数reduction
    /********** Begin *********/
    rationalNumber m = n;
    int a;
    while(m.fenmu!=0)
    {
        a=m.fenzi%m.fenmu;
        m.fenzi=m.fenmu;
        m.fenmu=a;
    }
    m.fenzi = (m.fenzi>0)? m.fenzi : -m.fenzi;
    n.fenzi = n.fenzi/m.fenzi;
    n.fenmu = n.fenmu/m.fenzi;

    return n;

    
    
    /********** End **********/
}

有理数加法

任务描述

本关任务：实现两个有理数的相加并返回结果且返回的结果必须是最简分数。

有理数平均数

任务描述

本关任务：计算n（n<100）个有理数的平均数并返回，要求输出结果为最简分数形式。

编程要求

在右侧编辑器中的Begin-End之间补充代码，计算n（n<100）个有理数（数据由平台提供，已在主函数中获取）的平均数并返回，结果为最简分数形式；

#include <iostream>
using namespace std;

struct rationalNumber{
    int fenzi; // 分子
    int fenmu; // 分母
};

// 函数rnMean：计算n个有理数的平均数
// 参数：a-存放有理数的数组,n-有理数的个数
// 返回值：n个有理数的平均数
rationalNumber rnMean(rationalNumber a[], int n);

int main()
{
    char c;
    rationalNumber a[100],z;
    int n, i;
    cin >> n;     // 输入有理数个数
    // 输入n个有理数
    for(i = 0; i < n; i++)
        cin >> a[i].fenzi >> c >> a[i].fenmu;
    z = rnMean(a,n);     // 计算有理数平均数
    // 输出平均数
    if(z.fenmu == 1)
        cout << z.fenzi << endl;
    else
        cout << z.fenzi << "/" << z.fenmu << endl;
    return 0;
}

// 请在此添加代码，实现函数rnMean
/********** Begin *********/
struct rationalNumber reduction(struct rationalNumber n)
{
int temp;
    int k,j;
    int max,min;
if(((n.fenzi)<0)&&((n.fenmu)>0))   // 分了几类,当然也能abs()是对整数取绝对值,而fabs()是对浮点数取.
{
    j = -n.fenzi;
    k = n.fenmu;
}
else if(((n.fenmu)<0) &&((n.fenzi)>0))
{
    j = n.fenzi;
    k = -n.fenmu;
}
else
{
    j = n.fenzi;
    k = n.fenmu;
}
if(k<j)
{
    temp = k;
    k = j;
    j = temp;
}
while(j!=0)				//辗转相除法？
{
    temp = k % j;
    k = j;
    j = temp;
}
n.fenzi = (n.fenzi) / k;
n.fenmu = (n.fenmu) / k;
return n;	//返回化简后的有理式(返回的与函数的类型一致)
}

struct rationalNumber rnAdd(struct rationalNumber x, struct rationalNumber y)
{
    struct rationalNumber k;
        k.fenzi = (x.fenzi) * (y.fenmu) + (x.fenmu) *(y.fenzi);  //这两行是分数加法同用的情况
        k.fenmu = (x.fenmu) * (y.fenmu);
        k = reduction(k);
    return k;
}

struct rationalNumber rnMean(struct rationalNumber a[], int n)
{
    int i;
    struct rationalNumber k;
    for(i=0;i<n-1;i++)
    {   
        a[i+1] = rnAdd(a[i],a[i+1]); //进行一个数据的叠加，此时已经化简好了。
    }
    a[i].fenmu = (a[i].fenmu) * n;

    return a[i];
}

/********** End **********/

书籍排序

任务描述

本关任务：编写一个完整的程序，对输入的n（n<100）本书进行排序并输出。

编程要求

在右侧编辑器中的Begin-End之间补充代码，编写一个完整的程序，对输入的n（n<100）本书进行排序并输出，具体要求如下：

程序输入
程序首先输入一个正整数n，然后输入n本书的信息，每本书用两行输入，第一行输入书的名称（书名最长不超过50个字符，中间可能有空格），第二行输入价格，价格为浮点数。

例如：

3
Programming in C
21.5
数据结构与算法
18.5
三体（一）
28.0

程序输出
程序要求对n本书按价格从低到高排序，如果价格相同，则按书名（字符串）字典序从小到大排序。最后输出排序结果，每行输出一本书的信息，首先输出价格，然后输出书名，中间用一个英文逗号和一个空格分开。

如上面输入对应的输出结果为：

18.5, 数据结构与算法
21.5, Programming in C
28, 三体（一）

#include <string.h>
#include <iostream>

using namespace std;

//请在此添加代码，实现书籍数据的输入、排序和输出
/********** Begin *********/
struct book{
	char name[55];
	float price;
}b[105];

int main()
{

	int n ;
    cin>>n;
	
	for(int i=0;i<n;i++)
	{
		getchar(); 
		cin.getline(b[i].name,55);
		cin>>b[i].price;		
	
	}
	// 排序
    for(int i=0;i<n-1;i++){
    	int k=i; //标记最小位置
		for(int j=i+1;j<n;j++){
			if(b[k].price > b[j].price)
			 k = j;
			else if(b[k].price == b[j].price && strcmp(b[k].name, b[j].name) > 0 ) //如果后面的串更小 
			 k = j; 
		}   
		if(k!=i){ //需要交换 
			book t = b[k];
			b[k] = b[i];
			b[i] = t;
			
		}
	} 

	for(int i=0; i<n; i++){
		cout << b[i].price << ", " << b[i].name << "\n";
	}
	return 0;
}

/********** End **********/

念去去~

关注

26
点赞
踩
97

收藏

觉得还不错? 一键收藏
1
评论
C++数据结构

任务描述本关任务：程序输入苹果数 m 和人数 n，要求输出每个人平均可以分到多少个苹果，并将计算结果存入到变量 x 中。相关知识C 和 C++ 的程序中，每个数据对象都必须有确定的数据类型。这是为什么呢？我们知道，计算机内存中的数据都是0、1串，例如下面这16位0、1组成的串。01000001 01000010那么这个0、1串到底代表什么意思呢？同样的这一段0、1串，如果是8位整数，则是两个整数65和66；如果是字符，则是‘A’和‘B’；如果是16位整数，则是16706。同一串数据，赋予不同
复制链接

扫一扫