程序设计思维与实践 Week9 作业

最新推荐文章于 2020-05-04 01:21:53 发布
最新推荐文章于 2020-05-04 01:21:53 发布
阅读量149 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43851185/article/details/105641320
版权

A - 咕咕东的目录管理器

题意

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

解题思路

  1. 首先我们要确定如何存储目录以及子目录，因为题目要求子目录必须要保持字典序，所以我们选用map来存储一个目录的所有子目录。
  2. MKDIR：直接在当前目录的map里插入新的目录即可。
  3. RM：是MKDIR的逆操作，将要删除的目录从当前目录中擦除即可。
  4. CD：将当前目录改为新目录
  5. SZ：每一次都遍历子目录会超时，所以我们可以对每一个目录增加sz来表示该目录的子节点数，这时，就需要在MKDIR和RM时向上更新sz直到root
  6. LS：直接判断并按顺序输出map的元素即可。
  7. TREE：与SZ类似，每一次都遍历的话会超时，所以我们可以存储一下答案，并标记一下是否被更新过。若进行了MKDIR和RM，则标记置空。
  8. UNDO：我们可以用一个vector存储执行过的指令，然后执行其逆操作即可。（在RM时我们不需要删除对应目录的所有信息，只需删去关系，以便恢复）

代码

#include <map>
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
map<string, int> cases = {
	{"MKDIR", 0}, {"RM", 1}, {"CD", 2},
	{"SZ", 3}, {"LS", 4},{"TREE", 5},{"UNDO", 6}
};
struct command{	//记录
	int code;	//操作编号
	int op1;	//记录操作时的当前目录
	int op2;	//记录mkdir、rm、cd的操作数
	command(int a, int b, int c): code(a), op1(b), op2(c){}
};
vector<command> cmd;//记录mkdir、rm、cd指令方便undo
int now;//记录当前所在目录的下标
struct Directory
{
	string name;
	map<string, int> mp;
	int fa, sz;
	vector<string> pre,bck;
	bool tag;
}node[100005];
int node_i;
void update(int id, int num){
	while(id != -1){
		node[id].tag = 0;
		node[id].sz += num;
		id = node[id].fa;
	}
}
void mkdir(string &str){
	if(node[now].mp.count(str)){
		cout << "ERR\n";
		return;
	}
	cout << "OK\n";
	update(now, 1);
	node[now].mp.insert(pair<string, int>(str, node_i));
	node[node_i].name = str;
	node[node_i].fa = now;
	node[node_i].sz = 1;
	node[node_i].pre.clear();
	node[node_i].bck.clear();
	node[node_i].mp.clear();
	node[node_i].tag = 0;
	command temp(0, now, node_i++);
	cmd.push_back(temp);
}
void rm(string &str){
	if(!node[now].mp.count(str)){
		cout << "ERR\n";
		return;
	}
	cout << "OK\n";
	int temps = node[now].mp[str];
	node[now].mp.erase(str);
	update(now, -node[temps].sz);
	command temp(1, now, temps);
	cmd.push_back(temp);
}
void cd(string &str){
	if(str == ".."){
		if(now == 0)
			cout << "ERR\n";
		else{
			int tmpn = now;
			now = node[now].fa;
			cout << "OK\n";
			command temp(2, tmpn, now);
			cmd.push_back(temp);
		}
	}else{
		if(node[now].mp.count(str)){
			int tmpn = now;
			now = node[now].mp[str];
			cout << "OK\n";
			command temp(2, tmpn, now);
			cmd.push_back(temp);
		}else
			cout << "ERR\n";
	}
}
void ls(){
	int t = node[now].mp.size();
	if(t == 0)
		cout << "EMPTY\n";
	else if(t >= 1 && t <= 10)
		for(auto cur = node[now].mp.begin(); cur != node[now].mp.end(); cur++)
			cout << cur->first << endl;
	else{
		auto cur = node[now].mp.begin();
		for(int i = 0; i < 5; i++){
			cout << cur->first << endl;
			cur++;
		}
		cout << "...\n";
		cur = node[now].mp.end();
		for(int i = 0; i < 5; i++) cur--;
		for(int i = 0; i < 5; i++){
			cout << cur->first << endl;
			cur++;
		}
	}
}
void undo(){
	if(!cmd.size()){
		cout << "ERR\n";
		return;
	}
	cout << "OK\n";
	command c = cmd[cmd.size()-1];
	cmd.pop_back();
	switch(c.code){
	case 0:
		update(c.op1, -node[c.op2].sz);
		node[c.op1].mp.erase(node[c.op2].name);
		break;
	case 1:
		update(c.op1, node[c.op2].sz);
		node[c.op1].mp[node[c.op2].name] = c.op2;
	case 2:
		now = c.op1;
	}
}
void pretrack(int id, int& t){
	node[now].pre.push_back(node[id].name);
	if(t-- == 0) return;
	for(auto cur = node[id].mp.begin(); cur != node[id].mp.end(); cur++){
		pretrack(cur->second, t);
		if(t == 0) break;
	}
}
void pretrack(){
	int t;
	if(node[now].sz > 10) t = 5;
	else t = node[now].sz;
	pretrack(now, t);
}
void bcktrack(int id, int& t){
	auto cur = node[id].mp.end();
	int SIZE = node[id].mp.size();
	for(int i = 0; i < SIZE; i++){
		cur--;
		bcktrack(cur->second, t);
		if(t == 0) return;
	}
	node[now].bck.push_back(node[id].name);
	t--;
}
void pushdown(){
	node[now].pre.clear();
	node[now].bck.clear();
	pretrack();
	if(node[now].sz > 10) {
		int t = 5;
		bcktrack(now, t);
	}
	else node[now].bck = node[now].pre;
	node[now].tag = 1;
}
void tree(){
	if(!node[now].tag) pushdown();
	if(node[now].sz == 1) cout << "EMPTY\n";
	else if(node[now].sz > 1 && node[now].sz <= 10)
		for(int i = 0; i < node[now].pre.size(); i++)
			cout << node[now].pre[i] << endl;
	else{
		for(int i = 0; i <5; i++) cout << node[now].pre[i] << endl;
		cout << "...\n";
		for(int i = 4; i >= 0; i--) cout <<node[now].bck[i] << endl;
	}
}
int main(){
	int T;
	cin >> T;
	while(T--){
		cmd.clear();
		node_i = 1;
		now = 0;
		node[0].name = "root";
		node[0].fa = -1;
		node[0].sz = 1;
		node[0].tag = 0;
		node[0].pre.clear();
		node[0].bck.clear();
		node[0].mp.clear();
		int Q;
		cin >> Q;
		while(Q--){
			string cmmd;
			cin >> cmmd;
			switch(cases[cmmd]){
			case 0:{
				string str;
				cin >> str;
				mkdir(str);
				break;
			}
			case 1:{
				string str;
				cin >> str;
				rm(str);
				break;
			}
			case 2:{
				string str;
				cin >> str;
				cd(str);
				break;
			}
			case 3:{
				cout << node[now].sz << endl;
				break;
			}
			case 4:{
				ls();
				break;
			}
			case 5:{
				tree();
				break;
			}
			case 6:{
				undo();
				break;
			}
			}
		}
		cout << "\n";
	}
	return 0;
}

B - 东东学打牌

题意

最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则：

  • 所有扑克牌只按数字来算大小，忽略花色。
  • 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分- 别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。
  • 每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌）

理所当然地，一手牌是有不同类型，并且有大小之分的。

举个栗子，现在东东的 “一手牌”（记为 α），瑞神的 “一手牌”（记为 β），要么 α > β，要么 α < β，要么 α = β。

那么这两个 “一手牌”，如何进行比较大小呢？首先对于不同类型的一手牌，其值的大小即下面的标号；对于同类型的一手牌，根据组成这手牌的 5 张牌不同，其值不同。下面依次列举了这手牌的形成规则：

  1. 大牌：这手牌不符合下面任一个形成规则。如果 α 和 β 都是大牌，那么定义它们的大小为组成这手牌的 5 张牌的大小总和。
  2. 对子：5 张牌中有 2 张牌的值相等。如果 α 和 β 都是对子，比较这个 “对子” 的大小，如果 α 和 β 的 “对子” 大小相等，那么比较剩下 3 张牌的总和。
  3. 两对：5 张牌中有两个不同的对子。如果 α 和 β 都是两对，先比较双方较大的那个对子，如果相等，再比较双方较小的那个对子，如果还相等，只能比较 5 张牌中的最后那张牌组不成对子的牌。
  4. 三个：5 张牌中有 3 张牌的值相等。如果 α 和 β 都是 “三个”，比较这个 “三个” 的大小，如果 α 和 β 的 “三个” 大小相等，那么比较剩下 2 张牌的总和。
  5. 三带二：5 张牌中有 3 张牌的值相等，另外 2 张牌值也相等。如果 α 和 β 都是 “三带二”，先比较它们的 “三个” 的大小，如果相等，再比较 “对子” 的大小。
  6. 炸弹：5 张牌中有 4 张牌的值相等。如果 α 和 β 都是 “炸弹”，比较 “炸弹” 的大小，如果相等，比较剩下那张牌的大小。
  7. 顺子：5 张牌中形成 x, x+1, x+2, x+3, x+4。如果 α 和 β 都是 “顺子”，直接比较两个顺子的最大值。
  8. 龙顺：5 张牌分别为 10、J、Q、K、A。

作为一个称职的魔法师，东东得知了全场人手里 5 张牌的情况。他现在要输出一个排行榜。排行榜按照选手们的 “一手牌” 大小进行排序，如果两个选手的牌相等，那么人名字典序小的排在前面。

不料，此时一束宇宙射线扫过，为了躲避宇宙射线，东东慌乱中清空了他脑中的 Cache。请你告诉东东，全场人的排名

解题思路

一道操作较多但都比较简单的模拟题，和这道题较为类似。
首先读入每位玩家的姓名和牌，将牌转换成int数组存储，之后计算i张相同牌的数量为cnt[i]，并将牌面存入对应的cnt1[i]中，之后就能较为方便的判断牌属于哪个牌型。

代码

#include <iostream>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
struct player{
	string name;
	int card[6];
	int cnt[6];//cnt[i]表示有几个i张牌相同
	vector<int> cnt1[6];//cnt1[i]表示i张牌相同的牌面
	int point;
	void count(){
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0; i < 6; i++)
			cnt1[i].clear();
		int last = card[0];
		int k = 1;
		for(int i = 1; i < 5; i++){
			if(card[i] == last)
				k++;
			else{
				cnt[k]++;
				cnt1[k].push_back(last);
				k = 1;
				last = card[i];
			}
		}
		cnt[k]++;
		cnt1[k].push_back(last);
	}
	void cal(){
		count();
		if(card[0] == 1 && card[1] == 10 && card[2] == 11 && card[3] == 12 && card[4] == 13)
			point = 8; 
		else if(card[1] == card[0] + 1 && card[2] == card[1] + 1 && card[3] == card[2] + 1 && card[4] == card[3] + 1)
			point = 7;
		else if(cnt[4] == 1)
			point = 6;
		else if(cnt[3] == 1 && cnt[2] == 1)
			point = 5;
		else if(cnt[3] == 1)
			point = 4;
		else if(cnt[2] == 2)
			point = 3;
		else if(cnt[2] == 1)
			point = 2;
		else 
			point = 1;
	}
}p[100005];
map<char, int>mp{{'K', 13}, {'Q', 12}, {'J', 11}, {'A', 1}, {'2', 2}, {'3', 3}, {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7}, {'8', 8}, {'9', 9}};
bool cmp(player &a, player &b){
	if(a.point != b.point)
		return a.point > b.point;
	else{
		int sum1 = 0, sum2 = 0;
		for(int i = 0; i < a.cnt1[1].size(); i++){
			sum1 += a.cnt1[1][i];
			sum2 += b.cnt1[1][i];
		}
		if(a.point == 8)
			return a.name < b.name;
		else if(a.point == 7){
			if(a.card[2] != b.card[2])
				return a.card[2] > b.card[2];
			else
				return a.name < b.name;
		}else if(a.point == 6){
			if(a.card[2] != b.card[2])
				return a.card[1] > b.card[1];
			else if(a.cnt1[1][0] != b.cnt1[1][0])
				return a.cnt1[1][0] > b.cnt1[1][0];
			else
				return a.name < b.name;
		}
		else if(a.point == 5){
			if(a.card[2] != b.card[2])
				return a.card[2] > b.card[2];
			else{
				if(a.cnt1[2][0] != b.cnt1[2][0])
					return a.cnt1[2][0] > b.cnt1[2][0];
				else
					return a.name < b.name;	
			}
		}else if(a.point == 4){
			if(a.card[2] != b.card[2])
				return a.card[2] > b.card[2];
			else{
				if(sum1 != sum2)
					return sum1 > sum2;
				else
					return a.name < b.name;
			}
		}else if(a.point == 3){
			if(a.card[3] != b.card[3])
				return a.card[3] > b.card[3];
			else if(a.card[1] != b.card[1])
				return a.card[1] > b.card[1];
			else if(a.cnt1[1][0] != b.cnt1[1][0])
				return a.cnt1[1][0] > b.cnt1[1][0];
			else 
				return a.name < b.name;
		}else if(a.point == 2){
			if(a.cnt1[2][0] != b.cnt1[2][0])
				return a.cnt1[2][0] > b.cnt1[2][0];
			else if(sum1 != sum2)
				return sum1 > sum2;
			else 
				return a.name < b.name;
		}else{
			if(sum1 != sum2)
				return sum1 > sum2;
			else 
				return a.name < b.name;
		}
	}
}
int main()
{
	int n;
	while(cin >> n){
		for(int i = 0; i < n; i++){
			string str;
			cin >> p[i].name >> str;
			int k = 0;
			for(int j = 0; j < str.length(); j++){
				if(str[j] == '1'){
					p[i].card[k++] = 10;
					j++;
				}else
					p[i].card[k++] = mp[str[j]];
			}
			sort(p[i].card, p[i].card + 5);
			p[i].cal();
		}
		sort(p, p + n, cmp);
		for(int i = 0; i < n; i++)
			cout << p[i].name << endl;
	}
    return 0;
}

C - 签到题

题意

SDUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。

解题思路

  • 因为没有规定一个凳子能坐多少人，mx的值很容易想到，y个人全部都坐到原来人数最多的凳子上即可，所以我们在读入每个凳子上人数的时候比较记录最大值，最后 m x = y + m a x ( a i ) mx = y + max(a_i) mx=y+max(ai​)
  • mn的取值分为两种情况：
    1. 当 s u m ( a i ) + y ≤ x ⋅ m a x ( a i ) sum(a_i)+y \leq x \cdot max(a_i) sum(ai​)+y≤x⋅max(ai​)时，我们可以把y个人分配到人数最多的长凳之外的长凳上，如果优先从人数少的长凳开始分配，则最后人数最多的长凳上的人数依然为 m a x ( a i ) max(a_i) max(ai​).
    2. 当 s u m ( a i ) + y > x ⋅ m a x ( a i ) sum(a_i)+y > x \cdot max(a_i) sum(ai​)+y>x⋅max(ai​)时，我们将所有人平均分配到x个长凳上，平均值即为mn(这里要注意如果 s u m ( a i ) + y sum(a_i)+y sum(ai​)+y不能被x整除，得到的结果要+1)

代码

#include <iostream>
using namespace std;
int main()
{
    int x, y;
    cin >> x >> y;
    int maxx = 0;
    int sum = 0;
    for (int i = 0; i < x; i++) {
        int temp;
        cin >> temp;
        if (temp > maxx)
            maxx = temp;
        sum += temp;
    }
    if (sum + y > maxx * x) {
        if ((sum + y) % x == 0)
            cout << (sum + y) / x;
        else
            cout << (sum + y) / x + 1;
    } else
        cout << maxx;
    cout << ' ';
    cout << maxx + y;
    return 0;
}
Noda233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
程序设计思维与实践 Week9 作业 B 东东学打牌
01-06
A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得 5 张扑克牌，组成一手牌！（每种扑克牌的张数是无限的，你不用担心，东东家里有无数副扑克牌） ...
程序设计思维与实践 Week9 B东东打牌
banzixiang的博客
04-20 142
题意： input： output： 对于每组测试数据，输出 n 行，即这次全场人的排名。 样例： 思路: 很明显是根据不同的牌的组合来得到一个分数，然后根据这个分数来进行一个关键字排序。在此处将关键字排序分为了三个：第一个关键字是手牌的8个类型，即按照给的手牌的分数，来依次给其score1赋上1到8分。第二个关键字是当手牌类型相同的时候，后续牌的大小不同来依次赋上score2相应的分数...
【20200415程序设计思维与实践 Week9 作业】
Camlost的博客
05-04 190
目录签到题题意思路代码A - 咕咕东的目录管理器题意思路代码B - 东东学打牌题意思路代码 签到题 题意 SDUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。 思路 显然，y个人全部坐到当前人数最...
Week9—A—咕咕东的目录管理器
XiaoAnn的博客
04-22 237
题目描述： Input： 输入文件包含多组测试数据，第一行输入一个整数表示测试数据的组数 T （T <= 20）； 每组测试数据的第一行输入一个整数表示该组测试数据的命令总数 Q （Q <= 1e5）； 每组测试数据的 2 ~ Q+1 行为具体的操作 （MKDIR、RM 操作总数不超过 5000）； 面对数据范围你要思考的是他们代表的 “命令” 执行的最大可接受复杂度，...
SDU 程序设计思维与实践 week5 最大矩形【单调栈】
01-08
【SDU程序设计思维与实践】week5的最大矩形问题主要涉及了算法设计中的单调栈这一数据结构。问题的目标是求解给定直方图中最大的矩形面积，直方图由一系列高度不等的小矩形构成，每个小矩形宽度为1。单调栈在这里的...
山东大学MATLAB应用教程 第4讲 MATLAB程序设计（共60页）.ppt
11-02
山东大学MATLAB应用教程 第1讲 MATLAB程序设计基础（共26页）.ppt 山东大学MATLAB应用教程 第2讲 MATLAB的数值计算（共65页）.ppt 山东大学MATLAB应用教程 第3讲 MATLAB的图形功能（共62页）.ppt 山东大学MATLAB应用...
厦大-unix程序设计课实验作业.zip
最新发布
06-02
【厦大-unix程序设计课实验作业】是一个与Unix系统编程相关的课程实验作业集合，包含了多个星期的作业内容。在Unix环境下，程序设计涉及到的知识点广泛且深入，它不仅是操作系统的一部分，也是软件开发的重要基石。...
程序设计入门—Python-week11
08-03
"程序设计入门—Python-week11"这个主题涵盖了多个基础概念，包括计算机的二进制系统、Python语言的特点，以及Python程序的编写和执行。下面将详细讨论这些知识点。 首先，我们来探讨计算机为什么使用二进制而非十...
程序设计思维与实践 Week9作业
Xu Pengbo
04-22 250
A - 咕咕东的目录管理器 Description 咕咕东的雪梨电脑的操作系统在上个月受到宇宙射线的影响，时不时发生故障，他受不了了，想要写一个高效易用零bug的操作系统 —— 这工程量太大了，所以他定了一个小目标，从实现一个目录管理器开始。前些日子，东东的电脑终于因为过度收到宇宙射线的影响而宕机，无法写代码。他的好友TT正忙着在B站看猫片，另一位好友瑞神正忙着打守望先锋。现在只有你能...
WEEK_9 复杂模拟题的普适性方法
Hdjjdsbjj的博客
04-20 265
B - 东东学打牌 题意： 最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则： 所有扑克牌只按数字来算大小，忽略花色。 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得...
Coursera Machine Learning 第二周 quiz Octave/Matlab Tutorial 习题答案
热门推荐
OovEver的专栏
11-09 3万+
1.Suppose I first execute the following Octave/Matlab commands: 12A = [1 2; 3 4; 5 6];B = [1 2 3; 4 5 6]; Which of the following are then valid commands? Check all that apply. (Hint: A' denotes th
程序设计思维与实践 Week9 作业 C 签到题
cax1165
04-16 244
题目描述： SDUQD 旁边的滨海公园有 x 条长凳。第 i 个长凳上坐着 a_i 个人。这时候又有 y 个人将来到公园，他们将选择坐在某些公园中的长凳上，那么当这 y 个人坐下后，记k = 所有椅子上的人数的最大值，那么k可能的最大值mx和最小值mn分别是多少。 input： 第一行包含一个整数 x (1 <= x <= 100) 表示公园中长椅的数目 第二行包含一个整数 y ...
东东学打牌
zhL816的博客
04-19 310
问题描述： 最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则： 所有扑克牌只按数字来算大小，忽略花色。 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得 5 张扑克牌，组成...
Week9 作业 B - 东东学打牌 模拟 Texas hold em Poker 计蒜客 - 41408 模拟
ziseon的博客
04-18 249
题面 最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则： 所有扑克牌只按数字来算大小，忽略花色。 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13。 每个玩家抽得...
程序设计之B - 东东学打牌（C++
ニャンコちゃん的博客
04-21 526
目录题目大致题意解题分析测试数据（全面代码 题目 题面 最近，东东沉迷于打牌。所以他找到 HRZ、ZJM 等人和他一起打牌。由于人数众多，东东稍微修改了亿下游戏规则： 所有扑克牌只按数字来算大小，忽略花色。 每张扑克牌的大小由一个值表示。A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K 分别指代 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12...
week9作业
playerz的博客
04-21 253
A B C 题意 x张椅子，各自有ai个人，现在又过来y个人。记k=所有椅子上人数的最大值，求k的最大值mx和最小值mn。 输入 3 7 1 6 1 输出 6 13 思路 mx： mx即为ai最大值加上y mn： mn的最小值为ai的最大值。在ai最大值的基础上，先将ai其它的值用y尽量填充到ai最大值。 若剩余的值为0，则mn为ai最大值； 若剩余值不为0，则将其平均分配至ai，取a...
单片机智能数字闹钟程序设计与代码解析
"辉虎的毕业设计--基于单片机的智能数字闹钟程序代码，包含主程序main.c，涉及单片机、LCD显示、蜂鸣器、铃声控制以及时间设置等功能。" 这个毕业设计项目是基于单片机实现的智能数字闹钟，通过编写程序代码来控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值