PAT[乙级]1016-1020

1016 部分A+B (15 分)

题目描述

$正整数A的“D_A（为1位整数）部分”定义为由A中所有D_A组成的新整数P_A。例如：给定A=3862767，D_A=6，则A的“6部分”P_A是66，因为A中有2个6。现给定A、D_A、B、D_B，请编写程序计算P_A+P_B。$
$输⼊格式$
$输⼊在⼀⾏中依次给出A、D_A、B、D_B，中间以空格分隔，其中0<A,B<10^{10}。$
$输出格式：$
$在⼀⾏中输出P_A+P_B的值$

输入样例 1：
3862767 6 13530293 3

输出样例 1：
399

输入样例 2：
3862767 1 13530293 8

输出样例 2：
0

代码

#include <iostream>
#include <cstring>

using namespace std;

int main() {
    string a,b;
    char da,db;
    cin >> a >> da >> b >> db;
    int k = 0 , j = 0;
    for(int i = 0 ; i < a.length() ; ++i)
        if(a[i] == da) ++k;//计算da的个数
    for(int i = 0 ; i < b.length() ; ++i)
        if(b[i] == db) ++j;//计算db的个数
    int pa = 0,pb = 0;
    //求pa,pb
    while(k--) pa = pa * 10 + da-'0';
    while(j--) pb = pb * 10 + db-'0';
    cout << pa + pb;
    return 0;
}

1017. A除以B (20) [大整数运算]

题目描述

本题要求计算 A/B，其中 A 是不超过 1000 位的正整数，B 是 1 位正整数。你需要输出商数 Q 和余数 R，使得 A=B×Q+R 成立。

输入格式：
输入在一行中依次给出 A 和 B，中间以 1 空格分隔。

输出格式：
在一行中依次输出 Q 和 R，中间以 1 空格分隔。

输入样例：
123456789050987654321 7

输出样例：
17636684150141093474 3

代码

#include <iostream>
using namespace std;

int main() {
    string a,q;
    int b,t = 0;
    cin >> a >> b;
    if(a.size() == 1)//考虑只有一位数的情况
        cout << (a[0]-'0') / b;
    for(auto i : a) {
        t = t % b * 10 + i-'0';
        q += t/b + '0';
    }
    q.erase(0,q.find_first_not_of("0"));//是从第一个数开始相除,可能会有前置0,需要去除
    for(auto x : q) cout << x;
    cout <<" "<< t%b <<endl;
    return 0;
}

$模拟⼿动除法的过程，每次⽤第⼀位去除以B，如果得到的商不是0就输出，否则就\ast 10+下⼀位，直到最后的数为余数$

1018. 锤⼦剪⼑布 (20) [模拟]

题目描述

大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。

输入格式：
输入第 1 行给出正整数 N（$\le 10^5$），即双方交锋的次数。随后 N 行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C 代表“锤子”、J 代表“剪刀”、B 代表“布”，第 1 个字母代表甲方，第 2 个代表乙方，中间有 1 个空格。

输出格式：
输出第 1、2 行分别给出甲、乙的胜、平、负次数，数字间以 1 个空格分隔。第 3 行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有 1 个空格。如果解不唯一，则输出按字母序最小的解。

输入样例：
10
C J
J B
C B
B B
B C
C C
C B
J B
B C
J J

输出样例：
5 3 2
2 3 5
B B

代码

#include <bits/stdc++.h>
using namespace std;
int j[4],jw[200],yw[200],n;//j[]为计数数组,jw[],yw[]为存储甲乙每次赢的手势
char f(int w[]) {//实现求次数最多的手势的功能
    int max = -1,l = 0;
    for(int i = 'B' ; i <= 'J' ; ++i)
		if(w[i])
			if(max < w[i]) {
				l = i;
				max = w[i];
			}
    return l;
}
int main() {
	cin >> n;
	for(int i = 0 ; i < n ; ++i) {
		char jia,yi;
		cin >> jia >> yi;
		if((jia=='C' && yi=='J') || (jia=='J' && yi=='B') || (jia=='B'&& yi=='C')) {
			j[0]++;//甲赢,乙输的次数
			jw[jia]++;//甲赢的手势
		}else if( jia == yi ) {
			j[1]++;//平的次数
		}else {
			j[2]++;//甲输,乙赢的次数
			yw[yi]++;//乙赢的手势
		}
	}
	printf("%d %d %d\n%d %d %d\n",j[0],j[1],j[2],j[2],j[1],j[0]);
	if     (j[0] == n) cout << f(jw) << " B";       //甲全获胜,乙输入B
	else if(j[1] == n) cout << "B B";               //甲乙平局,两者获胜次数为0,都输入B
    else if(j[2] == n) cout << "B " << f(yw);       //乙全获胜,甲输入B
    else               cout << f(jw) <<" "<< f(yw);
	return 0;
}

注意:

$需要考虑四种情况(①甲乙平局;②甲全获胜;③乙全获胜;④其他),这点非常容易遗漏$

1019 数字黑洞 (20 分)[数学问题]

题目描述

给定任一个各位数字不完全相同的 4 位正整数，如果我们先把 4 个数字按非递增排序，再按非递减排序，然后用第 1 个数字减第 2 个数字，将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的 6174，这个神奇的数字也叫 Kaprekar 常数。

例如，我们从6767开始，将得到

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
... ...

现给定任意 4 位正整数，请编写程序演示到达黑洞的过程。

输入格式：
输入给出一个 (0,$10^4$) 区间内的正整数 N。

输出格式：
如果 N 的 4 位数字全相等，则在一行内输出 N - N = 0000；否则将计算的每一步在一行内输出，直到 6174 作为差出现，输出格式见样例。注意每个数字按 4 位数格式输出。

输入样例 1：
6767

输出样例 1：
7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174

输入样例 2：
2222

输出样例 2：
2222 - 2222 = 0000

代码

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    string s;
    cin >> s;
    s.insert(0, 4 - s.length(), '0');
    if(s[0]==s[1] && s[0]==s[2] && s[0]==s[3]) {//四个数字全相等
		cout << s << " - " << s <<" = 0000";
    } else {
		while(1) {
	  		sort(s.begin(),s.end());//从小到大
			string s1 = s;//存储该字符串
			reverse(s.begin(),s.end());//从大到小
   			cout << s << " - " << s1 << " = ";
			s = to_string(stoi(s)-stoi(s1));//变成整数后相减再变成字符串,便于下一次循环
			s.insert(0, 4 - s.length(), '0');//添加前置0
			cout << s << endl;
		    if(s == "6174") break;
		}
	}
    return 0;
}

说明:

$字符串转为整型的时候如果前面有0会自动删掉0,但题目要求必须是4位数,所以转为字符串后需要手动加0$

1020. 月饼 (25) [贪⼼算法]

题目描述

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。

注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为 75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第 3 种月饼，获得 72 + 45/2 = 94.5（亿元）。

输入格式：
每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N 表示月饼的种类数、以及不超过 500（以万吨为单位）的正整数 D 表示市场最大需求量。随后一行给出 N 个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N 个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。

输出格式：
对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。

输入样例：
3 20
18 15 10
75 72 45

输出样例：
94.50

代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct mooncake {
    double mount , price , unit;
};
bool cmp(mooncake a , mooncake b) {
    return a.unit > b.unit ;
}
int main() {
    int n,d;
    cin >> n >> d;
    vector<mooncake> v(n);
    for(int i = 0 ; i < n ; ++i){
        cin >> v[i].mount;
    } //存储存量
    for(int i = 0 ; i < n ; ++i){
        cin >> v[i].price;
    } //存储总价
    for(int i = 0 ; i < n ; ++i){
        v[i].unit = v[i].price * 1.0 / v[i].mount;
    } //存储单价
    sort(v.begin() , v.end() , cmp);//从小到大排序
    double result = 0.0;
    for(int i = 0 ; i < n ; ++i) {
        if(v[i].mount <= d) {
            result += v[i].price;
        } else {
            result += v[i].unit * d;
            break;
        }
        d -= v[i].mount;
    }
    printf("%.2lf",result);
    return 0;
}

思路:

1. $这里采用“总是选择单价最高的月饼出售，可以获得最大的利润”的策略.$

   $因此，对每种月饼，都根据其库存量和总售价来计算出该种月饼的单价。$

2. $从单价高的月饼开始枚举。$
   $①需求量高于该种月饼仓库量，则卖出当前种类的所有月饼，然后需求量=原来需求量-当前月饼库存量，收益值增加为当前月饼的总售价大小。$
   $②当需求量小于月饼仓库量，则只提供需求量大小的月饼。$