hdvsyu's blog

Posted on Edited on In

为了用事实说明挖掘机技术到底哪家强，PAT组织了一场挖掘机技能大赛。现请你根据比赛结果统计出技术最强的那个学校。

输入格式：

输入在第1行给出不超过105的正整数N，即参赛人数。随后N行，每行给出一位参赛者的信息和成绩，包括其所代表的学校的编号（从1开始连续编号）、及其比赛成绩（百分制），中间以空格分隔。

输出格式：

在一行中给出总得分最高的学校的编号、及其总分，中间以空格分隔。题目保证答案唯一，没有并列。

输入样例：

6
3 65
2 80
1 100
2 70
3 40
3 0

输出样例：

2 150

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>

using namespace std;

int main() {
    int n;
    cin >> n;
    int *scores = new int[n + 1];
    int maxIndex = 1;
    for (int i = 0; i < n; i++) {
        int index, value;
        cin >> index >> value;
        scores[index] += value;

        if (scores[maxIndex] < scores[index]) {
            maxIndex = index;
        }
    }

    cout << maxIndex << " " << scores[maxIndex];
}

Posted on Edited on In

小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。 为方便起见，我们用[0-9]、[a-z]、[A-Z]范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。

图 1

输入格式：

每个输入包含1个测试用例。每个测试用例分别在2行中先后给出摊主的珠串和小红想做的珠串，两串都不超过1000个珠子。

输出格式：

如果可以买，则在一行中输出“Yes”以及有多少多余的珠子；如果不可以买，则在一行中输出“No”以及缺了多少珠子。其间以1个空格分隔。

输入样例1：

ppRYYGrrYBR2258
YrR8RrY

输出样例1：

Yes 8

输入样例2：

ppRYYGrrYB225
YrR8RrY

输出样例2：

No 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        char[] sales = in.nextLine().toCharArray();
        char[] bought = in.nextLine().toCharArray();
        in.close();

        Arrays.sort(sales);
        Arrays.sort(bought);

        int debt = 0;
        for (int i = 0, j = 0; j < bought.length; ) {
            if (i != sales.length) {

                if (sales[i] == bought[j]) {
                    i++;
                    j++;
                } else if (sales[i] > bought[j]) {
                    j++;
                    debt++;
                } else {
                    // sales[i] < bought[j];
                    i++;

                    if (i == sales.length) {
                        debt += sales.length - i;
                    }
                }
            } else {
                debt += bought.length - j;
                break;
            }
        }

        if (debt == 0) {
            System.out.println("Yes " + (sales.length - bought.length));
        } else {
            System.out.println("No " + debt);
        }
    }
}

Posted on Edited on In

旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及坏掉的那些键，打出的结果文字会是怎样？

输入格式：

输入在2行中分别给出坏掉的那些键、以及应该输入的文字。其中对应英文字母的坏键以大写给出；每段文字是不超过105个字符的串。可用的字符包括字母[a-z, A-Z]、数字0-9、以及下划线“_”（代表空格）、“,”、“.”、“-”、“+”（代表上档键）。题目保证第2行输入的文字串非空。 注意：如果上档键坏掉了，那么大写的英文字母无法被打出。

输出格式：

在一行中输出能够被打出的结果文字。如果没有一个字符能被打出，则输出空行。

输入样例：

7+IE.
7_This_is_a_test.

输出样例：

_hs_s_a_tst

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
#include <string>
#include <set>
#include <cctype>

using namespace std;

int main() {
    string badKeyInput, testKey;

    getline(cin, badKeyInput);
    getline(cin, testKey);

    bool noShiftKey = true;
    set<char> s;
    for (int i = 0; i < badKeyInput.length(); i++) {
        char c = badKeyInput[i];
        if (c == '+') {
            noShiftKey = false;
        }
        s.insert(c);
        s.insert(tolower(c));
    }

    if (noShiftKey) {

        for (int i = 0; i < testKey.length(); i++) {
            char c = testKey[i];
            if (s.count(c) == 0) {
                cout << c;
            }
        }
    } else {

        for (int i = 0; i < testKey.length(); i++) {
            char c = testKey[i];
            if (!isupper(c)) {
                if (s.count(c) == 0) {
                    cout << c;
                }
            }
        }
    }

    return 0;
}

Posted on Edited on In

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。 注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有3种月饼，其库存量分别为18、15、10万吨，总售价分别为75、72、45亿元。如果市场的最大需求量只有20万吨，那么我们最大收益策略应该是卖出全部15万吨第2种月饼、以及5万吨第3种月饼，获得 72 + 45/2 = 94.5（亿元）。

输入格式：

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

输出格式：

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

输入样例：

3 20
18 15 10
75 72 45

输出样例：

94.50

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <iostream>
#include <algorithm>

using namespace std;

struct Mooncake {
    double memory;
    double sale;
    double price;
};

bool cmp(Mooncake a, Mooncake b) {
    return a.price > b.price;
}


int main() {
    int n = 0, d = 0;

    cin >> n >> d;

    Mooncake *mooncakes = new Mooncake[n];
    for (int i = 0; i < n; i++) {
        cin >> mooncakes[i].memory;
    }

    for (int i = 0; i < n; i++) {
        cin >> mooncakes[i].sale;
        mooncakes[i].price = mooncakes[i].sale / mooncakes[i].memory;
    }

    sort(mooncakes, mooncakes + n, cmp);


    double total = 0;
    for (int i = 0; i < n; i++) {
        if (d - mooncakes[i].memory >= 0) {
            total += mooncakes[i].sale;
            d -= mooncakes[i].memory;
        } else {
            total += mooncakes[i].price * d;
            break;
        }
    }

    printf("%.2f", total);
}

Posted on Edited on In

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

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

输入格式：

输入第1行给出正整数N（<=105），即双方交锋的次数。随后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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <iostream>

using namespace std;

int main() {
    int n;
    cin >> n;

    int *states = new int[3];
    int JB = 0, JC = 0, JJ = 0;
    int YB = 0, YC = 0, YJ = 0;
    for (int i = 0; i < n; i++) {
        char a, b;
        cin >> a >> b;
        if (a == 'B') {
            if (b == 'B') {
                states[1]++;
            } else if (b == 'C') {
                states[0]++;
                JB++;
            } else {
                states[2]++;
                YJ++;
            }
        } else if (a == 'C') {
            if (b == 'B') {
                states[2]++;
                YB++;
            } else if (b == 'C') {
                states[1]++;
            } else {
                states[0]++;
                JC++;
            }
        } else {
            // a == 'J'
            if (b == 'B') {
                states[0]++;
                JJ++;
            } else if (b == 'C') {
                states[2]++;
                YC++;
            } else {
                states[1]++;
            }
        }
    }

    cout << states[0] << " " << states[1] << " " << states[2] << endl;
    cout << states[2] << " " << states[1] << " " << states[0] << endl;

    int max = JB;
    char symbol = 'B';
    if (max < JC) {
        max = JC;
        symbol = 'C';
    }
    if (max < JJ) {
        symbol = 'J';
    }

    cout << symbol << " ";

    max = YB;
    symbol = 'B';
    if (max < YC) {
        symbol = 'C';
        max = YC;
    }
    if (max < YJ) {
        symbol = 'J';
    }
    cout << symbol;

    return 0;
}

Posted on Edited on In

本题要求将给定的N个正整数按非递增的顺序，填入“螺旋矩阵”。所谓“螺旋矩阵”，是指从左上角第1个格子开始，按顺时针螺旋方向填充。要求矩阵的规模为m行n列，满足条件：m*n等于N；m>=n；且m-n取所有可能值中的最小值。

输入格式：

输入在第1行中给出一个正整数N，第2行给出N个待填充的正整数。所有数字不超过104，相邻数字以空格分隔。

输出格式：

输出螺旋矩阵。每行n个数字，共m行。相邻数字以1个空格分隔，行末不得有多余空格。

输入样例：

12
37 76 20 98 76 42 53 95 60 81 58 93

输出样例：

98 95 93
42 37 81
53 20 76
58 60 76

首先需要确定m和n，根据题目已知的关于m和n的条件，可以通过程序计算出m和n的值，下面代码的setMAndN就是一个求解m和n的过程。在求解出m和n之后，就可以创建一个m行n列的矩阵了。函数fillMatrix以顺时针的方式，将已排序的数组填入到矩阵中。最后printMatrix打印出数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

int m = 1, n = 1, **matrix, *a;

void setMAndN(int N) {
    int min = 100001;
    // i is n
    for (int i = 1; i <= sqrt(N); i++) {
        if (N % i == 0) {
            // j is m
            int j = N / i;
            // m - n is the most small.
            if (min > j - i) {
                m = j;
                n = i;
                min = m - n;
            }
        }
    }
}

void setMatrix() {
    matrix = new int *[m];
    for (int i = 0; i < m; i++) {
        matrix[i] = new int[n];
    }
}

void fillMatrix(int N) {
    int index = N - 1;
    int i = 0, j = 0;
    while (index >= 0) {
        // right.
        for (; index >= 0 && j < n && matrix[i][j] == 0; j++) {
            matrix[i][j] = a[index--];
        }
        i++;
        j--;
        // down.
        for (; index >= 0 && i < m && matrix[i][j] == 0; i++) {
            matrix[i][j] = a[index--];
        }
        i--;
        j--;

        // left.
        for (; index >= 0 && j >= 0 && matrix[i][j] == 0; j--) {
            matrix[i][j] = a[index--];
        }
        i--;
        j++;

        // up.
        for (; index >= 0 && i >= 0 && matrix[i][j] == 0; i--) {
            matrix[i][j] = a[index--];
        }
        i++;
        j++;
    }
}

void printMatrix() {
    for (int i = 0; i < m; i++) {
        cout << matrix[i][0];
        for (int j = 1; j < n; j++) {
            cout << " " << matrix[i][j];
        }
        cout << endl;
    }
}

void release(int *a) {
    delete[] a;
    for (int i = 0; i < m; i++) {
        delete[] matrix[i];
    }
    delete[] matrix;
}

int main() {
    int N = 0;
    cin >> N;
    a = new int[N];
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }

    sort(a, a + N);

    setMAndN(N);

    setMatrix();
    fillMatrix(N);
    printMatrix();
    release(a);
    return 0;
}

Posted on Edited on In

本题要求编写程序，计算2个有理数的和、差、积、商。

输入格式：

输入在一行中按照“a1/b1 a2/b2”的格式给出两个分数形式的有理数，其中分子和分母全是整型范围内的整数，负号只可能出现在分子前，分母不为0。

输出格式：

分别在4行中按照“有理数1 运算符 有理数2 = 结果”的格式顺序输出2个有理数的和、差、积、商。注意输出的每个有理数必须是该有理数的最简形式“k a/b”，其中k是整数部分，a/b是最简分数部分；若为负数，则须加括号；若除法分母为0，则输出“Inf”。题目保证正确的输出中没有超过整型范围的整数。

输入样例1：

2/3 -4/2

输出样例1：

2/3 + (-2) = (-1 1/3)
2/3 - (-2) = 2 2/3
2/3 * (-2) = (-1 1/3)
2/3 / (-2) = (-1/3)

输入样例2：

5/3 0/6

输出样例2：

1 2/3 + 0 = 1 2/3
1 2/3 - 0 = 1 2/3
1 2/3 * 0 = 0
1 2/3 / 0 = Inf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import java.util.Scanner;

public class Main {

    public static void main(String[]args) {

        Scanner in = new Scanner(System.in);
        String[]input = in.nextLine().split("[\\s/]");
        in.close();
        long a1 = Integer.parseInt(input[0]);
        long b1 = Integer.parseInt(input[1]);
        long a2 = Integer.parseInt(input[2]);
        long b2 = Integer.parseInt(input[3]);

        if (b1 != 0 && b2 != 0) {
            add(a1, b1, a2, b2);
            minus(a1, b1, a2, b2);
            mutilply(a1, b1, a2, b2);
            divide(a1, b1, a2, b2);
        }
    }

    public static void tackle(long a, long b) {
        if (a == 0) {
            System.out.print(0);
            return;
        }

        boolean isMinus = a > 0 ? false : true;
        if (isMinus) {
            System.out.print("(-");
            a = -a;
        }

        long gcd = getGcd(a, b);
        a = a / gcd;
        b = b / gcd;
        if (a % b == 0) {
            System.out.print(a / b);
        } else if (Math.abs(a) > b) {
            System.out.print(a / b + " " + (a % b) % b + "/" + b);
        } else if (a == b) {
            System.out.print(1);
        } else {
            System.out.print(a + "/" + b);
        }

        if (isMinus) {
            System.out.print(")");
        }

    }

    public static void divide(long a1, long b1, long a2, long b2) {
        tackle(a1, b1);
        System.out.print(" / ");
        tackle(a2, b2);
        System.out.print(" = ");
        if (a2 == 0) {
            System.out.print("Inf");
        } else if (a2 < 0) {
            tackle(-1 * a1 * b2, -1 * a2 * b1);
        } else {
            tackle(a1 * b2, a2 * b1);
        }
    }

    public static void mutilply(long a1, long b1, long a2, long b2) {
        tackle(a1, b1);
        System.out.print(" * ");
        tackle(a2, b2);
        System.out.print(" = ");
        tackle(a1 * a2, b1 * b2);
        System.out.println();
    }

    public static void minus(long a1, long b1, long a2, long b2) {
        tackle(a1, b1);
        System.out.print(" - ");
        tackle(a2, b2);
        System.out.print(" = ");
        tackle(a1 * b2 - a2 * b1, b1 * b2);
        System.out.println();
    }

    public static void add(long a1, long b1, long a2, long b2) {
        tackle(a1, b1);
        System.out.print(" + ");
        tackle(a2, b2);
        System.out.print(" = ");
        tackle(a1 * b2 + a2 * b1, b1 * b2);
        System.out.println();
    }

    public static long getGcd(long a, long b) {
        while (a % b != 0) {
            long temp = a % b;
            a = b;
            b = temp;
        }
        return b;
    }
}

Posted on Edited on In

著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。 给定划分后的N个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？ 例如给定N = 5, 排列是1、3、2、4、5。则：  

  • 1的左边没有元素，右边的元素都比它大，所以它可能是主元；
  • 尽管3的左边元素都比它小，但是它右边的2它小，所以它不能是主元；
  • 尽管2的右边元素都比它大，但其左边的3比它大，所以它不能是主元；
  • 类似原因，4和5都可能是主元。因此，有3个元素可能是主元。

输入格式：

输入在第1行中给出一个正整数N（<= 105）； 第2行是空格分隔的N个不同的正整数，每个数不超过109。

输出格式：

在第1行中输出有可能是主元的元素个数；在第2行中按递增顺序输出这些元素，其间以1个空格分隔，行末不得有多余空格。

输入样例：

5
1 3 2 4 5

输出样例：

3
1 4 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdlib>

using namespace std;

int cmp(const void *a, const void *b) {
    int arg1 = *static_cast<const int *>(a);
    int arg2 = *static_cast<const int *>(b);

    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}

int main() {
    int n = 0;
    scanf("%d", &n);
    int *array = new int[n];
    int *sorted = new int[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &array[i]);
        sorted[i] = array[i];
    }

    qsort(sorted, n, sizeof(int), cmp);
    vector<int> v;
    int max = -1;
    for (int i = 0; i < n; i++) {
        if (array[i] > max) {
            max = array[i];
        }

        if (sorted[i] == array[i] && sorted[i] == max) {
            v.push_back(array[i]);
        }
    }

    cout << v.size() << endl;
    for (int i = 0; i < v.size(); i++) {
        if (i == 0) {
            cout << v[0];
        } else {
            cout << " " << v[i];

        }
    }
    cout << endl;
    return 0;
}

Posted on Edited on In

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

*****
***
​ *
***
*****

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。 给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入格式：

输入在一行给出1个正整数N（<=1000）和一个符号，中间以空格分隔。

输出格式：

首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样例：

19 *

输出样例：

*****
***
​ *
***
*****
2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

int main() {
    int n = 0;
    char c;
    cin >> n;
    cin >> c;

    int w = sqrt((n + 1) / 2);
    for (int i = 0; i < 2 * w - 1; i++) {
        for (int j = 0; j < 2 * w - 1; j++) {
            if ((i > j && i + j < 2 * w - 2) || (i < j && i + j > 2 * w - 2)) {
                if (i > j && i + j < 2 * w - 2)
                    cout << " ";
            } else {
                cout << c;
            }
        }
        cout << endl;
    }

    cout << n - 2 * w * w + 1 << endl;
    return 0;
}

Posted on Edited on In

在不打扰居民的前提下，统计住房空置率的一种方法是根据每户用电量的连续变化规律进行判断。判断方法如下：

  • 在观察期内，若存在超过一半的日子用电量低于某给定的阈值e，则该住房为“可能空置”；
  • 若观察期超过某给定阈值D天，且满足上一个条件，则该住房为“空置”。

现给定某居民区的住户用电量数据，请你统计“可能空置”的比率和“空置”比率，即以上两种状态的住房占居民区住房总套数的百分比。

输入格式：

输入第一行给出正整数N（<=1000），为居民区住房总套数；正实数e，即低电量阈值；正整数D，即观察期阈值。随后N行，每行按以下格式给出一套住房的用电量数据： K E1 E2 … EK 其中K为观察的天数，Ei为第i天的用电量。

输出格式：

在一行中输出“可能空置”的比率和“空置”比率的百分比值，其间以一个空格分隔，保留小数点后1位。

输入样例：

5 0.5 10
6 0.3 0.4 0.5 0.2 0.8 0.6
10 0.0 0.1 0.2 0.3 0.0 0.8 0.6 0.7 0.0 0.5
5 0.4 0.3 0.5 0.1 0.7
11 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1
11 2 2 2 1 1 0.1 1 0.1 0.1 0.1 0.1

输出样例：

40.0% 20.0%

（样例解释：第2、3户为“可能空置”，第4户为“空置”，其他户不是空置。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>

using namespace std;

int main() {
    int n = 0;
    double e = 0;
    int d = 0;
    int mustEmpty = 0;
    int maybeEmpty = 0;
    cin >> n >> e >> d;
    for (int i = 0; i < n; i++) {
        int k = 0;
        cin >> k;
        int cnt = 0;
        if (k > d) {
            for (int j = 0; j < k; j++) {
                double temp = 0;
                cin >> temp;
                if (temp < e) {
                    cnt++;
                }
            }

            if (cnt > k / 2) {
                mustEmpty++;
            }
        } else {
            for (int j = 0; j < k; j++) {
                double temp = 0;
                cin >> temp;
                if (temp < e) {
                    cnt++;
                }
            }

            if (cnt > k / 2) {
                maybeEmpty++;
            }
        }
    }

    printf("%.1f%% %.1f%%", maybeEmpty * 1.0 / n * 100, mustEmpty * 1.0 / n * 100);
    return 0;
}
0%