hdvsyu's blog

Posted on Edited on In

某城镇进行人口普查，得到了全体居民的生日。现请你写个程序，找出镇上最年长和最年轻的人。 这里确保每个输入的日期都是合法的，但不一定是合理的——假设已知镇上没有超过200岁的老人，而今天是2014年9月6日，所以超过200岁的生日和未出生的生日都是不合理的，应该被过滤掉。

输入格式：

输入在第一行给出正整数N，取值在(0, 105]；随后N行，每行给出1个人的姓名（由不超过5个英文字母组成的字符串）、以及按“yyyy/mm/dd”（即年/月/日）格式给出的生日。题目保证最年长和最年轻的人没有并列。

输出格式：

在一行中顺序输出有效生日的个数、最年长人和最年轻人的姓名，其间以空格分隔。

输入样例：

5
John 2001/05/12
Tom 1814/09/06
Ann 2121/01/30
James 1814/09/05
Steve 1967/11/20

输出样例：

3 Tom John

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
#include <iostream>

using namespace std;

struct People {
    string name;
    int year;
    int month;
    int day;
};

bool isValid(struct People p) {
    if (p.year > 2014 || p.year < 1814) {
        return false;
    } else {
        if (p.year == 2014) {
            if (p.month < 9) {
                return true;
            } else if (p.month > 9) {
                return false;
            } else {
                if (p.day <= 6) {
                    return true;
                } else {
                    return false;
                }
            }
        } else if (p.year == 1814) {
            if (p.month > 9) {
                return true;
            } else if (p.month < 9) {
                return false;
            } else {
                if (p.day >= 6) {
                    return true;
                } else {
                    return false;
                }
            }
        } else {
            return true;
        }
    }
}

int compare(struct People man1, struct People man2) {
    if (man1.year < man2.year) {
        return 1;
    } else if (man1.year == man2.year) {
        if (man1.month < man2.month) {
            return 1;
        } else if (man1.month == man2.month) {
            if (man1.day < man2.day) {
                return 1;
            } else if (man1.day == man2.day) {
                return 0;
            } else {
                return -1;
            }
        } else {
            return -1;
        }
    } else {
        return -1;
    }
    return 0;
}

int main() {
    int n = 0;
    cin >> n;
    int valid = 0;
    struct People max, min;
    max.year = 2014;
    max.month = 9;
    max.day = 6;
    min.year = 1814;
    min.month = 9;
    min.day = 6;
    for (int i = 0; i < n; i++) {
        struct People p;
        cin >> p.name;
        scanf("%d/%d/%d", &p.year, &p.month, &p.day);

        if (isValid(p)) {
            max = compare(max, p) > 0 ? max : p;
            min = compare(p, min) > 0 ? min : p;
            valid++;
        }
    }

    if (valid != 0) {
        cout << valid << " " << max.name << " " << min.name << endl;
    } else {
        cout << 0;
    }
    return 0;
}

Posted on Edited on In

科学计数法是科学家用来表示很大或很小的数字的一种方便的方法，其满足正则表达式[+-][1-9]“.”[0-9]+E[+-][0-9]+，即数字的整数部分只有1位，小数部分至少有1位，该数字及其指数部分的正负号即使对正数也必定明确给出。 现以科学计数法的格式给出实数A，请编写程序按普通数字表示法输出A，并保证所有有效位都被保留。

输入格式：

每个输入包含1个测试用例，即一个以科学计数法表示的实数A。该数字的存储长度不超过9999字节，且其指数的绝对值不超过9999。

输出格式：

对每个测试用例，在一行中按普通数字表示法输出A，并保证所有有效位都被保留，包括末尾的0。

输入样例1：

+1.23400E-03

输出样例1：

0.00123400

输入样例2：

-1.2E+10

输出样例2：

-12000000000

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
#include <cstdio>
#include <iostream>
#include <cmath>

using namespace std;

string *parse(string in) {
    string *s = new string[3];

    int i = 0;
    while (in[i] != '.') {
        s[0] += in[i++];
    }
    i++;

    while (in[i] != 'E') {
        s[1] += in[i++];
    }
    i++;

    while (i < in.size()) {
        s[2] += in[i++];
    }
    return s;
}

int parseInt(string s) {
    int num = 0;
    for (int i = 1; i < s.size(); i++) {
        num = num * 10 + s[i] - '0';
    }

    if (s[0] == '-') {
        num = -num;
    }
    return num;
}

int main() {
    string in;
    cin >> in;
    string *sci = parse(in);

    int eff = parseInt(sci[0]);
    int pow = parseInt(sci[2]);
    if (pow >= 0) {
        printf("%d", eff);

        bool havePoint = true;
        if (sci[1].length() <= pow) {
            havePoint = false;
        }
        int i = 0;
        for (i = 0; i < sci[1].length() && pow != 0; i++, pow--) {
            putchar(sci[1][i]);
        }

        if (havePoint) {
            printf(".");
            for (; i < sci[1].length(); i++) {
                putchar(sci[1][i]);
            }
        }

        while (pow != 0) {
            printf("0");
            pow--;
        }

    } else {
        if (eff < 0) {
            printf("-");
            eff = -eff;
        }

        printf("0.");
        for (int i = 1; i < abs(pow); i++) {
            printf("0");
        }
        printf("%d", eff);
        cout << sci[1];
    }
    return 0;
}

Posted on Edited on In

萌萌哒表情符号通常由“手”、“眼”、“口”三个主要部分组成。简单起见，我们假设一个表情符号是按下列格式输出的：

[左手]([左眼][口][右眼])[右手]

现给出可选用的符号集合，请你按用户的要求输出表情。

输入格式：

输入首先在前三行顺序对应给出手、眼、口的可选符号集。每个符号括在一对方括号[]内。题目保证每个集合都至少有一个符号，并不超过10个符号；每个符号包含1到4个非空字符。 之后一行给出一个正整数K，为用户请求的个数。随后K行，每行给出一个用户的符号选择，顺序为左手、左眼、口、右眼、右手——这里只给出符号在相应集合中的序号（从1开始），数字间以空格分隔。

输出格式：

个用户请求，在一行中输出生成的表情。若用户选择的序号不存在，则输出“Are you kidding me? @\/@”。

输入样例：

[╮][╭][o][\][/] [<][>]
[╯][╰][^][-][=][>][<][@][⊙]
[Д][▽][_][ε][^] …
4
1 1 2 2 2
6 8 1 5 5
3 3 4 3 3
2 10 3 9 3

输出样例：

╮(╯▽╰)╭
<(@Д=)/~
o(^ε^)o
Are you kidding me? @/@

用一个parse函数，将括号里面的从前都提取出来，存放到一个vector中，然后根据输入就可以直接输出了，关键是parse函数，我是通过找到第一个’[‘然后开始，到’]‘结束，每次都这么找，就能找到所有的表情了

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
#include <vector>
#include <iostream>

using namespace std;

vector<string> parse(string s) {
    bool isStart = false;
    vector<string> v;
    string temp = "";
    v.push_back(temp);
    for (int i = 0; i < s.length(); i++) {
        if (s[i] == '[') {
            isStart = true;
        } else if (s[i] == ']') {
            isStart = false;
            v.push_back(temp);
            temp = "";
        } else {
            if (isStart) {
                temp += s[i];
            }
        }
    }
    return v;
}


int main() {
    string temp;
    getline(cin, temp);
    vector<string> hand = parse(temp);
    getline(cin, temp);
    vector<string> eye = parse(temp);
    getline(cin, temp);
    vector<string> mouth = parse(temp);

    int k = 0;
    cin >> k;
    for (int i = 0; i < k; i++) {
        int num[5];
        cin >> num[0] >> num[1] >> num[2] >> num[3] >> num[4];

        if (num[0] >= hand.size() || num[0] < 1 || num[4] >= hand.size() ||
            num[4] < 1 || num[1] >= eye.size() || num[1] < 1 || num[3] >= eye.size() ||
            num[3] < 1 ||
            num[2] >= mouth.size() || num[2] < 1) {
            printf("Are you kidding me? @\\/@\n");
            continue;
        }

        cout << hand[num[0]] + "(" + eye[num[1]] + mouth[num[2]] +
                eye[num[3]] + ")" + hand[num[4]] << endl;
    }

    return 0;
}

Posted on Edited on In

宋代史学家司马光在《资治通鉴》中有一段著名的“德才论”：“是故才德全尽谓之圣人，才德兼亡谓之愚人，德胜才谓之君子，才胜德谓之小人。凡取人之术，苟不得圣人，君子而与之，与其得小人，不若得愚人。” 现给出一批考生的德才分数，请根据司马光的理论给出录取排名。

输入格式：

输入第1行给出3个正整数，分别为：N（<=105），即考生总数；L（>=60），为录取最低分数线，即德分和才分均不低于L的考生才有资格被考虑录取；H（<100），为优先录取线——德分和才分均不低于此线的被定义为“才德全尽”，此类考生按德才总分从高到低排序；才分不到但德分到线的一类考生属于“德胜才”，也按总分排序，但排在第一类考生之后；德才分均低于H，但是德分不低于才分的考生属于“才德兼亡”但尚有“德胜才”者，按总分排序，但排在第二类考生之后；其他达到最低线L的考生也按总分排序，但排在第三类考生之后。 随后N行，每行给出一位考生的信息，包括：准考证号、德分、才分，其中准考证号为8位整数，德才分为区间[0, 100]内的整数。数字间以空格分隔。

输出格式：

输出第1行首先给出达到最低分数线的考生人数M，随后M行，每行按照输入格式输出一位考生的信息，考生按输入中说明的规则从高到低排序。当某类考生中有多人总分相同时，按其德分降序排列；若德分也并列，则按准考证号的升序输出。

输入样例：

14 60 80
10000001 64 90
10000002 90 60
10000011 85 80
10000003 85 80
10000004 80 85
10000005 82 77
10000006 83 76
10000007 90 78
10000008 75 79
10000009 59 90
10000010 88 45
10000012 80 100
10000013 90 99
10000014 66 60

输出样例：

12
10000013 90 99
10000012 80 100
10000003 85 80
10000011 85 80
10000004 80 85
10000007 90 78
10000006 83 76
10000005 82 77
10000002 90 60
10000014 66 60
10000008 75 79
10000001 64 90

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
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;

struct Stu {
    string id;
    int de;
    int cai;
};

bool cmp(struct Stu s1, struct Stu s2) {
    if ((s1.de + s1.cai) > (s2.de + s2.cai)) {
        return true;
    } else if ((s1.de + s1.cai) == (s2.de + s2.cai)) {
        if (s1.de > s2.de) {
            return true;
        } else if (s1.de == s2.de) {
            return s1.id < s2.id;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

int main() {
    int n = 0, l = 0, h = 0;
    cin >> n >> l >> h;
    vector<struct Stu> v1, v2, v3, v4;
    for (int i = 0; i < n; i++) {
        struct Stu temp;
        cin >> temp.id;
        scanf("%d %d", &temp.de, &temp.cai);

        if (temp.de >= l && temp.cai >= l) {
            if (temp.de >= h && temp.cai >= h) {
                v1.push_back(temp);
            } else if (temp.de >= h) {
                v2.push_back(temp);
            } else if (temp.de < h && temp.cai < h && temp.de >= temp.cai) {
                v3.push_back(temp);
            } else {
                v4.push_back(temp);
            }
        }
    }

    cout << (v1.size() + v2.size() + v3.size() + v4.size()) << endl;

    sort(v1.begin(), v1.end(), cmp);
    for (int i = 0; i < v1.size(); i++) {
        cout << v1[i].id << " ";
        printf("%d %d\n", v1[i].de, v1[i].cai);
    }
    sort(v2.begin(), v2.end(), cmp);
    for (int i = 0; i < v2.size(); i++) {
        cout << v2[i].id << " ";
        printf("%d %d\n", v2[i].de, v2[i].cai);
    }
    sort(v3.begin(), v3.end(), cmp);
    for (int i = 0; i < v3.size(); i++) {
        cout << v3[i].id << " ";
        printf("%d %d\n", v3[i].de, v3[i].cai);
    }
    sort(v4.begin(), v4.end(), cmp);
    for (int i = 0; i < v4.size(); i++) {
        cout << v4[i].id << " ";
        printf("%d %d\n", v4[i].de, v4[i].cai);
    }
    return 0;
}

Posted on Edited on In

字符串APPAPT中包含了两个单词“PAT”，其中第一个PAT是第2位(P),第4位(A),第6位(T)；第二个PAT是第3位(P),第4位(A),第6位(T)。 现给定字符串，问一共可以形成多少个PAT？

输入格式：

输入只有一行，包含一个字符串，长度不超过105，只包含P、A、T三种字母。

输出格式：

在一行中输出给定字符串中包含多少个PAT。由于结果可能比较大，只输出对1000000007取余数的结果。

输入样例：

APPAPT

输出样例：

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
45
46
47
48
49
50
51
52
53
54
55
56
#include <iostream>
#include <string>

using namespace std;

int main() {
    string s;
    cin >> s;

    long *p = new long[s.length()];
    long *t = new long[s.length()];
    for (int i = 0; i < s.length(); i++) {
        int j = s.length() - 1 - i;

        if (s[i] == 'P') {
            if (i == 0) {
                p[i] = 1;
            } else {
                p[i] = p[i - 1] + 1;
            }
        } else {
            if (i == 0) {
                p[i] = 0;
            } else {
                p[i] = p[i - 1];
            }
        }

        if (s[j] == 'T') {

            if (j == s.length() - 1) {
                t[j] = 1;
            } else {
                t[j] = t[j + 1] + 1;
            }
        } else {
            if (j == s.length() - 1) {
                t[j] = 0;
            } else {
                t[j] = t[j + 1];
            }
        }
    }

    long long total = 0;
    for (int i = 1; i < s.length() - 1; i++) {
        if (s[i] == 'A') {
            total = (total + (p[i] * t[i]) % 1000000007) % 1000000007;
        }
    }

    cout << total << endl;
    delete[] p;
    delete[] t;
    return 0;
}

Posted on Edited on In

给定一个常数K以及一个单链表L，请编写程序将L中每K个结点反转。例如：给定L为1→2→3→4→5→6，K为3，则输出应该为3→2→1→6→5→4；如果K为4，则输出应该为4→3→2→1→5→6，即最后不到K个元素不反转。

输入格式：

每个输入包含1个测试用例。每个测试用例第1行给出第1个结点的地址、结点总个数正整数N(<= 105)、以及正整数K(<=N)，即要求反转的子链结点的个数。结点的地址是5位非负整数，NULL地址用-1表示。 接下来有N行，每行格式为： Address Data Next 其中Address是结点地址，Data是该结点保存的整数数据，Next是下一结点的地址。

输出格式：

对每个测试用例，顺序输出反转后的链表，其上每个结点占一行，格式与输入相同。

输入样例：

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

输出样例：

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

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
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <algorithm>

using namespace std;

struct Node {
    int address;
    int data;
    int next;
};

vector<struct Node> v(100000);
vector<struct Node> a;

void link(int firstAddress) {
    while (firstAddress != -1) {
        a.push_back(v[firstAddress]);
        firstAddress = v[firstAddress].next;
    }
}

void rev(int k) {
    for (int i = 0; i + k <= a.size(); i += k) {
        reverse(a.begin() + i, a.begin() + i + k);
    }
}

int main() {
    int firstAddress = 0, n = 0, k = 0;
    scanf("%d %d %d", &firstAddress, &n, &k);

    for (int i = 0; i < n; i++) {
        struct Node temp;
        scanf("%d %d %d", &temp.address, &temp.data, &temp.next);
        v[temp.address] = temp;
    }

    link(firstAddress);
    rev(k);

    for (int i = 0; i < a.size() - 1; i++) {
        printf("%05d %d %05d\n", a[i].address, a[i].data, a[i + 1].address);
    }
    int end = a.size() - 1;
    printf("%05d %d -1", a[end].address, a[end].data);
    return 0;
}

Posted on Edited on In

给定一个正整数数列，和正整数p，设这个数列中的最大值是M，最小值是m，如果M <= m * p，则称这个数列是完美数列。 现在给定参数p和一些正整数，请你从中选择尽可能多的数构成一个完美数列。

输入格式：

输入第一行给出两个正整数N和p，其中N（<= 105）是输入的正整数的个数，p（<= 109）是给定的参数。第二行给出N个正整数，每个数不超过109。

输出格式：

在一行中输出最多可以选择多少个数可以用它们组成一个完美数列。 #### 输入样例：

10 8
2 3 20 4 5 1 6 7 8 9

输出样例：

8

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
#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int n = 0, p = 0;
    cin >> n >> p;
    long long a[100001];
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    if (n == 0 || p < 0) {
        cout << n;
        return 0;
    }

    sort(a, a + n);

    long cnt = 1;
    for (int i = n - 1; i >= 1; i--) {
        int temp = 1;
        long long M = a[i];
        for (int j = i - cnt; j >= 0 && M * 1.0 / a[j] <= p; j--) {
            temp = i - j + 1;
        }
        cnt = cnt > temp ? cnt : temp;
    }

    cout << cnt;
    return 0;
}

Posted on Edited on In

给定数字0-9各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意0不能做首位）。例如：给定两个0，两个1，三个5，一个8，我们得到的最小的数就是10015558。 现给定数字，请编写程序输出能够组成的最小的数。

输入格式：

每个输入包含1个测试用例。每个测试用例在一行中给出10个非负整数，顺序表示我们拥有数字0、数字1、……数字9的个数。整数间用一个空格分隔。10个数字的总个数不超过50，且至少拥有1个非0的数字。

输出格式：

在一行中输出能够组成的最小的数。

输入样例：

2 2 0 0 0 3 0 0 1 0

输出样例：

10015558

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
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] times = new int[10];
        for (int i = 0; i < 10; i++) {
            times[i] = in.nextInt();
        }
        in.close();

        StringBuilder s = new StringBuilder();
        for (int i = 1; i < 10; i++) {
            if (times[i] != 0) {
                s.append(i);
                times[i]--;
                break;
            }
        }

        for (int j = 0; j < 10; j++) {
            while (times[j] != 0) {
                s.append(j);
                times[j]--;
            }
        }

        System.out.println(s);

    }
}

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
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        char c = in.next().charAt(0);
        in.close();

        int w = (int) Math.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)
                        System.out.print(" ");
                } else {
                    System.out.print(c);
                }
            }

            System.out.println();
        }

        System.out.println(n - 2 * w * w + 1);
    }
}

Posted on Edited on In

本题要求读入N名学生的成绩，将获得某一给定分数的学生人数输出。

输入格式：

输入在第1行给出不超过105的正整数N，即学生总人数。随后1行给出N名学生的百分制整数成绩，中间以空格分隔。最后1行给出要查询的分数个数K（不超过N的正整数），随后是K个分数，中间以空格分隔。

输出格式：

在一行中按查询顺序给出得分等于指定分数的学生人数，中间以空格分隔，但行末不得有多余空格。

输入样例：

10
60 75 90 55 75 99 82 90 75 50
3 75 90 88

输出样例：

3 2 0

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>

using namespace std;

int main() {
    int *score = new int[101];
    int n = 0;
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        int temp = 0;
        cin >> temp;
        score[temp]++;
    }
    int k = 0;
    cin >> k;
    for (int i = 0; i < k - 1; i++) {
        int temp = 0;
        cin >> temp;
        cout << score[temp] << " ";
    }
    int temp = 0;
    cin >> temp;
    cout << score[temp];

    delete[] score;

}
0%