【iHooya】2023年2月2日寒假作业解析

#include 
using namespace std;

int main()
{

	int n, r; //n个人，r个水龙头
	cin >> n >> r;
	int time[n];
	for (int a = 0; a < n; a++)
	{
		cin >> time[a];
	}
	sort(time, time + n); //时间从小到大排序
	int minx = 0, lt_time[10001], j = 0; //存水龙头的时间，表示哪个水龙头
	for (int a = 0; a < n; a++)
	{
		j++;
		if (j == r + 1)
			j = 1; //水龙头是交替更换的
		lt_time[j] += time[a];
		minx += lt_time[j];
	}
	cout << minx;

	return 0;
}

偶数降序输出
给定一个长度为N(不大于500)的正整数序列，请将其中的所有偶数取出，并按降序输出。

输入
共2行:第1行为N;第2行为N个正整数，其间用空格间隔。

输出
降序输出的偶数序列，数之间以空格间隔。数据保证至少有一个偶数。

样例输入
10
l 3 2 6 5 4 9 8 7 10

样例输出
10 8 6 4 2

#include 
using namespace std;

//对数组进行升序排序后，倒序输出把偶数输出出来
int main()
{
	int n;
	cin >> n;
	int arr[n];
	for (int a = 0; a < n; a++)
		cin >> arr[a];
	sort(arr, arr + n); //对数组进行升序排列
	for (int b = n-1; b >= 0; b--)
	{
		if (arr[b] % 2 == 0) //数组元素如果是偶数
			cout << arr[b] << " ";
	}

	return 0;
}

#include 
using namespace std;

//给数组输入的时候判断是否为偶数，如果是偶数就添加到动态数组里
int main()
{
	int n;
	cin >> n;
	int arr[n];
	vector<int> v;
	for (int a = 0; a < n; a++)
	{
		cin >> arr[a];
		if (arr[a] % 2 == 0)
			v.push_back(arr[a]);
	}

	sort(v.begin(), v.end()); //对动态数组进行升序排列
	for (int a = v.size() - 1; a >= 0; a--)//倒序输出
		cout << v[a] << " ";

	return 0;
}

---

图像处理
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：

1. 四周最外侧的像素点灰度值不变；
2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均（舍入到最接近的整数）。

输入
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1 <= n <= 100，1 <= m <= 100。 接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，每个元素均在0~255之间。

输出
n行，每行m个整数，为模糊处理后的图像。相邻两个整数之间用单个空格隔开。

样例输入
4 5
100 0 100 0 50
50 100 200 0 0
50 50 100 100 200
100 100 50 50 100

样例输出
100 0 100 0 50
50 80 100 60 0
50 80 100 90 200
100 100 50 50 100

#include 
using namespace std;

int main()
{
	int n, m;
	cin >> n >> m;
	int arr[n][m];
	for (int a = 0; a < n; a++)
		for (int b = 0; b < m; b++)
			cin >> arr[a][b];
	int sum = 0;
	for (int a = 0; a < n; a++)
	{
		for (int b = 0; b < m ; b++)
		{
			if (a == 0 || a == n - 1 || b == 0 || b == m - 1)//最外圈元素正常输出
			{
				cout << arr[a][b] << " ";
			}
			else if (a > 0 && a < n - 1 || b > 0 && b < m - 1)//按照自己及四个方向求平均值
			{
				sum = arr[a][b] + arr[a - 1][b] + arr[a + 1][b] + arr[a][b - 1] + arr[a][b + 1];
				cout << sum / 5 << " ";
			}
		}
		cout << endl;
	}

	return 0;
}

字符统计
给定一个由a-z这26个字符组成的字符串，统计其中哪个字符出现的次数最多。

输入
输入包含一行，一个字符串，长度不超过1000。

输出
输出一行，包括出现次数最多的字符和该字符出现的次数，中间以一个空格分开。如果有多个字符出现的次数相同且最多，那么输出ascii码最小的那一个字符。

样例输入
abbccc

样例输出
c 3

#include 
using namespace std;

int main()
{
	string s;
	getline(cin, s);
	sort(s.begin(), s.end()); //对字符串内的字符按照ASCII码进行排序
	int maxn = 0;
	int count = 1;
	char c;
	for (int a = 0; a < s.length(); a++)
	{
		if (s[a] == s[a + 1])
		{
			count++;
		}
		else
		{
			if (count > maxn)
			{
				maxn = count;
				c = s[a];
			}
			count = 1;
		}
	}
	cout << c <<" "<< maxn;
	return 0;
}

#include 
using namespace std;

int main()
{
	string s;
	getline(cin, s);
	int letter[26] = {0};
	int maxn = 0, max_xb = 0;
	for (int a = 0; a < s.length(); a++)
		letter[s[a] - 'a']++; //统计a~z出现的次数
	for (int a = 0; a < 26; a++)
	{
		if (letter[a] >= maxn)
		{
			maxn = letter[a];
			max_xb = a;
		}
	}
	cout << (char)(max_xb + 'a') << " " << maxn;
	return 0;
}

#include 
using namespace std;

//用动态数组做
int main()
{
	string s;
	getline(cin, s);
	sort(s.begin(), s.end());
	vector<string> vec;
	int x = 0; //连续字符的起始位置
	for (int a = 0; a < s.length(); a++)
	{
		if (s[a] != s[a + 1])
		{
			vec.push_back(s.substr(x, a - x + 1));
			x = a + 1;
		}
	}
	int maxn = 0;
	char c;
	for (int b = 0; b < vec.size(); b++)
	{
		if (vec[b].length() > maxn)
		{
			maxn = vec[b].length();
			c = vec[b].front();
		}

	}
	cout << c << " " << maxn;
	return 0;
}

波兰表达式
波兰表达式是一种把运算符前置的算术表达式，例如普通的表达式2 + 3的波兰表示法为+ 2 3。波兰表达式的优点是运算符之间不必有优先级关系，也不必用括号改变运算次序，例如(2 + 3) * 4的波兰表示法为* + 2 3 4。本题求解波兰表达式的值，其中运算符包括+ - * /四个。

输入：输入为一行，其中运算符和运算数之间都用空格分隔，运算数是浮点数。

输出：输出为一行，表达式的值。

样例输入

• • 11.0 12.0 + 24.0 35.0

样例输出
1357.000000

使用栈求解前缀表达式
从右向左扫描前缀表达式。
遇到数字时，将数字入栈。
遇到运算符时，弹出栈顶的两个数，用该运算符对它们做相应的计算，结果入栈。
扫描结束后，栈顶数字就是结果。
EOF同时摁下ctrl+z然后回车代表结束程序

#include 
using namespace std;
#define N 1005
struct Node
{
    double n;
    char c;
};
Node eq[N];
int p;
double calc(double a, double b, char c)
{
    switch(c)
    {
        case '+':
            return a+b;
        case '-':
            return a-b;
        case '*':
            return a*b;
        case '/':
            return a/b;
    }
}
double solve()
{ 
    stack<double> stk;
    for(int i = p; i >= 1; --i)
    {
        if(eq[i].c)//如果是运算符 
        {//后进先出，第1运算数先出栈，第2运算数后出栈 
            double a = stk.top(); 
            stk.pop();
            double b = stk.top(); 
            stk.pop();
            stk.push(calc(a, b, eq[i].c));
        }
        else//数字 
            stk.push(eq[i].n);//第2运算数先入栈，第1运算数后入栈。 
    }
    return stk.top();
}
int main()
{
    char s[30];
    while(scanf("%s", s) != EOF)
    {
        if(s[0] == '+' || s[0] == '*' || s[0] == '/' || s[0] == '-' && strlen(s) == 1)//运算符 排除这是个负数 
            eq[++p].c = s[0];
        else//数字 
            eq[++p].n = atof(s);
    }
    printf("%f", solve());
    return 0;
}